hippo-memory 1.59.0 → 1.61.0

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

@@ -0,0 +1,11 @@
+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. */
+export declare function __resetSessionRecallHistoryMcp(): void;
+export declare const lastRecalledIds: Map<string, string[]>;
+export declare const autoSleepInFlight: Set<string>;
+export declare function resolveClientKey(ctx: {
+    clientKey?: string;
+    tenantId: string;
+} | undefined): string;
+//# sourceMappingURL=session-state.d.ts.map

package/dist/mcp/session-state.js

@@ -0,0 +1,28 @@
+// Per-process state the MCP tools share across calls: recall rings, last recalled ids, auto-sleep runs.
+// v0.33 / J1 — Module-level per-(tenant, session) recall-history ring map
+// for the MCP pipeline. Separate from CLI/HTTP rings per plan v3
+// architecture (per-pipeline rings; no IPC).
+export const sessionRecallHistoryMcp = new Map();
+/** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
+export function __resetSessionRecallHistoryMcp() {
+    sessionRecallHistoryMcp.clear();
+}
+// ── Track last recalled IDs for outcome feedback ──
+//
+// Keyed per-client so two HTTP-MCP clients hitting the same tenant cannot
+// poison each other's outcome feedback. The key is `ctx.clientKey` when the
+// transport supplies one (HTTP-MCP via src/server.ts builds
+// hash(bearer+remoteAddr)); stdio and any caller without a clientKey falls
+// back to `'stdio-${pid}'` (one process = one client) or
+// `${tenantId}:default` if a McpContext is constructed in tests without a
+// pid-bound transport.
+export const lastRecalledIds = new Map();
+export const autoSleepInFlight = new Set();
+export function resolveClientKey(ctx) {
+    if (ctx?.clientKey)
+        return ctx.clientKey;
+    if (ctx?.tenantId)
+        return `stdio-${process.pid}:${ctx.tenantId}`;
+    return `stdio-${process.pid}:default`;
+}
+//# sourceMappingURL=session-state.js.map

package/dist/mcp/stdio.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wire stdin/stdout to the dispatcher. Idempotent — only the entrypoint
+ * (cli.ts `hippo mcp`, or running this file directly) should call this.
+ * src/server.ts imports `handleMcpRequest` without invoking this, so the
+ * HTTP daemon does not steal stdin or exit when its parent closes a pipe.
+ */
+export declare function startStdioLoop(): void;
+//# sourceMappingURL=stdio.d.ts.map

package/dist/mcp/stdio.js

@@ -0,0 +1,79 @@
+// Stdio transport: newline-delimited JSON-RPC frames in on stdin, replies out on stdout.
+import { errorFields, log } from '../log.js';
+import { parseFrame } from './framing.js';
+import { mcpErrorResponse, isJsonObjectRecord, isJsonString } from './protocol.js';
+import { handleMcpRequest } from './request.js';
+// MCP stdio transport spec: messages are newline-delimited JSON-RPC, no embedded newlines.
+// https://modelcontextprotocol.io/specification/.../basic/transports#stdio
+function send(msg) {
+    process.stdout.write(JSON.stringify(msg) + '\n');
+}
+// ── Stdio transport ──
+let buffer = Buffer.alloc(0);
+// Only method is checked: handleMcpRequest narrows params where it reads them, as the HTTP transport does.
+function isRoutableRequest(v) {
+    return isJsonObjectRecord(v) && isJsonString(v.method);
+}
+function dispatch(body) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        log.debug('mcp: answered a frame that is not valid JSON with a parse error');
+        send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+        return;
+    }
+    // A frame without a string method cannot be routed; dropping it keeps a stray value from crashing the process.
+    if (!isRoutableRequest(parsed))
+        return;
+    const req = parsed;
+    if (req.method.startsWith('notifications/')) {
+        handleMcpRequest(req).catch((err) => {
+            log.error(`mcp notification ${req.method} failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        return;
+    }
+    handleMcpRequest(req).then((resp) => { if (resp)
+        send(resp); }).catch((err) => {
+        send(mcpErrorResponse(req.id, err));
+    });
+}
+/**
+ * Wire stdin/stdout to the dispatcher. Idempotent — only the entrypoint
+ * (cli.ts `hippo mcp`, or running this file directly) should call this.
+ * src/server.ts imports `handleMcpRequest` without invoking this, so the
+ * HTTP daemon does not steal stdin or exit when its parent closes a pipe.
+ */
+export function startStdioLoop() {
+    process.stdin.on('data', (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        while (true) {
+            const result = parseFrame(buffer);
+            if (result.kind === 'incomplete')
+                break;
+            buffer = result.rest;
+            if (result.kind === 'message')
+                dispatch(result.body);
+        }
+    });
+    process.stdin.on('end', () => process.exit(0));
+    // After an uncaught throw the process state is unknown, so log the cause and exit for the client to restart the server.
+    const crash = (kind, err) => {
+        log.error(`mcp ${kind}: ${err instanceof Error ? err.message : String(err)}`, errorFields(err));
+        exitAfterFlush(1);
+    };
+    process.on('uncaughtException', (err) => crash('uncaught exception', err));
+    process.on('unhandledRejection', (err) => crash('unhandled rejection', err));
+}
+/** Exit once stdout and stderr have drained, so the last reply and the crash log reach the client; capped at 1 s. */
+function exitAfterFlush(code) {
+    process.exitCode = code;
+    let pending = 2;
+    const done = () => { if (--pending === 0)
+        process.exit(code); };
+    process.stdout.write('', done);
+    process.stderr.write('', done);
+    setTimeout(() => process.exit(code), 1000).unref();
+}
+//# sourceMappingURL=stdio.js.map

package/dist/mcp/tools.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInputSchema } from './tool-args.js';
+interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+}
+export declare const TOOLS: readonly McpToolDefinition[];
+export declare const TOOLS_BY_NAME: Map<string, McpToolDefinition>;
+export declare const ARGS_CHECKED_BY_API: Map<string, ReadonlySet<string>>;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/mcp/tools.js

@@ -0,0 +1,247 @@
+// Tool definitions and input schemas served by tools/list.
+// ── Tool definitions ──
+// HTTP sets no budget cap; 25x the 4000 recall default leaves room for large-context clients while bounding one call's work.
+const MAX_BUDGET_TOKENS = 100_000;
+// Same ceiling as the HTTP list routes' parseListLimit.
+const MAX_LIST_LIMIT = 1000;
+export const TOOLS = [
+    {
+        name: 'hippo_recall',
+        description: 'Retrieve relevant memories from the project memory store. Returns memories ranked by relevance, strength, and recency within the token budget. Use at session start or when you need context about a topic. Pass include_continuity=true to also surface the active task snapshot, latest matching session handoff, and recent session events as a "## Continuity" appendix.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'What to search for in memory (natural language)' },
+                budget: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: MAX_BUDGET_TOKENS,
+                    description: `Max tokens to return (default: config.defaultBudget, 4000; max ${MAX_BUDGET_TOKENS})`,
+                },
+                include_continuity: {
+                    type: 'boolean',
+                    description: 'Append continuity context (active snapshot + handoff + last 5 session events) below the memory results. Useful at session boot.',
+                },
+                scope: {
+                    type: 'string',
+                    description: 'Restrict results and continuity to memories/rows matching this scope exactly. When omitted, default-deny applies to ANY <source>:private:* (slack, github, ...) and unknown-legacy rows.',
+                },
+                fresh_tail_count: {
+                    type: 'number',
+                    description: 'When > 0, surface the last N kind=raw rows tagged isFreshTail=true regardless of query match. Useful for "what did I just see" continuity. Capped at 200.',
+                },
+                fresh_tail_session_id: {
+                    type: 'string',
+                    description: 'Restrict the fresh-tail window to a specific session. Without this, fresh-tail is tenant-wide (legacy v1.5.2 behaviour, pre-v1.6.3 default).',
+                },
+                summarize_overflow: {
+                    type: 'boolean',
+                    description: 'When true (default), entries that overflow the limit and share a level-2 parent summary cause that summary to be appended in their place. Set false for strict-limit behaviour.',
+                },
+                scorer_window: {
+                    type: 'number',
+                    description: 'How many of the top-ranked memories the fresh-tail and summarize-overflow appendix is worked out against. The main list ranks the whole tenant store, so scorer_window does not narrow it. Default 200. Rejected as RecallContractError code=invalid_scorer_window if 0/negative/non-finite/non-numeric.',
+                },
+                session_id: {
+                    type: 'string',
+                    maxLength: 256,
+                    description: 'Optional session id (v1.7.4). When set AND (tenant, session) has active goals, applies the dlPFC goal-stack boost to the ranked memories before formatting. Mirrors fresh_tail_session_id shape (256-char cap).',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'hippo_assemble',
+        description: 'Build a chronologically-ordered context window for a session. Returns ordered items: fresh-tail raw rows + level-2 summary substitutions for older rows + budget-fit. Hippo-additive vs lossless-claw: eviction picks lowest-strength non-fresh-tail items first instead of oldest-first. Tenant-scoped; default-deny on private scopes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: {
+                    type: 'string',
+                    description: 'Session identifier. Returns clean empty result if no kind=raw rows match.',
+                },
+                budget: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: MAX_BUDGET_TOKENS,
+                    description: `Token budget for the assembled context (default 4000; max ${MAX_BUDGET_TOKENS}). Eviction kicks in over budget.`,
+                },
+                fresh_tail_count: {
+                    type: 'number',
+                    description: 'Recent raw rows always kept verbatim (default 10). These are never evicted.',
+                },
+                summarize_older: {
+                    type: 'boolean',
+                    description: 'When true (default), older raws sharing a level-2 parent summary get substituted. Set false to keep every older raw as-is.',
+                },
+                scope: {
+                    type: 'string',
+                    description: 'Restrict to memories whose scope matches exactly. When omitted, default-deny applies to ANY <source>:private:* scope and unknown:legacy rows. Pass an explicit scope to assemble a private session with consent.',
+                },
+            },
+            required: ['session_id'],
+        },
+    },
+    {
+        name: 'hippo_drill',
+        description: 'Walk one step down the DAG from a level-2+ topic summary to its direct children. Companion to hippo_recall: when recall returns an item with isSummary=true and substitutedFor=[ids], pass the summary id here to recover the original detail. Tenant-scoped; default-deny on private scopes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                summary_id: {
+                    type: 'string',
+                    description: 'ID of the level-2 (or higher) summary to drill into. Must be a summary, not a leaf — leaves are not drillable.',
+                },
+                limit: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: MAX_LIST_LIMIT,
+                    description: `Max children to return (default 50; max ${MAX_LIST_LIMIT}).`,
+                },
+                budget: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: MAX_BUDGET_TOKENS,
+                    description: `Max total token cost (~ chars/4) of returned children (max ${MAX_BUDGET_TOKENS}). Truncates chronologically.`,
+                },
+                depth: {
+                    type: 'integer',
+                    minimum: 1,
+                    maximum: 10,
+                    description: 'v0.30 / E5: walk N levels down (default 1 = direct children only). Higher values include children of children. Token budget remains GLOBAL across levels. Hard cap 10.',
+                },
+            },
+            required: ['summary_id'],
+        },
+    },
+    {
+        name: 'hippo_remember',
+        description: 'Store a new memory. Use when you learn something non-obvious, hit an error, or discover a useful pattern. Memories decay over time unless retrieved. Errors get 2x half-life.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'The memory to store (1-2 sentences, specific and concrete)',
+                },
+                error: { type: 'boolean', description: 'Mark as error memory (doubles half-life)' },
+                pin: { type: 'boolean', description: 'Pin memory (never decays)' },
+                tag: { type: 'string', description: 'Optional tag for categorization' },
+            },
+            required: ['text'],
+        },
+    },
+    {
+        name: 'hippo_outcome',
+        description: 'Report whether recalled memories were useful. Strengthens good memories (+5 days half-life) and weakens bad ones (-3 days). Call after completing work.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                good: {
+                    type: 'boolean',
+                    description: 'true = memories helped, false = memories were irrelevant',
+                },
+            },
+            required: ['good'],
+        },
+    },
+    {
+        name: 'hippo_context',
+        description: 'Smart context injection: auto-detects current task from git state and returns relevant memories plus the active task snapshot, session handoff and recent session trail (the same bundle as GET /v1/context). Use at the start of any session. Memories and those sections are scope-filtered: a no-scope caller does NOT see ANY <source>:private:* (slack, github, ...) or legacy-quarantine rows.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                budget: {
+                    type: 'number',
+                    minimum: 0,
+                    maximum: MAX_BUDGET_TOKENS,
+                    description: `Max tokens (default: config.defaultContextBudget, 3000; max ${MAX_BUDGET_TOKENS})`,
+                },
+                scope: {
+                    type: 'string',
+                    description: 'Restrict memories, snapshot, handoff and trail to this scope exactly. When omitted, default-deny applies to ANY <source>:private:* (slack, github, ...) and unknown-legacy rows.',
+                },
+            },
+        },
+    },
+    {
+        name: 'hippo_status',
+        description: 'Check memory health: counts, strengths, at-risk memories, last consolidation time.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'hippo_learn',
+        description: 'Scan recent git commits for lessons from fix/revert/bug/refactor/perf patterns. Run after coding sessions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                days: { type: 'number', description: 'Days to scan back (default: 7)' },
+            },
+        },
+    },
+    {
+        name: 'hippo_conflicts',
+        description: 'List open memory conflicts — contradictory memories that need resolution.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'hippo_resolve',
+        description: 'Resolve a memory conflict by keeping one memory and weakening or deleting the other.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                conflict_id: { type: 'number', description: 'The conflict ID to resolve' },
+                keep: { type: 'string', description: 'ID of the memory to keep' },
+                forget: { type: 'boolean', description: 'Delete the loser instead of weakening (default: false)' },
+                rejectLoser: { type: 'boolean', description: 'Tombstone the loser\'s value too, so it refuses re-ingestion (implies removal; default: false)' },
+                reason: { type: 'string', description: 'Reason recorded on the tombstone when rejectLoser is set (default: a conflict-context string)' },
+            },
+            required: ['conflict_id', 'keep'],
+        },
+    },
+    {
+        name: 'hippo_share',
+        description: 'Share a memory to the global store for cross-project use with transfer scoring.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID to share' },
+                force: { type: 'boolean', description: 'Share even if transfer score is low' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'hippo_peers',
+        description: 'List all projects that have contributed memories to the global shared store.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'hippo_predict_baserate',
+        description: 'J3 reference-class / planning-fallacy detector. Get base-rate stats for closed predictions in a class. Call this when you make a forward-looking claim (effort estimate, rollout risk, deadline) to anchor on the past track record rather than the inside view. Returns count + mean estimate + mean actual + mean ratio + median ratio + MAE + a human-readable summary. Tenant-scoped.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                class_tag: {
+                    type: 'string',
+                    description: 'Cohort label, e.g. "migration-effort", "rollout-risk", "deadline-week". Must match the class_tag used when the predictions were created via hippo_predict (or `hippo predict ...`).',
+                },
+            },
+            required: ['class_tag'],
+        },
+    },
+];
+export const TOOLS_BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));
+// api.retrieve rejects these itself, so MCP and HTTP callers get the same typed error code for the same bad value.
+export const ARGS_CHECKED_BY_API = new Map([['hippo_recall', new Set(['scorer_window'])]]);
+//# sourceMappingURL=tools.js.map

package/dist/memory.d.ts

@@ -135,19 +135,21 @@ export declare function _resetLossAversionRatioCacheForTests(): void;
  * Modulates effective half-life: memories with consistent positive outcomes
  * decay slower; consistent negative outcomes decay faster.
  */
-export declare function calculateRewardFactor(entry: MemoryEntry): number;
+export declare function calculateRewardFactor(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>): number;
 /**
  * Net wrongness: bad outcome marks past good ones, never below zero.
  * Strength halves per unit (capped at 3) and recall stops strengthening
  * the memory, so a correction outranks pinning, error tags and heavy recall.
  */
-export declare function netWrong(entry: MemoryEntry): number;
+export declare function netWrong(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>): number;
 /**
  * Options for decay basis.
  * - clock: wall-clock time (default pre-v0.15)
  * - session: decay by sleep cycle count (for intermittent agents)
  * - adaptive: auto-scale half-life by session frequency (default v0.15+)
  */
+/** What calculateStrength reads, so a caller can score a row without loading its text. */
+export type StrengthInputs = Pick<MemoryEntry, 'pinned' | 'created' | 'last_retrieved' | 'half_life_days' | 'retrieval_count' | 'emotional_valence' | 'outcome_positive' | 'outcome_negative'>;
 export interface DecayOptions {
     decayBasis?: 'clock' | 'session' | 'adaptive';
     /** Average interval between sleep cycles, in days. Used by 'adaptive' and 'session' modes. */
@@ -166,7 +168,10 @@ export interface DecayOptions {
  *
  * Pinned memories skip time decay; being marked wrong still fades them (netWrong).
  */
-export declare function calculateStrength(entry: MemoryEntry, now?: Date, options?: DecayOptions): number;
+export declare function calculateStrength(entry: StrengthInputs, now?: Date, options?: DecayOptions): number;
+/** calculateStrength's clock-basis formula as SQL over `memories` columns, flags and multipliers baked in; keep in step.
+ *  An unparseable date scores NULL here and 0 in JS, so sums agree. */
+export declare function strengthSql(now: Date): string;
 /**
  * Derive half-life based on signals, as per PLAN.md table.
  */

package/dist/memory.js

@@ -2,6 +2,7 @@
  * Core data model for Hippo memory entries.
  * Based on the strength formula from PLAN.md.
  */
+import { envLossAversionRatio } from './env.js';
 import { BadRequestError } from './api-errors.js';
 import { randomUUID } from 'crypto';
 import { isDecayAblated, isOutcomeSlowAblated, isRecallBoostAblated, evalNow, } from './ablation.js';
@@ -80,7 +81,7 @@ let _lossAversionRatioCache;
 function getLossAversionRatio() {
     if (_lossAversionRatioCache !== undefined)
         return _lossAversionRatioCache;
-    const raw = process.env.HIPPO_LOSS_AVERSION_RATIO;
+    const raw = envLossAversionRatio();
     if (raw === undefined || raw === '') {
         _lossAversionRatioCache = 1.0;
         return 1.0;
@@ -231,6 +232,31 @@ now = evalNow(), options = {}) {
     const clamped = Math.min(1.0, Math.max(0.0, raw));
     return Number.isFinite(clamped) ? clamped * wrongPenalty : 0.0;
 }
+/** calculateStrength's clock-basis formula as SQL over `memories` columns, flags and multipliers baked in; keep in step.
+ *  An unparseable date scores NULL here and 0 in JS, so sums agree. */
+export function strengthSql(now) {
+    const num = (n) => (Number.isInteger(n) ? n.toFixed(1) : String(n));
+    const pos = 'COALESCE(outcome_positive, 0)';
+    const neg = 'COALESCE(outcome_negative, 0)';
+    const wrong = isOutcomeSlowAblated() || isDecayAblated() ? '0' : `MAX(0, ${neg} - ${pos})`;
+    const reward = isOutcomeSlowAblated()
+        ? '1.0'
+        : `(CASE WHEN ${pos} = 0 AND ${neg} = 0 THEN 1.0 ELSE 1.0 + 0.5 * (${pos} - ${neg}) / (${pos} + ${neg} + 1.0) END)`;
+    const halfLife = `(COALESCE(half_life_days, 7) * ${reward})`;
+    const anchor = isRecallBoostAblated() ? 'created' : 'last_retrieved';
+    const nowJulian = num(now.getTime() / 86400000 + 2440587.5);
+    const decay = isDecayAblated() ? '1.0' : `pow(0.5, (${nowJulian} - julianday(${anchor})) / ${halfLife})`;
+    const boost = isRecallBoostAblated()
+        ? '1.0'
+        : `(CASE WHEN ${wrong} > 0 THEN 1.0 ELSE 1.0 + 0.1 * log2(COALESCE(retrieval_count, 0) + 1) END)`;
+    const valences = /* SAFETY: a Record keyed by EmotionalValence */ Object.keys(EMOTIONAL_MULTIPLIERS);
+    const emotion = `(CASE COALESCE(emotional_valence, 'neutral') ${valences
+        .map((v) => `WHEN '${v}' THEN ${num(applyLossAversionRatio(v, EMOTIONAL_MULTIPLIERS[v]))}`)
+        .join(' ')} ELSE 1.0 END)`;
+    const penalty = `pow(0.5, MIN(${wrong}, ${MAX_WRONG_HALVINGS}))`;
+    return `(CASE WHEN pinned THEN ${penalty} WHEN ${halfLife} <= 0 THEN 0.0
+    ELSE MIN(1.0, MAX(0.0, ${decay} * ${boost} * ${emotion})) * ${penalty} END)`;
+}
 /**
  * Derive half-life based on signals, as per PLAN.md table.
  */

package/dist/multihop.d.ts

@@ -1,5 +1,5 @@
 import type { MemoryEntry } from './memory.js';
-import { type ResultCost, type SearchResult } from './search.js';
+import type { ResultCost, SearchResult } from './search/types.js';
 export declare function multihopSearch(query: string, entries: MemoryEntry[], options?: {
     budget?: number;
     now?: Date;

package/dist/multihop.js

@@ -1,4 +1,5 @@
-import { fitBudget, search } from './search.js';
+import { fitBudget } from './search/finalize.js';
+import { search } from './search/bm25-search.js';
 export function multihopSearch(query, entries, options = {}) {
     const budget = options.budget ?? 4000;
     // Pass 1 searches wide to find entities, so each return fits the caller's budget, as search() does.

package/dist/owner-validation.js

@@ -10,6 +10,7 @@
  * to reject + exit. Strict mode will become the default once A5 v2 lands
  * (see `TODOS.md` A3 follow-ups for the migration path).
  */
+import { processEnv } from './env.js';
 export const OWNER_RE = /^(user|agent):[A-Za-z0-9_-]+$/;
 export const OWNER_CONTRACT_HINT = 'Must match ^(user|agent):[A-Za-z0-9_-]+$ (e.g. user:alice, agent:capture-bot).';
 /**
@@ -50,7 +51,7 @@ export function validateOwner(owner, opts = {}) {
  * Returns true when strict-owner enforcement is enabled via env var.
  * Centralised here so any future bump to default-strict is one edit.
  */
-export function isStrictOwnerEnv(env = process.env) {
+export function isStrictOwnerEnv(env = processEnv()) {
     return env.HIPPO_STRICT_OWNER === '1';
 }
 //# sourceMappingURL=owner-validation.js.map

package/dist/physics-state.js

@@ -46,19 +46,22 @@ export function createPhysicsTable(db) {
     ON memory_physics(mass DESC);
   `);
 }
+const PHYSICS_ID_CHUNK = 500;
 /**
  * Load physics state for specific memory IDs (or all if no IDs given).
  */
 export function loadPhysicsState(db, memoryIds) {
     const map = new Map();
-    let rows;
+    let rows = [];
     if (memoryIds && memoryIds.length > 0) {
-        const placeholders = memoryIds.map(() => '?').join(',');
-        // SAFETY: rows come from the SELECT above, which projects exactly the
-        // PhysicsRow columns (memory_id, position_blob, velocity_blob, mass,
-        // charge, temperature, last_simulation) in that order.
-        rows = db.prepare(`SELECT memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation
-       FROM memory_physics WHERE memory_id IN (${placeholders})`).all(...memoryIds);
+        // Chunked so a whole-store candidate list stays under SQLite's bound-parameter limit.
+        for (let i = 0; i < memoryIds.length; i += PHYSICS_ID_CHUNK) {
+            const chunk = memoryIds.slice(i, i + PHYSICS_ID_CHUNK);
+            const placeholders = chunk.map(() => '?').join(',');
+            // SAFETY: the SELECT projects exactly the PhysicsRow columns, in order.
+            rows = rows.concat(db.prepare(`SELECT memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation
+         FROM memory_physics WHERE memory_id IN (${placeholders})`).all(...chunk));
+        }
     }
     else {
         // SAFETY: same PhysicsRow column projection as the branch above, just

package/dist/policies.d.ts

@@ -36,6 +36,7 @@
  * Dual-write atomicity: `savePolicy` writes the memory + policies row (and, on
  * supersede, the predecessor's UPDATE) inside writeEntry's SAVEPOINT.
  */
+import { type KeysetPosition } from './keyset.js';
 export type PolicyStatus = 'active' | 'superseded' | 'closed';
 export declare const VALID_POLICY_STATES: ReadonlySet<PolicyStatus>;
 export interface Policy {
@@ -77,6 +78,8 @@ export interface SavePolicyOpts {
 export interface ListPoliciesOpts {
     status?: PolicyStatus;
     limit?: number;
+    /** Resume after this row: the position the previous page ended on. */
+    after?: KeysetPosition;
 }
 /**
  * Parse + canonicalize a date input to ISO-8601 datetime (`toISOString`). Throws

package/dist/policies.js

@@ -38,12 +38,13 @@
  */
 import { BadRequestError, ConflictError, NotFoundError } from './api-errors.js';
 import { openHippoDb, closeHippoDb } from './db.js';
-import { writeEntry } from './store.js';
+import { writeEntry } from './store/entry-writes.js';
 import { assertTenantId } from './tenant.js';
-import { markGraphDirty, removeGraphEntitiesForObject } from './graph.js';
+import { markGraphDirty, removeGraphEntitiesForObject } from './graph/write.js';
 import { createMemory, Layer } from './memory.js';
 import { appendAuditEvent } from './audit.js';
 import { objectHalfLifeDays } from './half-life-migration.js';
+import { keysetAfter } from './keyset.js';
 export const VALID_POLICY_STATES = new Set([
     'active',
     'superseded',
@@ -311,6 +312,7 @@ export function loadPolicyById(hippoRoot, tenantId, id) {
 export function loadPolicies(hippoRoot, tenantId, opts = {}) {
     assertTenantId('loadPolicies', tenantId);
     const limit = opts.limit ?? 100;
+    const after = keysetAfter('created_at', 'id', opts.after);
     const db = openHippoDb(hippoRoot);
     try {
         let rows;
@@ -322,20 +324,20 @@ export function loadPolicies(hippoRoot, tenantId, opts = {}) {
             // .all() returns rows in that shape regardless of the status filter applied.
             rows = db.prepare(`
         SELECT ${POLICY_COLS} FROM policies
-        WHERE tenant_id = ? AND status = ?
+        WHERE tenant_id = ? AND status = ?${after.sql}
         ORDER BY created_at DESC, id DESC
         LIMIT ?
-      `).all(tenantId, opts.status, limit);
+      `).all(tenantId, opts.status, ...after.params, limit);
         }
         else {
             // SAFETY: SELECT ${POLICY_COLS} projects exactly the PolicyRow columns;
             // .all() returns rows in that shape for every tenant-scoped row.
             rows = db.prepare(`
         SELECT ${POLICY_COLS} FROM policies
-        WHERE tenant_id = ?
+        WHERE tenant_id = ?${after.sql}
         ORDER BY created_at DESC, id DESC
         LIMIT ?
-      `).all(tenantId, limit);
+      `).all(tenantId, ...after.params, limit);
         }
         return rows.map(rowToPolicy);
     }

package/dist/postinstall.js

@@ -1,9 +1,10 @@
+import { envSkipPostinstall } from './env.js';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { detectRealCodexPath, isCodexWrapperInstalled, repairCodexWrapperIfInstalled, } from './hooks.js';
+import { detectRealCodexPath, isCodexWrapperInstalled, repairCodexWrapperIfInstalled } from './hooks/codex-wrapper.js';
 function main() {
-    if (process.env.HIPPO_SKIP_POSTINSTALL === '1')
+    if (envSkipPostinstall())
         return;
     try {
         // Repair-only: re-ensure the wrapper for users who previously opted in