hippo-memory 1.66.0 → 1.67.0

package/README.md

@@ -844,6 +844,8 @@ For Codex, it adds two hooks to `$CODEX_HOME/hooks.json` (else `~/.codex/hooks.j
 
 **Codex runs a new or changed hook only after you trust it, so open `/hooks` in Codex once and trust both;** `hippo doctor` reminds you. The per-prompt hook was checked against a real Codex request; the compaction hook follows Codex's documented `compact` start source and has not been watched end to end in Codex. Each hook also carries a `commandWindows` form (`hippo.cmd ...`), because Codex runs hooks through PowerShell on Windows, where the execution policy can block npm's `hippo.ps1`. hippo only ever appends these two entries and never rewrites one, since Codex treats a changed command as a new hook to trust. To remove: `hippo hook uninstall codex`, which takes out only hippo's exact commands and leaves every other hook, including one of yours that runs hippo.
 
+For GitHub Copilot, once `$COPILOT_HOME` (else `~/.copilot`) exists, `hippo setup` writes hippo's own `hooks/hippo.json`, adds a `hippo` server to `mcp-config.json` and puts a block in `copilot-instructions.md` that asks the agent to call `hippo_recall` and `hippo_remember`. The Copilot CLI, including its sessions inside VS Code, uses all four hooks, the server and the block. VS Code's Local agent runs only the session-start hook and reads neither of the other files, so it gets no pre-compact snapshot or end-of-session capture yet, and its recall tools need hippo added to VS Code's own `mcp.json`. The hooks, that `mcp.json` recipe and how to remove it all: [integrations/copilot.md](integrations/copilot.md).
+
 ### What the hook adds (Claude Code example)
 
 ````markdown

package/dist/api/auth.d.ts

@@ -1,5 +1,6 @@
 import { type ApiKeyListItem, type ApiKeyListRow } from '../auth.js';
 import type { KeysetPosition } from '../keyset.js';
+import { type HippoStore } from '../store-port.js';
 import type { Context } from './types.js';
 export interface AuthCreateOpts {
     label?: string;
@@ -64,9 +65,17 @@ export interface AuthRevokeResult {
     ok: true;
     revokedAt: string;
 }
+/** A promise when `ctx` carries a store, since every store method is async; today's plain result when it carries none.
+ *  hippoRoot keeps the second test off TypeScript's weak-type rule, which would fail a ctx that has no store key at all. */
+export type AuthRevokeReply<C extends Context> = C extends {
+    readonly store: HippoStore;
+} ? Promise<AuthRevokeResult> : C extends {
+    readonly hippoRoot: string;
+    readonly store?: undefined;
+} ? AuthRevokeResult : AuthRevokeResult | Promise<AuthRevokeResult>;
 /** Revoke a key in the caller's tenant: a member API key may revoke only itself, a resolver member only the keys it minted.
- *  The auth_revoke row carries the KEY ROW's tenant, as cmdAuthRevoke does, and is skipped for an already-revoked key. */
-export declare function authRevoke(ctx: Context, keyId: string): AuthRevokeResult;
+ *  With `ctx.store`, its keyAudit group revokes and writes the auth_revoke row; hippo.db is opened only when there is no store. */
+export declare function authRevoke<C extends Context>(ctx: C, keyId: string): AuthRevokeReply<C>;
 /**
  * The tenant that owns `keyId`, or undefined for an unknown key. Host admin only: it reads across tenants,
  * so the local CLI can run revoke and grant in the key's own tenant.

package/dist/api/auth.js

@@ -2,9 +2,10 @@
 import { openHippoDb, closeHippoDb } from '../db.js';
 import { BadRequestError, ConflictError, ForbiddenError, NotFoundError } from '../api-errors.js';
 import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import { createApiKey, listApiKeyRows, listLiveOwnedKeyIds, revokeApiKey, grantScope, ungrantScope } from '../auth.js';
+import { createApiKey, forgetVerifiedKey, listApiKeyRows, listLiveOwnedKeyIds, revokeApiKey, grantScope, ungrantScope, } from '../auth.js';
 import { DAY_MS } from '../dashboard-snapshot.js';
 import { isRestrictedScope } from '../recall-scope.js';
+import { requireGroup } from '../store-port.js';
 import { selectApiKeyOwner } from '../store/tenant-lookup.js';
 const API_KEY_SUBJECT = 'api_key:';
 /** The key id an API-key actor's subject names, or null for any other actor. */
@@ -168,11 +169,33 @@ function assertMayRevoke(ctx, keyId, row) {
     }
 }
 /** Revoke a key in the caller's tenant: a member API key may revoke only itself, a resolver member only the keys it minted.
- *  The auth_revoke row carries the KEY ROW's tenant, as cmdAuthRevoke does, and is skipped for an already-revoked key. */
+ *  With `ctx.store`, its keyAudit group revokes and writes the auth_revoke row; hippo.db is opened only when there is no store. */
 export function authRevoke(ctx, keyId) {
+    const reply = ctx.store ? revokeThroughStore(ctx, ctx.store, keyId) : revokeOnHippoDb(ctx, keyId);
+    // SAFETY: a C typed with a store gets the promise its path returns; a C whose type hides a runtime store (a Pick of
+    // Context) is typed as the union, which a caller has to await anyway.
+    return reply;
+}
+function assertMemberKeyRevokesSelf(ctx, keyId) {
     if (ctx.actor.role !== 'admin' && !ctx.actor.viaAuthResolver && keyIdOfSubject(ctx.actor.subject) !== keyId) {
         throw new ForbiddenError('A member key can revoke only itself');
     }
+}
+function keyOwnerOf(record) {
+    return record ? { tenantId: record.tenantId, revokedAt: record.revokedAt, role: record.role, ownerSubject: record.ownerSubject ?? null } : undefined;
+}
+/** The store keeps no handle on this process's verified-key cache, so the key leaves it here once the revoke commits. */
+async function revokeThroughStore(ctx, store, keyId) {
+    const keyAudit = requireGroup(store, 'keyAudit');
+    assertMemberKeyRevokesSelf(ctx, keyId);
+    assertMayRevoke(ctx, keyId, keyOwnerOf(await store.findApiKey(keyId)));
+    const revokedAt = await keyAudit.revokeApiKey({ tenantId: ctx.tenantId, keyId, actor: ctx.actor.subject, at: new Date().toISOString() });
+    forgetVerifiedKey(keyId);
+    return { ok: true, revokedAt };
+}
+/** The auth_revoke row carries the KEY ROW's tenant, as cmdAuthRevoke does, and is skipped for an already-revoked key. */
+function revokeOnHippoDb(ctx, keyId) {
+    assertMemberKeyRevokesSelf(ctx, keyId);
     const db = openHippoDb(ctx.hippoRoot);
     try {
         const row = selectApiKeyOwner(db, keyId);

package/dist/auth.d.ts

@@ -84,7 +84,9 @@ export declare class VerifiedKeyCache {
 }
 /** Verify a bearer API key against `store`, served at `hippoRoot`; a cache hit skips both scrypt and the store. Null when invalid. A token whose cache entry lapsed re-reads its record without scrypt; a throw from `beforeScrypt` refuses before scrypt runs. */
 export declare function verifyApiKeyCached(hippoRoot: string, plaintext: string, store: HippoStore, beforeScrypt?: () => void): Promise<VerifiedApiKey | null>;
-export declare function revokeApiKey(db: DatabaseSyncLike, keyId: string): void;
+export declare function revokeApiKey(db: DatabaseSyncLike, keyId: string, at?: string): void;
+/** A store other than hippo.db revokes without this process's cache, so its caller drops the key here once the revoke commits. */
+export declare function forgetVerifiedKey(keyId: string): void;
 /** Grant `keyId` read access to one restricted `scope`. Idempotent. */
 export declare function grantScope(db: DatabaseSyncLike, keyId: string, scope: string): void;
 /** Revoke `keyId`'s grant on `scope`. Not an error when no such grant exists. */

package/dist/auth.js

@@ -187,9 +187,13 @@ export async function verifyApiKeyCached(hippoRoot, plaintext, store, beforeScry
         verifiedKeys.set(hippoRoot, keyId, plaintext, found, Date.now());
     return found?.key ?? null;
 }
-export function revokeApiKey(db, keyId) {
+export function revokeApiKey(db, keyId, at = new Date().toISOString()) {
     db.prepare(`UPDATE api_keys SET revoked_at = ? WHERE key_id = ? AND revoked_at IS NULL`)
-        .run(new Date().toISOString(), keyId);
+        .run(at, keyId);
+    verifiedKeys.delete(keyId);
+}
+/** A store other than hippo.db revokes without this process's cache, so its caller drops the key here once the revoke commits. */
+export function forgetVerifiedKey(keyId) {
     verifiedKeys.delete(keyId);
 }
 /** Grant `keyId` read access to one restricted `scope`. Idempotent. */

package/dist/capture/compact.d.ts

@@ -1,3 +1,4 @@
+import { type HookRuntime } from '../capture-contract.js';
 /**
  * Log-forgery guard: messages here interpolate payload-controlled values
  * (transcript paths, session ids). Strip C0 control chars — newlines above
@@ -11,6 +12,7 @@ export interface PreCompactOptions {
     stdinText?: string;
     stdinTimedOut?: boolean;
     logFile?: string;
+    runtime?: HookRuntime;
 }
 /**
  * PreCompact hook entry point. Exit code 2 on PreCompact BLOCKS compaction,

package/dist/capture/compact.js

@@ -59,7 +59,8 @@ function printPreCompactInstruction(logFile) {
     }
 }
 /** Runs the PreCompact producer: records the compaction, asks the summariser for memories, saves a working-state snapshot. Never extracts memories itself; SessionEnd capture owns that. */
-function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile) {
+function runPreCompact(hippoRoot, options, logFile) {
+    const { stdinText, stdinTimedOut = false, runtime = 'claude-code' } = options;
     // The PreCompact hook fires in every Claude Code project, including
     // ones that never ran `hippo init`, so gate before any store-opening call
     // (saveActiveTaskSnapshot etc. call initStore, which would create one).
@@ -67,19 +68,20 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile) {
         appendPreCompactLog(logFile, 'skip: store not initialized');
         return;
     }
-    const receipt = readClaudeCodePreCompact(stdinText, stdinTimedOut);
+    const receipt = readClaudeCodePreCompact(stdinText, stdinTimedOut, runtime);
     if (receipt.status !== 'received') {
         appendPreCompactLog(logFile, `skip: ${receipt.reason}`);
         return;
     }
     const { sessionId, transcriptPath: payloadTranscriptPath, cwd: payloadCwd, trigger: payloadTrigger } = receipt.input;
     // The record is the "something saved before every compaction", so it lands even when no snapshot is derivable below.
+    // Copilot has no PostCompact hook to close a record, so its compactions get the snapshot alone.
     let recordId = null;
-    if (sessionId !== null && sessionId !== '') {
+    if (runtime === 'claude-code' && sessionId !== null && sessionId !== '') {
         recordId = recordCompactionStart(hippoRoot, { sessionId, trigger: payloadTrigger, cwd: payloadCwd, transcriptPath: payloadTranscriptPath }, (message) => appendPreCompactLog(logFile, message));
         printPreCompactInstruction(logFile);
     }
-    const transcriptPath = resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile);
+    const transcriptPath = resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile, runtime);
     if (!transcriptPath)
         return;
     // Nothing derivable skips the write, so a user-authored active snapshot is never clobbered with junk.
@@ -89,7 +91,7 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile) {
     saveDerivedSnapshot(hippoRoot, logFile, sessionId, recordId, derived);
 }
 /** The transcript to snapshot, or null after logging why there is none. */
-function resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile) {
+function resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile, runtime) {
     // A payload transcript_path is EXCLUSIVE: auto-discovery would snapshot a DIFFERENT session's
     // transcript under THIS payload's session_id, so it runs only on a manual invocation (no payload).
     let transcriptPath;
@@ -102,6 +104,10 @@ function resolvePreCompactTranscript(payloadTranscriptPath, stdinText, logFile)
             return null;
         }
     }
+    else if (runtime === 'copilot') {
+        // The scan only knows Claude Code's folders, so a manual Copilot run would snapshot a Claude session.
+        transcriptPath = null;
+    }
     else {
         transcriptPath = resolveLastSessionTranscript(undefined, stdinText, { mayScan: true });
     }
@@ -147,7 +153,7 @@ function saveDerivedSnapshot(hippoRoot, logFile, sessionId, recordId, derived) {
 export async function cmdPreCompact(hippoRoot, options) {
     const logFile = options.logFile ?? defaultPreCompactLogPath();
     try {
-        runPreCompact(hippoRoot, options.stdinText, options.stdinTimedOut ?? false, logFile);
+        runPreCompact(hippoRoot, options, logFile);
     }
     catch (err) {
         appendPreCompactLog(logFile, `pre-compact failed: ${errorMessage(err)}`);

package/dist/capture/copilot-transcript.d.ts

@@ -0,0 +1,15 @@
+/** The envelope fields a Copilot event-log line is read by; any may be absent. */
+export interface CopilotEventLine {
+    type?: unknown;
+    data?: unknown;
+    agentId?: unknown;
+}
+export interface CopilotTurn {
+    role: 'user' | 'assistant';
+    text: string;
+}
+/** The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a missing file. */
+export declare function copilotTranscriptFor(sessionId: string): string | null;
+/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a sub-agent's included. */
+export declare function copilotTurn(line: CopilotEventLine): CopilotTurn | null;
+//# sourceMappingURL=copilot-transcript.d.ts.map

package/dist/capture/copilot-transcript.js

@@ -0,0 +1,40 @@
+// The Copilot event log: one `{type, data, id, timestamp, parentId}` object per line, written by the Copilot CLI and VS Code Local alike.
+// Matched line by line, since the tail readers start mid-file and never see the session.start line.
+import * as fs from 'fs';
+import * as path from 'path';
+import { copilotHomeDir } from '../hooks/shared.js';
+import { isObjectLike, isStringValue } from '../capture-contract.js';
+// A session id becomes a folder name, so anything beyond word characters and hyphens could climb out of session-state.
+const SESSION_ID_RE = /^[\w-]+$/;
+// user.message sources that mark text hippo did not get from the human: a hidden skill injection or another agent's prompt.
+const INJECTED_SOURCE_PREFIXES = ['skill-', 'agent-'];
+/** The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a missing file. */
+export function copilotTranscriptFor(sessionId) {
+    if (!SESSION_ID_RE.test(sessionId))
+        return null;
+    const file = path.join(copilotHomeDir(), 'session-state', sessionId, 'events.jsonl');
+    return fs.existsSync(file) ? file : null;
+}
+function isSubagentLine(line, data) {
+    if (isStringValue(line.agentId) && line.agentId !== '')
+        return true;
+    return isStringValue(data.parentToolCallId) && data.parentToolCallId !== '';
+}
+function isInjectedUserMessage(data) {
+    if (data.isAutopilotContinuation === true)
+        return true;
+    const source = data.source;
+    return isStringValue(source) && INJECTED_SOURCE_PREFIXES.some((prefix) => source.startsWith(prefix));
+}
+/** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a sub-agent's included. */
+export function copilotTurn(line) {
+    const role = line.type === 'user.message' ? 'user' : line.type === 'assistant.message' ? 'assistant' : null;
+    const data = isObjectLike(line.data) ? line.data : null;
+    if (role === null || data === null || isSubagentLine(line, data))
+        return null;
+    if (role === 'user' && isInjectedUserMessage(data))
+        return null;
+    const text = isStringValue(data.content) ? data.content.trim() : '';
+    return text ? { role, text } : null;
+}
+//# sourceMappingURL=copilot-transcript.js.map

package/dist/capture/failure-reading.js

@@ -14,6 +14,9 @@ const LEADING_CD = /^\s*(?:(?:cd|pushd)\b[^;&|]*(?:&&|\|\||;)\s*)+/;
 const NO_MATCH = /\bno (?:matches|files|results) found\b/i;
 /** Shell commands whose exit code 1 means "nothing found" or "differs", not an error. */
 const QUIET_EXIT_1 = /^\s*(?:grep|rg|egrep|fgrep|find|test|\[|diff|cmp|git diff|git grep)\b/;
+// Claude Code's tool names, then the Copilot CLI's and VS Code's; tests/copilot-failure-reading.test.ts cites where each comes from.
+const SEARCH_TOOLS = new Set(['Grep', 'Glob', 'grep', 'glob', 'rg', 'grep_search', 'file_search', 'semantic_search']);
+const SHELL_TOOLS = new Set(['Bash', 'bash', 'powershell', 'run_in_terminal']);
 function isString(v) {
     return v !== undefined && v !== null && v.constructor === String;
 }
@@ -58,9 +61,9 @@ export function lessonFromFailure(payload, scrub = (text) => text) {
         return routine('os-permission');
     if (NO_MATCH.test(error))
         return routine('no-match');
-    if (tool === 'Grep' || tool === 'Glob')
+    if (SEARCH_TOOLS.has(tool))
         return routine('search-tool');
-    if (tool === 'Bash' && QUIET_EXIT_1.test(command) && /exit code 1\b/i.test(error))
+    if (SHELL_TOOLS.has(tool) && QUIET_EXIT_1.test(command) && /exit code 1\b/i.test(error))
         return routine('quiet-exit');
     return { text, detail };
 }

package/dist/capture/transcript.js

@@ -3,8 +3,9 @@ import { claudeConfigDir } from '../hooks/shared.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { isObjectLike, isStringValue } from '../capture-contract.js';
+import { copilotTurn } from './copilot-transcript.js';
 /**
- * Build a compact text summary from a Claude Code / OpenCode JSONL transcript.
+ * Build a compact text summary from a Claude Code / OpenCode / Copilot JSONL transcript.
  * Keeps plain user messages and the final chunk of assistant text, drops
  * thinking blocks, tool_use, and tool_result noise. Capture reads the same
  * turns through `sessionTail`, one text per turn.
@@ -53,6 +54,11 @@ export function collectSessionTurns(jsonl, visit) {
         if (!isObjectLike(entry) || !('type' in entry))
             continue;
         visit?.(entry);
+        const copilot = copilotTurn(entry);
+        if (copilot !== null) {
+            turns.push(copilot);
+            continue;
+        }
         if (entry.type === 'user' || entry.type === 'assistant') {
             const message = 'message' in entry && isObjectLike(entry.message) ? entry.message : undefined;
             if (!message)

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,