hippo-memory 1.66.0 → 1.67.0

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/sqlite-blocked.js

@@ -12,7 +12,7 @@ export class SqliteBlockedError extends Error {
 export class StoreNotPortedError extends SqliteBlockedError {
     group;
     constructor(storeKind, group) {
-        super(storeKind, `the '${storeKind}' store has no '${group}' reads; this code path is not ported to the store yet`);
+        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';
     }

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/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);