hippo-memory 1.65.0 → 1.67.0

package/dist/embeddings.js

@@ -101,16 +101,29 @@ export function saveStoredEmbeddingModel(hippoRoot, model) {
         closeHippoDb(db);
     }
 }
+/** The model the index was built by: the stored identity, else the default model when vectors exist. */
+export function indexedModel(state) {
+    return state.storedModel ?? (state.hasVectors ? DEFAULT_EMBEDDING_MODEL : null);
+}
+/** The one rebuild rule every store applies to its indexed model. */
+export function indexNeedsRebuild(indexed, providerId) {
+    return indexed !== null && indexed !== embeddingIndexIdentity(providerId);
+}
 export function resolveIndexedEmbeddingModel(hippoRoot, index) {
-    const stored = loadStoredEmbeddingModel(hippoRoot);
-    if (stored)
-        return stored;
-    const hasVectors = index ? Object.keys(index).length > 0 : withVectorDb(hippoRoot, hasStoredVectors);
-    return hasVectors ? DEFAULT_EMBEDDING_MODEL : null;
+    const storedModel = loadStoredEmbeddingModel(hippoRoot);
+    if (storedModel)
+        return storedModel;
+    return indexedModel({ storedModel, hasVectors: index ? Object.keys(index).length > 0 : withVectorDb(hippoRoot, hasStoredVectors) });
 }
 export function embeddingModelRequiresReindex(hippoRoot, model, index) {
-    const stored = resolveIndexedEmbeddingModel(hippoRoot, index);
-    return stored !== null && stored !== embeddingIndexIdentity(model);
+    return indexNeedsRebuild(resolveIndexedEmbeddingModel(hippoRoot, index), model);
+}
+/** hippo.db's index state, the meta row and the EXISTS on one handle. */
+export function embeddingIndexStateAt(hippoRoot) {
+    return withVectorDb(hippoRoot, (db) => ({
+        storedModel: getMeta(db, EMBEDDING_MODEL_META_KEY, '').trim() || null,
+        hasVectors: hasStoredVectors(db),
+    }));
 }
 async function rebuildEmbeddingIndex(entries, provider) {
     const rebuilt = {};
@@ -189,10 +202,6 @@ export function loadEmbeddingIndex(hippoRoot) {
 export function loadStoredVectors(hippoRoot, ids) {
     return ids.length === 0 ? new Map() : withVectorDb(hippoRoot, (db) => loadVectors(db, ids));
 }
-/** Whether the store holds any vector at all. */
-export function hasEmbeddings(hippoRoot) {
-    return withVectorDb(hippoRoot, hasStoredVectors);
-}
 /** Replace every stored vector with `index`; `model` defaults to the stored index identity. */
 export function saveEmbeddingIndex(hippoRoot, index, model) {
     withVectorDb(hippoRoot, (db) => replaceAllVectors(db, index, model ?? getMeta(db, EMBEDDING_MODEL_META_KEY, '')));

package/dist/hooks/copilot.d.ts

@@ -0,0 +1,45 @@
+/** Copilot drops what a per-prompt hook prints, so per-task recall goes through the MCP tool the block names. */
+export declare const COPILOT_INSTRUCTIONS: string;
+/** The three files hippo writes for Copilot. */
+export interface CopilotPaths {
+    readonly hooks: string;
+    readonly mcpConfig: string;
+    readonly instructions: string;
+}
+export declare function copilotPaths(): CopilotPaths;
+/** What to paste under "mcpServers" when hippo cannot edit the file itself. */
+export declare function copilotMcpSnippet(): string;
+export type McpMergeStatus = 'added' | 'present' | 'user-owned' | 'unreadable';
+/** Adds hippo's server and keeps every other key; a file hippo cannot parse, or a "hippo" key it did not write, stays as it is. */
+export declare function mergeMcpServer(file: string): McpMergeStatus;
+export type McpRemoveStatus = 'removed' | 'absent' | 'user-owned' | 'unreadable';
+/** Removes the "hippo" key only when hippo wrote it. */
+export declare function removeMcpServer(file: string): McpRemoveStatus;
+/** A filesystem error on mcp-config.json (EACCES, EISDIR, EBUSY), kept as its own message so setup can report it and go on. */
+export interface McpFailure {
+    readonly failed: string;
+}
+export declare function isMcpFailure(status: string | McpFailure): status is McpFailure;
+/** `kept`: a hippo block that is not the Copilot text (edited, or another agent's in a shared file); `unclosed`: a start marker with no end. */
+export type InstructionsInstallStatus = 'written' | 'present' | 'kept' | 'unclosed';
+/** Creates the file when missing; any block but hippo's own Copilot one, and a start marker with no end, leave the file as it is. */
+export declare function ensureInstructionsBlock(file: string): InstructionsInstallStatus;
+export type InstructionsRemoveStatus = 'removed' | 'absent' | 'kept' | 'unclosed';
+/** Splices out only hippo's own Copilot block and keeps every other byte; a file left with nothing but whitespace goes. */
+export declare function removeInstructionsBlock(file: string): InstructionsRemoveStatus;
+export interface CopilotInstallResult {
+    readonly paths: CopilotPaths;
+    /** True when the hooks file was written; false when it already held hippo's current table. */
+    readonly hooks: boolean;
+    readonly mcp: McpMergeStatus | McpFailure;
+    readonly instructions: InstructionsInstallStatus;
+}
+export declare function installCopilot(): CopilotInstallResult;
+export interface CopilotUninstallResult {
+    readonly paths: CopilotPaths;
+    readonly hooks: boolean;
+    readonly mcp: McpRemoveStatus | McpFailure;
+    readonly instructions: InstructionsRemoveStatus;
+}
+export declare function uninstallCopilot(): CopilotUninstallResult;
+//# sourceMappingURL=copilot.d.ts.map

package/dist/hooks/copilot.js

@@ -0,0 +1,187 @@
+// GitHub Copilot: hippo's hooks file, one MCP server key and an instructions block, all under the Copilot home folder.
+import * as fs from 'fs';
+import * as path from 'path';
+import { isDeepStrictEqual } from 'node:util';
+import { readJsonFile } from '../json.js';
+import { HOOK_MARKERS, hippoBlock } from '../cli/hook-blocks.js';
+import { copilotHomeDir, isJsonObject } from './shared.js';
+import { installJsonHooks, resolveJsonHookPaths, uninstallJsonHooks, writeSettingsFile } from './json-hooks.js';
+const MCP_KEY = 'hippo';
+/** Copilot drops what a per-prompt hook prints, so per-task recall goes through the MCP tool the block names. */
+export const COPILOT_INSTRUCTIONS = `
+## Project Memory (Hippo)
+
+At the start of each task, call the \`hippo_recall\` tool with a short query that
+names the task. Read the memories it returns before you write any code.
+
+When you learn something that should outlive this session (a decision and its
+reason, a user preference, why something failed), call the \`hippo_remember\`
+tool right then, while you work, never as a closing step. Set \`error\` to true
+for a failure. Leave out secrets and personal details.
+
+The installed hooks load pinned memories when a session starts, store failed
+tool calls and capture the session when it ends, so there is nothing to run
+before you finish.
+`.trim();
+export function copilotPaths() {
+    const home = copilotHomeDir();
+    return {
+        hooks: resolveJsonHookPaths('copilot').settings,
+        mcpConfig: path.join(home, 'mcp-config.json'),
+        instructions: path.join(home, 'copilot-instructions.md'),
+    };
+}
+/** Windows gets npm's .cmd shim, as the Codex hooks do, since a PowerShell execution policy can block hippo.ps1. */
+function hippoMcpServer() {
+    return { type: 'local', command: process.platform === 'win32' ? 'hippo.cmd' : 'hippo', args: ['mcp'], env: {}, tools: ['*'] };
+}
+/** Only a server hippo wrote counts as hippo's: a user's own "hippo" key with another command or args is never touched. */
+function isHipposServer(entry) {
+    return isJsonObject(entry) && (entry.command === 'hippo' || entry.command === 'hippo.cmd') && isDeepStrictEqual(entry.args, ['mcp']);
+}
+/** What to paste under "mcpServers" when hippo cannot edit the file itself. */
+export function copilotMcpSnippet() {
+    return `"${MCP_KEY}": ${JSON.stringify(hippoMcpServer())}`;
+}
+/** Null for a file with comments, one that is not JSON, or one whose shape a merge would overwrite; a missing file reads as empty. */
+function readMcpConfig(file) {
+    let config = {};
+    if (fs.existsSync(file)) {
+        try {
+            config = readJsonFile(file);
+        }
+        catch (err) {
+            // Only a parse failure means the text is not JSON hippo can merge; EACCES or EISDIR is thrown with its own message.
+            if (err instanceof SyntaxError)
+                return null;
+            throw err;
+        }
+    }
+    if (!isJsonObject(config))
+        return null;
+    if (config.mcpServers === undefined)
+        config.mcpServers = {};
+    const servers = config.mcpServers;
+    return isJsonObject(servers) ? { config, servers } : null;
+}
+/** Adds hippo's server and keeps every other key; a file hippo cannot parse, or a "hippo" key it did not write, stays as it is. */
+export function mergeMcpServer(file) {
+    const read = readMcpConfig(file);
+    if (read === null)
+        return 'unreadable';
+    const existing = read.servers[MCP_KEY];
+    if (existing !== undefined)
+        return isHipposServer(existing) ? 'present' : 'user-owned';
+    read.servers[MCP_KEY] = hippoMcpServer();
+    writeSettingsFile(file, read.config);
+    return 'added';
+}
+/** Removes the "hippo" key only when hippo wrote it. */
+export function removeMcpServer(file) {
+    if (!fs.existsSync(file))
+        return 'absent';
+    const read = readMcpConfig(file);
+    if (read === null)
+        return 'unreadable';
+    const existing = read.servers[MCP_KEY];
+    if (existing === undefined)
+        return 'absent';
+    if (!isHipposServer(existing))
+        return 'user-owned';
+    delete read.servers[MCP_KEY];
+    if (Object.keys(read.servers).length === 0)
+        delete read.config.mcpServers;
+    writeSettingsFile(file, read.config);
+    return 'removed';
+}
+export function isMcpFailure(status) {
+    return typeof status !== 'string';
+}
+function hasErrnoCode(err) {
+    return 'code' in err && typeof err.code === 'string';
+}
+/** One mcp-config.json step; a filesystem error comes back as a failure, so the hooks file and the block still install. */
+function mcpStep(step) {
+    try {
+        return step();
+    }
+    catch (err) {
+        if (err instanceof Error && hasErrnoCode(err))
+            return { failed: err.message };
+        throw err;
+    }
+}
+// A later release adds the hash of each earlier Copilot text here, as SHIPPED_HOOK_HASHES does for the other agents.
+function isCopilotBlock(inner) {
+    return inner === COPILOT_INSTRUCTIONS;
+}
+/** Replaces only the text between the markers, in the file's own line ending, or appends a block after the user's text. */
+function withCopilotBlock(text, found) {
+    if (found !== null) {
+        const { start, end, eol } = found;
+        return `${text.slice(0, start)}${eol}${COPILOT_INSTRUCTIONS.replace(/\n/g, eol)}${eol}${text.slice(end)}`;
+    }
+    const block = `${HOOK_MARKERS.start}\n${COPILOT_INSTRUCTIONS}\n${HOOK_MARKERS.end}\n`;
+    if (text === '')
+        return block;
+    return `${text}${text.endsWith('\n') ? '\n' : '\n\n'}${block}`;
+}
+/** Creates the file when missing; any block but hippo's own Copilot one, and a start marker with no end, leave the file as it is. */
+export function ensureInstructionsBlock(file) {
+    const old = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
+    const found = hippoBlock(old);
+    if (found === null && old.includes(HOOK_MARKERS.start))
+        return 'unclosed';
+    if (found !== null && !isCopilotBlock(found.inner))
+        return 'kept';
+    const next = withCopilotBlock(old, found);
+    if (next === old)
+        return 'present';
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, next, 'utf8');
+    return 'written';
+}
+/** `text` without the block and its markers, plus the line break after the end marker, else the one before the start marker. */
+function withoutCopilotBlock(text, found) {
+    const from = found.start - HOOK_MARKERS.start.length;
+    const to = found.end + HOOK_MARKERS.end.length;
+    const after = text.startsWith('\r\n', to) ? 2 : text.startsWith('\n', to) ? 1 : 0;
+    const before = after > 0 ? 0 : text.endsWith('\r\n', from) ? 2 : text.endsWith('\n', from) ? 1 : 0;
+    return text.slice(0, from - before) + text.slice(to + after);
+}
+/** Splices out only hippo's own Copilot block and keeps every other byte; a file left with nothing but whitespace goes. */
+export function removeInstructionsBlock(file) {
+    if (!fs.existsSync(file))
+        return 'absent';
+    const old = fs.readFileSync(file, 'utf8');
+    const found = hippoBlock(old);
+    if (found === null)
+        return old.includes(HOOK_MARKERS.start) ? 'unclosed' : 'absent';
+    if (!isCopilotBlock(found.inner))
+        return 'kept';
+    const left = withoutCopilotBlock(old, found);
+    if (left.trim() === '')
+        fs.rmSync(file);
+    else
+        fs.writeFileSync(file, left, 'utf8');
+    return 'removed';
+}
+export function installCopilot() {
+    const paths = copilotPaths();
+    return {
+        paths,
+        hooks: installJsonHooks('copilot').installedSessionStart,
+        mcp: mcpStep(() => mergeMcpServer(paths.mcpConfig)),
+        instructions: ensureInstructionsBlock(paths.instructions),
+    };
+}
+export function uninstallCopilot() {
+    const paths = copilotPaths();
+    return {
+        paths,
+        hooks: uninstallJsonHooks('copilot'),
+        mcp: mcpStep(() => removeMcpServer(paths.mcpConfig)),
+        instructions: removeInstructionsBlock(paths.instructions),
+    };
+}
+//# sourceMappingURL=copilot.js.map

package/dist/hooks/json-hooks.d.ts

@@ -20,7 +20,7 @@
  *    PreCompact and PostCompact entries go in too: the first records the compaction and
  *    asks the summariser for a "Memories for hippo" list, the second saves that list.
  *    Codex's hooks.json gets only two groups (per-prompt memory and
- *    compact-resume); see installCodexHooks.
+ *    compact-resume); see installCodexHooks. Copilot gets a file of its own; see installCopilotHooks.
  *
  * 2. Plugin install (OpenCode only). OpenCode does NOT share Claude Code's
  *    JSON-hook schema — its config has `additionalProperties: false` and no

package/dist/hooks/json-hooks.js

@@ -20,7 +20,7 @@
  *    PreCompact and PostCompact entries go in too: the first records the compaction and
  *    asks the summariser for a "Memories for hippo" list, the second saves that list.
  *    Codex's hooks.json gets only two groups (per-prompt memory and
- *    compact-resume); see installCodexHooks.
+ *    compact-resume); see installCodexHooks. Copilot gets a file of its own; see installCopilotHooks.
  *
  * 2. Plugin install (OpenCode only). OpenCode does NOT share Claude Code's
  *    JSON-hook schema — its config has `additionalProperties: false` and no
@@ -35,7 +35,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { isJsonObject, HIPPO_SLEEP_MARKER, HIPPO_LAST_SLEEP_MARKER, HIPPO_CAPTURE_MARKER, HIPPO_SESSION_END_MARKER, HIPPO_PINNED_INJECT_MARKER, HIPPO_PINNED_INJECT_COMMAND, HIPPO_PRE_COMPACT_MARKER, HIPPO_COMPACT_RESUME_MARKER, HIPPO_CAPTURE_ERROR_MARKER, HIPPO_POST_COMPACT_MARKER, homeDir, claudeConfigDir, codexHomeDir, defaultPreCompactLogPath } from './shared.js';
+import { isJsonObject, HIPPO_SLEEP_MARKER, HIPPO_LAST_SLEEP_MARKER, HIPPO_CAPTURE_MARKER, HIPPO_SESSION_END_MARKER, HIPPO_PINNED_INJECT_MARKER, HIPPO_PINNED_INJECT_COMMAND, HIPPO_PRE_COMPACT_MARKER, HIPPO_COMPACT_RESUME_MARKER, HIPPO_CAPTURE_ERROR_MARKER, HIPPO_POST_COMPACT_MARKER, homeDir, claudeConfigDir, codexHomeDir, copilotHomeDir, defaultPreCompactLogPath } from './shared.js';
 import { isJsonString, readJsonFile } from '../json.js';
 import { escapeRegex } from '../escape.js';
 import { errorMessage, log } from '../log.js';
@@ -56,6 +56,12 @@ export function resolveJsonHookPaths(target) {
                 logFile: path.join(logsDir, 'codex-sleep.log'),
                 display: 'Codex',
             };
+        case 'copilot':
+            return {
+                settings: path.join(copilotHomeDir(), 'hooks', 'hippo.json'),
+                logFile: path.join(logsDir, 'copilot-sleep.log'),
+                display: 'Copilot',
+            };
     }
 }
 // An unterminated quote runs to the end, as in a shell, which also keeps the scan linear.
@@ -196,12 +202,40 @@ function installCodexHooks(settingsPath, settings) {
         writeSettingsFile(settingsPath, settings);
     return { ...result, installedUserPromptSubmit, installedCompactResume };
 }
+/** One Copilot entry with a PowerShell twin: VS Code runs only `powershell` on Windows, where the execution policy can block npm's hippo.ps1. */
+function copilotCommandHook(args, timeoutSec) {
+    return [{ type: 'command', bash: `hippo ${args}`, powershell: `hippo.cmd ${args}`, timeoutSec }];
+}
+/** No command names a path, so nothing has to be quoted for bash and PowerShell; session-end --runtime copilot picks its own log file. */
+function copilotHooksTable() {
+    return {
+        version: 1,
+        hooks: {
+            sessionStart: copilotCommandHook('context --pinned-only --include-recent 5 --format copilot', 10),
+            postToolUseFailure: copilotCommandHook('capture-error --runtime copilot', 10),
+            preCompact: copilotCommandHook('pre-compact --runtime copilot', 30),
+            sessionEnd: copilotCommandHook('session-end --runtime copilot', 30),
+        },
+    };
+}
+/** Hippo owns this whole file, so install writes the full table and a second install changes no byte. */
+function installCopilotHooks(settingsPath) {
+    const result = nothingInstalled('copilot', settingsPath);
+    const table = copilotHooksTable();
+    const current = fs.existsSync(settingsPath) ? fs.readFileSync(settingsPath, 'utf8') : null;
+    if (current === JSON.stringify(table, null, 2) + '\n')
+        return result;
+    writeSettingsFile(settingsPath, table);
+    return { ...result, installedSessionStart: true, installedCaptureError: true, installedPreCompact: true, installedSessionEnd: true };
+}
 /** Adds hippo's hooks to `target`'s settings file and migrates older hippo entries; a file that is not JSON stays untouched. */
 export function installJsonHooks(target) {
     const { settings: settingsPath, logFile } = resolveJsonHookPaths(target);
     const dir = path.dirname(settingsPath);
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
+    if (target === 'copilot')
+        return installCopilotHooks(settingsPath);
     let settings = {};
     if (fs.existsSync(settingsPath)) {
         try {
@@ -443,6 +477,11 @@ export function uninstallJsonHooks(target) {
     const { settings: settingsPath } = resolveJsonHookPaths(target);
     if (!fs.existsSync(settingsPath))
         return false;
+    if (target === 'copilot') {
+        // Copilot reads every file in its hooks folder, so hippo's own file goes whole and the user's files stay.
+        fs.rmSync(settingsPath, { force: true });
+        return true;
+    }
     let settings;
     try {
         settings = readJsonFile(settingsPath);

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/quality-repair.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { appendAuditEvent } from './audit.js';
 import { withBackup } from './db/backup.js';
+import { assertSqliteAllowed } from './db/open.js';
 import { DatabaseSync } from './db/sqlite.js';
 import { getMeta, setMeta } from './db/meta.js';
 import { tableColumns } from './db/tables.js';
@@ -187,6 +188,8 @@ function repairOn(db, root, opts) {
     return { ...result, warnings };
 }
 function openForRepair(root, readOnly, fn) {
+    // Opens without openHippoDb to skip migrations, so it takes the same refusal itself.
+    assertSqliteAllowed(root);
     const file = path.join(root, 'hippo.db');
     if (!fs.existsSync(file))
         throw new Error(`No existing Hippo database at ${file}`);

package/dist/search/hybrid.d.ts

@@ -4,6 +4,7 @@ import { type BM25Corpus } from './bm25.js';
 import { type HybridVectorCandidates } from './vector.js';
 import { type GraphStreamOptions } from './fusion.js';
 import { type ResultCost, type SearchResult } from './types.js';
+import type { HippoStore } from '../store-port.js';
 export interface HybridSearchOptions {
     budget?: number;
     now?: Date;
@@ -40,6 +41,8 @@ export interface HybridSearchOptions {
     graphStream?: GraphStreamOptions;
     /** Add the rows nearest the query vector, not only rescore `entries`; without it a row no query word matches cannot surface. */
     vectorCandidates?: HybridVectorCandidates;
+    /** Where vectors are read; hippo.db under `hippoRoot` when unset. */
+    store?: HippoStore;
 }
 /** BM25 blended with cosine similarity when stored vectors and a provider are available, BM25 * strength * recency otherwise. */
 export declare function hybridSearch(query: string, entries: MemoryEntry[], options?: HybridSearchOptions): Promise<SearchResult[]>;

package/dist/search/physics-search.d.ts

@@ -1,5 +1,6 @@
 import { type MemoryEntry } from '../memory.js';
 import { type PhysicsConfig } from '../physics-config.js';
+import { type HippoStore } from '../store-port.js';
 import { type HybridVectorCandidates } from './vector.js';
 import { type ResultCost, type SearchResult } from './types.js';
 export interface PhysicsSearchOptions {
@@ -23,6 +24,8 @@ export interface PhysicsSearchOptions {
     summaryFreshness?: boolean;
     /** Same as hybridSearch's: rows nearest the query join the pool before physics scoring. */
     vectorCandidates?: HybridVectorCandidates;
+    /** Where vectors and particles are read; hippo.db under `hippoRoot` when unset. */
+    store?: HippoStore;
 }
 /** Scores memories by gravity, momentum and cluster amplification; rows without physics state rank through hybridSearch. */
 export declare function physicsSearch(query: string, entries: MemoryEntry[], options?: PhysicsSearchOptions): Promise<SearchResult[]>;