hippo-memory 1.65.0 → 1.67.0

package/dist/cli/session-hooks.js

@@ -4,6 +4,7 @@ import * as fs from 'fs';
 import { spawn } from 'child_process';
 import { resolveCodexSessionTranscript } from '../hooks/codex-session.js';
 import { resolveCodexWrapperPaths } from '../hooks/codex-wrapper.js';
+import { resolveJsonHookPaths } from '../hooks/json-hooks.js';
 import { isInitialized } from '../store/open.js';
 import { loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, closeTaskSnapshotsForSession, listSessionEvents, } from '../store/sessions.js';
 import { writeSessionEndHandoff } from '../store/handoffs.js';
@@ -20,16 +21,17 @@ import { cmdPreCompact, cmdPostCompact } from '../capture/compact.js';
 import { transcriptWorkingState } from '../capture/working-state.js';
 import { collectHandoffEvidence } from '../handoff-evidence.js';
 import { resolveLastSessionTranscript } from '../capture/transcript.js';
+import { copilotTranscriptFor } from '../capture/copilot-transcript.js';
 import { truncateCodePointSafe } from '../transcript-tail.js';
 import { COMPACTION_DB_WAIT_MS } from '../compaction-record.js';
 import { COMPACT_RESUME_EVENT_CONTENT_CAP, COMPACT_RESUME_MAX_AGE_MS, compactResumeText } from '../context-render.js';
-import { readStdinBounded } from '../stdin.js';
+import { readHookStdin } from '../stdin.js';
 import { resolveTenantId } from '../tenant.js';
 import { errorMessage, log } from '../log.js';
 import { withLedgerDb } from '../ledger-db.js';
 import { printError } from './output.js';
 import { cmdLastSleep } from './last-sleep.js';
-import { logSessionEndImport, appendSessionEndCloseLog, resetHookInjection, hookStoreRoot, runHookWithStores, inPilotHoldout, } from './shared.js';
+import { logSessionEndImport, appendSessionEndCloseLog, resetHookInjection, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout, } from './shared.js';
 /**
  * SessionStart(compact) injector. Prints the active task snapshot + recent
  * session trail so working state that would otherwise be lost to
@@ -140,10 +142,14 @@ function restoreCompactSnapshot(hippoRoot, payloadSessionId) {
  * the next SessionStart reads the log via `hippo last-sleep`.
  */
 export async function cmdSessionEnd(hippoRoot, flags) {
-    const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : null;
+    const runtime = hookRuntime(flags);
+    // Copilot's hook command carries no path, since one quoted into it would need escaping for each shell; the log goes where the hook table used to point.
+    const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : runtime === 'copilot' ? resolveJsonHookPaths('copilot').logFile : null;
     // Bounded read: extracts transcript_path + session_id for the detached worker's argv.
     let sessionId = null;
-    const { text: stdinText } = await readStdinBounded();
+    const { text: stdinText } = await readHookStdin();
+    // Before the spawn, since the worker finds its store from the folder it inherits.
+    const root = payloadCwdRoot(hippoRoot, stdinText, runtime);
     try {
         if (stdinText && stdinText.trim().startsWith('{')) {
             const payload = JSON.parse(stdinText);
@@ -156,8 +162,9 @@ export async function cmdSessionEnd(hippoRoot, flags) {
         // No stdin, not JSON, or read failure: the snapshot close below will no-op.
     }
     // Resolved here because only this process saw the payload; the worker captures just the path it is handed.
-    // Always a hook, so never scan: an empty stdin here is not a manual run.
-    const transcriptPath = resolveLastSessionTranscript(undefined, stdinText, { mayScan: false });
+    // Always a hook, so never scan: an empty stdin here is not a manual run. The Copilot CLI's sessionEnd names no transcript, so its log is found by id.
+    const transcriptPath = resolveLastSessionTranscript(undefined, stdinText, { mayScan: false })
+        ?? (runtime === 'copilot' && sessionId ? copilotTranscriptFor(sessionId) : null);
     const workerArgs = [process.argv[1], '__session-end-worker'];
     if (logFile)
         workerArgs.push('--log-file', logFile);
@@ -177,11 +184,13 @@ export async function cmdSessionEnd(hippoRoot, flags) {
     }
     catch {
         // If spawn fails, run inline as a last resort, handed what the child's argv would have carried.
+        if (logFile)
+            flags['log-file'] = logFile;
         if (transcriptPath)
             flags['transcript'] = transcriptPath;
         if (sessionId)
             flags['session-id'] = sessionId;
-        await cmdSessionEndWorker(hippoRoot, flags);
+        await cmdSessionEndWorker(root, flags);
         return;
     }
 }
@@ -493,19 +502,22 @@ export async function cmdCodexSessionEndWorker(hippoRoot, flags) {
 }
 export async function handlePreCompact({ hippoRoot, flags }) {
     // Bounded wait, not a TTY guard: an idle non-TTY pipe must not hang.
-    const { text: stdinText, timedOut: stdinTimedOut } = await readStdinBounded();
+    const { text: stdinText, timedOut: stdinTimedOut } = await readHookStdin();
+    const runtime = hookRuntime(flags);
+    const root = payloadCwdRoot(hippoRoot, stdinText, runtime);
     await runHookWithStores(async () => {
-        resetHookInjection(hippoRoot, stdinText, null);
-        await cmdPreCompact(hookStoreRoot(hippoRoot), {
+        resetHookInjection(root, stdinText, null);
+        await cmdPreCompact(hookStoreRoot(root), {
             stdinText,
             stdinTimedOut,
             logFile: typeof flags['log-file'] === 'string' ? flags['log-file'] : undefined,
+            runtime,
         });
     });
 }
 export async function handlePostCompact({ hippoRoot, flags }) {
     // PostCompact hook: saves the compaction summary and its memories, then prints one plain line, because Claude Code shows this hook's stdout as-is. Always exits 0.
-    const { text } = await readStdinBounded();
+    const { text } = await readHookStdin();
     const logFlag = flags['log-file'];
     const store = hookStoreRoot(hippoRoot);
     const line = await runHookWithStores(() => cmdPostCompact(store, {
@@ -524,12 +536,12 @@ export async function handlePostCompact({ hippoRoot, flags }) {
     if (line !== null && line !== undefined)
         console.log(line);
 }
-export async function handleCaptureError({ hippoRoot }) {
+export async function handleCaptureError({ hippoRoot, flags }) {
     // PostToolUseFailure hook: every path exits 0, and nothing is created
     // when no store exists (the hook fires in every directory).
-    const { text } = await readStdinBounded();
+    const { text } = await readHookStdin();
     try {
-        const root = hookStoreRoot(hippoRoot);
+        const root = hookStoreRoot(payloadCwdRoot(hippoRoot, text, hookRuntime(flags)));
         const payload = (text ?? '').trim();
         if (isInitialized(root) && payload) {
             // SAFETY: JSON.parse returns a JSON value by definition.
@@ -542,7 +554,7 @@ export async function handleCaptureError({ hippoRoot }) {
     }
 }
 export async function handleCompactResume({ hippoRoot }) {
-    const { text: stdinText, timedOut: stdinTimedOut } = await readStdinBounded();
+    const { text: stdinText, timedOut: stdinTimedOut } = await readHookStdin();
     await runHookWithStores(() => {
         resetHookInjection(hippoRoot, stdinText, 'compact');
         cmdCompactResume(hookStoreRoot(hippoRoot), stdinText, stdinTimedOut);
@@ -574,7 +586,7 @@ export async function handleCapture({ hippoRoot, flags }) {
     // Bounded, and only when last-session has no explicit path: the
     // --stdin source keeps its own blocking read in capture.ts by design.
     const bounded = captureSource === 'last-session' && !transcriptPath
-        ? await readStdinBounded()
+        ? await readHookStdin()
         : { text: undefined, timedOut: false };
     cmdCapture(hippoRoot, {
         source: captureSource,

package/dist/cli/setup.js

@@ -6,6 +6,7 @@ import { installJsonHooks, uninstallJsonHooks, checkUninstallable, resolveJsonHo
 import { detectInstalledTools } from '../hooks/shared.js';
 import { ensureCodexWrapperInstalled, installCodexWrapper, detectRealCodexPath, uninstallCodexWrapper, } from '../hooks/codex-wrapper.js';
 import { installOpencodePlugin, uninstallOpencodePlugin, resolveOpencodePluginPath } from '../hooks/opencode.js';
+import { copilotMcpSnippet, copilotPaths, installCopilot, isMcpFailure, uninstallCopilot } from '../hooks/copilot.js';
 import { isInitialized } from '../store/open.js';
 import { currentMachine, importUserMemories } from '../agent-memories/sync.js';
 import { getGlobalRoot } from '../shared.js';
@@ -15,7 +16,7 @@ import { log } from '../log.js';
 import { printError } from './output.js';
 import { printAgentImport, installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './shared.js';
 import { repairQualityOnceAt } from './quality-repair-once.js';
-import { HOOK_MARKERS, HOOKS, hippoBlock } from './hook-blocks.js';
+import { HOOK_MARKERS, HOOKS, hippoBlock, withoutHookBlock } from './hook-blocks.js';
 import { escapeRegex } from '../escape.js';
 // ---------------------------------------------------------------------------
 // Hook install/uninstall
@@ -41,13 +42,17 @@ function hookList() {
     for (const [name, hook] of Object.entries(HOOKS)) {
         console.log(`  ${name.padEnd(15)} -> ${hook.file} (${hook.description})`);
     }
+    console.log(`  ${'copilot'.padEnd(15)} -> $COPILOT_HOME or ~/.copilot (GitHub Copilot: hooks, MCP server and instructions)`);
     console.log('\nUsage: hippo hook install <name>');
     console.log('       hippo hook uninstall <name>');
 }
 function hookInstall(target) {
+    // Copilot's instructions live in its home folder, not in a project file, so it has no HOOKS entry.
+    if (target === 'copilot')
+        return printCopilotInstall(installCopilot(), '');
     if (!target || !HOOKS[target]) {
         printError(`Unknown hook target: ${target ?? '(none)'}`);
-        printError(`   Available: ${Object.keys(HOOKS).join(', ')}`);
+        printError(`   Available: ${[...Object.keys(HOOKS), 'copilot'].join(', ')}`);
         process.exit(1);
     }
     const hook = HOOKS[target];
@@ -150,7 +155,56 @@ function installOpencodeHook() {
         console.log(`WARNING: opencode.json is unparseable; legacy hooks block could not be auto-removed. Fix the file manually.`);
     }
 }
+const MCP_MERGE_LINES = {
+    added: (file) => `Added the "hippo" MCP server -> ${file}`,
+    present: (file) => `The "hippo" MCP server is already in ${file}`,
+    'user-owned': (file) => `Left the "hippo" MCP server in ${file} as it is: hippo did not write it`,
+    unreadable: (file) => `WARNING: ${file} has comments or is not a JSON object hippo can merge into, so it was left unchanged; add this under "mcpServers" by hand: ${copilotMcpSnippet()}`,
+};
+const mcpFailureLine = (file, failure, fix) => `WARNING: hippo could not use ${file} (${failure.failed}), so it was left unchanged; ${fix}`;
+const unclosedLine = (file) => `WARNING: ${file} has ${HOOK_MARKERS.start} with no ${HOOK_MARKERS.end}, so hippo left it unchanged; fix the markers by hand`;
+const INSTRUCTIONS_INSTALL_LINES = {
+    written: (file) => `Wrote the hippo block -> ${file}`,
+    present: (file) => `The hippo block is already in ${file}`,
+    kept: (file) => `Kept the hippo block in ${file} as it is: it is not the Copilot text hippo wrote, so it was edited or is another agent's`,
+    unclosed: unclosedLine,
+};
+const INSTRUCTIONS_REMOVE_LINES = {
+    removed: (file) => `Removed the hippo block from ${file}`,
+    absent: () => '',
+    kept: (file) => `Left the hippo block in ${file}: it is not the Copilot text hippo wrote. Delete it by hand if no agent needs it.`,
+    unclosed: unclosedLine,
+};
+function printCopilotInstall(result, indent) {
+    const { paths, mcp } = result;
+    const hooks = result.hooks ? "Installed hippo's Copilot hooks (sessionStart, postToolUseFailure, preCompact, sessionEnd) ->" : "hippo's Copilot hooks are already in";
+    console.log(`${indent}${hooks} ${paths.hooks}`);
+    const mcpLine = isMcpFailure(mcp) ? mcpFailureLine(paths.mcpConfig, mcp, `add this under "mcpServers" by hand: ${copilotMcpSnippet()}`) : MCP_MERGE_LINES[mcp](paths.mcpConfig);
+    console.log(`${indent}${mcpLine}`);
+    console.log(`${indent}${INSTRUCTIONS_INSTALL_LINES[result.instructions](paths.instructions)}`);
+    console.log(`${indent}VS Code Copilot runs new hooks in a new chat session.`);
+}
+function printCopilotUninstall(result) {
+    const { paths, mcp } = result;
+    if (result.hooks)
+        console.log(`Removed hippo's Copilot hooks file ${paths.hooks}`);
+    if (isMcpFailure(mcp))
+        console.log(mcpFailureLine(paths.mcpConfig, mcp, 'remove the "hippo" server by hand if hippo added it'));
+    if (mcp === 'removed')
+        console.log(`Removed the "hippo" MCP server from ${paths.mcpConfig}`);
+    if (mcp === 'user-owned')
+        console.log(`Left the "hippo" MCP server in ${paths.mcpConfig}: hippo did not write it`);
+    if (mcp === 'unreadable')
+        console.log(`WARNING: ${paths.mcpConfig} has comments or is not a JSON object hippo can edit, so it was left unchanged; remove the "hippo" server by hand if hippo added it`);
+    const instructions = INSTRUCTIONS_REMOVE_LINES[result.instructions](paths.instructions);
+    if (instructions)
+        console.log(instructions);
+    if (!result.hooks && mcp === 'absent' && result.instructions === 'absent')
+        console.log('No hippo Copilot hooks, MCP server or instructions block found.');
+}
 function hookUninstall(target) {
+    if (target === 'copilot')
+        return printCopilotUninstall(uninstallCopilot());
     if (!target || !HOOKS[target]) {
         printError(`Unknown hook target: ${target ?? '(none)'}`);
         process.exit(1);
@@ -218,10 +272,6 @@ function removeLegacyCursorRules() {
         console.log(left ? 'Removed the old Hippo hook from .cursorrules' : 'Deleted .cursorrules, which held only the old Hippo hook');
     }
 }
-function withoutHookBlock(text) {
-    const re = new RegExp(`\\n?${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}\\n?`, 'g');
-    return text.replace(re, '\n').replace(/\n{3,}/g, '\n\n').trim();
-}
 // `hippo setup` -- one-shot configuration for every AI coding tool on the box.
 // Detection and install logic live in ./hooks.ts.
 export function cmdSetup(flags) {
@@ -237,7 +287,7 @@ export function cmdSetup(flags) {
     const markdownTools = tools.filter((t) => t.kind === 'markdown-instruction' && t.detected);
     const pluginTools = tools.filter((t) => t.kind === 'plugin' && t.detected);
     if (jsonTools.length === 0 && !forceAll) {
-        console.log('No JSON-hook-capable tools detected (checked: claude-code).');
+        console.log('No JSON-hook-capable tools detected (checked: claude-code, copilot).');
         console.log('Run with --all to install hooks anyway.');
     }
     for (const tool of jsonTools)
@@ -276,7 +326,16 @@ export function cmdSetup(flags) {
     console.log('');
     console.log('Done. Restart your AI tool to activate the hooks.');
 }
+function setupCopilot(dryRun) {
+    const indent = `  ${'copilot'.padEnd(14)} `;
+    if (!dryRun)
+        return printCopilotInstall(installCopilot(), indent);
+    const { hooks, mcpConfig, instructions } = copilotPaths();
+    console.log(`[dry-run] would install hooks in ${hooks}, the MCP server in ${mcpConfig} and the hippo block in ${instructions}`);
+}
 function setupJsonTool(tool, dryRun) {
+    if (tool.name === 'copilot')
+        return setupCopilot(dryRun);
     if (dryRun) {
         // Resolve the real settings path so the filename is right for each tool
         // (claude-code -> settings.json, opencode -> opencode.json).

package/dist/cli/shared.d.ts

@@ -1,5 +1,6 @@
 import { type InstallResult } from '../hooks/json-hooks.js';
 import { TaskSnapshot, SessionEvent } from '../store/rows.js';
+import type { HookRuntime } from '../capture-contract.js';
 import type { SessionHandoff } from '../handoff.js';
 import type { SearchResult } from '../search/types.js';
 import { type HippoConfig } from '../config.js';
@@ -113,6 +114,10 @@ export declare function captureConsole(fn: () => void): string;
  * is looked for in the other.
  */
 export declare function hookStoreRoot(hippoRoot: string): string;
+/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
+export declare function hookRuntime(flags: CliFlags): HookRuntime;
+/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
+export declare function payloadCwdRoot(hippoRoot: string, stdinText: string | undefined, runtime: HookRuntime): string;
 export declare function learnFromRepo(hippoRoot: string, repoPath: string, days: number, label?: string): {
     added: number;
     skipped: number;

package/dist/cli/shared.js

@@ -7,13 +7,13 @@ import { execFileSync, execSync } from 'child_process';
 import { installJsonHooks } from '../hooks/json-hooks.js';
 import { CODEX_TRUST_LINE } from '../hooks/shared.js';
 import { confidenceLabel } from '../memory.js';
-import { isInitialized } from '../store/open.js';
+import { getHippoRoot, isInitialized } from '../store/open.js';
 import { explainMatch } from '../search/explain.js';
 import { isSharedStore } from '../config.js';
 import { openHippoDb, closeHippoDb, isSqliteBusy, noteStoreBusy, runWithRequestStores, HOOK_DB_WAIT_MS } from '../db.js';
 import { withLedgerDb } from '../ledger-db.js';
 import { sessionPilotArm } from '../pilot-arm.js';
-import { hookPayloadSessionId, isSubagentPayload, recordTokenUse } from '../token-ledger.js';
+import { hookPayloadSessionId, hookPayloadString, isSubagentPayload, recordTokenUse } from '../token-ledger.js';
 import { importAtSessionEnd, currentMachine } from '../agent-memories/sync.js';
 import { summaryLine } from '../agent-memories/report.js';
 import { detectChurnStale } from '../invalidation.js';
@@ -27,7 +27,7 @@ import { detectServer, removePidfileIfOwned } from '../server-detect.js';
 import { resolveTenantId } from '../tenant.js';
 import { adminActor, learn, CLI_LEARN } from '../api.js';
 import { snapshotText, sessionTrailText, handoffText } from '../context-render.js';
-import { log } from '../log.js';
+import { errorMessage, log } from '../log.js';
 import { printError } from './output.js';
 export function parseLimitFlag(value) {
     if (!value)
@@ -441,6 +441,25 @@ export function hookStoreRoot(hippoRoot) {
     const globalRoot = getGlobalRoot();
     return isInitialized(globalRoot) ? globalRoot : hippoRoot;
 }
+/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
+export function hookRuntime(flags) {
+    return flags['runtime'] === 'copilot' || flags['format'] === 'copilot' ? 'copilot' : 'claude-code';
+}
+/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
+export function payloadCwdRoot(hippoRoot, stdinText, runtime) {
+    const cwd = runtime === 'copilot' ? hookPayloadString(stdinText, 'cwd') : null;
+    if (cwd === null || cwd.trim() === '')
+        return hippoRoot;
+    try {
+        // Moving, not just re-rooting, keeps project identity, scope, handoff evidence and the session-end worker on that folder too.
+        process.chdir(cwd);
+    }
+    catch (err) {
+        log.warn(`hippo: payload cwd ${cwd} is not usable, so the hook stays in ${process.cwd()}: ${errorMessage(err)}`);
+        return hippoRoot;
+    }
+    return getHippoRoot(process.cwd());
+}
 export function learnFromRepo(hippoRoot, repoPath, days, label) {
     const prefix = label ? `[${label}] ` : '';
     const ctx = { hippoRoot, tenantId: resolveTenantId({}), actor: adminActor('cli') };

package/dist/cli/usage.js

@@ -255,18 +255,24 @@ export const VERB_USAGE = {
   session-end              SessionEnd hook: count this session's re-read tokens, run sleep, then
                            capture from the session's last 20 user and 10 assistant messages,
                            in a detached worker
-    --log-file <path>      Tee the worker's output to a log file (paired with 'hippo last-sleep')`],
+    --log-file <path>      Tee the worker's output to a log file (paired with 'hippo last-sleep')
+    --runtime copilot      The payload came from a Copilot hook: use the store of its cwd and find
+                           the Copilot CLI session log by session id; with no --log-file, log to
+                           ~/.hippo/logs/copilot-sleep.log`],
     'pre-compact': [`
   pre-compact              PreCompact hook: record the compaction, save a working-state snapshot, and
                            ask the summariser to end with a "Memories for hippo" list
-    --log-file <p>         Diagnostic log path (default: ~/.hippo/logs/pre-compact.log)`],
+    --log-file <p>         Diagnostic log path (default: ~/.hippo/logs/pre-compact.log)
+    --runtime copilot      The payload came from a Copilot hook: use the store of its cwd and save
+                           the snapshot only (Copilot has no PostCompact hook to close a record)`],
     'post-compact': [`
   post-compact             PostCompact hook: keep that list as memories (a busy store leaves the save to
                            the next hippo sleep) and print one line saying how many
     --log-file <p>         Same log path as pre-compact (default: ~/.hippo/logs/pre-compact.log)`],
     'capture-error': [`
   capture-error            Store a failed tool call as an error memory (reads the Claude Code
-                           PostToolUseFailure hook payload on stdin; skips routine failures)`],
+                           PostToolUseFailure hook payload on stdin; skips routine failures)
+    --runtime copilot      The payload came from a Copilot hook: use the store of its cwd`],
     'compact-resume': [`
   compact-resume           SessionStart(compact) hook: re-print the snapshot, if under 15 minutes old`],
     'codex-run': [`
@@ -544,23 +550,28 @@ export const VERB_USAGE = {
     --pinned-only          Only inject pinned memories (used by UserPromptSubmit hook)
     --include-recent <n>   With --pinned-only, also inject the last N writes regardless of pinning
     (the hook payload's "prompt" drives prompt recall instead of --include-recent when pinnedInject.promptRecall is on, the default)
-    --format <fmt>         Output format: markdown (default), json, or additional-context (Claude Code hook JSON)
+    --format <fmt>         Output format: markdown (default), json, additional-context (Claude Code hook JSON),
+                           or copilot (Copilot sessionStart hook JSON, from the store of the payload's cwd)
     --framing <mode>       Framing: observe (default), suggest, assert`],
     hook: [`
   hook <sub> [target]      Manage framework integrations
     hook list              Show available hooks
-    hook install <target>  Install hook (claude-code|codex|cursor|openclaw|opencode|pi)
+    hook install <target>  Install hook (claude-code|codex|copilot|cursor|openclaw|opencode|pi)
                            claude-code adds 7 hooks to $CLAUDE_CONFIG_DIR/settings.json
                            (~/.claude by default); opencode installs a plugin; codex
                            adds 2 hooks to $CODEX_HOME/hooks.json (trust them once in /hooks) and
-                           wraps the detected launcher in place; all but claude-code
-                           also patch an existing AGENTS.md
-    hook uninstall <target> Remove hook`],
+                           wraps the detected launcher in place; copilot writes
+                           hooks/hippo.json, the "hippo" MCP server and an instructions
+                           block under $COPILOT_HOME (~/.copilot by default); all but
+                           claude-code and copilot also patch an existing AGENTS.md
+    hook uninstall <target> Remove hook; for copilot, only what hippo wrote`],
     setup: [`
   setup                    One-shot: detect installed AI tools and install their hooks:
                            claude-code gets 7 hooks in $CLAUDE_CONFIG_DIR/settings.json
                            (~/.claude by default), opencode a plugin, codex 2 hooks in
-                           its hooks.json plus a launcher wrapper; other tools get a
+                           its hooks.json plus a launcher wrapper, copilot 4 hooks, the
+                           MCP server and an instructions block under $COPILOT_HOME
+                           (~/.copilot by default); other tools get a
                            hint. Then imports each agent's
                            user-level memories into the global store
     --all                  Install for every JSON-hook tool, even if not detected

package/dist/db/open.d.ts

@@ -18,10 +18,14 @@ export declare const SLEEP_DB_WAIT_MS = 5000;
 export declare function scopedBusyWait(): number | undefined;
 /** Runs `fn` so that every hippo.db open inside it, across awaits, throws; otherwise a missed port would create and write a hippo.db nobody reads. */
 export declare function withSqliteBlocked<T>(storeKind: string, fn: () => T): T;
-/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db. */
+/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db, or a copy that reads the old hippo.db. */
 export declare function withSqliteAllowed<T>(fn: () => T): T;
 /** First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently. */
 export declare function rethrowIfSqliteBlocked<E>(err: E): void;
+/** store init --db, store copy --db and serve --db write this file in the hippo root; its text is the store kind. */
+export declare const OTHER_STORE_MARKER = "other-store";
+/** Throws where hippo.db must not open; checked on every open, not cached, since the marker can appear while a process runs. */
+export declare function assertSqliteAllowed(hippoRoot: string): void;
 /** `busyWaitMs` shortens every lock wait of this open, for a hook that must finish inside its own timeout. */
 export declare function openHippoDb(hippoRoot: string, opts?: {
     busyWaitMs?: number;

package/dist/db/open.js

@@ -1,11 +1,13 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { log } from '../log.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { errorMessage, log } from '../log.js';
 import { DatabaseSync } from './sqlite.js';
 import { tableExists } from './tables.js';
 import { assertBinaryCompatible } from './migrate.js';
 import { connectHippoDb, getHippoDbPath } from './connect.js';
 import { currentRequestStores, isScopedHandle, runWithRequestStores } from './request-stores.js';
-import { SqliteBlockedError } from './sqlite-blocked.js';
+import { OtherStoreFolderError, SqliteBlockedError } from './sqlite-blocked.js';
 export { getHippoDbPath };
 /** Lock wait for hook commands: under the 5 s prompt-hook budget even after a few skipped writes, and far above a normal write's hold. */
 export const HOOK_DB_WAIT_MS = 1000;
@@ -32,29 +34,48 @@ const sqliteBlockedBy = new AsyncLocalStorage();
 export function withSqliteBlocked(storeKind, fn) {
     return sqliteBlockedBy.run(storeKind, fn);
 }
-/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db. */
+/** Runs `fn` with hippo.db opens allowed again, for a store whose own methods are backed by hippo.db, or a copy that reads the old hippo.db. */
 export function withSqliteAllowed(fn) {
-    return sqliteBlockedBy.exit(fn);
+    return sqliteBlockedBy.exit(() => markerWaived.run(true, fn));
 }
 /** First line of a best-effort catch around a hippo.db open: an unported path must fail closed, not fall back silently. */
 export function rethrowIfSqliteBlocked(err) {
     if (err instanceof SqliteBlockedError)
         throw err;
 }
-function assertSqliteAllowed() {
+/** store init --db, store copy --db and serve --db write this file in the hippo root; its text is the store kind. */
+export const OTHER_STORE_MARKER = 'other-store';
+const markerWaived = new AsyncLocalStorage();
+// An empty or unreadable marker still refuses: falling through would write the hippo.db the marker forbids.
+function markerKind(marker) {
+    try {
+        return readFileSync(marker, 'utf8').trim() || 'unknown';
+    }
+    catch (err) {
+        log.debug(`${marker} is unreadable, so its store kind reads as unknown: ${errorMessage(err)}`);
+        return 'unknown';
+    }
+}
+/** Throws where hippo.db must not open; checked on every open, not cached, since the marker can appear while a process runs. */
+export function assertSqliteAllowed(hippoRoot) {
     const storeKind = sqliteBlockedBy.getStore();
     if (storeKind !== undefined)
         throw new SqliteBlockedError(storeKind);
+    if (markerWaived.getStore())
+        return;
+    const marker = join(hippoRoot, OTHER_STORE_MARKER);
+    if (existsSync(marker))
+        throw new OtherStoreFolderError(markerKind(marker), marker);
 }
 /** `busyWaitMs` shortens every lock wait of this open, for a hook that must finish inside its own timeout. */
 export function openHippoDb(hippoRoot, opts) {
-    assertSqliteAllowed();
+    assertSqliteAllowed(hippoRoot);
     const stores = currentRequestStores();
     return stores ? stores.get(hippoRoot, opts) : connectHippoDb(hippoRoot, opts?.busyWaitMs);
 }
 /** Open an existing store without changing it: no mkdir, WAL switch, migration or mirror cleanup. Throws when hippo.db is missing. */
 export function openHippoDbReadOnly(hippoRoot) {
-    assertSqliteAllowed();
+    assertSqliteAllowed(hippoRoot);
     const db = new DatabaseSync(getHippoDbPath(hippoRoot), { readOnly: true });
     try {
         db.exec('PRAGMA busy_timeout = 5000');

package/dist/db/sqlite-blocked.d.ts

@@ -1,6 +1,16 @@
 /** Thrown by a hippo.db open inside a request served from another store: the code path is not ported to the store port yet. */
 export declare class SqliteBlockedError extends Error {
     readonly storeKind: string;
-    constructor(storeKind: string);
+    constructor(storeKind: string, message?: string);
+}
+/** A store that lacks a whole group of port methods; it maps to the same 501, and the log names the group instead of hippo.db. */
+export declare class StoreNotPortedError extends SqliteBlockedError {
+    readonly group: string;
+    constructor(storeKind: string, group: string);
+}
+/** Thrown by a hippo.db open in a folder whose marker file names the store that holds its memories, from the CLI as from a request. */
+export declare class OtherStoreFolderError extends SqliteBlockedError {
+    readonly markerPath: string;
+    constructor(storeKind: string, markerPath: string);
 }
 //# sourceMappingURL=sqlite-blocked.d.ts.map

package/dist/db/sqlite-blocked.js

@@ -2,10 +2,28 @@
 /** Thrown by a hippo.db open inside a request served from another store: the code path is not ported to the store port yet. */
 export class SqliteBlockedError extends Error {
     storeKind;
-    constructor(storeKind) {
-        super(`hippo.db is not opened while the '${storeKind}' store serves this request; this code path is not ported to the store yet`);
+    constructor(storeKind, message = `hippo.db is not opened while the '${storeKind}' store serves this request; this code path is not ported to the store yet`) {
+        super(message);
         this.storeKind = storeKind;
         this.name = 'SqliteBlockedError';
     }
 }
+/** A store that lacks a whole group of port methods; it maps to the same 501, and the log names the group instead of hippo.db. */
+export class StoreNotPortedError extends SqliteBlockedError {
+    group;
+    constructor(storeKind, group) {
+        super(storeKind, `the '${storeKind}' store has no '${group}' group; this code path is not ported to the store yet`);
+        this.group = group;
+        this.name = 'StoreNotPortedError';
+    }
+}
+/** Thrown by a hippo.db open in a folder whose marker file names the store that holds its memories, from the CLI as from a request. */
+export class OtherStoreFolderError extends SqliteBlockedError {
+    markerPath;
+    constructor(storeKind, markerPath) {
+        super(storeKind, `This folder's memories live in the '${storeKind}' store, so hippo.db is not used here (marker: ${markerPath})`);
+        this.markerPath = markerPath;
+        this.name = 'OtherStoreFolderError';
+    }
+}
 //# sourceMappingURL=sqlite-blocked.js.map

package/dist/db.d.ts

@@ -3,7 +3,7 @@ export { isSqliteBusy, isStoreBusy, StoreBusyError, STORE_BUSY_MESSAGE, execWith
 export { getSchemaVersion, getMeta, setMeta, isFtsAvailable } from './db/meta.js';
 export { countTableRows, pruneConsolidationRuns } from './db/tables.js';
 export { getCurrentSchemaVersion, IncompatibleBinaryError, ftsRowCounts, repairFtsDrift } from './db/migrate.js';
-export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, rethrowIfSqliteBlocked, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './db/open.js';
+export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, rethrowIfSqliteBlocked, OTHER_STORE_MARKER, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './db/open.js';
 export { RequestStores, runWithRequestStores, currentRequestStores, outsideRequestStores } from './db/request-stores.js';
-export { SqliteBlockedError } from './db/sqlite-blocked.js';
+export { OtherStoreFolderError, SqliteBlockedError } from './db/sqlite-blocked.js';
 //# sourceMappingURL=db.d.ts.map

package/dist/db.js

@@ -2,7 +2,7 @@ export { isSqliteBusy, isStoreBusy, StoreBusyError, STORE_BUSY_MESSAGE, execWith
 export { getSchemaVersion, getMeta, setMeta, isFtsAvailable } from './db/meta.js';
 export { countTableRows, pruneConsolidationRuns } from './db/tables.js';
 export { getCurrentSchemaVersion, IncompatibleBinaryError, ftsRowCounts, repairFtsDrift } from './db/migrate.js';
-export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, rethrowIfSqliteBlocked, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './db/open.js';
+export { getHippoDbPath, HOOK_DB_WAIT_MS, noteStoreBusy, withSharedStoreHandles, SERVER_DB_WAIT_MS, SLEEP_DB_WAIT_MS, scopedBusyWait, withSqliteBlocked, withSqliteAllowed, rethrowIfSqliteBlocked, OTHER_STORE_MARKER, openHippoDb, openHippoDbReadOnly, closeHippoDb, } from './db/open.js';
 export { RequestStores, runWithRequestStores, currentRequestStores, outsideRequestStores } from './db/request-stores.js';
-export { SqliteBlockedError } from './db/sqlite-blocked.js';
+export { OtherStoreFolderError, SqliteBlockedError } from './db/sqlite-blocked.js';
 //# sourceMappingURL=db.js.map

package/dist/delivery-recorder.d.ts

@@ -1,6 +1,6 @@
 import type { MemoryEntry } from './memory.js';
 import { type PromptRecallGate } from './prompt-recall.js';
-export type DeliveryRuntime = 'claude-code' | 'codex' | 'unknown';
+export type DeliveryRuntime = 'claude-code' | 'codex' | 'copilot' | 'unknown';
 export type DeliveryEventType = 'prompt-submit' | 'pinned-manual';
 export type DeliverySurface = 'hook' | 'context';
 export type DeliveryWriteStore = 'local' | 'global';
@@ -121,6 +121,8 @@ export interface DeliveryRecorderInit {
     tenantId: string;
     stdinText?: string;
     envSessionId?: string;
+    /** Set by the caller's runtime flag; Copilot payloads carry hook_event_name too, so inference would say claude-code. */
+    runtime?: DeliveryRuntime;
 }
 /** A recorder for one call; every observer method is guarded, and a throw marks it broken instead of escaping. */
 export declare function createDeliveryRecorder(init: DeliveryRecorderInit): DeliveryRecorder;

package/dist/delivery-recorder.js

@@ -92,7 +92,7 @@ function buildEvent(init, payload, state, ts, startedMs) {
     return {
         ts,
         tenantId: init.tenantId,
-        runtime: payload.hostTurnId !== null ? 'codex' : payload.hookEvent !== null ? 'claude-code' : 'unknown',
+        runtime: init.runtime ?? (payload.hostTurnId !== null ? 'codex' : payload.hookEvent !== null ? 'claude-code' : 'unknown'),
         eventType: payload.hookEvent === 'UserPromptSubmit' ? 'prompt-submit' : 'pinned-manual',
         surface: 'hook',
         storeHash: init.storeHash,

package/dist/embeddings.d.ts

@@ -64,8 +64,19 @@ export declare function embeddingInputText(entry: {
  * consistent with the compare side in `embeddingModelRequiresReindex`.
  */
 export declare function saveStoredEmbeddingModel(hippoRoot: string, model: string): void;
+/** What a store's vector index was built by: the stored identity, and whether any vector exists. */
+export interface EmbeddingIndexState {
+    readonly storedModel: string | null;
+    readonly hasVectors: boolean;
+}
+/** The model the index was built by: the stored identity, else the default model when vectors exist. */
+export declare function indexedModel(state: EmbeddingIndexState): string | null;
+/** The one rebuild rule every store applies to its indexed model. */
+export declare function indexNeedsRebuild(indexed: string | null, providerId: string): boolean;
 export declare function resolveIndexedEmbeddingModel(hippoRoot: string, index?: Record<string, number[]>): string | null;
 export declare function embeddingModelRequiresReindex(hippoRoot: string, model: string, index?: Record<string, number[]>): boolean;
+/** hippo.db's index state, the meta row and the EXISTS on one handle. */
+export declare function embeddingIndexStateAt(hippoRoot: string): EmbeddingIndexState;
 /**
  * Cosine similarity between two vectors. Handles unnormalized vectors.
  * Returns 0 for empty or mismatched vectors.
@@ -75,8 +86,6 @@ export declare function cosineSimilarity(a: number[], b: number[]): number;
 export declare function loadEmbeddingIndex(hippoRoot: string): Record<string, number[]>;
 /** Stored vectors for `ids` only. */
 export declare function loadStoredVectors(hippoRoot: string, ids: readonly string[]): Map<string, number[]>;
-/** Whether the store holds any vector at all. */
-export declare function hasEmbeddings(hippoRoot: string): boolean;
 /** Replace every stored vector with `index`; `model` defaults to the stored index identity. */
 export declare function saveEmbeddingIndex(hippoRoot: string, index: Record<string, number[]>, model?: string): void;
 /**