hippo-memory 1.52.8 → 1.53.0

package/dist/capture.js

@@ -11,17 +11,20 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createMemory, Layer } from './memory.js';
+import { duplicateKey, storedTextKeys } from './same-text.js';
 import { isContentWorthStoring } from './audit.js';
-import { isInitialized, writeEntry, loadAllEntries, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, } from './store.js';
+import { isInitialized, openStore, stampOriginProject, writeEntryMirrors, loadAllEntries, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, } from './store.js';
+import { gatedWrite } from './gated-write.js';
+import { PRE_COMPACT_INSTRUCTION, compactionOrigin, parsePostCompactPayload, postCompactLine, recordCompactionStart, recordSnapshotSaved, saveCompaction, replayCompactionsAt, COMPACTION_DB_WAIT_MS, } from './compaction-record.js';
 import { getGlobalRoot, initGlobal } from './shared.js';
 import { embedMemory } from './embeddings.js';
-import { isEmbeddingConfigured } from './embedding-provider.js';
 import { resolveTenantId } from './tenant.js';
 import { defaultPreCompactLogPath } from './hooks.js';
-import { redactSecretsStrict } from './secret-detect.js';
+import { maskEmails, redactSecretsStrict } from './secret-detect.js';
 import { RejectedValueError, checkRejectionGuard } from './rejection.js';
 import { openHippoDb, closeHippoDb } from './db.js';
 import { loadConfig } from './config.js';
+import { classifyOriginProject } from './project-identity.js';
 // Sentence-level patterns
 //
 // T1 (DF2): each pattern now carries TWO capture groups — group 1 is the
@@ -50,7 +53,7 @@ const DECISION_PATTERNS = [
     /(decision:\s*)(.{1,500})/i,
 ];
 const RULE_PATTERNS = [
-    /((?:never|always|must(?:\s+not)?|do(?:n't| not)\s+ever)\s+)(.{1,500})/i,
+    /\b((?:never|always|must(?:\s+not)?|do(?:n't| not)\s+ever)\s+)(.{1,500})/i,
     /((?:the rule is|rule:)\s*)(.{1,500})/i,
     /((?:important|critical|remember):\s*)(.{1,500})/i,
     /((?:make sure|ensure)\s+(?:to\s+)?)(.{1,500})/i,
@@ -77,7 +80,7 @@ const SPEC_HEADING_PATTERNS = [
 // ---------------------------------------------------------------------------
 // Extraction engine
 // ---------------------------------------------------------------------------
-function splitSentences(text) {
+export function splitSentences(text) {
     // Split on sentence boundaries, keeping reasonable chunks
     return text
         .split(/(?<=[.!?])\s+|\n/)
@@ -300,6 +303,21 @@ function cleanExtract(raw) {
     }
     return content;
 }
+/** The 500-char write gate minus the 200-char bound counted from the keyword. */
+const RULE_LEAD_CAP = 300;
+/** A modal rule keeps its subject ("We must never ..."); null keeps the keyword-start form when the lead is long or the keyword sits inside a bracket. */
+function ruleLead(sentence, keywordStart, contentStart) {
+    if (keywordStart < 0 || contentStart < 0 || contentStart > RULE_LEAD_CAP)
+        return null;
+    let depth = 0;
+    for (const ch of sentence.slice(0, keywordStart)) {
+        if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        else if ((ch === ')' || ch === ']' || ch === '}') && depth > 0)
+            depth--;
+    }
+    return depth > 0 ? null : sentence.slice(0, contentStart);
+}
 function extractFromPatterns(sentence, patterns, category, tag) {
     for (const pat of patterns) {
         // `d` gives per-group offsets; see the contentStart comment below.
@@ -355,7 +373,11 @@ function extractFromPatterns(sentence, patterns, category, tag) {
                 // capture, shipped in the previous commit. Codex P1, r6.
                 const contentStart = match.indices?.[2]?.[0] ?? -1;
                 const afterKeyword = contentStart >= 0 ? sentence.slice(contentStart) : (match[2] ?? match[0]);
-                bounded = boundToClause(keywordPrefix + afterKeyword, keywordPrefix.length);
+                const keywordStart = match.indices?.[1]?.[0] ?? -1;
+                const lead = pat === RULE_PATTERNS[0] ? ruleLead(sentence, keywordStart, contentStart) : null;
+                bounded = lead !== null
+                    ? boundToClause(lead + afterKeyword, lead.length, keywordStart + 200)
+                    : boundToClause(keywordPrefix + afterKeyword, keywordPrefix.length);
             }
             const content = cleanExtract(bounded);
             if (content.length >= 8 && content.length <= 500) {
@@ -410,7 +432,7 @@ export function extractFromText(text) {
     const items = [];
     const seen = new Set();
     const addIfNew = (item) => {
-        const norm = item.content.toLowerCase().replace(/\s+/g, ' ').trim();
+        const norm = duplicateKey(item.content);
         if (seen.has(norm))
             return;
         if (!isContentWorthStoring(item.content))
@@ -449,26 +471,6 @@ export function extractFromText(text) {
     }
     return items;
 }
-// ---------------------------------------------------------------------------
-// Normalisation for deduplication (mirrors import.ts)
-// ---------------------------------------------------------------------------
-function normalise(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^\w\s]/g, '')
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function isDuplicate(content, existing) {
-    const norm = normalise(content);
-    if (!norm)
-        return true;
-    for (const e of existing) {
-        if (normalise(e.content) === norm)
-            return true;
-    }
-    return false;
-}
 /**
  * Runtime shape guards used throughout this file wherever a value arrives
  * unparsed (JSONL transcript records, stdout/stderr write() chunks). Generic
@@ -480,14 +482,14 @@ function isDuplicate(content, existing) {
  * anything `JSON.parse` can produce (the only divergence is boxed
  * primitives, which JSON.parse never yields).
  */
-function isStringValue(value) {
+export function isStringValue(value) {
     return String(value) === value;
 }
-function isObjectLike(value) {
+export function isObjectLike(value) {
     return value !== null && value instanceof Object;
 }
 /** Message for a caught value of unknown shape. `cause` names the sanctioned unknown-input case (error-cause enrichment). */
-function errorMessage(cause) {
+export function errorMessage(cause) {
     return cause instanceof Error ? cause.message : String(cause);
 }
 /**
@@ -506,10 +508,29 @@ function isNonHumanUserLine(entry, content) {
     const head = content.trimStart();
     return CLAUDE_CODE_COMMAND_PREFIXES.some((p) => head.startsWith(p));
 }
-export function summariseTranscript(jsonl) {
+const NON_HUMAN_BLOCK_PREFIXES = ['<ide_', '[Request interrupted by user'];
+/** The human's words on a Claude Code user line, '' when none; VS Code stores prompts as text blocks, beside its own open-file, selection and interrupt blocks. */
+function humanUserText(entry, message) {
+    const content = message.content;
+    let text = '';
+    if (isStringValue(content)) {
+        text = content;
+    }
+    else if (Array.isArray(content) && !content.some((b) => isObjectLike(b) && 'type' in b && b.type === 'tool_result')) {
+        const parts = [];
+        for (const block of content) {
+            const blockText = isObjectLike(block) && 'type' in block && block.type === 'text' && 'text' in block ? block.text : undefined;
+            if (isStringValue(blockText) && !NON_HUMAN_BLOCK_PREFIXES.some((p) => blockText.trimStart().startsWith(p)))
+                parts.push(blockText);
+        }
+        text = parts.join('\n');
+    }
+    text = text.trim();
+    return text && !isNonHumanUserLine(entry, text) ? text : '';
+}
+export function collectSessionTurns(jsonl, visit) {
     const lines = jsonl.split('\n').filter((l) => l.trim());
-    const userMessages = [];
-    const assistantTexts = [];
+    const turns = [];
     for (const line of lines) {
         let entry;
         try {
@@ -518,19 +539,18 @@ export function summariseTranscript(jsonl) {
         catch {
             continue;
         }
-        if (!isObjectLike(entry))
+        if (!isObjectLike(entry) || !('type' in entry))
             continue;
-        if (('type' in entry) && (entry.type === 'user' || entry.type === 'assistant')) {
+        visit?.(entry);
+        if (entry.type === 'user' || entry.type === 'assistant') {
             const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
             if (!message)
                 continue;
             const content = 'content' in message ? message.content : undefined;
             if (entry.type === 'user') {
-                // Plain text user messages only (skip tool_result arrays), and only
-                // ones the human wrote (see isNonHumanUserLine).
-                if (isStringValue(content) && content.trim() && !isNonHumanUserLine(entry, content)) {
-                    userMessages.push(content.trim());
-                }
+                const text = humanUserText(entry, message);
+                if (text)
+                    turns.push({ role: 'user', text });
             }
             else if (Array.isArray(content)) {
                 // Keep assistant text blocks; drop thinking + tool_use
@@ -544,13 +564,13 @@ export function summariseTranscript(jsonl) {
                     }
                 }
                 if (chunks.length > 0) {
-                    assistantTexts.push(chunks.join('\n'));
+                    turns.push({ role: 'assistant', text: chunks.join('\n') });
                 }
             }
             continue;
         }
         // Codex rollout transcript shape: response_item -> payload.message
-        if ('type' in entry && entry.type === 'response_item') {
+        if (entry.type === 'response_item') {
             const payload = 'payload' in entry && isObjectLike(entry.payload) ? entry.payload : undefined;
             if (!payload || !('type' in payload) || payload.type !== 'message')
                 continue;
@@ -574,11 +594,19 @@ export function summariseTranscript(jsonl) {
             if (chunks.length === 0)
                 continue;
             if (role === 'user')
-                userMessages.push(chunks.join('\n'));
+                turns.push({ role: 'user', text: chunks.join('\n') });
             if (role === 'assistant')
-                assistantTexts.push(chunks.join('\n'));
+                turns.push({ role: 'assistant', text: chunks.join('\n') });
         }
     }
+    return turns;
+}
+export function summariseTranscript(jsonl) {
+    return summariseSessionTurns(collectSessionTurns(jsonl));
+}
+function summariseSessionTurns(turns) {
+    const userMessages = turns.filter((t) => t.role === 'user').map((t) => t.text);
+    const assistantTexts = turns.filter((t) => t.role === 'assistant').map((t) => t.text);
     if (userMessages.length === 0 && assistantTexts.length === 0)
         return '';
     // Keep the tail: last ~20 user turns and last ~10 assistant replies.
@@ -601,11 +629,11 @@ export function summariseTranscript(jsonl) {
  * Priority, where the first source present is the only one tried:
  *   1. Explicit `transcriptPath` option (from `--transcript <path>`)
  *   2. Stdin JSON payload (Claude Code / OpenCode SessionEnd hook shape)
- *   3. Most recent `.jsonl` under `~/.claude/projects/<any>/`, only on a proven manual run (no path, no stdin text, no timed-out read), because this scan spans every project on the box
+ *   3. Most recent `.jsonl` under `~/.claude/projects/<any>/`, only when the caller passes `mayScan` (only the caller knows it is not a hook) and there is no path and no stdin text, because this scan spans every project on the box
  *
  * Returns null when nothing resolves, a named transcript or payload whose file is missing included. Never throws.
  */
-export function resolveLastSessionTranscript(explicit, stdinText, stdinTimedOut = false) {
+export function resolveLastSessionTranscript(explicit, stdinText, opts) {
     if (explicit)
         return fs.existsSync(explicit) ? explicit : null;
     if (stdinText && stdinText.trim() !== '') {
@@ -622,7 +650,7 @@ export function resolveLastSessionTranscript(explicit, stdinText, stdinTimedOut
         }
         return null;
     }
-    if (stdinTimedOut)
+    if (!opts.mayScan)
         return null;
     const home = process.env.HOME || process.env.USERPROFILE;
     if (!home)
@@ -760,13 +788,16 @@ function cmdCaptureCore(hippoRoot, options) {
             break;
         }
         case 'last-session': {
-            const resolved = resolveLastSessionTranscript(options.transcriptPath, options.stdinText, options.stdinTimedOut);
-            if (!resolved) {
-                console.log('No transcript found. Pass --transcript <path> or run from a SessionEnd hook.');
-                return;
+            let turns = options.sessionTurns;
+            if (!turns) {
+                const resolved = resolveLastSessionTranscript(options.transcriptPath, options.stdinText, { mayScan: !options.stdinTimedOut });
+                if (!resolved) {
+                    console.log('No transcript found. Pass --transcript <path> or run from a SessionEnd hook.');
+                    return;
+                }
+                turns = collectSessionTurns(fs.readFileSync(resolved, 'utf8'));
             }
-            const jsonl = fs.readFileSync(resolved, 'utf8');
-            text = summariseTranscript(jsonl);
+            text = summariseSessionTurns(turns);
             if (!text) {
                 console.log('Transcript had no user/assistant messages to summarise.');
                 return;
@@ -778,16 +809,19 @@ function cmdCaptureCore(hippoRoot, options) {
         console.log('No text to capture from.');
         return;
     }
-    // Extract items
-    const extracted = extractFromText(text);
+    // Scrub once here, as the snapshot fields are: every source can carry a pasted token (AGENTS.md: no secrets in memories).
+    const extracted = extractFromText(maskEmails(redactSecretsStrict(text)));
     if (extracted.length === 0) {
         console.log('No actionable items found in the input.');
         return;
     }
-    // Load existing for dedup. L9: when options.tenantId is set on a non-global
-    // capture, scope the dedup read so tenant A's captures don't get suppressed
-    // by tenant B's existing content. Undefined preserves host-wide behaviour.
-    const existing = loadAllEntries(targetRoot, useGlobal ? undefined : options.tenantId);
+    // Dedup only against rows this capture's reader sees: another tenant's rows (L9), or another
+    // project's, are hidden from it, so they must not stop its own copy.
+    const stored = loadAllEntries(targetRoot, useGlobal ? undefined : options.tenantId);
+    const origin = options.originProject;
+    const keys = storedTextKeys(origin === undefined
+        ? stored
+        : stored.filter((e) => classifyOriginProject(e.origin_project, origin) !== 'cross-project'));
     let captured = 0;
     let skipped = 0;
     let rejected = 0;
@@ -800,9 +834,10 @@ function cmdCaptureCore(hippoRoot, options) {
     // once, run the same checkRejectionGuard the real write path uses via
     // writeEntry, never write anything.
     const dryRunDb = options.dryRun ? openHippoDb(targetRoot) : null;
+    const writeDb = options.dryRun ? null : openStore(targetRoot);
     try {
         for (const item of extracted) {
-            if (isDuplicate(item.content, existing)) {
+            if (keys.has(duplicateKey(item.content))) {
                 skipped++;
                 if (options.dryRun) {
                     console.log(`  [skip] (${item.category}) ${item.content.slice(0, 80)}`);
@@ -819,7 +854,7 @@ function cmdCaptureCore(hippoRoot, options) {
             // global: true, the global store is host-wide and tenant is irrelevant
             // (createMemory's default 'default' applies). When global: false,
             // options.tenantId scopes the write to the same tenant as the dedup.
-            const entry = createMemory(item.content, {
+            const created = createMemory(item.content, {
                 layer: Layer.Episodic,
                 tags: item.tags,
                 source: 'capture',
@@ -827,6 +862,7 @@ function cmdCaptureCore(hippoRoot, options) {
                 tenantId: useGlobal ? undefined : options.tenantId,
                 baseHalfLifeDays,
             });
+            const entry = options.originProject === undefined ? created : { ...created, origin_project: options.originProject };
             if (options.dryRun) {
                 if (dryRunDb) {
                     try {
@@ -843,24 +879,23 @@ function cmdCaptureCore(hippoRoot, options) {
                 }
                 console.log(`  [capture] (${item.category}) ${item.content}`);
             }
-            else {
+            else if (writeDb !== null) {
                 // AT1 (plan §3 containment): one rejected item must not abort the
                 // rest of this capture's items.
-                try {
-                    writeEntry(targetRoot, entry);
+                const stamped = stampOriginProject(targetRoot, entry);
+                const outcome = gatedWrite(writeDb, targetRoot, stamped);
+                if (outcome === 'skipped:rejected') {
+                    rejected++;
+                    continue;
                 }
-                catch (err) {
-                    if (err instanceof RejectedValueError) {
-                        rejected++;
-                        continue;
-                    }
-                    throw err;
+                if (outcome !== 'written') {
+                    skipped++;
+                    continue;
                 }
+                writeEntryMirrors(targetRoot, stamped);
                 updateStats(targetRoot, { remembered: 1 });
-                existing.push(entry); // within-batch dedup
-                if (isEmbeddingConfigured(targetRoot)) {
-                    embedMemory(targetRoot, entry).catch(() => { });
-                }
+                keys.add(duplicateKey(item.content)); // within-batch dedup
+                void embedMemory(targetRoot, entry);
             }
             captured++;
         }
@@ -868,6 +903,8 @@ function cmdCaptureCore(hippoRoot, options) {
     finally {
         if (dryRunDb)
             closeHippoDb(dryRunDb);
+        if (writeDb)
+            closeHippoDb(writeDb);
     }
     const prefix = options.dryRun ? '[dry-run] ' : '';
     const globalPrefix = useGlobal ? '[global] ' : '';
@@ -987,9 +1024,9 @@ function lastPlainUserMessage(jsonl) {
         const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
         if (!message)
             continue;
-        const content = 'content' in message ? message.content : undefined;
-        if (isStringValue(content) && content.trim() && !isNonHumanUserLine(entry, content))
-            return content.trim();
+        const text = humanUserText(entry, message);
+        if (text)
+            return text;
     }
     return '';
 }
@@ -1067,35 +1104,32 @@ function isReadableFile(filePath) {
         return false;
     }
 }
-/** 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)
-        return null;
-    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
- * pre-compact log, so both hooks find it from the same `--log-file`.
- */
-export function preCompactReportPath(logFile) {
-    return path.join(path.dirname(logFile), 'pre-compact-last.json');
+/** 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) {
+    try {
+        fs.writeSync(1, `${PRE_COMPACT_INSTRUCTION}\n`);
+    }
+    catch (err) {
+        appendPreCompactLog(logFile, `instruction not printed: ${errorMessage(err)}`);
+    }
 }
 /** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
 export function transcriptWorkingState(transcriptPath, log) {
-    let tail;
+    let tail = '';
+    let rawTask = '';
+    let rawNextStep = '';
     try {
-        // CX7 (codex round 2): a final record bigger than the window leaves an empty tail, as when a huge tool_result
-        // triggered compaction, so grow the window a bounded number of times until one complete line survives.
-        tail = readTranscriptTail(transcriptPath, PRE_COMPACT_TAIL_BYTES);
-        let prevCap = PRE_COMPACT_TAIL_BYTES;
-        for (const grownCap of [PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
-            if (tail.trim() !== '')
+        // Compaction fires when a big tool_result lands (CX7), so the last human and assistant turns can sit
+        // megabytes back: grow the window a bounded number of times until both turns are in it.
+        const size = fs.statSync(transcriptPath).size;
+        for (const cap of [PRE_COMPACT_TAIL_BYTES, PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
+            if (cap > PRE_COMPACT_TAIL_BYTES)
+                log(`tail window grown to ${cap} bytes (last ${rawTask ? 'assistant' : 'user'} turn is further back)`);
+            tail = readTranscriptTail(transcriptPath, cap);
+            rawTask = lastPlainUserMessage(tail);
+            rawNextStep = lastAssistantTextBlock(tail);
+            if ((rawTask && rawNextStep) || size <= cap)
                 break;
-            if (fs.statSync(transcriptPath).size <= prevCap)
-                break; // already read the whole file
-            log(`tail window grown to ${grownCap} bytes (oversized final record)`);
-            tail = readTranscriptTail(transcriptPath, grownCap);
-            prevCap = grownCap;
         }
     }
     catch (err) {
@@ -1103,25 +1137,23 @@ export function transcriptWorkingState(transcriptPath, log) {
         return null;
     }
     const rawSummary = summariseTranscript(tail);
-    const rawTask = lastPlainUserMessage(tail);
-    const rawNextStep = lastAssistantTextBlock(tail);
     if (!rawTask.trim() && !rawSummary.trim() && !rawNextStep.trim()) {
         log('skip: empty summary');
         return null;
     }
     // X9: these fields skip the capture content gate and reach a prompt, so the strict scrub runs. The caps protect the
     // re-injection token budget and never split a surrogate pair (X2); `hippo snapshot save` stays uncapped.
-    const task = redactSecretsStrict(rawTask);
-    const summary = redactSecretsStrict(rawSummary);
-    const nextStep = redactSecretsStrict(rawNextStep);
+    const task = maskEmails(redactSecretsStrict(rawTask));
+    const summary = maskEmails(redactSecretsStrict(rawSummary));
+    const nextStep = maskEmails(redactSecretsStrict(rawNextStep));
     return {
         task: task.trim() ? truncateCodePointSafe(task, PRE_COMPACT_TASK_CAP) : '',
         summary: summary.trim() ? truncateKeepNewest(summary, PRE_COMPACT_SUMMARY_CAP) : '',
         next_step: nextStep.trim() ? truncateCodePointSafe(nextStep, PRE_COMPACT_NEXT_STEP_CAP) : '',
     };
 }
-/** 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) {
+/** 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, stdinText, stdinTimedOut, logFile) {
     // 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).
@@ -1145,6 +1177,8 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     const manualInvocation = !stdinText || stdinText.trim() === '';
     let sessionId = null;
     let payloadTranscriptPath = null;
+    let payloadCwd = null;
+    let payloadTrigger = null;
     if (!manualInvocation) {
         let payload;
         try {
@@ -1163,8 +1197,9 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         }
         if ('session_id' in payload && isStringValue(payload.session_id))
             sessionId = payload.session_id;
-        report.sessionId = sessionId;
         payloadTranscriptPath = payload.transcript_path;
+        payloadCwd = 'cwd' in payload && isStringValue(payload.cwd) ? payload.cwd : null;
+        payloadTrigger = 'trigger' in payload && isStringValue(payload.trigger) ? payload.trigger : null;
     }
     // X11: payload transcript_path must end .jsonl. No directory-containment
     // check is applied on top of this — CLAUDE_CONFIG_DIR can relocate the
@@ -1177,6 +1212,12 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         appendPreCompactLog(logFile, `skip: payload transcript_path is not a .jsonl file: ${payloadTranscriptPath}`);
         return;
     }
+    // The record is the "something saved before every compaction", so it lands even when no snapshot is derivable below.
+    let recordId = null;
+    if (sessionId !== null && sessionId !== '') {
+        recordId = recordCompactionStart(hippoRoot, { sessionId, trigger: payloadTrigger, cwd: payloadCwd, transcriptPath: payloadTranscriptPath }, (message) => appendPreCompactLog(logFile, message));
+        printPreCompactInstruction(logFile);
+    }
     // A payload transcript_path is EXCLUSIVE: never fall back to
     // newest-transcript auto-discovery when it's missing/unreadable. That
     // fallback would snapshot a DIFFERENT session's transcript under THIS
@@ -1194,7 +1235,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         }
     }
     else {
-        transcriptPath = resolveLastSessionTranscript(undefined, stdinText);
+        transcriptPath = resolveLastSessionTranscript(undefined, stdinText, { mayScan: true });
     }
     if (!transcriptPath) {
         appendPreCompactLog(logFile, 'skip: no transcript resolved');
@@ -1245,7 +1286,8 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
                 session_id: sessionId,
             });
             appendPreCompactLog(logFile, 'snapshot saved');
-            report.snapshotSaved = true;
+            if (recordId !== null)
+                recordSnapshotSaved(hippoRoot, recordId, (message) => appendPreCompactLog(logFile, message));
         }
         catch (err) {
             appendPreCompactLog(logFile, `snapshot save failed: ${errorMessage(err)}`);
@@ -1261,68 +1303,51 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
  */
 export async function cmdPreCompact(hippoRoot, options) {
     const logFile = options.logFile ?? defaultPreCompactLogPath();
-    const report = { snapshotSaved: false, sessionId: null };
     try {
-        runPreCompact(hippoRoot, options.stdinText, options.stdinTimedOut ?? false, logFile, report);
+        runPreCompact(hippoRoot, options.stdinText, options.stdinTimedOut ?? false, logFile);
     }
     catch (err) {
         appendPreCompactLog(logFile, `pre-compact failed: ${errorMessage(err)}`);
     }
-    // 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) {
-        try {
-            fs.writeFileSync(preCompactReportPath(logFile), JSON.stringify({ ...report, at: new Date().toISOString() }));
-        }
-        catch {
-            // Losing the message must never fail the hook.
-        }
-    }
     process.exit(0);
 }
-/** How old a pre-compact report may be and still describe this compaction. */
-const POST_COMPACT_REPORT_MAX_AGE_MS = 10 * 60_000;
-/**
- * The message for the PostCompact hook, from the report pre-compact left,
- * or null when there is nothing to say. Consumes the report, so the message
- * shows once. A report from another session, or an old one, is dropped.
- * Never throws.
- */
-export function postCompactMessage(stdinText, logFile = defaultPreCompactLogPath(), now = new Date()) {
-    const reportFile = preCompactReportPath(logFile);
-    let raw;
-    try {
-        raw = fs.readFileSync(reportFile, 'utf8');
-        fs.rmSync(reportFile, { force: true });
-    }
-    catch {
-        return null;
-    }
+/** 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. */
+export function cmdPostCompact(hippoRoot, options) {
+    const logFile = options.logFile ?? defaultPreCompactLogPath();
+    const log = (message) => appendPreCompactLog(logFile, `post-compact: ${message}`);
+    const deadline = Date.now() + POST_COMPACT_REPLAY_BUDGET_MS;
     try {
-        const report = JSON.parse(raw);
-        if (!isObjectLike(report))
-            return null;
-        const at = 'at' in report && isStringValue(report.at) ? Date.parse(report.at) : Number.NaN;
-        if (Number.isNaN(at) || now.getTime() - at > POST_COMPACT_REPORT_MAX_AGE_MS)
+        if (!isInitialized(hippoRoot)) {
+            log('skip: no hippo store');
             return null;
-        let payloadSession = null;
-        try {
-            const payload = JSON.parse((stdinText ?? '').trim() || 'null');
-            if (isObjectLike(payload) && 'session_id' in payload && isStringValue(payload.session_id))
-                payloadSession = payload.session_id;
         }
-        catch {
-            // No usable payload: fall back to the age check alone.
+        const payload = parsePostCompactPayload(options.stdinText);
+        let line = null;
+        let storeBusy = false;
+        if (payload === null) {
+            log('skip: no PostCompact payload naming a session');
         }
-        const reportSession = 'sessionId' in report && isStringValue(report.sessionId) ? report.sessionId : null;
-        if (payloadSession !== null && reportSession !== null && payloadSession !== reportSession)
-            return null;
-        return preCompactMessage({
-            snapshotSaved: 'snapshotSaved' in report && report.snapshotSaved === true,
-        });
+        else {
+            const saved = saveCompaction(hippoRoot, payload, log);
+            line = postCompactLine(saved);
+            storeBusy = saved.deferred;
+            if (!storeBusy && payload.transcriptPath !== null && options.afterSave) {
+                try {
+                    options.afterSave(payload.transcriptPath, compactionOrigin(hippoRoot, payload.cwd), log);
+                }
+                catch (err) {
+                    log(`agent memory import failed: ${errorMessage(err)}`);
+                }
+            }
+        }
+        if (!storeBusy)
+            replayCompactionsAt(hippoRoot, log, { busyWaitMs: COMPACTION_DB_WAIT_MS, deadline });
+        return line;
     }
-    catch {
+    catch (err) {
+        log(`failed: ${errorMessage(err)}`);
         return null;
     }
 }

package/dist/cli.d.ts

@@ -43,8 +43,6 @@ export declare function parseArgs(argv: string[]): {
     args: string[];
     flags: Record<string, string | boolean | string[]>;
 };
-/** Import new entries from the Claude Code auto memory of the store's project, the frontmatter .md files in ~/.claude/projects/<project>/memory/. */
-export declare function learnFromMemoryMd(hippoRoot: string, homeDir?: string): number;
 /**
  * Render an api.sleep result as console output, byte-identical to the
  * pre-extraction inline implementation in cmdSleepCore.