hippo-memory 1.47.0 → 1.49.0

package/dist/server.js

@@ -116,6 +116,8 @@ const VALID_AUDIT_OPS = new Set([
     'conflict_resolve', // AT1 — emitted by resolveConflict on every resolution path; lockstep
     'half_life_migrate', // Decay default change — emitted by migrateDefaultHalfLife; lockstep with AuditOp union
     'dormant_restore', // Dormant memories — emitted by api.restoreDormant; lockstep with AuditOp union + cli.ts VALID_AUDIT_OPS
+    'auth_grant', // EI2: emitted by api.authGrant; lockstep with AuditOp union + cli.ts VALID_AUDIT_OPS
+    'auth_ungrant', // EI2: emitted by api.authUngrant; lockstep with AuditOp union + cli.ts VALID_AUDIT_OPS
 ]);
 // Cap on GET /v1/audit?limit=. Matches docs/api.md (when written) and is large
 // enough to dump a small deployment's full audit log without paginating, but
@@ -469,6 +471,7 @@ function buildContextWithAuth(req, hippoRoot) {
                 actor: {
                     subject: `api_key:${result.keyId}`,
                     role: result.role,
+                    scopes: result.scopes,
                 },
             };
         }
@@ -1191,16 +1194,13 @@ async function handleRequest(req, res, opts, startedAt, limiter) {
             limit = parsed;
         }
         const ctx = buildContextWithAuth(req, opts.hippoRoot);
-        // D2 v1.12.10: optional ?tenant=<t> param. Defaults to ctx.tenantId
-        // (caller's own tenant). Lets admins query the '__host__' synthetic
-        // tenant where host-wide ops like 'consolidate' are recorded. Today
-        // the audit route inherits the auth gate on /v1/audit (Bearer auth);
-        // a future per-tenant authz check should ensure non-admin Bearers
-        // can only pass their own tenant_id here.
+        // ?tenant=<t> reads another tenant (e.g. '__host__' for consolidate rows); admin only.
         const tenantOverride = query.get('tenant');
-        const effectiveCtx = tenantOverride !== null && tenantOverride !== ''
-            ? { ...ctx, tenantId: tenantOverride }
-            : ctx;
+        const crossTenant = tenantOverride !== null && tenantOverride !== '' && tenantOverride !== ctx.tenantId;
+        if (crossTenant && ctx.actor.role !== 'admin') {
+            throw new HttpError(403, '/v1/audit?tenant= for another tenant requires admin role');
+        }
+        const effectiveCtx = crossTenant ? { ...ctx, tenantId: tenantOverride } : ctx;
         const result = auditList(effectiveCtx, { op, since, limit });
         sendJson(res, 200, result);
         return;
@@ -3021,6 +3021,7 @@ async function handleRequest(req, res, opts, startedAt, limiter) {
                 actor: ctx.actor.subject,
                 // The caller's real role: MCP tools must not run a member key as admin.
                 role: ctx.actor.role,
+                scopes: ctx.actor.scopes,
                 clientKey: buildMcpClientKey(req),
             });
         }

package/dist/store.d.ts

@@ -190,23 +190,13 @@ interface LegacyStats {
     total_forgotten: JsonValue;
     consolidation_runs: JsonValue;
 }
-/**
- * Derive the current `HippoIndex` (entries + last-retrieval/trace lockstep
- * meta) from SQLite, the source of truth. Exported (AT1) for the same
- * reason as `writeIndexMirror` below: `src/reject-flow.ts` needs to rebuild
- * the index mirror post-commit after a (possibly multi-row) reject removal,
- * without duplicating this query.
- */
+/** Derive the current `HippoIndex` from SQLite. Exported for `rebuildIndex`
+ *  (the only index.json writer) and the longmemeval benchmark. */
 export declare function buildIndexFromDb(db: ReturnType<typeof openHippoDb>): HippoIndex;
-/**
- * Write the `index.json` mirror file for a given (already-derived) index.
- * Exported (AT1) so `src/reject-flow.ts` can replicate `deleteEntry`'s exact
- * post-commit "removeEntryMirrors then rewrite the index once" sequence for
- * the reject verb's (possibly multi-row) removal, without duplicating
- * `buildIndexFromDb`'s query.
- */
+/** Write the `index.json` mirror file for an already-derived index. Exported for
+ *  `rebuildIndex` (the only index.json writer) and the longmemeval benchmark. */
 export declare function writeIndexMirror(hippoRoot: string, index: HippoIndex): void;
-/** Load the derived index from SQLite. Read-only: writers refresh index.json, so readers never race on it. */
+/** Load the derived index from SQLite. Read-only: index.json is only ever written by `rebuildIndex`. */
 export declare function loadIndex(hippoRoot: string): HippoIndex;
 /**
  * Persist mutable index metadata. Entry rows themselves are derived from SQLite.
@@ -215,10 +205,8 @@ export declare function loadIndex(hippoRoot: string): HippoIndex;
  * land atomically — callers (getContext, cmdRecall) fold a freshly-written
  * trace id into `index.last_trace_id` before calling this, relying on BOTH
  * meta keys committing together. Wrapped in BEGIN/COMMIT so a crash or a
- * mid-write failure can never advance one key without the other. The
- * filesystem mirror write stays AFTER commit — the DB is the source of
- * truth, the mirror is best-effort (matches every other per-call-handle
- * site's convention).
+ * mid-write failure can never advance one key without the other. index.json
+ * is left untouched; only `rebuildIndex` writes it.
  */
 export declare function saveIndex(hippoRoot: string, index: HippoIndex): void;
 /**
@@ -277,13 +265,8 @@ export declare function writeEntryDbOnly(db: DatabaseSyncLike, entry: MemoryEntr
     actor?: string;
     afterWrite?: (db: DatabaseSyncLike, memoryId: string) => void;
 }): void;
-/**
- * Filesystem mirrors path. Caller passes `hippoRoot` + an open `db` handle
- * (used by `buildIndexFromDb` to derive the index from the source of truth).
- * MUST be invoked AFTER the outer transaction commits — a mirror write
- * during a tx that subsequently rolls back would leave orphan markdown.
- */
-export declare function writeEntryMirrors(hippoRoot: string, db: DatabaseSyncLike, entry: MemoryEntry): void;
+/** Markdown mirror path, invoked AFTER commit (a rolled-back tx must leave no orphan markdown). */
+export declare function writeEntryMirrors(hippoRoot: string, entry: MemoryEntry): void;
 /**
  * Read a memory entry by ID.
  *

package/dist/store.js

@@ -940,6 +940,7 @@ function upsertEntryRow(db, entry, bypassRejectionGuard = false) {
     if (!bypassRejectionGuard) {
         checkRejectionGuard(db, entry.tenantId ?? 'default', entry.id, entry.content);
     }
+    const isNewRow = db.prepare(`SELECT 1 FROM memories WHERE id = ?`).get(entry.id) === undefined;
     db.prepare(`
     INSERT INTO memories(
       id, created, last_retrieved, retrieval_count, strength, half_life_days, layer,
@@ -996,13 +997,14 @@ function upsertEntryRow(db, entry, bypassRejectionGuard = false) {
       dag_level_3_built_at = excluded.dag_level_3_built_at,
       updated_at = datetime('now')
   `).run(entry.id, entry.created, entry.last_retrieved, entry.retrieval_count, entry.strength, entry.half_life_days, entry.layer, JSON.stringify(entry.tags ?? []), entry.emotional_valence, entry.schema_fit, entry.source, entry.outcome_score, entry.outcome_positive ?? 0, entry.outcome_negative ?? 0, JSON.stringify(entry.conflicts_with ?? []), entry.pinned ? 1 : 0, entry.confidence, entry.content, JSON.stringify(entry.parents ?? []), entry.starred ? 1 : 0, entry.trace_outcome ?? null, entry.source_session_id ?? null, entry.valid_from ?? entry.created, entry.superseded_by ?? null, entry.extracted_from ?? null, entry.dag_level ?? 0, entry.dag_parent_id ?? null, entry.kind ?? 'distilled', entry.scope ?? null, entry.owner ?? null, entry.artifact_ref ?? null, entry.tenantId ?? 'default', entry.origin_project ?? null, entry.descendant_count ?? 0, entry.earliest_at ?? null, entry.latest_at ?? null, entry.dag_level_3_built_at ?? null);
-    syncFtsRow(db, entry);
+    syncFtsRow(db, entry, isNewRow);
 }
-function syncFtsRow(db, entry) {
+function syncFtsRow(db, entry, isNewRow = false) {
     if (!isFtsAvailable(db))
         return;
     try {
-        db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(entry.id);
+        if (!isNewRow)
+            db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(entry.id);
         db.prepare(`INSERT INTO memories_fts(id, content, tags) VALUES (?, ?, ?)`).run(entry.id, entry.content, entry.tags.join(' '));
     }
     catch {
@@ -1019,13 +1021,8 @@ function deleteFtsRow(db, id) {
         // Best effort.
     }
 }
-/**
- * Derive the current `HippoIndex` (entries + last-retrieval/trace lockstep
- * meta) from SQLite, the source of truth. Exported (AT1) for the same
- * reason as `writeIndexMirror` below: `src/reject-flow.ts` needs to rebuild
- * the index mirror post-commit after a (possibly multi-row) reject removal,
- * without duplicating this query.
- */
+/** Derive the current `HippoIndex` from SQLite. Exported for `rebuildIndex`
+ *  (the only index.json writer) and the longmemeval benchmark. */
 export function buildIndexFromDb(db) {
     // SAFETY: rows' shape matches the seven columns named in the SELECT below.
     const rows = db.prepare(`SELECT id, created, last_retrieved, strength, layer, tags_json, pinned FROM memories ORDER BY created ASC, id ASC`).all();
@@ -1076,13 +1073,8 @@ function buildStatsFromDb(db) {
         })),
     };
 }
-/**
- * Write the `index.json` mirror file for a given (already-derived) index.
- * Exported (AT1) so `src/reject-flow.ts` can replicate `deleteEntry`'s exact
- * post-commit "removeEntryMirrors then rewrite the index once" sequence for
- * the reject verb's (possibly multi-row) removal, without duplicating
- * `buildIndexFromDb`'s query.
- */
+/** Write the `index.json` mirror file for an already-derived index. Exported for
+ *  `rebuildIndex` (the only index.json writer) and the longmemeval benchmark. */
 export function writeIndexMirror(hippoRoot, index) {
     mirrorBestEffort('index.json', () => fs.writeFileSync(path.join(hippoRoot, 'index.json'), JSON.stringify(index, null, 2), 'utf8'));
 }
@@ -1115,10 +1107,9 @@ function syncMirrorFiles(hippoRoot, db) {
     ORDER BY updated_at DESC, id DESC
   `).all();
     mirrorBestEffort('conflict mirrors', () => writeConflictMirrors(hippoRoot, conflicts.map(rowToMemoryConflict)));
-    writeIndexMirror(hippoRoot, buildIndexFromDb(db));
     writeStatsMirror(hippoRoot, buildStatsFromDb(db));
 }
-/** Load the derived index from SQLite. Read-only: writers refresh index.json, so readers never race on it. */
+/** Load the derived index from SQLite. Read-only: index.json is only ever written by `rebuildIndex`. */
 export function loadIndex(hippoRoot) {
     initStore(hippoRoot);
     const db = openHippoDb(hippoRoot);
@@ -1136,10 +1127,8 @@ export function loadIndex(hippoRoot) {
  * land atomically — callers (getContext, cmdRecall) fold a freshly-written
  * trace id into `index.last_trace_id` before calling this, relying on BOTH
  * meta keys committing together. Wrapped in BEGIN/COMMIT so a crash or a
- * mid-write failure can never advance one key without the other. The
- * filesystem mirror write stays AFTER commit — the DB is the source of
- * truth, the mirror is best-effort (matches every other per-call-handle
- * site's convention).
+ * mid-write failure can never advance one key without the other. index.json
+ * is left untouched; only `rebuildIndex` writes it.
  */
 export function saveIndex(hippoRoot, index) {
     initStore(hippoRoot);
@@ -1158,7 +1147,6 @@ export function saveIndex(hippoRoot, index) {
             catch { /* already rolled back; keep the original error */ }
             throw error;
         }
-        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
     }
     finally {
         closeHippoDb(db);
@@ -1222,7 +1210,7 @@ export function writeEntry(hippoRoot, entry, opts) {
     try {
         writeEntryDbOnly(db, stamped, opts);
         opts?.afterCommit?.();
-        writeEntryMirrors(hippoRoot, db, stamped);
+        writeEntryMirrors(hippoRoot, stamped);
     }
     catch (error) {
         // AT1 (plan §3): writeEntryDbOnly's own SAVEPOINT has already unwound by
@@ -1286,15 +1274,9 @@ export function writeEntryDbOnly(db, entry, opts) {
         throw e;
     }
 }
-/**
- * Filesystem mirrors path. Caller passes `hippoRoot` + an open `db` handle
- * (used by `buildIndexFromDb` to derive the index from the source of truth).
- * MUST be invoked AFTER the outer transaction commits — a mirror write
- * during a tx that subsequently rolls back would leave orphan markdown.
- */
-export function writeEntryMirrors(hippoRoot, db, entry) {
+/** Markdown mirror path, invoked AFTER commit (a rolled-back tx must leave no orphan markdown). */
+export function writeEntryMirrors(hippoRoot, entry) {
     mirrorBestEffort(`${entry.id}.md`, () => writeMarkdownMirror(hippoRoot, entry));
-    writeIndexMirror(hippoRoot, buildIndexFromDb(db));
 }
 /**
  * Read a memory entry by ID.
@@ -1611,7 +1593,6 @@ export function deleteEntry(hippoRoot, id, opts) {
         if (!result)
             return false;
         purgeMirrorBestEffort(hippoRoot, id, false, 'deleteEntry');
-        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
         return true;
     }
     finally {
@@ -1786,7 +1767,6 @@ export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds, opts) {
         });
         for (const id of removedIds)
             purgeMirrorBestEffort(hippoRoot, id, false, 'batchWriteAndDelete');
-        writeIndexMirror(hippoRoot, buildIndexFromDb(db));
         return removedIds;
     }
     catch (error) {
@@ -1978,7 +1958,9 @@ export function rebuildIndex(hippoRoot) {
             }
         }
         syncMirrorFiles(hippoRoot, db);
-        return buildIndexFromDb(db);
+        const index = buildIndexFromDb(db);
+        writeIndexMirror(hippoRoot, index);
+        return index;
     }
     finally {
         closeHippoDb(db);

package/dist/support-bundle.d.ts

@@ -0,0 +1,12 @@
+import { type DoctorOpts } from './doctor.js';
+import type { JsonObject } from './working-memory.js';
+export interface SupportBundleOpts extends DoctorOpts {
+    readonly cwd: string;
+    readonly home: string;
+    readonly now: Date;
+    readonly includeLogs: boolean;
+}
+export declare const TAIL_MAX_LINES = 200;
+/** Read-only: builds one redacted support-ticket snapshot. Never reads a memory content column. */
+export declare function buildSupportBundle(opts: SupportBundleOpts): JsonObject;
+//# sourceMappingURL=support-bundle.d.ts.map

package/dist/support-bundle.js

@@ -0,0 +1,292 @@
+/** `hippo support-bundle`: one redacted JSON snapshot for a support ticket. Read-only; never touches memory content. */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { findHippoStoreDir, isGlobalStoreRoot, realpathOrResolve } from './project-identity.js';
+import { getGlobalRoot } from './shared.js';
+import { isInitialized } from './store.js';
+import { openHippoDbReadOnly, closeHippoDb, getSchemaVersion, getMeta, countTableRows } from './db.js';
+import { runDoctor } from './doctor.js';
+import { loadConfig } from './config.js';
+import { redactSecretsStrict } from './secret-detect.js';
+const TAIL_MAX_BYTES = 256 * 1024;
+export const TAIL_MAX_LINES = 200;
+const TAIL_MAX_LINE_CHARS = 2000;
+// Greedy on purpose: complete key blocks are redacted first, so any END left is an orphan and what precedes it may be key body.
+const ORPHAN_KEY_END_RE = /^[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/;
+// The other env vars hippo reads outside the HIPPO_ prefix (src/embedding-provider.ts, connectors/*).
+const OTHER_ENV_NAMES = [
+    'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'VOYAGE_API_KEY', 'COHERE_API_KEY', 'TYPESAFE_API_KEY',
+    'GITHUB_TOKEN', 'GITHUB_WEBHOOK_SECRET', 'GITHUB_WEBHOOK_SECRET_PREVIOUS',
+    'GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK', 'SLACK_BOT_TOKEN', 'SLACK_TEAM_ID',
+    'SLACK_SIGNING_SECRET', 'SLACK_SIGNING_SECRET_PREVIOUS', 'SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK',
+    'XDG_DATA_HOME', 'MCP_SSE_HEARTBEAT_MS', 'MCP_SSE_MAX_AGE_SEC',
+];
+const CONFIG_SECRET_KEY_RE = /key|token|secret|passw|credential|auth|cookie|bearer|signature|private/i;
+function isJsonObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function isJsonString(v) {
+    return typeof v === 'string';
+}
+function buildRuntime() {
+    return {
+        node: process.versions.node,
+        sqlite: process.versions.sqlite ?? null,
+        platform: process.platform,
+        arch: process.arch,
+        osRelease: os.release(),
+    };
+}
+function listTableNames(db) {
+    // SAFETY: each row's shape matches the single `name` column named in the SELECT above.
+    const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND sql NOT LIKE 'CREATE VIRTUAL TABLE%' ORDER BY name`).all();
+    return rows.map((r) => r.name);
+}
+function countTables(db) {
+    const tables = {};
+    for (const name of listTableNames(db))
+        tables[name] = countTableRows(db, name);
+    return tables;
+}
+function redactConfigValue(value) {
+    if (Array.isArray(value))
+        return value.map(redactConfigValue);
+    if (isJsonObject(value)) {
+        const out = {};
+        for (const [key, v] of Object.entries(value)) {
+            out[key] = CONFIG_SECRET_KEY_RE.test(key) ? '[REDACTED]' : redactConfigValue(v);
+        }
+        return out;
+    }
+    return value;
+}
+function readStoreConfig(storeDir) {
+    const configPath = path.join(storeDir, 'config.json');
+    let configFile = 'absent';
+    if (fs.existsSync(configPath)) {
+        try {
+            JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            configFile = 'present';
+        }
+        catch {
+            configFile = 'invalid';
+        }
+    }
+    // loadConfig always returns the effective config: its own defaults on a missing or broken file.
+    const effective = JSON.parse(JSON.stringify(loadConfig(storeDir)));
+    return { configFile, config: redactConfigValue(effective) };
+}
+function buildStoreEntry(kind, storeDir) {
+    const dbPath = path.join(storeDir, 'hippo.db');
+    if (!fs.existsSync(dbPath)) {
+        return { kind, path: storeDir, error: 'no hippo.db here (hippo init has not run)' };
+    }
+    // Stat before opening: a read-only open leaves an empty -wal behind it.
+    const files = { 'hippo.db': fs.statSync(dbPath).size };
+    const walPath = `${dbPath}-wal`;
+    if (fs.existsSync(walPath))
+        files['hippo.db-wal'] = fs.statSync(walPath).size;
+    let db = null;
+    try {
+        db = openHippoDbReadOnly(storeDir);
+        const schemaVersion = getSchemaVersion(db);
+        const minCompatibleBinary = getMeta(db, 'min_compatible_binary', '') || null;
+        const tables = countTables(db);
+        const { configFile, config } = readStoreConfig(storeDir);
+        return { kind, path: storeDir, schemaVersion, minCompatibleBinary, files, tables, configFile, config };
+    }
+    catch (err) {
+        return { kind, path: storeDir, error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        if (db !== null)
+            closeHippoDb(db);
+    }
+}
+function buildStores(opts) {
+    const stores = [];
+    const projectDir = findHippoStoreDir(opts.cwd, { homeDir: opts.home });
+    if (projectDir !== null)
+        stores.push(buildStoreEntry('project', projectDir));
+    const globalDir = getGlobalRoot();
+    const alreadyListed = projectDir !== null && isGlobalStoreRoot(projectDir);
+    if (isInitialized(globalDir) && !alreadyListed)
+        stores.push(buildStoreEntry('global', globalDir));
+    return stores;
+}
+function listSetEnvNames() {
+    const names = new Set();
+    for (const key of Object.keys(process.env)) {
+        if (key.startsWith('HIPPO_'))
+            names.add(key);
+    }
+    for (const key of OTHER_ENV_NAMES) {
+        if (process.env[key] !== undefined)
+            names.add(key);
+    }
+    return [...names].sort();
+}
+function listLogFileNames(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isFile())
+        .map((d) => d.name)
+        .sort();
+}
+function tailLogFile(file) {
+    const size = fs.statSync(file).size;
+    const readSize = Math.min(size, TAIL_MAX_BYTES);
+    const startedMidFile = size > TAIL_MAX_BYTES;
+    const fd = fs.openSync(file, 'r');
+    let text;
+    try {
+        const buf = Buffer.alloc(readSize);
+        fs.readSync(fd, buf, 0, readSize, size - readSize);
+        text = buf.toString('utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    let lines = text.split(/\r?\n/);
+    // A tail read starting mid-file cuts its first piece off mid-line.
+    if (startedMidFile)
+        lines = lines.slice(1);
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines = lines.slice(0, -1);
+    // Redact before splitting: a private key spans lines. An END still left has lost its BEGIN to the window cut.
+    const redacted = redactSecretsStrict(lines.join('\n')).replace(ORPHAN_KEY_END_RE, '[REDACTED]');
+    return redacted.split('\n').slice(-TAIL_MAX_LINES).map((line) => line.length > TAIL_MAX_LINE_CHARS ? `${line.slice(0, TAIL_MAX_LINE_CHARS)} [truncated]` : line);
+}
+function buildLogsSection(opts) {
+    const dir = path.join(opts.home, '.hippo', 'logs');
+    const names = listLogFileNames(dir);
+    const files = names.map((name) => {
+        const stat = fs.statSync(path.join(dir, name));
+        return { name, bytes: stat.size, modified: stat.mtime.toISOString() };
+    });
+    const logs = { dir: '~/.hippo/logs', files };
+    if (opts.includeLogs) {
+        const tails = {};
+        for (const name of names)
+            tails[name] = tailLogFile(path.join(dir, name));
+        logs['tails'] = tails;
+    }
+    return logs;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// The native realpath is the only form that exposes a short-name (8.3) or symlinked alias for what it is.
+function nativeRealPathKey(p) {
+    try {
+        const real = fs.realpathSync.native(p);
+        return process.platform === 'win32' ? real.toLowerCase() : real;
+    }
+    catch {
+        // A path that does not exist has no alias to find.
+        return null;
+    }
+}
+// Longest first: where one home form nests in another (a test home under the real one), swap the longer.
+function collectHomeForms(home, probes) {
+    const forms = new Set();
+    const add = (s) => { if (s.length >= 3)
+        forms.add(s); };
+    for (const base of [home, realpathOrResolve(home), os.homedir(), realpathOrResolve(os.homedir())]) {
+        add(base);
+        add(path.resolve(base));
+        if (process.platform === 'win32') {
+            add(base.replace(/\\/g, '/'));
+            add(path.resolve(base).replace(/\\/g, '/'));
+        }
+    }
+    // The alias (e.g. a short-name temp root) can sit above the probe itself, so walk ancestors and
+    // compare native realpaths rather than checking each probe alone.
+    const homeKeys = new Set([nativeRealPathKey(home), nativeRealPathKey(os.homedir())].filter((k) => k !== null));
+    for (const probe of probes) {
+        let dir = path.resolve(probe);
+        for (;;) {
+            const key = nativeRealPathKey(dir);
+            if (key !== null && homeKeys.has(key)) {
+                add(dir);
+                if (process.platform === 'win32')
+                    add(dir.replace(/\\/g, '/'));
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const f of [...forms].sort((a, b) => b.length - a.length)) {
+        const key = process.platform === 'win32' ? f.toLowerCase() : f;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(f);
+    }
+    return deduped;
+}
+function replaceHomeForms(text, forms) {
+    if (forms.length === 0)
+        return text;
+    // Stop only before another name character: "<home> now" and "<home>." swap, a longer user name ("<home>ty") does not.
+    const re = new RegExp(`(?:${forms.map(escapeRegExp).join('|')})(?![\\p{L}\\p{N}_])`, process.platform === 'win32' ? 'giu' : 'gu');
+    return text.replace(re, '~');
+}
+const URL_RE = /\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi;
+function redactUrlsInString(text) {
+    return text.replace(URL_RE, (match) => {
+        const scheme = match.slice(0, match.indexOf('://'));
+        try {
+            const url = new URL(match);
+            url.username = '';
+            url.password = '';
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        }
+        catch {
+            return `${scheme}://[REDACTED]`;
+        }
+    });
+}
+function redactString(text, homeForms) {
+    return replaceHomeForms(redactSecretsStrict(redactUrlsInString(text)), homeForms);
+}
+function redactStrings(value, homeForms) {
+    if (isJsonString(value))
+        return redactString(value, homeForms);
+    if (Array.isArray(value))
+        return value.map((v) => redactStrings(v, homeForms));
+    if (isJsonObject(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redactStrings(v, homeForms);
+        return out;
+    }
+    return value;
+}
+/** Read-only: builds one redacted support-ticket snapshot. Never reads a memory content column. */
+export function buildSupportBundle(opts) {
+    const bundle = {
+        format: 'hippo-support-bundle/1',
+        createdAt: opts.now.toISOString(),
+        hippo: opts.version,
+        runtime: buildRuntime(),
+        doctor: JSON.parse(JSON.stringify(runDoctor(opts))),
+        stores: buildStores(opts),
+        env: listSetEnvNames(),
+        logs: buildLogsSection(opts),
+    };
+    // Store paths found from the working folder arrive resolved; the global root arrives as HIPPO_HOME was typed, and log lines
+    // often quote the temp folder, which usually sits under the home.
+    const redacted = redactStrings(bundle, collectHomeForms(opts.home, [getGlobalRoot(), os.tmpdir()]));
+    // SAFETY: the value built above is always a JsonObject; redactStrings preserves object shape.
+    return redacted;
+}
+//# sourceMappingURL=support-bundle.js.map

package/dist/version.d.ts

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.47.0";
+export declare const PACKAGE_VERSION = "1.49.0";
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export declare function compareSemver(a: string, b: string): number;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.47.0';
+export const PACKAGE_VERSION = '1.49.0';
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export function compareSemver(a, b) {
     const parse = (v) => {

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.47.0",
+  "version": "1.49.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.47.0",
+  "version": "1.49.0",
   "type": "module",
   "description": "Hippo Memory plugin for OpenClaw - biologically-inspired agent memory",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.47.0",
+  "version": "1.49.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.47.0",
+  "version": "1.49.0",
   "description": "Biologically-inspired memory for AI agents. Zero runtime deps, SQLite, MCP server, and an opt-in hosted TypeSafe Jev reranker. Decay, retrieval strengthening, consolidation.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",
@@ -34,6 +34,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "oxlint",
+    "sbom": "node scripts/sbom.mjs",
     "audit:security": "npm audit --audit-level=high && npm --prefix ui audit --audit-level=high",
     "postinstall": "node scripts/postinstall.cjs",
     "smoke:pack": "node scripts/smoke-pack.mjs",