dsh-continual-evolve 0.15.6 → 0.15.8

package/lib/store.d.ts

@@ -1,8 +1,7 @@
 import type { MemoryProposal } from "./memory-rules.js";
 import { type SkillProposal } from "./skill-rules.js";
 import { type ProposalContext, type ProposalOutcome } from "./store-apply.js";
-import { type UsageTotals } from "./token-usage.js";
-export type { MemoryProposal, ProposalContext, ProposalOutcome, UsageTotals };
+export type { MemoryProposal, ProposalContext, ProposalOutcome };
 /** Thrown when the runtime lacks `node:sqlite` — the degrade signal. */
 export declare class StoreUnavailableError extends Error {
 }
@@ -50,22 +49,52 @@ export interface SkillUse {
     /** ISO instant of the last counted use, `null` when never consumed. */
     lastUsedAt: string | null;
 }
-/** One review-loop audit view over the extraction ledger (read-only). */
-export interface ReviewSummary {
+/** One per-item content-review verdict (the `item-review` account's row). */
+export interface ReviewLogEntry {
+    runId?: string | undefined;
+    workspaceId?: string | undefined;
+    itemKind: "memory" | "skill";
+    itemId: string;
+    verdict: "keep" | "rewrite" | "quarantine" | "skip";
+    reason?: string | undefined;
+    /** Normalized usage JSON of the cheap gate call, `undefined` when skipped before any call. */
+    cheapUsage?: unknown;
+    /** Normalized usage JSON of the evolve call, `undefined` unless rewritten. */
+    evolveUsage?: unknown;
+    /** Whether the rewrite landed (1) or the row is verdict-only (0). */
+    applied?: number | undefined;
+    /** How many times this item has evolved including this run. */
+    evolveCount?: number | undefined;
+}
+/** One day of the hard-cap account (UTC `YYYY-MM-DD`, budget = 100). */
+export interface DailyStats {
+    day: string;
+    budget: number;
+    reviewed: number;
+    newItems: number;
+    requeued: number;
+    approved: number;
     applied: number;
-    rejected: number;
-    skipped: number;
-    failed: number;
-    /** Top skip reasons, most frequent first (at most 3, display-truncated). */
-    topSkips: {
-        reason: string;
-        count: number;
-    }[];
-    /** Token totals over the same rows (unnormalizable payloads contribute nothing). */
-    tokens: UsageTotals;
+    cheapToken: number;
+    evolveToken: number;
+    backlog: number;
+    dropped: number;
+    /** JSON array of the top skip reasons, `null` when none. */
+    skipTop: string | null;
+}
+/** Additive counters merged into today's rollup by one run. */
+export interface DailyDelta {
+    newItems?: number | undefined;
+    requeued?: number | undefined;
+    approved?: number | undefined;
+    applied?: number | undefined;
+    cheapToken?: number | undefined;
+    evolveToken?: number | undefined;
+    /** Queue depth after the run (set, not added). */
+    backlog?: number | undefined;
+    dropped?: number | undefined;
+    skipReasons?: string[] | undefined;
 }
-/** The empty audit view: no rows, no signal — never a failure. */
-export declare function zeroReviewSummary(): ReviewSummary;
 /** One stored memory record (snake_case columns camelCased). */
 export interface MemoryRecord {
     workspaceId: string;
@@ -81,6 +110,8 @@ export interface MemoryRecord {
     sourceSeqs: string | null;
     /** The extraction run that wrote it; `'explicit'` for tool writes. */
     sourceRun: string | null;
+    /** Id of the memory this row corrects/supersedes in the same workspace, `null` when standalone. */
+    corrects: string | null;
     createdAt: string;
     updatedAt: string;
 }
@@ -94,13 +125,15 @@ export interface LedgerEntry {
     runId?: string | undefined;
     sessionId?: string | undefined;
     workspaceId?: string | undefined;
-    trigger: "turn-debounce" | "compaction" | "close-drain" | "explicit" | "import";
+    trigger: "turn-debounce" | "compaction" | "close-drain" | "explicit" | "import" | "item-review";
     decision?: string | undefined;
     skipReason?: string | undefined;
     status?: string | undefined;
     durationMs?: number | undefined;
     model?: string | undefined;
     usage?: unknown;
+    /** Pre-gate call payload (extraction cheap gate); `undefined` when the run never reached it. */
+    cheapUsage?: unknown;
     /** Applied/attempted mutations: `{id, action, before?, after?, sourceSeqs}`; a parse-failed run instead carries the raw answer's head. */
     files?: unknown;
 }
@@ -205,12 +238,39 @@ export interface MemoryStore {
     /** Aggregate usage for one skill, undefined when never consumed. */
     getSkillUse(workspaceId: string, skillId: string, scope: string): SkillUse | undefined;
     /**
-     * Read-only audit over the extraction ledger for one workspace: judgment
-     * counts, top skip reasons, and token totals. Degrades to zeros on any
-     * fault — the card observes, never breaks. `since` is an inclusive ISO
-     * lower bound; empty counts every row.
+     * Record one real memory consumption (a body served by id, never a list
+     * or search hit). Same heartbeat discipline as skill usage: accounting
+     * never fails the read it rides on.
+     */
+    recordMemoryUse(workspaceId: string, memoryId: string): void;
+    /** Aggregate usage for one memory, undefined when never consumed. */
+    getMemoryUse(workspaceId: string, memoryId: string): SkillUse | undefined;
+    /** Append one per-item content-review verdict (the `item-review` account). */
+    logReview(entry: ReviewLogEntry): void;
+    /**
+     * Atomically consume one unit of today's review budget: returns the
+     * remaining budget after consumption, or -1 when the day is exhausted
+     * (the caller drops the low-priority item and counts it as dropped).
+     */
+    consumeReviewBudget(day: string, budget: number): number;
+    /** Today's rollup row, undefined when nothing ran yet today. */
+    getDaily(day: string): DailyStats | undefined;
+    /** Merge one run's counters into today's rollup row (upsert, additive). */
+    mergeDaily(day: string, budget: number, delta: DailyDelta): void;
+    /**
+     * Soft-isolate one item (review quarantine verdict): hidden from
+     * injection and reads, never deleted — the ledger keeps the before
+     * snapshot for undo. Returns false when the row is absent.
+     */
+    quarantine(workspaceId: string, kind: "memory" | "skill", id: string): boolean;
+    /**
+     * The review history of one item: last verdict instant and landed
+     * rewrite count, undefined when never reviewed (a new item).
      */
-    reviewSummary(workspaceId: string, since?: string): ReviewSummary;
+    reviewStateOf(workspaceId: string, kind: "memory" | "skill", id: string): {
+        lastTs: string | null;
+        evolveCount: number;
+    } | undefined;
 }
 /** Default database location: `$DSH_HOME/evolve/memory.db`, else `~/.dsh/…`. */
 export declare function defaultStorePath(): string;

package/lib/store.js

@@ -17,7 +17,6 @@ import { secretLeakReason } from "./memory-rules.js";
 import { globalSkillsDir, projectSkillsDir, renderSkillMarkdown, SKILL_GENERATED_MARKER, skillDir, skillFieldGateReasons, slugifySkillId, validateRenderedSkill, } from "./skill-rules.js";
 import { isValidMemoryId } from "./memory-rules.js";
 import { applyProposals } from "./store-apply.js";
-import { normalizeUsage, sumUsage, zeroUsage } from "./token-usage.js";
 /** Thrown when the runtime lacks `node:sqlite` — the degrade signal. */
 export class StoreUnavailableError extends Error {
 }
@@ -52,6 +51,7 @@ PRAGMA busy_timeout=5000;CREATE TABLE IF NOT EXISTS memories (
   source_session TEXT,
   source_seqs TEXT,
   source_run TEXT,
+  corrects TEXT,
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL,
   PRIMARY KEY (workspace_id, id)
@@ -67,9 +67,10 @@ CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
 -- patrol() reconciles any residue.
 CREATE TABLE IF NOT EXISTS extraction_log (
   run_id TEXT, ts TEXT NOT NULL, session_id TEXT, workspace_id TEXT,
-  trigger TEXT CHECK (trigger IN ('turn-debounce','compaction','close-drain','explicit','import')),
+  trigger TEXT CHECK (trigger IN ('turn-debounce','compaction','close-drain','explicit','import','item-review')),
   decision TEXT, skip_reason TEXT,
   status TEXT, duration_ms INTEGER, model TEXT, usage TEXT,
+  cheap_usage TEXT,
   files TEXT, occurrences INTEGER NOT NULL DEFAULT 1
 );
 CREATE TABLE IF NOT EXISTS state (
@@ -111,11 +112,46 @@ CREATE TABLE IF NOT EXISTS skill_usage (
   last_used_at TEXT,
   PRIMARY KEY (workspace_id, skill_id, scope)
 ) STRICT;
+-- Memory usage counters (content-quality loop): one aggregate row per memory,
+-- the same presence-heartbeat discipline as skill_usage — a body served by id
+-- counts, search/list hits stay uncounted.
+CREATE TABLE IF NOT EXISTS memory_usage (
+  workspace_id TEXT NOT NULL,
+  memory_id TEXT NOT NULL,
+  use_count INTEGER NOT NULL DEFAULT 0,
+  last_used_at TEXT,
+  PRIMARY KEY (workspace_id, memory_id)
+) STRICT;
+-- Per-item content-review verdicts (the item-review trigger's account):
+-- one row per reviewed item per run. Pruned with the ledgers.
+CREATE TABLE IF NOT EXISTS review_log (
+  run_id TEXT, ts TEXT NOT NULL, workspace_id TEXT,
+  item_kind TEXT NOT NULL CHECK (item_kind IN ('memory','skill')),
+  item_id TEXT NOT NULL,
+  verdict TEXT NOT NULL CHECK (verdict IN ('keep','rewrite','quarantine','skip')),
+  reason TEXT,
+  cheap_usage TEXT, evolve_usage TEXT,
+  applied INTEGER NOT NULL DEFAULT 0,
+  evolve_count INTEGER NOT NULL DEFAULT 0
+);
+-- One rollup row per UTC day: the hard-cap account (budget vs reviewed vs
+-- backlog vs dropped) plus the token account split by cheap/evolve purpose.
+CREATE TABLE IF NOT EXISTS review_daily (
+  day TEXT NOT NULL PRIMARY KEY,
+  budget INTEGER NOT NULL,
+  reviewed INTEGER NOT NULL DEFAULT 0,
+  new_items INTEGER NOT NULL DEFAULT 0,
+  requeued INTEGER NOT NULL DEFAULT 0,
+  approved INTEGER NOT NULL DEFAULT 0,
+  applied INTEGER NOT NULL DEFAULT 0,
+  cheap_token INTEGER NOT NULL DEFAULT 0,
+  evolve_token INTEGER NOT NULL DEFAULT 0,
+  backlog INTEGER NOT NULL DEFAULT 0,
+  dropped INTEGER NOT NULL DEFAULT 0,
+  skip_top TEXT,
+  skip_counts TEXT
+) STRICT;
 `;
-/** The empty audit view: no rows, no signal — never a failure. */
-export function zeroReviewSummary() {
-    return { applied: 0, rejected: 0, skipped: 0, failed: 0, topSkips: [], tokens: zeroUsage() };
-}
 /** Default database location: `$DSH_HOME/evolve/memory.db`, else `~/.dsh/…`. */
 export function defaultStorePath() {
     const home = process.env.DSH_HOME?.trim();
@@ -133,6 +169,7 @@ function recordOf(row) {
         sourceSession: row.source_session,
         sourceSeqs: row.source_seqs,
         sourceRun: row.source_run,
+        corrects: row.corrects ?? null,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -263,6 +300,8 @@ export async function openMemoryStore(explicitPath) {
     }
     database.exec(DDL);
     ensureLedgerOccurrences(database);
+    ensureMemoriesCorrects(database);
+    ensureExtractionCheapUsage(database);
     const stmts = {
         get: database.prepare("SELECT * FROM memories WHERE workspace_id = ? AND id = ?"),
         list: database.prepare(`SELECT * FROM memories WHERE workspace_id = ? AND status = 'active' ${LIST_ORDER}`),
@@ -281,8 +320,8 @@ export async function openMemoryStore(explicitPath) {
             "WHERE status = 'active' AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
         recentSkill: database.prepare("SELECT workspace_id, MAX(ts) AS ts FROM skill_log " +
             "WHERE workspace_id IS NOT NULL AND workspace_id <> '' GROUP BY workspace_id ORDER BY ts DESC LIMIT 1"),
-        ledger: database.prepare("INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, files) " +
-            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        ledger: database.prepare("INSERT INTO extraction_log (run_id, ts, session_id, workspace_id, trigger, decision, skip_reason, status, duration_ms, model, usage, cheap_usage, files) " +
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
         latestSkip: database.prepare("SELECT rowid AS rid, skip_reason AS reason, status FROM extraction_log " +
             "WHERE workspace_id IS ? AND session_id IS ? ORDER BY ts DESC, rowid DESC LIMIT 1"),
         bumpSkip: database.prepare(`UPDATE extraction_log SET ts = ?, ${LEDGER_OCCURRENCES} = ${LEDGER_OCCURRENCES} + 1 WHERE rowid = ?`),
@@ -311,10 +350,25 @@ export async function openMemoryStore(explicitPath) {
         skillActiveRows: database.prepare("SELECT * FROM skills WHERE status = 'active'"),
         skillQuarantine: database.prepare("UPDATE skills SET status = 'quarantined' WHERE workspace_id = ? AND id = ?"),
         skillWorkspaces: database.prepare("SELECT workspace_id, COUNT(*) AS n, MAX(updated_at) AS u FROM skills WHERE status = 'active' GROUP BY workspace_id ORDER BY u DESC"),
-        reviewRows: database.prepare("SELECT status, skip_reason, usage FROM extraction_log WHERE workspace_id = ? AND ts >= ?"),
         skillUseGet: database.prepare("SELECT use_count, last_used_at FROM skill_usage WHERE workspace_id = ? AND skill_id = ? AND scope = ?"),
         skillUseUpsert: database.prepare("INSERT INTO skill_usage (workspace_id, skill_id, scope, use_count, last_used_at) VALUES (?, ?, ?, 1, ?) " +
             "ON CONFLICT (workspace_id, skill_id, scope) DO UPDATE SET use_count = use_count + 1, last_used_at = excluded.last_used_at"),
+        memUseGet: database.prepare("SELECT use_count, last_used_at FROM memory_usage WHERE workspace_id = ? AND memory_id = ?"),
+        memUseUpsert: database.prepare("INSERT INTO memory_usage (workspace_id, memory_id, use_count, last_used_at) VALUES (?, ?, 1, ?) " +
+            "ON CONFLICT (workspace_id, memory_id) DO UPDATE SET use_count = use_count + 1, last_used_at = excluded.last_used_at"),
+        reviewLog: database.prepare("INSERT INTO review_log (run_id, ts, workspace_id, item_kind, item_id, verdict, reason, cheap_usage, evolve_usage, applied, evolve_count) " +
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"),
+        reviewLast: database.prepare("SELECT ts, applied FROM review_log WHERE workspace_id IS ? AND item_kind = ? AND item_id = ? ORDER BY rowid DESC LIMIT 1"),
+        reviewEvolved: database.prepare("SELECT COUNT(*) AS n FROM review_log WHERE workspace_id IS ? AND item_kind = ? AND item_id = ? AND applied = 1"),
+        reviewPrune: database.prepare("DELETE FROM review_log WHERE ts < ?"),
+        dailyGet: database.prepare("SELECT * FROM review_daily WHERE day = ?"),
+        dailyUpsert: database.prepare("INSERT INTO review_daily (day, budget, reviewed, new_items, requeued, approved, applied, cheap_token, evolve_token, backlog, dropped, skip_top, skip_counts) " +
+            "VALUES (?, ?, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL) " +
+            "ON CONFLICT (day) DO UPDATE SET budget = excluded.budget"),
+        dailyConsume: database.prepare("UPDATE review_daily SET reviewed = reviewed + 1 WHERE day = ? AND reviewed < budget"),
+        dailyMerge: database.prepare("UPDATE review_daily SET new_items = new_items + ?, requeued = requeued + ?, " +
+            "approved = approved + ?, applied = applied + ?, cheap_token = cheap_token + ?, evolve_token = evolve_token + ?, " +
+            "backlog = ?, dropped = dropped + ?, skip_top = ?, skip_counts = ? WHERE day = ?"),
     };
     // LIKE fallback: one OR-triplet per token, every token required. Statements
     // are cached by token count — the query set repeats, the counts don't grow.
@@ -729,7 +783,8 @@ export async function openMemoryStore(explicitPath) {
         pruneLedger(beforeIso) {
             const memory = Number(stmts.prune.run(beforeIso).changes);
             const skills = Number(stmts.skillPrune.run(beforeIso).changes);
-            return memory + skills;
+            const reviews = Number(stmts.reviewPrune.run(beforeIso).changes);
+            return memory + skills + reviews;
         },
         close() {
             database.close();
@@ -826,50 +881,86 @@ export async function openMemoryStore(explicitPath) {
                 return undefined;
             }
         },
-        reviewSummary(workspaceId, since) {
+        recordMemoryUse(workspaceId, memoryId) {
             try {
-                const rows = stmts.reviewRows.all(workspaceId, since ?? "");
-                const summary = zeroReviewSummary();
-                const skips = new Map();
-                for (const row of rows) {
-                    if (row.status === "applied") {
-                        summary.applied += 1;
-                    }
-                    else if (row.status === "rejected") {
-                        summary.rejected += 1;
-                    }
-                    else if (row.status === "failed") {
-                        summary.failed += 1;
-                    }
-                    else {
-                        summary.skipped += 1;
-                    }
-                    if (row.status !== "applied" && row.status !== "rejected" && typeof row.skip_reason === "string" && row.skip_reason.length > 0) {
-                        skips.set(row.skip_reason, (skips.get(row.skip_reason) ?? 0) + 1);
-                    }
-                    if (typeof row.usage === "string" && row.usage.length > 0) {
-                        try {
-                            const normalized = normalizeUsage(JSON.parse(row.usage));
-                            if (normalized !== null) {
-                                summary.tokens = sumUsage(summary.tokens, normalized);
-                            }
-                        }
-                        catch {
-                            // One corrupt payload must not void the whole audit.
-                        }
-                    }
+                stmts.memUseUpsert.run(workspaceId, memoryId, new Date().toISOString());
+            }
+            catch {
+                // Accounting never fails the read it rides on.
+            }
+        },
+        getMemoryUse(workspaceId, memoryId) {
+            try {
+                const row = stmts.memUseGet.get(workspaceId, memoryId);
+                if (row === undefined) {
+                    return undefined;
                 }
-                summary.topSkips = [...skips.entries()]
-                    .sort((a, b) => b[1] - a[1])
-                    .slice(0, 3)
-                    .map(([reason, count]) => ({
-                    reason: reason.length > 80 ? `${reason.slice(0, 80)}…` : reason,
-                    count,
-                }));
-                return summary;
+                return { useCount: row.use_count, lastUsedAt: row.last_used_at };
             }
             catch {
-                return zeroReviewSummary();
+                return undefined;
+            }
+        },
+        logReview(entry) {
+            stmts.reviewLog.run(entry.runId ?? null, new Date().toISOString(), entry.workspaceId ?? null, entry.itemKind, entry.itemId, entry.verdict, entry.reason ?? null, entry.cheapUsage === undefined ? null : JSON.stringify(entry.cheapUsage), entry.evolveUsage === undefined ? null : JSON.stringify(entry.evolveUsage), entry.applied ?? 0, entry.evolveCount ?? 0);
+        },
+        consumeReviewBudget(day, budget) {
+            stmts.dailyUpsert.run(day, budget);
+            const result = stmts.dailyConsume.run(day);
+            if (Number(result.changes) === 0) {
+                return -1;
+            }
+            const row = stmts.dailyGet.get(day);
+            if (row === undefined) {
+                return -1;
+            }
+            return row.budget - row.reviewed;
+        },
+        getDaily(day) {
+            const row = stmts.dailyGet.get(day);
+            if (row === undefined) {
+                return undefined;
+            }
+            return {
+                day: row.day, budget: row.budget, reviewed: row.reviewed, newItems: row.new_items,
+                requeued: row.requeued, approved: row.approved, applied: row.applied,
+                cheapToken: row.cheap_token, evolveToken: row.evolve_token,
+                backlog: row.backlog, dropped: row.dropped, skipTop: row.skip_top,
+            };
+        },
+        mergeDaily(day, budget, delta) {
+            stmts.dailyUpsert.run(day, budget);
+            const row = stmts.dailyGet.get(day);
+            const counts = parseCounts(row.skip_counts);
+            for (const reason of delta.skipReasons ?? []) {
+                counts[reason] = (counts[reason] ?? 0) + 1;
+            }
+            const entries = Object.entries(counts)
+                .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))
+                .slice(0, 3)
+                .map(([reason]) => reason);
+            stmts.dailyMerge.run(delta.newItems ?? 0, delta.requeued ?? 0, delta.approved ?? 0, delta.applied ?? 0, delta.cheapToken ?? 0, delta.evolveToken ?? 0, delta.backlog ?? row.backlog, delta.dropped ?? 0, entries.length > 0 ? JSON.stringify(entries) : row.skip_top, Object.keys(counts).length > 0 ? JSON.stringify(counts) : null, day);
+        },
+        quarantine(workspaceId, kind, id) {
+            try {
+                const result = (kind === "memory" ? stmts.quarantine : stmts.skillQuarantine).run(workspaceId, id);
+                return Number(result.changes) > 0;
+            }
+            catch {
+                return false;
+            }
+        },
+        reviewStateOf(workspaceId, kind, id) {
+            try {
+                const last = stmts.reviewLast.get(workspaceId, kind, id);
+                if (last === undefined) {
+                    return undefined;
+                }
+                const evolved = stmts.reviewEvolved.get(workspaceId, kind, id);
+                return { lastTs: last.ts, evolveCount: Number(evolved.n) };
+            }
+            catch {
+                return undefined;
             }
         },
     };
@@ -887,8 +978,54 @@ function ensureLedgerOccurrences(database) {
     }
     database.exec(`ALTER TABLE extraction_log ADD COLUMN ${LEDGER_OCCURRENCES} INTEGER NOT NULL DEFAULT 1`);
 }
+/**
+ * Add the memories `corrects` link column to a store created before the
+ * correction-linking field existed. Same single-migration discipline as the
+ * ledger occurrences column above.
+ */
+function ensureMemoriesCorrects(database) {
+    const columns = database.prepare("SELECT name FROM pragma_table_info('memories')").all();
+    if (columns.some((column) => column.name === "corrects")) {
+        return;
+    }
+    database.exec("ALTER TABLE memories ADD COLUMN corrects TEXT");
+}
+/**
+ * Add the extraction ledger `cheap_usage` column to a store created before
+ * the cheap pre-gate existed. Same single-migration discipline as the
+ * columns above.
+ */
+function ensureExtractionCheapUsage(database) {
+    const columns = database.prepare("SELECT name FROM pragma_table_info('extraction_log')").all();
+    if (columns.some((column) => column.name === "cheap_usage")) {
+        return;
+    }
+    database.exec("ALTER TABLE extraction_log ADD COLUMN cheap_usage TEXT");
+}
+/** Parse the daily skip-counts map; corrupt payloads degrade to empty. */
+function parseCounts(raw) {
+    if (raw === null) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return {};
+        }
+        const counts = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+                counts[key] = Math.floor(value);
+            }
+        }
+        return counts;
+    }
+    catch {
+        return {};
+    }
+}
 /** JSON-encode the optional ledger fields and insert the row (never throws past a warn). */
 function writeLedger(stmt, entry) {
-    stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.files === undefined ? null : JSON.stringify(entry.files));
+    stmt.run(entry.runId ?? null, new Date().toISOString(), entry.sessionId ?? null, entry.workspaceId ?? null, entry.trigger, entry.decision ?? null, entry.skipReason ?? null, entry.status ?? null, entry.durationMs ?? null, entry.model ?? null, entry.usage === undefined ? null : JSON.stringify(entry.usage), entry.cheapUsage === undefined ? null : JSON.stringify(entry.cheapUsage), entry.files === undefined ? null : JSON.stringify(entry.files));
 }
 //# sourceMappingURL=store.js.map

package/lib/token-usage.d.ts

@@ -4,8 +4,9 @@
  * `inputTokens`/`outputTokens` are usual, `totalTokens`, `cacheReadTokens`,
  * `cacheWriteTokens`, and `reasoningTokens` come and go — so every call site
  * normalizes through {@link normalizeUsage} and aggregates with
- * {@link sumUsage}. Nothing here touches the store: aggregation over ledger
- * rows lives in `store.reviewSummary`, which stays read-only and bounded.
+ * {@link sumUsage}. Nothing here touches the store: per-day aggregation over
+ * ledger rows lives in the review daily rollup, which stays read-only and
+ * bounded (one row per day).
  */
 /** Token counts for one LLM call, every field present, zeros when unknown. */
 export interface UsageTotals {

package/lib/token-usage.js

@@ -4,8 +4,9 @@
  * `inputTokens`/`outputTokens` are usual, `totalTokens`, `cacheReadTokens`,
  * `cacheWriteTokens`, and `reasoningTokens` come and go — so every call site
  * normalizes through {@link normalizeUsage} and aggregates with
- * {@link sumUsage}. Nothing here touches the store: aggregation over ledger
- * rows lives in `store.reviewSummary`, which stays read-only and bounded.
+ * {@link sumUsage}. Nothing here touches the store: per-day aggregation over
+ * ledger rows lives in the review daily rollup, which stays read-only and
+ * bounded (one row per day).
  */
 /** The zero value: no signal, not a failure. */
 export function zeroUsage() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-continual-evolve",
-  "version": "0.15.6",
+  "version": "0.15.8",
   "description": "ZCode-style workspace memory for DeepSeek Harness: one central SQLite store partitioned by workspace, index injection, and sole-writer gated writes.",
   "license": "MIT",
   "repository": {