hacklab 0.22.2 → 26.921.1

package/dist/scanners/incremental.js

@@ -1,788 +0,0 @@
-import { mkdir, open, readFile, stat, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { addPromptToActivity, countWords, emptyPromptActivity, IDE_PROMPT_SOURCES, mergePromptActivities, parsePromptLine, } from '../prompt-stats.js';
-import { getSessionPath } from '../session.js';
-import { antigravityTokenFiles, scanAntigravity } from './antigravity.js';
-import { githubCopilotTokenFiles, scanGitHubCopilot } from './github-copilot.js';
-import { claudeCodeFiles, codexDateForFile, codexFiles, codexFileTotals, dateDaysAgo, grokLogFiles, hermesDbPath, openclawFiles, opencodeDbPath, PROMPT_ACTIVITY_DATE_CAP, PROMPT_ACTIVITY_SESSION_CAP, parseClaudeCodeLine, parseGrokLine, parseOpenclawLine, scanHermes, scanOpenCode, toDateStr, } from './index.js';
-// The incremental half of the scanners: what `hacklab sync --tick` runs every
-// minute instead of the full stateless re-scan the daily job does.
-//
-// The idea is a tail-follow. Everything the last scan already accounted for is
-// kept in scan-state.json — per-file read offsets plus the aggregates those
-// bytes produced — so a tick only has to stat the log tree and parse the bytes
-// that were appended since. Lines are parsed by the exact same functions the
-// full scanners use (parseClaudeCodeLine / parseOpenclawLine / codexFileTotals),
-// so the tail can be added to aggregates the full scan produced without drift.
-//
-// Anything that makes the tail-follow unsound (a file shrank, or one we were
-// following disappeared) drops that harness back to a full re-read, because we
-// don't track which file contributed which tokens. And the daily `sync --quiet`
-// rebuilds the whole state from its full scan, so drift can never last a day.
-/**
- * Bumping this makes `loadScanState` return null, which re-reads every log
- * from scratch and re-derives the aggregates.
- *
- * 3: the prompt scanner learned to skip harness-written `user` entries
- * (PROMPT_SCANNER_VERSION 2). The server is wiping the prompt tables once that
- * ships, and `replacePromptActivity` only re-sends sessions and dates whose
- * numbers *moved* — so a day that happened to contain no harness noise would
- * stay identical locally and never be re-uploaded after the wipe. A cold
- * rebuild marks every session and date within local retention dirty exactly
- * once, and they all go back out.
- *
- * 4: the same wipe, for the machines 3 couldn't save. The wipe landed
- * 2026-09-10, and a machine that had already upgraded to 0.21.0 did its one
- * cold rebuild *before* that — it re-uploaded everything, cleared every dirty
- * flag, and then watched the server delete the lot. Nothing on that machine
- * moves afterwards, so `replacePromptActivity` re-sends nothing and the history
- * is simply gone. This bump is the one-shot rescue: another cold rebuild, after
- * the wipe this time. For anyone still on an older CLI it costs one extra
- * rescan and nothing else.
- *
- * 5: prompt activity is partitioned by source, so rebuilding a Claude log or
- * rotating an IDE transcript cannot erase or double-count another harness.
- *
- * Token totals are unaffected: they travel as cumulative absolutes that the
- * server diffs against its own per-machine snapshot, and `state.uploaded` is
- * only the tick's "nothing moved" short-circuit — so a rebuild re-baselines
- * rather than double-counting.
- */
-export const SCAN_STATE_VERSION = 5;
-/** How long a session is kept in the state after its last prompt. */
-export const PROMPT_SESSION_RETENTION_DAYS = 45;
-/** How long a per-day prompt tally is kept. Matches the wire's date cap. */
-export const PROMPT_DAILY_RETENTION_DAYS = PROMPT_ACTIVITY_DATE_CAP;
-/** Lives next to the session file, so it honors HACKLAB_SESSION_PATH. */
-export function scanStatePath() {
-    return join(dirname(getSessionPath()), 'scan-state.json');
-}
-export function emptyHarness() {
-    return { files: {}, daily: {}, models: {} };
-}
-export function emptyPromptState() {
-    return { ...emptyPromptActivity(), dirtySessions: [], dirtyDates: [] };
-}
-export function emptyState() {
-    return {
-        version: SCAN_STATE_VERSION,
-        harnesses: {},
-        dirty: [],
-        prompts: emptyPromptState(),
-        promptSources: {},
-        promptFiles: {},
-        uploaded: { toolTotals: {}, modelTotals: {} },
-    };
-}
-function harness(state, tool) {
-    const existing = state.harnesses[tool];
-    if (existing)
-        return existing;
-    const fresh = emptyHarness();
-    state.harnesses[tool] = fresh;
-    return fresh;
-}
-/**
- * The saved state, or null when there isn't a usable one — missing, corrupt, or
- * written by an older layout. Null means "re-read everything from scratch";
- * callers must treat that rebuild as a baseline, not as new tokens.
- */
-export async function loadScanState() {
-    try {
-        const parsed = JSON.parse(await readFile(scanStatePath(), 'utf8'));
-        if (parsed?.version !== SCAN_STATE_VERSION)
-            return null;
-        if (!parsed.harnesses || typeof parsed.harnesses !== 'object')
-            return null;
-        parsed.dirty ??= [];
-        parsed.prompts ??= emptyPromptState();
-        parsed.uploaded ??= { toolTotals: {}, modelTotals: {} };
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Drop prompt rows that have aged out, dirty or not.
- *
- * Dropping a dirty row means it is never uploaded, which is the right trade at
- * this age: a session or a day that has sat unsent for its whole retention
- * window is not coming back, and the alternative is a dirty list that grows
- * forever on a machine that never consented (the tick still counts prompts at
- * the `none` tier — it just never sends them).
- */
-function prunePromptAggregate(prompts) {
-    const sessionCutoff = dateDaysAgo(PROMPT_SESSION_RETENTION_DAYS);
-    for (const [id, session] of Object.entries(prompts.sessions)) {
-        if (session.lastActiveAt.slice(0, 10) < sessionCutoff) {
-            delete prompts.sessions[id];
-        }
-    }
-    const dateCutoff = dateDaysAgo(PROMPT_DAILY_RETENTION_DAYS);
-    for (const date of Object.keys(prompts.daily)) {
-        if (date < dateCutoff)
-            delete prompts.daily[date];
-    }
-}
-function prunePrompts(prompts) {
-    prunePromptAggregate(prompts);
-    prompts.dirtySessions = prompts.dirtySessions.filter((id) => prompts.sessions[id] !== undefined);
-    prompts.dirtyDates = prompts.dirtyDates.filter((date) => prompts.daily[date] !== undefined);
-}
-/** Persist the state, pruning prompt rows that aged out of their retention
- * window (they'd otherwise accumulate forever). Best-effort. */
-export async function saveScanState(state) {
-    prunePrompts(state.prompts);
-    for (const source of Object.values(state.promptSources)) {
-        prunePromptAggregate(source);
-    }
-    try {
-        await mkdir(dirname(scanStatePath()), { recursive: true });
-        await writeFile(scanStatePath(), `${JSON.stringify(state)}\n`, 'utf8');
-    }
-    catch {
-        // a state we can't persist just means the next tick re-reads everything
-    }
-}
-// ---- aggregate bookkeeping -------------------------------------------------
-function addDaily(h, date, model, tokens, messages, dirty) {
-    const key = `${date}|${model}`;
-    const existing = h.daily[key];
-    if (existing) {
-        existing.tokens += tokens;
-        existing.messages += messages;
-    }
-    else {
-        h.daily[key] = { tokens, messages };
-    }
-    if (model)
-        h.models[model] = (h.models[model] ?? 0) + tokens;
-    dirty.add(date);
-}
-/** A full scanner's result as the maps the state stores. */
-export function aggregatesOfResult(result) {
-    const daily = {};
-    for (const entry of result.daily) {
-        daily[`${entry.date}|${entry.model ?? ''}`] = {
-            tokens: entry.tokens,
-            messages: entry.messages ?? 0,
-        };
-    }
-    return { daily, models: { ...result.models } };
-}
-function aggregatesOf(h) {
-    return { daily: structuredClone(h.daily), models: { ...h.models } };
-}
-/**
- * Mark every date whose rows moved between two versions of a harness's
- * aggregates. Used whenever a harness is re-read rather than tailed (a SQLite
- * requery, or a JSONL harness whose tail-follow was invalidated): most dates
- * come back identical, so diffing keeps the upload down to what actually
- * changed instead of re-sending the user's whole history.
- */
-function markMovedDates(before, after, dirty) {
-    const compare = (a, b) => {
-        for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
-            const x = a[key];
-            const y = b[key];
-            if (!x || !y || x.tokens !== y.tokens || x.messages !== y.messages) {
-                dirty.add(key.split('|')[0] ?? '');
-            }
-        }
-    };
-    compare(before.daily, after.daily);
-}
-/** Swap in freshly scanned aggregates, dirtying the dates that moved. */
-function replaceAggregates(h, next, dirty) {
-    markMovedDates({ daily: h.daily, models: h.models }, next, dirty);
-    h.daily = next.daily;
-    h.models = next.models;
-}
-/**
- * Swap in a freshly scanned prompt aggregate, dirtying every session and date
- * whose numbers moved. Same idea as `markMovedDates`: a daily full scan mostly
- * reproduces what the ticks already sent, and only the difference is worth
- * putting back on the wire.
- */
-function replacePromptActivity(prompts, next) {
-    const dirtySessions = new Set(prompts.dirtySessions);
-    for (const id of new Set([
-        ...Object.keys(prompts.sessions),
-        ...Object.keys(next.sessions),
-    ])) {
-        const before = prompts.sessions[id];
-        const after = next.sessions[id];
-        if (!after)
-            continue;
-        if (!before ||
-            before.promptCount !== after.promptCount ||
-            before.startedAt !== after.startedAt ||
-            before.lastActiveAt !== after.lastActiveAt) {
-            dirtySessions.add(id);
-        }
-    }
-    const dirtyDates = new Set(prompts.dirtyDates);
-    for (const date of new Set([
-        ...Object.keys(prompts.daily),
-        ...Object.keys(next.daily),
-    ])) {
-        const before = prompts.daily[date];
-        const after = next.daily[date];
-        if (!after)
-            continue;
-        if (!before ||
-            before.prompts !== after.prompts ||
-            before.words !== after.words) {
-            dirtyDates.add(date);
-        }
-    }
-    prompts.sessions = next.sessions;
-    prompts.daily = next.daily;
-    // A session or date the full scan can no longer see has nothing left to say.
-    prompts.dirtySessions = [...dirtySessions].filter((id) => next.sessions[id] !== undefined);
-    prompts.dirtyDates = [...dirtyDates]
-        .filter((date) => next.daily[date] !== undefined)
-        .sort();
-}
-// ---- reading the tail ------------------------------------------------------
-async function statOrNull(path) {
-    try {
-        return await stat(path);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Read `[from, to)` and hand back only whole lines. A harness may be mid-append
- * when we look, so the trailing partial line is left for the next tick — that's
- * what the returned offset points at.
- */
-export async function readCompleteLines(path, from, to) {
-    if (to <= from)
-        return { text: '', offset: from };
-    const handle = await open(path, 'r');
-    try {
-        const buf = Buffer.alloc(to - from);
-        const { bytesRead } = await handle.read(buf, 0, buf.length, from);
-        const chunk = buf.subarray(0, bytesRead);
-        // Byte-wise, not string-wise: the chunk can end mid-codepoint.
-        const lastNewline = chunk.lastIndexOf(0x0a);
-        if (lastNewline < 0)
-            return { text: '', offset: from };
-        return {
-            text: chunk.subarray(0, lastNewline).toString('utf8'),
-            offset: from + lastNewline + 1,
-        };
-    }
-    finally {
-        await handle.close();
-    }
-}
-/** The real harnesses. Injectable so the tick can be tested against a tmp dir. */
-export function defaultSources() {
-    return {
-        jsonl: [
-            {
-                tool: 'claude_code',
-                files: claudeCodeFiles,
-                parse: parseClaudeCodeLine,
-                parsePrompt: parsePromptLine,
-            },
-            { tool: 'openclaw', files: openclawFiles, parse: parseOpenclawLine },
-            { tool: 'grok', files: grokLogFiles, parse: parseGrokLine },
-        ],
-        codex: { files: codexFiles, dateFor: codexDateForFile },
-        sqlite: [
-            { tool: 'hermes', dbPath: hermesDbPath, scan: scanHermes },
-            { tool: 'opencode', dbPath: opencodeDbPath, scan: scanOpenCode },
-        ],
-        prompts: IDE_PROMPT_SOURCES,
-        snapshots: [
-            {
-                tool: 'github_copilot',
-                files: githubCopilotTokenFiles,
-                scan: scanGitHubCopilot,
-            },
-            {
-                tool: 'antigravity',
-                files: antigravityTokenFiles,
-                scan: scanAntigravity,
-            },
-        ],
-    };
-}
-async function statFiles(paths) {
-    const out = [];
-    for (const path of paths) {
-        const s = await statOrNull(path);
-        if (s)
-            out.push({ path, size: s.size, mtimeMs: s.mtimeMs, mtime: s.mtime });
-    }
-    return out;
-}
-/**
- * Can we still trust this harness's aggregates? Not if a file we were following
- * lost bytes or vanished: we know what those files contributed in total but not
- * per file, so there's nothing to subtract and the only repair is a re-read.
- */
-function tailInvalidated(h, files) {
-    const present = new Map(files.map((f) => [f.path, f]));
-    for (const [path, state] of Object.entries(h.files)) {
-        const now = present.get(path);
-        if (!now || now.size < state.offset)
-            return true;
-    }
-    return false;
-}
-function resetHarness(h) {
-    h.files = {};
-    if (h.codexTotals)
-        h.codexTotals = {};
-    h.daily = {};
-    h.models = {};
-}
-async function tickJsonl(state, src, dirty) {
-    const h = harness(state, src.tool);
-    const files = await statFiles(await src.files());
-    const invalidated = tailInvalidated(h, files);
-    // On a re-read, collect into a throwaway set and diff at the end: most of the
-    // rebuilt aggregate is identical to what we had, and only the difference is
-    // worth re-uploading.
-    const before = invalidated ? aggregatesOf(h) : null;
-    const target = invalidated ? new Set() : dirty;
-    if (invalidated)
-        resetHarness(h);
-    // Keep each source independent: a rewritten Claude transcript must not
-    // discard Copilot/Antigravity activity on the same date.
-    if (src.parsePrompt && (invalidated || !state.promptSources[src.tool])) {
-        state.promptSources[src.tool] = emptyPromptActivity();
-    }
-    const prompts = state.promptSources[src.tool];
-    let changed = invalidated;
-    for (const file of files) {
-        const prev = h.files[file.path];
-        if (prev && prev.size === file.size && prev.mtimeMs === file.mtimeMs) {
-            continue;
-        }
-        const from = prev?.offset ?? 0;
-        const { text, offset } = await readCompleteLines(file.path, from, file.size).catch(() => ({ text: '', offset: from }));
-        let fallbackDate = null;
-        for (const line of text.split('\n')) {
-            const prompt = src.parsePrompt?.(line);
-            if (prompt && prompts) {
-                addPromptToActivity(prompts, prompt);
-            }
-            const usage = src.parse(line);
-            if (!usage)
-                continue;
-            let date = usage.date;
-            if (!date) {
-                fallbackDate ??= toDateStr(file.mtime);
-                date = fallbackDate;
-            }
-            addDaily(h, date, usage.model, usage.tokens, 1, target);
-        }
-        h.files[file.path] = { size: file.size, mtimeMs: file.mtimeMs, offset };
-        changed = true;
-    }
-    if (before)
-        markMovedDates(before, aggregatesOf(h), dirty);
-    if (src.parsePrompt && changed) {
-        replacePromptActivity(state.prompts, mergePromptActivities(Object.values(state.promptSources)));
-    }
-    return changed;
-}
-async function tickCodex(state, src, dirty) {
-    const h = harness(state, 'codex');
-    h.codexTotals ??= {};
-    const files = await statFiles(await src.files());
-    const invalidated = tailInvalidated(h, files);
-    const before = invalidated ? aggregatesOf(h) : null;
-    const target = invalidated ? new Set() : dirty;
-    if (invalidated) {
-        resetHarness(h);
-        h.codexTotals = {};
-    }
-    let changed = invalidated;
-    for (const file of files) {
-        const prev = h.files[file.path];
-        if (prev && prev.size === file.size && prev.mtimeMs === file.mtimeMs) {
-            continue;
-        }
-        const from = prev?.offset ?? 0;
-        const { text, offset } = await readCompleteLines(file.path, from, file.size).catch(() => ({ text: '', offset: from }));
-        const { maxTotal, model } = codexFileTotals(text);
-        const stored = h.codexTotals[file.path];
-        const date = stored?.date ?? src.dateFor(file.path) ?? toDateStr(file.mtime);
-        const storedMax = stored?.maxTotal ?? 0;
-        const nextMax = Math.max(storedMax, maxTotal);
-        // A session that switches model mid-file leaves the earlier tokens under the
-        // old model — the full scan credits them all to the last model seen. The
-        // daily repair pass reconciles that.
-        const nextModel = model || stored?.model || '';
-        if (nextMax > storedMax) {
-            // Running totals: only the growth is new. `messages` counts the session
-            // once, the way the full scan does (one addDaily per file).
-            addDaily(h, date, nextModel, nextMax - storedMax, storedMax === 0 ? 1 : 0, target);
-        }
-        h.codexTotals[file.path] = { maxTotal: nextMax, model: nextModel, date };
-        h.files[file.path] = { size: file.size, mtimeMs: file.mtimeMs, offset };
-        changed = true;
-    }
-    if (before)
-        markMovedDates(before, aggregatesOf(h), dirty);
-    return changed;
-}
-/**
- * SQLite-backed harnesses can't be tailed — a write lands anywhere in the file —
- * but their DBs are small, so the incremental strategy is to fingerprint the db
- * and its -wal and re-run the harness's normal query only when one moved.
- */
-async function tickSqlite(state, src, dirty) {
-    const h = harness(state, src.tool);
-    const path = src.dbPath();
-    const db = await statOrNull(path);
-    const wal = await statOrNull(`${path}-wal`);
-    const dbMtimeMs = db?.mtimeMs ?? 0;
-    const walMtimeMs = wal?.mtimeMs ?? 0;
-    if (h.dbMtimeMs === dbMtimeMs && h.walMtimeMs === walMtimeMs)
-        return false;
-    replaceAggregates(h, aggregatesOfResult(await src.scan()), dirty);
-    h.dbMtimeMs = dbMtimeMs;
-    h.walMtimeMs = walMtimeMs;
-    return true;
-}
-/** Cumulative session records need replacement, never additive tail parsing. */
-async function tickSnapshot(state, source, dirty) {
-    const files = await statFiles(await source.files());
-    const h = harness(state, source.tool);
-    if (Object.keys(h.files).length === files.length &&
-        files.every((file) => h.files[file.path]?.size === file.size &&
-            h.files[file.path]?.mtimeMs === file.mtimeMs))
-        return false;
-    replaceAggregates(h, aggregatesOfResult(await source.scan()), dirty);
-    h.files = Object.fromEntries(files.map((file) => [
-        file.path,
-        { size: file.size, mtimeMs: file.mtimeMs, offset: 0 },
-    ]));
-    return true;
-}
-async function tickPromptSnapshot(state, source) {
-    const files = await statFiles(await source.files());
-    const previous = state.promptFiles[source.id];
-    if (previous &&
-        Object.keys(previous).length === files.length &&
-        files.every((file) => previous[file.path]?.size === file.size &&
-            previous[file.path]?.mtimeMs === file.mtimeMs))
-        return false;
-    const activity = emptyPromptActivity();
-    for (const prompt of await source.scan()) {
-        if (!prompt.timestamp)
-            continue;
-        const words = countWords(prompt.text);
-        if (words > 0) {
-            addPromptToActivity(activity, {
-                sessionId: prompt.sessionId,
-                timestamp: prompt.timestamp,
-                words,
-            });
-        }
-    }
-    state.promptSources[source.id] = activity;
-    state.promptFiles[source.id] = Object.fromEntries(files.map((file) => [
-        file.path,
-        { size: file.size, mtimeMs: file.mtimeMs, offset: 0 },
-    ]));
-    replacePromptActivity(state.prompts, mergePromptActivities(Object.values(state.promptSources)));
-    return true;
-}
-/**
- * One incremental pass over every harness. `prev` is the saved state, or null
- * for a cold start — in which case this reads everything and marks no *token*
- * date dirty: those tokens are already on the server (the daily job put them
- * there), and re-uploading every date would only invite the reconcile to prune
- * rows this scan can't see (Cursor's, above all).
- *
- * Prompt rows go the other way on a cold start: everything found is marked
- * dirty. They're idempotent GREATEST upserts, so a resend costs nothing, and a
- * cold start (fresh install, or a state file this version can't read) is
- * exactly the case where we have no evidence any of it ever reached the server.
- */
-export async function runTick(prev, sources = defaultSources(), options = {}) {
-    const cold = prev === null;
-    const state = prev ?? emptyState();
-    const dirty = new Set(state.dirty);
-    let changed = cold;
-    for (const src of sources.jsonl) {
-        if (await tickJsonl(state, src, dirty))
-            changed = true;
-    }
-    if (await tickCodex(state, sources.codex, dirty))
-        changed = true;
-    for (const src of sources.sqlite) {
-        if (await tickSqlite(state, src, dirty))
-            changed = true;
-    }
-    for (const source of sources.snapshots ?? []) {
-        if (await tickSnapshot(state, source, dirty))
-            changed = true;
-    }
-    if (options.promptActivity !== false) {
-        for (const source of sources.prompts ?? []) {
-            if (await tickPromptSnapshot(state, source))
-                changed = true;
-        }
-    }
-    if (cold) {
-        state.dirty = [];
-        state.prompts.dirtySessions = Object.keys(state.prompts.sessions);
-        state.prompts.dirtyDates = Object.keys(state.prompts.daily).sort();
-    }
-    else {
-        state.dirty = [...dirty].sort();
-    }
-    return { state, changed };
-}
-// ---- payload ---------------------------------------------------------------
-/** Cumulative per-tool and per-model totals for this machine. */
-export function cumulativeTotals(state) {
-    const toolTotals = {};
-    const modelTotals = {};
-    for (const [tool, h] of Object.entries(state.harnesses)) {
-        let sum = 0;
-        for (const value of Object.values(h.daily))
-            sum += value.tokens;
-        toolTotals[tool] = sum;
-        for (const [model, tokens] of Object.entries(h.models)) {
-            modelTotals[model] = (modelTotals[model] ?? 0) + tokens;
-        }
-    }
-    return { toolTotals, modelTotals };
-}
-export function sameTotals(a, b) {
-    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
-    for (const key of keys)
-        if ((a[key] ?? 0) !== (b[key] ?? 0))
-            return false;
-    return true;
-}
-/**
- * Is there prompt activity waiting to go out?
- *
- * A dirty id whose row is gone (pruned between the mark and the send) doesn't
- * count: it would have the tick POST an empty block every minute forever, since
- * there'd be nothing for `markUploaded` to clear.
- */
-export function hasPromptActivity(state) {
-    const { prompts } = state;
-    return (prompts.dirtySessions.some((id) => prompts.sessions[id] !== undefined) ||
-        prompts.dirtyDates.some((date) => prompts.daily[date] !== undefined));
-}
-/**
- * Stake a claim on the outstanding prompt rows: the ones this payload carries
- * are recorded in `prompts.sent`, and `markUploaded` clears exactly those. Rows
- * a cap held back stay dirty and go out next tick.
- *
- * Most-recently-active first, so a machine with a long backlog syncs the work
- * the user actually cares about before the archaeology.
- */
-function takePromptActivity(state) {
-    const { prompts } = state;
-    const sessions = prompts.dirtySessions
-        .flatMap((sessionId) => {
-        const session = prompts.sessions[sessionId];
-        return session ? [{ sessionId, ...session }] : [];
-    })
-        .sort((a, b) => b.lastActiveAt.localeCompare(a.lastActiveAt))
-        .slice(0, PROMPT_ACTIVITY_SESSION_CAP);
-    const dates = [...prompts.dirtyDates]
-        .sort((a, b) => b.localeCompare(a))
-        .slice(0, PROMPT_ACTIVITY_DATE_CAP);
-    const dailyPrompts = dates.flatMap((date) => {
-        const day = prompts.daily[date];
-        return day ? [{ date, ...day }] : [];
-    });
-    prompts.sent = { sessions: sessions.map((s) => s.sessionId), dates };
-    if (sessions.length === 0 && dailyPrompts.length === 0)
-        return undefined;
-    return { sessions, dailyPrompts };
-}
-/**
- * What a tick uploads: cumulative tool/model totals (the server diffs those
- * against its own per-machine snapshot) plus the daily rows for the dirty dates
- * only, and — under the `stats` or `full` tier — the outstanding prompt
- * activity.
- *
- * Every harness's rows go out for a dirty date, including Cursor's — which the
- * tick never scans, and carries over from the last full scan instead. The
- * server reconciles a date by deleting this machine's rows for it that the
- * payload didn't mention, so a date has to be reported complete or the harnesses
- * left out of it lose that day.
- */
-export function tickPayload(state, opts = {}) {
-    const dirty = new Set(state.dirty);
-    const dailyTotals = [];
-    for (const [tool, h] of Object.entries(state.harnesses)) {
-        for (const [key, value] of Object.entries(h.daily)) {
-            const [date = '', model = ''] = key.split('|');
-            if (!dirty.has(date) || value.tokens <= 0)
-                continue;
-            dailyTotals.push({
-                date,
-                tool,
-                tokens: value.tokens,
-                messages: value.messages,
-                model: model || undefined,
-            });
-        }
-    }
-    // Claim the prompt rows this payload carries, or drop a claim a previous
-    // payload left behind: a stale one would have `markUploaded` clear rows this
-    // upload never mentioned (a tier turned down to `none` between two ticks).
-    state.prompts.sent = undefined;
-    const promptActivity = opts.promptActivity
-        ? takePromptActivity(state)
-        : undefined;
-    const { toolTotals, modelTotals } = cumulativeTotals(state);
-    return {
-        toolTotals,
-        dailyTotals,
-        modelTotals,
-        grandTotal: Object.values(toolTotals).reduce((a, b) => a + b, 0),
-        cursorStats: null,
-        cursorScanStatus: { source: 'none' },
-        ...(promptActivity ? { promptActivity } : {}),
-    };
-}
-/** Called on a 200: whatever that payload carried is on the server now. */
-export function markUploaded(state) {
-    state.dirty = [];
-    const sent = state.prompts.sent;
-    if (sent) {
-        const sessions = new Set(sent.sessions);
-        const dates = new Set(sent.dates);
-        state.prompts.dirtySessions = state.prompts.dirtySessions.filter((id) => !sessions.has(id));
-        state.prompts.dirtyDates = state.prompts.dirtyDates.filter((date) => !dates.has(date));
-        state.prompts.sent = undefined;
-    }
-    state.uploaded = cumulativeTotals(state);
-    state.lastError = undefined;
-    state.nextAllowedAt = undefined;
-}
-// ---- the daily repair pass -------------------------------------------------
-async function snapshotFileCursors(h, paths) {
-    for (const file of await statFiles(paths)) {
-        // Offsets are set to EOF *after* the full scan read the file, so a file that
-        // grew mid-scan is re-read from the end rather than double-counted — the
-        // next repair picks up whatever slipped through.
-        h.files[file.path] = {
-            size: file.size,
-            mtimeMs: file.mtimeMs,
-            offset: file.size,
-        };
-    }
-}
-/**
- * Rebuild the whole state from a full scan's results — the self-healing half of
- * the design. Whatever the tick's tail-follow got wrong (a rotated log, a
- * mid-file model switch, a Codex date guessed from an mtime) is corrected here,
- * so incremental drift can never outlive a day. Best-effort: a state we failed
- * to rebuild costs a tick, never the sync that called us.
- *
- * Staged rather than persisted outright, because the full-scan paths carry
- * prompt activity too — a machine with no daemon has no tick to drain it. The
- * rebuild diffs the scan's aggregate against what was already sent, claims the
- * difference for this upload, and only `commit` (on a 200) clears it. A failed
- * POST therefore leaves every row dirty for the next run, which the server's
- * GREATEST upserts make free to resend.
- *
- * `prompts` says whether this caller has any authority over the prompt state —
- * see `StagedPrompts`. Only a caller that actually resolved the consent tier
- * gets to rewrite it, and only such a caller claims prompt rows for the upload.
- */
-export async function stageFullScan(results, prompts = 'untouched', sources = defaultSources()) {
-    const nothingStaged = {
-        commit: async () => {
-            // Nothing was staged, so there is nothing to record as delivered.
-        },
-    };
-    try {
-        const previous = await loadScanState();
-        const state = emptyState();
-        state.prompts = previous?.prompts ?? emptyPromptState();
-        state.promptSources = previous?.promptSources ?? {};
-        state.promptFiles = previous?.promptFiles ?? {};
-        // Nothing is claimed as in-flight any more: whatever the last upload sent
-        // was either acked (and cleared) or lost. A caller with authority re-derives
-        // the claim below; one without leaves the rows dirty for the tick.
-        state.prompts.sent = undefined;
-        if (prompts !== 'untouched') {
-            state.promptSources = prompts.scanned
-                ? (prompts.scanned.sources ?? {
-                    claude_code: mergePromptActivities([prompts.scanned]),
-                })
-                : {};
-            // A fresh scan's partitions are authoritative. Recheck IDE snapshots on
-            // the next tick rather than advancing a cursor past concurrent writes.
-            state.promptFiles = {};
-            replacePromptActivity(state.prompts, prompts.scanned ?? emptyPromptActivity());
-        }
-        for (const result of results) {
-            replaceAggregates(harness(state, result.tool), aggregatesOfResult(result), new Set());
-        }
-        for (const src of sources.jsonl) {
-            await snapshotFileCursors(harness(state, src.tool), await src.files());
-        }
-        // Codex has to be re-read: its per-file running totals aren't recoverable
-        // from the aggregate, and without them the next tick would count each file's
-        // whole total a second time.
-        const codex = harness(state, 'codex');
-        codex.codexTotals = {};
-        const codexPaths = await sources.codex.files();
-        await snapshotFileCursors(codex, codexPaths);
-        for (const path of codexPaths) {
-            const cursor = codex.files[path];
-            if (!cursor)
-                continue;
-            const content = await readFile(path, 'utf8').catch(() => '');
-            const { maxTotal, model } = codexFileTotals(content);
-            if (maxTotal <= 0)
-                continue;
-            codex.codexTotals[path] = {
-                maxTotal,
-                model,
-                date: sources.codex.dateFor(path) ?? toDateStr(new Date(cursor.mtimeMs)),
-            };
-        }
-        for (const src of sources.sqlite) {
-            const h = harness(state, src.tool);
-            const path = src.dbPath();
-            h.dbMtimeMs = (await statOrNull(path))?.mtimeMs ?? 0;
-            h.walMtimeMs = (await statOrNull(`${path}-wal`))?.mtimeMs ?? 0;
-        }
-        // Only a caller that knows the tier may put prompt rows on the wire. For
-        // anyone else `sent` stays empty, so `commit` clears no prompt rows either.
-        const claimed = prompts === 'untouched' ? undefined : takePromptActivity(state);
-        return {
-            ...(claimed ? { promptActivity: claimed } : {}),
-            commit: async () => {
-                try {
-                    // The full token payload just went out, and the server took the
-                    // prompt rows this upload claimed — markUploaded records both.
-                    markUploaded(state);
-                    await saveScanState(state);
-                }
-                catch {
-                    // never fail the sync that called us
-                }
-            },
-        };
-    }
-    catch {
-        // never fail the sync that called us
-        return nothingStaged;
-    }
-}
-//# sourceMappingURL=incremental.js.map