hippo-memory 1.69.0 → 1.70.0

package/dist/consolidate/physics-pass.js

@@ -1,60 +1,60 @@
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { loadPhysicsState, savePhysicsState, refreshParticleProperties } from '../physics-state.js';
-import { simulate } from '../physics.js';
+import { refreshParticleProperties } from '../db/physics-state.js';
+import { loadStoredParticles, saveStoredParticles } from '../store/vector-writes.js';
+import { simulate } from '../core/physics.js';
+import { errorMessage } from '../util/log.js';
+const STATS_DECIMALS = 4;
 // -------------------------------------------------------------------------
 // 2. Physics simulation pass
 // -------------------------------------------------------------------------
 export function physicsPass(run) {
     if (run.dryRun)
         return;
-    const { config, result, survivors } = run;
+    const { config, result } = run;
     try {
         const physicsEnabled = config.physics.enabled === true
             || (config.physics.enabled === 'auto');
-        if (physicsEnabled) {
-            const db = openHippoDb(run.hippoRoot);
-            try {
-                const physicsMap = loadPhysicsState(db);
-                const particles = Array.from(physicsMap.values());
-                if (particles.length > 0) {
-                    // Build entry lookup for property refresh
-                    const entryMap = new Map(survivors.map(e => [e.id, e]));
-                    refreshParticleProperties(particles, entryMap, run.now);
-                    // Build conflict pairs from survivors
-                    const conflictPairs = new Map();
-                    for (const entry of survivors) {
-                        if (entry.conflicts_with.length > 0) {
-                            const set = conflictPairs.get(entry.id) ?? new Set();
-                            for (const cid of entry.conflicts_with)
-                                set.add(cid);
-                            conflictPairs.set(entry.id, set);
-                        }
-                    }
-                    // Build half-life lookup
-                    const halfLives = new Map();
-                    for (const entry of survivors) {
-                        halfLives.set(entry.id, entry.half_life_days);
-                    }
-                    const ctx = {
-                        conflictPairs,
-                        halfLives,
-                        config: config.physics,
-                    };
-                    const stats = simulate(particles, ctx);
-                    savePhysicsState(db, particles);
-                    result.physicsSimulated = stats.particleCount;
-                    result.details.push(`  ⚛️  physics: ${stats.particleCount} particles, ` +
-                        `avg vel ${stats.avgVelocityMagnitude.toFixed(4)}, ` +
-                        `energy ${stats.energy.total.toFixed(4)}`);
-                }
-            }
-            finally {
-                closeHippoDb(db);
-            }
-        }
+        if (physicsEnabled)
+            simulateStoredParticles(run);
     }
     catch (error) {
-        result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
+        result.details.push(`  ⚠️ physics simulation skipped: ${errorMessage(error)}`);
+    }
+}
+function simulateStoredParticles(run) {
+    const { result, survivors } = run;
+    const particles = loadStoredParticles(run.hippoRoot);
+    if (particles.length === 0)
+        return;
+    // Build entry lookup for property refresh
+    const entryMap = new Map(survivors.map(e => [e.id, e]));
+    refreshParticleProperties(particles, entryMap, run.now);
+    const stats = simulate(particles, survivorForces(run));
+    saveStoredParticles(run.hippoRoot, particles);
+    result.physicsSimulated = stats.particleCount;
+    result.details.push(`  ⚛️  physics: ${stats.particleCount} particles, ` +
+        `avg vel ${stats.avgVelocityMagnitude.toFixed(STATS_DECIMALS)}, ` +
+        `energy ${stats.energy.total.toFixed(STATS_DECIMALS)}`);
+}
+function survivorForces(run) {
+    // Build conflict pairs from survivors
+    const conflictPairs = new Map();
+    for (const entry of run.survivors) {
+        if (entry.conflicts_with.length > 0) {
+            const set = conflictPairs.get(entry.id) ?? new Set();
+            for (const cid of entry.conflicts_with)
+                set.add(cid);
+            conflictPairs.set(entry.id, set);
+        }
+    }
+    // Build half-life lookup
+    const halfLives = new Map();
+    for (const entry of run.survivors) {
+        halfLives.set(entry.id, entry.half_life_days);
     }
+    return {
+        conflictPairs,
+        halfLives,
+        config: run.config.physics,
+    };
 }
 //# sourceMappingURL=physics-pass.js.map

package/dist/{replay.d.ts → consolidate/replay.d.ts}

@@ -22,7 +22,7 @@
  *   - merge: collapses near-duplicate episodics into semantics
  *   - REPLAY: picks winners and rehearses them (this file)
  */
-import { type MemoryEntry } from './memory.js';
+import { type MemoryEntry } from '../core/memory.js';
 /**
  * Priority score used to rank survivors for replay. Higher = more likely
  * to be sampled. Pure function of the entry and current time.

package/dist/{replay.js → consolidate/replay.js}

@@ -22,8 +22,8 @@
  *   - merge: collapses near-duplicate episodics into semantics
  *   - REPLAY: picks winners and rehearses them (this file)
  */
-import { isOutcomeSlowAblated } from './ablation.js';
-import { resolveConfidence } from './memory.js';
+import { isOutcomeSlowAblated } from '../core/ablation.js';
+import { resolveConfidence } from '../core/memory.js';
 const VALENCE_WEIGHT = {
     neutral: 1.0,
     positive: 1.3,

package/dist/consolidate/run.d.ts

@@ -1,12 +1,12 @@
-import { MemoryEntry, type DecayOptions } from '../memory.js';
-import { type DatabaseSyncLike } from '../db.js';
-import { type DormantMove } from '../dormant.js';
-import { loadConfig } from '../config.js';
+import { MemoryEntry, type DecayOptions } from '../core/memory.js';
+import { type DormantMove } from '../store/dormant.js';
+import { type TombstoneChecks } from '../store/tombstone-checks.js';
+import { loadConfig } from '../core/config.js';
 export interface ConsolidationResult {
     decayed: number;
     removed: number;
     /** Faded memories moved to the dormant store instead of deleted (config
-     *  `dormant.enabled`; src/dormant.ts). Always 0 when that is off. */
+     *  `dormant.enabled`; src/store/dormant.ts). Always 0 when that is off. */
     dormant: number;
     /** Dormant memories deleted for good this sleep because they outlived
      *  `dormant.retentionDays` without a restore. */
@@ -35,12 +35,6 @@ export interface ConsolidationResult {
 }
 export declare const REPLAY_COUNT_DEFAULT = 5;
 export declare function keptAsWritten(entry: MemoryEntry): boolean;
-/** The sleep's one tombstone-check handle: opened on first use, never under dryRun, closed once. */
-interface LazyDb {
-    get: () => DatabaseSyncLike | null;
-    close: () => void;
-}
-export declare function lazyConsolidateDb(hippoRoot: string, dryRun: boolean): LazyDb;
 /** Re-syncs the full-text index with `memories`; a store open that is already current no longer counts the two. */
 export declare function syncFtsIndex(hippoRoot: string, dryRun: boolean, result: ConsolidationResult): void;
 /** State every sleep stage reads or appends to; the pending lists are flushed at the end, each of `units` whole in one transaction. */
@@ -53,7 +47,8 @@ export interface SleepRun {
     result: ConsolidationResult;
     all: MemoryEntry[];
     retirable: (entry: MemoryEntry) => boolean;
-    getConsolidateDb: () => DatabaseSyncLike | null;
+    /** Auto-promote (1.4) and merge (3) write deterministic content through the guard's bypass, so both check tombstones here first. */
+    tombstones: TombstoneChecks;
     survivors: MemoryEntry[];
     pendingWrites: MemoryEntry[];
     pendingDeletes: string[];
@@ -61,5 +56,4 @@ export interface SleepRun {
     units: string[][];
 }
 export declare function newConsolidationResult(dryRun: boolean): ConsolidationResult;
-export {};
 //# sourceMappingURL=run.d.ts.map

package/dist/consolidate/run.js

@@ -1,46 +1,15 @@
-import { openHippoDb, closeHippoDb, ftsRowCounts, isFtsAvailable, repairFtsDrift } from '../db.js';
-import { NO_MERGE_TAGS } from '../shared.js';
+import { ftsDrift } from '../store/entry-row.js';
+import { NO_MERGE_TAGS } from '../sharing/shared.js';
 export const REPLAY_COUNT_DEFAULT = 5;
 export function keptAsWritten(entry) {
     return entry.tags.some((tag) => NO_MERGE_TAGS.has(tag));
 }
-// Auto-promote (1.4) and merge (3) write deterministic content through the guard's bypass, so both
-// need this tombstone check. Lazy so a sleep reaching neither never opens it; call it IMMEDIATELY
-// before the try whose finally closes it, so a throw in any phase cannot leak the handle.
-export function lazyConsolidateDb(hippoRoot, dryRun) {
-    let consolidateDbHandle = null;
-    let consolidateDbOpened = false;
-    const get = () => {
-        if (dryRun)
-            return null;
-        if (!consolidateDbOpened) {
-            consolidateDbHandle = openHippoDb(hippoRoot);
-            consolidateDbOpened = true;
-        }
-        return consolidateDbHandle;
-    };
-    const close = () => {
-        if (consolidateDbHandle)
-            closeHippoDb(consolidateDbHandle);
-    };
-    return { get, close };
-}
 /** Re-syncs the full-text index with `memories`; a store open that is already current no longer counts the two. */
 export function syncFtsIndex(hippoRoot, dryRun, result) {
-    const db = openHippoDb(hippoRoot);
-    try {
-        if (!isFtsAvailable(db))
-            return;
-        const counts = ftsRowCounts(db);
-        if (counts === null || counts.memories === counts.fts)
-            return;
-        if (!dryRun)
-            repairFtsDrift(db);
-        result.details.push(`  🔎 ${dryRun ? 'would re-sync' : 're-synced'} the full-text index (${counts.fts} indexed rows for ${counts.memories} memories)`);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const counts = ftsDrift(hippoRoot, !dryRun);
+    if (counts === null)
+        return;
+    result.details.push(`  🔎 ${dryRun ? 'would re-sync' : 're-synced'} the full-text index (${counts.fts} indexed rows for ${counts.memories} memories)`);
 }
 export function newConsolidationResult(dryRun) {
     return {

package/dist/consolidate/sleep.d.ts

@@ -6,7 +6,7 @@
  * 2. Merge pass  - find episodic entries with high text overlap, create semantic summaries
  * 3. Stats tracking
  */
-import { type WriteBudget } from '../write-budget.js';
+import { type WriteBudget } from '../util/write-budget.js';
 import { type ConsolidationResult } from './run.js';
 /**
  * Run a full consolidation pass.

package/dist/consolidate/sleep.js

@@ -6,28 +6,29 @@
  * 2. Merge pass  - find episodic entries with high text overlap, create semantic summaries
  * 3. Stats tracking
  */
-import { evalNow } from '../ablation.js';
-import { canAutoDelete } from '../memory.js';
+import { evalNow } from '../core/ablation.js';
+import { canAutoDelete } from '../core/memory.js';
 import { loadAllEntries } from '../store/entry-reads.js';
-import { batchWriteAndDeleteOn, memoriesBackingObjects, noteFailedUnit } from '../store/delete-and-batch.js';
-import { openStore } from '../store/open.js';
+import { commitInChunks, memoriesBackingObjects } from '../store/delete-and-batch.js';
 import { appendConsolidationRun, loadSessionDecayContext, incrementSleepCount } from '../store/index-and-stats.js';
 import { replaceDetectedConflicts } from '../store/conflicts.js';
-import { openHippoDb, closeHippoDb, SLEEP_DB_WAIT_MS } from '../db.js';
-import { deleteExpiredDormantRow, expiredDormantKeys } from '../dormant.js';
-import { loadConfig } from '../config.js';
-import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from '../half-life-migration.js';
-import { log } from '../log.js';
-import { WRITE_BUDGET } from '../write-budget.js';
+import { SLEEP_DB_WAIT_MS } from '../db/index.js';
+import { expireDormantBefore } from '../store/dormant.js';
+import { loadConfig } from '../core/config.js';
+import { recordAuditEventsRowByRow, reportAuditWriteFailure } from '../store/audit.js';
+import { lazyTombstoneChecks } from '../store/tombstone-checks.js';
+import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from './half-life-migration.js';
+import { errorMessage, log } from '../util/log.js';
+import { WRITE_BUDGET } from '../util/write-budget.js';
 import { decayPass } from './decay.js';
 import { familyUnits, groupFlush } from './flush-units.js';
 import { retireHeldTexts, mergePass } from './merge.js';
 import { detectConflicts } from './conflicts.js';
-import { lazyConsolidateDb, newConsolidationResult, syncFtsIndex } from './run.js';
+import { newConsolidationResult, syncFtsIndex } from './run.js';
 import { promoteSessionTraces, replayPass } from './traces.js';
 import { llmPasses } from './llm-passes.js';
 import { physicsPass } from './physics-pass.js';
+import { DAY_MS } from '../util/time.js';
 /**
  * Run a full consolidation pass.
  */
@@ -47,18 +48,11 @@ export async function consolidate(hippoRoot, options = {}) {
     // Retirable: auto-deletable (never pinned, raw or kept for good) and not backing a first-class object.
     const retirable = (entry) => canAutoDelete(entry) && !backingObjects.has(entry.id);
     const snapshot = new Map(structuredClone(all).map((e) => [e.id, e]));
-    // Load decay options from config + session context
     const config = loadConfig(hippoRoot);
-    const sessionCtx = loadSessionDecayContext(hippoRoot);
-    const decayOpts = {
-        decayBasis: config.decayBasis,
-        avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
-        sleepCount: sessionCtx.sleepCount,
-    };
-    const consolidateDb = lazyConsolidateDb(hippoRoot, dryRun);
+    const decayOpts = sessionDecayOptions(hippoRoot, config);
     const run = {
         hippoRoot, now, dryRun, config, decayOpts, result, all, retirable,
-        getConsolidateDb: consolidateDb.get,
+        tombstones: lazyTombstoneChecks(hippoRoot, dryRun),
         survivors: [],
         // Collect all writes/deletes and batch them at the end
         pendingWrites: [],
@@ -67,30 +61,43 @@ export async function consolidate(hippoRoot, options = {}) {
         units: [],
     };
     const decay = decayPass(run);
+    await runPassesAfterDecay(run, options.fetcher);
+    const budget = options.budget ?? WRITE_BUDGET;
+    await flushPending(run, snapshot, budget);
+    await expireDormant(run, budget);
+    if (!dryRun)
+        logRun(run, decay);
+    return result;
+}
+// Load decay options from config + session context
+function sessionDecayOptions(hippoRoot, config) {
+    const sessionCtx = loadSessionDecayContext(hippoRoot);
+    return {
+        decayBasis: config.decayBasis,
+        avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
+        sleepCount: sessionCtx.sleepCount,
+    };
+}
+/** Every pass between decay and the flush; the tombstone-check handle closes whichever of them throws. */
+async function runPassesAfterDecay(run, fetcher) {
     let mergesSkippedRejected = 0;
     try {
         promoteSessionTraces(run);
         replayPass(run);
-        await llmPasses(run, options.fetcher);
+        await llmPasses(run, fetcher);
         physicsPass(run);
         retireHeldTexts(run);
         mergesSkippedRejected = mergePass(run);
     }
     finally {
-        consolidateDb.close();
+        run.tombstones.close();
     }
     if (mergesSkippedRejected > 0) {
         log.warn(`consolidate: skipped ${mergesSkippedRejected} merge(s) whose content matches a rejected value`);
     }
-    const budget = options.budget ?? WRITE_BUDGET;
-    await flushPending(run, snapshot, budget);
-    await expireDormant(run, budget);
-    if (!dryRun)
-        logRun(run, decay);
-    return result;
 }
 // A changed default half-life moves memories still on the old base first,
-// so this pass decays them at the new one (src/half-life-migration.ts).
+// so this pass decays them at the new one (src/consolidate/half-life-migration.ts).
 function migrateHalfLives(hippoRoot, dryRun, result) {
     const halfLife = migrateDefaultHalfLife(hippoRoot, loadConfig(hippoRoot).defaultHalfLifeDays, { dryRun });
     if (halfLife.rescaled > 0) {
@@ -108,7 +115,8 @@ async function flushPending(run, snapshot, budget) {
         return;
     const units = [...run.units, ...familyUnits(pendingWrites, pendingDeletes, pendingDormant, snapshot)];
     const components = groupFlush(pendingWrites, pendingDeletes, pendingDormant, units);
-    const left = new Set(await commitInChunks(run.hippoRoot, components, snapshot, budget));
+    // The snapshot keeps what the DAG passes and other writers changed while sleep ran; the wait is sleep's own, not a server request's 250 ms.
+    const left = new Set(await commitInChunks(run.hippoRoot, components, { snapshot, budget, busyWaitMs: SLEEP_DB_WAIT_MS }));
     for (const id of [...pendingDeletes, ...pendingDormant.map((m) => m.entry.id)]) {
         if (!left.has(id))
             result.details.push(`  ↩  ${id} not removed: pinned or already gone before sleep saved`);
@@ -117,67 +125,6 @@ async function flushPending(run, snapshot, budget) {
     result.removed = result.removedIds.length;
     result.dormant = pendingDormant.filter((m) => left.has(m.entry.id)).length;
 }
-/** Commits whole components in transactions of about `budget.holdMs`, letting other writers in between; returns the ids that left `memories`.
- *  The snapshot keeps what the DAG passes and other writers changed while sleep ran. */
-async function commitInChunks(hippoRoot, components, snapshot, budget) {
-    if (components.length === 0)
-        return [];
-    const removed = [];
-    // Its own wait, not a server request's 250 ms, and an option rather than a PRAGMA so a shared hook handle keeps its own.
-    const db = openStore(hippoRoot, { busyWaitMs: SLEEP_DB_WAIT_MS });
-    let next = 0;
-    try {
-        let committedAt = 0;
-        while (next < components.length) {
-            if (next > 0)
-                await budget.pause(committedAt);
-            const chunk = batchWriteAndDeleteOn(db, hippoRoot, components, next, { snapshot, holdMs: budget.holdMs, clock: budget.clock });
-            committedAt = budget.clock();
-            next = chunk.next;
-            for (const id of chunk.removedIds)
-                removed.push(id);
-        }
-    }
-    catch (err) {
-        // A unit that threw is already tagged; a throw outside one (a pause, BEGIN or COMMIT) names the chunk's first unit.
-        if (err instanceof Error)
-            noteFailedUnit(err, components[next]);
-        throw err;
-    }
-    finally {
-        closeHippoDb(db);
-    }
-    return removed;
-}
-/** Deletes `keys` in transactions of about `budget.holdMs`, letting other writers in between; returns how many went. */
-async function expireInChunks(db, keys, cutoff, budget) {
-    let gone = 0;
-    let next = 0;
-    let committedAt = 0;
-    while (next < keys.length) {
-        if (next > 0)
-            await budget.pause(committedAt);
-        db.exec('BEGIN IMMEDIATE');
-        const begunAt = budget.clock();
-        try {
-            do
-                gone += deleteExpiredDormantRow(db, keys[next++], cutoff);
-            while (next < keys.length && budget.clock() - begunAt < budget.holdMs);
-            db.exec('COMMIT');
-        }
-        catch (err) {
-            if (db.isTransaction !== false) {
-                try {
-                    db.exec('ROLLBACK');
-                }
-                catch { /* preserve the original throw */ }
-            }
-            throw err;
-        }
-        committedAt = budget.clock();
-    }
-    return gone;
-}
 // Dormant retention: a dormant memory nobody restored within
 // dormant.retentionDays is deleted for good (0 keeps them forever). Runs
 // even when dormant.enabled is off, so turning it off still ages out what
@@ -186,16 +133,8 @@ async function expireDormant(run, budget) {
     const { config, result, dryRun } = run;
     if (!(config.dormant.retentionDays > 0))
         return;
-    const cutoff = new Date(run.now.getTime() - config.dormant.retentionDays * 24 * 60 * 60 * 1000).toISOString();
-    const db = openHippoDb(run.hippoRoot, { busyWaitMs: SLEEP_DB_WAIT_MS });
-    try {
-        // The keys come from a read, so a sleep with nothing to expire never takes the write lock; one DELETE scanned every stored entry under it.
-        const keys = expiredDormantKeys(db, cutoff);
-        result.dormantExpired = dryRun ? keys.length : await expireInChunks(db, keys, cutoff, budget);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const cutoff = new Date(run.now.getTime() - config.dormant.retentionDays * DAY_MS).toISOString();
+    result.dormantExpired = await expireDormantBefore(run.hippoRoot, cutoff, { dryRun, budget, busyWaitMs: SLEEP_DB_WAIT_MS });
     if (result.dormantExpired > 0) {
         result.details.push(`  ⌛ ${dryRun ? 'would expire' : 'expired'} ${result.dormantExpired} dormant memor${result.dormantExpired === 1 ? 'y' : 'ies'} older than ${config.dormant.retentionDays} days`);
     }
@@ -223,41 +162,32 @@ function logRun(run, decay) {
 // One audit row per rescue, written only after the last flush chunk commits, so a run stopped mid-flush asserts no rescue.
 function auditRescues(run, { rescuedEntries, rankById }) {
     const { result } = run;
+    const rescueEvent = (entry) => {
+        const rank = rankById.get(entry.id);
+        return {
+            tenantId: entry.tenantId,
+            actor: 'sleep',
+            op: 'mv_rescue',
+            targetId: entry.id,
+            metadata: rank
+                ? { rank: rank.rank, totalNonPinned: rank.totalNonPinned, keepN: rank.keepN, score: rank.score }
+                : {},
+        };
+    };
     try {
-        const auditDb = openHippoDb(run.hippoRoot);
-        try {
-            // Per-row try/catch: one failed appendAuditEvent must not silently drop every remaining row.
-            let auditFailures = 0;
-            for (const entry of rescuedEntries) {
-                try {
-                    const rank = rankById.get(entry.id);
-                    appendAuditEvent(auditDb, {
-                        tenantId: entry.tenantId,
-                        actor: 'sleep',
-                        op: 'mv_rescue',
-                        targetId: entry.id,
-                        metadata: rank
-                            ? { rank: rank.rank, totalNonPinned: rank.totalNonPinned, keepN: rank.keepN, score: rank.score }
-                            : {},
-                    });
-                }
-                catch (error) {
-                    auditFailures++;
-                    reportAuditWriteFailure('mv_rescue', String(error), entry.id);
-                }
-            }
-            if (auditFailures > 0) {
-                result.details.push(`  ⚠️ memory-value: ${auditFailures} mv_rescue audit row${auditFailures === 1 ? '' : 's'} ` +
-                    `failed to write (the rescue itself still landed)`);
-            }
-        }
-        finally {
-            closeHippoDb(auditDb);
+        // Row by row: one failed audit write must not silently drop every remaining row.
+        const failed = recordAuditEventsRowByRow(run.hippoRoot, rescuedEntries.map(rescueEvent));
+        for (const { event, error } of failed)
+            reportAuditWriteFailure('mv_rescue', String(error), event.targetId);
+        const auditFailures = failed.length;
+        if (auditFailures > 0) {
+            result.details.push(`  ⚠️ memory-value: ${auditFailures} mv_rescue audit row${auditFailures === 1 ? '' : 's'} ` +
+                `failed to write (the rescue itself still landed)`);
         }
     }
-    catch {
-        // openHippoDb/closeHippoDb-level failure: audit must never crash a
-        // mutation (mirrors store.ts's audit() posture).
+    catch (err) {
+        // An audit store that will not open must never crash the mutation it records.
+        log.debug(`mv_rescue audit unavailable: ${errorMessage(err)}`);
         result.details.push(`  ⚠️ memory-value: mv_rescue audit unavailable this cycle ` +
             `(${rescuedEntries.length} rescue${rescuedEntries.length === 1 ? '' : 's'} not audited)`);
     }

package/dist/{trace.js → consolidate/trace.js}

@@ -5,7 +5,8 @@
  * sequence of agent actions and their final outcome. v1 stores steps as
  * markdown in `content`; `renderTraceContent` is the canonical formatter.
  */
-import { isJsonString } from './json.js';
+import { isJsonString, isJsonObject } from '../util/json.js';
+import { errorMessage } from '../util/log.js';
 /**
  * Render a trace record as agent-readable markdown.
  *
@@ -30,9 +31,6 @@ export function renderTraceContent(rec) {
     });
     return lines.join('\n');
 }
-function isJsonRecord(value) {
-    return value !== null && !Array.isArray(value) && typeof value === 'object';
-}
 /**
  * Parse a JSON string into an array of TraceStep. Throws on invalid shape.
  */
@@ -42,13 +40,13 @@ export function parseSteps(json) {
         parsed = JSON.parse(json);
     }
     catch (err) {
-        throw new Error(`Invalid trace steps JSON: ${err instanceof Error ? err.message : String(err)}`);
+        throw new Error(`Invalid trace steps JSON: ${errorMessage(err)}`, { cause: err });
     }
     if (!Array.isArray(parsed)) {
         throw new Error('trace steps must be an array');
     }
     return parsed.map((s, i) => {
-        if (!isJsonRecord(s)) {
+        if (!isJsonObject(s)) {
             throw new Error(`trace step ${i}: not an object`);
         }
         const action = s.action;

package/dist/consolidate/traces.js

@@ -1,15 +1,16 @@
-import { isRecallBoostAblated } from '../ablation.js';
-import { Layer, createMemory, markRetrieved } from '../memory.js';
+import { isRecallBoostAblated } from '../core/ablation.js';
+import { Layer, createMemory, markRetrieved } from '../core/memory.js';
 import { findPromotableSessions, traceExistsForSession, listSessionEvents } from '../store/sessions.js';
-import { rejectionDigest, findRejectedValue } from '../rejection.js';
-import { sampleForReplay } from '../replay.js';
-import { renderTraceContent } from '../trace.js';
-import { resolveTenantId } from '../tenant.js';
-import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import { commonDerivationScope } from '../recall-scope.js';
-import { log } from '../log.js';
+import { rejectionDigest } from '../store/rejection.js';
+import { sampleForReplay } from './replay.js';
+import { renderTraceContent } from './trace.js';
+import { resolveTenantId } from '../store/tenant.js';
+import { reportAuditWriteFailure } from '../store/audit.js';
+import { commonDerivationScope } from '../store/recall-scope.js';
+import { log } from '../util/log.js';
 import { REPLAY_COUNT_DEFAULT } from './run.js';
-import { isJsonString } from '../json.js';
+import { isJsonString } from '../util/json.js';
+import { DAY_MS } from '../util/time.js';
 // -------------------------------------------------------------------------
 // 1.4. Auto-promote complete sessions to traces
 // -------------------------------------------------------------------------
@@ -24,7 +25,7 @@ export function promoteSessionTraces(run) {
         return;
     let tracesSkippedRejected = 0;
     const windowDays = run.config.autoTraceWindowDays ?? 7;
-    const sinceMs = run.now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+    const sinceMs = run.now.getTime() - windowDays * DAY_MS;
     // Auto-trace runs single-tenant (the env-resolved tenant); consolidating
     // every tenant needs a per-tenant loop layered on top of this.
     const consolidationTenant = resolveTenantId({});
@@ -66,23 +67,13 @@ function sessionTrace(run, consolidationTenant, sessionId) {
         run.result.details.push(`  ⏭  skipped session ${sessionId}: events span mixed scopes`);
         return null;
     }
-    const completeEvent = events.find((e) => e.event_type === 'session_complete');
-    if (!completeEvent)
-        return null; // defence-in-depth; findPromotableSessions filters already.
-    const outcomeRaw = completeEvent.content;
-    if (outcomeRaw !== 'success' && outcomeRaw !== 'failure' && outcomeRaw !== 'partial') {
-        // Malformed terminal event — skip rather than crash the whole sleep.
+    const ending = sessionEnding(events);
+    if (!ending)
         return null;
-    }
-    const outcome = outcomeRaw;
+    const { outcome, summary } = ending;
     const steps = events
         .filter((e) => e.event_type !== 'session_complete')
         .map((e) => ({ action: e.content, observation: '' }));
-    // SAFETY: session event metadata is a free-form Record<string, unknown>
-    // bag; summary is optional and is only trusted once isJsonString below
-    // confirms it is actually a string.
-    const summaryValue = completeEvent.metadata.summary;
-    const summary = isJsonString(summaryValue) ? summaryValue : '(untitled)';
     const trace = createMemory(renderTraceContent({ task: summary, steps, outcome }), {
         layer: Layer.Trace,
         trace_outcome: outcome,
@@ -97,18 +88,32 @@ function sessionTrace(run, consolidationTenant, sessionId) {
     });
     return { trace, outcome };
 }
+/** The outcome and title a session's terminal event carries, or null when it has none or the event is malformed. */
+function sessionEnding(events) {
+    const completeEvent = events.find((e) => e.event_type === 'session_complete');
+    if (!completeEvent)
+        return null; // defence-in-depth; findPromotableSessions filters already.
+    const outcomeRaw = completeEvent.content;
+    if (outcomeRaw !== 'success' && outcomeRaw !== 'failure' && outcomeRaw !== 'partial') {
+        // Malformed terminal event — skip rather than crash the whole sleep.
+        return null;
+    }
+    // SAFETY: session event metadata is a free-form Record<string, unknown>
+    // bag; summary is optional and is only trusted once isJsonString below
+    // confirms it is actually a string.
+    const summaryValue = completeEvent.metadata.summary;
+    const summary = isJsonString(summaryValue) ? summaryValue : '(untitled)';
+    return { outcome: outcomeRaw, summary };
+}
 // traceExistsForSession only sees live rows, so a removed rejected trace would regenerate every
 // sleep; check the tombstone under the entry's own stamped tenantId, never a guessed one.
 function traceRejected(run, trace, sessionId) {
-    const consolidateDb = run.getConsolidateDb();
-    if (!consolidateDb)
-        return false;
     const traceDigest = rejectionDigest(trace.content);
-    const tombstone = findRejectedValue(consolidateDb, trace.tenantId, traceDigest);
+    const tombstone = run.tombstones.find(trace.tenantId, traceDigest);
     if (!tombstone)
         return false;
     try {
-        appendAuditEvent(consolidateDb, {
+        run.tombstones.audit({
             tenantId: trace.tenantId,
             actor: 'sleep',
             op: 'reject_refusal',