hippo-memory 1.67.0 → 1.69.0

package/dist/capture/session-worker.js

@@ -0,0 +1,194 @@
+// One session-end worker per session at a time, plus how far turn capture has read that session's transcript.
+// Two fast replies would otherwise start two workers that both read the dedupe keys before either writes.
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'node:crypto';
+import { homeDir } from '../hooks/shared.js';
+import { errorMessage } from '../log.js';
+import { isObjectLike, isStringValue } from '../capture-contract.js';
+import { SESSION_ID_RE } from './copilot-transcript.js';
+/** Null for a missing id or one that could climb out of the sessions folder. */
+function sessionStateFiles(sessionId) {
+    if (sessionId === null || !SESSION_ID_RE.test(sessionId))
+        return null;
+    const base = path.join(homeDir(), '.hippo', 'sessions', sessionId);
+    return { lock: `${base}.lock`, queued: `${base}.queued`, cursor: `${base}.cursor.json` };
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM means the process exists but belongs to someone else.
+        return err instanceof Error && 'code' in err && err.code === 'EPERM';
+    }
+}
+/** Windows reuses pids, so past this a lock is stale whatever process it names; a worker rarely waits more than minutes on a busy store. */
+const STALE_LOCK_MS = 15 * 60 * 1000;
+/** A dead holder frees its session at once, and any holder at STALE_LOCK_MS. */
+function holderAlive(lock) {
+    let text;
+    let mtimeMs;
+    try {
+        text = fs.readFileSync(lock, 'utf8');
+        mtimeMs = fs.statSync(lock).mtimeMs;
+    }
+    catch (err) {
+        // Gone means released; any other read error is taken as held, so two workers never run on a guess.
+        return !(err instanceof Error && 'code' in err && err.code === 'ENOENT');
+    }
+    const held = /^(\d+):(\d+)$/.exec(text.trim());
+    if (Date.now() - (held ? Number(held[2]) : mtimeMs) > STALE_LOCK_MS)
+        return false;
+    // Empty or torn: its taker is between the create and the write, so it is held.
+    if (!held)
+        return true;
+    const pid = Number(held[1]);
+    return pid !== process.pid && pidAlive(pid);
+}
+// SHORTCUT: two takers racing one stale-lock cleanup can both run, as every worker did before the lock; an atomic link-based take if that shows up.
+function takeSessionLock(lock) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            fs.writeFileSync(lock, `${process.pid}:${Date.now()}`, { flag: 'wx' });
+            return 'taken';
+        }
+        catch (err) {
+            if (!(err instanceof Error && 'code' in err && err.code === 'EEXIST'))
+                return 'unusable';
+            if (holderAlive(lock))
+                return 'held';
+        }
+        try {
+            fs.rmSync(lock, { force: true });
+        }
+        catch {
+            return 'unusable';
+        }
+    }
+    return 'held';
+}
+function releaseSessionLock(lock) {
+    try {
+        fs.rmSync(lock, { force: true });
+    }
+    catch {
+        // A lock left behind names this pid, which is dead once the worker exits, so the next taker clears it.
+    }
+}
+/** False when the sessions folder cannot be written, so the caller runs unlocked as before. */
+function queueRun(files, mode) {
+    try {
+        fs.mkdirSync(path.dirname(files.queued), { recursive: true });
+        // A full close outranks a turn close: it overwrites a queued turn, and a turn never replaces a queued full close.
+        if (mode === 'full')
+            fs.writeFileSync(files.queued, 'full');
+        else
+            fs.writeFileSync(files.queued, 'turn', { flag: 'wx' });
+        return true;
+    }
+    catch (err) {
+        return err instanceof Error && 'code' in err && err.code === 'EEXIST';
+    }
+}
+/** Takes the queued request by renaming it, so one queued while this reads it lands in a fresh file. */
+function takeQueued(queued) {
+    const taken = `${queued}.${process.pid}`;
+    try {
+        fs.renameSync(queued, taken);
+    }
+    catch {
+        // Nothing queued, or a rename refused for a moment; the request stays queued for the next round.
+        return null;
+    }
+    try {
+        return fs.readFileSync(taken, 'utf8') === 'full' ? 'full' : 'turn';
+    }
+    finally {
+        fs.rmSync(taken, { force: true });
+    }
+}
+/** Runs `work` unless a live worker holds this session, which then runs the request after its own so the last reply is never dropped. */
+export async function runSessionWorker(sessionId, mode, work) {
+    const files = sessionStateFiles(sessionId);
+    if (files === null || !queueRun(files, mode))
+        return work(mode);
+    for (let take = takeSessionLock(files.lock); take !== 'held'; take = takeSessionLock(files.lock)) {
+        if (take === 'unusable')
+            return work(mode);
+        let ran = false;
+        try {
+            for (let next = takeQueued(files.queued); next !== null; next = takeQueued(files.queued)) {
+                ran = true;
+                await work(next);
+            }
+        }
+        finally {
+            releaseSessionLock(files.lock);
+        }
+        // A request queued after the last take found the lock still held and left, so it runs here.
+        if (!ran || !fs.existsSync(files.queued))
+            return;
+    }
+}
+function turnKey(turn) {
+    return createHash('sha256').update(`${turn.role}\n${turn.text}`).digest('hex').slice(0, 16);
+}
+/** The cursor position after `turns`: how many there were and a hash of the last. */
+export function turnPosition(turns) {
+    return turns.length === 0 ? '0:' : `${turns.length}:${turnKey(turns[turns.length - 1])}`;
+}
+/** The turns after `position`; all of them when it is null or its last turn is no longer in view. */
+export function turnsAfter(turns, position) {
+    if (position === null)
+        return turns;
+    const [countText, key] = position.split(':');
+    const count = Number(countText);
+    if (!Number.isInteger(count) || count <= 0)
+        return turns;
+    if (count <= turns.length && turnKey(turns[count - 1]) === key)
+        return turns.slice(count);
+    // A transcript too big to read whole is read from its tail, so the count shifts; the last turn's text still marks the place.
+    for (let i = turns.length - 1; i >= 0; i--) {
+        if (turnKey(turns[i]) === key)
+            return turns.slice(i + 1);
+    }
+    return turns;
+}
+/** The saved position for this session's transcript; null when none was saved, it names another file, or it is unreadable. */
+export function loadTurnPosition(sessionId, transcriptPath) {
+    const file = sessionStateFiles(sessionId)?.cursor;
+    if (!file || !fs.existsSync(file))
+        return null;
+    try {
+        const cursor = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!isObjectLike(cursor) || !('source' in cursor) || cursor.source !== transcriptPath)
+            return null;
+        return 'position' in cursor && isStringValue(cursor.position) ? cursor.position : null;
+    }
+    catch {
+        // A torn cursor means the next capture reads every turn, which the dedupe keys absorb.
+        return null;
+    }
+}
+// SHORTCUT: one small cursor file per chat is never pruned; prune by age at sleep if the folder grows.
+export function saveTurnPosition(sessionId, transcriptPath, turns, log) {
+    const file = sessionStateFiles(sessionId)?.cursor;
+    if (!file)
+        return;
+    const cursor = {
+        runtime: 'vscode', sessionId, source: transcriptPath, position: turnPosition(turns), updatedAt: new Date().toISOString(),
+    };
+    const tmp = `${file}.${process.pid}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(tmp, JSON.stringify(cursor));
+        fs.renameSync(tmp, file);
+    }
+    catch (err) {
+        // Windows refuses the rename (EPERM) while another process has the cursor open; the next reply re-reads these turns, which the dedupe keys absorb.
+        log(`cursor not saved: ${errorMessage(err)}`);
+    }
+}
+//# sourceMappingURL=session-worker.js.map

package/dist/capture-contract.d.ts

@@ -1,5 +1,5 @@
 /** A host lifecycle moment hippo can capture from. */
-export type CaptureEvent = 'prompt' | 'tool-failure' | 'pre-compact' | 'post-compact' | 'session-start' | 'session-end' | 'reset';
+export type CaptureEvent = 'prompt' | 'tool-failure' | 'pre-compact' | 'post-compact' | 'session-start' | 'session-end' | 'turn-end' | 'reset';
 /** What hippo read from one host payload, before anything is written. */
 export interface CaptureInput {
     readonly runtime: string;
@@ -46,4 +46,6 @@ export declare function isObjectLike<T>(value: T): value is T & object;
 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;
+/** Reads VS Code's per-reply Stop payload. Pass the raw stdin: stdin.ts would give a Copilot CLI agentStop the same snake_case keys. */
+export declare function readVscodeStop(stdinText: string | undefined, timedOut: boolean): CaptureReceipt;
 //# sourceMappingURL=capture-contract.d.ts.map

package/dist/capture-contract.js

@@ -46,4 +46,40 @@ export function readClaudeCodePreCompact(stdinText, timedOut, runtime = 'claude-
         },
     };
 }
+/** Reads VS Code's per-reply Stop payload. Pass the raw stdin: stdin.ts would give a Copilot CLI agentStop the same snake_case keys. */
+export function readVscodeStop(stdinText, timedOut) {
+    if (!stdinText || stdinText.trim() === '') {
+        return timedOut
+            ? { status: 'unavailable', reason: 'no Stop payload arrived before the stdin wait window closed' }
+            : { status: 'skipped', reason: 'no payload: turn capture runs only from a VS Code Stop hook' };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(stdinText.trim());
+    }
+    catch {
+        // Non-JSON stdin leaves payload undefined, which the shape check rejects.
+    }
+    if (!isObjectLike(payload) || !('hook_event_name' in payload) || payload.hook_event_name !== 'Stop') {
+        return { status: 'skipped', reason: 'not a VS Code Stop payload (no snake_case hook_event_name "Stop")' };
+    }
+    if (!('transcript_path' in payload) || !isStringValue(payload.transcript_path) || !/\.jsonl$/i.test(payload.transcript_path)) {
+        return { status: 'skipped', reason: 'Stop payload names no .jsonl transcript_path' };
+    }
+    if (!('session_id' in payload) || !isStringValue(payload.session_id) || payload.session_id === '') {
+        return { status: 'skipped', reason: 'Stop payload has no session_id' };
+    }
+    return {
+        status: 'received',
+        input: {
+            runtime: 'vscode',
+            event: 'turn-end',
+            manual: false,
+            sessionId: payload.session_id,
+            cwd: 'cwd' in payload && isStringValue(payload.cwd) ? payload.cwd : null,
+            transcriptPath: payload.transcript_path,
+            trigger: null,
+        },
+    };
+}
 //# sourceMappingURL=capture-contract.js.map

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) => {