hippo-memory 1.68.0 → 1.69.0

package/dist/cli/session-hooks.js

@@ -21,11 +21,15 @@ 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 { copilotTranscriptFor, SESSION_ID_RE } from '../capture/copilot-transcript.js';
+import { loadTurnPosition, runSessionWorker, saveTurnPosition, turnsAfter } from '../capture/session-worker.js';
+import { isStringValue, readVscodeStop } from '../capture-contract.js';
+import { loadConfig } from '../config.js';
+import { countCreatedSinceLastSleep } from '../store/index-and-stats.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 { readHookStdin } from '../stdin.js';
+import { normaliseHookPayload, readHookStdin, readStdinBounded } from '../stdin.js';
 import { resolveTenantId } from '../tenant.js';
 import { errorMessage, log } from '../log.js';
 import { withLedgerDb } from '../ledger-db.js';
@@ -143,11 +147,16 @@ function restoreCompactSnapshot(hippoRoot, payloadSessionId) {
  */
 export async function cmdSessionEnd(hippoRoot, flags) {
     const runtime = hookRuntime(flags);
+    const turn = flags['turn'] === true;
     // 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 readHookStdin();
+    const raw = await readStdinBounded();
+    // Read before normalising: the Copilot CLI's agentStop shares this hook line, and camelCase keys would pass as VS Code's.
+    if (turn && !isVscodeStopPayload(raw))
+        return;
+    const stdinText = normaliseHookPayload(raw.text);
     // Before the spawn, since the worker finds its store from the folder it inherits.
     const root = payloadCwdRoot(hippoRoot, stdinText, runtime);
     try {
@@ -172,6 +181,8 @@ export async function cmdSessionEnd(hippoRoot, flags) {
         workerArgs.push('--transcript', transcriptPath);
     if (sessionId)
         workerArgs.push('--session-id', sessionId);
+    if (turn)
+        workerArgs.push('--turn');
     try {
         const child = spawn(process.execPath, workerArgs, {
             detached: true,
@@ -194,7 +205,16 @@ export async function cmdSessionEnd(hippoRoot, flags) {
         return;
     }
 }
+/** A VS Code Stop payload with a session id that can name the lock file; anything else makes turn mode a silent no-op. */
+function isVscodeStopPayload(raw) {
+    const receipt = readVscodeStop(raw.text, raw.timedOut);
+    return receipt.status === 'received' && receipt.input.sessionId !== null && SESSION_ID_RE.test(receipt.input.sessionId);
+}
 export async function cmdSessionEndWorker(hippoRoot, flags) {
+    const sessionId = flags['session-id'];
+    await runSessionWorker(isStringValue(sessionId) ? sessionId : null, flags['turn'] === true ? 'turn' : 'full', (mode) => sessionEndWork(hippoRoot, flags, mode));
+}
+async function sessionEndWork(hippoRoot, flags, mode) {
     const transcriptPath = typeof flags['transcript'] === 'string' ? flags['transcript'] : undefined;
     const closeLogFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : null;
     const closeSessionId = typeof flags['session-id'] === 'string' ? flags['session-id'] : null;
@@ -211,11 +231,18 @@ export async function cmdSessionEndWorker(hippoRoot, flags) {
         flushRereadLog();
         return;
     }
-    await sleepProjectStore(hippoRoot, flags, closeLogFile, transcriptPath);
+    if (mode === 'turn' && closeSessionId)
+        await sleepIfDue(hippoRoot, flags, closeLogFile, transcriptPath, closeSessionId);
+    else
+        await sleepProjectStore(hippoRoot, flags, closeLogFile, transcriptPath);
     flushRereadLog();
     const digestLog = (message) => appendSessionEndCloseLog(closeLogFile, message);
     const scan = transcriptPath ? readSessionScan(transcriptPath, digestLog) : null;
-    captureEndedSession(hippoRoot, store, flags, transcriptPath, scan);
+    const capture = (turns) => captureEndedSession(hippoRoot, store, flags, transcriptPath, turns);
+    if (mode === 'turn')
+        captureNewTurns(transcriptPath, closeSessionId, scan, capture, digestLog);
+    else
+        capture(scan?.turns);
     recordSessionDigest(hippoRoot, scan, {
         key: closeSessionId || path.basename(transcriptPath ?? '', '.jsonl'),
         tenantId: resolveTenantId({}),
@@ -225,7 +252,12 @@ export async function cmdSessionEndWorker(hippoRoot, flags) {
     // session-end may never fire (crash, kill -9) the freshness bound in loadFreshActiveTaskSnapshot is the backstop.
     // The handoff is written first, while the snapshot writeSessionEndHandoff reads is still active.
     if (closeSessionId)
-        writeEndHandoff(store, closeSessionId, transcriptPath, closeLogFile);
+        writeEndHandoff(store, closeSessionId, transcriptPath, closeLogFile, mode === 'turn');
+    if (mode === 'turn') {
+        // The chat goes on after a reply, so its snapshot stays for the next compaction to restore.
+        appendSessionEndCloseLog(closeLogFile, 'skip snapshot close: turn mode');
+        return;
+    }
     try {
         if (closeSessionId) {
             const closed = closeTaskSnapshotsForSession(store, resolveTenantId({}), closeSessionId);
@@ -255,32 +287,68 @@ async function sleepProjectStore(hippoRoot, flags, closeLogFile, transcriptPath)
         logSessionEndImport(closeLogFile, transcriptPath);
     }
 }
-function captureEndedSession(hippoRoot, store, flags, transcriptPath, scan) {
+/** A close after every reply sleeps only at the MCP server's auto-sleep threshold; each line starts the log afresh, as a sleep does. */
+async function sleepIfDue(hippoRoot, flags, closeLogFile, transcriptPath, sessionId) {
+    if (!isInitialized(hippoRoot))
+        return sleepProjectStore(hippoRoot, flags, closeLogFile, transcriptPath);
+    const prefix = `turn close, session ${sessionId}`;
+    try {
+        const { enabled, threshold } = loadConfig(hippoRoot).autoSleep;
+        const count = enabled ? countCreatedSinceLastSleep(hippoRoot, resolveTenantId({})) : 0;
+        if (!enabled || count < threshold) {
+            const why = enabled ? `${count} new memories, threshold ${threshold}` : 'auto-sleep is off';
+            appendSessionEndCloseLog(closeLogFile, `${prefix}: skip sleep, ${why}`, { startFresh: true });
+            return;
+        }
+        await sleepProjectStore(hippoRoot, flags, closeLogFile, transcriptPath);
+        appendSessionEndCloseLog(closeLogFile, `${prefix}: ran sleep at ${count} new memories (threshold ${threshold})`);
+    }
+    catch (err) {
+        appendSessionEndCloseLog(closeLogFile, `${prefix}: sleep check failed: ${errorMessage(err)}`, { startFresh: true });
+    }
+}
+/** Captures only the turns after this session's cursor, then moves the cursor, so each reply is extracted once. */
+function captureNewTurns(transcriptPath, sessionId, scan, capture, log) {
+    if (!transcriptPath || !sessionId || !scan) {
+        log('skip capture: no readable transcript for this session');
+        return;
+    }
+    const fresh = turnsAfter(scan.turns, loadTurnPosition(sessionId, transcriptPath));
+    if (fresh.length === 0) {
+        log('skip capture: no new turns since the last reply');
+        return;
+    }
+    if (capture(fresh))
+        saveTurnPosition(sessionId, transcriptPath, scan.turns, log);
+}
+/** True when capture ran to the end, so a turn close may move its cursor past these turns. */
+function captureEndedSession(hippoRoot, store, flags, transcriptPath, turns) {
     try {
         const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : undefined;
         // With no stdin of its own, capture would read this as a manual run and scan every project.
         if (!transcriptPath) {
             appendSessionEndCloseLog(logFile ?? null, 'skip capture: no transcript for this session');
+            return false;
         }
-        else {
-            cmdCapture(store, {
-                source: 'last-session',
-                transcriptPath,
-                logFile,
-                dryRun: false,
-                global: false,
-                tenantId: resolveTenantId({}),
-                // In the global store, rows would otherwise read as user-global and show up in every project.
-                originProject: store === hippoRoot ? undefined : resolveProjectIdentity(process.cwd()),
-                sessionTurns: scan?.turns,
-            });
-        }
+        cmdCapture(store, {
+            source: 'last-session',
+            transcriptPath,
+            logFile,
+            dryRun: false,
+            global: false,
+            tenantId: resolveTenantId({}),
+            // In the global store, rows would otherwise read as user-global and show up in every project.
+            originProject: store === hippoRoot ? undefined : resolveProjectIdentity(process.cwd()),
+            sessionTurns: turns,
+        });
+        return true;
     }
     catch {
         // Same treatment — the failure line is already in the log.
+        return false;
     }
 }
-function writeEndHandoff(store, closeSessionId, transcriptPath, closeLogFile) {
+function writeEndHandoff(store, closeSessionId, transcriptPath, closeLogFile, inPlace = false) {
     try {
         const tenantId = resolveTenantId({});
         const ownSnapshot = loadActiveTaskSnapshot(store, tenantId)?.session_id === closeSessionId;
@@ -293,7 +361,7 @@ function writeEndHandoff(store, closeSessionId, transcriptPath, closeLogFile) {
         }
         else {
             const evidence = collectHandoffEvidence(process.cwd(), 'unknown');
-            const handoff = writeSessionEndHandoff(store, tenantId, closeSessionId, evidence, derived);
+            const handoff = writeSessionEndHandoff(store, tenantId, closeSessionId, evidence, derived, undefined, { inPlace });
             appendSessionEndCloseLog(closeLogFile, handoff ? `wrote handoff for session ${closeSessionId}` : `skip: kept the existing handoff for session ${closeSessionId}`);
         }
     }

package/dist/cli/setup.js

@@ -2,11 +2,11 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import { execFileSync } from 'child_process';
-import { installJsonHooks, uninstallJsonHooks, checkUninstallable, resolveJsonHookPaths } from '../hooks/json-hooks.js';
+import { installJsonHooks, uninstallJsonHooks, checkUninstallable, copilotHookEvents, resolveJsonHookPaths } from '../hooks/json-hooks.js';
 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 { COPILOT_CLI_MCP, VSCODE_MCP, copilotMcpSnippet, copilotPaths, installCopilot, isCopilotCliPresent, 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';
@@ -42,7 +42,7 @@ 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(`  ${'copilot'.padEnd(15)} -> $COPILOT_HOME or ~/.copilot, and each VS Code User folder (GitHub Copilot: hooks, MCP server and instructions)`);
     console.log('\nUsage: hippo hook install <name>');
     console.log('       hippo hook uninstall <name>');
 }
@@ -155,11 +155,12 @@ function installOpencodeHook() {
         console.log(`WARNING: opencode.json is unparseable; legacy hooks block could not be auto-removed. Fix the file manually.`);
     }
 }
+const addByHand = (host) => `add this under "${host.key}" by hand: ${copilotMcpSnippet(host)}`;
 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()}`,
+    unreadable: (file, host) => `WARNING: ${file} has comments or is not a JSON object hippo can merge into, so it was left unchanged; ${addByHand(host)}`,
 };
 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`;
@@ -175,32 +176,74 @@ const INSTRUCTIONS_REMOVE_LINES = {
     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,
 };
+const VSCODE_INSTRUCTIONS_INSTALL_LINES = {
+    written: (file) => `Wrote the hippo instructions file -> ${file}`,
+    present: (file) => `The hippo instructions file is already at ${file}`,
+    kept: (file) => `Kept ${file} as it is: it is not the text hippo writes, so it was edited or is someone else's`,
+};
+const VSCODE_INSTRUCTIONS_REMOVE_LINES = {
+    removed: (file) => `Removed the hippo instructions file ${file}`,
+    absent: () => '',
+    kept: (file) => `Left ${file}: it is not the text hippo wrote. Delete it by hand if no agent needs it.`,
+};
+const VSCODE_HOOKS_LINE = 'VS Code: hooks need VS Code 1.109.3 or later with chat.useHooks on (the default); older versions get the MCP server and the instructions file only.';
+function mcpInstallLine(file, mcp, host) {
+    return isMcpFailure(mcp) ? mcpFailureLine(file, mcp, addByHand(host)) : MCP_MERGE_LINES[mcp](file, host);
+}
+function printVscodeInstall(result, indent) {
+    const { paths } = result;
+    console.log(`${indent}${mcpInstallLine(paths.mcpConfig, result.mcp, VSCODE_MCP)}`);
+    console.log(`${indent}${VSCODE_INSTRUCTIONS_INSTALL_LINES[result.instructions](paths.instructions)}`);
+    if (paths.profiles.length > 0) {
+        const names = paths.profiles.map((dir) => path.basename(dir)).join(', ');
+        console.log(`${indent}Found VS Code profiles (${names}) under ${path.join(paths.userDir, 'profiles')}: hippo set up the default profile only; copy the "hippo" server and prompts/hippo.instructions.md into a profile to use hippo there.`);
+    }
+}
 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";
+    const { paths } = result;
+    const hooks = result.hooks ? `Installed hippo's Copilot hooks (${copilotHookEvents().join(', ')}) ->` : "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)}`);
+    if (result.mcp === null || result.instructions === null) {
+        console.log(`${indent}No Copilot CLI files in ${path.dirname(paths.mcpConfig)}, so hippo skipped mcp-config.json and copilot-instructions.md, which only the Copilot CLI reads`);
+    }
+    else {
+        console.log(`${indent}${mcpInstallLine(paths.mcpConfig, result.mcp, COPILOT_CLI_MCP)}`);
+        console.log(`${indent}${INSTRUCTIONS_INSTALL_LINES[result.instructions](paths.instructions)}`);
+    }
+    for (const vscode of result.vscode)
+        printVscodeInstall(vscode, indent);
+    if (result.vscode.length > 0)
+        console.log(`${indent}${VSCODE_HOOKS_LINE}`);
     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}`);
+/** The lines for one MCP config file; empty when hippo's server was not there. */
+function mcpRemoveLines(file, mcp) {
     if (isMcpFailure(mcp))
-        console.log(mcpFailureLine(paths.mcpConfig, mcp, 'remove the "hippo" server by hand if hippo added it'));
+        return [mcpFailureLine(file, mcp, 'remove the "hippo" server by hand if hippo added it')];
     if (mcp === 'removed')
-        console.log(`Removed the "hippo" MCP server from ${paths.mcpConfig}`);
+        return [`Removed the "hippo" MCP server from ${file}`];
     if (mcp === 'user-owned')
-        console.log(`Left the "hippo" MCP server in ${paths.mcpConfig}: hippo did not write it`);
+        return [`Left the "hippo" MCP server in ${file}: 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.');
+        return [`WARNING: ${file} 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`];
+    return [];
+}
+function printCopilotUninstall(result) {
+    const { paths, mcp } = result;
+    const lines = [];
+    if (result.hooks)
+        lines.push(`Removed hippo's Copilot hooks file ${paths.hooks}`);
+    lines.push(...mcpRemoveLines(paths.mcpConfig, mcp));
+    lines.push(INSTRUCTIONS_REMOVE_LINES[result.instructions](paths.instructions));
+    for (const vscode of result.vscode) {
+        lines.push(...mcpRemoveLines(vscode.paths.mcpConfig, vscode.mcp));
+        lines.push(VSCODE_INSTRUCTIONS_REMOVE_LINES[vscode.instructions](vscode.paths.instructions));
+    }
+    const printed = lines.filter((line) => line !== '');
+    for (const line of printed)
+        console.log(line);
+    if (printed.length === 0)
+        console.log('No hippo Copilot hooks, MCP server or instructions found.');
 }
 function hookUninstall(target) {
     if (target === 'copilot')
@@ -330,8 +373,11 @@ 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}`);
+    const { hooks, mcpConfig, instructions, vscode } = copilotPaths();
+    const cliFiles = isCopilotCliPresent() ? `, the MCP server in ${mcpConfig} and the hippo block in ${instructions}` : '';
+    console.log(`[dry-run] would install hooks in ${hooks}${cliFiles}`);
+    for (const dir of vscode)
+        console.log(`[dry-run] would add the MCP server to ${dir.mcpConfig} and write ${dir.instructions}`);
 }
 function setupJsonTool(tool, dryRun) {
     if (tool.name === 'copilot')

package/dist/cli/usage.js

@@ -258,7 +258,10 @@ export const VERB_USAGE = {
     --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`],
+                           ~/.hippo/logs/copilot-sleep.log
+    --turn                 VS Code Stop hook, after each reply: capture only the new turns, sleep
+                           only at the auto-sleep threshold, and keep the session's snapshot; does
+                           nothing for any other payload`],
     '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

package/dist/cli.js

@@ -57,7 +57,7 @@ export const BOOLEAN_FLAGS = new Set([
     'no-learn', 'no-mmr', 'no-propagate', 'no-schedule', 'no-share', 'no-summarize-older',
     'observed', 'open', 'physics', 'pin', 'pinned-only', 'reject-loser', 'rerank-utility',
     'reset-physics', 'save-baseline', 'show-cases', 'stats', 'stdin',
-    'strict', 'suite', 'value-aware', 'verified', 'version', 'why',
+    'strict', 'suite', 'turn', 'value-aware', 'verified', 'version', 'why',
 ]);
 // Every flag some command reads. Anything else is a typo that no command would act on.
 export const KNOWN_FLAGS = new Set([

package/dist/connectors/github/ingest.js

@@ -132,7 +132,8 @@ function markKeySeenWithoutMemory(hippoRoot, idempotencyKey, input) {
 }
 function rememberWithEventLog(ctx, input, idempotencyKey, opts) {
     // No `|| 'connector:github'` fallback (see rememberWithEventLog in slack/ingest.ts for rationale).
-    const result = remember(ctx, {
+    const result = remember({ ...ctx, store: undefined }, // the event log row commits with the memory on hippo.db's own handle, never through a store
+    {
         ...opts,
         untrusted: true,
         afterWrite: (innerDb, memoryId) => {

package/dist/connectors/slack/deletion.js

@@ -44,7 +44,8 @@ export function handleMessageDeleted(ctx, input) {
     // Archive + event-log mark commit together via afterArchive. The hook
     // receives the same db handle the archive is using, so the INSERT lives
     // inside the SAVEPOINT.
-    archiveRaw(ctx, memoryId, `source_deleted:slack:${input.teamId}:${input.channelId}:${input.deletedTs}`, {
+    archiveRaw({ ...ctx, store: undefined }, // afterArchive runs on hippo.db's own handle, never through a store
+    memoryId, `source_deleted:slack:${input.teamId}:${input.channelId}:${input.deletedTs}`, {
         afterArchive: (sameDb, archivedId) => {
             markEventSeen(sameDb, input.eventId, archivedId);
         },

package/dist/connectors/slack/ingest.js

@@ -63,7 +63,8 @@ export function ingestMessage(ctx, input) {
 function rememberWithEventLog(ctx, eventId, opts) {
     // No `|| 'connector:slack'` fallback: the caller always builds ctx with the connector subject, and with
     // an object-shaped Context.actor an OR-fallback would never fire anyway.
-    const result = remember(ctx, {
+    const result = remember({ ...ctx, store: undefined }, // the event log row commits with the memory on hippo.db's own handle, never through a store
+    {
         ...opts,
         untrusted: true,
         afterWrite: (innerDb, memoryId) => {

package/dist/env.d.ts

@@ -41,6 +41,8 @@ export declare function envRequireSessionScopedFreshTail(): boolean;
 export declare function envStdinWaitMs(): number | undefined;
 export declare function envLogLevel(): string;
 export declare function envPort(): string | undefined;
+/** How long a client waits for a running server's /health before writing to the store directly; server-detect.ts holds the default. */
+export declare function envHealthProbeMs(): number | undefined;
 export declare function envRequireAuth(): boolean;
 export declare function envV1Rps(): string | undefined;
 export declare function envApiKey(): string | undefined;

package/dist/env.js

@@ -83,6 +83,8 @@ export function envStdinWaitMs() { return positiveInt('HIPPO_STDIN_WAIT_MS'); }
 export function envLogLevel() { return raw('HIPPO_LOG')?.trim().toLowerCase() ?? ''; }
 // Server.
 export function envPort() { return raw('HIPPO_PORT'); }
+/** How long a client waits for a running server's /health before writing to the store directly; server-detect.ts holds the default. */
+export function envHealthProbeMs() { return positiveInt('HIPPO_HEALTH_PROBE_MS'); }
 export function envRequireAuth() { return isOne('HIPPO_REQUIRE_AUTH'); }
 export function envV1Rps() { return raw('HIPPO_V1_RPS'); }
 export function envApiKey() { return raw('HIPPO_API_KEY'); }

package/dist/hooks/copilot.d.ts

@@ -1,21 +1,41 @@
+import type { JsonObject } from '../working-memory.js';
 /** 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 declare const VSCODE_INSTRUCTIONS: string;
+/** The files hippo writes in one VS Code User folder. */
+export interface VscodePaths {
+    readonly userDir: string;
+    readonly mcpConfig: string;
+    readonly instructions: string;
+    /** Profile folders, which keep their own mcp.json and prompts; hippo installs into the default profile only. */
+    readonly profiles: readonly string[];
+}
+/** The three files hippo writes for Copilot, plus the two it writes in each VS Code User folder. */
 export interface CopilotPaths {
     readonly hooks: string;
     readonly mcpConfig: string;
     readonly instructions: string;
+    readonly vscode: readonly VscodePaths[];
 }
 export declare function copilotPaths(): CopilotPaths;
-/** What to paste under "mcpServers" when hippo cannot edit the file itself. */
-export declare function copilotMcpSnippet(): string;
+/** The app that reads an MCP config: where it keeps its servers, and hippo's entry there. */
+export interface McpHost {
+    readonly key: 'mcpServers' | 'servers';
+    server(): JsonObject;
+}
+/** The Copilot CLI's mcp-config.json keeps servers under "mcpServers", each with an env and a tool list. */
+export declare const COPILOT_CLI_MCP: McpHost;
+/** VS Code's mcp.json keeps stdio servers under "servers"; it has no "mcpServers" key. */
+export declare const VSCODE_MCP: McpHost;
+/** What to paste under the host's key when hippo cannot edit the file itself. */
+export declare function copilotMcpSnippet(host?: McpHost): 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 declare function mergeMcpServer(file: string, host?: McpHost): 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 declare function removeMcpServer(file: string, host?: McpHost): McpRemoveStatus;
+/** A filesystem error on an MCP config file (EACCES, EISDIR, EBUSY), kept as its own message so setup can report it and go on. */
 export interface McpFailure {
     readonly failed: string;
 }
@@ -27,19 +47,41 @@ export declare function ensureInstructionsBlock(file: string): InstructionsInsta
 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;
+/** `kept`: the file is there but is not the text hippo writes, so the user edited it or it is someone else's. */
+export type VscodeInstructionsInstallStatus = 'written' | 'present' | 'kept';
+/** The file is hippo's alone, so it is written whole; an earlier hippo text is upgraded, and any other text already there stays. */
+export declare function ensureVscodeInstructions(file: string): VscodeInstructionsInstallStatus;
+export type VscodeInstructionsRemoveStatus = 'removed' | 'absent' | 'kept';
+/** Deletes the file only when it still holds exactly what a hippo release wrote. */
+export declare function removeVscodeInstructions(file: string): VscodeInstructionsRemoveStatus;
+export interface VscodeInstallResult {
+    readonly paths: VscodePaths;
+    readonly mcp: McpMergeStatus | McpFailure;
+    readonly instructions: VscodeInstructionsInstallStatus;
+}
 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;
+    /** Null, like `instructions`, when the Copilot CLI is not installed, since only it reads these two files. */
+    readonly mcp: McpMergeStatus | McpFailure | null;
+    readonly instructions: InstructionsInstallStatus | null;
+    readonly vscode: readonly VscodeInstallResult[];
 }
+/** The CLI's folder holds more than the hooks folder setup makes for VS Code, so a rerun on a VS Code-only machine still finds no CLI. */
+export declare function isCopilotCliPresent(home?: string): boolean;
 export declare function installCopilot(): CopilotInstallResult;
+export interface VscodeUninstallResult {
+    readonly paths: VscodePaths;
+    readonly mcp: McpRemoveStatus | McpFailure;
+    readonly instructions: VscodeInstructionsRemoveStatus;
+}
 export interface CopilotUninstallResult {
     readonly paths: CopilotPaths;
     readonly hooks: boolean;
     readonly mcp: McpRemoveStatus | McpFailure;
     readonly instructions: InstructionsRemoveStatus;
+    readonly vscode: readonly VscodeUninstallResult[];
 }
 export declare function uninstallCopilot(): CopilotUninstallResult;
 //# sourceMappingURL=copilot.d.ts.map