hippo-memory 1.66.0 → 1.68.0

package/dist/capture/working-state.js

@@ -5,6 +5,7 @@ import { isObjectLike, isStringValue } from '../capture-contract.js';
 import { errorMessage } from '../log.js';
 import { PRE_COMPACT_TAIL_BYTES, readTranscriptTail, truncateCodePointSafe } from '../transcript-tail.js';
 import { humanUserText, summariseTranscript } from './transcript.js';
+import { copilotTurn } from './copilot-transcript.js';
 export const PRE_COMPACT_TASK_CAP = 200;
 export const PRE_COMPACT_SUMMARY_CAP = 2000;
 export const PRE_COMPACT_NEXT_STEP_CAP = 500;
@@ -48,7 +49,7 @@ export function truncateKeepNewest(text, maxChars) {
         start = nl + 1;
     return TRIM_MARKER + text.slice(start);
 }
-/** Most recent plain-text user message in a JSONL tail. Claude Code transcript shape only (PreCompact is claude-code-only). */
+/** Most recent plain-text user message in a JSONL tail, from a Claude Code or a Copilot transcript. */
 function lastPlainUserMessage(jsonl) {
     const lines = jsonl.split('\n').filter((l) => l.trim());
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -61,7 +62,12 @@ function lastPlainUserMessage(jsonl) {
         }
         if (!isObjectLike(entry))
             continue;
-        if (!('type' in entry) || entry.type !== 'user')
+        if (!('type' in entry))
+            continue;
+        const copilot = copilotTurn(entry);
+        if (copilot?.role === 'user')
+            return copilot.text;
+        if (entry.type !== 'user')
             continue;
         // An isMeta user line holds an earlier compact summary and an isSidechain one is a sub-agent turn; neither is the human's task.
         if (('isMeta' in entry && entry.isMeta === true) || ('isSidechain' in entry && entry.isSidechain === true))
@@ -88,7 +94,12 @@ function lastAssistantTextBlock(jsonl) {
         }
         if (!isObjectLike(entry))
             continue;
-        if (!('type' in entry) || entry.type !== 'assistant')
+        if (!('type' in entry))
+            continue;
+        const copilot = copilotTurn(entry);
+        if (copilot?.role === 'assistant')
+            return copilot.text;
+        if (entry.type !== 'assistant')
             continue;
         // Same meta/sidechain guard as lastPlainUserMessage: sub-agent turns
         // (isSidechain) are not this session's next step.

package/dist/capture-contract.d.ts

@@ -42,6 +42,8 @@ export interface ProgressCursor {
 export declare function isStringValue<T>(value: T): value is T & string;
 /** An object guard that avoids `typeof`; arrays count as objects, as they do for `typeof`. */
 export declare function isObjectLike<T>(value: T): value is T & object;
-/** Reads a Claude Code PreCompact payload; only an empty stdin counts as a manual run. */
-export declare function readClaudeCodePreCompact(stdinText: string | undefined, timedOut: boolean): CaptureReceipt;
+/** The hook runtimes a `--runtime` flag names; absent means Claude Code. */
+export type HookRuntime = 'claude-code' | 'copilot';
+/** Reads a Claude Code PreCompact payload, or a Copilot one after stdin.ts mapped it to the same snake_case keys; only an empty stdin counts as a manual run. */
+export declare function readClaudeCodePreCompact(stdinText: string | undefined, timedOut: boolean, runtime?: HookRuntime): CaptureReceipt;
 //# sourceMappingURL=capture-contract.d.ts.map

package/dist/capture-contract.js

@@ -8,13 +8,13 @@ export function isStringValue(value) {
 export function isObjectLike(value) {
     return value !== null && value instanceof Object;
 }
-/** Reads a Claude Code PreCompact payload; only an empty stdin counts as a manual run. */
-export function readClaudeCodePreCompact(stdinText, timedOut) {
+/** Reads a Claude Code PreCompact payload, or a Copilot one after stdin.ts mapped it to the same snake_case keys; only an empty stdin counts as a manual run. */
+export function readClaudeCodePreCompact(stdinText, timedOut, runtime = 'claude-code') {
     const empty = !stdinText || stdinText.trim() === '';
     if (timedOut && empty) {
         return { status: 'unavailable', reason: 'no PreCompact payload arrived before the stdin wait window closed' };
     }
-    const base = { runtime: 'claude-code', event: 'pre-compact' };
+    const base = { runtime, event: 'pre-compact' };
     if (empty) {
         return { status: 'received', input: { ...base, manual: true, sessionId: null, cwd: null, transcriptPath: null, trigger: null } };
     }

package/dist/cli/context.js

@@ -7,14 +7,14 @@ import { isGlobalStoreRoot } from '../project-identity.js';
 import { autoDetectContext } from '../context-auto.js';
 import { detectScope } from '../scope.js';
 import { ledgerRoot, withLedgerDb } from '../ledger-db.js';
-import { readStdinBounded } from '../stdin.js';
+import { readHookStdin } from '../stdin.js';
 import * as api from '../api.js';
 import { resolveTenantId } from '../tenant.js';
 import { renderAmbientSummary } from '../ambient.js';
 import { contextBlockLines, contextCost, crossProjectLines, settleTokens } from '../context-render.js';
-import { additionalContextOutput, flushDeliveryRecorder, hasContextData, toRenderItems, } from '../prompt-hook.js';
+import { additionalContextOutput, flushDeliveryRecorder, hasContextData, sessionStartEnvelope, toRenderItems, } from '../prompt-hook.js';
 import { printError } from './output.js';
-import { parseLimitFlag, parseCountFlag, parseBudgetFlag, requireInit, printActiveTaskSnapshot, printSessionEvents, printHandoff, hostSessionId, captureConsole, hookStoreRoot, runHookWithStores, inPilotHoldout, } from './shared.js';
+import { parseLimitFlag, parseCountFlag, parseBudgetFlag, requireInit, printActiveTaskSnapshot, printSessionEvents, printHandoff, hostSessionId, captureConsole, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout, } from './shared.js';
 export async function cmdContext(hippoRoot, args, flags, stdinText) {
     const rec = startDeliveryRecorder(hippoRoot, flags, stdinText);
     // No try/finally: a render throw keeps its own exit code and writes no event.
@@ -37,6 +37,7 @@ function startDeliveryRecorder(hippoRoot, flags, stdinText) {
             tenantId: resolveTenantId({}),
             stdinText,
             envSessionId: hostSessionId(),
+            runtime: hookRuntime(flags) === 'copilot' ? 'copilot' : undefined,
         });
     }
     catch (error) {
@@ -102,11 +103,12 @@ async function renderContext(hippoRoot, args, flags, stdinText, rec) {
         rec?.delivered({ state: 'empty' });
         return;
     }
-    const view = { hippoRoot, tenantId: ctx.tenantId, ledgerSessionId, payloadSessionId, pinnedOnly, framing, rec, result };
+    const envelope = format === 'copilot' ? sessionStartEnvelope(stdinText) : undefined;
+    const view = { hippoRoot, tenantId: ctx.tenantId, ledgerSessionId, payloadSessionId, pinnedOnly, framing, rec, result, envelope };
     if (format === 'json') {
         renderContextJson(view, query);
     }
-    else if (format === 'additional-context') {
+    else if (format === 'additional-context' || format === 'copilot') {
         const stdout = additionalContextOutput(view);
         if (stdout)
             process.stdout.write(stdout);
@@ -145,7 +147,7 @@ function buildContextOpts(flags, input) {
         currentSessionId: input.session.currentSessionId,
         prompt: input.session.prompt,
         // JSON is budgeted as the markdown it stands for, so one budget picks the same memories in every format.
-        cost: contextCost(input.format === 'additional-context' ? 'additional-context' : 'markdown', input.framing),
+        cost: contextCost(input.format === 'additional-context' || input.format === 'copilot' ? 'additional-context' : 'markdown', input.framing),
         deliveryObserver: input.rec ?? undefined,
     };
 }
@@ -225,7 +227,8 @@ export function printContextMarkdown(items, totalTokens, framing = 'observe', op
 }
 export async function handleContext({ hippoRoot, args, flags }) {
     // Bounded, not a TTY guard: the hot stdin path and a manual run share this one command.
-    const { text: stdinText } = await readStdinBounded();
-    await runHookWithStores(() => cmdContext(hookStoreRoot(hippoRoot), args, flags, stdinText));
+    const { text: stdinText } = await readHookStdin();
+    const root = payloadCwdRoot(hippoRoot, stdinText, hookRuntime(flags));
+    await runHookWithStores(() => cmdContext(hookStoreRoot(root), args, flags, stdinText));
 }
 //# sourceMappingURL=context.js.map

package/dist/cli/hook-blocks.d.ts

@@ -15,4 +15,6 @@ export declare function hippoBlock(text: string): {
     inner: string;
     owner?: string;
 } | null;
+/** `text` with every hippo block and its markers removed, trimmed. */
+export declare function withoutHookBlock(text: string): string;
 //# sourceMappingURL=hook-blocks.d.ts.map

package/dist/cli/hook-blocks.js

@@ -1,5 +1,6 @@
 // The hippo block each agent's instruction file carries, and how init recognises one it wrote earlier.
 import { createHash } from 'node:crypto';
+import { escapeRegex } from '../escape.js';
 export const HOOK_MARKERS = {
     start: '<!-- hippo:start -->',
     end: '<!-- hippo:end -->',
@@ -230,4 +231,9 @@ export function hippoBlock(text) {
     const owner = Object.keys(HOOKS).find((k) => HOOKS[k].content === inner) ?? SHIPPED_HOOK_HASHES.get(createHash('sha256').update(inner).digest('hex'));
     return { start, end, eol: raw.includes('\r\n') ? '\r\n' : '\n', inner, owner };
 }
+/** `text` with every hippo block and its markers removed, trimmed. */
+export 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();
+}
 //# sourceMappingURL=hook-blocks.js.map

package/dist/cli/session-hooks.d.ts

@@ -20,7 +20,7 @@ export declare function cmdCodexRun(hippoRoot: string, args: string[]): void;
 export declare function cmdCodexSessionEndWorker(hippoRoot: string, flags: Record<string, string | boolean | string[]>): Promise<void>;
 export declare function handlePreCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
 export declare function handlePostCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
-export declare function handleCaptureError({ hippoRoot }: CommandContext): Promise<void>;
+export declare function handleCaptureError({ hippoRoot, flags }: CommandContext): Promise<void>;
 export declare function handleCompactResume({ hippoRoot }: CommandContext): Promise<void>;
 export declare function handleCapture({ hippoRoot, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=session-hooks.d.ts.map

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/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,