@adecore/agents 0.41.1 → 0.43.0

package/dist/usage/history-file.js

@@ -0,0 +1,72 @@
+import { UsageProviderSchema } from '@adecore/agent-contracts';
+import { foldByKey } from './record.js';
+import { CURRENT_ROW, decodeRows, RowWriter } from './rows.js';
+const HISTORY_VERSION = 1;
+const NEWLINE = 0x0a;
+export function encodeHeader(header) {
+    return `${JSON.stringify({ v: HISTORY_VERSION, gen: header.gen, base: header.base })}\n`;
+}
+export function encodeEntry(entry) {
+    const writer = new RowWriter();
+    const rows = entry.usage.records.map((record) => writer.row(record));
+    const tail = entry.usage.tail.map((record) => writer.row(record));
+    const { models, sessions, folders, accounts } = writer.tables;
+    const line = { p: entry.path, k: entry.usage.provider, op: entry.op, m: models, s: sessions, f: folders, a: accounts, r: rows, t: tail };
+    return `${JSON.stringify(line)}\n`;
+}
+function parseLine(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function decodeHeader(text) {
+    const header = parseLine(text);
+    if (header?.v !== HISTORY_VERSION || typeof header.gen !== 'string' || typeof header.base !== 'number') {
+        return null;
+    }
+    return { gen: header.gen, base: header.base };
+}
+function decodeEntry(text) {
+    const line = parseLine(text);
+    if (typeof line?.p !== 'string' || (line.op !== 'set' && line.op !== 'add') || !UsageProviderSchema.safeParse(line.k).success) {
+        return null;
+    }
+    const provider = line.k;
+    const tables = { models: line.m, sessions: line.s, folders: line.f, accounts: line.a };
+    const records = decodeRows(line.r, tables, provider, CURRENT_ROW);
+    const tail = decodeRows(line.t, tables, provider, CURRENT_ROW);
+    if (records === null || tail === null) {
+        return null;
+    }
+    return { path: line.p, op: line.op, usage: { provider, records, tail } };
+}
+/* Folds one line into what every path counted. */
+export function applyEntry(usage, entry) {
+    const known = usage.get(entry.path);
+    if (entry.op === 'set' || known === undefined || known.provider !== entry.usage.provider) {
+        usage.set(entry.path, entry.usage);
+        return;
+    }
+    usage.set(entry.path, { provider: known.provider, records: foldByKey([...known.records, ...entry.usage.records]), tail: entry.usage.tail });
+}
+/*
+ * Every line stands alone, so a line that does not read back costs only that line. Only the end can
+ * be half-written, since lines are only ever appended.
+ */
+export function decodeHistory(bytes) {
+    const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const complete = buffer.lastIndexOf(NEWLINE) + 1;
+    const lines = buffer.toString('utf8', 0, complete).split('\n');
+    const usage = new Map();
+    const header = complete === 0 ? null : decodeHeader(lines[0]);
+    for (let i = header === null ? 0 : 1; i < lines.length; i++) {
+        const entry = lines[i] === '' ? null : decodeEntry(lines[i]);
+        if (entry !== null) {
+            applyEntry(usage, entry);
+        }
+    }
+    return { header, usage, complete };
+}

package/dist/usage/index-file.d.ts

@@ -15,4 +15,4 @@ export interface IndexedFile {
 }
 export type UsageIndex = Map<string, IndexedFile>;
 export declare function encodeIndex(index: UsageIndex): string;
-export declare function decodeIndex(text: string): UsageIndex;
+export declare function decodeIndex(text: string): UsageIndex | null;

package/dist/usage/index-file.js

@@ -1,52 +1,15 @@
 import { UsageProviderSchema } from '@adecore/agent-contracts';
-/* Old records survive deleted transcripts; the scanner reparses existing Codex files with its current reader. */
+import { CURRENT_ROW, decodeRows, RowWriter } from './rows.js';
+/*
+ * The single index usage was kept in before history and scan state went apart. The store reads it
+ * once to migrate it; nothing writes it any more but the tests that need one to migrate.
+ */
 const INDEX_VERSION = 3;
 /* Before accounts: every record was the default account's, so it reads as that without a scan. */
 const ACCOUNTLESS_VERSION = 1;
-class Interner {
-    values = [];
-    at = new Map();
-    index(value) {
-        const seen = this.at.get(value);
-        if (seen !== undefined) {
-            return seen;
-        }
-        const next = this.values.length;
-        this.values.push(value);
-        this.at.set(value, next);
-        return next;
-    }
-}
 export function encodeIndex(index) {
-    const models = new Interner();
-    const sessions = new Interner();
-    const folders = new Interner();
-    const accounts = new Interner();
+    const writer = new RowWriter();
     const files = {};
-    const row = (record) => {
-        const counted = [
-            record.timestampMs,
-            models.index(record.model),
-            sessions.index(record.sessionId),
-            folders.index(record.cwd),
-            record.totals.calls,
-            record.totals.input,
-            record.totals.cacheRead,
-            record.totals.cacheWrite,
-            record.totals.cacheWrite1h,
-            record.totals.output,
-            record.totals.reasoning,
-            record.dedupeKey ?? 0,
-            record.account === undefined ? 0 : accounts.index(record.account) + 1
-        ];
-        if (record.costUsd !== undefined || record.serviceTier !== undefined) {
-            counted[13] = record.costUsd;
-        }
-        if (record.serviceTier !== undefined) {
-            counted[14] = record.serviceTier;
-        }
-        return counted;
-    };
     for (const [path, file] of index) {
         files[path] = {
             p: file.provider,
@@ -54,107 +17,63 @@ export function encodeIndex(index) {
             m: file.mtimeMs,
             o: file.offset,
             c: file.codex,
-            r: file.records.map(row),
-            t: file.tail.map(row),
+            r: file.records.map((record) => writer.row(record)),
+            t: file.tail.map((record) => writer.row(record)),
             ...(file.head === null ? {} : { h: file.head }),
             ...(file.parserVersion === undefined ? {} : { v: file.parserVersion }),
             ...(file.compressed === undefined ? {} : { z: file.compressed })
         };
     }
-    const document = {
-        version: INDEX_VERSION,
-        models: models.values,
-        sessions: sessions.values,
-        folders: folders.values,
-        accounts: accounts.values,
-        files
-    };
+    const document = { version: INDEX_VERSION, ...writer.tables, files };
     return JSON.stringify(document);
 }
-function isRow(row, version) {
-    return (Array.isArray(row) &&
-        (version === ACCOUNTLESS_VERSION ? row.length === 12 : row.length >= 13 && row.length <= (version === INDEX_VERSION ? 15 : 14)) &&
-        row.slice(0, 11).every((value) => typeof value === 'number') &&
-        (typeof row[11] === 'string' || row[11] === 0) &&
-        (version === ACCOUNTLESS_VERSION || typeof row[12] === 'number') &&
-        (row.length < 14 || row[13] === null || row[13] === undefined || typeof row[13] === 'number') &&
-        (row.length < 15 || typeof row[14] === 'string'));
-}
 /*
- * A row that does not read back costs a cold parse of the file it belonged to, never a wrong total,
- * so anything unexpected drops that file's entry rather than being repaired.
+ * Null for text that is no index of a version this reads. A file whose rows do not read back is left
+ * out, so only that file's usage is missing from what migrates, never a wrong total.
  */
 export function decodeIndex(text) {
-    const index = new Map();
     let document;
     try {
         document = JSON.parse(text);
     }
     catch {
-        return index;
+        return null;
     }
     const version = document?.version;
     if ((version !== INDEX_VERSION && version !== 2 && version !== ACCOUNTLESS_VERSION) ||
         !Array.isArray(document.models) ||
         !Array.isArray(document.sessions) ||
         !Array.isArray(document.folders)) {
-        return index;
+        return null;
     }
-    const accounts = Array.isArray(document.accounts) ? document.accounts : [];
-    const name = (table, at) => (typeof table[at] === 'string' ? table[at] : null);
+    const index = new Map();
+    const tables = { ...document, accounts: Array.isArray(document.accounts) ? document.accounts : [] };
+    const shape = { accountless: version === ACCOUNTLESS_VERSION, maxLength: version === INDEX_VERSION ? CURRENT_ROW.maxLength : 14 };
     for (const [path, file] of Object.entries(document.files ?? {})) {
         // Every provider the schema knows, so a new one is never dropped from the index it was saved in.
         if (!UsageProviderSchema.safeParse(file.p).success) {
             continue;
         }
-        if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0 || !Array.isArray(file.r)) {
+        if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0) {
             continue;
         }
-        let broken = false;
-        const decode = (rows) => {
-            const records = [];
-            for (const row of rows) {
-                const valid = isRow(row, version);
-                const model = valid ? name(document.models, row[1]) : null;
-                const sessionId = valid ? name(document.sessions, row[2]) : null;
-                const cwd = valid ? name(document.folders, row[3]) : null;
-                const accountAt = valid ? (row[12] ?? 0) : 0;
-                const account = accountAt === 0 ? undefined : name(accounts, accountAt - 1);
-                if (!valid || model === null || sessionId === null || cwd === null || account === null) {
-                    broken = true;
-                    return records;
-                }
-                records.push({
-                    provider: file.p,
-                    timestampMs: row[0],
-                    model,
-                    sessionId,
-                    cwd,
-                    ...(account === undefined ? {} : { account }),
-                    totals: { calls: row[4], input: row[5], cacheRead: row[6], cacheWrite: row[7], cacheWrite1h: row[8], output: row[9], reasoning: row[10] },
-                    ...(typeof row[13] === 'number' ? { costUsd: row[13] } : {}),
-                    ...(typeof row[14] === 'string' ? { serviceTier: row[14] } : {}),
-                    dedupeKey: row[11] === 0 ? null : row[11]
-                });
-            }
-            return records;
-        };
-        const records = decode(file.r);
-        const tail = decode(Array.isArray(file.t) ? file.t : []);
-        if (!broken) {
-            index.set(path, {
-                provider: file.p,
-                size: file.s,
-                mtimeMs: file.m,
-                offset: file.o,
-                records,
-                tail,
-                codex: file.c ?? null,
-                head: typeof file.h === 'string' ? file.h : null,
-                ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
-                ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
-            });
+        const records = decodeRows(file.r, tables, file.p, shape);
+        const tail = decodeRows(Array.isArray(file.t) ? file.t : [], tables, file.p, shape);
+        if (records === null || tail === null) {
+            continue;
         }
+        index.set(path, {
+            provider: file.p,
+            size: file.s,
+            mtimeMs: file.m,
+            offset: file.o,
+            records,
+            tail,
+            codex: file.c ?? null,
+            head: typeof file.h === 'string' ? file.h : null,
+            ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
+            ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
+        });
     }
     return index;
 }

package/dist/usage/rows.d.ts

@@ -0,0 +1,23 @@
+import type { UsageProvider } from '@adecore/agent-contracts';
+import type { UsageRecord } from './record.ts';
+export type RecordRow = [number, number, number, number, number, number, number, number, number, number, number, string | 0, number?, number?, string?];
+export interface RowTables {
+    models: string[];
+    sessions: string[];
+    folders: string[];
+    accounts: string[];
+}
+export declare class RowWriter {
+    private readonly models;
+    private readonly sessions;
+    private readonly folders;
+    private readonly accounts;
+    get tables(): RowTables;
+    row(record: UsageRecord): RecordRow;
+}
+export interface RowShape {
+    accountless: boolean;
+    maxLength: number;
+}
+export declare const CURRENT_ROW: RowShape;
+export declare function decodeRows(rows: unknown, tables: Partial<Record<keyof RowTables, unknown>>, provider: UsageProvider, shape: RowShape): UsageRecord[] | null;

package/dist/usage/rows.js

@@ -0,0 +1,94 @@
+class Interner {
+    values = [];
+    at = new Map();
+    index(value) {
+        const seen = this.at.get(value);
+        if (seen !== undefined) {
+            return seen;
+        }
+        const next = this.values.length;
+        this.values.push(value);
+        this.at.set(value, next);
+        return next;
+    }
+}
+/* Turns records into rows, collecting the names they share into one set of tables. */
+export class RowWriter {
+    models = new Interner();
+    sessions = new Interner();
+    folders = new Interner();
+    accounts = new Interner();
+    get tables() {
+        return { models: this.models.values, sessions: this.sessions.values, folders: this.folders.values, accounts: this.accounts.values };
+    }
+    row(record) {
+        const counted = [
+            record.timestampMs,
+            this.models.index(record.model),
+            this.sessions.index(record.sessionId),
+            this.folders.index(record.cwd),
+            record.totals.calls,
+            record.totals.input,
+            record.totals.cacheRead,
+            record.totals.cacheWrite,
+            record.totals.cacheWrite1h,
+            record.totals.output,
+            record.totals.reasoning,
+            record.dedupeKey ?? 0,
+            record.account === undefined ? 0 : this.accounts.index(record.account) + 1
+        ];
+        if (record.costUsd !== undefined || record.serviceTier !== undefined) {
+            counted[13] = record.costUsd;
+        }
+        if (record.serviceTier !== undefined) {
+            counted[14] = record.serviceTier;
+        }
+        return counted;
+    }
+}
+export const CURRENT_ROW = { accountless: false, maxLength: 15 };
+function isRow(row, shape) {
+    return (Array.isArray(row) &&
+        (shape.accountless ? row.length === 12 : row.length >= 13 && row.length <= shape.maxLength) &&
+        row.slice(0, 11).every((value) => typeof value === 'number') &&
+        (typeof row[11] === 'string' || row[11] === 0) &&
+        (shape.accountless || typeof row[12] === 'number') &&
+        (row.length < 14 || row[13] === null || row[13] === undefined || typeof row[13] === 'number') &&
+        (row.length < 15 || typeof row[14] === 'string'));
+}
+function nameAt(table, at) {
+    return Array.isArray(table) && typeof table[at] === 'string' ? table[at] : null;
+}
+/* The records of `rows`, or null when any row does not read back against its tables. */
+export function decodeRows(rows, tables, provider, shape) {
+    if (!Array.isArray(rows)) {
+        return null;
+    }
+    const records = [];
+    for (const row of rows) {
+        if (!isRow(row, shape)) {
+            return null;
+        }
+        const model = nameAt(tables.models, row[1]);
+        const sessionId = nameAt(tables.sessions, row[2]);
+        const cwd = nameAt(tables.folders, row[3]);
+        const accountAt = row[12] ?? 0;
+        const account = accountAt === 0 ? undefined : nameAt(tables.accounts, accountAt - 1);
+        if (model === null || sessionId === null || cwd === null || account === null) {
+            return null;
+        }
+        records.push({
+            provider,
+            timestampMs: row[0],
+            model,
+            sessionId,
+            cwd,
+            ...(account === undefined ? {} : { account }),
+            totals: { calls: row[4], input: row[5], cacheRead: row[6], cacheWrite: row[7], cacheWrite1h: row[8], output: row[9], reasoning: row[10] },
+            ...(typeof row[13] === 'number' ? { costUsd: row[13] } : {}),
+            ...(typeof row[14] === 'string' ? { serviceTier: row[14] } : {}),
+            dedupeKey: row[11] === 0 ? null : row[11]
+        });
+    }
+    return records;
+}

package/dist/usage/scan-state.d.ts

@@ -0,0 +1,21 @@
+import { type UsageProvider } from '@adecore/agent-contracts';
+import type { CodexParserState } from './readers/codex.ts';
+export interface ScanState {
+    provider: UsageProvider;
+    size: number;
+    mtimeMs: number;
+    offset: number;
+    codex: CodexParserState | null;
+    head: string | null;
+    parserVersion?: number;
+    compressed?: boolean;
+}
+export interface HistoryMark {
+    gen: string;
+    bytes: number;
+}
+export declare function encodeState(state: ReadonlyMap<string, ScanState>, history: HistoryMark): string;
+export declare function decodeState(text: string): {
+    history: HistoryMark;
+    files: Map<string, ScanState>;
+} | null;

package/dist/usage/scan-state.js

@@ -0,0 +1,53 @@
+import { UsageProviderSchema } from '@adecore/agent-contracts';
+const STATE_VERSION = 1;
+export function encodeState(state, history) {
+    const files = {};
+    for (const [path, file] of state) {
+        files[path] = {
+            p: file.provider,
+            s: file.size,
+            m: file.mtimeMs,
+            o: file.offset,
+            c: file.codex,
+            ...(file.head === null ? {} : { h: file.head }),
+            ...(file.parserVersion === undefined ? {} : { v: file.parserVersion }),
+            ...(file.compressed === undefined ? {} : { z: file.compressed })
+        };
+    }
+    const document = { version: STATE_VERSION, history, files };
+    return JSON.stringify(document);
+}
+/* Null for text that is no state of this version; an entry that does not read only costs a read of its transcript. */
+export function decodeState(text) {
+    let document;
+    try {
+        document = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const history = document?.history;
+    if (document?.version !== STATE_VERSION || typeof history?.gen !== 'string' || typeof history.bytes !== 'number') {
+        return null;
+    }
+    const files = new Map();
+    for (const [path, file] of Object.entries(document.files ?? {})) {
+        if (!UsageProviderSchema.safeParse(file.p).success) {
+            continue;
+        }
+        if (typeof file.s !== 'number' || typeof file.m !== 'number' || typeof file.o !== 'number' || file.o < 0) {
+            continue;
+        }
+        files.set(path, {
+            provider: file.p,
+            size: file.s,
+            mtimeMs: file.m,
+            offset: file.o,
+            codex: file.c ?? null,
+            head: typeof file.h === 'string' ? file.h : null,
+            ...(typeof file.v === 'number' ? { parserVersion: file.v } : {}),
+            ...(typeof file.z === 'boolean' ? { compressed: file.z } : {})
+        });
+    }
+    return { history: { gen: history.gen, bytes: history.bytes }, files };
+}

package/dist/usage/scanner.d.ts

@@ -20,14 +20,11 @@ export interface UsageScannerOptions {
 type AccountOf = (record: UsageRecord) => string | undefined;
 export declare function accountResolver(root: UsageRootPath, sessionAccounts: () => ReadonlyMap<string, string>): AccountOf;
 export declare class UsageScanner {
-    private readonly home;
     private readonly roots;
     private readonly sessionAccounts;
-    private index;
+    private readonly store;
     private loaded;
-    private dirty;
     constructor(home: string, roots?: UsageRootPath[] | (() => UsageRootPath[]), options?: UsageScannerOptions);
-    private get file();
     load(): Promise<void>;
     scan(): Promise<ScanReport>;
     records(): UsageRecord[];

package/dist/usage/scanner.js

@@ -1,17 +1,17 @@
 import { createHash } from 'node:crypto';
-import { mkdir, open, readFile, readdir, stat } from 'node:fs/promises';
+import { open, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Readable } from 'node:stream';
 import { createZstdDecompress } from 'node:zlib';
 import { errorText } from '../error-text.js';
-import { isNotFound, writeAtomic } from '../fs.js';
-import { decodeIndex, encodeIndex } from './index-file.js';
+import { isNotFound } from '../fs.js';
 import { foldByKey } from './record.js';
 import { claudeMightCarryUsage, parseClaudeLine } from './readers/claude.js';
 import { GROK_USAGE_FILE, parseGrokUsage } from './readers/grok.js';
 import { hostLogMightCarryUsage, parseHostUsageLine } from './readers/host-log.js';
 import { cloneCodexState, codexMightCarryUsage, createCodexState, parseCodexLine } from './readers/codex.js';
 import { usageRoots } from './roots.js';
+import { UsageStore } from './usage-store.js';
 const HASH_CHUNK_BYTES = 65536;
 // How much of a transcript is read at once. Codex writes sessions of more than a gigabyte, which read whole held several times their size.
 const READ_CHUNK_BYTES = 1 << 20;
@@ -77,6 +77,10 @@ function readsWhole(provider) {
 function isUsageFile(provider, name) {
     return readsWhole(provider) ? name === GROK_USAGE_FILE : name.endsWith('.jsonl') || (provider === 'codex' && name.endsWith('.jsonl.zst'));
 }
+/* A compressed Codex session is the same transcript as the plain one it was, so both count under one path. */
+function keyOf(path, provider) {
+    return provider === 'codex' && path.endsWith('.jsonl.zst') ? path.slice(0, -4) : path;
+}
 async function listUsageFiles(dir, provider, out = []) {
     let entries;
     try {
@@ -186,42 +190,33 @@ function withAccount(records, accountOf) {
 }
 /*
  * Parses only what a transcript appended since the last scan, and starts a file over once it was
- * rewritten or cut. A deleted transcript keeps its totals, since its usage still happened.
+ * rewritten or cut. A deleted transcript keeps its totals, since its usage still happened; only
+ * where the scan left it is forgotten.
  */
 export class UsageScanner {
-    home;
     roots;
     sessionAccounts;
-    index = new Map();
+    store;
     loaded = false;
-    dirty = false;
     /* `roots` as a function is asked again on every scan, so an account added since is walked too. */
     constructor(home, roots = usageRoots(), options = {}) {
-        this.home = home;
+        this.store = new UsageStore(join(home, 'usage'));
         this.roots = typeof roots === 'function' ? roots : () => roots;
         this.sessionAccounts = options.sessionAccounts ?? (() => new Map());
     }
-    get file() {
-        return join(this.home, 'usage', 'index.json');
-    }
+    /* A history that does not read fails the scan rather than being written over, which would lose what only it holds. */
     async load() {
         if (this.loaded) {
             return;
         }
+        await this.store.load();
         this.loaded = true;
-        try {
-            this.index = decodeIndex(await readFile(this.file, 'utf8'));
-        }
-        catch (e) {
-            if (!isNotFound(e)) {
-                console.warn('The usage index would not read; starting from a cold scan:', errorText(e));
-            }
-        }
     }
     async scan() {
         const started = Date.now();
         await this.load();
         const roots = [];
+        const seen = new Set();
         let files = 0;
         let changedFiles = 0;
         let sessions = null;
@@ -256,6 +251,7 @@ export class UsageScanner {
                     continue;
                 }
                 files += 1;
+                seen.add(keyOf(path, root.provider));
                 try {
                     if (await this.readFileInto(path, root.provider, accountOf)) {
                         changedFiles += 1;
@@ -268,26 +264,24 @@ export class UsageScanner {
             }
             roots.push({ provider: root.provider, path: root.path, status: failure === null ? 'ok' : 'failed', message: failure });
         }
-        if (this.dirty) {
-            this.dirty = false;
-            await mkdir(join(this.home, 'usage'), { recursive: true, mode: 0o700 });
-            await writeAtomic(this.file, encodeIndex(this.index));
+        // A root that is gone for now costs a read from the start once it is back, which replaces and never adds.
+        for (const path of [...this.store.state.keys()]) {
+            if (!seen.has(path)) {
+                this.store.forget(path);
+            }
         }
+        await this.store.commit();
         return { at: Date.now(), files, changedFiles, durationMs: Date.now() - started, roots };
     }
-    /* Every record the index holds, with the copies one message left in several transcripts folded. */
+    /* Every record the history holds, with the copies one message left in several transcripts folded. */
     records() {
-        const all = [];
-        for (const file of this.index.values()) {
-            all.push(...file.records, ...file.tail);
-        }
-        return foldByKey(all);
+        return this.store.records();
     }
     async readFileInto(path, provider, accountOf) {
         const info = await stat(path);
         const compressed = provider === 'codex' && path.endsWith('.jsonl.zst');
-        const key = compressed ? path.slice(0, -4) : path;
-        const known = this.index.get(key);
+        const key = keyOf(path, provider);
+        const known = this.store.state.get(key);
         const currentParser = provider !== 'codex' || known?.parserVersion === CODEX_PARSER_VERSION;
         if (currentParser &&
             known !== undefined &&
@@ -313,25 +307,27 @@ export class UsageScanner {
         const hash = grown === null || prefix === null ? createHash('sha256') : prefix;
         const from = grown?.offset ?? 0;
         const parsed = await parseLines(readBytes(path, from, compressed), hash, provider, from, grown?.codex ?? null);
-        const before = grown?.records ?? [];
-        const entry = {
+        const usage = { provider, records: withAccount(parsed.records, accountOf), tail: withAccount(parsed.tail, accountOf) };
+        const state = {
             provider,
             size: info.size,
             mtimeMs: info.mtimeMs,
             offset: parsed.offset,
-            // Folding here keeps the streaming copies of one message out of the index entirely.
-            records: foldByKey([...before, ...withAccount(parsed.records, accountOf)]),
-            tail: withAccount(parsed.tail, accountOf),
             codex: parsed.codex,
             head: headOf(hash),
             ...(provider === 'codex' ? { parserVersion: CODEX_PARSER_VERSION, compressed } : {})
         };
-        this.index.set(key, entry);
-        this.dirty = true;
+        if (grown === null) {
+            // Folding here keeps the streaming copies of one message out of the history entirely.
+            this.store.replace(key, { ...usage, records: foldByKey(usage.records) }, state);
+        }
+        else {
+            this.store.append(key, usage, state);
+        }
         return true;
     }
     /*
-     * A file rewritten as a whole replaces what the index held of it, so a turn it still lists is never
+     * A file rewritten as a whole replaces what the history held of it, so a turn it still lists is never
      * counted twice. One that does not parse, such as one caught halfway through a write, keeps the
      * records it had and is read again on the next scan.
      */
@@ -340,17 +336,8 @@ export class UsageScanner {
         if (records === null) {
             return false;
         }
-        this.index.set(path, {
-            provider,
-            size: info.size,
-            mtimeMs: info.mtimeMs,
-            offset: info.size,
-            records: foldByKey(withAccount(records, accountOf)),
-            tail: [],
-            codex: null,
-            head: null
-        });
-        this.dirty = true;
+        const state = { provider, size: info.size, mtimeMs: info.mtimeMs, offset: info.size, codex: null, head: null };
+        this.store.replace(path, { provider, records: foldByKey(withAccount(records, accountOf)), tail: [] }, state);
         return true;
     }
 }