hippo-memory 1.70.0 → 1.72.0

package/dist/capture/compaction-record.js

@@ -1,54 +1,20 @@
-// One record per Claude Code compaction, and what turns its summary into kept memories.
+// What turns a compaction's summary into text the store keeps; the SQL is src/store/compactions-record.ts.
 import * as fs from 'fs';
-import * as path from 'path';
-import { ConflictError } from '../core/api-errors.js';
 import { isStringValue } from '../core/capture-contract.js';
-import { COMPACTION_ITEM_MAX_CHARS, compactSummaryBody, parseCompactionItems, selectItemRows } from './compaction-items.js';
+import { COMPACTION_ITEM_MAX_CHARS, compactSummaryBody, parseCompactionItems } from '../util/compaction-items.js';
 import { importSpool, spool } from './compaction-spool.js';
-import { isSharedStore, loadConfig } from '../core/config.js';
-import { closeHippoDb, isSqliteBusy, openHippoDb, withWriteScopeOr } from '../db/index.js';
-import { gatedWrite } from '../trust/gated-write.js';
-import { COMPACTION_MEMORY_TAG, COMPACTION_SOURCE_PREFIX, Layer, createMemory, generateId } from '../core/memory.js';
-import { fallbackOrigin, isGlobalStoreRoot, projectId, projectNames, resolveProjectIdentity } from '../core/project-identity.js';
-import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
-import { closeStartedWithoutSummary, compactionProgress, compactionRowsByRequest, heldMemoryRows, insertStartedCompaction, insertSummarisedCompaction, latestCompactionRows, latestStartedRows, markCompactionDone, markCompactionSummarised, markSnapshotSavedRow, nextCompactionStart, openTranscriptRows, stalledSummarisedRows, } from '../store/compactions.js';
-import { strengthenRetrievedOn, writeEntryMirrors } from '../store/entry-writes.js';
-import { isRecallBoostAblated } from '../core/ablation.js';
-import { updateStats } from '../store/index-and-stats.js';
+import { replayStoredCompactions, saveCompactionAt, } from '../store/compactions-record.js';
 import { resolveTenantId } from '../store/tenant.js';
-import { errorMessage, log as logger } from '../util/log.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { errorMessage, reportCompactionFailure } from '../util/log.js';
 import { readTranscriptTail, truncateCodePointSafe } from '../util/transcript-tail.js';
-/** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
-export const COMPACTION_DB_WAIT_MS = 2000;
 /** Tested verbatim: Claude Code hands PreCompact stdout to the summariser as instructions. */
-export const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out anything an earlier summary already listed under 'Memories for hippo', and anything this session already saved with `hippo remember`. Write '- none' if nothing new remains.";
+export const PRE_COMPACT_INSTRUCTION = "In your summary, add a last section titled 'Memories for hippo'. List, one per line starting with '- ', each lesson learned, decision made (with its " +
+    "reason) and correction the user gave in this session that should outlive it. Write each as a standalone sentence that names its subject. Leave out " +
+    "anything an earlier summary already listed under 'Memories for hippo', and anything this session already saved with `hippo remember`. Write '- none' " +
+    "if nothing new remains.";
 const SUMMARY_MAX_CHARS = 256 * 1024;
-/** Long enough that a live hook has finished with its own record. */
-export const REPLAY_AFTER_MS = 10 * 60_000;
-/** Claude Code deletes transcripts after 30 days, so an older gap can never be filled. */
-export const TRANSCRIPT_FILL_WINDOW_MS = 30 * 24 * 60 * 60_000;
 const TRANSCRIPT_TAIL_CAPS = [1 << 20, 8 << 20, 64 << 20];
-/** The marker redactSecretsStrict writes; an item holding it was a secret before it was stored. */
-const REDACTED = '[REDACTED]';
-/** Where the session ran: rows written through the global store or a shared store keep the project the session was in. */
-function compactionProject(hippoRoot, cwd) {
-    if (!isGlobalStoreRoot(hippoRoot) && !isSharedStore(hippoRoot))
-        return resolveProjectIdentity(path.dirname(hippoRoot));
-    // No cwd means user-global, as stampOriginProject gives the global store; undefined would fall back to the hook's own cwd.
-    return cwd === null ? '' : resolveProjectIdentity(cwd);
-}
-/** The record column cannot hold NULL, but an item from an unknown folder on a shared store must not read as user-global. */
-function itemOrigin(hippoRoot, ctx) {
-    return ctx.cwd === null && isSharedStore(hippoRoot) ? fallbackOrigin(hippoRoot) : ctx.originProject;
-}
-function compactionOrigin(hippoRoot, cwd) {
-    return projectId(compactionProject(hippoRoot, cwd));
-}
-/** The names a record's held rows may carry: its origin, plus the folder name rows saved before project ids used. */
-function heldOrigins(hippoRoot, cwd, originProject) {
-    const names = projectNames(compactionProject(hippoRoot, cwd));
-    return names.includes(originProject) ? names : [originProject];
-}
 function scrub(text) {
     return maskEmails(redactSecretsStrict(text));
 }
@@ -58,297 +24,34 @@ export function readCompactionText(compactSummary) {
     const parsed = parseCompactionItems(body);
     return { summary: truncateCodePointSafe(scrub(body), SUMMARY_MAX_CHARS), items: parsed.items.map(scrub), found: parsed.found };
 }
-/** A caller's items scrubbed as readCompactionText scrubs a summary's, since another machine's scrub is not trusted; cut after it, as a mask can run longer than what it hides. */
+/** A caller's items scrubbed as readCompactionText scrubs a summary's, since another machine's scrub is not trusted; cut after it, as a
+ * mask can run longer than what it hides. */
 export function scrubCompactionItems(items) {
     return items.map((item) => truncateCodePointSafe(scrub(item), COMPACTION_ITEM_MAX_CHARS));
 }
-function toRecord(row) {
-    const listed = row.items_json === null ? [] : JSON.parse(row.items_json);
-    return {
-        id: row.id,
-        tenantId: row.tenant_id,
-        sessionId: row.session_id,
-        originProject: row.origin_project,
-        trigger: row.compact_trigger,
-        cwd: row.cwd,
-        transcriptPath: row.transcript_path,
-        snapshotSaved: row.snapshot_saved === 1,
-        startedAt: row.started_at,
-        summarisedAt: row.summarised_at,
-        summary: row.summary,
-        items: Array.isArray(listed) ? listed.filter(isStringValue) : [],
-        itemsWritten: row.items_written,
-        status: row.status,
-    };
-}
-export function startCompaction(db, tenantId, start, at = new Date()) {
-    const id = generateId('cmp');
-    insertStartedCompaction(db, tenantId, { id, ...start, startedAt: at.toISOString() });
-    return id;
-}
-/** A session's newest record, or null. */
-export function latestCompaction(db, tenantId, sessionId) {
-    return latestCompactionRows(db, tenantId, sessionId).map(toRecord)[0] ?? null;
-}
-/** The record a caller's request made, whatever state it reached, so a retry neither writes its items twice nor starts a second record; another session's id is a ConflictError. */
-export function compactionByRequest(db, tenantId, requestId, sessionId) {
-    const record = compactionRowsByRequest(db, tenantId, requestId).map(toRecord)[0] ?? null;
-    // Sessions are owner-bound, so this also keeps one owner from reading or finishing another's record.
-    if (record !== null && record.sessionId !== sessionId)
-        throw new ConflictError('request id belongs to another session');
-    return record;
-}
-/** Pre-compact's record for the compaction that is ending: the session's newest `started` one within REPLAY_AFTER_MS before `at`, so an older one is left for the transcript fill. */
-function latestStarted(db, tenantId, sessionId, at) {
-    return latestStartedRows(db, tenantId, sessionId, at.toISOString(), new Date(at.getTime() - REPLAY_AFTER_MS).toISOString()).map(toRecord)[0] ?? null;
-}
-function markSummarised(db, tenantId, id, options) {
-    const { text, summarisedAt, requestId } = options;
-    return markCompactionSummarised(db, tenantId, id, { summary: text.summary, itemsJson: JSON.stringify(text.items), summarisedAt, requestId });
-}
-/** Best effort, never throws: a compaction must not fail because its record could not be written. */
-export function recordCompactionStart(hippoRoot, start, log) {
-    let db;
-    try {
-        db = openHippoDb(hippoRoot, { busyWaitMs: COMPACTION_DB_WAIT_MS });
-        return startCompaction(db, resolveTenantId({}), { ...start, originProject: compactionOrigin(hippoRoot, start.cwd) });
-    }
-    catch (err) {
-        log(`compaction record not started: ${errorMessage(err)}`);
-        return null;
-    }
-    finally {
-        if (db)
-            closeHippoDb(db);
-    }
-}
-/** On the caller's handle and tenant, so a server marks the record under the caller's tenant with its own wait. */
-export function markSnapshotSaved(db, tenantId, recordId) {
-    markSnapshotSavedRow(db, tenantId, recordId);
-}
-export function recordSnapshotSaved(hippoRoot, tenantId, recordId, log) {
-    let db;
+function spoolSummary(hippoRoot, payload, text, at, reason, result, log) {
     try {
-        db = openHippoDb(hippoRoot, { busyWaitMs: COMPACTION_DB_WAIT_MS });
-        markSnapshotSaved(db, tenantId, recordId);
-    }
-    catch (err) {
-        log(`compaction record not marked with its snapshot: ${errorMessage(err)}`);
-    }
-    finally {
-        if (db)
-            closeHippoDb(db);
-    }
-}
-/** Puts the summary on the session's `started` record, or inserts a `summarised` one when pre-compact wrote none. One statement each. */
-export function recordSummary(db, hippoRoot, tenantId, options) {
-    const { meta, text, at, caller = {} } = options;
-    const now = new Date().toISOString();
-    const itemsJson = JSON.stringify(text.items);
-    const { requestId } = caller;
-    const started = latestStarted(db, tenantId, meta.sessionId, at);
-    if (started && markSummarised(db, tenantId, started.id, { text, summarisedAt: now, requestId })) {
-        return { ...started, summary: text.summary, items: text.items, summarisedAt: now, status: 'summarised' };
-    }
-    const originProject = caller.originProject ?? compactionOrigin(hippoRoot, meta.cwd);
-    const id = generateId('cmp');
-    insertSummarisedCompaction(db, tenantId, { ...meta, originProject, startedAt: at.toISOString() }, { id, summary: text.summary, itemsJson, summarisedAt: now, requestId });
-    return {
-        id, tenantId, sessionId: meta.sessionId, originProject, trigger: meta.trigger, cwd: meta.cwd, transcriptPath: meta.transcriptPath,
-        snapshotSaved: false, startedAt: at.toISOString(), summarisedAt: now, summary: text.summary, items: text.items, itemsWritten: 0, status: 'summarised',
-    };
-}
-/** Words whose loss reverses or narrows a statement: "do not", "can't", "only", "unless". */
-const PROTECTED_WORDS = new Set(['not', 'no', 'never', 'none', 'nor', 'without', 'cannot', 't', 'only', 'except', 'unless', 'until']);
-/** Below this share of the held text's words, an item is a fragment of something longer, not a restatement. */
-const RESTATE_MIN_SHARE = 0.5;
-function words(text) {
-    return text.normalize('NFC').toLowerCase().split(/[^\p{L}\p{M}\p{N}_]+/u).filter(Boolean);
-}
-/** True when `item` is `held` with words left out, in the same order, keeping every number and protected word. Spacing, case and punctuation may differ. */
-function restates(item, held) {
-    if (item.length === 0 || item.length < RESTATE_MIN_SHARE * held.length)
-        return false;
-    const kept = new Set(item);
-    let next = 0;
-    for (const w of held) {
-        if (next < item.length && w === item[next])
-            next++;
-        else if (!kept.has(w) && (PROTECTED_WORDS.has(w) || /\p{N}/u.test(w)))
-            return false;
-    }
-    return next === item.length;
-}
-/** Live rows of one tenant and origin that default recall shows: a compaction often restates what an earlier one, or the user, already saved. */
-function heldRows(db, tenantId, origins) {
-    return heldMemoryRows(db, tenantId, origins).map((r) => ({ id: r.id, sessionId: r.source_session_id, words: words(r.content) }));
-}
-function compactionEntry(text, ctx, origin, baseHalfLifeDays) {
-    return {
-        ...createMemory(text, {
-            layer: Layer.Episodic,
-            tags: [COMPACTION_MEMORY_TAG],
-            source: `${COMPACTION_SOURCE_PREFIX}${ctx.sessionId}`,
-            confidence: 'observed',
-            kind: 'distilled',
-            source_session_id: ctx.sessionId,
-            tenantId: ctx.tenantId,
-            baseHalfLifeDays,
-        }),
-        origin_project: origin,
-    };
-}
-/** Runs inside saveItems' transaction: restatements of held rows are counted, the rest go through the write gate. */
-function writeItemRows(db, hippoRoot, ctx, rows, baseHalfLifeDays) {
-    const out = { written: [], repeats: 0, refused: 0, restated: [] };
-    const held = heldRows(db, ctx.tenantId, ctx.caller?.origins ?? heldOrigins(hippoRoot, ctx.cwd, ctx.originProject));
-    const origin = ctx.caller === undefined ? itemOrigin(hippoRoot, ctx) : ctx.originProject;
-    const restated = new Set();
-    for (const text of rows) {
-        const itemWords = words(text);
-        const match = held.find((h) => restates(itemWords, h.words));
-        if (match) {
-            out.repeats++;
-            if (match.id !== null && match.sessionId !== ctx.sessionId)
-                restated.add(match.id);
-            continue;
-        }
-        // createMemory throws below 3 chars, which would sink the whole transaction.
-        if (text.trim().length < 3) {
-            out.refused++;
-            continue;
-        }
-        const entry = compactionEntry(text, ctx, origin, baseHalfLifeDays);
-        if (gatedWrite(db, hippoRoot, entry, { actor: ctx.caller?.actor ?? 'post-compact' }) === 'written') {
-            out.written.push(entry);
-            held.push({ id: null, sessionId: ctx.sessionId, words: itemWords });
-        }
-        else {
-            out.refused++;
-        }
-    }
-    out.restated = [...restated];
-    return out;
-}
-/** After commit: report skips, mirror the new rows, bump the counter. */
-function finishItemWrites(hippoRoot, writes, log) {
-    if (writes.repeats > 0)
-        log(`skipped ${writes.repeats} item(s) the store already holds`);
-    if (writes.refused > 0)
-        log(`skipped ${writes.refused} item(s) the write gate refused`);
-    for (const entry of writes.written)
-        writeEntryMirrors(hippoRoot, entry);
-    if (writes.written.length > 0) {
-        try {
-            updateStats(hippoRoot, { remembered: writes.written.length });
-        }
-        catch (err) {
-            // The rows are committed; a counter that could not be bumped must not turn that into a failed step.
-            log(`remembered counter not updated: ${errorMessage(err)}`);
-        }
+        spool(hippoRoot, resolveTenantId({}), payload, text, at);
+        result.deferred = true;
+        log(`store busy, summary spooled: ${reason}`);
     }
-}
-/** Items that become rows, then the record `done`, in one transaction so two sessions cannot both insert one text. Mirrors after commit. */
-export function saveItems(db, hippoRoot, ctx, log) {
-    const usable = ctx.items.filter((item) => !item.includes(REDACTED));
-    if (usable.length < ctx.items.length)
-        log(`skipped ${ctx.items.length - usable.length} item(s) as secret`);
-    const { rows, tooLong, capped } = selectItemRows(usable);
-    if (tooLong > 0)
-        log(`item too long: ${tooLong} kept in the record only`);
-    if (capped > 0)
-        log(`capped: ${capped} more kept in the record only`);
-    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
-    let finishedItems = 0;
-    const writes = withWriteScopeOr(db, 'save_items', (rollback) => {
-        if (ctx.recordId !== null) {
-            // A replayer that read the record before another finished it must not write its items again.
-            const current = compactionProgress(db, ctx.tenantId, ctx.recordId);
-            if (current?.status !== 'summarised') {
-                finishedItems = current?.items_written ?? 0;
-                return rollback(null);
-            }
-        }
-        const written = writeItemRows(db, hippoRoot, ctx, rows, baseHalfLifeDays);
-        // Said again by another session is the same signal as being recalled; the same session carrying it forward is not.
-        strengthenRetrievedOn(db, written.restated, { tenantId: ctx.tenantId, recallBoostAblated: isRecallBoostAblated() });
-        if (ctx.recordId !== null) {
-            markCompactionDone(db, ctx.tenantId, ctx.recordId, written.written.length);
-        }
-        return written;
-    });
-    if (writes === null) {
-        log(`${ctx.recordId} was already finished by another process`);
-        return finishedItems;
+    catch (spoolErr) {
+        reportCompactionFailure(log, 'spool', errorMessage(spoolErr));
     }
-    finishItemWrites(hippoRoot, writes, log);
-    return writes.written.length;
 }
 /** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or defers. Never throws. */
 export function saveCompaction(hippoRoot, payload, log) {
-    const result = { written: null, deferred: false, snapshotSaved: false };
     if (payload.compactSummary === null) {
         log('skip: payload has no compact_summary');
-        return result;
+        return { written: null, deferred: false, snapshotSaved: false };
     }
     const at = new Date();
     const { found, ...text } = readCompactionText(payload.compactSummary);
     if (!found)
         log('no memories section');
-    let db;
-    try {
-        db = openHippoDb(hippoRoot, { busyWaitMs: COMPACTION_DB_WAIT_MS });
-        const tenantId = resolveTenantId({});
-        let record = null;
-        try {
-            record = recordSummary(db, hippoRoot, tenantId, { meta: payload, text, at });
-            result.snapshotSaved = record.snapshotSaved;
-        }
-        catch (err) {
-            if (isSqliteBusy(err))
-                throw err;
-            log(`record step failed: ${errorMessage(err)}`);
-            logger.error(`post-compact: record step failed: ${errorMessage(err)}`);
-        }
-        try {
-            result.written = saveItems(db, hippoRoot, {
-                tenantId,
-                recordId: record?.id ?? null,
-                sessionId: payload.sessionId,
-                originProject: record?.originProject ?? compactionOrigin(hippoRoot, payload.cwd),
-                cwd: payload.cwd,
-                items: text.items,
-            }, log);
-        }
-        catch (err) {
-            if (!isSqliteBusy(err) || record === null)
-                throw err;
-            // The record already holds the items; sleep finishes them.
-            result.deferred = true;
-            log(`store busy, items left for the next sleep: ${errorMessage(err)}`);
-        }
-    }
-    catch (err) {
-        if (isSqliteBusy(err) || db === undefined) {
-            try {
-                spool(hippoRoot, resolveTenantId({}), payload, text, at);
-                result.deferred = true;
-                log(`store busy, summary spooled: ${errorMessage(err)}`);
-            }
-            catch (spoolErr) {
-                log(`spool failed: ${errorMessage(spoolErr)}`);
-                logger.error(`post-compact: spool failed: ${errorMessage(spoolErr)}`);
-            }
-        }
-        else {
-            log(`items step failed: ${errorMessage(err)}`);
-            logger.error(`post-compact: items step failed: ${errorMessage(err)}`);
-        }
-    }
-    finally {
-        if (db)
-            closeHippoDb(db);
-    }
+    const { result, spoolReason } = saveCompactionAt(hippoRoot, payload, text, at, log);
+    if (spoolReason !== null)
+        spoolSummary(hippoRoot, payload, text, at, spoolReason, result, log);
     return result;
 }
 /** The one line PostCompact prints, or null when nothing was saved. */
@@ -393,89 +96,21 @@ function transcriptSummary(transcriptPath, afterMs, beforeMs) {
     }
     return null;
 }
-function closeWithoutSummary(db, tenantId, id, log) {
-    if (closeStartedWithoutSummary(db, tenantId, id) > 0)
-        log(`${id} closed as no-summary: its transcript holds no summary for it`);
-}
-function nextStartedAt(db, record) {
-    return nextCompactionStart(db, record.tenantId, record.sessionId, record.startedAt);
-}
-/** Records a spooled summary, then writes its items. */
-function spoolImporter(db, hippoRoot, log) {
-    return (spooled, recorded) => {
-        const record = recordSummary(db, hippoRoot, spooled.tenantId, { meta: spooled.payload, text: spooled.text, at: spooled.at });
-        // The record holds the items now, so the file is done even if the write below fails.
-        recorded();
-        saveItems(db, hippoRoot, { tenantId: spooled.tenantId, recordId: record.id, sessionId: record.sessionId, originProject: record.originProject, cwd: record.cwd, items: record.items }, log);
-    };
-}
-/** Finishes what a killed hook or a busy store left: `summarised` records, spool files, and `started` records the transcript can fill. Returns how many compactions it saved. */
-export function replayCompactions(db, hippoRoot, log, deadline = Number.POSITIVE_INFINITY) {
-    const tenantId = resolveTenantId({});
-    const now = Date.now();
-    let finished = 0;
-    const stalled = stalledSummarisedRows(db, tenantId, new Date(now - REPLAY_AFTER_MS).toISOString()).map(toRecord);
-    for (const record of stalled) {
-        if (Date.now() > deadline)
-            break;
-        try {
-            saveItems(db, hippoRoot, { tenantId, recordId: record.id, sessionId: record.sessionId, originProject: record.originProject, cwd: record.cwd, items: record.items }, log);
-            finished++;
-        }
-        catch (err) {
-            log(`replay of ${record.id} failed: ${errorMessage(err)}`);
-        }
-    }
-    try {
-        finished += importSpool(hippoRoot, tenantId, log, deadline, spoolImporter(db, hippoRoot, log));
-    }
-    catch (err) {
-        log(`spool import failed: ${errorMessage(err)}`);
-    }
-    const open = openTranscriptRows(db, tenantId, new Date(now - REPLAY_AFTER_MS).toISOString(), new Date(now - TRANSCRIPT_FILL_WINDOW_MS).toISOString()).map(toRecord);
-    for (const record of open) {
-        if (Date.now() > deadline)
-            break;
-        try {
-            if (record.transcriptPath === null || !fs.existsSync(record.transcriptPath))
-                continue;
-            const next = nextStartedAt(db, record);
-            const found = transcriptSummary(record.transcriptPath, Date.parse(record.startedAt), next === null ? Number.POSITIVE_INFINITY : Date.parse(next));
-            if (found === null) {
-                // The record is past REPLAY_AFTER_MS, so a window that is fully scanned or out of reach stays empty.
-                closeWithoutSummary(db, tenantId, record.id, log);
-                continue;
-            }
+function replaySources(hippoRoot, log) {
+    return {
+        importSpool: (tenantId, deadline, record) => importSpool(hippoRoot, tenantId, log, deadline, record),
+        transcriptExists: (transcriptPath) => fs.existsSync(transcriptPath),
+        transcriptText: (transcriptPath, afterMs, beforeMs) => {
+            const found = transcriptSummary(transcriptPath, afterMs, beforeMs);
+            if (found === null)
+                return null;
             const { found: listed, ...text } = readCompactionText(found);
-            if (!listed)
-                log(`no memories section in the transcript summary for ${record.id}`);
-            if (!markSummarised(db, tenantId, record.id, { text, summarisedAt: new Date().toISOString() })) {
-                log(`${record.id} was filled by another process`);
-                continue;
-            }
-            saveItems(db, hippoRoot, { tenantId, recordId: record.id, sessionId: record.sessionId, originProject: record.originProject, cwd: record.cwd, items: text.items }, log);
-            finished++;
-        }
-        catch (err) {
-            log(`transcript fill of ${record.id} failed: ${errorMessage(err)}`);
-        }
-    }
-    return finished;
+            return { text, listed };
+        },
+    };
 }
-/** For `hippo sleep` and post-compact: opens the store itself and never throws. */
+/** For `hippo sleep` and post-compact: finishes what a killed hook or a busy store left, never throws. */
 export function replayCompactionsAt(hippoRoot, log, opts = {}) {
-    let db;
-    try {
-        db = openHippoDb(hippoRoot, { busyWaitMs: opts.busyWaitMs });
-        return replayCompactions(db, hippoRoot, log, opts.deadline);
-    }
-    catch (err) {
-        log(`replay failed: ${errorMessage(err)}`);
-        return 0;
-    }
-    finally {
-        if (db)
-            closeHippoDb(db);
-    }
+    return replayStoredCompactions(hippoRoot, replaySources(hippoRoot, log), log, opts);
 }
 //# sourceMappingURL=compaction-record.js.map

package/dist/capture/compaction-spool.d.ts

@@ -1,6 +1,8 @@
-import type { CompactionText, Log, PostCompactPayload } from './compaction-record.js';
+import type { CompactionText, Log } from '../store/compactions-record.js';
+import type { PostCompactPayload } from './compaction-record.js';
 export declare const SPOOL_DIR = "compactions-spool";
-/** Starts the log line of a step that broke with an unexpected error, so the session-start banner counts it; a set-aside file is counted by its `.bad` name instead. */
+/** Starts the log line of a step that broke with an unexpected error, so the session-start banner counts it; a set-aside file is counted
+ * by its `.bad` name instead. */
 export declare const SPOOL_PROBLEM = "spool problem: ";
 /** Only the fs calls the spool makes, so a test can stand in for one of them. */
 export interface SpoolFs {
@@ -21,7 +23,7 @@ export interface SpoolFs {
     }): void;
 }
 /** Test-only seam, so a test can make one fs call fail; null restores the real fs. */
-export declare function __setSpoolFs(next: SpoolFs | null): void;
+export declare function _setSpoolFsForTests(next: SpoolFs | null): void;
 export interface SpooledCompaction {
     tenantId: string;
     payload: PostCompactPayload;

package/dist/capture/compaction-spool.js

@@ -1,4 +1,5 @@
 // Summaries post-compact could not record because the store was busy, waiting on disk for the next replay.
+import { MINUTE_MS } from '../util/time.js';
 import { randomBytes } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -7,11 +8,12 @@ import { isSqliteBusy } from '../db/busy.js';
 import { errorMessage } from '../util/log.js';
 const STAMP_DIGITS = 13;
 export const SPOOL_DIR = 'compactions-spool';
-/** Starts the log line of a step that broke with an unexpected error, so the session-start banner counts it; a set-aside file is counted by its `.bad` name instead. */
+/** Starts the log line of a step that broke with an unexpected error, so the session-start banner counts it; a set-aside file is counted
+ * by its `.bad` name instead. */
 export const SPOOL_PROBLEM = 'spool problem: ';
 const LOCK = 'replay.lock';
 /** Long enough that a live replayer has finished with its claim. */
-const STALE_MS = 10 * 60_000;
+const STALE_MS = 10 * MINUTE_MS;
 const MAX_ATTEMPTS = 3;
 const BUSY_RETRIES = 3;
 const BUSY_WAIT_MS = 50;
@@ -29,7 +31,7 @@ const NEW_STEM = /^(\d{13})-[0-9a-f]{8}$/;
 const LEGACY_STEM_TIME = /-(\d+)$/;
 let fsx = fs;
 /** Test-only seam, so a test can make one fs call fail; null restores the real fs. */
-export function __setSpoolFs(next) {
+export function _setSpoolFsForTests(next) {
     fsx = next ?? fs;
 }
 const stamp = (ms) => String(Math.trunc(ms)).padStart(STAMP_DIGITS, '0');
@@ -100,7 +102,16 @@ function spoolFile(hippoRoot) {
 export function spool(hippoRoot, tenantId, payload, text, at) {
     const file = spoolFile(hippoRoot);
     fsx.mkdirSync(path.dirname(file), { recursive: true });
-    const body = { tenantId, sessionId: payload.sessionId, trigger: payload.trigger, cwd: payload.cwd, transcriptPath: payload.transcriptPath, at: at.toISOString(), summary: text.summary, items: text.items };
+    const body = {
+        tenantId,
+        sessionId: payload.sessionId,
+        trigger: payload.trigger,
+        cwd: payload.cwd,
+        transcriptPath: payload.transcriptPath,
+        at: at.toISOString(),
+        summary: text.summary,
+        items: text.items,
+    };
     // Renamed into place so a replayer listing `.json` files never reads half a file.
     fsx.writeFileSync(`${file}.tmp`, JSON.stringify(body), { encoding: 'utf8', flag: 'wx' });
     // A rename that stays busy leaves a whole tmp, which a replay promotes once it is STALE_MS old.
@@ -255,7 +266,7 @@ function recoverStaleClaims(dir, names, log) {
 function putBack(dir, claim, stem, attempt, log) {
     const name = path.basename(claim);
     if (settle(() => fsx.renameSync(claim, path.join(dir, `${stem}.a${attempt}.json`)), log, `spool file ${name} not put back`) === 'busy') {
-        log(`spool file ${name} could not be put back; it returns ${STALE_MS / 60_000} minutes after its claim`);
+        log(`spool file ${name} could not be put back; it returns ${STALE_MS / MINUTE_MS} minutes after its claim`);
     }
 }
 /** Writes `<stem>.<cause>.bad` through a random temp file, so the rename replaces any torn `.bad` a crash left. */
@@ -329,7 +340,9 @@ function importFailed(dir, claim, entry, options) {
     const busy = isSqliteBusy(cause);
     if (recorded) {
         // The record stays `summarised`, so the stalled-record step of a later replay writes its items.
-        log(busy ? `spool file ${name} saved; its memories wait for the next sleep (store busy)` : `spool file ${name} saved; writing its memories failed: ${errorMessage(cause)}`);
+        log(busy
+            ? `spool file ${name} saved; its memories wait for the next sleep (store busy)`
+            : `spool file ${name} saved; writing its memories failed: ${errorMessage(cause)}`);
         return busy ? 'stop' : 'skipped';
     }
     if (busy) {
@@ -366,8 +379,9 @@ function importFile(dir, entry, tenantId, log, importOne) {
         return 'skipped';
     const spooled = parseSpooled(text, tenantId);
     if (spooled === null) {
-        if (moveBad(dir, claim, { stem: entry.stem, attempt: entry.attempt, cause: 'unreadable', log, raw: text }))
+        if (moveBad(dir, claim, { stem: entry.stem, attempt: entry.attempt, cause: 'unreadable', log, raw: text })) {
             log(`spool file ${name} is not readable, set aside as .bad`);
+        }
         return 'skipped';
     }
     let recorded = false;

package/dist/capture/copilot-transcript.d.ts

@@ -13,6 +13,7 @@ export declare const SESSION_ID_RE: RegExp;
 export declare function copilotTranscriptFor(sessionId: string): string | null;
 /** True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in either slash and any case. */
 export declare function isVscodeTranscript(file: string | null): boolean;
-/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a sub-agent's included. */
+/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a
+ * sub-agent's included. */
 export declare function copilotTurn(line: CopilotEventLine): CopilotTurn | null;
 //# sourceMappingURL=copilot-transcript.d.ts.map

package/dist/capture/copilot-transcript.js

@@ -33,7 +33,8 @@ function isInjectedUserMessage(data) {
     const source = data.source;
     return isStringValue(source) && INJECTED_SOURCE_PREFIXES.some((prefix) => source.startsWith(prefix));
 }
-/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a sub-agent's included. */
+/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a
+ * sub-agent's included. */
 export function copilotTurn(line) {
     const role = line.type === 'user.message' ? 'user' : line.type === 'assistant.message' ? 'assistant' : null;
     const data = isObjectLike(line.data) ? line.data : null;

package/dist/capture/extract.d.ts

@@ -2,8 +2,11 @@ export interface ExtractedItem {
     content: string;
     category: string;
     tags: string[];
+    /** A person said it, not the agent: capture pins a rule that carries this. */
+    fromUser?: boolean;
 }
-/** Captures complete supported statements, each text parsed alone so a fence or heading in one never reaches the next. */
-export declare function extractFromTexts(texts: readonly string[]): ExtractedItem[];
+/** Captures complete supported statements, each text parsed alone so a fence or heading in one never reaches the next.
+ *  The first `userTexts` texts are a person's own words; on a repeat their copy wins, so it keeps `fromUser`. */
+export declare function extractFromTexts(texts: readonly string[], userTexts?: number): ExtractedItem[];
 export declare function extractFromText(text: string): ExtractedItem[];
 //# sourceMappingURL=extract.d.ts.map

package/dist/capture/extract.js

@@ -158,10 +158,11 @@ function extractOne(text) {
     }
     return items;
 }
-/** Captures complete supported statements, each text parsed alone so a fence or heading in one never reaches the next. */
-export function extractFromTexts(texts) {
+/** Captures complete supported statements, each text parsed alone so a fence or heading in one never reaches the next.
+ *  The first `userTexts` texts are a person's own words; on a repeat their copy wins, so it keeps `fromUser`. */
+export function extractFromTexts(texts, userTexts = 0) {
     const seen = new Set();
-    return texts.flatMap(extractOne).filter((item) => {
+    return texts.flatMap((text, i) => extractOne(text).map((item) => (i < userTexts ? { ...item, fromUser: true } : item))).filter((item) => {
         const key = duplicateKey(item.content);
         if (seen.has(key) || !assessAutomaticMemory(item.content).accepted)
             return false;

package/dist/capture/failure-caller.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../api/types.js';
-import { type CaptureErrorOutcome, type RoutineRule } from '../store/failure-log.js';
+import type { CaptureErrorOutcome, RoutineRule } from '../store/failure-log.js';
 import type { CallerProject } from '../api/prompt-hook.js';
 type FailureSkip = Exclude<CaptureErrorOutcome, 'stored' | 'duplicate'>;
 /** failureReport's reading of the payload, read on the caller's machine, plus the id its retries carry. */