hippo-memory 2.0.0 → 2.1.0

package/dist/hooks/json-hooks.js

@@ -1,5 +1,6 @@
-/** Hook install/uninstall for AI coding tools. Claude Code gets a JSON `hooks` block in settings.json; older forms are migrated automatically.
- * OpenCode rejects the JSON-hook schema (no `hooks` key), so it gets a TS plugin (OPENCODE_PLUGIN_SOURCE); see installCodexHooks, installCopilotHooks. */
+/** Hook install/uninstall for AI coding tools. Claude Code gets a JSON `hooks` block in settings.json; older forms are
+ * migrated automatically. OpenCode rejects the JSON-hook schema (no `hooks` key), so it gets a TS plugin
+ * (OPENCODE_PLUGIN_SOURCE); see installCodexHooks, installCopilotHooks. */
 import * as fs from 'fs';
 import * as path from 'path';
 import { HIPPO_SLEEP_MARKER, HIPPO_LAST_SLEEP_MARKER, HIPPO_CAPTURE_MARKER, HIPPO_SESSION_END_MARKER, HIPPO_PINNED_INJECT_MARKER, HIPPO_PINNED_INJECT_COMMAND, HIPPO_PRE_COMPACT_MARKER, HIPPO_COMPACT_RESUME_MARKER, HIPPO_CAPTURE_ERROR_MARKER, HIPPO_POST_COMPACT_MARKER, copilotHooksFile, defaultPreCompactLogPath } from './shared.js';
@@ -7,7 +8,7 @@ import { claudeConfigDir, codexHomeDir, homeDir } from '../util/agent-homes.js';
 import { isJsonString, readJsonFile, isJsonObjectLiteral } from '../util/json.js';
 import { escapeRegex } from '../util/escape.js';
 import { writeFileAtomic } from '../util/atomic-write.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 /** The paths for `target` under the current home directory; reads and writes nothing. */
 export function resolveJsonHookPaths(target) {
     const home = homeDir();
@@ -39,13 +40,15 @@ const QUOTED_SPAN = /'[^']*(?:'|$)|"(?:[^"\\]|\\[\s\S]?)*(?:"|$)/g;
  * text ignored: `say hippo sleep`, `echo "a; hippo sleep"` and `./backup.sh && hippo sleep` stay a user's. */
 function isHippoCommand(command, marker) {
     const unquoted = command.replace(QUOTED_SPAN, '');
-    return new RegExp(`(?:^|\\()\\s*(?:[A-Za-z_]\\w*=\\S*\\s+)*(?:[^\\s(]*[/\\\\])?${escapeRegex(marker)}(?![\\w.-])`).test(unquoted);
+    const pattern = `(?:^|\\()\\s*(?:[A-Za-z_]\\w*=\\S*\\s+)*(?:[^\\s(]*[/\\\\])?${escapeRegex(marker)}(?![\\w.-])`;
+    return new RegExp(pattern).test(unquoted);
 }
 const runsHippo = (...markers) => (command) => markers.some((m) => isHippoCommand(command, m));
 function handlerCommand(handler) {
     return isJsonObjectLiteral(handler) && isJsonString(handler.command) ? handler.command : null;
 }
-/** `groups` minus the handlers `isOurs` picks; a group goes only once it has no handler left. Null when no handler matched. */
+/** `groups` minus the handlers `isOurs` picks; a group goes only once it has no handler left. Null when no handler
+ * matched. */
 function withoutHandlers(groups, isOurs) {
     let removed = false;
     const kept = groups.flatMap((group) => {
@@ -80,7 +83,8 @@ function stripHandlers(hooks, event, isOurs) {
 function handlerCommands(groups) {
     return groups.flatMap((group) => (isJsonObjectLiteral(group) && Array.isArray(group.hooks) ? group.hooks.flatMap((h) => handlerCommand(h) ?? []) : []));
 }
-/** The loose "already installed?" test, on purpose weaker than isHippoCommand: a launcher or env prefix still counts, and a false hit only skips an append. */
+/** The loose "already installed?" test, on purpose weaker than isHippoCommand: a launcher or env prefix still counts,
+ * and a false hit only skips an append. */
 function hookArrayContains(hookArray, marker) {
     return Array.isArray(hookArray) && handlerCommands(hookArray).some((command) => command.includes(marker));
 }
@@ -133,7 +137,8 @@ function nothingInstalled(target, settingsPath) {
         invalidJson: false,
     };
 }
-/** A command hook with a Windows form: Codex runs hooks in PowerShell there, whose execution policy can block npm's hippo.ps1. */
+/** A command hook with a Windows form: Codex runs hooks in PowerShell there, whose execution policy can block npm's
+ * hippo.ps1. */
 function codexCommandHook(command, timeout) {
     return { type: 'command', command, commandWindows: command.replace(/^hippo /, 'hippo.cmd '), timeout };
 }
@@ -143,11 +148,14 @@ function ensureHooksObject(settings, events) {
     if (settings.hooks === undefined)
         settings.hooks = {};
     const hooks = settings.hooks;
-    if (!isJsonObjectLiteral(hooks) || events.some((e) => hooks[e] !== undefined && !Array.isArray(hooks[e])))
+    if (!isJsonObjectLiteral(hooks))
+        return null;
+    if (events.some((e) => hooks[e] !== undefined && !Array.isArray(hooks[e])))
         return null;
     return hooks;
 }
-/** Codex keys trust to each hook's position and hash and re-asks for a changed one, so hippo only appends and never edits an entry. */
+/** Codex keys trust to each hook's position and hash and re-asks for a changed one, so hippo only appends and never
+ * edits an entry. */
 function installCodexHooks(settingsPath, settings) {
     const result = nothingInstalled('codex', settingsPath);
     if (!isJsonObjectLiteral(settings))
@@ -173,11 +181,13 @@ function installCodexHooks(settingsPath, settings) {
         writeSettingsFile(settingsPath, settings);
     return { ...result, installedUserPromptSubmit, installedCompactResume };
 }
-/** One Copilot entry with a PowerShell twin: VS Code runs only `powershell` on Windows, where the execution policy can block npm's hippo.ps1. */
+/** One Copilot entry with a PowerShell twin: VS Code runs only `powershell` on Windows, where the execution policy can
+ * block npm's hippo.ps1. */
 function copilotCommandHook(args, timeoutSec) {
     return [{ type: 'command', bash: `hippo ${args}`, powershell: `hippo.cmd ${args}`, timeoutSec }];
 }
-/** No command names a path, so nothing has to be quoted for bash and PowerShell; session-end --runtime copilot picks its own log file. */
+/** No command names a path, so nothing has to be quoted for bash and PowerShell; session-end --runtime copilot picks
+ * its own log file. */
 function copilotHooksTable() {
     return {
         version: 1,
@@ -185,7 +195,8 @@ function copilotHooksTable() {
             sessionStart: copilotCommandHook('context --pinned-only --include-recent 5 --format copilot', 10),
             postToolUseFailure: copilotCommandHook('capture-error --runtime copilot', 10),
             preCompact: copilotCommandHook('pre-compact --runtime copilot', 30),
-            // VS Code maps no camelCase preCompact. The Copilot CLI may run both names, so pre-compact skips a snapshot saved seconds before.
+            // VS Code maps no camelCase preCompact. The Copilot CLI may run both names, so pre-compact skips a snapshot saved
+            // seconds before.
             PreCompact: copilotCommandHook('pre-compact --runtime copilot', 30),
             // VS Code's per-reply Stop. --turn acts on a VS Code payload only, so the Copilot CLI's agentStop does nothing.
             agentStop: copilotCommandHook('session-end --runtime copilot --turn', 30),
@@ -206,9 +217,16 @@ function installCopilotHooks(settingsPath) {
     if (current === JSON.stringify(table, null, 2) + '\n')
         return result;
     writeSettingsFile(settingsPath, table);
-    return { ...result, installedSessionStart: true, installedCaptureError: true, installedPreCompact: true, installedSessionEnd: true };
+    return {
+        ...result,
+        installedSessionStart: true,
+        installedCaptureError: true,
+        installedPreCompact: true,
+        installedSessionEnd: true,
+    };
 }
-/** Adds hippo's hooks to `target`'s settings file and migrates older hippo entries; a file that is not JSON stays untouched. */
+/** Adds hippo's hooks to `target`'s settings file and migrates older hippo entries; a file that is not JSON stays
+ * untouched. */
 export function installJsonHooks(target) {
     const { settings: settingsPath, logFile } = resolveJsonHookPaths(target);
     const dir = path.dirname(settingsPath);
@@ -231,19 +249,22 @@ export function installJsonHooks(target) {
         return { ...nothingInstalled(target, settingsPath), invalidJson: true };
     return installClaudeCodeHooks(settingsPath, settings, logFile);
 }
-/** Swaps the file in with one rename, so a crash mid-write cannot leave a truncated settings.json that Claude Code cannot parse. */
+/** Swaps the file in with one rename, so a crash mid-write cannot leave a truncated settings.json that Claude Code
+ * cannot parse. */
 export function writeSettingsFile(file, settings) {
     writeFileAtomic(file, JSON.stringify(settings, null, 2) + '\n');
 }
 function migrateLegacyClaudeHooks(hooks) {
     const migratedFromStop = stripHandlers(hooks, 'Stop', runsHippo(HIPPO_SLEEP_MARKER));
-    // The legacy SessionEnd forms in the file header collapse into `hippo session-end`, but only while that entry is absent.
+    // The legacy SessionEnd forms in the file header collapse into `hippo session-end`, but only while that entry is
+    // absent.
     let migratedLegacySessionEnd = false;
     let migratedSplitSessionEnd = false;
     if (Array.isArray(hooks.SessionEnd) && !hookArrayContains(hooks.SessionEnd, HIPPO_SESSION_END_MARKER)) {
         const kept = withoutHandlers(hooks.SessionEnd, runsHippo(HIPPO_SLEEP_MARKER, HIPPO_CAPTURE_MARKER));
         if (kept !== null) {
-            // Whatever form was removed reports as the split migration; the legacy flag also marks a SessionEnd that held several groups.
+            // Whatever form was removed reports as the split migration; the legacy flag also marks a SessionEnd that held
+            // several groups.
             migratedSplitSessionEnd = true;
             migratedLegacySessionEnd = hooks.SessionEnd.length > 1;
             if (kept.length === 0)
@@ -266,7 +287,8 @@ function appendHookIfMissing(hooks, event, marker, group) {
     hooks[event].push(group);
     return true;
 }
-/** Every command hippo has written to Claude Code's settings per event, the legacy forms included; uninstall removes only handlers that run one. */
+/** Every command hippo has written to Claude Code's settings per event, the legacy forms included; uninstall removes
+ * only handlers that run one. */
 const CLAUDE_HOOK_MARKERS = [
     ['SessionEnd', [HIPPO_SESSION_END_MARKER, HIPPO_SLEEP_MARKER, HIPPO_CAPTURE_MARKER]],
     ['SessionStart', [HIPPO_LAST_SLEEP_MARKER, HIPPO_COMPACT_RESUME_MARKER]],
@@ -276,26 +298,29 @@ const CLAUDE_HOOK_MARKERS = [
     ['PostToolUseFailure', [HIPPO_CAPTURE_ERROR_MARKER]],
     ['Stop', [HIPPO_SLEEP_MARKER]],
 ];
-// Stop is only ever migrated away, so install never appends to it and a Stop that is not a list does not block the install.
+// Stop is only ever migrated away, so install never appends to it and a Stop that is not a list does not block the
+// install.
 const CLAUDE_APPENDED_EVENTS = CLAUDE_HOOK_MARKERS.map(([event]) => event).filter((event) => event !== 'Stop');
 function appendSessionHooks(hooks, logFile) {
     const installedSessionEnd = appendHookIfMissing(hooks, 'SessionEnd', HIPPO_SESSION_END_MARKER, claudeCommandGroup(`hippo session-end --log-file "${logFile}"`, 5));
     const installedSessionStart = appendHookIfMissing(hooks, 'SessionStart', HIPPO_LAST_SLEEP_MARKER, claudeCommandGroup(`hippo last-sleep --path "${logFile}"`, 5));
-    // Mid-session pinned-rule re-injection: UserPromptSubmit runs every turn, so pinned memories stay in context; the fresh write tail
-    // makes lessons saved earlier in the session visible on the next prompt even before they are pinned.
+    // Mid-session pinned-rule re-injection: UserPromptSubmit runs every turn, so pinned memories stay in context; the
+    // fresh write tail makes lessons saved earlier in the session visible on the next prompt even before they are pinned.
     const migratedPinnedInjectRecent = migratePinnedInjectRecentCommands(hooks.UserPromptSubmit);
     const installedUserPromptSubmit = appendHookIfMissing(hooks, 'UserPromptSubmit', HIPPO_PINNED_INJECT_MARKER, claudeCommandGroup(HIPPO_PINNED_INJECT_COMMAND, 5));
     return { installedSessionEnd, installedSessionStart, migratedPinnedInjectRecent, installedUserPromptSubmit };
 }
 function appendCompactionHooks(hooks) {
-    // PreCompact: fires on manual AND auto compaction (no matcher); records it, asks the summariser for a "Memories for hippo" list and saves a snapshot.
-    // The exit-0 contract lives in the verb itself (cmdPreCompact, src/capture/compact.ts), not in this install-time wiring.
+    // PreCompact: fires on manual AND auto compaction (no matcher); records it, asks the summariser for a "Memories for
+    // hippo" list and saves a snapshot. The exit-0 contract lives in the verb itself (cmdPreCompact,
+    // src/capture/compact.ts), not in this install-time wiring.
     const installedPreCompact = appendHookIfMissing(hooks, 'PreCompact', HIPPO_PRE_COMPACT_MARKER, claudeCommandGroup(`hippo pre-compact --log-file "${defaultPreCompactLogPath()}"`, 30));
-    // SessionStart(compact): a second SessionStart entry beside the unmatched last-sleep one. The matcher is an optimization, not a dependency:
-    // compact-resume checks payload.source itself, and the marker check keys on the command string, so this stays idempotent.
+    // SessionStart(compact): a second SessionStart entry beside the unmatched last-sleep one. The matcher is an
+    // optimization, not a dependency: compact-resume checks payload.source itself, and the marker check keys on the
+    // command string, so this stays idempotent.
     const installedCompactResume = appendHookIfMissing(hooks, 'SessionStart', HIPPO_COMPACT_RESUME_MARKER, claudeCommandGroup('hippo compact-resume', 10, 'compact'));
-    // PostCompact: saves the memories the summariser listed and prints one line, which Claude Code only shows.
-    // PreCompact stdout, by contrast, is handed to the summariser as instructions, so pre-compact prints just the request.
+    // PostCompact: saves the memories the summariser listed and prints one line, which Claude Code only shows. PreCompact
+    // stdout, by contrast, is handed to the summariser as instructions, so pre-compact prints just the request.
     const installedPostCompact = appendHookIfMissing(hooks, 'PostCompact', HIPPO_POST_COMPACT_MARKER, claudeCommandGroup(`hippo post-compact --log-file "${defaultPreCompactLogPath()}"`, 10));
     return { installedPreCompact, installedCompactResume, installedPostCompact };
 }
@@ -337,8 +362,9 @@ const CODEX_HOOK_COMMANDS = [
 /** A group loses only hippo's handlers and goes only once empty, so a user's hook beside or like hippo's stays. */
 function uninstallCodexHooks(hooks) {
     let changed = false;
-    for (const [event, command] of CODEX_HOOK_COMMANDS)
+    for (const [event, command] of CODEX_HOOK_COMMANDS) {
         changed = stripHandlers(hooks, event, (c) => c === command) || changed;
+    }
     return changed;
 }
 /** One stderr line naming the handlers uninstall kept that still mention a hippo command
@@ -346,14 +372,17 @@ function uninstallCodexHooks(hooks) {
 function warnKeptHippoHandlers(settingsPath, hooks) {
     const kept = CLAUDE_HOOK_MARKERS.flatMap(([event, markers]) => {
         const groups = hooks[event];
-        return Array.isArray(groups) ? handlerCommands(groups).filter((command) => markers.some((m) => command.includes(m))) : [];
+        return Array.isArray(groups)
+            ? handlerCommands(groups).filter((command) => markers.some((m) => command.includes(m)))
+            : [];
     });
     if (kept.length === 0)
         return;
     process.stderr.write(`hippo kept these hook handlers in ${settingsPath} because they do not start with a hippo command; ` +
         `remove any that are hippo's by hand: ${kept.map((c) => JSON.stringify(c)).join(', ')}\n`);
 }
-/** Removes hippo's own hook handlers from `target`'s settings file and keeps every other handler; true when the file changed. */
+/** Removes hippo's own hook handlers from `target`'s settings file and keeps every other handler; true when the file
+ * changed. */
 export function uninstallJsonHooks(target) {
     const { settings: settingsPath } = resolveJsonHookPaths(target);
     if (!fs.existsSync(settingsPath))
@@ -369,9 +398,10 @@ export function uninstallJsonHooks(target) {
     }
     catch (err) {
         // Never rewrite a settings file we cannot parse; a read failure (permissions, a directory) is the caller's to see.
-        if (!(err instanceof SyntaxError))
+        if (!(err instanceof SyntaxError)) {
             throw new Error(`could not read ${settingsPath}: ${errorMessage(err)}`, { cause: err });
-        log.warn(`${settingsPath} is not valid JSON, so no hippo hooks were removed from it: ${err.message}`);
+        }
+        log.warn(`${settingsPath} is not valid JSON, so no hippo hooks were removed from it: ${err.message}`, errorFields(err));
         return false;
     }
     if (!isJsonObjectLiteral(settings) || !isJsonObjectLiteral(settings.hooks))
@@ -395,7 +425,11 @@ export function checkUninstallable(target) {
         return { settingsPath, invalidJson: false };
     try {
         const settings = readJsonFile(settingsPath);
-        return { settingsPath, invalidJson: !isJsonObjectLiteral(settings) || (settings.hooks !== undefined && !isJsonObjectLiteral(settings.hooks)) };
+        return {
+            settingsPath,
+            invalidJson: !isJsonObjectLiteral(settings) ||
+                (settings.hooks !== undefined && !isJsonObjectLiteral(settings.hooks)),
+        };
     }
     catch {
         return { settingsPath, invalidJson: true };
@@ -403,8 +437,9 @@ export function checkUninstallable(target) {
 }
 function uninstallClaudeCodeHooks(hooks) {
     let changed = false;
-    for (const [event, markers] of CLAUDE_HOOK_MARKERS)
+    for (const [event, markers] of CLAUDE_HOOK_MARKERS) {
         changed = stripHandlers(hooks, event, runsHippo(...markers)) || changed;
+    }
     return changed;
 }
 //# sourceMappingURL=json-hooks.js.map

package/dist/hooks/opencode.js

@@ -4,8 +4,12 @@ import { homeDir } from '../util/agent-homes.js';
 import { writeFileAtomic } from '../util/atomic-write.js';
 import { isJsonString, isJsonObjectLiteral } from '../util/json.js';
 const HIPPO_OPENCODE_PLUGIN_MARKER = 'HIPPO_OPENCODE_PLUGIN_V1';
-/** The opencode plugin installed at ~/.config/opencode/plugins/hippo.ts: session.idle runs `hippo session-end`, session.created runs `hippo last-sleep`.
- * No `@opencode-ai/plugin` type import (unresolved, it would crash the loader); `$` is guarded and `.nothrow()` keeps a missing hippo binary from throwing. */
+/**
+ * The opencode plugin installed at ~/.config/opencode/plugins/hippo.ts: session.idle runs `hippo session-end`,
+ * session.created runs `hippo last-sleep`.
+ * No `@opencode-ai/plugin` type import (unresolved, it would crash the loader); `$` is guarded and `.nothrow()` keeps a
+ * missing hippo binary from throwing.
+ */
 const OPENCODE_PLUGIN_SOURCE = `// ${HIPPO_OPENCODE_PLUGIN_MARKER}
 // hippo-memory opencode plugin. DO NOT EDIT — regenerated on every
 // \`hippo hook install opencode\` from src/hooks.ts OPENCODE_PLUGIN_SOURCE
@@ -41,8 +45,12 @@ export function resolveOpencodePluginPath() {
 function resolveOpencodeConfigPath() {
     return path.join(homeDir(), '.config', 'opencode', 'opencode.json');
 }
-/** True iff a hook entry's command starts with `hippo ` plus a verb hippo itself installs (session-end, last-sleep, sleep, capture, context).
- * Structural, not substring (`echo "remember to hippo sleep"` is not ours), and per hook so user-authored hooks in the same entry survive. */
+/**
+ * True iff a hook entry's command starts with `hippo ` plus a verb hippo itself installs (session-end, last-sleep,
+ * sleep, capture, context).
+ * Structural, not substring (`echo "remember to hippo sleep"` is not ours), and per hook so user-authored hooks in the
+ * same entry survive.
+ */
 const HIPPO_OWNED_COMMAND_RE = /^\s*hippo\s+(session-end|last-sleep|sleep|capture|context)(?=\s|$)/;
 function hookIsHippoOwned(hook) {
     if (!isJsonObjectLiteral(hook))
@@ -50,7 +58,9 @@ function hookIsHippoOwned(hook) {
     const cmd = hook.command;
     return isJsonString(cmd) && HIPPO_OWNED_COMMAND_RE.test(cmd);
 }
-/** Strip every hippo-owned hook from opencode.json's `hooks` key, deleting entries, keys and the object as they empty; user-authored hooks and other keys stay.
+/**
+ * Strip every hippo-owned hook from opencode.json's `hooks` key, deleting entries, keys and the object as they empty;
+ * user-authored hooks and other keys stay.
  * Returns `{ migrated, jsonRepairFailed }`; jsonRepairFailed means the file is present but unparseable. */
 function migrateLegacyOpencodeHooksBlock() {
     const configPath = resolveOpencodeConfigPath();

package/dist/hooks/shared.d.ts

@@ -20,24 +20,43 @@ export declare const HIPPO_POST_COMPACT_MARKER = "hippo post-compact";
 /** Copilot's config folder: $COPILOT_HOME, else ~/.copilot under os.homedir(), as the
  * Copilot apps resolve it (a HOME that differs from the profile must not move it). */
 export declare function copilotHomeDir(home?: string, env?: Readonly<Record<string, string | undefined>>): string;
-/** Codex counts as installed only when its config folder exists: Codex itself refuses a CODEX_HOME that is not a folder. */
+/**
+ * Codex counts as installed only when its config folder exists: Codex itself refuses a CODEX_HOME that is not a folder.
+ */
 export declare function isCodexPresent(home?: string): boolean;
 /** hippo's own hooks file, in the hooks folder the Copilot CLI reads. */
 export declare function copilotHooksFile(): string;
-/** Where VS Code's agent finds hippo.json: its docs name ~/.copilot/hooks as the user hooks folder, whatever COPILOT_HOME says. */
+/**
+ * Where VS Code's agent finds hippo.json: its docs name ~/.copilot/hooks as the user hooks folder, whatever
+ * COPILOT_HOME says.
+ */
 export declare function vscodeUserHooksFile(home?: string): string;
-/** The VS Code User folders that exist; Stable and Insiders keep their own, and only an edition the user has run has one. */
+/**
+ * The VS Code User folders that exist; Stable and Insiders keep their own, and only an edition the user has run has
+ * one.
+ */
 export declare function vscodeUserDirs(env?: Readonly<Record<string, string | undefined>>, home?: string): string[];
-/** Copilot counts as installed only when its config folder or a VS Code User folder exists, so setup never creates ~/.copilot on a machine with neither. */
+/**
+ * Copilot counts as installed only when its config folder or a VS Code User folder exists, so setup never creates
+ * ~/.copilot on a machine with neither.
+ */
 export declare function isCopilotPresent(home?: string): boolean;
-/** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
-export declare const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";
+/**
+ * Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says
+ * what they would trust.
+ */
+export declare const CODEX_TRUST_LINE: string;
 /** Default log path consumed by `hippo last-sleep` when a caller passes no --path. */
 export declare function defaultSleepLogPath(): string;
-/** Diagnostic-only log path for `hippo pre-compact`, kept apart from the SessionEnd sleep log because `hippo last-sleep` truncates that one every SessionStart.
+/**
+ * Diagnostic-only log path for `hippo pre-compact`, kept apart from the SessionEnd sleep log because `hippo last-sleep`
+ * truncates that one every SessionStart.
  * Nothing reads it programmatically; overridden by `--log-file`. */
 export declare function defaultPreCompactLogPath(): string;
 export declare function ensureDir(dir: string): void;
-/** Detect which AI coding tools are installed from config directory presence; `hippo setup` uses it to pick JSON-hook installs. */
+/**
+ * Detect which AI coding tools are installed from config directory presence; `hippo setup` uses it to pick JSON-hook
+ * installs.
+ */
 export declare function detectInstalledTools(): ToolDetection[];
 //# sourceMappingURL=shared.d.ts.map

package/dist/hooks/shared.js

@@ -19,7 +19,9 @@ export const HIPPO_POST_COMPACT_MARKER = 'hippo post-compact';
 export function copilotHomeDir(home = os.homedir(), env = processEnv()) {
     return env.COPILOT_HOME || path.join(home, '.copilot');
 }
-/** Codex counts as installed only when its config folder exists: Codex itself refuses a CODEX_HOME that is not a folder. */
+/**
+ * Codex counts as installed only when its config folder exists: Codex itself refuses a CODEX_HOME that is not a folder.
+ */
 export function isCodexPresent(home = homeDir()) {
     return fs.statSync(codexHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true;
 }
@@ -27,27 +29,43 @@ export function isCodexPresent(home = homeDir()) {
 export function copilotHooksFile() {
     return path.join(copilotHomeDir(), 'hooks', 'hippo.json');
 }
-/** Where VS Code's agent finds hippo.json: its docs name ~/.copilot/hooks as the user hooks folder, whatever COPILOT_HOME says. */
+/**
+ * Where VS Code's agent finds hippo.json: its docs name ~/.copilot/hooks as the user hooks folder, whatever
+ * COPILOT_HOME says.
+ */
 export function vscodeUserHooksFile(home = os.homedir()) {
     return path.join(home, '.copilot', 'hooks', 'hippo.json');
 }
-/** The VS Code User folders that exist; Stable and Insiders keep their own, and only an edition the user has run has one. */
+/**
+ * The VS Code User folders that exist; Stable and Insiders keep their own, and only an edition the user has run has
+ * one.
+ */
 export function vscodeUserDirs(env = processEnv(), home = os.homedir()) {
     return vscodeDataFolders({ env, home, platform: process.platform })
         .map((dir) => path.join(dir, 'User'))
         .filter((dir) => fs.statSync(dir, { throwIfNoEntry: false })?.isDirectory() === true);
 }
-/** Copilot counts as installed only when its config folder or a VS Code User folder exists, so setup never creates ~/.copilot on a machine with neither. */
+/**
+ * Copilot counts as installed only when its config folder or a VS Code User folder exists, so setup never creates
+ * ~/.copilot on a machine with neither.
+ */
 export function isCopilotPresent(home = os.homedir()) {
-    return fs.statSync(copilotHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true || vscodeUserDirs(processEnv(), home).length > 0;
+    return (fs.statSync(copilotHomeDir(home), { throwIfNoEntry: false })?.isDirectory() === true ||
+        vscodeUserDirs(processEnv(), home).length > 0);
 }
-/** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
-export const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";
+/**
+ * Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says
+ * what they would trust.
+ */
+export const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only " +
+    "after you trust them once in `/hooks`.";
 /** Default log path consumed by `hippo last-sleep` when a caller passes no --path. */
 export function defaultSleepLogPath() {
     return path.join(homeDir(), '.hippo', 'logs', 'last-sleep.log');
 }
-/** Diagnostic-only log path for `hippo pre-compact`, kept apart from the SessionEnd sleep log because `hippo last-sleep` truncates that one every SessionStart.
+/**
+ * Diagnostic-only log path for `hippo pre-compact`, kept apart from the SessionEnd sleep log because `hippo last-sleep`
+ * truncates that one every SessionStart.
  * Nothing reads it programmatically; overridden by `--log-file`. */
 export function defaultPreCompactLogPath() {
     return path.join(homeDir(), '.hippo', 'logs', 'pre-compact.log');
@@ -56,7 +74,13 @@ export function ensureDir(dir) {
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
 }
-/** Detect which AI coding tools are installed from config directory presence; `hippo setup` uses it to pick JSON-hook installs. */
+const COPILOT_NOTES = 'hooks in hooks/hippo.json, the MCP server in ' +
+    'mcp-config.json and a block in copilot-instructions.md; for VS Code, the server in each User mcp.json and ' +
+    'prompts/hippo.instructions.md';
+/**
+ * Detect which AI coding tools are installed from config directory presence; `hippo setup` uses it to pick JSON-hook
+ * installs.
+ */
 export function detectInstalledTools() {
     const home = homeDir();
     const exists = (...parts) => fs.existsSync(path.join(home, ...parts));
@@ -68,26 +92,43 @@ export function detectInstalledTools() {
             configDir: '~/.config/opencode',
             detected: exists('.config', 'opencode'),
             kind: 'plugin',
-            notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts'
+            notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts',
+        },
+        {
+            name: 'openclaw',
+            configDir: '~/.openclaw',
+            detected: exists('.openclaw'),
+            kind: 'plugin',
+            notes: 'install via `openclaw plugins install hippo-memory`',
         },
-        { name: 'openclaw', configDir: '~/.openclaw', detected: exists('.openclaw'), kind: 'plugin', notes: 'install via `openclaw plugins install hippo-memory`' },
         {
             name: 'codex',
             configDir: '~/.codex',
             detected: isCodexPresent(home),
             kind: 'wrapper',
-            notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation'
+            notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation',
+        },
+        {
+            name: 'copilot',
+            configDir: copilotHomeDir(),
+            detected: isCopilotPresent(),
+            kind: 'json-hook',
+            notes: COPILOT_NOTES,
         },
-        { name: 'copilot', configDir: copilotHomeDir(), detected: isCopilotPresent(), kind: 'json-hook', notes: 'hooks in hooks/hippo.json, the MCP server in ' +
-                'mcp-config.json and a block in copilot-instructions.md; for VS Code, the server in each User mcp.json and prompts/hippo.instructions.md' },
         {
             name: 'cursor',
             configDir: '~/.cursor',
             detected: exists('.cursor'),
             kind: 'markdown-instruction',
-            notes: 'no hook API - patches AGENTS.md in the project'
+            notes: 'no hook API - patches AGENTS.md in the project',
+        },
+        {
+            name: 'pi',
+            configDir: '~/.pi',
+            detected: exists('.pi'),
+            kind: 'markdown-instruction',
+            notes: 'no hook API - patches AGENTS.md in the project',
         },
-        { name: 'pi', configDir: '~/.pi', detected: exists('.pi'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
     ];
 }
 //# sourceMappingURL=shared.js.map

package/dist/importers/core.d.ts

@@ -5,8 +5,12 @@ export interface ImportResult {
     total: number;
     imported: number;
     skipped: number;
-    /** Entries refused by the rejection-value guard, kept apart from `skipped` (dedup) so a tombstoned value is distinguishable in summaries.
-     *  Optional because `ImportResult` is exported from the package root and a required field breaks existing consumers; read sites use `?? 0`. */
+    /**
+     * Entries refused by the rejection-value guard, kept apart from `skipped` (dedup) so a tombstoned value is
+     * distinguishable in summaries.
+     * Optional because `ImportResult` is exported from the package root and a required field breaks existing consumers;
+     * read sites use `?? 0`.
+     */
     rejected?: number;
     /** K1 vault import: rows archived this run (changed + source-deleted). In a
      *  dryRun this is the would-be count (a true deletion-sync preview). */
@@ -23,8 +27,12 @@ export interface ImportOptions {
     /** Tenant scope for the dedup read: when set and `global` is false, only this tenant's entries count.
      *  Ignored when `global: true` (host-wide); undefined means host-wide dedup. */
     tenantId?: string;
-    /** K1 vault import only: logical vault name for the `vault:<name>` tag and `artifactRef` key. REQUIRED by importVault (throws if missing or blank),
-     *  because it keys the destructive deletion sync and two vaults sharing a basename would clobber each other. LIKE-escaped by the loader. */
+    /**
+     * K1 vault import only: logical vault name for the `vault:<name>` tag and `artifactRef` key. REQUIRED by importVault
+     * (throws if missing or blank),
+     * because it keys the destructive deletion sync and two vaults sharing a basename would clobber each other.
+     * LIKE-escaped by the loader.
+     */
     name?: string;
     /** K1 vault import only. Memory scope stamped on every imported note. Defaults
      *  to null (unscoped) when unset. */

package/dist/importers/core.js

@@ -24,7 +24,8 @@ export function importEntries(chunks, source, tags, options) {
     let rejected = 0;
     let redacted = 0;
     const entries = [];
-    // One scope, so the store opens once however many chunks land: each write, or a dry run's guard probe, shares its handle.
+    // One scope, so the store opens once however many chunks land: each write, or a dry run's guard probe, shares its
+    // handle.
     return withRequestStoresSync(() => {
         for (const raw of chunks) {
             const { chunk, wasRedacted } = prepareImportChunk(raw, allTags);
@@ -54,7 +55,6 @@ export function importEntries(chunks, source, tags, options) {
 /** The store the import writes to, made ready, with the text keys it already holds. */
 function openImportTarget(options) {
     const targetRoot = options.global ? getGlobalRoot() : options.hippoRoot;
-    // Ensure store is ready
     if (options.global) {
         initGlobal();
     }
@@ -62,10 +62,8 @@ function openImportTarget(options) {
     return { targetRoot, keys };
 }
 function skipReason(chunk, keys) {
-    // Skip empty or too-short chunks
     if (!chunk || chunk.length < 10)
         return 'too-short';
-    // Dedup check: skip only when the same text is already stored
     if (keys.has(duplicateKey(chunk)))
         return 'duplicate';
     return null;
@@ -81,8 +79,10 @@ function prepareImportChunk(raw, allTags) {
     return { chunk: trimmed.slice(0, 1000), wasRedacted };
 }
 function createImportEntry(chunk, source, allTags, options, baseHalfLifeDays) {
-    // kind defaults to 'distilled': these exports are curated user pastes, not raw transcripts from a system of record (see MEMORY_ENVELOPE.md).
-    // The write must use the same tenant as the scoped dedup read above: global=true writes host-wide, global=false writes to options.tenantId.
+    // kind defaults to 'distilled': these exports are curated user pastes, not raw transcripts from a system of record
+    // (see MEMORY_ENVELOPE.md).
+    // The write must use the same tenant as the scoped dedup read above: global=true writes host-wide, global=false
+    // writes to options.tenantId.
     return createMemory(chunk, {
         layer: Layer.Episodic,
         tags: allTags,
@@ -94,8 +94,9 @@ function createImportEntry(chunk, source, allTags, options, baseHalfLifeDays) {
 }
 /** Writes the entry, or on a dry run only probes the guard; false when a rejected value refuses it. */
 function writeOrProbeImport(targetRoot, entry, options) {
-    if (options.dryRun)
+    if (options.dryRun) {
         return !rejectionGuardRefuses(targetRoot, entry.tenant_id ?? DEFAULT_TENANT_ID, entry.id, entry.content);
+    }
     // A rejection refuses one chunk, not the whole import, so siblings still land.
     try {
         writeEntry(targetRoot, entry);

package/dist/importers/markdown-parse.d.ts

@@ -1,18 +1,28 @@
-/** Minimal inline frontmatter split (no YAML dep) on a leading `---\n...\n---\n` block; returns the key-value map plus the body,
+/**
+ * Minimal inline frontmatter split (no YAML dep) on a leading `---\n...\n---\n` block; returns the key-value map plus
+ * the body,
  *  or an empty `fm` and the original content when no well-formed block is present. */
 interface FrontmatterParseResult {
     fm: Record<string, string>;
     body: string;
 }
 export declare function splitMarkdownFrontmatter(raw: string): FrontmatterParseResult;
-/** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a comma-separated scalar, or one token into a string[];
+/**
+ * Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a comma-separated scalar, or one token into a
+ * string[];
  *  quotes and brackets are stripped and empty entries dropped. */
 export declare function frontmatterList(value: string | undefined): string[];
-/** Parse `[[wikilinks]]` from body text: `[[target]]` and `[[target|alias]]` both yield `target`; de-duplicated, order-preserving.
+/**
+ * Parse `[[wikilinks]]` from body text: `[[target]]` and `[[target|alias]]` both yield `target`; de-duplicated,
+ * order-preserving.
  *  Embeds (`![[...]]`) match too, because the leading `!` is outside the capture and a candidate target is harmless. */
 export declare function parseWikilinks(body: string): string[];
-/** Recursively collect files matching `match` (`*.md` default) under `root` as forward-slash relative paths; symlinks are not followed.
- *  Skips dot-directories and the Hippo store path so a vault containing the store never imports its own mirror files; importVault handles root-IS-the-store. */
+/**
+ * Recursively collect files matching `match` (`*.md` default) under `root` as forward-slash relative paths; symlinks
+ * are not followed.
+ * Skips dot-directories and the Hippo store path so a vault containing the store never imports its own mirror files;
+ * importVault handles root-IS-the-store.
+ */
 export declare function collectMarkdownFiles(root: string, hippoRoot: string, match?: RegExp): string[];
 export {};
 //# sourceMappingURL=markdown-parse.d.ts.map