hippo-memory 1.72.0 → 2.1.0

package/dist/capture/compact.js

@@ -7,15 +7,16 @@ import { recordCompactionStart, recordSnapshotSaved } from '../store/compactions
 import { COMPACTION_DB_WAIT_MS } from '../core/compaction-timing.js';
 import { resolveTenantId } from '../store/tenant.js';
 import { defaultPreCompactLogPath, vscodeUserHooksFile } from '../hooks/shared.js';
-import { readClaudeCodePostCompact, readClaudeCodePreCompact } from '../core/capture-contract.js';
-import { errorMessage, log as logger } from '../util/log.js';
+import { readClaudeCodePostCompact, readClaudeCodePreCompact, } from '../core/capture-contract.js';
+import { errorMessage, log as logger, errorFields } from '../util/log.js';
 import { resolveLastSessionTranscript } from './transcript.js';
 import { isVscodeTranscript } from './copilot-transcript.js';
 import { mergeWorkingState, transcriptWorkingState } from './working-state.js';
 // Diagnostic-only log; a long-lived install must not grow it unbounded.
 const PRE_COMPACT_LOG_MAX_BYTES = 256 * 1024;
-/** Log-forgery guard: strip C0 control chars (newlines above all) from payload-controlled values so a crafted value cannot inject fake `[hippo]` log lines.
- *  Exported as the one shared guard for every `[hippo]`-prefixed log writer that interpolates payload values. */
+/** Log-forgery guard: strip C0 control chars (newlines above all) from payload-controlled values so a crafted value
+ * cannot inject fake `[hippo]` log lines. Exported as the one shared guard for every `[hippo]`-prefixed log writer that
+ * interpolates payload values. */
 export function sanitizeLogMessage(message) {
     // eslint-disable-next-line no-control-regex
     return message.replace(/[\x00-\x1f]/g, '');
@@ -23,14 +24,16 @@ export function sanitizeLogMessage(message) {
 function appendPreCompactLog(logFile, message) {
     try {
         fs.mkdirSync(path.dirname(logFile), { recursive: true });
-        // One handle, so the cap acts on the file it measured; two hooks writing in the same instant can overwrite one diagnostic line, which this log accepts.
+        // One handle, so the cap acts on the file it measured; two hooks writing in the same instant can overwrite one
+        // diagnostic line, which this log accepts.
         const fd = fs.openSync(logFile, fs.constants.O_RDWR | fs.constants.O_CREAT);
         try {
             const size = fs.fstatSync(fd).size;
             const startFresh = size > PRE_COMPACT_LOG_MAX_BYTES; // a dumb cap, no rotation
             if (startFresh)
                 fs.ftruncateSync(fd, 0);
-            fs.writeSync(fd, `[hippo] ${new Date().toISOString()} ${sanitizeLogMessage(message)}\n`, startFresh ? 0 : size, 'utf8');
+            const line = `[hippo] ${new Date().toISOString()} ${sanitizeLogMessage(message)}\n`;
+            fs.writeSync(fd, line, startFresh ? 0 : size, 'utf8');
         }
         finally {
             fs.closeSync(fd);
@@ -38,7 +41,7 @@ function appendPreCompactLog(logFile, message) {
     }
     catch (err) {
         // Diagnostic-only; a log write failure must never affect the exit-0 contract.
-        logger.debug(`pre-compact log not written: ${errorMessage(err)}`);
+        logger.debug(`pre-compact log not written: ${errorMessage(err)}`, errorFields(err));
     }
 }
 /** True iff `filePath` exists and is readable — checks both in one call. */
@@ -51,8 +54,8 @@ function isReadableFile(filePath) {
         return false; // missing and unreadable both mean "no file" to the caller
     }
 }
-/** PreCompact stdout is the summariser's instructions; sent before the snapshot work because a locked store can run the hook past its 30
- * s limit, and via writeSync because process.exit drops buffered pipe output. */
+/** PreCompact stdout is the summariser's instructions; sent before the snapshot work because a locked store can run the
+ * hook past its 30 s limit, and via writeSync because process.exit drops buffered pipe output. */
 function printPreCompactInstruction(logFile) {
     const text = `${PRE_COMPACT_INSTRUCTION}\n`;
     try {
@@ -70,13 +73,15 @@ function snapshotJustSaved(hippoRoot, sessionId) {
     if (sessionId === null || sessionId === '')
         return false;
     const active = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-    return active?.session_id === sessionId && active.source === 'pre-compact' && Date.now() - Date.parse(active.updated_at) < TWIN_FIRE_MS;
+    return active?.session_id === sessionId && active.source === 'pre-compact' &&
+        Date.now() - Date.parse(active.updated_at) < TWIN_FIRE_MS;
 }
-/** Runs the PreCompact producer: records the compaction, asks the summariser for memories, saves a working-state snapshot. Never extracts
- * memories itself; SessionEnd capture owns that. */
+/** Runs the PreCompact producer: records the compaction, asks the summariser for memories, saves a working-state
+ * snapshot. Never extracts memories itself; SessionEnd capture owns that. */
 function runPreCompact(hippoRoot, options, logFile) {
     const { stdinText, stdinTimedOut = false, runtime = 'claude-code' } = options;
-    // PreCompact fires in every Claude Code project, including ones that never ran `hippo init`; gate before any call that would create a store.
+    // PreCompact fires in every Claude Code project, including ones that never ran `hippo init`; gate before any call
+    // that would create a store.
     if (!isInitialized(hippoRoot)) {
         appendPreCompactLog(logFile, 'skip: store not initialized');
         return;
@@ -87,7 +92,8 @@ function runPreCompact(hippoRoot, options, logFile) {
         return;
     }
     const { sessionId, transcriptPath: payloadTranscriptPath } = receipt.input;
-    // With chat.useClaudeHooks on, VS Code runs Claude Code's hooks too; it never sends PostCompact to close a record, nor reads the summariser text.
+    // With chat.useClaudeHooks on, VS Code runs Claude Code's hooks too; it never sends PostCompact to close a record,
+    // nor reads the summariser text.
     const vscode = runtime === 'claude-code' && isVscodeTranscript(payloadTranscriptPath);
     if (vscode && fs.existsSync(vscodeUserHooksFile())) {
         appendPreCompactLog(logFile, 'skip: VS Code payload, hippo.json runs pre-compact for this chat');
@@ -97,7 +103,8 @@ function runPreCompact(hippoRoot, options, logFile) {
         appendPreCompactLog(logFile, `skip: snapshot for session ${sessionId} saved under ${TWIN_FIRE_MS / 1000} s ago, by the other preCompact entry`);
         return;
     }
-    const recordId = markCompactionBoundary(hippoRoot, options, logFile, receipt.input, runtime === 'claude-code' && !vscode);
+    const closable = runtime === 'claude-code' && !vscode;
+    const recordId = markCompactionBoundary(hippoRoot, options, logFile, receipt.input, closable);
     const transcriptPath = resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile, runtime);
     if (!transcriptPath)
         return;
@@ -107,8 +114,8 @@ function runPreCompact(hippoRoot, options, logFile) {
         return;
     saveDerivedSnapshot(hippoRoot, logFile, sessionId, recordId, derived);
 }
-/** Starts the compaction record when the host will close one (`closable`), then tells `onBoundary` what was printed; the record id, or
- * null without a record. */
+/** Starts the compaction record when the host will close one (`closable`), then tells `onBoundary` what was printed;
+ * the record id, or null without a record. */
 function markCompactionBoundary(hippoRoot, options, logFile, input, closable) {
     const { sessionId } = input;
     // The record is the "something saved before every compaction", so it lands even when no snapshot is derivable later.
@@ -162,9 +169,10 @@ function saveDerivedSnapshot(hippoRoot, logFile, sessionId, recordId, derived) {
         existing = loadActiveTaskSnapshot(hippoRoot, tenantId);
     }
     catch (err) {
-        logger.debug(`pre-compact: stored snapshot unreadable, saving the derived one alone: ${errorMessage(err)}`);
+        logger.warn(`pre-compact: stored snapshot unreadable, saving the derived one alone: ${errorMessage(err)}`, errorFields(err));
     }
-    // Carried-over fields are not re-capped, as `hippo snapshot save` stays uncapped; saveActiveTaskSnapshot scrubs every field.
+    // Carried-over fields are not re-capped, as `hippo snapshot save` stays uncapped; saveActiveTaskSnapshot scrubs every
+    // field.
     const merged = mergeWorkingState(derived, existing, sessionId);
     if (merged === null) {
         appendPreCompactLog(logFile, 'skip: no snapshot content for this session (nothing derivable; fallback blocked or empty)');
@@ -173,16 +181,18 @@ function saveDerivedSnapshot(hippoRoot, logFile, sessionId, recordId, derived) {
         try {
             saveActiveTaskSnapshot(hippoRoot, tenantId, { ...merged, source: 'pre-compact', session_id: sessionId });
             appendPreCompactLog(logFile, 'snapshot saved');
-            if (recordId !== null)
+            if (recordId !== null) {
                 recordSnapshotSaved(hippoRoot, tenantId, recordId, (message) => appendPreCompactLog(logFile, message));
+            }
         }
         catch (err) {
             appendPreCompactLog(logFile, `snapshot save failed: ${errorMessage(err)}`);
         }
     }
 }
-/** PreCompact hook entry point. Exit code 2 BLOCKS compaction, so every path (bad stdin, missing transcript, store error) must exit 0 as a logged no-op.
- *  Callers must not wrap this in anything that turns a caught-and-logged failure into a non-zero exit. */
+/** PreCompact hook entry point. Exit code 2 BLOCKS compaction, so every path (bad stdin, missing transcript, store
+ * error) must exit 0 as a logged no-op. Callers must not wrap this in anything that turns a caught-and-logged failure
+ * into a non-zero exit. */
 export async function cmdPreCompact(hippoRoot, options) {
     const logFile = options.logFile ?? defaultPreCompactLogPath();
     try {
@@ -195,7 +205,8 @@ export async function cmdPreCompact(hippoRoot, options) {
 }
 /** A PostCompact hook has 10 s in all; replay stops starting new records after this. */
 const POST_COMPACT_REPLAY_BUDGET_MS = 6000;
-/** PostCompact entry point: saves the summary and its items, replays earlier leftovers, returns the one line to show. Never throws, so the hook exits 0. */
+/** PostCompact entry point: saves the summary and its items, replays earlier leftovers, returns the one line to show.
+ * Never throws, so the hook exits 0. */
 export function cmdPostCompact(hippoRoot, options) {
     const logFile = options.logFile ?? defaultPreCompactLogPath();
     const log = (message) => appendPreCompactLog(logFile, `post-compact: ${message}`);

package/dist/capture/compaction-items-caller.js

@@ -1,4 +1,5 @@
-// PostCompact for a caller on another machine: the items it parsed become rows under its owner and project, and a retried request id writes nothing twice.
+// PostCompact for a caller on another machine: the items it parsed become rows under its owner and project, and a
+// retried request id writes nothing twice.
 import { BadRequestError } from '../core/api-errors.js';
 import { COMPACTION_ITEM_MAX_CHARS } from '../util/compaction-items.js';
 import { saveCallerItems } from '../store/compaction-caller.js';
@@ -17,8 +18,13 @@ export function saveCompactionItemsForCaller(ctx, req) {
     if (callerInHoldout(ctx, req.sessionId))
         return { written: 0 };
     const written = saveCallerItems(ctx.hippoRoot, ctx.tenantId, {
-        sessionId: req.sessionId, trigger: req.trigger, requestId: req.requestId, project: req.project.name, items: scrubCompactionItems(req.items),
-        owner: key.owner, origins: key.project,
+        sessionId: req.sessionId,
+        trigger: req.trigger,
+        requestId: req.requestId,
+        project: req.project.name,
+        items: scrubCompactionItems(req.items),
+        owner: key.owner,
+        origins: key.project,
     }, (message) => log.info(`post-compact: ${message}`));
     return { written };
 }

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

@@ -9,8 +9,8 @@ interface ScrubbedSummary {
 }
 /** What the record keeps of a compact_summary: the scrubbed body, and every parsed item scrubbed. */
 export declare function readCompactionText(compactSummary: string): ScrubbedSummary;
-/** 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 declare function scrubCompactionItems(items: readonly string[]): string[];
 export interface PostCompactPayload {
     sessionId: string;
@@ -20,7 +20,8 @@ export interface PostCompactPayload {
     /** null when Claude Code sent none; the transcript fills the record later. */
     compactSummary: string | null;
 }
-/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or defers. Never throws. */
+/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or
+ * defers. Never throws. */
 export declare function saveCompaction(hippoRoot: string, payload: PostCompactPayload, log: Log): CompactionSaveResult;
 /** The one line PostCompact prints, or null when nothing was saved. */
 export declare function postCompactLine(result: CompactionSaveResult): string | null;

package/dist/capture/compaction-record.js

@@ -6,13 +6,14 @@ import { importSpool, spool } from './compaction-spool.js';
 import { replayStoredCompactions, saveCompactionAt, } from '../store/compactions-record.js';
 import { resolveTenantId } from '../store/tenant.js';
 import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
-import { errorMessage, reportCompactionFailure } from '../util/log.js';
+import { errorFields, errorMessage, reportCompactionFailure } from '../util/log.js';
 import { readTranscriptTail, truncateCodePointSafe } from '../util/transcript-tail.js';
 /** 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;
 const TRANSCRIPT_TAIL_CAPS = [1 << 20, 8 << 20, 64 << 20];
 function scrub(text) {
@@ -22,10 +23,14 @@ function scrub(text) {
 export function readCompactionText(compactSummary) {
     const body = compactSummaryBody(compactSummary);
     const parsed = parseCompactionItems(body);
-    return { summary: truncateCodePointSafe(scrub(body), SUMMARY_MAX_CHARS), items: parsed.items.map(scrub), found: parsed.found };
+    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));
 }
@@ -36,10 +41,11 @@ function spoolSummary(hippoRoot, payload, text, at, reason, result, log) {
         log(`store busy, summary spooled: ${reason}`);
     }
     catch (spoolErr) {
-        reportCompactionFailure(log, 'spool', errorMessage(spoolErr));
+        reportCompactionFailure(log, 'spool', errorMessage(spoolErr), errorFields(spoolErr));
     }
 }
-/** The PostCompact work: record the summary, then write its items. Each step is independent; a busy store spools or defers. Never throws. */
+/** 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) {
     if (payload.compactSummary === null) {
         log('skip: payload has no compact_summary');
@@ -63,7 +69,8 @@ export function postCompactLine(result) {
     if (result.written === 0)
         return "Hippo kept this compaction's summary; it listed no new memories.";
     const noun = result.written === 1 ? 'memory' : 'memories';
-    return `Hippo saved ${result.written} ${noun} from this compaction${result.snapshotSaved ? ' and restored your task snapshot' : ''}.`;
+    const restored = result.snapshotSaved ? ' and restored your task snapshot' : '';
+    return `Hippo saved ${result.written} ${noun} from this compaction${restored}.`;
 }
 function lineText(line) {
     const content = line.message?.content;
@@ -73,7 +80,8 @@ function lineText(line) {
         return '';
     return content.map((block) => (isStringValue(block.text) ? block.text : '')).join('\n');
 }
-/** The summary Claude Code wrote into a transcript between two moments; null when it is not (yet) there or the window cannot reach back that far. */
+/** The summary Claude Code wrote into a transcript between two moments; null when it is not (yet) there or the window
+ * cannot reach back that far. */
 function transcriptSummary(transcriptPath, afterMs, beforeMs) {
     const size = fs.statSync(transcriptPath).size;
     for (const cap of TRANSCRIPT_TAIL_CAPS) {

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

@@ -1,7 +1,9 @@
 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
+/**
+ * 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. */
@@ -22,17 +24,18 @@ export interface SpoolFs {
         flag?: 'wx';
     }): void;
 }
-/** Test-only seam, so a test can make one fs call fail; null restores the real fs. */
-export declare function _setSpoolFsForTests(next: SpoolFs | null): void;
 export interface SpooledCompaction {
     tenantId: string;
     payload: PostCompactPayload;
     text: CompactionText;
     at: Date;
 }
-/** Records one spooled compaction; it calls `recorded` once the store holds the summary, so the file is done even if a later step throws. */
+/**
+ * Records one spooled compaction; it calls `recorded` once the store holds the summary, so the file is done even if a
+ * later step throws.
+ */
 export type SpoolImporter = (spooled: SpooledCompaction, recorded: () => void) => void;
-export declare function spool(hippoRoot: string, tenantId: string, payload: PostCompactPayload, text: CompactionText, at: Date): void;
+export declare function spool(hippoRoot: string, tenantId: string, payload: PostCompactPayload, text: CompactionText, at: Date, fsx?: SpoolFs): void;
 /** null when the text is not a spooled compaction. */
 export declare function parseSpooled(text: string, fallbackTenantId: string): SpooledCompaction | null;
 export interface SpoolCounts {
@@ -40,8 +43,14 @@ export interface SpoolCounts {
     stale: number;
     bad: number;
 }
-/** What doctor reports, read only: files a replay should have taken by now, claims and tmp files a dead process left, and `.bad` files. */
-export declare function spoolCounts(hippoRoot: string, now: Date, waitingAfterMs: number): SpoolCounts;
-/** One replayer at a time holds `replay.lock`, so only one process claims a file even where Windows lets two renames of it both land. */
-export declare function importSpool(hippoRoot: string, tenantId: string, log: Log, deadline: number, importOne: SpoolImporter): number;
+/**
+ * What doctor reports, read only: files a replay should have taken by now, claims and tmp files a dead process left,
+ * and `.bad` files.
+ */
+export declare function spoolCounts(hippoRoot: string, now: Date, waitingAfterMs: number, fsx?: SpoolFs): SpoolCounts;
+/**
+ * One replayer at a time holds `replay.lock`, so only one process claims a file even where Windows lets two renames of
+ * it both land.
+ */
+export declare function importSpool(hippoRoot: string, tenantId: string, log: Log, deadline: number, importOne: SpoolImporter, fsx?: SpoolFs): number;
 //# sourceMappingURL=compaction-spool.d.ts.map