hippo-memory 1.66.0 → 1.67.0

package/dist/hooks/shared.d.ts

@@ -2,7 +2,7 @@ import type { JsonObject } from '../working-memory.js';
 import type { JsonValue } from '../json.js';
 /** JSON-value plain-object check (excludes arrays and null); `constructor` avoids the `typeof` tag banned by anti-slop/no-runtime-typeof. */
 export declare function isJsonObject(value: JsonValue | undefined): value is JsonObject;
-export type JsonHookTarget = 'claude-code' | 'codex';
+export type JsonHookTarget = 'claude-code' | 'codex' | 'copilot';
 export interface ToolDetection {
     name: string;
     configDir: string;
@@ -24,10 +24,14 @@ export declare const HIPPO_POST_COMPACT_MARKER = "hippo post-compact";
 export declare function homeDir(): string;
 /** Codex's config folder: $CODEX_HOME, else ~/.codex, as the Codex hooks docs describe. */
 export declare function codexHomeDir(home?: string, env?: Readonly<Record<string, string | undefined>>): string;
+/** Copilot's config folder: $COPILOT_HOME, else ~/.copilot under os.homedir(), as the Copilot apps resolve it (a HOME that differs from the profile must not move it). */
+export declare function copilotHomeDir(home?: string, env?: Readonly<Record<string, string | undefined>>): string;
 /** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
 export declare function claudeConfigDir(home?: string, env?: Readonly<Record<string, string | undefined>>): string;
 /** Codex counts as installed only when its config folder exists: Codex itself refuses a CODEX_HOME that is not a folder. */
 export declare function isCodexPresent(home?: string): boolean;
+/** Copilot counts as installed only when its config folder exists, so setup never creates ~/.copilot on a machine without it. */
+export declare function isCopilotPresent(home?: string): boolean;
 /** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
 export declare const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";
 /**

package/dist/hooks/shared.js

@@ -24,6 +24,10 @@ export function homeDir() {
 export function codexHomeDir(home = homeDir(), env = processEnv()) {
     return env.CODEX_HOME || path.join(home, '.codex');
 }
+/** Copilot's config folder: $COPILOT_HOME, else ~/.copilot under os.homedir(), as the Copilot apps resolve it (a HOME that differs from the profile must not move it). */
+export function copilotHomeDir(home = os.homedir(), env = processEnv()) {
+    return env.COPILOT_HOME || path.join(home, '.copilot');
+}
 /** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
 export function claudeConfigDir(home = os.homedir(), env = processEnv()) {
     return env.CLAUDE_CONFIG_DIR || path.join(home, '.claude');
@@ -32,6 +36,10 @@ export function claudeConfigDir(home = os.homedir(), env = processEnv()) {
 export function isCodexPresent(home = homeDir()) {
     return fs.statSync(codexHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true;
 }
+/** Copilot counts as installed only when its config folder exists, so setup never creates ~/.copilot on a machine without it. */
+export function isCopilotPresent(home = os.homedir()) {
+    return fs.statSync(copilotHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true;
+}
 /** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
 export const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";
 /**
@@ -68,6 +76,7 @@ export function detectInstalledTools() {
         { name: 'opencode', configDir: '~/.config/opencode', detected: exists('.config', 'opencode'), kind: 'plugin', notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts' },
         { name: 'openclaw', configDir: '~/.openclaw', detected: exists('.openclaw'), kind: 'plugin', notes: 'install via `openclaw plugins install hippo-memory`' },
         { name: 'codex', configDir: '~/.codex', detected: isCodexPresent(home), kind: 'wrapper', notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation' },
+        { name: 'copilot', configDir: copilotHomeDir(), detected: isCopilotPresent(), kind: 'json-hook', notes: 'hooks in hooks/hippo.json, the MCP server in mcp-config.json and a block in copilot-instructions.md' },
         { name: 'cursor', configDir: '~/.cursor', detected: exists('.cursor'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
         { name: 'pi', configDir: '~/.pi', detected: exists('.pi'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
     ];

package/dist/mcp/request.d.ts

@@ -4,8 +4,6 @@ import { type McpContext, type McpRequest, type McpResponse } from './protocol.j
  * 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

@@ -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

@@ -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,9 @@ 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 { hasGroup, sqliteStore, type HippoStore, type KeyAudit, type KeyRevoke, type RecallSearchArgs, type RecallWrites, type StoreGroup, type StoreGroups, type VectorReads, } from './store-port.js';
 export type { ApiKeyRecord } from './auth.js';
-export type { AppendAuditOpts } from './audit.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';

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,7 +46,7 @@ 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';
@@ -98,7 +98,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 },
@@ -110,7 +110,7 @@ const V1_ROUTES = [
     { 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: '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 +177,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 +228,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 +247,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 +518,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-port.d.ts

@@ -1,5 +1,5 @@
 import { type ApiKeyRecord } from './auth.js';
-import { type AppendAuditOpts } from './audit.js';
+import { type AppendAuditOpts, type AuditEvent, type ListAuditAfterOpts } from './audit.js';
 import type { ContinuityBlock } from './api/recall-types.js';
 import { type EmbeddingIndexState } from './embeddings.js';
 import { type ActiveGoals, type GetActiveGoalsOpts, type GoalRecallLogRow } from './goals.js';
@@ -37,7 +37,7 @@ export interface RecallWrites {
         readonly opts: StrengthenOptions;
     };
 }
-/** The reads behind recall's vector arm, one group a store sets in full as `HippoStore.vectors` or leaves unset. */
+/** The reads behind recall's vector arm. */
 export interface VectorReads {
     /** The stored model and whether any vector exists, in one snapshot. */
     embeddingIndexState(): Promise<EmbeddingIndexState>;
@@ -48,8 +48,33 @@ export interface VectorReads {
     /** The particles of `ids` only; an empty list reads nothing. */
     physicsParticles(ids: readonly string[]): Promise<Map<string, PhysicsParticle>>;
 }
+export interface KeyRevoke {
+    readonly tenantId: string;
+    readonly keyId: string;
+    readonly actor: string;
+    readonly at: string;
+}
+export interface KeyAudit {
+    /** Sets revoked_at to `at` and appends one auth_revoke row (the key's tenant, `actor`, the key id) in one transaction, then resolves to `at`. A revoked
+     *  key resolves to its own revoked_at and writes nothing; a key missing from `tenantId` rejects with NotFoundError `Unknown key_id: <keyId>`. */
+    revokeApiKey(revoke: KeyRevoke): Promise<string>;
+    /** As `listAuditEventsAfter`: rows above `afterId` in ascending id order, with its RangeErrors, limit clamp and tenant filter. */
+    auditEventsAfter(opts: ListAuditAfterOpts): Promise<AuditEvent[]>;
+    /** The highest audit id ever assigned, pruned rows included, 0 before the first; a tail that sees it drop knows the log was restored. */
+    auditHighId(): Promise<number>;
+}
+/** The optional groups: a store sets each one whole or leaves it unset, and a route or MCP tool names the one it needs. */
+export interface StoreGroups {
+    /** Unset on a store built before them, where hybrid and physics recall under an embedding provider answer 501. */
+    readonly vectors: VectorReads;
+    readonly keyAudit: KeyAudit;
+}
+export type StoreGroup = 'base' | keyof StoreGroups;
+export declare function hasGroup(store: HippoStore, group: StoreGroup): boolean;
+/** The group's methods; a store without them throws StoreNotPortedError, which answers 501 as any unported path does. */
+export declare function requireGroup<G extends keyof StoreGroups>(store: HippoStore, group: G): StoreGroups[G];
 /** What `serve()` reads and writes through. Each method is atomic and no transaction spans an await, since SQLite's lock wait blocks the event loop; a lock timeout throws `StoreBusyError`. */
-export interface HippoStore {
+export interface HippoStore extends Partial<StoreGroups> {
     /** 'sqlite' is hippo.db under the served root. Under any other kind, an unported route answers 501 and a hippo.db open inside a request throws. */
     readonly kind: string;
     /** The api_keys row for `keyId` with its scope grants, revoked or not; null when no row matches. */
@@ -78,8 +103,6 @@ export interface HippoStore {
     bumpRecallStats(recalled: number): Promise<void>;
     /** One token-ledger row. Throws, so the caller decides whether a ledger failure matters. */
     recordTokens(use: TokenUse): Promise<void>;
-    /** Unset on a store built before them, where hybrid and physics recall under an embedding provider answer 501. */
-    readonly vectors?: VectorReads;
     /** Releases the store's connections; `serve()` closes only a store it made itself. */
     close(): Promise<void>;
 }
@@ -89,9 +112,7 @@ export declare function storeFor(ctx: {
     readonly store?: HippoStore;
 }): HippoStore;
 /** The built-in store: today's synchronous hippo.db functions behind the port, each call on its own short-lived handles, so close has nothing to release. */
-export declare function sqliteStore(hippoRoot: string): HippoStore & {
-    readonly vectors: VectorReads;
-};
+export declare function sqliteStore(hippoRoot: string): HippoStore & StoreGroups;
 /** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
 export declare function continuityAt(hippoRoot: string, tenantId: string, eventLimit: number, key: ContinuityKey | null): ContinuityBlock;
 /** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */

package/dist/store-port.js

@@ -1,19 +1,32 @@
 // The async seam the server reaches its store through, so an add-on can serve from a database other than hippo.db.
 import { readApiKeyRecord } from './auth.js';
-import { appendAuditEvent } from './audit.js';
+import { appendAuditEvent, listAuditEventsAfter } from './audit.js';
 import { closeHippoDb, openHippoDb, withWriteScope } from './db.js';
+import { StoreNotPortedError } from './db/sqlite-blocked.js';
 import { embeddingIndexStateAt, loadStoredVectors } from './embeddings.js';
 import { activeGoalsWithPolicies, localGoalRecallRows, writeGoalRecallLog, } from './goals.js';
 import { loadPhysicsState } from './physics-state.js';
 import { planningFallacyEvidenceAt } from './predictions/planning-fallacy.js';
 import { writeRecallTrace } from './recall-trace.js';
 import { loadEntriesByIds, loadFreshRawMemories } from './store/entry-reads.js';
+import { auditHighIdAt, revokeKeyAt } from './store/key-audit.js';
 import { strengthenRetrievedInOwnTx } from './store/entry-writes.js';
 import { loadLatestHandoff } from './store/handoffs.js';
 import { updateStats } from './store/index-and-stats.js';
 import { loadRecallSearchEntries, loadVectorCandidateEntries } from './store/search-rows.js';
 import { listSessionEvents, loadActiveTaskSnapshot } from './store/sessions.js';
 import { recordTokenUse } from './token-ledger.js';
+export function hasGroup(store, group) {
+    return group === 'base' || store[group] !== undefined;
+}
+/** The group's methods; a store without them throws StoreNotPortedError, which answers 501 as any unported path does. */
+export function requireGroup(store, group) {
+    const groups = store;
+    const methods = groups[group];
+    if (methods === undefined)
+        throw new StoreNotPortedError(store.kind, group);
+    return methods;
+}
 function onHandle(hippoRoot, fn) {
     const db = openHippoDb(hippoRoot);
     try {
@@ -84,9 +97,23 @@ export function sqliteStore(hippoRoot) {
                 return ids.length === 0 ? new Map() : onHandle(hippoRoot, (db) => loadPhysicsState(db, [...ids]));
             },
         },
+        keyAudit: sqliteKeyAudit(hippoRoot),
         async close() { },
     };
 }
+function sqliteKeyAudit(hippoRoot) {
+    return {
+        async revokeApiKey(revoke) {
+            return onHandle(hippoRoot, (db) => revokeKeyAt(db, revoke));
+        },
+        async auditEventsAfter(opts) {
+            return onHandle(hippoRoot, (db) => listAuditEventsAfter(db, opts));
+        },
+        async auditHighId() {
+            return onHandle(hippoRoot, auditHighIdAt);
+        },
+    };
+}
 /** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
 export function continuityAt(hippoRoot, tenantId, eventLimit, key) {
     const activeSnapshot = loadActiveTaskSnapshot(hippoRoot, tenantId, key ?? undefined);