hippo-memory 1.72.0 → 2.1.0

package/dist/importers/markdown-parse.js

@@ -2,7 +2,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 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)
         return { fm: {}, body: raw };
@@ -16,7 +15,8 @@ export function splitMarkdownFrontmatter(raw) {
             continue;
         let val = kv[2].trim();
         if (val === '') {
-            // YAML block-style list (`key:` then indented `- item` lines, common in Obsidian/Dendron): collect into a comma-joined value for frontmatterList.
+            // YAML block-style list (`key:` then indented `- item` lines, common in Obsidian/Dendron): collect into a
+            // comma-joined value for frontmatterList.
             const items = [];
             let j = i + 1;
             let item;
@@ -33,7 +33,9 @@ export function splitMarkdownFrontmatter(raw) {
     }
     return { fm, body };
 }
-/** 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 function frontmatterList(value) {
     if (!value)
@@ -46,7 +48,9 @@ export function frontmatterList(value) {
         .map((s) => s.trim().replace(/^['"]|['"]$/g, '').trim())
         .filter(Boolean);
 }
-/** 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 function parseWikilinks(body) {
     const out = [];
@@ -65,11 +69,16 @@ export function parseWikilinks(body) {
     }
     return out;
 }
-/** 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 function collectMarkdownFiles(root, hippoRoot, match = /\.md$/i) {
     const out = [];
-    // Canonicalize (realpath) so a non-dot HIPPO_HOME store nested in the vault is skipped even via a junction or Windows case alias.
+    // Canonicalize (realpath) so a non-dot HIPPO_HOME store nested in the vault is skipped even via a junction or Windows
+    // case alias.
     const resolvedHippoRoot = realpathOrResolve(hippoRoot);
     const walk = (dir) => {
         const entries = fs.readdirSync(dir, { withFileTypes: true });

package/dist/importers/markdown.js

@@ -12,7 +12,10 @@ function slugify(heading) {
         .replace(/-+/g, '-')
         .slice(0, SLUG_MAX_CHARS);
 }
-/** Parse structured markdown into {content, sectionSlug} pairs: each heading starts a section whose bullets or numbered items become memories. */
+/**
+ * Parse structured markdown into {content, sectionSlug} pairs: each heading starts a section whose bullets or numbered
+ * items become memories.
+ */
 function parseStructuredMarkdown(raw) {
     const results = [];
     const lines = raw.split('\n');
@@ -27,7 +30,6 @@ function parseStructuredMarkdown(raw) {
     }
     for (const line of lines) {
         const trimmed = line.trim();
-        // Heading
         const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)/);
         if (headingMatch) {
             flush();
@@ -35,19 +37,16 @@ function parseStructuredMarkdown(raw) {
             currentSlug = slugify(currentSection);
             continue;
         }
-        // Bullet or numbered item: flush previous, start new
         if (/^[-*+]\s+/.test(trimmed) || /^\d+\.\s+/.test(trimmed)) {
             flush();
             const itemText = trimmed.replace(/^[-*+]\s+/, '').replace(/^\d+\.\s+/, '').trim();
             pendingText = itemText;
             continue;
         }
-        // Empty line: flush current pending
         if (!trimmed) {
             flush();
             continue;
         }
-        // Continuation of current item
         pendingText = pendingText ? pendingText + ' ' + trimmed : trimmed;
     }
     flush();
@@ -56,8 +55,7 @@ function parseStructuredMarkdown(raw) {
 export function importMarkdown(filePath, options) {
     const raw = fs.readFileSync(filePath, 'utf8');
     const parsed = parseStructuredMarkdown(raw);
-    // Group by section slug so we can pass per-chunk tags
-    // We call importEntries per unique slug to get the right tags per section
+    // importEntries takes one tag set per call, so each section's chunks go in as one call.
     const bySlug = new Map();
     for (const { content, sectionSlug } of parsed) {
         const list = bySlug.get(sectionSlug) ?? [];
@@ -72,8 +70,7 @@ export function importMarkdown(filePath, options) {
             total: totalResult.total + result.total,
             imported: totalResult.imported + result.imported,
             skipped: totalResult.skipped + result.skipped,
-            // AT1 P2 fix: `rejected` is now optional on ImportResult (compat) — tolerate
-            // undefined on either side of the accumulation.
+            // rejected and redacted are optional on ImportResult, so either side may be undefined.
             rejected: (totalResult.rejected ?? 0) + (result.rejected ?? 0),
             redacted: (totalResult.redacted ?? 0) + (result.redacted ?? 0),
             entries: [...totalResult.entries, ...result.entries],

package/dist/importers/sources.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { importEntries } from './core.js';
 import { splitMarkdownFrontmatter, collectMarkdownFiles } from './markdown-parse.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { isJsonString, isJsonObject } from '../util/json.js';
 /** Coerce one imported record (string, `{content|text: ...}` object, or
  *  anything else) into the plain-text memory chunk it represents. */
@@ -14,27 +14,24 @@ function extractMemoryText(candidate) {
     }
     return '';
 }
-/** Parse a ChatGPT memory export: a JSON array of strings or `{content, created}` objects, `{"memories": [...]}`, or plain text with one memory per line. */
+/** Parse a ChatGPT memory export: a JSON array of strings or `{content, created}` objects, `{"memories": [...]}`, or
+ * plain text with one memory per line. */
 function parseChatGPTFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8').trim();
-    // Try JSON first
     if (raw.startsWith('[') || raw.startsWith('{')) {
         try {
             const parsed = JSON.parse(raw);
-            // {"memories": [...]} - ChatGPT export format
             if (isJsonObject(parsed) && Array.isArray(parsed.memories)) {
                 return parsed.memories.map(extractMemoryText).filter(Boolean);
             }
-            // Array format
             if (Array.isArray(parsed)) {
                 return parsed.map(extractMemoryText).filter(Boolean);
             }
         }
         catch (err) {
-            log.warn(`import: ${filePath} is not valid JSON (${errorMessage(err)}); reading it as plain text`);
+            log.warn(`import: ${filePath} is not valid JSON (${errorMessage(err)}); reading it as plain text`, errorFields(err));
         }
     }
-    // Plain text: one memory per line
     return raw.split('\n').map((l) => l.trim()).filter(Boolean);
 }
 export function importChatGPT(filePath, options) {
@@ -62,18 +59,17 @@ function splitMarkdown(content) {
         chunks.push(current.trim());
     return chunks.filter(Boolean);
 }
-/** Takes one line into the chunk being built, pushing that chunk when the line ends it; returns the chunk still open. */
+/** Takes one line into the chunk being built, pushing that chunk when the line ends it; returns the chunk still
+ * open. */
 function appendLine(chunks, open, line) {
     let current = open;
     const trimmed = line.trim();
-    // Heading: start a new chunk
     if (/^#{1,6}\s+/.test(trimmed)) {
         if (current.trim())
             chunks.push(current.trim());
         current = trimmed;
         return current;
     }
-    // Bullet point: each bullet is its own chunk (flush previous if not a bullet context)
     if (/^[-*+]\s+/.test(trimmed)) {
         if (current.trim() && !/^[-*+]\s+/.test(current.split('\n')[0])) {
             chunks.push(current.trim());
@@ -86,7 +82,6 @@ function appendLine(chunks, open, line) {
         current = trimmed.replace(/^[-*+]\s+/, '').trim();
         return current;
     }
-    // Numbered list item
     if (/^\d+\.\s+/.test(trimmed)) {
         if (current.trim()) {
             chunks.push(current.trim());
@@ -95,7 +90,6 @@ function appendLine(chunks, open, line) {
         current = trimmed.replace(/^\d+\.\s+/, '').trim();
         return current;
     }
-    // Empty line
     if (!trimmed) {
         if (current.trim()) {
             chunks.push(current.trim());
@@ -103,13 +97,11 @@ function appendLine(chunks, open, line) {
         }
         return current;
     }
-    // Regular line: append to current
     return current ? current + ' ' + trimmed : trimmed;
 }
 /** Parse CLAUDE.md or Claude memory.json. */
 function parseClaudeFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8');
-    // JSON memory file
     if (filePath.endsWith('.json')) {
         try {
             const parsed = JSON.parse(raw.trim());
@@ -118,10 +110,9 @@ function parseClaudeFile(filePath) {
             }
         }
         catch (err) {
-            log.warn(`import: ${filePath} is not valid JSON (${errorMessage(err)}); reading it as markdown`);
+            log.warn(`import: ${filePath} is not valid JSON (${errorMessage(err)}); reading it as markdown`, errorFields(err));
         }
     }
-    // Markdown file: strip hippo block and split
     const cleaned = stripHippoBlock(raw);
     return splitMarkdown(cleaned);
 }
@@ -137,7 +128,7 @@ function parseCursorFile(content) {
     let current = '';
     for (const line of lines) {
         const trimmed = line.trim();
-        // Skip comment-only lines that are empty after stripping #
+        // A bare '#' is an empty comment line, so it ends the rule like a blank line.
         if (!trimmed || trimmed === '#') {
             if (current.trim()) {
                 chunks.push(current.trim());
@@ -145,7 +136,6 @@ function parseCursorFile(content) {
             }
             continue;
         }
-        // Numbered item: 1. 2. 3.
         if (/^\d+\.\s+/.test(trimmed)) {
             if (current.trim()) {
                 chunks.push(current.trim());
@@ -154,7 +144,6 @@ function parseCursorFile(content) {
             current = trimmed.replace(/^\d+\.\s+/, '').trim();
             continue;
         }
-        // Bullet: - or *
         if (/^[-*]\s+/.test(trimmed)) {
             if (current.trim()) {
                 chunks.push(current.trim());
@@ -163,7 +152,6 @@ function parseCursorFile(content) {
             current = trimmed.replace(/^[-*]\s+/, '').trim();
             continue;
         }
-        // Regular line
         current = current ? current + ' ' + trimmed : trimmed;
     }
     if (current.trim())
@@ -186,18 +174,17 @@ export function importCursor(sourcePath, options) {
     });
     return importEntries(chunks, 'import:cursor', ['imported', 'cursor'], options);
 }
-/** Split a generic file into chunks: markdown on headings and bullets, plain text on double newlines or one per line. */
+/** Split a generic file into chunks: markdown on headings and bullets, plain text on double newlines or one per
+ * line. */
 function parseGenericFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8');
     const isMarkdown = filePath.endsWith('.md') || filePath.endsWith('.mdx');
     if (isMarkdown) {
         return splitMarkdown(raw);
     }
-    // Plain text: try double newlines first
     const byParagraph = raw.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
     if (byParagraph.length > 1)
         return byParagraph;
-    // Fall back to one-per-line
     return raw.split('\n').map((l) => l.trim()).filter(Boolean);
 }
 export function importGenericFile(filePath, options) {

package/dist/importers/vault.d.ts

@@ -1,5 +1,5 @@
 import { type ImportResult, type ImportOptions } from './core.js';
-/** Import a markdown vault FOLDER as `kind='raw'` memories.
- *  NOT re-entrant: idempotency rests on the in-memory `existing` Map loaded once, so two concurrent runs over one vault can double-insert. */
-export declare function importVault(folderPath: string, options: ImportOptions): ImportResult;
+/** Import a markdown vault FOLDER as `kind='raw'` memories. NOT re-entrant: idempotency rests on the in-memory
+ * `existing` Map loaded once, so two concurrent runs over one vault can double-insert. */
+export declare function importVault(folderPath: string, options: ImportOptions): Promise<ImportResult>;
 //# sourceMappingURL=vault.d.ts.map

package/dist/importers/vault.js

@@ -5,28 +5,31 @@ import { createHash } from 'node:crypto';
 import { createMemory } from '../core/memory.js';
 import { loadVaultRawRows } from '../store/entry-reads.js';
 import { remember, archiveRaw, isPrivateScope } from '../api/index.js';
+import { sqliteStore } from '../store/sqlite/store.js';
 import { assertClientScope } from '../core/recall-scope.js';
 import { RejectedValueError } from '../core/api-errors.js';
 import { rejectionGuardRefuses } from '../store/rejected-values.js';
-import { withRequestStoresSync } from '../db/request-stores.js';
+import { runWithRequestStores } from '../db/request-stores.js';
 import { loadConfig } from '../core/config.js';
 import { vetSecrets } from '../util/secret-detect.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { splitMarkdownFrontmatter, frontmatterList, parseWikilinks, collectMarkdownFiles } from './markdown-parse.js';
 import { realpathOrResolve } from '../util/real-path.js';
 import { isJsonString } from '../util/json.js';
 import { escapeLike } from '../util/escape.js';
-/** Import a markdown vault FOLDER as `kind='raw'` memories.
- *  NOT re-entrant: idempotency rests on the in-memory `existing` Map loaded once, so two concurrent runs over one vault can double-insert. */
-export function importVault(folderPath, options) {
+/** Import a markdown vault FOLDER as `kind='raw'` memories. NOT re-entrant: idempotency rests on the in-memory
+ * `existing` Map loaded once, so two concurrent runs over one vault can double-insert. */
+export async function importVault(folderPath, options) {
     const hippoRoot = options.hippoRoot;
     const identity = vaultIdentityOrThrow(options);
     if (options.global) {
-        // The raw-archive path is tenant-local, so global mode would put raw vault rows in the wrong store; reject for SDK callers too, not only the CLI.
+        // The raw-archive path is tenant-local, so global mode would put raw vault rows in the wrong store; reject for SDK
+        // callers too, not only the CLI.
         throw new Error('importVault does not support global mode (raw rows are tenant-local).');
     }
-    // Self-store no-op guard: MUST run before the existing-rows load and the deletion-sync. If the vault IS (or sits inside) the store, an empty scan looks like
-    // "every note deleted" and deletion-sync would irreversibly archive every live row, so do nothing. Canonicalize both paths (realpath) to catch aliased paths.
+    // Self-store no-op guard: MUST run before the existing-rows load and the deletion-sync. If the vault IS (or sits
+    // inside) the store, an empty scan looks like "every note deleted" and deletion-sync would irreversibly archive every
+    // live row, so do nothing. Canonicalize both paths (realpath) to catch aliased paths.
     const resolvedStore = realpathOrResolve(hippoRoot);
     const resolvedFolder = realpathOrResolve(folderPath);
     if (resolvedFolder === resolvedStore || resolvedFolder.startsWith(resolvedStore + path.sep)) {
@@ -34,7 +37,7 @@ export function importVault(folderPath, options) {
     }
     return syncVaultFolder(folderPath, options, identity);
 }
-function syncVaultFolder(folderPath, options, { vaultName, scope }) {
+async function syncVaultFolder(folderPath, options, { vaultName, scope }) {
     const hippoRoot = options.hippoRoot;
     const tenantId = options.tenantId ?? DEFAULT_TENANT_ID;
     const extraTags = options.extraTags ?? [];
@@ -45,6 +48,7 @@ function syncVaultFolder(folderPath, options, { vaultName, scope }) {
         // Process-local actor; the vault importer is a CLI/SDK ingestion path, not
         // a bearer-authed request. archiveRaw / remember thread this into audit.
         actor: { subject: 'connector:vault', role: 'admin' },
+        store: sqliteStore(hippoRoot),
     };
     const existing = loadVaultRows(hippoRoot, tenantId, vaultName);
     const relpaths = collectMarkdownFiles(folderPath, hippoRoot);
@@ -54,15 +58,15 @@ function syncVaultFolder(folderPath, options, { vaultName, scope }) {
     const run = {
         ctx, folderPath, vaultName, scope, extraTags, dryRun, existing, seen, baseHalfLifeDays, tally,
     };
-    const importNotes = () => {
+    const importNotes = async () => {
         for (const relpath of relpaths)
-            importVaultNote(run, relpath);
+            await importVaultNote(run, relpath);
     };
     // A dry run probes the rejection guard once per changed note; one scope lets every probe share a handle.
     if (dryRun)
-        withRequestStoresSync(importNotes);
+        await runWithRequestStores(importNotes);
     else
-        importNotes();
+        await importNotes();
     // Deletion-sync: an artifactRef in the Map but not seen this run vanished from the source, so archive its raw row.
     // Per-file archiveRaw, no outer SAVEPOINT: there is no cross-file idempotency row to commit atomically.
     for (const [artifactRef, rows] of existing) {
@@ -71,14 +75,15 @@ function syncVaultFolder(folderPath, options, { vaultName, scope }) {
         for (const row of rows) {
             tally.archived++; // count even in dryRun so the preview reflects destructive deletes
             if (!dryRun)
-                archiveRaw(ctx, row.id, `source_deleted:${artifactRef}`);
+                await archiveRaw(ctx, row.id, `source_deleted:${artifactRef}`);
         }
     }
     const { total, imported, skipped, rejected, archived, redacted, entries } = tally;
     return { total, imported, skipped, rejected, archived, redacted, entries };
 }
 function vaultIdentityOrThrow(options) {
-    // The vault NAME keys the destructive deletion-sync, so it must be explicit: defaulting to the folder basename made two vaults
+    // The vault NAME keys the destructive deletion-sync, so it must be explicit: defaulting to the folder basename made
+    // two vaults
     // sharing a basename collide on the same `vault:<name>:*` prefix and the sync archived the first one's rows.
     const vaultName = options.name?.trim();
     if (!vaultName) {
@@ -86,12 +91,14 @@ function vaultIdentityOrThrow(options) {
             'basename.');
     }
     if (vaultName.includes(':')) {
-        // ':' delimits the artifactRef (vault:<name>:<relpath>); a name containing it lets another vault's prefix scan over-match and archive its rows.
+        // ':' delimits the artifactRef (vault:<name>:<relpath>); a name containing it lets another vault's prefix scan
+        // over-match and archive its rows.
         throw new Error(`vault name must not contain ':' (artifactRef delimiter): ${vaultName}`);
     }
     const scope = options.scope ?? null;
-    // Privacy guard: recall only default-denies scopes shaped `<source>:private:*` (isPrivateScope in src/core/recall-scope.ts), so a bare `private`
-    // alias would be returned to no-scope callers. Reject any scope naming a `private` segment that is not a valid `<source>:private:*`.
+    // Privacy guard: recall only default-denies scopes shaped `<source>:private:*` (isPrivateScope in
+    // src/core/recall-scope.ts), so a bare `private` alias would be returned to no-scope callers. Reject any scope naming
+    // a `private` segment that is not a valid `<source>:private:*`.
     assertClientScope(scope);
     if (scope !== null && scope.split(':').includes('private') && !isPrivateScope(scope)) {
         throw new Error(`vault scope '${scope}' is not recognized as private by recall (only '<source>:private:*' scopes are default-denied). ` +
@@ -120,52 +127,56 @@ function loadVaultRows(hippoRoot, tenantId, vaultName) {
     }
     return existing;
 }
-function importVaultNote(run, relpath) {
+async function importVaultNote(run, relpath) {
     const { tally } = run;
     tally.total++;
     const artifactRef = `vault:${run.vaultName}:${relpath}`;
     run.seen.add(artifactRef);
-    // The content hash covers the RAW file bytes (deterministic, no Date/random) so frontmatter edits are idempotent like body edits.
+    // The content hash covers the RAW file bytes (deterministic, no
+    // Date/random) so frontmatter edits are idempotent like body edits.
     const rawFileContent = readVaultNote(run, relpath);
     if (rawFileContent === null)
         return;
     const hash = createHash('sha256').update(rawFileContent).digest('hex');
     const hashTag = `content-hash:${hash}`;
-    // Load every live raw row for this ref (>1 only after a concurrent double-insert); decide idempotency below, once the full tag set is built.
+    // Load every live raw row for this ref (>1 only after a concurrent double-insert); decide idempotency below, once the
+    // full tag set is built.
     const priors = run.existing.get(artifactRef) ?? [];
     const { fm, body } = splitMarkdownFrontmatter(rawFileContent);
-    // Empty or frontmatter-only note: nothing storable, and the content was deleted at source, so archive prior rows (the old body must not stay searchable)
-    // and skip the write. Safe because remember() is skipped, so there is no archive-then-throw hazard; the note stays in `seen` so deletion-sync skips it.
+    // Empty or frontmatter-only note: nothing storable, and the content was deleted at source, so archive prior rows (the
+    // old body must not stay searchable) and skip the write. Safe because remember() is skipped, so there is no
+    // archive-then-throw hazard; the note stays in `seen` so deletion-sync skips it.
     if (body.trim().length < 3) {
-        archivePriors(run, priors, `emptied:${artifactRef}`);
+        await archivePriors(run, priors, `emptied:${artifactRef}`);
         tally.skipped++;
         return;
     }
     const tags = vaultNoteTags(run, hashTag, fm, body);
     if (vaultEnvelopeUnchanged(priors, tags, run.scope)) {
-        // Unchanged file + envelope → skip (idempotent re-import).
         tally.skipped++;
         return;
     }
-    writeChangedNote(run, artifactRef, priors, body, tags);
+    await writeChangedNote(run, artifactRef, priors, body, tags);
 }
-function writeChangedNote(run, artifactRef, priors, body, tags) {
+async function writeChangedNote(run, artifactRef, priors, body, tags) {
     const { ctx, tally } = run;
-    // Changed file: archive EVERY old raw row for this ref (>1 only after a concurrent double-insert), then append the new one; NEVER supersede.
-    // archiveRaw commits before remember() runs, so no double-live row; a crash between them self-heals on the next import.
-    archivePriors(run, priors, `changed:${artifactRef}`);
-    // remember() owns the write; the `echo` from createMemory only fills the ImportResult, with its id reconciled to the row that landed.
+    // Changed file: archive EVERY old raw row for this ref (>1 only after a concurrent double-insert), then append the
+    // new one; NEVER supersede. archiveRaw commits before remember() runs, so no double-live row; a crash between them
+    // self-heals on the next import.
+    await archivePriors(run, priors, `changed:${artifactRef}`);
+    // remember() owns the write; the `echo` from createMemory only fills the ImportResult, with its id reconciled to the
+    // row that landed.
     const content = vetSecrets(body, tags, true).content;
     const echo = createMemory(content, {
         kind: 'raw',
         tags,
         scope: run.scope,
         owner: 'agent:vault-import',
-        artifact_ref: artifactRef,
+        artifactRef: artifactRef,
         tenantId: ctx.tenantId,
         baseHalfLifeDays: run.baseHalfLifeDays,
     });
-    if (!storeVaultNote(run, echo, content, tags, artifactRef)) {
+    if (!(await storeVaultNote(run, echo, content, tags, artifactRef))) {
         tally.rejected++;
         return;
     }
@@ -179,21 +190,23 @@ function readVaultNote(run, relpath) {
         return fs.readFileSync(path.join(run.folderPath, relpath), 'utf8');
     }
     catch (err) {
-        // One unreadable note (gone since the listing, or a transient IO error) must not abort the import; a re-run picks it up.
-        log.debug(`vault note skipped: ${relpath}: ${errorMessage(err)}`);
+        // One unreadable note (gone since the listing, or a transient
+        // IO error) must not abort the import; a re-run picks it up.
+        log.warnThenDebug(`vault-note-skipped:${run.folderPath}`, `vault note skipped: ${relpath}: ${errorMessage(err)}`, errorFields(err));
         run.tally.skipped++;
         return null;
     }
 }
-function archivePriors(run, priors, reason) {
+async function archivePriors(run, priors, reason) {
     for (const p of priors) {
         run.tally.archived++; // count the would-be archive even in dryRun (true preview)
         if (!run.dryRun)
-            archiveRaw(run.ctx, p.id, reason);
+            await archiveRaw(run.ctx, p.id, reason);
     }
 }
 function vaultNoteTags(run, hashTag, fm, body) {
-    // Build the FULL tag envelope before the idempotency decision, de-duplicated and order-preserving (createMemory stores tags verbatim).
+    // Build the FULL tag envelope before the idempotency decision, de-duplicated and order-preserving (createMemory
+    // stores tags verbatim).
     const frontmatterTags = [
         ...frontmatterList(fm['tags']),
         ...frontmatterList(fm['aliases']).map((a) => `alias:${a}`),
@@ -209,8 +222,9 @@ function vaultNoteTags(run, hashTag, fm, body) {
     ]));
 }
 function vaultEnvelopeUnchanged(priors, tags, scope) {
-    // Unchanged iff EVERY live raw row carries the EXACT same tag set AND scope; comparing the complete envelope (not hash plus a subset) catches
-    // scope, added and removed tags. `length > 0` guards a never-seen file; archiving all priors on a mismatch also clears concurrent double-inserts.
+    // Unchanged iff EVERY live raw row carries the EXACT same tag set AND scope; comparing the complete envelope (not
+    // hash plus a subset) catches scope, added and removed tags. `length > 0` guards a never-seen file; archiving all
+    // priors on a mismatch also clears concurrent double-inserts.
     const wantTags = new Set(tags);
     return (priors.length > 0 &&
         priors.every((p) => {
@@ -221,14 +235,15 @@ function vaultEnvelopeUnchanged(priors, tags, scope) {
         }));
 }
 /** Returns false when the rejection guard refuses the note; any other error propagates. */
-function storeVaultNote(run, echo, content, tags, artifactRef) {
-    // A dry run writes nothing; it asks the guard remember() uses, so its `rejected` count matches what a real run would refuse.
+async function storeVaultNote(run, echo, content, tags, artifactRef) {
+    // A dry run writes nothing; it asks the guard remember() uses,
+    // so its `rejected` count matches what a real run would refuse.
     if (run.dryRun)
         return !rejectionGuardRefuses(run.ctx.hippoRoot, run.ctx.tenantId, echo.id, echo.content);
     try {
         // A rejected note must not stop the scan or the deletion sync. Its priors are archived by now, so a rerun meets
         // the same refusal and counts it again.
-        const result = remember(run.ctx, {
+        const result = await remember(run.ctx, {
             content,
             kind: 'raw',
             artifactRef,
@@ -245,7 +260,8 @@ function storeVaultNote(run, echo, content, tags, artifactRef) {
         throw err;
     }
 }
-/** Tolerant JSON-array parse for the loader's `tags_json` column (the store's `parseJsonArray` is not exported); returns [] on null or garbage. */
+/** Tolerant JSON-array parse for the loader's `tags_json` column (the store's `parseJsonArray` is not exported);
+ * returns [] on null or garbage. */
 function parseJsonArrayLoose(value) {
     if (!value)
         return [];
@@ -254,7 +270,7 @@ function parseJsonArrayLoose(value) {
         return Array.isArray(parsed) ? parsed.filter(isJsonString) : [];
     }
     catch (err) {
-        log.debug(`import: unreadable tags_json read as no tags: ${errorMessage(err)}`);
+        log.warnThenDebug('import-tags-json-unreadable', `import: unreadable tags_json read as no tags: ${errorMessage(err)}`, errorFields(err));
         return [];
     }
 }

package/dist/index.d.ts

@@ -2,9 +2,33 @@
  * Hippo public API  - re-exports for programmatic use.
  */
 import { type CreateMemoryOptions, type MemoryEntry } from './core/memory.js';
+import { type SleepOpts, type SleepResult } from './api/sleep/sleep.js';
+import type { Context } from './api/types.js';
 export { MemoryEntry, Layer, EmotionalValence, ConfidenceLevel, DecayOptions, calculateStrength, resolveConfidence, confidenceFacets, type ConfidenceFacets, applyOutcome, generateId, computeSchemaFit } from './core/memory.js';
-/** Published signature, so `baseHalfLifeDays` stays optional here; hippo's own writers use the strict one in memory.ts. */
-export declare function createMemory(content: string, options?: Partial<CreateMemoryOptions>): MemoryEntry;
+/** Core's camelCase options, plus the snake_case spellings 2.0 published; the camelCase key wins when both are set. */
+type PublicCreateMemoryOptions = CreateMemoryOptions & {
+    /** @deprecated Use emotionalValence; removed in 3.0. */
+    emotional_valence?: CreateMemoryOptions['emotionalValence'];
+    /** @deprecated Use schemaFit; removed in 3.0. */
+    schema_fit?: CreateMemoryOptions['schemaFit'];
+    /** @deprecated Use traceOutcome; removed in 3.0. */
+    trace_outcome?: CreateMemoryOptions['traceOutcome'];
+    /** @deprecated Use sourceSessionId; removed in 3.0. */
+    source_session_id?: CreateMemoryOptions['sourceSessionId'];
+    /** @deprecated Use validFrom; removed in 3.0. */
+    valid_from?: CreateMemoryOptions['validFrom'];
+    /** @deprecated Use extractedFrom; removed in 3.0. */
+    extracted_from?: CreateMemoryOptions['extractedFrom'];
+    /** @deprecated Use dagLevel; removed in 3.0. */
+    dag_level?: CreateMemoryOptions['dagLevel'];
+    /** @deprecated Use dagParentId; removed in 3.0. */
+    dag_parent_id?: CreateMemoryOptions['dagParentId'];
+    /** @deprecated Use artifactRef; removed in 3.0. */
+    artifact_ref?: CreateMemoryOptions['artifactRef'];
+};
+/** Published signature, so `baseHalfLifeDays` stays optional
+ * here; hippo's own writers use the strict one in memory.ts. */
+export declare function createMemory(content: string, options?: Partial<PublicCreateMemoryOptions>): MemoryEntry;
 export { search } from './search/bm25-search.js';
 export { hybridSearch } from './search/hybrid.js';
 export { physicsSearch } from './search/physics-search.js';
@@ -20,23 +44,25 @@ export { initStore } from './store/open.js';
 export { writeEntry } from './store/entry-writes.js';
 export { loadAllEntries, readEntry } from './store/entry-reads.js';
 export { deleteEntry } from './store/delete-and-batch.js';
-export { loadSearchEntries, loadRecallSearchEntries } from './store/search-rows.js';
+export { loadSearchEntries, loadRecallEntries, type RecallSearchEntriesOptions } from './store/search-rows.js';
 export { loadIndex, rebuildIndex, loadSessionDecayContext, SessionDecayContext } from './store/index-and-stats.js';
 export { saveActiveTaskSnapshot, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, SNAPSHOT_AMBIENT_MAX_AGE_MS, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, type ContinuityKey, } from './store/sessions.js';
 export { listMemoryConflicts, replaceDetectedConflicts, resolveConflict } from './store/conflicts.js';
 export { saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, } from './store/handoffs.js';
 export { createCard, loadCard, listCards, loadCardDeps, loadCardRuns, loadCardComments, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, loadLatestHandoffForCard, } from './store/cards.js';
 export { SessionHandoff, HandoffOutcome, HandoffEvidence, isHandoffOutcome } from './core/handoff.js';
-export { Card, CardStatus, CardRun, CardComment, CardTransitions, isCardStatus, CARD_TRANSITIONS, CARD_LEASE_MS } from './core/card.js';
+export { Card, CardStatus, CardRun, CardComment, CardTransitions, isCardStatus, CARD_TRANSITIONS, CARD_LEASE_MS, } from './core/card.js';
 export { consolidate } from './consolidate/sleep.js';
 export { ConsolidationResult } from './consolidate/run.js';
-export { sleep, type SleepOpts, type SleepResult } from './api/sleep.js';
+export type { SleepOpts, SleepResult } from './api/sleep/sleep.js';
+/** Published signature, so the Context may carry no store: it then runs on hippo.db under its root. */
+export declare function sleep(ctx: Context, opts?: SleepOpts): Promise<SleepResult>;
 export { strengthBucket } from './consolidate/dedupe.js';
 export { isEmbeddingAvailable, getEmbedding } from './embeddings/local.js';
 export { cosineSimilarity } from './store/embeddings/index.js';
 export { embedMemory, embedAll } from './search/embed-memories.js';
 export { loadEmbeddingIndex, saveEmbeddingIndex } from './store/vector-index.js';
-export { captureError, extractLessons, partitionLessons, deduplicateLesson, runWatched, fetchGitLog, } from './learn/autolearn.js';
+export { captureError, extractLessons, partitionLessons, deduplicateLesson, runWatched, runWatchedLine, type RunWatchedOptions, fetchGitLog, } from './learn/autolearn.js';
 export { getGlobalRoot, initGlobal, promoteToGlobal } from './sharing/global-store.js';
 export { searchBoth, searchBothHybrid, HybridSearchOptions } from './sharing/search-both.js';
 export { syncGlobalToLocal } from './sharing/global-sync.js';
@@ -50,5 +76,5 @@ export { runFeatureEval, formatResult, resultToBaseline, detectRegressions, buil
 export { computeSalience, SalienceDecision, SalienceResult, SalienceOptions, } from './core/salience.js';
 export { computeAmbientState, renderAmbientSummary, formatAmbientVector, AmbientState, } from './core/ambient.js';
 export { appendAuditEvent, queryAuditEvents, listAuditEventsAfter, AUDIT_OPS, type AuditEvent, type AuditOp, type QueryAuditOpts, type ListAuditAfterOpts, } from './store/audit.js';
-export { openHippoDb, openHippoDbReadOnly, closeHippoDb, type DatabaseSyncLike } from './db/index.js';
+export * from './entry/sqlite-handles.js';
 //# sourceMappingURL=index.d.ts.map