hippo-memory 1.64.1 → 1.65.0

package/dist/mcp/request.d.ts

@@ -1,4 +1,11 @@
 import { type McpContext, type McpRequest, type McpResponse } from './protocol.js';
+/**
+ * Record the memory text a recall or context tool returned. Best-effort: a
+ * ledger failure never fails the tool call. Other tools are not recorded.
+ */
+export declare function recordMcpTokens(toolName: string, output: string, ctx?: McpContext): Promise<void>;
+/** The tools listed and run under a store other than hippo.db. */
+export declare const STORE_READY_TOOLS: ReadonlySet<string>;
 /**
  * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
  * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message

package/dist/mcp/request.js

@@ -1,12 +1,15 @@
 // Transport-agnostic request handling: tool dispatch table, tool execution and the JSON-RPC method switch.
 import { log } from '../log.js';
+import { STORE_NOT_PORTED_MESSAGE } from '../http-util.js';
 import { getGlobalRoot, initGlobal } from '../shared.js';
 import { loadConfig } from '../config.js';
 import { resolveTenantId } from '../tenant.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { estimateTokens, recordTokenUse } from '../token-ledger.js';
+import { rethrowIfSqliteBlocked, runWithRequestStores } from '../db.js';
+import { storeFor } from '../store-port.js';
+import { estimateTokens } from '../token-ledger.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { validateToolArgs } from './tool-args.js';
+import { RecallRequestError } from '../api/recall-request.js';
 import { findHippoRoot, isJsonObjectRecord } from './protocol.js';
 import { TOOLS, TOOLS_BY_NAME, ARGS_CHECKED_BY_API } from './tools.js';
 import { runRecallTool, runAssembleTool, runDrillTool, runContextTool } from './recall-tools.js';
@@ -35,7 +38,7 @@ const MCP_TOKEN_SURFACES = new Map([
  * Record the memory text a recall or context tool returned. Best-effort: a
  * ledger failure never fails the tool call. Other tools are not recorded.
  */
-function recordMcpTokens(toolName, output, ctx) {
+export async function recordMcpTokens(toolName, output, ctx) {
     const surface = MCP_TOKEN_SURFACES.get(toolName);
     if (!surface || !output)
         return;
@@ -43,40 +46,41 @@ function recordMcpTokens(toolName, output, ctx) {
         const hippoRoot = ctx?.hippoRoot ?? findHippoRoot();
         if (!hippoRoot)
             return;
-        const db = openHippoDb(hippoRoot);
-        try {
-            recordTokenUse(db, {
-                tenantId: ctx?.tenantId ?? resolveTenantId({}),
-                surface,
-                event: 'inject',
-                items: 0,
-                tokens: estimateTokens(output),
-            });
-        }
-        finally {
-            closeHippoDb(db);
-        }
+        await storeFor({ hippoRoot, store: ctx?.store }).recordTokens({
+            tenantId: ctx?.tenantId ?? resolveTenantId({}),
+            surface,
+            event: 'inject',
+            items: 0,
+            tokens: estimateTokens(output),
+        });
     }
     catch (err) {
+        rethrowIfSqliteBlocked(err);
         log.warnThenDebug('mcp-token-ledger', `token ledger write failed; the tool reply is unaffected: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
-// ── Tool execution ──
 const TOOL_HANDLERS = new Map([
-    ['hippo_recall', runRecallTool],
-    ['hippo_assemble', runAssembleTool],
-    ['hippo_drill', runDrillTool],
-    ['hippo_predict_baserate', runPredictBaserateTool],
-    ['hippo_remember', runRememberTool],
-    ['hippo_outcome', runOutcomeTool],
-    ['hippo_context', runContextTool],
-    ['hippo_status', runStatusTool],
-    ['hippo_learn', runLearnTool],
-    ['hippo_conflicts', runConflictsTool],
-    ['hippo_resolve', runResolveTool],
-    ['hippo_share', runShareTool],
-    ['hippo_peers', runPeersTool],
+    ['hippo_recall', { handler: runRecallTool, storeReady: true }],
+    ['hippo_assemble', { handler: runAssembleTool }],
+    ['hippo_drill', { handler: runDrillTool }],
+    ['hippo_predict_baserate', { handler: runPredictBaserateTool }],
+    ['hippo_remember', { handler: runRememberTool }],
+    ['hippo_outcome', { handler: runOutcomeTool }],
+    ['hippo_context', { handler: runContextTool }],
+    ['hippo_status', { handler: runStatusTool }],
+    ['hippo_learn', { handler: runLearnTool }],
+    ['hippo_conflicts', { handler: runConflictsTool }],
+    ['hippo_resolve', { handler: runResolveTool }],
+    ['hippo_share', { handler: runShareTool }],
+    ['hippo_peers', { handler: runPeersTool }],
 ]);
+/** The tools listed and run under a store other than hippo.db. */
+export const STORE_READY_TOOLS = new Set([...TOOL_HANDLERS].filter(([, entry]) => entry.storeReady).map(([name]) => name));
+/** The served store's kind when it is not hippo.db, else null. */
+function otherStoreKind(ctx) {
+    const kind = ctx?.store?.kind;
+    return kind !== undefined && kind !== 'sqlite' ? kind : null;
+}
 async function executeTool(name, args, ctx) {
     // When a transport hands us a context (HTTP path), trust it: the HTTP
     // server already resolved hippoRoot from its bound opts and tenantId
@@ -89,13 +93,21 @@ async function executeTool(name, args, ctx) {
     // tenant-isolated. Resolved once per tool call: prefer the transport's
     // ctx.tenantId so an HTTP Bearer for tenant B doesn't drop to HIPPO_TENANT.
     const tenantId = ctx?.tenantId ?? resolveTenantId({});
-    const handler = TOOL_HANDLERS.get(name);
+    const handler = TOOL_HANDLERS.get(name)?.handler;
     // handleMcpRequest rejects names missing from TOOLS, so reaching here means TOOLS and this table drifted apart.
     if (!handler)
         throw new Error(`hippo-mcp: tool ${name} is declared but has no handler`);
     return handler({ args, ctx, hippoRoot, config, tenantId });
 }
 // ── Request handling ──
+// The MCP spec reports input validation as a tool result with isError, so the model can read it and retry.
+function invalidArgs(id, toolName, problems) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: { content: [{ type: 'text', text: `Invalid arguments for ${toolName}: ${problems.join('; ')}` }], isError: true },
+    };
+}
 /**
  * Transport-agnostic MCP dispatcher. Both the stdio loop (below) and the
  * HTTP/SSE transport in src/server.ts route every incoming JSON-RPC message
@@ -119,7 +131,7 @@ export async function handleMcpRequest(req, ctx) {
         case 'notifications/initialized':
             return null;
         case 'tools/list':
-            return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+            return { jsonrpc: '2.0', id, result: { tools: otherStoreKind(ctx) ? TOOLS.filter((t) => STORE_READY_TOOLS.has(t.name)) : TOOLS } };
         case 'tools/call': {
             const nameValue = params?.name;
             const toolName = isJsonString(nameValue) ? nameValue : '';
@@ -127,6 +139,10 @@ export async function handleMcpRequest(req, ctx) {
             if (!tool) {
                 return { jsonrpc: '2.0', id, error: { code: -32602, message: `Unknown tool: ${toolName.slice(0, 128)}` } };
             }
+            // The same refusal a ported tool gives when it reaches hippo.db, so a client handles one shape.
+            if (otherStoreKind(ctx) && !STORE_READY_TOOLS.has(toolName)) {
+                return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_NOT_PORTED_MESSAGE } };
+            }
             const refusal = sharedStoreRefusal(toolName, ctx);
             if (refusal !== undefined)
                 return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: refusal }], isError: true } };
@@ -135,17 +151,23 @@ export async function handleMcpRequest(req, ctx) {
                 return { jsonrpc: '2.0', id, error: { code: -32602, message: `${toolName}: arguments must be an object` } };
             }
             const toolArgs = isJsonObjectRecord(argumentsValue) ? argumentsValue : {};
-            // The MCP spec reports input validation as a tool result with isError, so the model can read it and retry.
             const problems = validateToolArgs(tool.inputSchema, toolArgs, ARGS_CHECKED_BY_API.get(toolName));
-            if (problems.length > 0) {
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: { content: [{ type: 'text', text: `Invalid arguments for ${toolName}: ${problems.join('; ')}` }], isError: true },
-                };
+            if (problems.length > 0)
+                return invalidArgs(id, toolName, problems);
+            let output;
+            try {
+                // One handle per store for the tool and its ledger row; stdio interleaves calls, so each gets its own scope.
+                output = await runWithRequestStores(async () => {
+                    const text = await executeTool(toolName, toolArgs, ctx);
+                    await recordMcpTokens(toolName, text, ctx);
+                    return text;
+                });
+            }
+            catch (err) {
+                if (!(err instanceof RecallRequestError))
+                    throw err;
+                return invalidArgs(id, toolName, [err.message]);
             }
-            const output = await executeTool(toolName, toolArgs, ctx);
-            recordMcpTokens(toolName, output, ctx);
             return {
                 jsonrpc: '2.0',
                 id,

package/dist/mcp/session-state.d.ts

@@ -1,6 +1,4 @@
-import type { RingBuffer } from '../recall-history.js';
-export declare const sessionRecallHistoryMcp: Map<string, RingBuffer>;
-/** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
+/** Test-only: reset the MCP recall rings. Call from beforeEach. */
 export declare function __resetSessionRecallHistoryMcp(): void;
 export declare const MAX_RECALL_CLIENTS = 4096;
 export declare const lastRecalledIds: Map<string, string[]>;

package/dist/mcp/session-state.js

@@ -1,10 +1,8 @@
 // Per-process state the MCP tools share across calls: recall rings, last recalled ids, auto-sleep runs.
-// Per-(tenant, session) recall-history rings for the MCP pipeline, kept apart from
-// the CLI/HTTP rings: each pipeline owns its rings, with no IPC between them.
-export const sessionRecallHistoryMcp = new Map();
-/** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
+import { resetSessionRings } from '../api/recall-record.js';
+/** Test-only: reset the MCP recall rings. Call from beforeEach. */
 export function __resetSessionRecallHistoryMcp() {
-    sessionRecallHistoryMcp.clear();
+    resetSessionRings('mcp');
 }
 // ── Track last recalled IDs for outcome feedback ──
 //

package/dist/predictions/planning-fallacy.d.ts

@@ -1,3 +1,6 @@
+import { type AppendAuditOpts } from '../audit.js';
+import { type ForwardClaimMatch } from '../forward-claim-detector.js';
+import { type PredictionBaserate } from './store.js';
 /**
  * Surface delivered on `RecallResult.planningFallacyHint` when an
  * agent's recall query carries a forward-prediction phrase AND the closest
@@ -66,6 +69,49 @@ export interface ComputePlanningFallacyHintOpts {
      *  carry the right attribution instead of the 'cli' default. */
     actor?: string;
 }
+export interface ClassResolution {
+    classTag: string | null;
+    /** True when ≥2 classes tied at the best overlap score AND best ≥ 1.
+     *  Caller emits `recall_autodebias_hint_tiebreak` audit and returns
+     *  null hint (silent — prevents the "show wrong class half the time"
+     *  failure mode the alphabetical-tiebreak alternative would create). */
+    tiebreak: boolean;
+}
+/** The prediction class a forward claim resolves to, and that class's closed-prediction stats when one resolved. */
+export interface PlanningFallacyEvidence extends ClassResolution {
+    readonly baserate: PredictionBaserate | null;
+}
+/** The output a claim earns from its evidence, and the audit row that records the decision when there is one. */
+export interface PlanningFallacyDecision {
+    output: PlanningFallacyOutput;
+    audit?: AppendAuditOpts;
+}
+/**
+ * Resolve a query-token set to a unique best-matching class_tag for the
+ * tenant. Scores by lower-cased token overlap; requires best score ≥ 1
+ * AND strictly greater than the 2nd-best score.
+ *
+ * Indexed via idx_predictions_tenant_class (db.ts:1015) → O(log n) seek
+ * plus a small DISTINCT scan over the per-tenant class-tag set.
+ *
+ * Scope behaviour (deliberate): class_tag selection is TENANT-GLOBAL,
+ * NOT scope-filtered against
+ * the recall's opts.scope. The class_tag is an aggregator label across
+ * historical predictions in the class, not a per-memory scope-bound
+ * property. A no-scope recall CAN surface a class_tag from a privately-
+ * scoped prediction's class in PlanningFallacyHint.classTag — by design,
+ * because base-rate reasoning needs the full historical sample.
+ * Implications:
+ *   - The hint payload itself carries no memory content (only the aggregate
+ *     summary string + numeric stats), so memory bodies do not leak.
+ *   - The class_tag NAME is the side-channel. If sensitive labels are a
+ *     concern, callers should either use opaque class names (e.g. hashes
+ *     or numeric tokens) or set HIPPO_AUTODEBIAS=off.
+ *   - tests/api-recall-autodebias.test.ts locks this with an explicit
+ *     test asserting that scope-set predictions surface via no-scope
+ *     recalls (so future "fix" attempts that scope-filter trip CI).
+ */
+export declare function resolveClassFromTokens(hippoRoot: string, tenantId: string, queryTokens: readonly string[]): ClassResolution;
 /**
  * Planning-fallacy orchestrator.
  *
@@ -92,4 +138,10 @@ export interface ComputePlanningFallacyHintOpts {
  * Latency budget: well under 50ms; a miss pays only the regex.
  */
 export declare function computePlanningFallacyOutput(hippoRoot: string, tenantId: string, queryText: string, opts?: ComputePlanningFallacyHintOpts): PlanningFallacyOutput;
+/** The forward claim in a recall query; null when HIPPO_AUTODEBIAS=off, the query is empty or no claim matches. */
+export declare function detectPlanningClaim(queryText: string, opts?: ComputePlanningFallacyHintOpts): ForwardClaimMatch | null;
+/** Resolves a claim's tokens to one class and reads its baserate, writing no audit row. */
+export declare function planningFallacyEvidenceAt(hippoRoot: string, tenantId: string, classQueryTokens: readonly string[]): PlanningFallacyEvidence;
+/** The hint, the watching variant or nothing for a claim and its class evidence; reads and writes nothing itself. */
+export declare function decidePlanningFallacy(match: ForwardClaimMatch, evidence: PlanningFallacyEvidence, tenantId: string, actor: string): PlanningFallacyDecision;
 //# sourceMappingURL=planning-fallacy.d.ts.map

package/dist/predictions/planning-fallacy.js

@@ -28,7 +28,7 @@ import { computePredictionBaserate } from './store.js';
  *     test asserting that scope-set predictions surface via no-scope
  *     recalls (so future "fix" attempts that scope-filter trip CI).
  */
-function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
+export function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
     if (queryTokens.length === 0)
         return { classTag: null, tiebreak: false };
     const db = openHippoDb(hippoRoot);
@@ -100,56 +100,69 @@ function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
  * Latency budget: well under 50ms; a miss pays only the regex.
  */
 export function computePlanningFallacyOutput(hippoRoot, tenantId, queryText, opts = {}) {
-    // Env read FIRST so AUTODEBIAS=off pays zero regex cost. Per-call read
-    // (rather than module-load cache) is deliberate: tests env-toggle this
-    // via process.env mutation without module reload.
-    const mode = opts.mode ?? (envAutodebiasOff() ? 'off' : 'regex');
-    if (mode === 'off')
-        return {};
-    if (!queryText)
-        return {};
-    const match = detectForwardClaim(queryText);
+    const match = detectPlanningClaim(queryText, opts);
     if (!match)
         return {};
     const actor = opts.actor ?? 'recall';
-    const resolution = resolveClassFromTokens(hippoRoot, tenantId, match.classQueryTokens);
-    if (resolution.tiebreak) {
+    const { output, audit } = decidePlanningFallacy(match, planningFallacyEvidenceAt(hippoRoot, tenantId, match.classQueryTokens), tenantId, actor);
+    if (audit)
+        appendAuditEventOnce(hippoRoot, audit);
+    return output;
+}
+/** The forward claim in a recall query; null when HIPPO_AUTODEBIAS=off, the query is empty or no claim matches. */
+export function detectPlanningClaim(queryText, opts = {}) {
+    // Env read FIRST so AUTODEBIAS=off pays zero regex cost; read per call so tests can toggle it without a module reload.
+    const mode = opts.mode ?? (envAutodebiasOff() ? 'off' : 'regex');
+    if (mode === 'off')
+        return null;
+    if (!queryText)
+        return null;
+    return detectForwardClaim(queryText);
+}
+/** Resolves a claim's tokens to one class and reads its baserate, writing no audit row. */
+export function planningFallacyEvidenceAt(hippoRoot, tenantId, classQueryTokens) {
+    const resolution = resolveClassFromTokens(hippoRoot, tenantId, classQueryTokens);
+    // emitAudit=false: the recall_autodebias_hint row carries n_closed and mean_ratio, so predict_baserate stays off.
+    const baserate = resolution.classTag ? computePredictionBaserate(hippoRoot, tenantId, resolution.classTag, 'recall', false) : null;
+    return { ...resolution, baserate };
+}
+/** The hint, the watching variant or nothing for a claim and its class evidence; reads and writes nothing itself. */
+export function decidePlanningFallacy(match, evidence, tenantId, actor) {
+    if (evidence.tiebreak) {
         // Telemetry: forward-claim detected, ≥2 classes tied at best overlap. The watching variant lets the
         // caller render "watching but no baserate (tiebreak)"; the audit channel stays the source of truth.
-        return watchingWithAudit(hippoRoot, tenantId, actor, match, 'tiebreak', TIEBREAK_SUGGESTION);
+        return watchingWithAudit(tenantId, actor, match, 'tiebreak', TIEBREAK_SUGGESTION);
     }
-    if (!resolution.classTag) {
-        // Telemetry: forward-claim detected, no class scored ≥ 1. High volume here means regex+token-overlap
-        // misses real forward-claims with no class signal, the case for an embedding fallback.
-        // The watching variant lets the caller render "watching but no baserate (no class match)".
-        return watchingWithAudit(hippoRoot, tenantId, actor, match, 'no_class_match', NO_CLASS_MATCH_SUGGESTION);
+    if (!evidence.classTag) {
+        // Telemetry: no class scored ≥ 1. High volume here means regex+token-overlap misses real forward-claims
+        // with no class signal, the case for an embedding fallback.
+        return watchingWithAudit(tenantId, actor, match, 'no_class_match', NO_CLASS_MATCH_SUGGESTION);
     }
-    // emitAudit=false: avoid double-write to predict_baserate channel.
-    // The recall_autodebias_hint audit below carries n_closed + mean_ratio.
-    const baserate = computePredictionBaserate(hippoRoot, tenantId, resolution.classTag, actor, 
-    /*emitAudit=*/ false);
-    if (baserate.nClosed === 0)
-        return {}; // Silent — wait for closed data.
-    appendAuditEventOnce(hippoRoot, {
-        tenantId,
-        actor,
-        op: 'recall_autodebias_hint',
-        targetId: resolution.classTag,
-        metadata: {
-            class_tag: resolution.classTag,
-            detected_phrase: match.phrase,
-            n_closed: baserate.nClosed,
-            mean_ratio: baserate.meanRatio,
-        },
-    });
+    const baserate = evidence.baserate;
+    if (!baserate || baserate.nClosed === 0)
+        return { output: {} }; // Silent — wait for closed data.
     return {
-        hint: {
-            classTag: resolution.classTag,
-            baserateSummary: baserate.summary,
-            source: 'j3.2-auto',
-            detectedPhrase: match.phrase,
-            nClosed: baserate.nClosed,
-            meanRatio: baserate.meanRatio,
+        output: {
+            hint: {
+                classTag: evidence.classTag,
+                baserateSummary: baserate.summary,
+                source: 'j3.2-auto',
+                detectedPhrase: match.phrase,
+                nClosed: baserate.nClosed,
+                meanRatio: baserate.meanRatio,
+            },
+        },
+        audit: {
+            tenantId,
+            actor,
+            op: 'recall_autodebias_hint',
+            targetId: evidence.classTag,
+            metadata: {
+                class_tag: evidence.classTag,
+                detected_phrase: match.phrase,
+                n_closed: baserate.nClosed,
+                mean_ratio: baserate.meanRatio,
+            },
         },
     };
 }
@@ -165,19 +178,21 @@ function appendAuditEventOnce(hippoRoot, event) {
         closeHippoDb(db);
     }
 }
-function watchingWithAudit(hippoRoot, tenantId, actor, match, reason, suggestion) {
-    appendAuditEventOnce(hippoRoot, {
-        tenantId,
-        actor,
-        op: reason === 'tiebreak' ? 'recall_autodebias_hint_tiebreak' : 'recall_autodebias_hint_no_class_match',
-        targetId: match.phrase.slice(0, 100),
-        metadata: { detected_phrase: match.phrase, token_count: match.classQueryTokens.length },
-    });
+function watchingWithAudit(tenantId, actor, match, reason, suggestion) {
     return {
-        watching: {
-            detectedPhrase: match.phrase,
-            reason,
-            suggestion,
+        output: {
+            watching: {
+                detectedPhrase: match.phrase,
+                reason,
+                suggestion,
+            },
+        },
+        audit: {
+            tenantId,
+            actor,
+            op: reason === 'tiebreak' ? 'recall_autodebias_hint_tiebreak' : 'recall_autodebias_hint_no_class_match',
+            targetId: match.phrase.slice(0, 100),
+            metadata: { detected_phrase: match.phrase, token_count: match.classQueryTokens.length },
         },
     };
 }

package/dist/recall-trace.d.ts

@@ -173,7 +173,7 @@ export interface DeliveryEventRow {
 }
 /** One event plus its candidates in one write transaction, then prune; fail-soft. The caller must not hold a transaction on `db`. */
 export declare function writeDeliveryEvent(db: DatabaseSyncLike, input: DeliveryEventInput): number | null;
-/** Write on a short-lived connection that waits at most {@link DELIVERY_LEDGER_WAIT_MS} for the lock. Fail-soft. */
+/** Write on the request's handle, or a short-lived one, waiting at most {@link DELIVERY_LEDGER_WAIT_MS} for the lock. Fail-soft. */
 export declare function writeDeliveryEventAtRoot(root: string, input: DeliveryEventInput): number | null;
 /** On a caller's open handle, which saves a second open and close per turn; the handle's own lock wait comes back after. */
 export declare function writeDeliveryEventOnHandle(db: DatabaseSyncLike, input: DeliveryEventInput): number | null;

package/dist/recall-trace.js

@@ -15,7 +15,7 @@
  * new debug env var).
  */
 import { createHash } from 'node:crypto';
-import { openHippoDb, closeHippoDb } from './db.js';
+import { openHippoDb, closeHippoDb, rethrowIfSqliteBlocked } from './db.js';
 import { DELIVERY_LEDGER_VERSION } from './delivery-recorder.js';
 import { log } from './log.js';
 /**
@@ -109,6 +109,7 @@ export function writeRecallTraceAtRoot(root, input) {
         db = openHippoDb(root);
     }
     catch (error) {
+        rethrowIfSqliteBlocked(error);
         log.error(`recall trace connection failed: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
@@ -267,11 +268,11 @@ export function writeDeliveryEvent(db, input) {
         return null;
     }
 }
-/** Write on a short-lived connection that waits at most {@link DELIVERY_LEDGER_WAIT_MS} for the lock. Fail-soft. */
+/** Write on the request's handle, or a short-lived one, waiting at most {@link DELIVERY_LEDGER_WAIT_MS} for the lock. Fail-soft. */
 export function writeDeliveryEventAtRoot(root, input) {
     let db;
     try {
-        db = openHippoDb(root, { busyWaitMs: DELIVERY_LEDGER_WAIT_MS });
+        db = openHippoDb(root);
     }
     catch (error) {
         // Same hook stderr line as writeDeliveryEvent above.
@@ -279,7 +280,7 @@ export function writeDeliveryEventAtRoot(root, input) {
         return null;
     }
     try {
-        return writeDeliveryEvent(db, input);
+        return writeDeliveryEventOnHandle(db, input);
     }
     finally {
         closeHippoDb(db);

package/dist/search/physics-search.js

@@ -6,7 +6,7 @@ import { resolveEmbeddingProvider } from '../embedding-provider.js';
 import { physicsScore as computePhysicsScores, computeMass } from '../physics.js';
 import { DEFAULT_PHYSICS_CONFIG } from '../physics-config.js';
 import { loadPhysicsState } from '../physics-state.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
+import { openHippoDb, closeHippoDb, rethrowIfSqliteBlocked } from '../db.js';
 import { compareScoredResults } from '../compare.js';
 import { log } from '../log.js';
 import { churnStaleFactor, summaryMultipliers, summaryScoring } from './boosts.js';
@@ -57,6 +57,7 @@ async function physicsQueryVector(query, root, given) {
         return vec && vec.length > 0 ? vec : null;
     }
     catch (err) {
+        rethrowIfSqliteBlocked(err);
         log.debug(`physics search: query embed failed, using hybrid: ${err instanceof Error ? err.message : String(err)}`);
         return null;
     }
@@ -68,6 +69,7 @@ function withVectorCandidates(root, entries, queryVector, spec) {
         return [...entries, ...vectorCandidatesOutside(root, entries, queryVector, spec)];
     }
     catch (err) {
+        rethrowIfSqliteBlocked(err);
         log.warn(`physics search ranked the lexical pool only; the vector lookup failed: ${err instanceof Error ? err.message : String(err)}`);
         return entries;
     }
@@ -84,6 +86,7 @@ function loadCandidateParticles(root, pool) {
         }
     }
     catch (err) {
+        rethrowIfSqliteBlocked(err);
         log.debug(`physics search: state load failed, using hybrid: ${err instanceof Error ? err.message : String(err)}`);
         return null;
     }

package/dist/search/vector.js

@@ -1,6 +1,7 @@
 import { cosineSimilarity, embeddingModelRequiresReindex, hasEmbeddings, loadStoredVectors } from '../embeddings.js';
 import { loadVectorCandidateEntries } from '../store/search-rows.js';
 import { resolveEmbeddingProvider } from '../embedding-provider.js';
+import { rethrowIfSqliteBlocked } from '../db.js';
 import { log } from '../log.js';
 import { redactSecretsStrict } from '../secret-detect.js';
 import { currentEntries } from './as-of.js';
@@ -22,6 +23,7 @@ export async function resolveVectorArm(query, entries, options) {
         await fillVectorArm(arm, query, options.hippoRoot, options);
     }
     catch (err) {
+        rethrowIfSqliteBlocked(err);
         warnBm25Fallback('error', err instanceof Error ? err.message : String(err));
     }
     return arm;

package/dist/server/routes/recall.d.ts

@@ -1,5 +1,5 @@
 import type { RouteRequest } from '../types.js';
-/** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
+/** Test-only: reset the HTTP recall rings. Call from beforeEach. */
 export declare function __resetSessionRecallHistoryHttp(): void;
 export declare function handleRecallMemories({ req, res, opts, query }: RouteRequest): Promise<void>;
 export declare function handleAssembleSession({ req, res, opts, query }: RouteRequest, assembleMatch: Record<string, string>): Promise<void>;