hippo-memory 1.69.0 → 1.71.0

package/dist/hooks/opencode.d.ts

@@ -1,42 +1,4 @@
 declare const HIPPO_OPENCODE_PLUGIN_MARKER = "HIPPO_OPENCODE_PLUGIN_V1";
-/**
- * The opencode plugin file we install at ~/.config/opencode/plugins/hippo.ts.
- *
- * Per https://opencode.ai/docs/plugins/, plugins are TS/JS modules exporting an
- * async function returning hooks. We subscribe to `event` and route:
- *   session.idle    → `hippo session-end` (Claude Code's SessionEnd equiv)
- *   session.created → `hippo last-sleep` (Claude Code's SessionStart equiv)
- *
- * Design choices:
- *
- * 1. No `import type { Plugin } from "@opencode-ai/plugin"`. The package's npm
- *    publication status was unverifiable from the build sandbox (npmjs.com
- *    returned 403); an unresolved type-only import would still crash the TS
- *    runtime opencode uses to load the plugin. opencode infers plugin shape
- *    from the returned object, so the type was convenience-only.
- *
- * 2. Defensive `typeof $ !== 'function'` guard. opencode runs in Bun (where
- *    `$` is the shell-template helper), but a future Node-mode deployment
- *    would have `$` undefined in the destructured context and the plugin
- *    would throw on every session.idle, killing opencode sessions in a
- *    hard-to-recover way (the idempotence marker prevents auto-reinstall).
- *    Fail closed, let opencode continue.
- *
- * 3. `.quiet().nothrow()` on each `$\`...\`` so a missing hippo binary
- *    (e.g. PATH-misconfigured user) does NOT throw out of the event handler.
- *    The surrounding try/catch is belt-and-braces.
- *
- * 4. UserPromptSubmit equivalent NOT wired. opencode's `message.updated`
- *    fires per-token, not per-prompt-submit; no clean per-prompt event.
- *    Users wanting pinned-context auto-injection can call `hippo context`
- *    via the MCP server (`hippo mcp`).
- *
- * 5. Versioned marker `HIPPO_OPENCODE_PLUGIN_V1` allows future versions to
- *    overwrite cleanly. The installer's idempotence check requires BOTH
- *    marker match AND content equality, so a plugin-source revision under
- *    the same V1 marker re-writes the file on next install.
- */
-export declare const OPENCODE_PLUGIN_SOURCE = "// HIPPO_OPENCODE_PLUGIN_V1\n// hippo-memory opencode plugin. DO NOT EDIT \u2014 regenerated on every\n// `hippo hook install opencode` from src/hooks.ts OPENCODE_PLUGIN_SOURCE\n// in https://github.com/kitfunso/hippo-memory. Local changes will be lost.\n\nexport const HippoPlugin = async ({ $ }) => {\n  return {\n    event: async ({ event }) => {\n      // Defense in depth: opencode currently runs in Bun where $ is the shell\n      // template helper. A non-Bun runtime would have $ as undefined; fail\n      // closed instead of crashing the host session.\n      if (typeof $ !== \"function\") return;\n      try {\n        if (event.type === \"session.idle\") {\n          await $`hippo session-end`.quiet().nothrow();\n        } else if (event.type === \"session.created\") {\n          await $`hippo last-sleep`.quiet().nothrow();\n        }\n      } catch {\n        // hippo CLI not on PATH or other failure \u2014 never crash the host session.\n      }\n    },\n  };\n};\n";
 export { HIPPO_OPENCODE_PLUGIN_MARKER };
 export interface OpencodePluginInstallResult {
     installed: boolean;

package/dist/hooks/opencode.js

@@ -1,46 +1,12 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { isJsonObject, homeDir } from './shared.js';
-import { isJsonString } from '../json.js';
+import { homeDir } from './shared.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 file we install at ~/.config/opencode/plugins/hippo.ts.
- *
- * Per https://opencode.ai/docs/plugins/, plugins are TS/JS modules exporting an
- * async function returning hooks. We subscribe to `event` and route:
- *   session.idle    → `hippo session-end` (Claude Code's SessionEnd equiv)
- *   session.created → `hippo last-sleep` (Claude Code's SessionStart equiv)
- *
- * Design choices:
- *
- * 1. No `import type { Plugin } from "@opencode-ai/plugin"`. The package's npm
- *    publication status was unverifiable from the build sandbox (npmjs.com
- *    returned 403); an unresolved type-only import would still crash the TS
- *    runtime opencode uses to load the plugin. opencode infers plugin shape
- *    from the returned object, so the type was convenience-only.
- *
- * 2. Defensive `typeof $ !== 'function'` guard. opencode runs in Bun (where
- *    `$` is the shell-template helper), but a future Node-mode deployment
- *    would have `$` undefined in the destructured context and the plugin
- *    would throw on every session.idle, killing opencode sessions in a
- *    hard-to-recover way (the idempotence marker prevents auto-reinstall).
- *    Fail closed, let opencode continue.
- *
- * 3. `.quiet().nothrow()` on each `$\`...\`` so a missing hippo binary
- *    (e.g. PATH-misconfigured user) does NOT throw out of the event handler.
- *    The surrounding try/catch is belt-and-braces.
- *
- * 4. UserPromptSubmit equivalent NOT wired. opencode's `message.updated`
- *    fires per-token, not per-prompt-submit; no clean per-prompt event.
- *    Users wanting pinned-context auto-injection can call `hippo context`
- *    via the MCP server (`hippo mcp`).
- *
- * 5. Versioned marker `HIPPO_OPENCODE_PLUGIN_V1` allows future versions to
- *    overwrite cleanly. The installer's idempotence check requires BOTH
- *    marker match AND content equality, so a plugin-source revision under
- *    the same V1 marker re-writes the file on next install.
- */
-export const OPENCODE_PLUGIN_SOURCE = `// ${HIPPO_OPENCODE_PLUGIN_MARKER}
+/** 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
 // in https://github.com/kitfunso/hippo-memory. Local changes will be lost.
@@ -72,47 +38,17 @@ export function resolveOpencodePluginPath() {
 function resolveOpencodeConfigPath() {
     return path.join(homeDir(), '.config', 'opencode', 'opencode.json');
 }
-/**
- * Return true iff a single hook-array entry's command string starts with
- * `hippo ` (the verb-prefix). Used to surgically remove only hippo-owned
- * commands when migrating an opencode.json. We own the install side, so only
- * the canonical `hippo <verb>` form needs to match — and only canonical verbs
- * hippo itself installs (session-end, last-sleep, sleep, capture, context),
- * not any third-party tool that happens to be named `hippo`.
- *
- * Structural check: substring matching against
- * arbitrary user content is unsafe — a user's
- * `echo "remember to hippo sleep your laptop"` is not a hippo-owned hook.
- *
- * Per-hook (not per-entry) granularity: an entry whose inner
- * hooks array mixes hippo-installed commands with user-authored commands
- * must NOT lose the user-authored commands. The migration filters the inner
- * array per-hook, then drops the entry only when its inner array is empty.
- */
+/** 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 (!isJsonObject(hook))
+    if (!isJsonObjectLiteral(hook))
         return false;
     const cmd = hook.command;
     return isJsonString(cmd) && HIPPO_OWNED_COMMAND_RE.test(cmd);
 }
-/**
- * Structurally strip every hippo-owned hook from opencode.json's hooks key.
- * Returns one of:
- *   { migrated: true,  jsonRepairFailed: false } — at least one hook removed.
- *   { migrated: false, jsonRepairFailed: false } — file fine, nothing to do.
- *   { migrated: false, jsonRepairFailed: true  } — file present but unparseable.
- *
- * Per-hook surgery:
- *   - For each entry in each event-key array, filter the inner `hooks` array
- *     to remove hippo-owned hooks only. User-authored hooks in the same
- *     inner array are preserved.
- *   - When an entry's inner `hooks` array becomes empty, that entry is
- *     removed from the outer array.
- *   - When an event-key array becomes empty, the key is deleted.
- *   - When the top-level `hooks` object becomes empty, it is deleted.
- *   - Other keys (theme, etc.) are always preserved.
- */
+/** 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();
     if (!fs.existsSync(configPath))
@@ -127,7 +63,7 @@ function migrateLegacyOpencodeHooksBlock() {
     const hooks = settings.hooks;
     // Non-object hooks values (string, array, null) are user content we don't
     // recognise — leave them alone, return migrated=false.
-    if (!isJsonObject(hooks)) {
+    if (!isJsonObjectLiteral(hooks)) {
         return { migrated: false, jsonRepairFailed: false };
     }
     const hooksObj = hooks;
@@ -135,26 +71,9 @@ function migrateLegacyOpencodeHooksBlock() {
     for (const key of Object.keys(hooksObj)) {
         if (!Array.isArray(hooksObj[key]))
             continue;
-        const survivingEntries = [];
-        for (const entry of hooksObj[key]) {
-            if (!isJsonObject(entry)) {
-                survivingEntries.push(entry);
-                continue;
-            }
-            const innerHooks = entry.hooks;
-            if (!Array.isArray(innerHooks)) {
-                survivingEntries.push(entry);
-                continue;
-            }
-            const beforeInner = innerHooks.length;
-            const survivingInner = innerHooks.filter((h) => !hookIsHippoOwned(h));
-            if (survivingInner.length !== beforeInner)
-                changed = true;
-            if (survivingInner.length === 0)
-                continue; // drop entry, nothing left
-            entry.hooks = survivingInner;
-            survivingEntries.push(entry);
-        }
+        const { survivingEntries, strippedAny } = stripHippoHooksFromEntries(hooksObj[key]);
+        if (strippedAny)
+            changed = true;
         if (survivingEntries.length !== hooksObj[key].length)
             changed = true;
         hooksObj[key] = survivingEntries;
@@ -165,24 +84,46 @@ function migrateLegacyOpencodeHooksBlock() {
         return { migrated: false, jsonRepairFailed: false };
     if (Object.keys(hooksObj).length === 0)
         delete settings.hooks;
-    fs.writeFileSync(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    writeFileAtomic(configPath, JSON.stringify(settings, null, 2) + '\n');
     return { migrated: true, jsonRepairFailed: false };
 }
+/** One event's entries with every hippo-owned hook taken out, and whether any was. */
+function stripHippoHooksFromEntries(entries) {
+    const survivingEntries = [];
+    let strippedAny = false;
+    for (const entry of entries) {
+        if (!isJsonObjectLiteral(entry)) {
+            survivingEntries.push(entry);
+            continue;
+        }
+        const innerHooks = entry.hooks;
+        if (!Array.isArray(innerHooks)) {
+            survivingEntries.push(entry);
+            continue;
+        }
+        const beforeInner = innerHooks.length;
+        const survivingInner = innerHooks.filter((h) => !hookIsHippoOwned(h));
+        if (survivingInner.length !== beforeInner)
+            strippedAny = true;
+        if (survivingInner.length === 0)
+            continue; // drop entry, nothing left
+        entry.hooks = survivingInner;
+        survivingEntries.push(entry);
+    }
+    return { survivingEntries, strippedAny };
+}
 export function installOpencodePlugin() {
     const pluginPath = resolveOpencodePluginPath();
     const { migrated, jsonRepairFailed } = migrateLegacyOpencodeHooksBlock();
-    // Idempotence: skip the write only if BOTH the marker is present AND the
-    // content matches the current source. Marker-only matches (with stale
-    // content) overwrite cleanly so future plugin-source patches reach
-    // existing installs.
+    // Skip the write only if BOTH the marker is present and the content matches; a marker-only match with stale
+    // content is rewritten so plugin-source patches reach existing installs.
     if (fs.existsSync(pluginPath)) {
         const existing = fs.readFileSync(pluginPath, 'utf8');
         if (existing.includes(HIPPO_OPENCODE_PLUGIN_MARKER) && existing === OPENCODE_PLUGIN_SOURCE) {
             return { installed: false, pluginPath, migratedLegacyHooks: migrated, jsonRepairFailed };
         }
     }
-    fs.mkdirSync(path.dirname(pluginPath), { recursive: true });
-    fs.writeFileSync(pluginPath, OPENCODE_PLUGIN_SOURCE, 'utf8');
+    writeFileAtomic(pluginPath, OPENCODE_PLUGIN_SOURCE);
     return { installed: true, pluginPath, migratedLegacyHooks: migrated, jsonRepairFailed };
 }
 export function uninstallOpencodePlugin() {

package/dist/hooks/shared.d.ts

@@ -1,7 +1,3 @@
-import type { JsonObject } from '../working-memory.js';
-import type { JsonValue } from '../json.js';
-/** JSON-value plain-object check (excludes arrays and null); `constructor` avoids the `typeof` tag banned by anti-slop/no-runtime-typeof. */
-export declare function isJsonObject(value: JsonValue | undefined): value is JsonObject;
 export type JsonHookTarget = 'claude-code' | 'codex' | 'copilot';
 export interface ToolDetection {
     name: string;
@@ -24,9 +20,11 @@ export declare const HIPPO_POST_COMPACT_MARKER = "hippo post-compact";
 export declare function homeDir(): string;
 /** Codex's config folder: $CODEX_HOME, else ~/.codex, as the Codex hooks docs describe. */
 export declare function codexHomeDir(home?: string, env?: Readonly<Record<string, string | undefined>>): string;
-/** 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). */
+/** 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;
-/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
+/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else
+ * ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
 export declare function claudeConfigDir(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. */
 export declare function isCodexPresent(home?: string): boolean;
@@ -40,23 +38,12 @@ export declare function vscodeUserDirs(env?: Readonly<Record<string, string | un
 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`.";
-/**
- * Default log path consumed by `hippo last-sleep`. Shared fallback when
- * a caller doesn't pass --path explicitly.
- */
+/** 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`. Deliberately separate
- * from the SessionEnd sleep log: `hippo last-sleep` truncates that file on
- * every SessionStart, which would wipe pre-compact lines before anyone
- * could read them. Nothing consumes this file programmatically — it exists
- * for manual troubleshooting only. Overridden by `--log-file`.
- */
+/** 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 based on config directory presence.
- * Used by `hippo setup` to decide which JSON-hook installs to run.
- */
+/** 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

@@ -1,12 +1,8 @@
-import { envHomeDir, processEnv } from '../env.js';
+import { envHomeDir, processEnv } from '../util/env.js';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { vscodeDataFolders } from '../agent-memories/copilot.js';
-/** JSON-value plain-object check (excludes arrays and null); `constructor` avoids the `typeof` tag banned by anti-slop/no-runtime-typeof. */
-export function isJsonObject(value) {
-    return value !== undefined && value !== null && !Array.isArray(value) && value.constructor === Object;
-}
 export const HIPPO_SLEEP_MARKER = 'hippo sleep';
 export const HIPPO_LAST_SLEEP_MARKER = 'hippo last-sleep';
 export const HIPPO_CAPTURE_MARKER = 'hippo capture --last-session';
@@ -25,11 +21,13 @@ export function homeDir() {
 export function codexHomeDir(home = homeDir(), env = processEnv()) {
     return env.CODEX_HOME || path.join(home, '.codex');
 }
-/** 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). */
+/** 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 function copilotHomeDir(home = os.homedir(), env = processEnv()) {
     return env.COPILOT_HOME || path.join(home, '.copilot');
 }
-/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
+/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else
+ * ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
 export function claudeConfigDir(home = os.homedir(), env = processEnv()) {
     return env.CLAUDE_CONFIG_DIR || path.join(home, '.claude');
 }
@@ -57,20 +55,12 @@ export function isCopilotPresent(home = os.homedir()) {
 }
 /** 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`. Shared fallback when
- * a caller doesn't pass --path explicitly.
- */
+/** 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`. Deliberately separate
- * from the SessionEnd sleep log: `hippo last-sleep` truncates that file on
- * every SessionStart, which would wipe pre-compact lines before anyone
- * could read them. Nothing consumes this file programmatically — it exists
- * for manual troubleshooting only. Overridden by `--log-file`.
- */
+/** 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');
 }
@@ -78,21 +68,36 @@ export function ensureDir(dir) {
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
 }
-/**
- * Detect which AI coding tools are installed based on config directory presence.
- * Used by `hippo setup` to decide which JSON-hook installs to run.
- */
+/** 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));
     const claudeDir = claudeConfigDir();
     return [
         { name: 'claude-code', configDir: claudeDir, detected: fs.existsSync(claudeDir), kind: 'json-hook' },
-        { name: 'opencode', configDir: '~/.config/opencode', detected: exists('.config', 'opencode'), kind: 'plugin', notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts' },
+        {
+            name: 'opencode',
+            configDir: '~/.config/opencode',
+            detected: exists('.config', 'opencode'),
+            kind: 'plugin',
+            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: 'codex', configDir: '~/.codex', detected: isCodexPresent(home), kind: 'wrapper', notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation' },
+        {
+            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'
+        },
         { 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' },
+        {
+            name: 'cursor',
+            configDir: '~/.cursor',
+            detected: exists('.cursor'),
+            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' },
     ];
 }

package/dist/importers/core.d.ts

@@ -1,22 +1,12 @@
-/**
- * Memory importers for Hippo.
- * Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown.
- */
-import { MemoryEntry } from '../memory.js';
-import type { JsonValue } from '../json.js';
+/** Memory importers for Hippo.
+ *  Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown. */
+import { MemoryEntry } from '../core/memory.js';
 export interface ImportResult {
     total: number;
     imported: number;
     skipped: number;
-    /** AT1: refused by the rejection-value guard — kept distinct from
-     *  `skipped` (dedup) so a tombstoned value is distinguishable from a
-     *  plain duplicate in import summaries (plan §3 containment, round-2 low).
-     *  AT1 P2 fix (codex, published-surface compat): optional, not required —
-     *  `ImportResult` is re-exported from the package root (index.ts), and a
-     *  required field breaks any existing consumer constructing the pre-AT1
-     *  shape. Every producer in this file still always sets a real number;
-     *  `?? 0` at read sites (this file's own accumulation, cli.ts's summary
-     *  prints) tolerates a caller-supplied object that omits it. */
+    /** 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). */
@@ -30,36 +20,17 @@ export interface ImportOptions {
     global?: boolean;
     extraTags?: string[];
     hippoRoot: string;
-    /**
-     * L9: tenant scope for the dedup read. When provided AND `global` is
-     * false, the dedup check only considers this tenant's existing entries.
-     * Ignored when `global: true` (global writes are host-wide by definition).
-     * Undefined preserves pre-1.12.1 host-wide dedup behaviour.
-     */
+    /** 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 used in the `vault:<name>` tag and
-     * the `artifactRef='vault:<name>:<relpath>'` key. REQUIRED by importVault: it
-     * is the identity key for the destructive source-deletion sync, so it must be
-     * set explicitly rather than inferred from the folder basename (two vaults
-     * sharing a basename would collide and clobber each other). importVault throws
-     * if it is missing or blank. Optional in this shared type only because the
-     * other importers ignore it. Operator-supplied, so the loader query LIKE-escapes
-     * it (`escapeLike` in src/escape.ts).
-     */
+    /** 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.
-     */
+    /** K1 vault import only. Memory scope stamped on every imported note. Defaults
+     *  to null (unscoped) when unset. */
     scope?: string;
 }
-/**
- * Given an array of raw text chunks, deduplicate against existing memories,
- * create MemoryEntry objects, write them (unless dry-run), and return a result.
- */
+/** Given an array of raw text chunks, deduplicate against existing memories,
+ *  create MemoryEntry objects, write them (unless dry-run), and return a result. */
 export declare function importEntries(chunks: string[], source: string, tags: string[], options: ImportOptions): ImportResult;
-export declare function isJsonPlainObject(x: JsonValue): x is {
-    [key: string]: JsonValue;
-};
 //# sourceMappingURL=core.d.ts.map

package/dist/importers/core.js

@@ -1,32 +1,21 @@
-/**
- * Memory importers for Hippo.
- * Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown.
- */
-import { createMemory, Layer } from '../memory.js';
-import { writeEntryOn } from '../store/entry-writes.js';
-import { openStore } from '../store/open.js';
+/** Memory importers for Hippo.
+ *  Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown. */
+import { DEFAULT_TENANT_ID } from '../util/env.js';
+import { createMemory, Layer } from '../core/memory.js';
+import { writeEntry } from '../store/entry-writes.js';
 import { loadAllEntries } from '../store/entry-reads.js';
-import { duplicateKey, storedTextKeys } from '../same-text.js';
-import { getGlobalRoot, initGlobal } from '../shared.js';
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { RejectedValueError, checkRejectionGuard } from '../rejection.js';
-import { loadConfig } from '../config.js';
-import { vetSecrets } from '../secret-detect.js';
-import { log } from '../log.js';
-// ---------------------------------------------------------------------------
-// Shared core: dedup + write
-// ---------------------------------------------------------------------------
-/**
- * Given an array of raw text chunks, deduplicate against existing memories,
- * create MemoryEntry objects, write them (unless dry-run), and return a result.
- */
+import { duplicateKey, storedTextKeys } from '../util/same-text.js';
+import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
+import { withRequestStoresSync } from '../db/request-stores.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { rejectionGuardRefuses } from '../store/rejected-values.js';
+import { loadConfig } from '../core/config.js';
+import { vetSecrets } from '../util/secret-detect.js';
+import { log } from '../util/log.js';
+/** Given an array of raw text chunks, deduplicate against existing memories,
+ *  create MemoryEntry objects, write them (unless dry-run), and return a result. */
 export function importEntries(chunks, source, tags, options) {
-    const targetRoot = options.global ? getGlobalRoot() : options.hippoRoot;
-    // Ensure store is ready
-    if (options.global) {
-        initGlobal();
-    }
-    const keys = storedTextKeys(loadAllEntries(targetRoot, options.global ? undefined : options.tenantId));
+    const { targetRoot, keys } = openImportTarget(options);
     const allTags = [...new Set([...tags, ...(options.extraTags ?? [])])];
     const baseHalfLifeDays = loadConfig(targetRoot).defaultHalfLifeDays;
     let total = 0;
@@ -35,24 +24,19 @@ export function importEntries(chunks, source, tags, options) {
     let rejected = 0;
     let redacted = 0;
     const entries = [];
-    // A dry run probes the rejection guard read-only; a real run writes every chunk on this one handle.
-    const db = options.dryRun ? openHippoDb(targetRoot) : openStore(targetRoot);
-    try {
+    // 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);
-            // Skip empty or too-short chunks
-            if (!chunk || chunk.length < 10) {
-                skipped++;
-                continue;
-            }
-            total++;
-            // Dedup check: skip only when the same text is already stored
-            if (keys.has(duplicateKey(chunk))) {
+            const skip = skipReason(chunk, keys);
+            if (skip !== 'too-short')
+                total++;
+            if (skip !== null) {
                 skipped++;
                 continue;
             }
             const entry = createImportEntry(chunk, source, allTags, options, baseHalfLifeDays);
-            if (!writeOrProbeImport(db, targetRoot, entry, options)) {
+            if (!writeOrProbeImport(targetRoot, entry, options)) {
                 rejected++;
                 continue;
             }
@@ -65,10 +49,26 @@ export function importEntries(chunks, source, tags, options) {
                 redacted++;
         }
         return { total, imported, skipped, rejected, redacted, entries };
+    });
+}
+/** 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();
     }
-    finally {
-        closeHippoDb(db);
-    }
+    const keys = storedTextKeys(loadAllEntries(targetRoot, options.global ? undefined : options.tenantId));
+    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;
 }
 /** The secret-vetted chunk capped at 1000 chars, and whether vetting changed it. */
 function prepareImportChunk(raw, allTags) {
@@ -81,17 +81,8 @@ function prepareImportChunk(raw, allTags) {
     return { chunk: trimmed.slice(0, 1000), wasRedacted };
 }
 function createImportEntry(chunk, source, allTags, options, baseHalfLifeDays) {
-    // A3: kind defaults to 'distilled'. ChatGPT/Claude/Cursor exports are curated
-    // user pastes, not raw transcripts from a system of record, so distilled is
-    // correct here. E1.3 (Slack ingestion) shipped 2026-04-29 in src/connectors/slack/
-    // and sets kind: 'raw' + routes deletions through archiveRawMemory() — these
-    // importers stay 'distilled' per the original reasoning. See MEMORY_ENVELOPE.md.
-    // L9: the dedup read above is scoped by options.tenantId — the WRITE
-    // must match, or scoped-dedup-passes-then-default-tenant-write breaks
-    // the per-tenant contract. Mirror the dedup-read guard: global=true
-    // → host-wide write to global store (tenantId irrelevant, createMemory
-    // defaults to 'default'). global=false → write to the same tenant as
-    // the dedup read.
+    // 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,
@@ -102,13 +93,12 @@ 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(db, targetRoot, entry, options) {
+function writeOrProbeImport(targetRoot, entry, options) {
+    if (options.dryRun)
+        return !rejectionGuardRefuses(targetRoot, entry.tenantId ?? DEFAULT_TENANT_ID, entry.id, entry.content);
     // A rejection refuses one chunk, not the whole import, so siblings still land.
     try {
-        if (options.dryRun)
-            checkRejectionGuard(db, entry.tenantId ?? 'default', entry.id, entry.content);
-        else
-            writeEntryOn(db, targetRoot, entry);
+        writeEntry(targetRoot, entry);
     }
     catch (err) {
         if (err instanceof RejectedValueError)
@@ -117,10 +107,4 @@ function writeOrProbeImport(db, targetRoot, entry, options) {
     }
     return true;
 }
-// ---------------------------------------------------------------------------
-// ChatGPT importer
-// ---------------------------------------------------------------------------
-export function isJsonPlainObject(x) {
-    return x !== null && !Array.isArray(x) && typeof x === 'object';
-}
 //# sourceMappingURL=core.js.map