hippo-memory 1.69.0 → 1.70.0

package/dist/hooks/json-hooks.js

@@ -35,10 +35,10 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { isJsonObject, 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, homeDir, claudeConfigDir, codexHomeDir, copilotHooksFile, defaultPreCompactLogPath } from './shared.js';
-import { isJsonString, readJsonFile } from '../json.js';
-import { escapeRegex } from '../escape.js';
-import { errorMessage, log } from '../log.js';
+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, homeDir, claudeConfigDir, codexHomeDir, copilotHooksFile, defaultPreCompactLogPath } from './shared.js';
+import { isJsonString, readJsonFile, isJsonObjectLiteral } from '../util/json.js';
+import { escapeRegex } from '../util/escape.js';
+import { writeFileAtomic } from '../util/atomic-write.js';
 /** The paths for `target` under the current home directory; reads and writes nothing. */
 export function resolveJsonHookPaths(target) {
     const home = homeDir();
@@ -73,13 +73,13 @@ function isHippoCommand(command, marker) {
 }
 const runsHippo = (...markers) => (command) => markers.some((m) => isHippoCommand(command, m));
 function handlerCommand(handler) {
-    return isJsonObject(handler) && isJsonString(handler.command) ? handler.command : null;
+    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. */
 function withoutHandlers(groups, isOurs) {
     let removed = false;
     const kept = groups.flatMap((group) => {
-        if (!isJsonObject(group) || !Array.isArray(group.hooks))
+        if (!isJsonObjectLiteral(group) || !Array.isArray(group.hooks))
             return [group];
         const handlers = group.hooks.filter((h) => {
             const command = handlerCommand(h);
@@ -108,7 +108,7 @@ function stripHandlers(hooks, event, isOurs) {
 }
 /** Every command string in `groups`; a group or handler of an unexpected shape adds none. */
 function handlerCommands(groups) {
-    return groups.flatMap((group) => (isJsonObject(group) && Array.isArray(group.hooks) ? group.hooks.flatMap((h) => handlerCommand(h) ?? []) : []));
+    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. */
 function hookArrayContains(hookArray, marker) {
@@ -126,13 +126,13 @@ function migratePinnedInjectRecentCommands(hookArray) {
         return false;
     let changed = false;
     for (const entry of hookArray) {
-        if (!isJsonObject(entry))
+        if (!isJsonObjectLiteral(entry))
             continue;
         const innerHooks = entry.hooks;
         if (!Array.isArray(innerHooks))
             continue;
         for (const hook of innerHooks) {
-            if (!isJsonObject(hook))
+            if (!isJsonObjectLiteral(hook))
                 continue;
             if (!isJsonString(hook.command))
                 continue;
@@ -172,14 +172,14 @@ function ensureHooksObject(settings, events) {
     if (settings.hooks === undefined)
         settings.hooks = {};
     const hooks = settings.hooks;
-    if (!isJsonObject(hooks) || events.some((e) => hooks[e] !== undefined && !Array.isArray(hooks[e])))
+    if (!isJsonObjectLiteral(hooks) || 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. */
 function installCodexHooks(settingsPath, settings) {
     const result = nothingInstalled('codex', settingsPath);
-    if (!isJsonObject(settings))
+    if (!isJsonObjectLiteral(settings))
         return { ...result, invalidJson: true };
     const hooks = ensureHooksObject(settings, ['UserPromptSubmit', 'SessionStart']);
     if (hooks === null)
@@ -225,7 +225,7 @@ function copilotHooksTable() {
 /** The events in hippo's Copilot hooks file, in file order, for setup to name. */
 export function copilotHookEvents() {
     const hooks = copilotHooksTable().hooks;
-    return isJsonObject(hooks) ? Object.keys(hooks) : [];
+    return isJsonObjectLiteral(hooks) ? Object.keys(hooks) : [];
 }
 /** Hippo owns this whole file, so install writes the full table and a second install changes no byte. */
 function installCopilotHooks(settingsPath) {
@@ -256,112 +256,13 @@ export function installJsonHooks(target) {
     }
     if (target === 'codex')
         return installCodexHooks(settingsPath, settings);
-    if (!isJsonObject(settings))
+    if (!isJsonObjectLiteral(settings))
         return { ...nothingInstalled(target, settingsPath), invalidJson: true };
     return installClaudeCodeHooks(settingsPath, settings, logFile);
 }
-const RENAME_RETRY_MS = 1000;
-const WINDOWS_RENAME_REFUSALS = ['EPERM', 'EACCES', 'EBUSY'];
-// A rename can be refused where an in-place write still works (a bind-mounted file, a read-only folder), so these fall back to one.
-const REPLACE_REFUSALS = ['EBUSY', 'EXDEV', 'EACCES', 'EPERM'];
-// Matches the usual SYMLOOP_MAX, so a link cycle ends in an error instead of a hang.
-const MAX_LINK_HOPS = 40;
-function errnoCode(err) {
-    return 'code' in err ? String(err.code) : '';
-}
-/** Windows refuses a rename onto a file another program has open, usually for a moment, so a refusal is retried before it is reported. */
-function renameOnto(tmp, target) {
-    const deadline = Date.now() + RENAME_RETRY_MS;
-    const idle = new Int32Array(new SharedArrayBuffer(4));
-    for (let pause = 10;; pause = Math.min(pause * 2, 200)) {
-        try {
-            fs.renameSync(tmp, target);
-            return;
-        }
-        catch (err) {
-            const transient = process.platform === 'win32' && err instanceof Error && WINDOWS_RENAME_REFUSALS.includes(errnoCode(err));
-            const left = deadline - Date.now();
-            if (!transient || left <= 0)
-                throw err;
-            Atomics.wait(idle, 0, 0, Math.min(pause, left));
-        }
-    }
-}
-/** Where a write to `file` lands: through any symlink, a dangling one included, so a dotfile manager's link survives. */
-function writeTarget(file) {
-    let target = file;
-    for (let hop = 0; hop < MAX_LINK_HOPS && fs.lstatSync(target, { throwIfNoEntry: false })?.isSymbolicLink(); hop++) {
-        target = path.resolve(path.dirname(target), fs.readlinkSync(target));
-    }
-    return fs.existsSync(target) ? fs.realpathSync(target) : target;
-}
-/** Gives the replacement the old file's exact mode (umask trims the create mode) and, for root, its owner. */
-function keepAccess(tmp, old) {
-    fs.chmodSync(tmp, old.mode & 0o777);
-    if (process.getuid?.() === 0)
-        fs.chownSync(tmp, old.uid, old.gid);
-}
-/** Cleanup must not hide the failure that made it necessary, so a cleanup error is logged and the first error stays the one thrown. */
-function removeTemp(tmp) {
-    try {
-        fs.rmSync(tmp, { force: true });
-    }
-    catch (err) {
-        log.warn(`could not remove the temporary file ${tmp}: ${errorMessage(err)}`);
-    }
-}
-function replaceViaTemp(target, text, old) {
-    const tmp = `${target}.${process.pid}.tmp`;
-    try {
-        fs.writeFileSync(tmp, text, { encoding: 'utf8', mode: (old?.mode ?? 0o666) & 0o777 });
-        if (old)
-            keepAccess(tmp, old);
-        renameOnto(tmp, target);
-    }
-    catch (err) {
-        removeTemp(tmp);
-        throw err;
-    }
-}
-/** The pre-rename write: it truncates first, so it is only the fallback, but it needs just a writable file and keeps hard links together. */
-function writeInPlace(target, text) {
-    try {
-        fs.writeFileSync(target, text, 'utf8');
-    }
-    catch (err) {
-        if (!(err instanceof Error))
-            throw err;
-        const reason = errnoCode(err) === 'EBUSY'
-            ? 'is in use by another program, so hippo could not replace it; close that program and run the command again'
-            : `could not be replaced (${errnoCode(err) || err.message})`;
-        throw new Error(`${target} ${reason}`, { cause: err });
-    }
-}
 /** 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) {
-    const target = writeTarget(file);
-    const text = JSON.stringify(settings, null, 2) + '\n';
-    const old = fs.statSync(target, { throwIfNoEntry: false });
-    if (old === undefined) {
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-    }
-    else {
-        // A rename replaces a read-only file that the in-place write refused, and Windows would retry that refusal for a second.
-        fs.accessSync(target, fs.constants.W_OK);
-    }
-    if (old !== undefined && old.nlink > 1) {
-        // A rename gives the file a new inode, which would leave the other hard links on the old content.
-        writeInPlace(target, text);
-        return;
-    }
-    try {
-        replaceViaTemp(target, text, old);
-    }
-    catch (err) {
-        if (!(err instanceof Error) || !REPLACE_REFUSALS.includes(errnoCode(err)))
-            throw err;
-        writeInPlace(target, text);
-    }
+    writeFileAtomic(file, JSON.stringify(settings, null, 2) + '\n');
 }
 function migrateLegacyClaudeHooks(hooks) {
     const migratedFromStop = stripHandlers(hooks, 'Stop', runsHippo(HIPPO_SLEEP_MARKER));
@@ -406,13 +307,7 @@ const CLAUDE_HOOK_MARKERS = [
 ];
 // 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 installClaudeCodeHooks(settingsPath, settings, logFile) {
-    const merge = ensureHooksObject(settings, CLAUDE_APPENDED_EVENTS);
-    if (merge === null)
-        return { ...nothingInstalled('claude-code', settingsPath), invalidJson: true };
-    // SAFETY: ensureHooksObject left every event hippo appends to absent or an array.
-    const hooks = merge;
-    const migration = migrateLegacyClaudeHooks(hooks);
+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,
@@ -422,6 +317,9 @@ function installClaudeCodeHooks(settingsPath, settings, logFile) {
     // before the user pins them explicitly.
     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 the compaction, asks the
     // summariser for a "Memories for hippo" list and saves a working-state snapshot before the summary drops detail.
     // Exit-0 contract lives in the verb itself (src/capture.ts cmdPreCompact),
@@ -437,6 +335,17 @@ function installClaudeCodeHooks(settingsPath, settings, logFile) {
     // 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 };
+}
+function installClaudeCodeHooks(settingsPath, settings, logFile) {
+    const merge = ensureHooksObject(settings, CLAUDE_APPENDED_EVENTS);
+    if (merge === null)
+        return { ...nothingInstalled('claude-code', settingsPath), invalidJson: true };
+    // SAFETY: ensureHooksObject left every event hippo appends to absent or an array.
+    const hooks = merge;
+    const migration = migrateLegacyClaudeHooks(hooks);
+    const { installedSessionEnd, installedSessionStart, migratedPinnedInjectRecent, installedUserPromptSubmit } = appendSessionHooks(hooks, logFile);
+    const { installedPreCompact, installedCompactResume, installedPostCompact } = appendCompactionHooks(hooks);
     // PostToolUseFailure: a failed tool call becomes an error memory, after
     // `hippo capture-error` drops routine failures (interrupts, declined
     // permissions, empty searches) and repeats. Same hook the plugin ships.
@@ -499,7 +408,7 @@ export function uninstallJsonHooks(target) {
         // Never rewrite a settings file we cannot parse; report nothing uninstalled.
         return false;
     }
-    if (!isJsonObject(settings) || !isJsonObject(settings.hooks))
+    if (!isJsonObjectLiteral(settings) || !isJsonObjectLiteral(settings.hooks))
         return false;
     const hooks = settings.hooks;
     const changed = target === 'codex' ? uninstallCodexHooks(hooks) : uninstallClaudeCodeHooks(hooks);
@@ -519,7 +428,7 @@ export function checkUninstallable(target) {
         return { settingsPath, invalidJson: false };
     try {
         const settings = readJsonFile(settingsPath);
-        return { settingsPath, invalidJson: !isJsonObject(settings) || (settings.hooks !== undefined && !isJsonObject(settings.hooks)) };
+        return { settingsPath, invalidJson: !isJsonObjectLiteral(settings) || (settings.hooks !== undefined && !isJsonObjectLiteral(settings.hooks)) };
     }
     catch {
         return { settingsPath, invalidJson: true };

package/dist/hooks/opencode.js

@@ -1,7 +1,8 @@
 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.
@@ -91,7 +92,7 @@ function resolveOpencodeConfigPath() {
  */
 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);
@@ -127,7 +128,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 +136,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,9 +149,34 @@ 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();
@@ -181,8 +190,7 @@ export function installOpencodePlugin() {
             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;

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';

package/dist/importers/core.d.ts

@@ -2,8 +2,7 @@
  * 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';
+import { MemoryEntry } from '../core/memory.js';
 export interface ImportResult {
     total: number;
     imported: number;
@@ -45,7 +44,7 @@ export interface ImportOptions {
      * 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).
+     * it (`escapeLike` in src/util/escape.ts).
      */
     name?: string;
     /**
@@ -59,7 +58,4 @@ export interface ImportOptions {
  * 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

@@ -2,17 +2,17 @@
  * 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';
+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';
+import { duplicateKey, storedTextKeys } from '../util/same-text.js';
+import { getGlobalRoot, initGlobal } from '../sharing/shared.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';
 // ---------------------------------------------------------------------------
 // Shared core: dedup + write
 // ---------------------------------------------------------------------------
@@ -21,12 +21,7 @@ import { log } from '../log.js';
  * 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 +30,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 +55,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) {
@@ -102,13 +108,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', 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)
@@ -120,7 +125,4 @@ function writeOrProbeImport(db, targetRoot, entry, options) {
 // ---------------------------------------------------------------------------
 // ChatGPT importer
 // ---------------------------------------------------------------------------
-export function isJsonPlainObject(x) {
-    return x !== null && !Array.isArray(x) && typeof x === 'object';
-}
 //# sourceMappingURL=core.js.map

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

@@ -6,7 +6,7 @@ interface FrontmatterParseResult {
     fm: Record<string, string>;
     body: string;
 }
-export declare function parseFrontmatter(raw: string): FrontmatterParseResult;
+export declare function splitMarkdownFrontmatter(raw: string): FrontmatterParseResult;
 /** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a
  *  comma-separated scalar (`a, b`), or a single token, into a string[]. Quotes
  *  and surrounding brackets are stripped; empty entries dropped. */
@@ -28,14 +28,5 @@ export declare function parseWikilinks(body: string): string[];
  *  importVault (a no-op early return), NOT here: returning [] for it would feed
  *  the deletion-sync an empty scan that mass-archives every live row (codex R8). */
 export declare function collectMarkdownFiles(root: string, hippoRoot: string, match?: RegExp): string[];
-/** Canonicalize a path for the self-store comparison: dereference symlinks /
- *  junctions and normalize case (Windows) via the OS realpath, so a junction or
- *  a case-variant path to the store is still recognized as self-store (codex R9
- *  P2: path.resolve does neither, so an aliased store path slipped past the
- *  guard and triggered the mass-archive). Falls back to path.resolve when the
- *  path does not exist yet - an uninitialized store or a typo'd vault path
- *  cannot be a live self-store, and a non-existent vault folder fails later in
- *  the walk (readdirSync) before deletion-sync can archive anything. */
-export declare function realpathOrResolve(p: string): string;
 export {};
 //# sourceMappingURL=markdown-parse.d.ts.map

package/dist/importers/markdown-parse.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { log } from '../log.js';
-export function parseFrontmatter(raw) {
+import { realpathOrResolve } from '../util/real-path.js';
+export function splitMarkdownFrontmatter(raw) {
     // Must start with `---` on its own line. Accept CRLF or LF.
     const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
     if (!m)
@@ -112,21 +112,4 @@ export function collectMarkdownFiles(root, hippoRoot, match = /\.md$/i) {
     out.sort();
     return out;
 }
-/** Canonicalize a path for the self-store comparison: dereference symlinks /
- *  junctions and normalize case (Windows) via the OS realpath, so a junction or
- *  a case-variant path to the store is still recognized as self-store (codex R9
- *  P2: path.resolve does neither, so an aliased store path slipped past the
- *  guard and triggered the mass-archive). Falls back to path.resolve when the
- *  path does not exist yet - an uninitialized store or a typo'd vault path
- *  cannot be a live self-store, and a non-existent vault folder fails later in
- *  the walk (readdirSync) before deletion-sync can archive anything. */
-export function realpathOrResolve(p) {
-    try {
-        return fs.realpathSync.native(p);
-    }
-    catch (err) {
-        log.debug(`import: realpath fell back to resolve for ${p}: ${err instanceof Error ? err.message : String(err)}`);
-        return path.resolve(p);
-    }
-}
 //# sourceMappingURL=markdown-parse.js.map

package/dist/importers/markdown.js

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import { importEntries } from './core.js';
+const SLUG_MAX_CHARS = 50;
 // ---------------------------------------------------------------------------
 // Structured markdown importer (MEMORY.md / AGENTS.md format)
 // ---------------------------------------------------------------------------
@@ -14,7 +15,7 @@ function slugify(heading) {
         .trim()
         .replace(/\s+/g, '-')
         .replace(/-+/g, '-')
-        .slice(0, 50);
+        .slice(0, SLUG_MAX_CHARS);
 }
 /**
  * Parse structured markdown into {content, sectionSlug} pairs.