hippo-memory 1.62.0 → 1.63.0

package/dist/doctor.js

@@ -139,7 +139,8 @@ function projectsCheck(globalRoot) {
         const r = planProjectRepair(db, globalRoot, resolveTenantId({}));
         const found = [
             r.copies.length > 0 ? `${r.copies.length} imported notes copied under the wrong project` : '',
-            r.folds.length > 0 ? `${r.folds.length} old project names that now resolve to another project` : '',
+            r.folds.length > 0 ? `old project names that now resolve to another project: ${r.folds.map((f) => `${f.from} -> ${f.into}`).join(', ')}` : '',
+            r.collisions.length > 0 ? `old project names shared by several projects, folded by hand only: ${r.collisions.map((c) => `${c.name} (${c.ids.join(', ')})`).join('; ')}` : '',
             r.toProject.length + r.setAside.length > 0 ? `${r.toProject.length + r.setAside.length} merged memories tagged user-global` : '',
         ].filter((s) => s !== '');
         return found.length === 0
@@ -154,124 +155,138 @@ function projectsCheck(globalRoot) {
             closeHippoDb(db);
     }
 }
+function nodeCheck(node) {
+    return versionAtLeast(node, MIN_NODE)
+        ? { id: 'node', status: 'pass', detail: `Node.js ${node}` }
+        : { id: 'node', status: 'fail', detail: `Node.js ${node} is older than ${MIN_NODE}`, fix: `Install Node.js ${MIN_NODE} or newer` };
+}
+/** The store the checks run against (project first, then global), and the check that says which. */
+function storeCheck(local, globalRoot, hasGlobal) {
+    if (local !== null && isInitialized(local)) {
+        return { store: local, check: { id: 'store', status: 'pass', detail: `project store at ${local}${hasGlobal ? ` (global store at ${globalRoot} too)` : ''}` } };
+    }
+    if (local !== null) {
+        // The walk stops at the first .hippo it finds, so a bare one (no hippo.db) blocks a parent or global store too.
+        return { store: null, check: { id: 'store', status: 'fail', detail: `${local} has no hippo.db, so hippo commands run here stop at it`, fix: `run hippo init in ${path.dirname(local)}, or remove that .hippo folder` } };
+    }
+    if (hasGlobal) {
+        return { store: globalRoot, check: { id: 'store', status: 'warn', detail: `no project store here; using the global store at ${globalRoot}`, fix: 'hippo init   (in the project root)' } };
+    }
+    return { store: null, check: { id: 'store', status: 'fail', detail: 'no hippo store found (project or global)', fix: 'hippo init   (in the project root), or hippo init --global' } };
+}
+function schemaCheck(have, want) {
+    return have === want
+        ? { id: 'schema', status: 'pass', detail: `database schema v${have}` }
+        : have > want
+            ? { id: 'schema', status: 'fail', detail: `database schema v${have} is newer than this hippo (v${want})`, fix: 'npm install -g hippo-memory@latest' }
+            : { id: 'schema', status: 'info', detail: `database schema v${have}; hippo migrates it to v${want} on the next write` };
+}
+function memoriesCheck(db) {
+    const memories = countTableRows(db, 'memories');
+    const dormant = countTableRows(db, 'dormant_memories');
+    const memoryCheck = { id: 'memories', status: 'info', detail: `${memories ?? '?'} memories${dormant !== null ? `, ${dormant} dormant` : ''}` };
+    if (memories === 0) {
+        memoryCheck.status = 'warn';
+        memoryCheck.fix = 'hippo learn --git   (seed lessons from git history)';
+    }
+    return memoryCheck;
+}
+function tokensCheck(db, since) {
+    try {
+        // SAFETY: COUNT/SUM aggregate row.
+        const row = db.prepare(`SELECT COUNT(CASE WHEN event = 'inject' THEN 1 END) AS n,
+              COALESCE(SUM(CASE WHEN event = 'inject' THEN tokens END), 0) AS t,
+              COALESCE(SUM(CASE WHEN event = 'reread' THEN tokens END), 0) AS r
+       FROM token_ledger WHERE ts >= ?`).get(since);
+        return {
+            id: 'tokens',
+            status: 'info',
+            detail: `${Number(row?.n ?? 0)} memory blocks sent to agents in 7 days, about ${Number(row?.t ?? 0)} tokens sent and ${Number(row?.r ?? 0)} re-read by later model calls (hippo tokens for detail)`,
+        };
+    }
+    catch {
+        return { id: 'tokens', status: 'info', detail: 'no token ledger yet (created on the next write)' };
+    }
+}
+/** Checks that read the store's database; a failed open becomes a failed schema check after whatever already passed. */
+function databaseChecks(store, now) {
+    const checks = [];
+    let db = null;
+    try {
+        db = openHippoDbReadOnly(store);
+        const have = getSchemaVersion(db);
+        checks.push(schemaCheck(have, getCurrentSchemaVersion()));
+        checks.push(memoriesCheck(db));
+        const since = new Date(now.getTime() - 7 * 86_400_000).toISOString();
+        checks.push(tokensCheck(db, since));
+        checks.push(failuresCheck(db, since, have));
+        checks.push(sleepCheck(db, now));
+        checks.push(compactionsCheck(db, now));
+    }
+    catch (err) {
+        checks.push({
+            id: 'schema',
+            status: 'fail',
+            detail: `cannot open the database: ${err instanceof Error ? err.message : String(err)}`,
+            fix: err instanceof IncompatibleBinaryError ? 'npm install -g hippo-memory@latest' : 'check file permissions on the .hippo folder',
+        });
+    }
+    finally {
+        if (db !== null)
+            closeHippoDb(db);
+    }
+    return checks;
+}
+// Each hook and what it does, so a partial install says what is missing.
+const CLAUDE_CODE_HOOKS = [
+    ['hippo context --pinned-only', 'per-prompt memory'],
+    ['hippo session-end', 'session-end capture and sleep'],
+    ['hippo pre-compact', 'compaction snapshot and memories request'],
+    ['hippo compact-resume', 'resume after compaction'],
+    ['hippo post-compact', 'saving the memories a compaction lists'],
+    ['hippo capture-error', 'failed-tool capture'],
+];
+function claudeCodeCheck(home) {
+    const claudeDir = path.join(home, '.claude');
+    if (!fs.existsSync(claudeDir)) {
+        return { id: 'claude-code', status: 'info', detail: 'Claude Code not found; other agents can use hippo over MCP (hippo mcp)' };
+    }
+    const settings = readJson(path.join(claudeDir, 'settings.json'));
+    const text = settings === null ? '' : JSON.stringify(settings);
+    const viaPlugin = /hippo-memory@/.test(text);
+    const missing = CLAUDE_CODE_HOOKS.filter(([marker]) => !text.includes(marker)).map(([, what]) => what);
+    if (viaPlugin) {
+        return { id: 'claude-code', status: 'pass', detail: 'Claude Code: hippo plugin enabled (all hooks, including compaction and failed-tool capture)' };
+    }
+    if (missing.length === 0) {
+        return { id: 'claude-code', status: 'pass', detail: 'Claude Code: all hippo hooks installed, including compaction and failed-tool capture' };
+    }
+    if (missing.length === CLAUDE_CODE_HOOKS.length) {
+        return { id: 'claude-code', status: 'warn', detail: 'Claude Code found, but no hippo hooks are installed', fix: 'hippo hook install claude-code' };
+    }
+    return { id: 'claude-code', status: 'warn', detail: `Claude Code: hippo hooks missing for ${missing.join(', ')}`, fix: 'hippo hook install claude-code   (adds only what is missing)' };
+}
 /** Run every check. Never throws for a broken install; broken parts become failed checks. */
 export function runDoctor(opts) {
     const cwd = opts.cwd ?? process.cwd();
     const home = opts.home ?? os.homedir();
     const now = opts.now ?? new Date();
     const checks = [];
-    const node = opts.nodeVersion ?? process.versions.node;
-    checks.push(versionAtLeast(node, MIN_NODE)
-        ? { id: 'node', status: 'pass', detail: `Node.js ${node}` }
-        : { id: 'node', status: 'fail', detail: `Node.js ${node} is older than ${MIN_NODE}`, fix: `Install Node.js ${MIN_NODE} or newer` });
+    checks.push(nodeCheck(opts.nodeVersion ?? process.versions.node));
     const local = findHippoStoreDir(cwd);
     const globalRoot = getGlobalRoot();
     const hasGlobal = isInitialized(globalRoot);
-    let store = null;
-    if (local !== null && isInitialized(local)) {
-        store = local;
-        checks.push({ id: 'store', status: 'pass', detail: `project store at ${local}${hasGlobal ? ` (global store at ${globalRoot} too)` : ''}` });
-    }
-    else if (local !== null) {
-        // The walk stops at the first .hippo it finds, so a bare one (no hippo.db) blocks a parent or global store too.
-        checks.push({ id: 'store', status: 'fail', detail: `${local} has no hippo.db, so hippo commands run here stop at it`, fix: `run hippo init in ${path.dirname(local)}, or remove that .hippo folder` });
-    }
-    else if (hasGlobal) {
-        store = globalRoot;
-        checks.push({ id: 'store', status: 'warn', detail: `no project store here; using the global store at ${globalRoot}`, fix: 'hippo init   (in the project root)' });
-    }
-    else {
-        checks.push({ id: 'store', status: 'fail', detail: 'no hippo store found (project or global)', fix: 'hippo init   (in the project root), or hippo init --global' });
-    }
-    if (store !== null) {
-        let db = null;
-        try {
-            db = openHippoDbReadOnly(store);
-            const have = getSchemaVersion(db);
-            const want = getCurrentSchemaVersion();
-            checks.push(have === want
-                ? { id: 'schema', status: 'pass', detail: `database schema v${have}` }
-                : have > want
-                    ? { id: 'schema', status: 'fail', detail: `database schema v${have} is newer than this hippo (v${want})`, fix: 'npm install -g hippo-memory@latest' }
-                    : { id: 'schema', status: 'info', detail: `database schema v${have}; hippo migrates it to v${want} on the next write` });
-            const memories = countTableRows(db, 'memories');
-            const dormant = countTableRows(db, 'dormant_memories');
-            const memoryCheck = { id: 'memories', status: 'info', detail: `${memories ?? '?'} memories${dormant !== null ? `, ${dormant} dormant` : ''}` };
-            if (memories === 0) {
-                memoryCheck.status = 'warn';
-                memoryCheck.fix = 'hippo learn --git   (seed lessons from git history)';
-            }
-            checks.push(memoryCheck);
-            const since = new Date(now.getTime() - 7 * 86_400_000).toISOString();
-            try {
-                // SAFETY: COUNT/SUM aggregate row.
-                const row = db.prepare(`SELECT COUNT(CASE WHEN event = 'inject' THEN 1 END) AS n,
-                  COALESCE(SUM(CASE WHEN event = 'inject' THEN tokens END), 0) AS t,
-                  COALESCE(SUM(CASE WHEN event = 'reread' THEN tokens END), 0) AS r
-           FROM token_ledger WHERE ts >= ?`).get(since);
-                checks.push({
-                    id: 'tokens',
-                    status: 'info',
-                    detail: `${Number(row?.n ?? 0)} memory blocks sent to agents in 7 days, about ${Number(row?.t ?? 0)} tokens sent and ${Number(row?.r ?? 0)} re-read by later model calls (hippo tokens for detail)`,
-                });
-            }
-            catch {
-                checks.push({ id: 'tokens', status: 'info', detail: 'no token ledger yet (created on the next write)' });
-            }
-            checks.push(failuresCheck(db, since, have));
-            checks.push(sleepCheck(db, now));
-            checks.push(compactionsCheck(db, now));
-        }
-        catch (err) {
-            checks.push({
-                id: 'schema',
-                status: 'fail',
-                detail: `cannot open the database: ${err instanceof Error ? err.message : String(err)}`,
-                fix: err instanceof IncompatibleBinaryError ? 'npm install -g hippo-memory@latest' : 'check file permissions on the .hippo folder',
-            });
-        }
-        finally {
-            if (db !== null)
-                closeHippoDb(db);
-        }
-    }
+    const { store, check } = storeCheck(local, globalRoot, hasGlobal);
+    checks.push(check);
+    if (store !== null)
+        checks.push(...databaseChecks(store, now));
     const holdoutRateBp = store === null ? 0 : loadConfig(store).pilot.holdoutRateBp;
     if (holdoutRateBp > 0) {
         checks.push({ id: 'pilot', status: 'info', detail: `pilot holdout on: about ${holdoutRateBp / 100}% of sessions get no memories pushed by hippo (pilot.holdoutRateBp=${holdoutRateBp})` });
     }
     if (hasGlobal)
         checks.push(projectsCheck(globalRoot));
-    const claudeDir = path.join(home, '.claude');
-    if (fs.existsSync(claudeDir)) {
-        const settings = readJson(path.join(claudeDir, 'settings.json'));
-        const text = settings === null ? '' : JSON.stringify(settings);
-        const viaPlugin = /hippo-memory@/.test(text);
-        // Each hook and what it does, so a partial install says what is missing.
-        const hooks = [
-            ['hippo context --pinned-only', 'per-prompt memory'],
-            ['hippo session-end', 'session-end capture and sleep'],
-            ['hippo pre-compact', 'compaction snapshot and memories request'],
-            ['hippo compact-resume', 'resume after compaction'],
-            ['hippo post-compact', 'saving the memories a compaction lists'],
-            ['hippo capture-error', 'failed-tool capture'],
-        ];
-        const missing = hooks.filter(([marker]) => !text.includes(marker)).map(([, what]) => what);
-        if (viaPlugin) {
-            checks.push({ id: 'claude-code', status: 'pass', detail: 'Claude Code: hippo plugin enabled (all hooks, including compaction and failed-tool capture)' });
-        }
-        else if (missing.length === 0) {
-            checks.push({ id: 'claude-code', status: 'pass', detail: 'Claude Code: all hippo hooks installed, including compaction and failed-tool capture' });
-        }
-        else if (missing.length === hooks.length) {
-            checks.push({ id: 'claude-code', status: 'warn', detail: 'Claude Code found, but no hippo hooks are installed', fix: 'hippo hook install claude-code' });
-        }
-        else {
-            checks.push({ id: 'claude-code', status: 'warn', detail: `Claude Code: hippo hooks missing for ${missing.join(', ')}`, fix: 'hippo hook install claude-code   (adds only what is missing)' });
-        }
-    }
-    else {
-        checks.push({ id: 'claude-code', status: 'info', detail: 'Claude Code not found; other agents can use hippo over MCP (hippo mcp)' });
-    }
+    checks.push(claudeCodeCheck(home));
     if (isCodexPresent(home))
         checks.push(codexCheck(home));
     checks.push({ id: 'embeddings', status: 'info', detail: isEmbeddingAvailable() ? 'local embeddings available (hybrid search)' : 'embeddings not installed; recall uses BM25 (optional: hippo embed --help)' });

package/dist/dormant.js

@@ -1,4 +1,5 @@
 import { rejectionDigest } from './rejection.js';
+import { escapeLike } from './escape.js';
 const DEFAULT_LIST_LIMIT = 20;
 /**
  * Insert (or refresh) the dormant snapshot for `move.entry`. Does not touch
@@ -17,10 +18,6 @@ export function insertDormantRow(db, move) {
       dormant_at = excluded.dormant_at
   `).run(move.entry.tenantId, move.entry.id, move.entry.content, JSON.stringify(move.entry), move.reason, move.strength, move.dormantAt);
 }
-/** Escape LIKE metacharacters so a search term matches literally (ESCAPE '\'). */
-function escapeLike(term) {
-    return term.replace(/[\\%_]/g, (ch) => `\\${ch}`);
-}
 /**
  * Parse a stored snapshot back into a MemoryEntry, or null when the row no
  * longer matches the snapshot it carries (edited by hand, or truncated).

package/dist/embedding-provider.d.ts

@@ -8,14 +8,10 @@
  * read their key from a conventional env var. The provider is selected by
  * `config.embeddings.provider` (default `'local'`).
  *
- * Design contract (see docs/plans/2026-06-08-b-pluggable-embedding-provider.md):
- *   - Local provider `id` is the BARE model string. (Historical note: this
- *     originally guaranteed NO identity change on upgrade; since the
- *     embed-text-format versioning in embeddings.ts (`embeddingIndexIdentity`,
- *     `${id}#t2`, docs/plans/2026-07-09-recall-determinism.md T1), the STORED
- *     identity carries a `#t<N>` suffix and pre-#t2 stores get exactly one
- *     forced reindex on their next embed-touching operation — deliberate,
- *     because their vectors were computed over path-contaminated text.)
+ * Design contract:
+ *   - Local provider `id` is the BARE model string; the STORED identity adds a `#t<N>`
+ *     embed-text-format suffix (`embeddingIndexIdentity`), so older stores reindex once:
+ *     their vectors were computed over path-contaminated text.
  *   - API provider `id` is `${kind}:${model}`; switching to/from an API embedder
  *     (or a dimension change) flips the identity and triggers the existing
  *     reindex-on-change path.

package/dist/embedding-provider.js

@@ -8,14 +8,10 @@
  * read their key from a conventional env var. The provider is selected by
  * `config.embeddings.provider` (default `'local'`).
  *
- * Design contract (see docs/plans/2026-06-08-b-pluggable-embedding-provider.md):
- *   - Local provider `id` is the BARE model string. (Historical note: this
- *     originally guaranteed NO identity change on upgrade; since the
- *     embed-text-format versioning in embeddings.ts (`embeddingIndexIdentity`,
- *     `${id}#t2`, docs/plans/2026-07-09-recall-determinism.md T1), the STORED
- *     identity carries a `#t<N>` suffix and pre-#t2 stores get exactly one
- *     forced reindex on their next embed-touching operation — deliberate,
- *     because their vectors were computed over path-contaminated text.)
+ * Design contract:
+ *   - Local provider `id` is the BARE model string; the STORED identity adds a `#t<N>`
+ *     embed-text-format suffix (`embeddingIndexIdentity`), so older stores reindex once:
+ *     their vectors were computed over path-contaminated text.
  *   - API provider `id` is `${kind}:${model}`; switching to/from an API embedder
  *     (or a dimension change) flips the identity and triggers the existing
  *     reindex-on-change path.

package/dist/embeddings.js

@@ -314,7 +314,7 @@ export async function embedMemory(hippoRoot, entry, model) {
         try {
             const identity = provider.id;
             if (embeddingModelRequiresReindex(hippoRoot, identity)) {
-                // L9: host-wide rebuild. The embedding index is keyed by entry.id
+                // Host-wide rebuild. The embedding index is keyed by entry.id
                 // (which is tenant-scoped) but the index itself is one per hippoRoot.
                 // Cross-tenant content equivalence is visible at the vector level.
                 // Per-tenant indices would be a larger architecture change.
@@ -357,6 +357,57 @@ export async function embedMemory(hippoRoot, entry, model) {
         log.warn(`skipped embedding ${entry.id} (${err instanceof Error ? err.message : String(err)}); run 'hippo embed' to backfill`);
     });
 }
+/** Throws when an unavailable provider is a misconfiguration rather than an intentional no-op. */
+function throwIfProviderKeyMissing(hippoRoot, provider) {
+    // A configured (non-disabled) API provider with a missing key is a
+    // misconfiguration, not a no-op: surface it so programmatic callers of the
+    // exported embedAll() learn nothing was written. Local-not-installed and an
+    // explicit enabled=false stay silent no-ops (best-effort / intentional).
+    const cfg = loadConfig(hippoRoot).embeddings;
+    if (provider.kind !== 'local' &&
+        cfg.enabled !== false &&
+        provider.keyEnv &&
+        !envByName(provider.keyEnv)?.trim()) {
+        throw new Error(`Embedding provider '${provider.kind}' is configured but ${provider.keyEnv} is not set.`);
+    }
+}
+// Embed entries without a cached vector in save-checkpointed chunks.
+// provider.embed batches internally (one HTTP request per batchSize for API
+// providers; sequential for local). A `[]` row means that single item could
+// not be embedded and is left for a later run (resumable). On a hard provider
+// failure mid-backfill we persist the chunks already embedded this run rather
+// than discarding paid progress, then stop and resume on the next run.
+async function backfillPending(hippoRoot, provider, pending, model) {
+    let count = 0;
+    // Initialized to `undefined` (not a known-evidence literal like `null`) so
+    // it stays a plain `unknown` binding for the arbitrary caught value below;
+    // falsy either way, so `if (backfillError)` behaves identically.
+    let backfillError = undefined;
+    const SAVE_CHUNK = 64;
+    for (let i = 0; i < pending.length; i += SAVE_CHUNK) {
+        const chunk = pending.slice(i, i + SAVE_CHUNK);
+        let vectors;
+        try {
+            vectors = await provider.embed(chunk.map((e) => embeddingInputText(e)), 'passage');
+        }
+        catch (err) {
+            // Preserve the chunks already saved this run, then surface the failure
+            // below so the explicit `hippo embed` path never reports a false success.
+            backfillError = err;
+            break;
+        }
+        const rows = [];
+        for (let j = 0; j < chunk.length; j++) {
+            const vec = vectors[j];
+            if (vec && vec.length > 0)
+                rows.push([chunk[j].id, vec]);
+            else
+                noteSkippedEmbedding(chunk[j].id);
+        }
+        count += withVectorDb(hippoRoot, (db) => upsertVectors(db, rows, model));
+    }
+    return { count, backfillError };
+}
 /**
  * Embed all entries in hippoRoot that don't already have cached vectors.
  * Prunes orphaned embeddings for memories that no longer exist.
@@ -364,22 +415,12 @@ export async function embedMemory(hippoRoot, entry, model) {
  */
 export async function embedAll(hippoRoot, model, provider = resolveEmbeddingProvider(hippoRoot, { model })) {
     if (!provider.isAvailable()) {
-        // A configured (non-disabled) API provider with a missing key is a
-        // misconfiguration, not a no-op: surface it so programmatic callers of the
-        // exported embedAll() learn nothing was written. Local-not-installed and an
-        // explicit enabled=false stay silent no-ops (best-effort / intentional).
-        const cfg = loadConfig(hippoRoot).embeddings;
-        if (provider.kind !== 'local' &&
-            cfg.enabled !== false &&
-            provider.keyEnv &&
-            !envByName(provider.keyEnv)?.trim()) {
-            throw new Error(`Embedding provider '${provider.kind}' is configured but ${provider.keyEnv} is not set.`);
-        }
+        throwIfProviderKeyMissing(hippoRoot, provider);
         return 0;
     }
     return withEmbedLock(hippoRoot, async () => {
         const identity = provider.id;
-        // L9: host-wide by design. embedAll backfills vectors for all tenants'
+        // Host-wide by design. embedAll backfills vectors for all tenants'
         // entries into the per-host embedding index. Per-tenant filtering would
         // produce partial indices and break recall.
         const entries = loadAllEntries(hippoRoot);
@@ -395,41 +436,8 @@ export async function embedAll(hippoRoot, model, provider = resolveEmbeddingProv
             deleteOrphanVectors(db);
             return storedVectorIds(db);
         });
-        // Embed entries without a cached vector in save-checkpointed chunks.
-        // provider.embed batches internally (one HTTP request per batchSize for API
-        // providers; sequential for local). A `[]` row means that single item could
-        // not be embedded and is left for a later run (resumable). On a hard provider
-        // failure mid-backfill we persist the chunks already embedded this run rather
-        // than discarding paid progress, then stop and resume on the next run.
         const pending = entries.filter((e) => !embedded.has(e.id));
-        let count = 0;
-        // Initialized to `undefined` (not a known-evidence literal like `null`) so
-        // it stays a plain `unknown` binding for the arbitrary caught value below;
-        // falsy either way, so `if (backfillError)` behaves identically.
-        let backfillError = undefined;
-        const SAVE_CHUNK = 64;
-        for (let i = 0; i < pending.length; i += SAVE_CHUNK) {
-            const chunk = pending.slice(i, i + SAVE_CHUNK);
-            let vectors;
-            try {
-                vectors = await provider.embed(chunk.map((e) => embeddingInputText(e)), 'passage');
-            }
-            catch (err) {
-                // Preserve the chunks already saved this run, then surface the failure
-                // below so the explicit `hippo embed` path never reports a false success.
-                backfillError = err;
-                break;
-            }
-            const rows = [];
-            for (let j = 0; j < chunk.length; j++) {
-                const vec = vectors[j];
-                if (vec && vec.length > 0)
-                    rows.push([chunk[j].id, vec]);
-                else
-                    noteSkippedEmbedding(chunk[j].id);
-            }
-            count += withVectorDb(hippoRoot, (db) => upsertVectors(db, rows, model));
-        }
+        const { count, backfillError } = await backfillPending(hippoRoot, provider, pending, model);
         saveStoredEmbeddingModel(hippoRoot, identity);
         // Partial progress is now persisted; surface a hard backfill failure so the
         // explicit embed path reports it (best-effort callers go via embedMemory).

package/dist/env.d.ts

@@ -35,7 +35,7 @@ export declare function envTenant(): string;
 export declare function envSkipAutoIntegrations(): boolean;
 export declare function envSkipPostinstall(): boolean;
 export declare function envMcpStdio(): boolean;
-/** Any non-empty value counts, unlike the `=1` switches. */
+/** `1` or `true`, so `0` and `false` turn it off; `true` stays on for anyone who set it that way. */
 export declare function envRequireServer(): boolean;
 export declare function envRequireSessionScopedFreshTail(): boolean;
 export declare function envStdinWaitMs(): number | undefined;

package/dist/env.js

@@ -15,9 +15,9 @@ function positiveInt(name) {
     const parsed = Number.parseInt(raw(name) ?? '', 10);
     return parsed > 0 ? parsed : undefined;
 }
-/** parseInt, kept when nonzero: these sites have always used `|| default`, so a negative value passes through. */
-function nonZeroInt(name) {
-    return Number.parseInt(raw(name) ?? '', 10) || undefined;
+/** Trimmed, with an empty or whitespace-only value read as unset. */
+function trimmed(name) {
+    return raw(name)?.trim() || undefined;
 }
 /** The whole environment, for code that takes it as an injectable map (agent-memory machines, owner checks, support bundles). */
 export function processEnv() {
@@ -61,10 +61,10 @@ export function envHippoHome() { return raw('HIPPO_HOME')?.trim(); }
 export function envXdgDataHome() { return raw('XDG_DATA_HOME')?.trim(); }
 export function envHomeDir() { return raw('HOME') || raw('USERPROFILE'); }
 export function envPath() { return raw('PATH'); }
-export function envModelCache() { return raw('HIPPO_MODEL_CACHE'); }
+export function envModelCache() { return trimmed('HIPPO_MODEL_CACHE'); }
 // Session, scope and tenant.
-export function envHippoSessionId() { return raw('HIPPO_SESSION_ID'); }
-export function envClaudeCodeSessionId() { return raw('CLAUDE_CODE_SESSION_ID'); }
+export function envHippoSessionId() { return trimmed('HIPPO_SESSION_ID'); }
+export function envClaudeCodeSessionId() { return trimmed('CLAUDE_CODE_SESSION_ID'); }
 export function envScope() { return raw('HIPPO_SCOPE'); }
 export function envGstackSkill() { return raw('GSTACK_SKILL'); }
 export function envOpenclawSkill() { return raw('OPENCLAW_SKILL'); }
@@ -76,8 +76,8 @@ export function envTenant() {
 export function envSkipAutoIntegrations() { return isOne('HIPPO_SKIP_AUTO_INTEGRATIONS'); }
 export function envSkipPostinstall() { return isOne('HIPPO_SKIP_POSTINSTALL'); }
 export function envMcpStdio() { return isOne('HIPPO_MCP_STDIO'); }
-/** Any non-empty value counts, unlike the `=1` switches. */
-export function envRequireServer() { return Boolean(raw('HIPPO_REQUIRE_SERVER')); }
+/** `1` or `true`, so `0` and `false` turn it off; `true` stays on for anyone who set it that way. */
+export function envRequireServer() { return isOneOrTrue('HIPPO_REQUIRE_SERVER'); }
 export function envRequireSessionScopedFreshTail() { return isOne('HIPPO_REQUIRE_SESSION_SCOPED_FRESH_TAIL'); }
 export function envStdinWaitMs() { return positiveInt('HIPPO_STDIN_WAIT_MS'); }
 export function envLogLevel() { return raw('HIPPO_LOG')?.trim().toLowerCase() ?? ''; }
@@ -89,18 +89,18 @@ export function envApiKey() { return raw('HIPPO_API_KEY'); }
 export function envClientIpHeader() { return raw('HIPPO_CLIENT_IP_HEADER')?.trim().toLowerCase(); }
 export function envTrustedProxies() { return raw('HIPPO_TRUSTED_PROXIES'); }
 export function envMcpSseMaxStreams() { return positiveInt('MCP_SSE_MAX_STREAMS'); }
-export function envMcpSseHeartbeatMs() { return nonZeroInt('MCP_SSE_HEARTBEAT_MS'); }
-export function envMcpSseMaxAgeSec() { return nonZeroInt('MCP_SSE_MAX_AGE_SEC'); }
+export function envMcpSseHeartbeatMs() { return positiveInt('MCP_SSE_HEARTBEAT_MS'); }
+export function envMcpSseMaxAgeSec() { return positiveInt('MCP_SSE_MAX_AGE_SEC'); }
 // LLM and reranker credentials and knobs.
 export function envAnthropicApiKey() { return raw('ANTHROPIC_API_KEY'); }
 export function envLlmTimeoutMs() { return positiveInt('HIPPO_LLM_TIMEOUT_MS'); }
-export function envTypesafeApiKey() { return raw('TYPESAFE_API_KEY'); }
+export function envTypesafeApiKey() { return trimmed('TYPESAFE_API_KEY'); }
 export function envJevTimeoutMs() { return positiveInt('HIPPO_JEV_TIMEOUT_MS'); }
 export function envJevModel() { return raw('HIPPO_JEV_MODEL'); }
 export function envLlmRerankerUrl() { return raw('HIPPO_LLM_RERANKER_URL'); }
 export function envLlmRerankerKey() { return raw('HIPPO_LLM_RERANKER_KEY'); }
 export function envLlmRerankerModel() { return raw('HIPPO_LLM_RERANKER_MODEL'); }
-export function envLlmRerankerTimeoutMs() { return nonZeroInt('HIPPO_LLM_RERANKER_TIMEOUT_MS'); }
+export function envLlmRerankerTimeoutMs() { return positiveInt('HIPPO_LLM_RERANKER_TIMEOUT_MS'); }
 export function envClefEndpoint() { return raw('HIPPO_CLEF_ENDPOINT')?.trim(); }
 export function envClefEndpointToken() { return raw('HIPPO_CLEF_ENDPOINT_TOKEN')?.trim() || undefined; }
 export function envClefTimeoutMs() { return raw('HIPPO_CLEF_TIMEOUT_MS'); }

package/dist/escape.d.ts

@@ -0,0 +1,5 @@
+/** Escape LIKE metacharacters for a query that declares `ESCAPE '\'`. */
+export declare function escapeLike(term: string): string;
+/** Escape a string for use as a literal inside a RegExp source. */
+export declare function escapeRegex(s: string): string;
+//# sourceMappingURL=escape.d.ts.map

package/dist/escape.js

@@ -0,0 +1,10 @@
+// Leaf module: literal-match escapes, kept in one place so every LIKE and RegExp caller escapes the same set.
+/** Escape LIKE metacharacters for a query that declares `ESCAPE '\'`. */
+export function escapeLike(term) {
+    return term.replace(/[%_\\]/g, '\\$&');
+}
+/** Escape a string for use as a literal inside a RegExp source. */
+export function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=escape.js.map

package/dist/eval-stats.d.ts

@@ -1,6 +1,5 @@
 /**
- * Statistics and cost accounting for the token-efficiency evals (ROADMAP
- * Part IX, TE3-TE5).
+ * Statistics and cost accounting for the token-efficiency evals.
  *
  * - Cost: price provider usage over four buckets (uncached input, cache
  *   write, cache read, output). Raw token counts overstate savings when most

package/dist/eval-stats.js

@@ -1,6 +1,5 @@
 /**
- * Statistics and cost accounting for the token-efficiency evals (ROADMAP
- * Part IX, TE3-TE5).
+ * Statistics and cost accounting for the token-efficiency evals.
  *
  * - Cost: price provider usage over four buckets (uncached input, cache
  *   write, cache read, output). Raw token counts overstate savings when most