hippo-memory 1.68.0 → 1.70.0

package/dist/capture/command.js

@@ -1,22 +1,22 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { createMemory, Layer } from '../memory.js';
-import { duplicateKey, storedTextKeys } from '../same-text.js';
+import { createMemory, Layer } from '../core/memory.js';
+import { duplicateKey, longestWord, storedTextKeys } from '../util/same-text.js';
 import { stampOriginProject } from '../store/entry-row.js';
 import { isInitialized, openStore } from '../store/open.js';
 import { writeEntryMirrors } from '../store/entry-writes.js';
-import { loadAllEntries } from '../store/entry-reads.js';
-import { updateStats } from '../store/index-and-stats.js';
-import { gatedWrite } from '../gated-write.js';
-import { getGlobalRoot, initGlobal } from '../shared.js';
-import { embedMemory } from '../embeddings.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, projectId } from '../project-identity.js';
-import { isStringValue } from '../capture-contract.js';
-import { errorMessage, log } from '../log.js';
+import { EVERY_SCOPE, loadTextsHoldingWords } from '../store/candidates.js';
+import { updateStatsOn } from '../store/index-and-stats.js';
+import { gatedWrite } from '../trust/gated-write.js';
+import { getGlobalRoot, initGlobal } from '../sharing/shared.js';
+import { embedMemory } from '../store/embeddings/index.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { RejectedValueError, checkRejectionGuard } from '../store/rejection.js';
+import { openHippoDb, closeHippoDb } from '../db/index.js';
+import { loadConfig } from '../core/config.js';
+import { classifyOriginProject, projectId } from '../core/project-identity.js';
+import { isStringValue } from '../core/capture-contract.js';
+import { errorMessage, log } from '../util/log.js';
 import { extractFromTexts } from './extract.js';
 import { collectSessionTurns, sessionTail, resolveLastSessionTranscript } from './transcript.js';
 export function cmdCapture(hippoRoot, options) {
@@ -48,25 +48,11 @@ export function cmdCapture(hippoRoot, options) {
  * the data.
  */
 function beginLogTee(logFile) {
-    try {
-        fs.mkdirSync(path.dirname(logFile), { recursive: true });
-        fs.appendFileSync(logFile, `[hippo] ${new Date().toISOString()} capturing session...\n`, 'utf8');
-    }
-    catch (err) {
-        log.warn(`could not open log file ${logFile}: ${errorMessage(err)}`);
+    if (!writeLogBanner(logFile))
         return () => { };
-    }
     const origStdoutWrite = process.stdout.write.bind(process.stdout);
     const origStderrWrite = process.stderr.write.bind(process.stderr);
-    const tee = (chunk) => {
-        try {
-            const buf = isStringValue(chunk) ? chunk : Buffer.from(chunk).toString('utf8');
-            fs.appendFileSync(logFile, buf, 'utf8');
-        }
-        catch {
-            // log failures are non-fatal
-        }
-    };
+    const tee = (chunk) => appendToLog(logFile, chunk);
     const wrapWrite = (origWrite) => {
         const wrapped = (...args) => {
             tee(args[0]);
@@ -89,6 +75,27 @@ function beginLogTee(logFile) {
         process.stderr.write = origStderrWrite;
     };
 }
+/** Creates the log's folder and appends the banner line; false, after a warning, when the log cannot be written. */
+function writeLogBanner(logFile) {
+    try {
+        fs.mkdirSync(path.dirname(logFile), { recursive: true });
+        fs.appendFileSync(logFile, `[hippo] ${new Date().toISOString()} capturing session...\n`, 'utf8');
+    }
+    catch (err) {
+        log.warn(`could not open log file ${logFile}: ${errorMessage(err)}`);
+        return false;
+    }
+    return true;
+}
+function appendToLog(logFile, chunk) {
+    try {
+        const buf = isStringValue(chunk) ? chunk : Buffer.from(chunk).toString('utf8');
+        fs.appendFileSync(logFile, buf, 'utf8');
+    }
+    catch {
+        // log failures are non-fatal
+    }
+}
 // Console lines here are the `hippo capture` command's printed result, so they stay off the logger.
 function cmdCaptureCore(hippoRoot, options) {
     const useGlobal = options.global;
@@ -115,22 +122,28 @@ function cmdCaptureCore(hippoRoot, options) {
         console.log('No actionable items found in the input.');
         return;
     }
-    // Dedup only against rows this capture's reader sees: another tenant's rows, 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'));
+    const keys = storedKeysInView(targetRoot, options, extracted);
     const writeOpts = {
         dryRun: options.dryRun,
         tenantId: useGlobal ? undefined : options.tenantId,
-        originProject: origin,
+        originProject: options.originProject,
         lean: false,
     };
-    const { captured, skipped, rejected } = captureExtractedItems(targetRoot, writeOpts, extracted, keys);
+    printCaptureTally(options, captureExtractedItems(targetRoot, writeOpts, extracted, keys));
+}
+// Dedup only against rows this capture's reader sees: another tenant's rows, or another
+// project's, are hidden from it, so they must not stop its own copy.
+// Only a row holding an item's longest word can hold that item, so the store returns those rows and no others.
+function storedKeysInView(targetRoot, options, extracted) {
+    const stored = loadTextsHoldingWords(targetRoot, options.global ? undefined : options.tenantId, extracted.map((item) => longestWord(item.content)), undefined, EVERY_SCOPE);
+    const origin = options.originProject;
+    return storedTextKeys(origin === undefined
+        ? stored
+        : stored.filter((e) => classifyOriginProject(e.origin_project, origin) !== 'cross-project'));
+}
+function printCaptureTally(options, { captured, skipped, rejected }) {
     const prefix = options.dryRun ? '[dry-run] ' : '';
-    const globalPrefix = useGlobal ? '[global] ' : '';
+    const globalPrefix = options.global ? '[global] ' : '';
     console.log(`\n${prefix}${globalPrefix}Captured ${captured} items (${skipped} skipped as duplicates` +
         (rejected > 0 ? `, ${rejected} rejected` : '') +
         ')');
@@ -247,7 +260,7 @@ function captureOne(ctx, item, entry) {
             return 'skipped';
         writeEntryMirrors(targetRoot, stamped);
         if (!options.lean)
-            updateStats(targetRoot, { remembered: 1 });
+            updateStatsOn(writeDb, targetRoot, { remembered: 1 });
         keys.add(duplicateKey(item.content)); // within-batch dedup
         if (!options.lean)
             void embedMemory(targetRoot, entry);

package/dist/capture/compact-resume-caller.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../api/types.js';
-import type { CallerProject } from '../prompt-hook.js';
+import type { CallerProject } from '../api/prompt-hook.js';
 import type { CallerHookOutput } from './pre-compact-caller.js';
 export interface CallerCompactResumeRequest {
     readonly sessionId: string;

package/dist/capture/compact-resume-caller.js

@@ -1,9 +1,9 @@
-import { COMPACT_RESUME_EVENT_CONTENT_CAP, COMPACT_RESUME_MAX_AGE_MS, compactResumeText } from '../context-render.js';
-import { withLedgerDb } from '../ledger-db.js';
-import { errorMessage, log } from '../log.js';
+import { COMPACT_RESUME_EVENT_CONTENT_CAP, COMPACT_RESUME_MAX_AGE_MS, compactResumeText } from '../api/context-render.js';
+import { bookTokenUse } from '../api/ledger-db.js';
+import { errorMessage, log } from '../util/log.js';
 import { listSessionEvents, loadFreshActiveTaskSnapshot } from '../store/sessions.js';
-import { estimateTokens, recordTokenUse } from '../token-ledger.js';
-import { truncateCodePointSafe } from '../transcript-tail.js';
+import { estimateTokens } from '../util/token-text.js';
+import { truncateCodePointSafe } from '../util/transcript-tail.js';
 import { bindCaller, callerInHoldout } from './caller-session.js';
 export function compactResumeForCaller(ctx, req) {
     const key = bindCaller(ctx, req.sessionId, req.project);
@@ -14,9 +14,9 @@ export function compactResumeForCaller(ctx, req) {
     if (snapshot === null || (snapshot.session_id !== null && snapshot.session_id !== req.sessionId))
         return { stdout: '' };
     const text = compactResumeText(snapshot, sessionTrail(ctx, snapshot.session_id));
-    withLedgerDb(ctx.hippoRoot, (db) => recordTokenUse(db, {
+    bookTokenUse(ctx.hippoRoot, {
         tenantId: ctx.tenantId, sessionId: req.sessionId, surface: 'compact_resume', event: 'inject', items: 1, tokens: estimateTokens(text),
-    }), { sharedStore: true });
+    }, { sharedStore: true });
     return { stdout: text };
 }
 /** A bad trail row costs the trail, not the snapshot. */

package/dist/capture/compact.d.ts

@@ -1,4 +1,4 @@
-import { type HookRuntime } from '../capture-contract.js';
+import { type HookRuntime } from '../core/capture-contract.js';
 /**
  * Log-forgery guard: messages here interpolate payload-controlled values
  * (transcript paths, session ids). Strip C0 control chars — newlines above
@@ -13,6 +13,8 @@ export interface PreCompactOptions {
     stdinTimedOut?: boolean;
     logFile?: string;
     runtime?: HookRuntime;
+    /** Called once when the hook accepts a compaction, with the text it printed or null when it printed none. */
+    onBoundary?: (printed: string | null) => void;
 }
 /**
  * PreCompact hook entry point. Exit code 2 on PreCompact BLOCKS compaction,
@@ -24,6 +26,7 @@ export interface PreCompactOptions {
 export declare function cmdPreCompact(hippoRoot: string, options: PreCompactOptions): Promise<void>;
 export interface PostCompactOptions {
     stdinText?: string;
+    stdinTimedOut?: boolean;
     logFile?: string;
     afterSave?: (transcriptPath: string, cwd: string | null, log: (message: string) => void) => void;
 }

package/dist/capture/compact.js

@@ -2,12 +2,13 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { isInitialized } from '../store/open.js';
 import { saveActiveTaskSnapshot, loadActiveTaskSnapshot } from '../store/sessions.js';
-import { PRE_COMPACT_INSTRUCTION, parsePostCompactPayload, postCompactLine, recordCompactionStart, recordSnapshotSaved, saveCompaction, replayCompactionsAt, COMPACTION_DB_WAIT_MS, } from '../compaction-record.js';
-import { resolveTenantId } from '../tenant.js';
-import { defaultPreCompactLogPath } from '../hooks/shared.js';
-import { readClaudeCodePreCompact } from '../capture-contract.js';
-import { errorMessage } from '../log.js';
+import { PRE_COMPACT_INSTRUCTION, postCompactLine, recordCompactionStart, recordSnapshotSaved, saveCompaction, replayCompactionsAt, COMPACTION_DB_WAIT_MS, } from './compaction-record.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 { resolveLastSessionTranscript } from './transcript.js';
+import { isVscodeTranscript } from './copilot-transcript.js';
 import { mergeWorkingState, transcriptWorkingState } from './working-state.js';
 // ---------------------------------------------------------------------------
 // `hippo pre-compact` — PreCompact hook producer
@@ -35,8 +36,9 @@ function appendPreCompactLog(logFile, message) {
         }
         fs.appendFileSync(logFile, `[hippo] ${new Date().toISOString()} ${sanitizeLogMessage(message)}\n`, 'utf8');
     }
-    catch {
+    catch (err) {
         // Diagnostic-only; a log write failure must never affect the exit-0 contract.
+        logger.debug(`pre-compact log not written: ${errorMessage(err)}`);
     }
 }
 /** True iff `filePath` exists and is readable — checks both in one call. */
@@ -51,13 +53,24 @@ function isReadableFile(filePath) {
 }
 /** 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 {
-        fs.writeSync(1, `${PRE_COMPACT_INSTRUCTION}\n`);
+        fs.writeSync(1, text);
+        return text;
     }
     catch (err) {
         appendPreCompactLog(logFile, `instruction not printed: ${errorMessage(err)}`);
+        return null;
     }
 }
+/** The Copilot CLI accepts both preCompact and PreCompact, so hippo.json's pair can run twice for one compaction. */
+const TWIN_FIRE_MS = 10_000;
+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;
+}
 /** 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;
@@ -73,14 +86,18 @@ function runPreCompact(hippoRoot, options, logFile) {
         appendPreCompactLog(logFile, `skip: ${receipt.reason}`);
         return;
     }
-    const { sessionId, transcriptPath: payloadTranscriptPath, cwd: payloadCwd, trigger: payloadTrigger } = receipt.input;
-    // The record is the "something saved before every compaction", so it lands even when no snapshot is derivable below.
-    // Copilot has no PostCompact hook to close a record, so its compactions get the snapshot alone.
-    let recordId = null;
-    if (runtime === 'claude-code' && sessionId !== null && sessionId !== '') {
-        recordId = recordCompactionStart(hippoRoot, { sessionId, trigger: payloadTrigger, cwd: payloadCwd, transcriptPath: payloadTranscriptPath }, (message) => appendPreCompactLog(logFile, message));
-        printPreCompactInstruction(logFile);
+    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.
+    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');
+        return;
     }
+    if (runtime === 'copilot' && snapshotJustSaved(hippoRoot, sessionId)) {
+        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 transcriptPath = resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile, runtime);
     if (!transcriptPath)
         return;
@@ -90,6 +107,26 @@ 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. */
+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.
+    // Copilot has no PostCompact hook to close a record, so its compactions get the snapshot alone.
+    let recordId = null;
+    let printed = null;
+    if (closable && sessionId !== null && sessionId !== '') {
+        recordId = recordCompactionStart(hippoRoot, { sessionId, trigger: input.trigger, cwd: input.cwd, transcriptPath: input.transcriptPath }, (message) => appendPreCompactLog(logFile, message));
+        printed = printPreCompactInstruction(logFile);
+    }
+    // Its own guard, so a throwing callback can never skip the snapshot work that follows.
+    try {
+        options.onBoundary?.(printed);
+    }
+    catch (err) {
+        appendPreCompactLog(logFile, `boundary callback failed: ${errorMessage(err)}`);
+    }
+    return recordId;
+}
 /** The transcript to snapshot, or null after logging why there is none. */
 function resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile, runtime) {
     // A payload transcript_path is EXCLUSIVE: auto-discovery would snapshot a DIFFERENT session's
@@ -123,8 +160,8 @@ function saveDerivedSnapshot(hippoRoot, logFile, sessionId, recordId, derived) {
     try {
         existing = loadActiveTaskSnapshot(hippoRoot, tenantId);
     }
-    catch {
-        // No existing snapshot to merge against — proceed with derived-only.
+    catch (err) {
+        logger.debug(`pre-compact: stored snapshot unreadable, saving the derived one alone: ${errorMessage(err)}`);
     }
     // Carried-over fields are not re-capped, as `hippo snapshot save` stays uncapped; saveActiveTaskSnapshot scrubs every field.
     const merged = mergeWorkingState(derived, existing, sessionId);
@@ -172,19 +209,19 @@ export function cmdPostCompact(hippoRoot, options) {
             log('skip: no hippo store');
             return null;
         }
-        const payload = parsePostCompactPayload(options.stdinText);
+        const receipt = readClaudeCodePostCompact(options.stdinText, options.stdinTimedOut ?? false);
         let line = null;
         let storeBusy = false;
-        if (payload === null) {
-            log('skip: no PostCompact payload naming a session');
+        if (receipt.status !== 'received') {
+            log(`skip: ${receipt.reason}`);
         }
         else {
-            const saved = saveCompaction(hippoRoot, payload, log);
+            const saved = saveCompaction(hippoRoot, receipt.input, log);
             line = postCompactLine(saved);
             storeBusy = saved.deferred;
-            if (!storeBusy && payload.transcriptPath !== null && options.afterSave) {
+            if (!storeBusy && receipt.input.transcriptPath !== null && options.afterSave) {
                 try {
-                    options.afterSave(payload.transcriptPath, payload.cwd, log);
+                    options.afterSave(receipt.input.transcriptPath, receipt.input.cwd, log);
                 }
                 catch (err) {
                     log(`agent memory import failed: ${errorMessage(err)}`);

package/dist/capture/compaction-items-caller.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from '../api/types.js';
-import type { CallerProject } from '../prompt-hook.js';
+import type { CallerProject } from '../api/prompt-hook.js';
 export interface CallerItemsRequest {
     readonly sessionId: string;
     readonly project: CallerProject;

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

@@ -1,8 +1,8 @@
 // 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 '../api-errors.js';
-import { COMPACTION_ITEM_MAX_CHARS } from '../compaction-items.js';
-import { compactionByRequest, recordSummary, saveItems, scrubCompactionItems } from '../compaction-record.js';
-import { log } from '../log.js';
+import { BadRequestError } from '../core/api-errors.js';
+import { COMPACTION_ITEM_MAX_CHARS } from './compaction-items.js';
+import { compactionByRequest, recordSummary, saveItems, scrubCompactionItems } from './compaction-record.js';
+import { log } from '../util/log.js';
 import { assertRequestId, assertTrigger, bindCaller, callerInHoldout, withCallerDb } from './caller-session.js';
 /** Busy throws, for the server's 503: the retry carries the same request id, so nothing is spooled or deferred here. */
 export function saveCompactionItemsForCaller(ctx, req) {
@@ -21,7 +21,9 @@ export function saveCompactionItemsForCaller(ctx, req) {
             return { written: earlier.itemsWritten };
         const meta = { sessionId: req.sessionId, trigger: req.trigger, cwd: null, transcriptPath: null };
         const text = { summary: '', items: scrubCompactionItems(req.items) };
-        const record = earlier ?? recordSummary(db, ctx.hippoRoot, ctx.tenantId, meta, text, new Date(), { originProject: req.project.name, requestId: req.requestId });
+        const record = earlier ?? recordSummary(db, ctx.hippoRoot, ctx.tenantId, {
+            meta, text, at: new Date(), caller: { originProject: req.project.name, requestId: req.requestId },
+        });
         const written = saveItems(db, ctx.hippoRoot, {
             tenantId: ctx.tenantId, recordId: record.id, sessionId: req.sessionId, originProject: record.originProject, cwd: null,
             items: record.items, caller: { actor: key.owner, origins: key.project },

package/dist/{compaction-items.js → capture/compaction-items.js}

@@ -2,10 +2,34 @@
 export const COMPACTION_ITEM_MAX_CHARS = 500;
 export const COMPACTION_ITEM_ROW_CAP = 10;
 const HEADING = 'memories for hippo';
-const ITEM_LINE = /^\s*(?:[-*]|\d+[.)])(?:\s+(.*))?$/;
+// `\S` parts the gap from the text, so a line that fails to match is scanned once, not once per space.
+const ITEM_LINE = /^\s*(?:[-*]|\d+[.)])(?:\s+(\S.*)?)?$/;
+const ANALYSIS_OPEN = '<analysis>';
+const ANALYSIS_CLOSE = '</analysis>';
+const HEADING_TRAILER = /[*:\s]/;
+/** `text` minus each closed <analysis> block; a search, as a lazy pattern rescans the rest from every unclosed tag. */
+function withoutAnalysis(text) {
+    let kept = '';
+    let from = 0;
+    for (;;) {
+        const open = text.indexOf(ANALYSIS_OPEN, from);
+        const close = open < 0 ? -1 : text.indexOf(ANALYSIS_CLOSE, open + ANALYSIS_OPEN.length);
+        if (close < 0)
+            return kept + text.slice(from);
+        kept += text.slice(from, open);
+        from = close + ANALYSIS_CLOSE.length;
+    }
+}
+/** `text` minus its trailing run of `*`, `:` and spaces; read from the end, as a `+$` pattern retries the run from each character. */
+function withoutHeadingTrailer(text) {
+    let end = text.length;
+    while (end > 0 && HEADING_TRAILER.test(text[end - 1]))
+        end--;
+    return text.slice(0, end);
+}
 /** The <summary> body of a PostCompact compact_summary with any <analysis> block removed; the whole text trimmed when there is no <summary> tag. */
 export function compactSummaryBody(compactSummary) {
-    const text = compactSummary.replace(/<analysis>[\s\S]*?<\/analysis>/g, '');
+    const text = withoutAnalysis(compactSummary);
     const open = text.lastIndexOf('<summary>');
     if (open < 0)
         return text.trim();
@@ -14,7 +38,7 @@ export function compactSummaryBody(compactSummary) {
     return text.slice(from, close < 0 ? undefined : close).trim();
 }
 function isHeading(line) {
-    const bare = line.replace(/^(?:[#*\s]|\d+\.)+/, '').replace(/[*:\s]+$/, '');
+    const bare = withoutHeadingTrailer(line.replace(/^(?:[#*\s]|\d+\.)+/, ''));
     return bare.toLowerCase() === HEADING;
 }
 /** found=false when no "Memories for hippo" heading; items in order, "none" dropped, never cut. */

package/dist/{compaction-record.d.ts → capture/compaction-record.d.ts}

@@ -1,4 +1,5 @@
-import { type DatabaseSyncLike } from './db.js';
+import { type DatabaseSyncLike } from '../db/index.js';
+import { type CompactionStatus } from '../store/compactions.js';
 /** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
 export declare const COMPACTION_DB_WAIT_MS = 2000;
 /** Tested verbatim: Claude Code hands PreCompact stdout to the summariser as instructions. */
@@ -7,7 +8,7 @@ export declare const PRE_COMPACT_INSTRUCTION = "In your summary, add a last sect
 export declare const REPLAY_AFTER_MS: number;
 /** Claude Code deletes transcripts after 30 days, so an older gap can never be filled. */
 export declare const TRANSCRIPT_FILL_WINDOW_MS: number;
-export type CompactionStatus = 'started' | 'summarised' | 'done' | 'no-summary';
+export type { CompactionStatus };
 export interface CompactionRecord {
     id: string;
     tenantId: string;
@@ -61,8 +62,14 @@ export interface SummaryCaller {
     originProject?: string;
     requestId?: string;
 }
+export interface RecordSummaryOptions {
+    readonly meta: Omit<CompactionStart, 'originProject'>;
+    readonly text: CompactionText;
+    readonly at: Date;
+    readonly caller?: SummaryCaller;
+}
 /** Puts the summary on the session's `started` record, or inserts a `summarised` one when pre-compact wrote none. One statement each. */
-export declare function recordSummary(db: DatabaseSyncLike, hippoRoot: string, tenantId: string, meta: Omit<CompactionStart, 'originProject'>, text: CompactionText, at: Date, caller?: SummaryCaller): CompactionRecord;
+export declare function recordSummary(db: DatabaseSyncLike, hippoRoot: string, tenantId: string, options: RecordSummaryOptions): CompactionRecord;
 export interface ItemContext {
     tenantId: string;
     /** null when the record step failed: the items still go in, with no record to close. */
@@ -88,8 +95,6 @@ export interface PostCompactPayload {
     /** null when Claude Code sent none; the transcript fills the record later. */
     compactSummary: string | null;
 }
-/** null when the text is not a PostCompact payload naming a session. */
-export declare function parsePostCompactPayload(stdinText: string | undefined): PostCompactPayload | null;
 export interface CompactionSaveResult {
     /** Memories written; null when neither the record nor the items could be saved. */
     written: number | null;
@@ -108,5 +113,4 @@ export declare function replayCompactionsAt(hippoRoot: string, log: Log, opts?:
     busyWaitMs?: number;
     deadline?: number;
 }): number;
-export {};
 //# sourceMappingURL=compaction-record.d.ts.map