hippo-memory 1.69.0 → 1.71.0

package/dist/api/types.d.ts

@@ -1,12 +1,7 @@
-import { BadRequestError } from '../api-errors.js';
-import type { HippoStore } from '../store-port.js';
-/**
- * Actor identity + authorization role for a Context.
- *
- * Carries the audit-log subject plus a role for /v1/sleep admin gating. Audit
- * helpers take the bare `string`, so callers pass `ctx.actor.subject`. Role checks happen at the request
- * boundary (e.g. /v1/sleep), except in authCreate and authRevoke (ForbiddenError).
- */
+import { BadRequestError } from '../core/api-errors.js';
+import type { HippoStore } from '../store/index.js';
+/** Actor identity + role for a Context: the audit-log subject (pass `ctx.actor.subject` to audit helpers) and the role for admin gating.
+ * Role checks happen at the request boundary (e.g. /v1/sleep), except in authCreate and authRevoke (ForbiddenError). */
 export interface Actor {
     /** 'cli' | 'localhost:cli' | 'api_key:<key_id>' | 'mcp' | 'connector:slack' | 'connector:github' */
     subject: string;
@@ -34,31 +29,13 @@ export type StoreReply<C extends Context, R> = C extends {
     readonly hippoRoot: string;
     readonly store?: undefined;
 } ? R : R | Promise<R>;
-/**
- * Helper for building process-local Actor values (admin and host admin),
- * used by CLI and CLI-run connector Context constructors so the role
- * boilerplate isn't repeated at every site. Bearer-authed callers (HTTP
- * /v1/*) construct Actor directly from the api_keys row's role column via
- * buildContextWithAuth in src/server.ts.
- */
+/** Builds process-local Actor values (admin and host admin) for CLI and CLI-run connector Contexts; Bearer-authed callers build Actor from the api_keys row
+ * instead. */
 export declare function adminActor(subject: string): Actor;
 /** The per-person key: an unowned key gets its own bucket by key id rather than sharing one. */
 export declare function ownerOrSubject(actor: Actor): string;
-/**
- * Thrown by `api.recall` when a caller's options violate a recall contract
- * that has been opted into via env. Carries a stable `code` field for HTTP /
- * MCP / CLI render paths to discriminate without parsing the message.
- *
- * Codes:
- *   - 'fresh_tail_requires_session_id' — `freshTailCount > 0` AND no
- *     `freshTailSessionId` AND `HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1`.
- *     Default behaviour (env unset) returns tenant-wide rows; the env gate
- *     is opt-in so multi-session tenants can fail loud instead of silently
- *     surfacing cross-session rows tagged `isFreshTail=true`.
- *   - 'invalid_scorer_window' — `opts.scorerWindow` is set to a non-positive,
- *     non-integer, or non-finite value. 0 would route through FTS/LIKE
- *     `LIMIT 0` and then an uncapped full-store fallback, so it is validated upfront.
- */
+/** Thrown by `api.recall` on a contract violation; the stable `code` lets callers discriminate without parsing the message.
+ * 'fresh_tail_requires_session_id' (needs HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1) or 'invalid_scorer_window' (0 would hit an uncapped fallback). */
 export declare class RecallContractError extends BadRequestError {
     readonly code: 'fresh_tail_requires_session_id' | 'invalid_scorer_window';
     constructor(code: 'fresh_tail_requires_session_id' | 'invalid_scorer_window', message: string);

package/dist/api/types.js

@@ -1,12 +1,7 @@
 // Request context (caller identity and tenant) shared by every API module, plus the recall contract error.
-import { BadRequestError } from '../api-errors.js';
-/**
- * Helper for building process-local Actor values (admin and host admin),
- * used by CLI and CLI-run connector Context constructors so the role
- * boilerplate isn't repeated at every site. Bearer-authed callers (HTTP
- * /v1/*) construct Actor directly from the api_keys row's role column via
- * buildContextWithAuth in src/server.ts.
- */
+import { BadRequestError } from '../core/api-errors.js';
+/** Builds process-local Actor values (admin and host admin) for CLI and CLI-run connector Contexts; Bearer-authed callers build Actor from the api_keys row
+ * instead. */
 export function adminActor(subject) {
     return { subject, role: 'admin', hostAdmin: true };
 }
@@ -14,21 +9,8 @@ export function adminActor(subject) {
 export function ownerOrSubject(actor) {
     return actor.owner ?? actor.subject;
 }
-/**
- * Thrown by `api.recall` when a caller's options violate a recall contract
- * that has been opted into via env. Carries a stable `code` field for HTTP /
- * MCP / CLI render paths to discriminate without parsing the message.
- *
- * Codes:
- *   - 'fresh_tail_requires_session_id' — `freshTailCount > 0` AND no
- *     `freshTailSessionId` AND `HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1`.
- *     Default behaviour (env unset) returns tenant-wide rows; the env gate
- *     is opt-in so multi-session tenants can fail loud instead of silently
- *     surfacing cross-session rows tagged `isFreshTail=true`.
- *   - 'invalid_scorer_window' — `opts.scorerWindow` is set to a non-positive,
- *     non-integer, or non-finite value. 0 would route through FTS/LIKE
- *     `LIMIT 0` and then an uncapped full-store fallback, so it is validated upfront.
- */
+/** Thrown by `api.recall` on a contract violation; the stable `code` lets callers discriminate without parsing the message.
+ * 'fresh_tail_requires_session_id' (needs HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL=1) or 'invalid_scorer_window' (0 would hit an uncapped fallback). */
 export class RecallContractError extends BadRequestError {
     code;
     constructor(code, message) {

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

@@ -1,6 +1,6 @@
 import { type Context } from '../api/types.js';
-import { type DatabaseSyncLike } from '../db.js';
-import { type CallerProject } from '../prompt-hook.js';
+import { type DatabaseSyncLike } from '../db/index.js';
+import { type CallerProject } from '../api/prompt-hook.js';
 import type { ContinuityKey } from '../store/sessions.js';
 import { type WorkingState } from './working-state.js';
 /** Checks the ids, then binds the session to the caller's owner (a ConflictError when another owner holds it). Returns the key the call's rows go under. */

package/dist/capture/caller-session.js

@@ -1,13 +1,13 @@
 // The checks every caller call shares: ids, project, the session's owner and the pilot arm, all from the request, never the server's env or folder.
-import { BadRequestError } from '../api-errors.js';
+import { BadRequestError } from '../core/api-errors.js';
 import { ownerOrSubject } from '../api/types.js';
-import { closeHippoDb, openHippoDb } from '../db.js';
-import { MAX_ID_LEN } from '../http-util.js';
-import { sessionPilotArm } from '../pilot-arm.js';
-import { assertCallerIds } from '../prompt-hook.js';
-import { assertCallerProject, projectNames } from '../project-identity.js';
-import { maskEmails, redactSecretsStrict } from '../secret-detect.js';
-import { bindSessionOwner } from '../session-owners.js';
+import { closeHippoDb, openHippoDb } from '../db/index.js';
+import { MAX_ID_LEN } from '../util/http-util.js';
+import { sessionPilotArm } from '../api/pilot-arm.js';
+import { assertCallerIds } from '../api/prompt-hook.js';
+import { assertCallerProject, projectNames } from '../core/project-identity.js';
+import { maskEmails, redactSecretsStrict } from '../util/secret-detect.js';
+import { bindSessionOwner } from '../api/session-owners.js';
 import { fitWorkingState, WORKING_STATE_CAPS } from './working-state.js';
 /** Checks the ids, then binds the session to the caller's owner (a ConflictError when another owner holds it). Returns the key the call's rows go under. */
 export function bindCaller(ctx, sessionId, project) {

package/dist/{capture-error.d.ts → capture/capture-error.d.ts}

@@ -1,5 +1,5 @@
-import { type CaptureErrorOutcome } from './capture/failure-reading.js';
-import type { JsonValue } from './json.js';
+import { type CaptureErrorOutcome } from '../store/failure-log.js';
+import type { JsonValue } from '../util/json.js';
 /** Store a failure as an error memory unless it is routine or a repeat, and log it either way, even when storing throws. */
 export declare function captureToolFailure(hippoRoot: string, tenantId: string, payload: JsonValue): CaptureErrorOutcome;
 /** Who sent a failure from another machine: the audit actor and the project its lesson and repeat check belong to. */

package/dist/{capture-error.js → capture/capture-error.js}

@@ -1,13 +1,13 @@
 // `hippo capture-error`, run by the Claude Code PostToolUseFailure hook: routine failures and repeats are not
 // stored, because error memories decay slowly and would crowd out real lessons; what is stored stays `observed`
 // until outcome feedback confirms it. Every failure, stored or not, goes to the failure log.
-import { createMemory } from './memory.js';
-import { writeEntry } from './store/entry-writes.js';
-import { loadContentsWithTag } from './store/entry-reads.js';
-import { loadConfig } from './config.js';
-import { closeHippoDb, openHippoDb } from './db.js';
-import { recordFailure } from './failure-log.js';
-import { failureHash, failureSignature, lessonFromFailure, payloadString, } from './capture/failure-reading.js';
+import { createMemory } from '../core/memory.js';
+import { writeEntry } from '../store/entry-writes.js';
+import { loadContentsWithTag } from '../store/entry-reads.js';
+import { loadConfig } from '../core/config.js';
+import { closeHippoDb, openHippoDb } from '../db/index.js';
+import { recordFailure } from '../store/failure-log.js';
+import { failureHash, failureSignature, lessonFromFailure, payloadString, } from './failure-reading.js';
 /** Store a failure as an error memory unless it is routine or a repeat, and log it either way, even when storing throws. */
 export function captureToolFailure(hippoRoot, tenantId, payload) {
     const lesson = lessonFromFailure(payload);

package/dist/{codex-patch.js → capture/codex-patch.js}

@@ -1,7 +1,7 @@
 // Files named by a Codex apply_patch call, read the way openai/codex codex-rs/apply-patch reads them
 // (parser.rs for the body, invocation.rs for the shell forms it runs as apply_patch).
 import * as path from 'path';
-import { isStringValue } from './capture-contract.js';
+import { isStringValue } from '../core/capture-contract.js';
 /** Codex prints this line only when a patch applied (apply-patch lib.rs). */
 export const PATCH_SUCCESS_LINE = 'Success. Updated the following files:';
 const BEGIN_PATCH = '*** Begin Patch';

package/dist/capture/command.d.ts

@@ -1,4 +1,4 @@
-import { type ProjectRef } from '../project-identity.js';
+import { type ProjectRef } from '../core/project-identity.js';
 import { type ExtractedItem } from './extract.js';
 import { type SessionTurn } from './transcript.js';
 export interface CaptureOptions {
@@ -12,21 +12,13 @@ export interface CaptureOptions {
     stdinText?: string;
     stdinTimedOut?: boolean;
     sessionTurns?: readonly SessionTurn[];
-    /**
-     * Tee stdout/stderr to this log file while capture runs. Mirrors the
-     * pattern used by `hippo sleep --log-file` so the SessionEnd hook output
-     * (invisible during TUI teardown) can be surfaced via `hippo last-sleep`
-     * on the next session start. Appends rather than truncates — `hippo sleep`
-     * writes the same file first in the SessionEnd sequence.
-     */
+    /** Tee stdout/stderr to this log file while capture runs, so SessionEnd output (lost in TUI teardown) shows via `hippo last-sleep`.
+     *  Appends, because `hippo sleep` writes the same file first. */
     logFile?: string;
     dryRun: boolean;
     global: boolean;
-    /**
-     * Tenant scope for the dedup read in `cmdCaptureCore`. When provided
-     * AND `global` is false, the dedup check only considers this tenant's
-     * existing memories. Undefined means host-wide dedup. Ignored when `global: true` (global captures are host-wide).
-     */
+    /** Tenant scope for the dedup read in `cmdCaptureCore`: when set and `global` is false, only this tenant's memories count.
+     *  Undefined means host-wide dedup; ignored when `global: true`. */
     tenantId?: string;
     /** The session's project: rows are stamped with its id, and dedup reads its rows under either name. */
     originProject?: ProjectRef;

package/dist/capture/command.js

@@ -1,30 +1,26 @@
 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/global-store.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) {
-    // Tee stdout/stderr to a log file when --log-file is set. Used by the
-    // SessionEnd hook so output (otherwise swallowed by TUI teardown) surfaces
-    // on the next session start via `hippo last-sleep`. Runs second in the
-    // SessionEnd sequence after `hippo sleep`, so we APPEND rather than
-    // truncate — sleep already wrote its own header + body to this file.
+    // Tee to a log file for the SessionEnd hook; APPEND, because `hippo sleep` runs first in that sequence and already wrote its header and body.
     const restoreStdio = options.logFile ? beginLogTee(options.logFile) : null;
     try {
         cmdCaptureCore(hippoRoot, options);
@@ -41,45 +37,20 @@ export function cmdCapture(hippoRoot, options) {
             restoreStdio();
     }
 }
-/**
- * Append-mode tee: writes a banner line then mirrors every stdout/stderr
- * chunk to `logFile` until the returned restore function is called.
- * Failures to write the log are non-fatal; the real streams still get
- * the data.
- */
+/** Append-mode tee: mirror every stdout/stderr chunk to `logFile` until the returned restore function is called; a log-write failure is non-fatal. */
 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]);
-            // SAFETY: forwarding the exact arguments Node's real overloaded
-            // `write` received is safe regardless of which overload the call
-            // site used — Node dispatches on the actual argument shapes at
-            // runtime, and `StreamWriteArgs` is the union of both overloads'
-            // parameter lists.
+            // SAFETY: forwarding the exact arguments the real overloaded `write` received is safe; `StreamWriteArgs` is the union of both overloads' parameter lists.
             return origWrite(...args);
         };
-        // SAFETY: `wrapped` matches both real `write` overload shapes it's
-        // assigned to; TS can't verify a single implementation covers an
-        // overloaded type, but this one forwards to the real stream method.
+        // SAFETY: `wrapped` matches both real `write` overload shapes; TS cannot verify one implementation covers an overloaded type.
         return wrapped;
     };
     process.stdout.write = wrapWrite(origStdoutWrite);
@@ -89,6 +60,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 +107,27 @@ 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 or project's rows are hidden, 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 +244,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,29 +1,21 @@
-import { type HookRuntime } from '../capture-contract.js';
-/**
- * Log-forgery guard: messages here interpolate payload-controlled values
- * (transcript paths, session ids). Strip C0 control chars — newlines above
- * all — so a crafted value can't inject fake `[hippo] ...` log lines.
- * Exported for every `[hippo]`-prefixed log writer that interpolates
- * payload-controlled values (cli.ts appendSessionEndCloseLog) — one shared
- * guard, not per-file copies.
- */
+import { type HookRuntime } from '../core/capture-contract.js';
+/** 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 declare function sanitizeLogMessage(message: string): string;
 export interface PreCompactOptions {
     stdinText?: string;
     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,
- * so this verb must exit 0 on every path — malformed stdin, missing
- * transcript, and store errors all degrade to a logged no-op rather than a
- * thrown error. Callers (src/cli.ts) must not wrap this in anything that
- * could turn a caught-and-logged failure back 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 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;
 }