hippo-memory 1.66.0 → 1.68.0

package/dist/mcp/request.js

@@ -5,7 +5,7 @@ import { getGlobalRoot, initGlobal } from '../shared.js';
 import { loadConfig } from '../config.js';
 import { resolveTenantId } from '../tenant.js';
 import { rethrowIfSqliteBlocked, runWithRequestStores } from '../db.js';
-import { storeFor } from '../store-port.js';
+import { hasGroup, storeFor } from '../store-port.js';
 import { estimateTokens } from '../token-ledger.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { validateToolArgs } from './tool-args.js';
@@ -60,7 +60,7 @@ export async function recordMcpTokens(toolName, output, ctx) {
     }
 }
 const TOOL_HANDLERS = new Map([
-    ['hippo_recall', { handler: runRecallTool, storeReady: true }],
+    ['hippo_recall', { handler: runRecallTool, storeReady: 'base' }],
     ['hippo_assemble', { handler: runAssembleTool }],
     ['hippo_drill', { handler: runDrillTool }],
     ['hippo_predict_baserate', { handler: runPredictBaserateTool }],
@@ -74,12 +74,14 @@ const TOOL_HANDLERS = new Map([
     ['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;
+/** The served store when it is not hippo.db, else null. */
+function otherStore(ctx) {
+    const store = ctx?.store;
+    return store !== undefined && store.kind !== 'sqlite' ? store : null;
+}
+function runsOn(store, toolName) {
+    const group = TOOL_HANDLERS.get(toolName)?.storeReady;
+    return group !== undefined && hasGroup(store, group);
 }
 async function executeTool(name, args, ctx) {
     // When a transport hands us a context (HTTP path), trust it: the HTTP
@@ -130,8 +132,10 @@ export async function handleMcpRequest(req, ctx) {
             };
         case 'notifications/initialized':
             return null;
-        case 'tools/list':
-            return { jsonrpc: '2.0', id, result: { tools: otherStoreKind(ctx) ? TOOLS.filter((t) => STORE_READY_TOOLS.has(t.name)) : TOOLS } };
+        case 'tools/list': {
+            const other = otherStore(ctx);
+            return { jsonrpc: '2.0', id, result: { tools: other ? TOOLS.filter((t) => runsOn(other, t.name)) : TOOLS } };
+        }
         case 'tools/call': {
             const nameValue = params?.name;
             const toolName = isJsonString(nameValue) ? nameValue : '';
@@ -140,7 +144,8 @@ export async function handleMcpRequest(req, ctx) {
                 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)) {
+            const other = otherStore(ctx);
+            if (other && !runsOn(other, toolName)) {
                 return { jsonrpc: '2.0', id, error: { code: -32603, message: STORE_NOT_PORTED_MESSAGE } };
             }
             const refusal = sharedStoreRefusal(toolName, ctx);

package/dist/prompt-hook.d.ts

@@ -21,7 +21,13 @@ export interface ContextView {
     /** The static block's hash the caller says it printed last. Undefined keeps the ledger-only skip rule;
      *  a string or null also needs that hash to match, because the ledger counts blocks a caller that prints elsewhere may never have shown. */
     readonly printedHash?: string | null;
+    /** The reply's JSON wrapper; absent means Claude Code's UserPromptSubmit. */
+    readonly envelope?: HookEnvelope;
 }
+/** `copilot-session-start` is the Copilot harness's top-level reply, `vscode-session-start` the nested one VS Code Local reads. */
+export type HookEnvelope = 'user-prompt-submit' | 'copilot-session-start' | 'vscode-session-start';
+/** A Copilot sessionStart reply's wrapper, picked by the sender's casing: stdin.ts keeps a camelCase `sessionId`, which only the Copilot harness sends. */
+export declare function sessionStartEnvelope(stdinText: string | undefined): HookEnvelope;
 export declare function hasContextData(result: ContextResult): boolean;
 export type RenderItem = {
     entry: MemoryEntry;

package/dist/prompt-hook.js

@@ -11,7 +11,7 @@ import { withLedgerDb } from './ledger-db.js';
 import { sessionPilotArm } from './pilot-arm.js';
 import { assertCallerProject, MAX_PROJECT_ALIASES } from './project-identity.js';
 import { writeDeliveryEventAtRoot, writeDeliveryEventOnHandle } from './recall-trace.js';
-import { blockHash, estimateTokens, isSubagentPayload, lastSentState, recordTokenUse, shouldSkipUnchanged } from './token-ledger.js';
+import { blockHash, estimateTokens, hookPayloadString, isSubagentPayload, lastSentState, recordTokenUse, shouldSkipUnchanged, } from './token-ledger.js';
 /** With `db`, writes on the token ledger's handle (same store); without it, opens its own. A second flush is a no-op. */
 export function flushDeliveryRecorder(rec, db) {
     if (rec === null)
@@ -24,6 +24,16 @@ export function flushDeliveryRecorder(rec, db) {
         console.error(`[hippo] delivery ledger write failed:${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/** A Copilot sessionStart reply's wrapper, picked by the sender's casing: stdin.ts keeps a camelCase `sessionId`, which only the Copilot harness sends. */
+export function sessionStartEnvelope(stdinText) {
+    return hookPayloadString(stdinText, 'sessionId') !== null ? 'copilot-session-start' : 'vscode-session-start';
+}
+function hookReply(envelope, additionalContext) {
+    if (envelope === 'copilot-session-start')
+        return JSON.stringify({ additionalContext });
+    const hookEventName = envelope === 'vscode-session-start' ? 'SessionStart' : 'UserPromptSubmit';
+    return JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext } });
+}
 const NOTHING_RENDERED = Object.freeze({ stdout: '', staticHash: null });
 export function hasContextData(result) {
     return Boolean(result.entries.length > 0 ||
@@ -70,12 +80,7 @@ function renderAdditionalContext(view) {
         rec?.delivered({ state: 'reused', staticHash: blockHash(staticBlock), staticReused });
         return NOTHING_RENDERED;
     }
-    const stdout = JSON.stringify({
-        hookSpecificOutput: {
-            hookEventName: 'UserPromptSubmit',
-            additionalContext,
-        },
-    });
+    const stdout = hookReply(view.envelope ?? 'user-prompt-submit', additionalContext);
     rec?.delivered({
         state: staticReused ? 'reused-recall-sent' : 'sent',
         staticHash: staticBlock.trim() ? blockHash(staticBlock) : null,
@@ -94,6 +99,9 @@ function skipUnchangedStatic(view, surface, staticBlock, recallBlock, staticCoun
     const ledgerOpts = { sharedStore: view.sharedStore };
     if (!view.pinnedOnly || payloadSessionId === undefined)
         return false;
+    // Session start is the only injection Copilot gets, so a resumed session needs the whole block again.
+    if (view.envelope === 'copilot-session-start' || view.envelope === 'vscode-session-start')
+        return false;
     const injectCfg = loadConfig(hippoRoot).pinnedInject;
     if (injectCfg.skipUnchanged === false)
         return false;

package/dist/search/vector.js

@@ -1,9 +1,8 @@
 import { cosineSimilarity, indexedModel, indexNeedsRebuild } from '../embeddings.js';
 import { resolveEmbeddingProvider } from '../embedding-provider.js';
 import { rethrowIfSqliteBlocked } from '../db.js';
-import { StoreNotPortedError } from '../db/sqlite-blocked.js';
 import { log } from '../log.js';
-import { sqliteStore } from '../store-port.js';
+import { requireGroup, sqliteStore } from '../store-port.js';
 import { redactSecretsStrict } from '../secret-detect.js';
 import { currentEntries } from './as-of.js';
 // Search runs on every hook prompt, so one line per reason per process says why vectors went unused without flooding stderr.
@@ -19,9 +18,7 @@ function reindexHint(storeKind) {
 }
 /** The store's vector reads; a store without them answers 501, as any unported path does. */
 export function requireVectorReads(store) {
-    if (!store.vectors)
-        throw new StoreNotPortedError(store.kind, 'vectors');
-    return store.vectors;
+    return requireGroup(store, 'vectors');
 }
 /** The nearest admitted rows not already in `entries`. */
 export async function vectorCandidatesOutside(reads, entries, queryVector, spec) {

package/dist/server/routes/admin.js

@@ -44,7 +44,7 @@ export async function handleCreateAuthKey({ req, res, opts }) {
     // bound to the caller's authenticated tenant (ctx.tenantId, resolved
     // from the Bearer token). Forwarding body.tenantId here would let
     // tenant A mint a key for tenant B — see authCreate doc comment.
-    const result = authCreate(ctx, {
+    const result = await authCreate(ctx, {
         label: labelRaw,
         role,
     });
@@ -68,7 +68,7 @@ export async function handleListAuthKeys({ req, res, opts, query }) {
     const limit = parseListLimit(query.get('limit'), MAX_AUTH_KEYS_PAGE, MAX_AUTH_KEYS_PAGE);
     const after = parseCursor(query.get('cursor'), 'integer', 'integer');
     const ctx = await buildContextWithAuth(req, opts);
-    const page = pageOf(authListRows(ctx, { active, limit: limit + 1, after }), limit, (r) => ({ key: r.rowId, id: r.rowId }));
+    const page = pageOf(await authListRows(ctx, { active, limit: limit + 1, after }), limit, (r) => ({ key: r.rowId, id: r.rowId }));
     setNextCursorHeader(res, page.nextCursor);
     sendJson(res, 200, page.items.map((r) => r.key));
     return;
@@ -79,7 +79,7 @@ export async function handleListAuthKeys({ req, res, opts, query }) {
 export async function handleRevokeAuthKey({ req, res, opts }, keyMatch) {
     validateIdSegment(keyMatch.keyId, 'key id');
     const ctx = await buildContextWithAuth(req, opts);
-    const result = authRevoke(ctx, keyMatch.keyId);
+    const result = await authRevoke(ctx, keyMatch.keyId);
     sendJson(res, 200, result);
     return;
 }

package/dist/server/types.d.ts

@@ -2,7 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Context } from '../api.js';
 import type { JsonValue } from '../json.js';
 import type { RateLimiter } from '../rate-limit.js';
-import type { HippoStore } from '../store-port.js';
+import type { HippoStore, StoreGroup } from '../store-port.js';
 export interface ServerHandle {
     port: number;
     url: string;
@@ -28,10 +28,11 @@ export interface AddonCall {
     readonly ctx: Context;
     readonly body: Readonly<Record<string, JsonValue>>;
 }
-/** A POST /v1 route an add-on mounts through serve(): core authenticates and parses first, then sends the returned value as 200 JSON. */
+/** A POST /v1 route an add-on mounts through serve(): core authenticates and parses first, then sends the returned value as 200 JSON. Under another store it runs only when that store has its `storeReady` group. */
 export interface AddonRoute {
     readonly path: string;
     readonly handler: (call: AddonCall) => Promise<JsonValue>;
+    readonly storeReady?: StoreGroup;
 }
 export interface RateLimitSpec {
     ratePerSec: number;
@@ -76,10 +77,10 @@ export interface RouteRequest {
     opts: ResolvedServeOpts;
     query: URLSearchParams;
 }
-/** One /v1 route: an exact path, a matchPath pattern, or a regex, each paired with the handler for one method. `storeReady` routes run under any store. */
+/** One /v1 route: an exact path, a matchPath pattern, or a regex, each paired with the handler for one method. Under another store it runs only when that store has its `storeReady` group. */
 export type Route = {
     method: string;
-    storeReady?: true;
+    storeReady?: StoreGroup;
 } & ({
     path: string;
     handler: (r: RouteRequest) => Promise<void>;

package/dist/server.d.ts

@@ -1,7 +1,7 @@
-import { type Actor, authCreateSelf, type AuthCreateSelfOpts, type AuthCreateSelfResult, authRevoke, type Context } from './api.js';
-import { ForbiddenError } from './api-errors.js';
+import { type Actor, authCreateSelf, type AuthCreateSelfOpts, type AuthCreateSelfResult, authRevoke, type AuthRevokeReply, type AuthRevokeResult, type Context } from './api.js';
+import { ForbiddenError, NotFoundError } from './api-errors.js';
 import type { ServeOpts, ServerHandle } from './server/types.js';
-export { authCreateSelf, authRevoke, ForbiddenError, type AuthCreateSelfOpts, type AuthCreateSelfResult, type Context, type Actor };
+export { authCreateSelf, authRevoke, ForbiddenError, NotFoundError, type AuthCreateSelfOpts, type AuthCreateSelfResult, type AuthRevokeReply, type AuthRevokeResult, type Context, type Actor, };
 export { isCrossSite, LOOPBACK_HOST_HEADER } from './http-util.js';
 export { __resetSessionRecallHistoryHttp } from './server/routes/recall.js';
 export { clientIpForRateLimit } from './server/client-ip.js';
@@ -11,9 +11,11 @@ export { HttpError } from './http-util.js';
 export { promptHookContext, type CallerProject } from './prompt-hook.js';
 export type { JsonValue } from './json.js';
 export { captureSessionTexts, type SessionCaptureRequest, type SessionCaptureResult } from './capture/session-texts.js';
-export { sqliteStore, type HippoStore, type RecallSearchArgs, type RecallWrites, type VectorReads } from './store-port.js';
-export type { ApiKeyRecord } from './auth.js';
-export type { AppendAuditOpts } from './audit.js';
+export { hasGroup, sqliteStore, type HippoStore, type KeyAudit, type KeyListQuery, type KeyMint, type KeyRevoke, type KeyWrites, type RecallSearchArgs, type RecallWrites, type SelfKeyMint, type StoreGroup, type StoreGroups, type VectorReads, type VectorBackfillQuery, type VectorRowWrite, type VectorWrite, type VectorWriteResult, type VectorWrites, } from './store-port.js';
+export type { HippoDbContext, StoreReply } from './api/types.js';
+export type { ApiKeyListItem, ApiKeyListRow, ApiKeyRecord, ListApiKeysOpts, NewApiKey } from './auth.js';
+export type { KeysetPosition } from './keyset.js';
+export type { AppendAuditOpts, AuditEvent, ListAuditAfterOpts } from './audit.js';
 export type { ContinuityBlock } from './api/recall-types.js';
 export type { ActiveGoals, GetActiveGoalsOpts, Goal, GoalRecallLogRow, RetrievalPolicy } from './goals.js';
 export type { MemoryEntry } from './memory.js';
@@ -27,8 +29,9 @@ export type { TokenUse } from './token-ledger.js';
 export type { EmbeddingIndexState } from './embeddings.js';
 export type { PhysicsParticle } from './physics.js';
 export { StoreBusyError } from './db.js';
-export { decodeVector, EMBEDDING_MODEL_META_KEY, rankVectorRows, type VectorMatch, type VectorRow } from './vector-store.js';
-export { bufferToFloat32 } from './physics-state.js';
+export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows, type VectorMatch, type VectorRow } from './vector-store.js';
+export { bufferToFloat32, float32ToBuffer } from './physics-state.js';
+export { replacesIndex } from './embeddings.js';
 export { OTHER_STORE_MARKER, OtherStoreFolderError, withSqliteAllowed } from './db.js';
 export { authCreate, type AuthCreateOpts, type AuthCreateResult } from './api.js';
 export { isSharedStore } from './config.js';

package/dist/server.js

@@ -3,17 +3,17 @@ import { createServer } from 'node:http';
 import { existsSync } from 'node:fs';
 import { detectServer, removePidfileIfOwned, writePidfile } from './server-detect.js';
 import { closeHippoDb, getHippoDbPath, isStoreBusy, openHippoDb, outsideRequestStores, runWithRequestStores, SERVER_DB_WAIT_MS, withSqliteBlocked } from './db.js';
-import { sqliteStore } from './store-port.js';
+import { hasGroup, sqliteStore } from './store-port.js';
 import { markSharedStore } from './config.js';
 import { auditWriteFailureCount } from './audit.js';
 import { PACKAGE_VERSION } from './version.js';
 import { errorFields, log } from './log.js';
 import { createRateLimiter } from './rate-limit.js';
-import { authCreateSelf, authRevoke, RecallContractError } from './api.js';
+import { authCreateSelf, authRevoke, RecallContractError, } from './api.js';
 import { handleSlackEventsWebhook } from './connectors/slack/webhook.js';
 import { handleGitHubEventsWebhook } from './connectors/github/webhook.js';
 import { BodyTimeoutError, BodyTooLargeError, closeAfterReply, HttpError, JSON_HEADERS, sendJson, STORE_NOT_PORTED_MESSAGE } from './http-util.js';
-import { ForbiddenError } from './api-errors.js';
+import { ForbiddenError, NotFoundError } from './api-errors.js';
 import { buildContextWithAuth, isLoopback, LIMITER_MAX_KEYS, requireAuth } from './server/auth.js';
 import { enforceRateLimit } from './server/client-ip.js';
 import { drainAndClose } from './server/lifecycle.js';
@@ -33,7 +33,7 @@ import { handleAssembleSession, handleDrillRecall, handleGetContext, handleRecal
 import { handleCloseSkill, handleCreateSkill, handleExportSkills, handleGetSkill, handleListSkills, handleSupersedeSkill } from './server/routes/skills.js';
 import { parseJsonBody } from './server/validation.js';
 // Add-on packages mint and revoke keys through these without importing the whole api surface.
-export { authCreateSelf, authRevoke, ForbiddenError };
+export { authCreateSelf, authRevoke, ForbiddenError, NotFoundError, };
 // Published on the hippo-memory/server subpath before they moved to http-util.ts, so they stay exported here.
 export { isCrossSite, LOOPBACK_HOST_HEADER } from './http-util.js';
 // The code behind these lives in src/server/; this subpath keeps exporting them.
@@ -46,11 +46,13 @@ export { promptHookContext } from './prompt-hook.js';
 // A session-end route stores the turns its caller read from a transcript on the caller's own machine.
 export { captureSessionTexts } from './capture/session-texts.js';
 // An add-on serves from another database by passing serve() its own HippoStore.
-export { sqliteStore } from './store-port.js';
+export { hasGroup, sqliteStore, } from './store-port.js';
 export { StoreBusyError } from './db.js';
-// An add-on store decodes and ranks with hippo.db's own code, so both return the same ids in the same order.
-export { decodeVector, EMBEDDING_MODEL_META_KEY, rankVectorRows } from './vector-store.js';
-export { bufferToFloat32 } from './physics-state.js';
+// An add-on store encodes, decodes and ranks vectors and particles with hippo.db's own code, and drops the index by its rule,
+// so both stores keep the same bytes and return the same ids in the same order.
+export { decodeVector, EMBEDDING_MODEL_META_KEY, encodeVector, rankVectorRows } from './vector-store.js';
+export { bufferToFloat32, float32ToBuffer } from './physics-state.js';
+export { replacesIndex } from './embeddings.js';
 // store copy --db writes the marker and reads the old hippo.db under the waiver.
 export { OTHER_STORE_MARKER, OtherStoreFolderError, withSqliteAllowed } from './db.js';
 // An add-on's install step mints the first admin key into a store folder it names, which `hippo auth create` cannot reach.
@@ -98,7 +100,7 @@ const LOOPBACK_HOSTS = new Set(['127.0.0.1', '::1', 'localhost']);
 const V1_ROUTES = [
     { method: 'POST', path: '/v1/memories', handler: handleCreateMemory },
     { method: 'GET', path: '/v1/graph', handler: handleGetGraph },
-    { method: 'GET', path: '/v1/memories', storeReady: true, handler: handleRecallMemories },
+    { method: 'GET', path: '/v1/memories', storeReady: 'base', handler: handleRecallMemories },
     { method: 'GET', pattern: '/v1/sessions/:id/assemble', handler: handleAssembleSession },
     { method: 'GET', pattern: '/v1/recall/drill/:id', handler: handleDrillRecall },
     { method: 'POST', pattern: '/v1/memories/:id/archive', handler: handleArchiveMemory },
@@ -108,9 +110,9 @@ const V1_ROUTES = [
     { method: 'POST', path: '/v1/outcome', handler: handleApplyOutcome },
     { method: 'GET', path: '/v1/context', handler: handleGetContext },
     { method: 'POST', path: '/v1/sleep', handler: handleSleep },
-    { method: 'POST', path: '/v1/auth/keys', handler: handleCreateAuthKey },
-    { method: 'GET', path: '/v1/auth/keys', handler: handleListAuthKeys },
-    { method: 'DELETE', pattern: '/v1/auth/keys/:keyId', handler: handleRevokeAuthKey },
+    { method: 'POST', path: '/v1/auth/keys', storeReady: 'keyWrites', handler: handleCreateAuthKey },
+    { method: 'GET', path: '/v1/auth/keys', storeReady: 'keyWrites', handler: handleListAuthKeys },
+    { method: 'DELETE', pattern: '/v1/auth/keys/:keyId', storeReady: 'keyAudit', handler: handleRevokeAuthKey },
     { method: 'GET', path: '/v1/quarantine', handler: handleListQuarantine },
     { method: 'POST', pattern: '/v1/quarantine/:id/approve', handler: handleApproveQuarantine },
     { method: 'POST', pattern: '/v1/quarantine/:id/reject', handler: handleRejectQuarantine },
@@ -177,8 +179,7 @@ async function dispatchV1Route(r, method, path) {
         const run = routeMatches(route, method, path);
         if (run === null)
             continue;
-        if (!route.storeReady)
-            await refuseUnportedRoute(r.req, r.opts);
+        await refuseUnportedRoute(r.req, r.opts, route.storeReady);
         await run(r);
         return true;
     }
@@ -229,7 +230,7 @@ async function dispatchAddonRoute({ req, res, opts }, method, path) {
     const route = method === 'POST' ? opts.routes?.find((r) => r.path === path) : undefined;
     if (!route)
         return false;
-    await refuseUnportedRoute(req, opts);
+    await refuseUnportedRoute(req, opts, route.storeReady);
     const ctx = await buildContextWithAuth(req, opts);
     const body = await parseJsonBody(req, ctx);
     sendJson(res, 200, await route.handler({ ctx, body }));
@@ -248,9 +249,9 @@ function assertSqliteStore(opts) {
     if (opts.store.kind !== 'sqlite')
         throw new HttpError(501, STORE_NOT_PORTED_MESSAGE);
 }
-/** Under another store, a route not yet ported answers 501 without running; the caller is checked first, so a bad key is still a 401. */
-async function refuseUnportedRoute(req, opts) {
-    if (opts.store.kind === 'sqlite')
+/** Under another store, a route that names no group, or one the store lacks, answers 501 without running; the caller is checked first, so a bad key is still a 401. */
+async function refuseUnportedRoute(req, opts, group) {
+    if (opts.store.kind === 'sqlite' || (group !== undefined && hasGroup(opts.store, group)))
         return;
     await requireAuth(req, opts);
     assertSqliteStore(opts);
@@ -519,7 +520,7 @@ export async function serve(opts) {
     const host = opts.host ?? '127.0.0.1';
     const requestedPort = opts.port ?? Number(envPort() ?? 6789);
     // A frozen copy, so a route the caller adds or renames after boot never skips the check below.
-    const routes = Object.freeze((opts.routes ?? []).map(({ path, handler }) => Object.freeze({ path, handler })));
+    const routes = Object.freeze((opts.routes ?? []).map(({ path, handler, storeReady }) => Object.freeze(storeReady === undefined ? { path, handler } : { path, handler, storeReady })));
     assertAddonRoutes(routes);
     const publicJsonBodies = assertPublicJson(opts.publicJson ?? {});
     const { perAddress: limiter, callerLimiter, failedAuthLimiter } = bootLimiters(opts.rateLimits);

package/dist/stdin.d.ts

@@ -9,4 +9,9 @@ export interface BoundedStdin {
  * idle (default 1000ms, or `HIPPO_STDIN_WAIT_MS`), refreshed on each chunk
  * so a slow but real write is not cut off, and capped at `waitMs * 10`. */
 export declare function readStdinBounded(waitMs?: number): Promise<BoundedStdin>;
+/** A hook payload with Copilot's camelCase fields copied to the snake_case keys hippo reads. The camelCase keys stay,
+ * so the sessionStart reply can follow the sender's casing; text that needs no change comes back exactly as sent. */
+export declare function normaliseHookPayload(text: string | undefined): string | undefined;
+/** The stdin read every hook verb uses: {@link readStdinBounded}, with the payload passed through {@link normaliseHookPayload}. */
+export declare function readHookStdin(waitMs?: number): Promise<BoundedStdin>;
 //# sourceMappingURL=stdin.d.ts.map

package/dist/stdin.js

@@ -1,4 +1,6 @@
 import { envStdinWaitMs } from './env.js';
+import { isJsonObject } from './hooks/shared.js';
+import { isJsonString } from './json.js';
 function defaultWaitMs() {
     return envStdinWaitMs() ?? 1000;
 }
@@ -39,4 +41,64 @@ export function readStdinBounded(waitMs = defaultWaitMs()) {
         stdin.once('error', done);
     });
 }
+// The Copilot harness's camelCase hook fields and the snake_case keys every hippo payload reader looks up.
+const CAMEL_TO_SNAKE = [
+    ['sessionId', 'session_id'],
+    ['transcriptPath', 'transcript_path'],
+    ['toolName', 'tool_name'],
+    ['hookEventName', 'hook_event_name'],
+    ['customInstructions', 'custom_instructions'],
+];
+/** Copilot sends `toolArgs` as the model's raw JSON string; Claude Code and VS Code send `tool_input` already parsed. */
+function parsedToolArgs(value) {
+    if (!isJsonString(value))
+        return value;
+    try {
+        // SAFETY: JSON.parse returns a JSON value by definition.
+        return JSON.parse(value);
+    }
+    catch {
+        // Arguments that are not JSON stay the string the model wrote.
+        return value;
+    }
+}
+/** The snake_case keys a payload lacks, filled from its camelCase twins; a snake_case key already present wins. */
+function snakeCaseFields(payload) {
+    const added = {};
+    for (const [camel, snake] of CAMEL_TO_SNAKE) {
+        if (camel in payload && !(snake in payload))
+            added[snake] = payload[camel];
+    }
+    if ('toolArgs' in payload && !('tool_input' in payload))
+        added.tool_input = parsedToolArgs(payload.toolArgs);
+    const error = payload.error;
+    // An error object gives its message, so readers that expect the documented string still get one.
+    if (isJsonObject(error) && isJsonString(error.message))
+        added.error = error.message;
+    return added;
+}
+/** A hook payload with Copilot's camelCase fields copied to the snake_case keys hippo reads. The camelCase keys stay,
+ * so the sessionStart reply can follow the sender's casing; text that needs no change comes back exactly as sent. */
+export function normaliseHookPayload(text) {
+    if (text === undefined || text.trim() === '')
+        return text;
+    let payload;
+    try {
+        // SAFETY: JSON.parse returns a JSON value by definition.
+        payload = JSON.parse(text.trim());
+    }
+    catch {
+        // Not JSON: each reader already treats that as a malformed payload, so it passes through untouched.
+        return text;
+    }
+    if (!isJsonObject(payload))
+        return text;
+    const added = snakeCaseFields(payload);
+    return Object.keys(added).length === 0 ? text : JSON.stringify({ ...payload, ...added });
+}
+/** The stdin read every hook verb uses: {@link readStdinBounded}, with the payload passed through {@link normaliseHookPayload}. */
+export async function readHookStdin(waitMs) {
+    const read = await readStdinBounded(waitMs);
+    return { text: normaliseHookPayload(read.text), timedOut: read.timedOut };
+}
 //# sourceMappingURL=stdin.js.map

package/dist/store/key-audit.d.ts

@@ -0,0 +1,6 @@
+import { type DatabaseSyncLike } from '../db.js';
+import type { KeyRevoke } from '../store-port.js';
+/** The revoke and its audit row commit together, so a failed audit write leaves the key live and the caller sees the error. */
+export declare function revokeKeyAt(db: DatabaseSyncLike, revoke: KeyRevoke): string;
+export declare function auditHighIdAt(db: DatabaseSyncLike): number;
+//# sourceMappingURL=key-audit.d.ts.map

package/dist/store/key-audit.js

@@ -0,0 +1,25 @@
+// hippo.db's half of the KeyAudit store group.
+import { NotFoundError } from '../api-errors.js';
+import { appendAuditEvent } from '../audit.js';
+import { revokeApiKey } from '../auth.js';
+import { withWriteScope } from '../db.js';
+import { selectApiKeyOwner } from './tenant-lookup.js';
+/** The revoke and its audit row commit together, so a failed audit write leaves the key live and the caller sees the error. */
+export function revokeKeyAt(db, revoke) {
+    return withWriteScope(db, 'revoke_api_key', () => {
+        const row = selectApiKeyOwner(db, revoke.keyId);
+        if (!row || row.tenantId !== revoke.tenantId)
+            throw new NotFoundError(`Unknown key_id: ${revoke.keyId}`);
+        if (row.revokedAt)
+            return row.revokedAt;
+        revokeApiKey(db, revoke.keyId, revoke.at);
+        appendAuditEvent(db, { tenantId: row.tenantId, actor: revoke.actor, op: 'auth_revoke', targetId: revoke.keyId });
+        return revoke.at;
+    });
+}
+export function auditHighIdAt(db) {
+    // SAFETY: the SELECT names one column, seq; `.get` returns undefined before audit_log's first row.
+    const row = db.prepare("SELECT seq FROM sqlite_sequence WHERE name = 'audit_log'").get();
+    return row?.seq ?? 0;
+}
+//# sourceMappingURL=key-audit.js.map

package/dist/store/key-writes.d.ts

@@ -0,0 +1,9 @@
+import { type AppendAuditOpts } from '../audit.js';
+import { type DatabaseSyncLike } from '../db.js';
+import type { KeyMint, SelfKeyMint } from '../store-port.js';
+/** The auth_create row a mint writes; the plaintext never reaches it. */
+export declare function createAuditOf({ key, actor, metadata }: KeyMint): AppendAuditOpts;
+export declare function createKeyAt(db: DatabaseSyncLike, mint: KeyMint): void;
+/** IMMEDIATE takes the write lock before the count, so two mints for one owner cannot both see room under the cap. */
+export declare function createSelfKeyAt(db: DatabaseSyncLike, mint: SelfKeyMint): string[];
+//# sourceMappingURL=key-writes.d.ts.map

package/dist/store/key-writes.js

@@ -0,0 +1,30 @@
+// hippo.db's half of the KeyWrites store group.
+import { appendAuditEvent } from '../audit.js';
+import { insertApiKey, listLiveOwnedKeyIds, revokeApiKey } from '../auth.js';
+import { withWriteScope } from '../db.js';
+/** The auth_create row a mint writes; the plaintext never reaches it. */
+export function createAuditOf({ key, actor, metadata }) {
+    return { tenantId: key.tenantId, actor, op: 'auth_create', targetId: key.keyId, metadata };
+}
+export function createKeyAt(db, mint) {
+    withWriteScope(db, 'create_api_key', () => {
+        insertApiKey(db, mint.key);
+        appendAuditEvent(db, createAuditOf(mint));
+    });
+}
+/** IMMEDIATE takes the write lock before the count, so two mints for one owner cannot both see room under the cap. */
+export function createSelfKeyAt(db, mint) {
+    const { key, actor, perSubject } = mint;
+    return withWriteScope(db, 'create_self_api_key', () => {
+        const live = listLiveOwnedKeyIds(db, key.tenantId, key.ownerSubject, Date.parse(key.createdAt));
+        const replaced = live.slice(0, Math.max(0, live.length - perSubject + 1));
+        insertApiKey(db, key);
+        for (const keyId of replaced) {
+            revokeApiKey(db, keyId, key.createdAt);
+            appendAuditEvent(db, { tenantId: key.tenantId, actor, op: 'auth_revoke', targetId: keyId, metadata: { replacedBy: key.keyId } });
+        }
+        appendAuditEvent(db, createAuditOf(mint));
+        return replaced;
+    });
+}
+//# sourceMappingURL=key-writes.js.map

package/dist/store/vector-writes.d.ts

@@ -0,0 +1,6 @@
+import { type DatabaseSyncLike } from '../db.js';
+import type { MemoryEntry } from '../memory.js';
+import type { VectorBackfillQuery, VectorWrite, VectorWriteResult } from '../store-port.js';
+export declare function entriesWithoutVectorAt(db: DatabaseSyncLike, query: VectorBackfillQuery): MemoryEntry[];
+export declare function writeVectorsAt(db: DatabaseSyncLike, write: VectorWrite): VectorWriteResult;
+//# sourceMappingURL=vector-writes.d.ts.map

package/dist/store/vector-writes.js

@@ -0,0 +1,59 @@
+// hippo.db's half of the VectorWrites store group.
+import { setMeta, withWriteScope } from '../db.js';
+import { embeddingIndexStateOn, replacesIndex } from '../embeddings.js';
+import { float32ToBuffer } from '../physics-state.js';
+import { EMBEDDING_MODEL_META_KEY, upsertVectors } from '../vector-store.js';
+import { chunked } from './entry-reads.js';
+import { MEMORY_SELECT_COLUMNS, rowToEntry } from './rows.js';
+const MAX_BACKFILL_PAGE = 500;
+export function entriesWithoutVectorAt(db, query) {
+    if (!Number.isInteger(query.limit))
+        throw new RangeError('limit must be an integer');
+    const limit = Math.max(1, Math.min(query.limit, MAX_BACKFILL_PAGE));
+    const tenantClause = query.tenantId === undefined ? '' : ' AND tenant_id = ?';
+    const tenantArgs = query.tenantId === undefined ? [] : [query.tenantId];
+    // SAFETY: selects exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
+    const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id > ?${tenantClause}
+       AND NOT EXISTS (SELECT 1 FROM memory_vectors v WHERE v.memory_id = memories.id AND v.model = ?)
+     ORDER BY id LIMIT ?`).all(query.afterId ?? '', ...tenantArgs, query.model, limit);
+    return rows.map(rowToEntry);
+}
+function ownedIds(db, ids, tenantId) {
+    const owned = new Set();
+    for (const chunk of chunked([...new Set(ids)])) {
+        // SAFETY: the SELECT names one column, id.
+        const rows = db.prepare(`SELECT id FROM memories WHERE tenant_id = ? AND id IN (${chunk.map(() => '?').join(', ')})`).all(tenantId, ...chunk);
+        for (const row of rows)
+            owned.add(row.id);
+    }
+    return owned;
+}
+// savePhysicsState opens its own transaction and overwrites, so the first particle for a memory is inserted here instead.
+function insertNewParticles(db, rows) {
+    const stmt = db.prepare(`
+    INSERT INTO memory_physics (memory_id, position_blob, velocity_blob, mass, charge, temperature, last_simulation)
+    VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(memory_id) DO NOTHING
+  `);
+    for (const { memoryId, particle: p } of rows) {
+        if (p)
+            stmt.run(memoryId, float32ToBuffer(p.position), float32ToBuffer(p.velocity), p.mass, p.charge, p.temperature, p.lastSimulation);
+    }
+}
+export function writeVectorsAt(db, write) {
+    return withWriteScope(db, 'write_vectors', () => {
+        const replaces = replacesIndex(embeddingIndexStateOn(db), write.model);
+        if (replaces && !write.replaceIndex)
+            return { written: 0, modelMismatch: true };
+        const owned = ownedIds(db, write.rows.map((r) => r.memoryId), write.tenantId);
+        const rows = write.rows.filter((r) => owned.has(r.memoryId) && r.vector.length > 0 && r.vector.every(Number.isFinite));
+        if (rows.length === 0)
+            return { written: 0, modelMismatch: false };
+        if (replaces)
+            db.exec('DELETE FROM memory_vectors; DELETE FROM memory_physics;');
+        const written = upsertVectors(db, rows.map((r) => [r.memoryId, r.vector]), write.model);
+        insertNewParticles(db, rows);
+        setMeta(db, EMBEDDING_MODEL_META_KEY, write.model);
+        return { written, modelMismatch: false };
+    });
+}
+//# sourceMappingURL=vector-writes.js.map