hippo-memory 1.51.0 → 1.52.0

package/README.md

@@ -724,9 +724,9 @@ For Claude Code, it also adds:
 - a `SessionEnd` hook so `hippo sleep` runs automatically when the session exits
 - a `SessionStart` hook that prints the previous session's consolidation output
 - a `UserPromptSubmit` hook that runs `hippo context --pinned-only --include-recent 5 --format additional-context` every turn. It re-injects pinned memories (`hippo remember <text> --pin`) plus the last 5 writes, so fresh same-session lessons appear on the next prompt before you pin them. The block is rendered without live strength percentages, so it stays byte-identical while its memories do not change, and it is sent only when it changed since the session's last prompt: an unchanged block is skipped, resent every 10 skips (`pinnedInject.refreshTurns`, `0` never resends) and resent after compaction. `{"pinnedInject":{"skipUnchanged":false}}` sends it every turn as before. Opt out entirely with `{"pinnedInject":{"enabled":false}}` in `.hippo/config.json`.
-- a `PreCompact` hook that runs `hippo pre-compact` before the transcript gets summarized. It saves a working-state snapshot (task/summary/next step) and extracts durable memories from the tail, so mid-session compaction can't drop them.
+- a `PreCompact` hook that runs `hippo pre-compact` before the transcript gets summarized. It saves a working-state snapshot (task/summary/next step) so mid-session compaction can't drop it; the `SessionEnd` hook still owns extracting durable memories.
 - a second `SessionStart` hook (matcher `compact`) that runs `hippo compact-resume`, printing that snapshot plus the recent session trail back into context right after compaction.
-- a `PostCompact` hook that runs `hippo post-compact`, which tells you what was saved ("Hippo saved your task snapshot and 2 new memories before compacting"). It prints nothing when nothing was saved.
+- a `PostCompact` hook that runs `hippo post-compact`, which tells you what was saved ("Hippo saved your task snapshot before compacting."). It prints nothing when nothing was saved.
 - a `PostToolUseFailure` hook that runs `hippo capture-error`, which stores a failed tool call as an error memory. It skips interrupts, declined permissions and searches that found nothing, and stores a repeated failure once. It also logs every failure, stored or not, for `hippo failures`: the session, the tool and hashes of the error, never its text. A hash is not anonymous, since anyone who guesses an error's text can check it against the hash. The log keeps 90 days.
 
 To remove: `hippo hook uninstall claude-code`

package/dist/capture.d.ts

@@ -106,16 +106,11 @@ export declare function sanitizeLogMessage(message: string): string;
 /** What one pre-compact run saved, reported to the user after compaction. */
 export interface PreCompactReport {
     snapshotSaved: boolean;
-    captured: number;
     /** Claude Code session the run belonged to, when the payload named one. */
     sessionId: string | null;
 }
-/**
- * The line shown to the user after compaction, or null when nothing was
- * saved. Without it the only sign was Claude Code's generic
- * "PreCompact [...] completed successfully".
- */
-export declare function preCompactMessage(report: Pick<PreCompactReport, 'snapshotSaved' | 'captured'>): string | null;
+/** Line shown after compaction, or null when nothing was saved (Claude Code's own generic message is the fallback). */
+export declare function preCompactMessage(report: Pick<PreCompactReport, 'snapshotSaved'>): string | null;
 /**
  * Where pre-compact leaves its report for `hippo post-compact`: next to the
  * pre-compact log, so both hooks find it from the same `--log-file`.

package/dist/capture.js

@@ -21,7 +21,6 @@ import { defaultPreCompactLogPath } from './hooks.js';
 import { redactSecrets } from './secret-detect.js';
 import { RejectedValueError, checkRejectionGuard } from './rejection.js';
 import { openHippoDb, closeHippoDb } from './db.js';
-import { loadConfig } from './config.js';
 // Sentence-level patterns
 //
 // T1 (DF2): each pattern now carries TWO capture groups — group 1 is the
@@ -469,62 +468,6 @@ function isDuplicate(content, existing) {
     }
     return false;
 }
-/**
- * Write already-extracted items to the store, deduped against existing
- * tenant-scoped entries. Shared write path for `cmdCapture` (extracted from
- * raw text inline) and `cmdPreCompact` (extracted from a pre-computed tail
- * summary, no raw-text re-extraction). Mirrors the non-dry-run write loop in
- * `cmdCaptureCore`: same layer/source/confidence, same embed-if-configured,
- * fire-and-forget behaviour.
- *
- * Returns the fire-and-forget `embedMemory` promises alongside the counts
- * (review round X6) so a caller that must not exit before embeddings settle
- * — `cmdPreCompact`, which runs process.exit(0) right after — can await them
- * with a bounded timeout instead of racing a detached write.
- */
-function writeExtractedItems(hippoRoot, tenantId, extracted) {
-    if (extracted.length === 0)
-        return { captured: 0, skipped: 0, rejected: 0, embeds: [] };
-    const existing = loadAllEntries(hippoRoot, tenantId);
-    const embeds = [];
-    let captured = 0;
-    let skipped = 0;
-    let rejected = 0;
-    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
-    for (const item of extracted) {
-        if (isDuplicate(item.content, existing)) {
-            skipped++;
-            continue;
-        }
-        const entry = createMemory(item.content, {
-            layer: Layer.Episodic,
-            tags: item.tags,
-            source: 'capture',
-            confidence: 'observed',
-            tenantId,
-            baseHalfLifeDays,
-        });
-        // AT1 (plan §3 containment): a refusal is per-VALUE — one rejected
-        // extraction must not abort the rest of this transcript's captures.
-        try {
-            writeEntry(hippoRoot, entry);
-        }
-        catch (err) {
-            if (err instanceof RejectedValueError) {
-                rejected++;
-                continue;
-            }
-            throw err;
-        }
-        updateStats(hippoRoot, { remembered: 1 });
-        existing.push(entry); // within-batch dedup
-        if (isEmbeddingConfigured(hippoRoot)) {
-            embeds.push(embedMemory(hippoRoot, entry).catch(() => { }));
-        }
-        captured++;
-    }
-    return { captured, skipped, rejected, embeds };
-}
 /**
  * Runtime shape guards used throughout this file wherever a value arrives
  * unparsed (JSONL transcript records, stdout/stderr write() chunks). Generic
@@ -557,7 +500,7 @@ function errorMessage(cause) {
 /** Leading markers of the command lines Claude Code writes with type 'user'. */
 const CLAUDE_CODE_COMMAND_PREFIXES = ['<local-command-', '<command-name>', '<command-message>', '<command-args>'];
 function isNonHumanUserLine(entry, content) {
-    if (entry.isMeta === true || entry.isSidechain === true || entry.isCompactSummary === true)
+    if (entry.isMeta === true || entry.isSidechain === true || entry.isCompactSummary === true || entry.promptSource === 'system')
         return true;
     const head = content.trimStart();
     return CLAUDE_CODE_COMMAND_PREFIXES.some((p) => head.startsWith(p));
@@ -1121,20 +1064,11 @@ function isReadableFile(filePath) {
         return false;
     }
 }
-/**
- * The line shown to the user after compaction, or null when nothing was
- * saved. Without it the only sign was Claude Code's generic
- * "PreCompact [...] completed successfully".
- */
+/** Line shown after compaction, or null when nothing was saved (Claude Code's own generic message is the fallback). */
 export function preCompactMessage(report) {
-    if (!report.snapshotSaved && report.captured === 0)
+    if (!report.snapshotSaved)
         return null;
-    const parts = [];
-    if (report.snapshotSaved)
-        parts.push('your task snapshot');
-    if (report.captured > 0)
-        parts.push(`${report.captured} new memor${report.captured === 1 ? 'y' : 'ies'}`);
-    return `Hippo saved ${parts.join(' and ')} before compacting.${report.snapshotSaved ? ' The snapshot is restored into the new context.' : ''}`;
+    return 'Hippo saved your task snapshot before compacting. The snapshot is restored into the new context.';
 }
 /**
  * Where pre-compact leaves its report for `hippo post-compact`: next to the
@@ -1143,24 +1077,20 @@ export function preCompactMessage(report) {
 export function preCompactReportPath(logFile) {
     return path.join(path.dirname(logFile), 'pre-compact-last.json');
 }
-/**
- * Runs the PreCompact producer. Returns any `embedMemory` promises kicked
- * off along the way (empty on every skip path) so `cmdPreCompact` can await
- * them, bounded, before it exits (X6).
- */
+/** Runs the PreCompact producer: saves a working-state snapshot into `report`. Never extracts memories; SessionEnd capture owns that. */
 function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     // X3: the PreCompact hook fires in every Claude Code project, including
     // ones that never ran `hippo init`, so gate before any store-opening call
     // (saveActiveTaskSnapshot etc. call initStore, which would create one).
     if (!isInitialized(hippoRoot)) {
         appendPreCompactLog(logFile, 'skip: store not initialized');
-        return [];
+        return;
     }
     // Same hazard X4 guards below, different trigger: a read that timed out
     // must not reach auto-discovery either, or it snapshots another session.
     if (stdinTimedOut && (!stdinText || stdinText.trim() === '')) {
         appendPreCompactLog(logFile, 'skip: no PreCompact payload arrived before the stdin wait window closed');
-        return [];
+        return;
     }
     // A true manual invocation has no stdin at all (TTY, or a non-TTY pipe
     // that yielded an empty read) — that's the ONLY case newest-transcript
@@ -1186,7 +1116,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
             // `"transcript_path": null` (or the key missing entirely) — all fail
             // the string check. Log and skip; never fall through to auto-discovery.
             appendPreCompactLog(logFile, 'skip: malformed or incomplete PreCompact payload (missing string transcript_path)');
-            return [];
+            return;
         }
         if ('session_id' in payload && isStringValue(payload.session_id))
             sessionId = payload.session_id;
@@ -1202,7 +1132,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     // this check could gate on, so containment buys no real isolation.
     if (payloadTranscriptPath !== null && !/\.jsonl$/i.test(payloadTranscriptPath)) {
         appendPreCompactLog(logFile, `skip: payload transcript_path is not a .jsonl file: ${payloadTranscriptPath}`);
-        return [];
+        return;
     }
     // A payload transcript_path is EXCLUSIVE: never fall back to
     // newest-transcript auto-discovery when it's missing/unreadable. That
@@ -1217,7 +1147,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         }
         else {
             appendPreCompactLog(logFile, `skip: payload transcript_path unreadable: ${payloadTranscriptPath}`);
-            return [];
+            return;
         }
     }
     else {
@@ -1225,7 +1155,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     }
     if (!transcriptPath) {
         appendPreCompactLog(logFile, 'skip: no transcript resolved');
-        return [];
+        return;
     }
     let tail;
     try {
@@ -1248,22 +1178,18 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     }
     catch (err) {
         appendPreCompactLog(logFile, `skip: could not read transcript tail: ${errorMessage(err)}`);
-        return [];
+        return;
     }
     const summaryFull = summariseTranscript(tail);
-    // CX5 (codex round 2): extraction runs over REDACTED text — extracted
-    // items become durable memories and must never carry raw secrets any more
-    // than the snapshot fields may. (The pre-existing SessionEnd capture path
-    // is deliberately unchanged.)
+    // Snapshot fields must never carry raw secrets, same rule X9 applies below to task/next_step.
     const scrubbedSummary = redactSecrets(summaryFull);
-    const extracted = extractFromText(scrubbedSummary);
     const rawTask = lastPlainUserMessage(tail);
     const rawNextStep = lastAssistantTextBlock(tail);
-    // Full skip only when EVERY derived field is empty and nothing was
-    // extracted — never clobber a user-authored active snapshot with junk.
-    if (!rawTask.trim() && !summaryFull.trim() && !rawNextStep.trim() && extracted.length === 0) {
-        appendPreCompactLog(logFile, 'skip: empty summary and no extracted items');
-        return [];
+    // Full skip only when every derived field is empty: never clobber a
+    // user-authored active snapshot with junk.
+    if (!rawTask.trim() && !summaryFull.trim() && !rawNextStep.trim()) {
+        appendPreCompactLog(logFile, 'skip: empty summary');
+        return;
     }
     const tenantId = resolveTenantId({});
     // Per-field merge (X1): a tool-heavy tail whose only user turns are
@@ -1309,10 +1235,8 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     const nextStep = scrubbedNextStep.trim()
         ? truncateCodePointSafe(scrubbedNextStep, PRE_COMPACT_NEXT_STEP_CAP)
         : (fallback?.next_step ?? '');
-    // Snapshot writes FIRST: a capture-extraction failure below must never
-    // lose the headline artifact. The reverse order would risk it. All-empty
-    // fields (cross-session tail with nothing derivable) skip the write so a
-    // foreign session's junk never displaces the owning session's snapshot.
+    // All-empty fields (cross-session tail with nothing derivable) skip the
+    // write so a foreign session's junk never displaces the owning snapshot.
     if (!task && !summary && !nextStep) {
         appendPreCompactLog(logFile, 'skip: no snapshot content for this session (nothing derivable; fallback blocked or empty)');
     }
@@ -1332,25 +1256,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
             appendPreCompactLog(logFile, `snapshot save failed: ${errorMessage(err)}`);
         }
     }
-    // Capture extraction SECOND, own try/catch: a failure here self-heals at
-    // the next SessionEnd capture (existing dedup absorbs the overlap).
-    try {
-        const { captured, skipped, rejected, embeds } = writeExtractedItems(hippoRoot, tenantId, extracted);
-        report.captured = captured;
-        appendPreCompactLog(logFile, `capture: ${captured} items captured, ${skipped} skipped` +
-            (rejected > 0 ? `, ${rejected} rejected` : ''));
-        return embeds;
-    }
-    catch (err) {
-        appendPreCompactLog(logFile, `capture failed: ${errorMessage(err)}`);
-        return [];
-    }
 }
-// X6: bound how long cmdPreCompact will wait for fire-and-forget embeddings
-// to settle before it exits. PreCompact runs under a hook timeout (30s in
-// the installer) — 3s leaves ample headroom while still giving embeddings a
-// real chance to finish instead of racing process.exit(0) unconditionally.
-const EMBED_SETTLE_TIMEOUT_MS = 3000;
 /**
  * PreCompact hook entry point. Exit code 2 on PreCompact BLOCKS compaction,
  * so this verb must exit 0 on every path — malformed stdin, missing
@@ -1360,29 +1266,17 @@ const EMBED_SETTLE_TIMEOUT_MS = 3000;
  */
 export async function cmdPreCompact(hippoRoot, options) {
     const logFile = options.logFile ?? defaultPreCompactLogPath();
-    let embeds = [];
-    const report = { snapshotSaved: false, captured: 0, sessionId: null };
+    const report = { snapshotSaved: false, sessionId: null };
     try {
-        embeds = runPreCompact(hippoRoot, options.stdinText, options.stdinTimedOut ?? false, logFile, report);
+        runPreCompact(hippoRoot, options.stdinText, options.stdinTimedOut ?? false, logFile, report);
     }
     catch (err) {
         appendPreCompactLog(logFile, `pre-compact failed: ${errorMessage(err)}`);
     }
-    if (embeds.length > 0) {
-        let timer;
-        const timeout = new Promise((resolve) => {
-            timer = setTimeout(() => resolve('timeout'), EMBED_SETTLE_TIMEOUT_MS);
-            timer.unref?.();
-        });
-        const settled = Promise.allSettled(embeds).then(() => 'settled');
-        const outcome = await Promise.race([settled, timeout]);
-        clearTimeout(timer);
-        appendPreCompactLog(logFile, outcome === 'settled' ? 'embeddings settled' : 'embeddings timeout');
-    }
     // Nothing goes to stdout: Claude Code passes PreCompact stdout to the
     // summarising model as extra instructions. The PostCompact hook
     // (`hippo post-compact`) tells the user instead, from this report.
-    if (report.snapshotSaved || report.captured > 0) {
+    if (report.snapshotSaved) {
         try {
             fs.writeFileSync(preCompactReportPath(logFile), JSON.stringify({ ...report, at: new Date().toISOString() }));
         }
@@ -1431,7 +1325,6 @@ export function postCompactMessage(stdinText, logFile = defaultPreCompactLogPath
             return null;
         return preCompactMessage({
             snapshotSaved: 'snapshotSaved' in report && report.snapshotSaved === true,
-            captured: 'captured' in report && Number.isInteger(report.captured) ? Number(report.captured) : 0,
         });
     }
     catch {

package/dist/cli.js

@@ -41,7 +41,7 @@ import { execFileSync, execSync, spawn } from 'child_process';
 import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, ensureCodexWrapperInstalled, installCodexWrapper, isCodexWrapperInstalled, repairCodexWrapperIfInstalled, uninstallCodexWrapper, resolveCodexSessionTranscript, resolveCodexWrapperPaths, installOpencodePlugin, uninstallOpencodePlugin, resolveOpencodePluginPath, } from './hooks.js';
 import { createMemory, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, confidenceFacets, confidenceLabel, computeSchemaFit, Layer, } from './memory.js';
 import { detectSecret } from './secret-detect.js';
-import { getHippoRoot, isInitialized, initStore, writeEntry, strengthenRetrieved, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, createCard, loadCard, listCards, loadCardRuns, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, } from './store.js';
+import { getHippoRoot, isInitialized, initStore, writeEntry, strengthenRetrieved, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, createCard, loadCard, listCards, loadCardRuns, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, } from './store.js';
 import { rejectValue, unrejectValue, listRejectionsForTenant } from './reject-flow.js';
 import { RejectedValueError } from './rejection.js';
 import { isHandoffOutcome, formatHandoffEvidenceLine } from './handoff.js';
@@ -2935,6 +2935,8 @@ function cmdLastSleep(flags) {
 // X8: session-event content is capped at print time only — the shared
 // printSessionEvents stays untouched for every other caller.
 const COMPACT_RESUME_EVENT_CONTENT_CAP = 400;
+// A snapshot older than this was not written for this compaction (pre-compact skipped), so restoring it is stale, not a resume.
+const COMPACT_RESUME_MAX_AGE_MS = 15 * 60_000;
 function cmdCompactResume(hippoRoot, stdinText, stdinTimedOut) {
     try {
         // X3: gate on the non-exiting isInitialized check before any
@@ -2985,7 +2987,7 @@ function cmdCompactResume(hippoRoot, stdinText, stdinTimedOut) {
         }
         if (!suppressOutput) {
             const tenantId = resolveTenantId({});
-            const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
+            const snapshot = loadFreshActiveTaskSnapshot(hippoRoot, tenantId, { maxAgeMs: COMPACT_RESUME_MAX_AGE_MS });
             // X5: concurrent sessions must not cross-restore. Only suppress when
             // BOTH ids are present and differ — either side missing, or a manual
             // invocation with no payload session_id, still prints.
@@ -8953,7 +8955,7 @@ Commands:
   last-sleep               Print the last 'hippo sleep --log-file' output and clear it
     --path <p>             Log path (default: ~/.hippo/logs/last-sleep.log)
     --keep                 Print without clearing
-  pre-compact              PreCompact hook: snapshot + capture the tail before compaction
+  pre-compact              PreCompact hook: save a working-state snapshot before compaction
     --log-file <p>         Diagnostic log path (default: ~/.hippo/logs/pre-compact.log)
   compact-resume           SessionStart(compact) hook: re-print the snapshot + session trail
   post-compact             PostCompact hook: tell the user what pre-compact saved

package/dist/version.d.ts

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.51.0";
+export declare const PACKAGE_VERSION = "1.52.0";
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export declare function compareSemver(a: string, b: string): number;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.51.0';
+export const PACKAGE_VERSION = '1.52.0';
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export function compareSemver(a, b) {
     const parse = (v) => {

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.51.0",
+  "version": "1.52.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.51.0",
+  "version": "1.52.0",
   "type": "module",
   "description": "Hippo Memory plugin for OpenClaw - biologically-inspired agent memory",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.51.0",
+  "version": "1.52.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.51.0",
+  "version": "1.52.0",
   "description": "Biologically-inspired memory for AI agents. Zero runtime deps, SQLite, MCP server, and an opt-in hosted TypeSafe Jev reranker. Decay, retrieval strengthening, consolidation.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",