hippo-memory 2.0.0 → 2.1.0

package/dist/db/migrate.d.ts

@@ -3,9 +3,11 @@ export declare function getCurrentSchemaVersion(): number;
 /** Thrown by {@link assertBinaryCompatible}; doctor uses it to pick the upgrade fix over a generic permissions fix. */
 export declare class IncompatibleBinaryError extends Error {
 }
-/** Refuse a store stamped for a newer binary. Fails closed: runMigrations creates meta first, so a failed read is a real error. */
+/** Refuse a store stamped for a newer binary. Fails closed:
+ * runMigrations creates meta first, so a failed read is a real error. */
 export declare function assertBinaryCompatible(db: DatabaseSyncLike): void;
-/** The fast path's single probe: versions, the binary minimum, the FTS flag, and counts of the meta defaults and required objects. */
+/** The fast path's single probe: versions, the binary minimum, the
+ * FTS flag, and counts of the meta defaults and required objects. */
 export declare const SCHEMA_PROBE_SQL: string;
 /** What the probe of a current store read beyond the schema proof, so the same open need not read them again. */
 export interface OpenFacts {
@@ -13,13 +15,16 @@ export interface OpenFacts {
     readonly archiveTop: number;
     readonly hasMemories: boolean;
 }
-/** Brings the store to the current schema; returns the probe's facts when it was current already, null after any repair. */
+/** Brings the store to the current schema; returns the probe's
+ * facts when it was current already, null after any repair. */
 export declare function runMigrations(db: DatabaseSyncLike, hippoRoot?: string, busyWaitMs?: number): OpenFacts | null;
-/** Row counts of `memories` and its full-text index, which differ once the index drifts; null when either table is missing. */
+/** Row counts of `memories` and its full-text index, which differ
+ * once the index drifts; null when either table is missing. */
 export declare function ftsRowCounts(db: DatabaseSyncLike): {
     memories: number;
     fts: number;
 } | null;
-/** Re-syncs `memories_fts` with `memories` when their counts differ and returns whether it did; sleep runs it because a fast open does not. */
+/** Re-syncs `memories_fts` with `memories` when their counts differ and returns whether it did; sleep runs it
+ * because a fast open does not. */
 export declare function repairFtsDrift(db: DatabaseSyncLike): boolean;
 //# sourceMappingURL=migrate.d.ts.map

package/dist/db/migrate.js

@@ -4,7 +4,7 @@ import { importLegacyEmbeddingIndex } from './vector-store.js';
 import { execWithBusyRetry, withWriteScope } from './busy.js';
 import { tableExists } from './tables.js';
 import { ensureMetaTable, getMeta, getSchemaVersion, setMeta, setSchemaVersion } from './meta.js';
-import { MEMORIES_FTS_DDL, REQUIRED_SCHEMA_OBJECTS, ensureContinuityIndexes, ensureContinuityTables } from './continuity.js';
+import { MEMORIES_FTS_DDL, REQUIRED_SCHEMA_OBJECTS, ensureContinuityIndexes, ensureContinuityTables, } from './continuity.js';
 import { CURRENT_SCHEMA_VERSION, MIGRATIONS } from './migrations/index.js';
 import { placeholders } from '../util/sql.js';
 export function getCurrentSchemaVersion() {
@@ -15,11 +15,14 @@ export class IncompatibleBinaryError extends Error {
 }
 function assertMinBinary(minRequired) {
     if (minRequired && compareSemver(minRequired, PACKAGE_VERSION) > 0) {
-        throw new IncompatibleBinaryError(`hippo-memory: this database requires hippo-memory >= ${minRequired}, but the running binary is ${PACKAGE_VERSION}. ` +
-            `Upgrade hippo-memory to open it; an older binary does not know this schema and could expose private rows or damage the store.`);
+        throw new IncompatibleBinaryError(`hippo-memory: this database requires hippo-memory >= ` +
+            `${minRequired}, but the running binary is ${PACKAGE_VERSION}. ` +
+            `Upgrade hippo-memory to open it; an older binary does not know ` +
+            `this schema and could expose private rows or damage the store.`);
     }
 }
-/** Refuse a store stamped for a newer binary. Fails closed: runMigrations creates meta first, so a failed read is a real error. */
+/** Refuse a store stamped for a newer binary. Fails closed:
+ * runMigrations creates meta first, so a failed read is a real error. */
 export function assertBinaryCompatible(db) {
     assertMinBinary(getMeta(db, 'min_compatible_binary'));
 }
@@ -34,17 +37,20 @@ const META_DEFAULTS = [
 ];
 // Names come from our own constants and match \w+, so inlining them as literals is safe.
 const sqlList = (names) => names.map((n) => `'${n}'`).join(', ');
-/** The fast path's single probe: versions, the binary minimum, the FTS flag, and counts of the meta defaults and required objects. */
+const REQUIRED_OBJECTS = sqlList(REQUIRED_SCHEMA_OBJECTS);
+/** The fast path's single probe: versions, the binary minimum, the
+ * FTS flag, and counts of the meta defaults and required objects. */
 export const SCHEMA_PROBE_SQL = `SELECT
   (SELECT user_version FROM pragma_user_version) AS user_version,
   (SELECT value FROM meta WHERE key = 'schema_version') AS schema_version,
   (SELECT value FROM meta WHERE key = 'min_compatible_binary') AS min_binary,
   (SELECT value FROM meta WHERE key = 'fts5_available') AS fts5,
   (SELECT COUNT(*) FROM meta WHERE key IN (${sqlList(META_DEFAULTS.map(([key]) => key))})) AS meta_keys,
-  (SELECT COUNT(*) FROM sqlite_master WHERE type IN ('table', 'index') AND name IN (${sqlList(REQUIRED_SCHEMA_OBJECTS)})) AS objects,
+  (SELECT COUNT(*) FROM sqlite_master WHERE type IN ('table', 'index') AND name IN (${REQUIRED_OBJECTS})) AS objects,
   (SELECT MAX(id) FROM raw_archive) AS archive_top,
   (SELECT 1 FROM memories LIMIT 1) AS has_memories`;
-/** The probe's facts when the store is current and whole, so the open can skip every DDL statement; else null. Runs the binary check either way. */
+/** The probe's facts when the store is current and whole, so the open can skip every DDL statement; else null. Runs
+ * the binary check either way. */
 function currentStoreFacts(db) {
     let probe;
     try {
@@ -67,7 +73,8 @@ function currentStoreFacts(db) {
         && probe.fts5 === '1';
     return current ? { archiveTop: Number(probe.archive_top ?? 0), hasMemories: probe.has_memories !== null } : null;
 }
-/** Brings the store to the current schema; returns the probe's facts when it was current already, null after any repair. */
+/** Brings the store to the current schema; returns the probe's
+ * facts when it was current already, null after any repair. */
 export function runMigrations(db, hippoRoot, busyWaitMs) {
     const facts = currentStoreFacts(db);
     if (!facts)
@@ -122,14 +129,18 @@ function importLegacyVectors(db, hippoRoot) {
         importLegacyEmbeddingIndex(db, hippoRoot);
     }
     catch (err) {
-        log.warn(`embeddings.json import failed; the next open retries it (${errorMessage(err)})`, { hippoRoot });
+        log.warn(`embeddings.json import failed; the next open retries it (${errorMessage(err)})`, {
+            hippoRoot,
+            ...errorFields(err),
+        });
     }
 }
 function ensureMetaDefaults(db) {
     // Read-first: an already-current store has all 7 keys, so this is one SELECT and zero writes instead of 7 no-op
     // INSERT OR IGNOREs, each of which takes a RESERVED lock even when nothing changes.
     const keys = META_DEFAULTS.map(([key]) => key);
-    // SAFETY: the statement selects only the `key` column of `meta`, which is TEXT NOT NULL, so each row is { key: string }.
+    // SAFETY: the statement selects only the `key` column of `meta`, which is TEXT NOT NULL, so each row is { key: string
+    // }.
     const present = new Set(db
         .prepare(`SELECT key FROM meta WHERE key IN (${placeholders(keys.length)})`)
         .all(...keys)
@@ -153,7 +164,7 @@ function ensureOptionalFts(db) {
             log.warn(`full-text index not set up this open (${errorMessage(err)}); the next open retries`, errorFields(err));
             return;
         }
-        log.warn(`full-text index unavailable (${errorMessage(err)}); search falls back to slower LIKE matching`);
+        log.warn(`full-text index unavailable (${errorMessage(err)}); search falls back to slower LIKE matching`, errorFields(err));
         writeFtsFlag(db, '0');
         return;
     }
@@ -164,7 +175,8 @@ function writeFtsFlag(db, flag) {
     if (getMeta(db, 'fts5_available') !== flag)
         setMeta(db, 'fts5_available', flag);
 }
-/** Row counts of `memories` and its full-text index, which differ once the index drifts; null when either table is missing. */
+/** Row counts of `memories` and its full-text index, which differ
+ * once the index drifts; null when either table is missing. */
 export function ftsRowCounts(db) {
     if (!tableExists(db, 'memories_fts') || !tableExists(db, 'memories'))
         return null;
@@ -176,7 +188,8 @@ export function ftsRowCounts(db) {
     const fts = db.prepare(`SELECT COUNT(*) AS c FROM ${ftsTable}`).get()?.c ?? 0;
     return { memories: Number(memories), fts: Number(fts) };
 }
-/** Re-syncs `memories_fts` with `memories` when their counts differ and returns whether it did; sleep runs it because a fast open does not. */
+/** Re-syncs `memories_fts` with `memories` when their counts differ and returns whether it did; sleep runs it
+ * because a fast open does not. */
 export function repairFtsDrift(db) {
     const counts = ftsRowCounts(db);
     if (counts === null || counts.memories === counts.fts)

package/dist/db/migrations/index.d.ts

@@ -1,5 +1,5 @@
 import type { Migration } from './types.js';
-export declare const CURRENT_SCHEMA_VERSION = 55;
+export declare const CURRENT_SCHEMA_VERSION = 56;
 /** Every schema migration in version order; runMigrations applies each one above the stored version. */
 export declare const MIGRATIONS: Migration[];
 //# sourceMappingURL=index.d.ts.map

package/dist/db/migrations/index.js

@@ -53,7 +53,8 @@ import { v52 } from './v52.js';
 import { v53 } from './v53.js';
 import { v54 } from './v54.js';
 import { v55 } from './v55.js';
-export const CURRENT_SCHEMA_VERSION = 55;
+import { v56 } from './v56.js';
+export const CURRENT_SCHEMA_VERSION = 56;
 /** Every schema migration in version order; runMigrations applies each one above the stored version. */
 export const MIGRATIONS = [
     v01,
@@ -111,5 +112,6 @@ export const MIGRATIONS = [
     v53,
     v54,
     v55,
+    v56,
 ];
 //# sourceMappingURL=index.js.map

package/dist/db/migrations/types.d.ts

@@ -1,5 +1,6 @@
 import type { DatabaseSyncLike } from '../sqlite.js';
-/** Context for migrations that need to know where the store lives. hippoRoot is the store directory (e.g. `<project>/.hippo`);
+/** Context for migrations that need to know where the store lives. hippoRoot is the store directory (e.g.
+ * `<project>/.hippo`);
  * undefined only for callers that open a DB without a filesystem store. */
 export type MigrationContext = {
     hippoRoot?: string;

package/dist/db/migrations/v12.js

@@ -5,7 +5,8 @@ export const v12 = {
         if (!tableHasColumn(db, 'memories', 'extracted_from')) {
             db.exec(`ALTER TABLE memories ADD COLUMN extracted_from TEXT`);
         }
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_extracted_from ON memories(extracted_from) WHERE extracted_from IS NOT NULL`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_extracted_from ` +
+            `ON memories(extracted_from) WHERE extracted_from IS NOT NULL`);
     },
 };
 //# sourceMappingURL=v12.js.map

package/dist/db/migrations/v14.js

@@ -48,7 +48,8 @@ export const v14 = {
         if (!tableHasColumn(db, 'memories', 'owner')) {
             db.exec(`ALTER TABLE memories ADD COLUMN owner TEXT`);
         }
-        // SHORTCUT: artifact_ref has no index, so connector deletes and vault lookups scan the tenant; the index is held until a schema migration is approved.
+        // SHORTCUT: artifact_ref has no index, so connector deletes and vault lookups scan the tenant; the index is held
+        // until a schema migration is approved.
         if (!tableHasColumn(db, 'memories', 'artifact_ref')) {
             db.exec(`ALTER TABLE memories ADD COLUMN artifact_ref TEXT`);
         }

package/dist/db/migrations/v15.js

@@ -1,8 +1,10 @@
 export const v15 = {
     version: 15,
     up: (db) => {
-        // Close the NULL-kind bypass: v14 triggers used `WHEN NEW.kind IS NOT NULL AND ...`, so kind=NULL slipped past; now `IS NULL OR NOT IN (...)` rejects it.
-        // Add UNIQUE(memory_id, archived_at) to raw_archive so re-archiving in the same instant cannot yield ambiguous audit rows (per-id history stays allowed).
+        // Close the NULL-kind bypass: v14 triggers used `WHEN NEW.kind IS NOT NULL AND ...`, so kind=NULL slipped past;
+        // now `IS NULL OR NOT IN (...)` rejects it.
+        // Add UNIQUE(memory_id, archived_at) to raw_archive so re-archiving in the same instant cannot yield ambiguous
+        // audit rows (per-id history stays allowed).
         db.exec(`DROP TRIGGER IF EXISTS trg_memories_kind_check_insert`);
         db.exec(`DROP TRIGGER IF EXISTS trg_memories_kind_check_update`);
         db.exec(`

package/dist/db/migrations/v16.js

@@ -48,10 +48,13 @@ export const v16 = {
         // Composite indexes for recall hot paths. Leading column is tenant_id so
         // single-tenant lookups are O(log n).
         db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_tenant_created ON memories(tenant_id, created)`);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_working_memory_tenant ON working_memory(tenant_id, importance DESC, created_at DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_working_memory_tenant ` +
+            `ON working_memory(tenant_id, importance DESC, created_at DESC)`);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_consolidation_runs_tenant_ts ON consolidation_runs(tenant_id, timestamp DESC)`);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_task_snapshots_tenant_status ON task_snapshots(tenant_id, status, updated_at DESC)`);
-        // Stub auth: api_keys (scrypt-hashed; plaintext returned once) and audit_log (append-only mutation trail), both with tenant_id from day 1
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_task_snapshots_tenant_status ` +
+            `ON task_snapshots(tenant_id, status, updated_at DESC)`);
+        // Stub auth: api_keys (scrypt-hashed; plaintext returned once) and audit_log (append-only mutation trail), both
+        // with tenant_id from day 1
         // so future multi-tenant enforcement is a config flip, not a re-migration.
         db.exec(CREATE_TABLE_API_KEYS_SQL);
         db.exec(CREATE_INDEX_IDX_API_KEYS_TENANT_ACTIVE_SQL);

package/dist/db/migrations/v17.js

@@ -9,7 +9,8 @@ export const v17 = {
           memory_id TEXT
         )
       `);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_slack_event_log_memory ON slack_event_log(memory_id) WHERE memory_id IS NOT NULL`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_slack_event_log_memory ` +
+            `ON slack_event_log(memory_id) WHERE memory_id IS NOT NULL`);
         db.exec(`
         CREATE TABLE IF NOT EXISTS slack_cursors (
           tenant_id TEXT NOT NULL,

package/dist/db/migrations/v19.js

@@ -2,8 +2,10 @@ import { tableHasColumn } from '../tables.js';
 export const v19 = {
     version: 19,
     up: (db) => {
-        // Widen slack_dlq with bucketing, retry tracking and the signature/timestamp pair `hippo slack dlq replay` re-verifies;
-        // ALTER ADD COLUMN with DEFAULT is non-destructive, so legacy rows take the defaults. Idempotent via tableHasColumn().
+        // Widen slack_dlq with bucketing, retry tracking and the signature/timestamp pair `hippo slack dlq replay`
+        // re-verifies;
+        // ALTER ADD COLUMN with DEFAULT is non-destructive, so legacy rows take the defaults. Idempotent via
+        // tableHasColumn().
         if (!tableHasColumn(db, 'slack_dlq', 'team_id')) {
             db.exec(`ALTER TABLE slack_dlq ADD COLUMN team_id TEXT`);
         }

package/dist/db/migrations/v20.js

@@ -2,7 +2,8 @@ import { warnDamagedColumn } from '../../util/stored-json.js';
 export const v20 = {
     version: 20,
     up: (db) => {
-        // GDPR Path A backfill: redact every existing raw_archive.payload_json to the metadata-only shape (store/raw-archive.ts); unparseable legacy JSON
+        // GDPR Path A backfill: redact every existing raw_archive.payload_json to the metadata-only shape
+        // (store/raw-archive.ts); unparseable legacy JSON
         // gets tenant_id='unknown', kind='unknown'. The audit_log remains the compliance record.
         // SAFETY: rows' shape matches the four columns named in the SELECT above.
         const rows = db

package/dist/db/migrations/v22.js

@@ -44,8 +44,10 @@ const BACKFILL_SESSION_HANDOFFS_TENANT_SQL = `
 export const v22 = {
     version: 22,
     up: (db) => {
-        // session_events and session_handoffs missed the v16 tenant migration (cross-tenant leak): add tenant_id (NOT NULL DEFAULT 'default') backfilled from
-        // task_snapshots when unambiguous, plus a scope column. Re-run v4/v5 CREATE IF NOT EXISTS first so a partial-init store isn't stamped v22 without tables.
+        // session_events and session_handoffs missed the v16 tenant migration (cross-tenant leak): add tenant_id (NOT
+        // NULL DEFAULT 'default') backfilled from
+        // task_snapshots when unambiguous, plus a scope column. Re-run v4/v5 CREATE IF NOT EXISTS first so a partial-init
+        // store isn't stamped v22 without tables.
         db.exec(CREATE_TABLE_SESSION_EVENTS_SQL);
         if (!tableHasColumn(db, 'session_events', 'tenant_id')) {
             db.exec(`ALTER TABLE session_events ADD COLUMN tenant_id TEXT NOT NULL DEFAULT 'default'`);
@@ -59,12 +61,16 @@ export const v22 = {
         if (!tableHasColumn(db, 'session_handoffs', 'scope')) {
             db.exec(`ALTER TABLE session_handoffs ADD COLUMN scope TEXT`);
         }
-        // Smart backfill: a row whose session_id maps to exactly one tenant in task_snapshots inherits it; ambiguous or unmapped rows keep 'default'.
-        // The COUNT(DISTINCT) gate is load-bearing: without it a session_id spanning tenants would silently pick whichever group came first.
+        // Smart backfill: a row whose session_id maps to exactly one tenant in task_snapshots inherits it; ambiguous or
+        // unmapped rows keep 'default'.
+        // The COUNT(DISTINCT) gate is load-bearing: without it a session_id spanning tenants would silently pick
+        // whichever group came first.
         db.exec(BACKFILL_SESSION_EVENTS_TENANT_SQL);
         db.exec(BACKFILL_SESSION_HANDOFFS_TENANT_SQL);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_events_tenant_session ON session_events(tenant_id, session_id, created_at DESC, id DESC)`);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_session ON session_handoffs(tenant_id, session_id, created_at DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_events_tenant_session ` +
+            `ON session_events(tenant_id, session_id, created_at DESC, id DESC)`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_session ` +
+            `ON session_handoffs(tenant_id, session_id, created_at DESC)`);
     },
 };
 //# sourceMappingURL=v22.js.map

package/dist/db/migrations/v23.js

@@ -2,7 +2,8 @@ import { tableHasColumn, tableExists } from '../tables.js';
 export const v23 = {
     version: 23,
     up: (db) => {
-        // task_snapshots: add scope so all three continuity tables carry it; self-heal partial-init stores via CREATE TABLE IF NOT EXISTS.
+        // task_snapshots: add scope so all three continuity tables carry it; self-heal partial-init stores via CREATE
+        // TABLE IF NOT EXISTS.
         db.exec(`
         CREATE TABLE IF NOT EXISTS task_snapshots (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -20,8 +21,10 @@ export const v23 = {
         if (!tableHasColumn(db, 'task_snapshots', 'scope')) {
             db.exec(`ALTER TABLE task_snapshots ADD COLUMN scope TEXT`);
         }
-        // Quarantine pre-existing continuity rows with NULL scope as 'unknown:legacy' so the recall default-deny filter excludes them for no-scope callers;
-        // new rows legitimately carry NULL. UPDATE only tables that exist (v22 healing is skipped on some paths); WHERE scope IS NULL keeps it idempotent.
+        // Quarantine pre-existing continuity rows with NULL scope as 'unknown:legacy' so the recall default-deny filter
+        // excludes them for no-scope callers;
+        // new rows legitimately carry NULL. UPDATE only tables that exist (v22 healing is skipped on some paths); WHERE
+        // scope IS NULL keeps it idempotent.
         if (tableExists(db, 'task_snapshots')) {
             db.exec(`UPDATE task_snapshots SET scope = 'unknown:legacy' WHERE scope IS NULL`);
         }

package/dist/db/migrations/v24.js

@@ -56,18 +56,21 @@ export const v24 = {
         // GitHub connector schema.
         // Six tables + a min_compatible_binary meta row for rollback safety.
         db.exec(CREATE_TABLE_GITHUB_EVENT_LOG_SQL);
-        db.exec(`CREATE INDEX IF NOT EXISTS idx_github_event_log_memory ON github_event_log(memory_id) WHERE memory_id IS NOT NULL`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_github_event_log_memory ` +
+            `ON github_event_log(memory_id) WHERE memory_id IS NOT NULL`);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_github_event_log_delivery ON github_event_log(delivery_id)`);
         db.exec(CREATE_TABLE_GITHUB_CURSORS_SQL);
         db.exec(CREATE_TABLE_GITHUB_DLQ_SQL);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_github_dlq_tenant_received ON github_dlq(tenant_id, received_at)`);
         db.exec(CREATE_TABLE_GITHUB_INSTALLATIONS_SQL);
-        // PAT-mode multi-tenant routing: maps repo_full_name to a tenant when the webhook envelope has no `installation` field.
+        // PAT-mode multi-tenant routing: maps repo_full_name to a tenant when the webhook envelope has no `installation`
+        // field.
         // Composite PK so one repo can be visible to several tenants; the collision is on the (repo, tenant) pair.
         db.exec(CREATE_TABLE_GITHUB_REPOSITORIES_SQL);
         // Rollback-safety guard: an older binary lacks the *:private:* default-deny and would leak
         // github:private:* rows; the startup guard refuses a DB whose min_compatible_binary is newer.
-        db.prepare(`INSERT INTO meta(key, value) VALUES('min_compatible_binary', ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run('1.2.1');
+        db.prepare(`INSERT INTO meta(key, value) VALUES('min_compatible_binary', ?) ` +
+            `ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run('1.2.1');
     },
 };
 //# sourceMappingURL=v24.js.map

package/dist/db/migrations/v25.js

@@ -2,7 +2,8 @@ import { tableHasColumn } from '../tables.js';
 export const v25 = {
     version: 25,
     up: (db) => {
-        // DAG-aware recall: three additive optional columns cache summary metadata so the assembler need not re-walk the DAG.
+        // DAG-aware recall: three additive optional columns cache summary metadata so the assembler need not re-walk the
+        // DAG.
         // No min_compatible_binary bump: older binaries see them as NULL / 0 and behave as before.
         if (!tableHasColumn(db, 'memories', 'descendant_count')) {
             db.exec(`ALTER TABLE memories ADD COLUMN descendant_count INTEGER NOT NULL DEFAULT 0`);
@@ -13,7 +14,8 @@ export const v25 = {
         if (!tableHasColumn(db, 'memories', 'latest_at')) {
             db.exec(`ALTER TABLE memories ADD COLUMN latest_at TEXT`);
         }
-        // Backfill descendant_count for existing level-2 summary rows via dag_parent_id = summary id; level-3 (entity profiles) is not built, so it stays 0.
+        // Backfill descendant_count for existing level-2 summary rows via dag_parent_id = summary id; level-3 (entity
+        // profiles) is not built, so it stays 0.
         db.exec(`
         UPDATE memories
            SET descendant_count = (

package/dist/db/migrations/v26.js

@@ -2,8 +2,10 @@ import { tableHasColumn, tableExists } from '../tables.js';
 export const v26 = {
     version: 26,
     up: (db) => {
-        // Add api_keys.role for the admin/member split gating /v1/sleep; existing keys backfill to 'admin' via DEFAULT. No min_compatible_binary bump.
-        // Guard on tableExists: a partial-v16 DB without api_keys would crash this ALTER and block later migrations (v27 heals it with role present).
+        // Add api_keys.role for the admin/member split gating /v1/sleep; existing keys backfill to 'admin' via DEFAULT.
+        // No min_compatible_binary bump.
+        // Guard on tableExists: a partial-v16 DB without api_keys would crash this ALTER and block later migrations (v27
+        // heals it with role present).
         if (tableExists(db, 'api_keys') && !tableHasColumn(db, 'api_keys', 'role')) {
             db.exec(`ALTER TABLE api_keys ADD COLUMN role TEXT NOT NULL DEFAULT 'admin'`);
         }

package/dist/db/migrations/v27.js

@@ -2,8 +2,10 @@ import { tableHasColumn, tableExists } from '../tables.js';
 export const v27 = {
     version: 27,
     up: (db) => {
-        // Self-heal: re-assert the v16 schema (api_keys + audit_log) on stores stamped past v16 whose tables are missing (dropped table or old-backup restore).
-        // All CREATE IF NOT EXISTS, so a no-op for healthy stores; includes the role column so v26's ALTER is not needed on this path.
+        // Self-heal: re-assert the v16 schema (api_keys + audit_log) on stores stamped past v16 whose tables are missing
+        // (dropped table or old-backup restore).
+        // All CREATE IF NOT EXISTS, so a no-op for healthy stores; includes the role column so v26's ALTER is not needed
+        // on this path.
         db.exec(`
         CREATE TABLE IF NOT EXISTS api_keys (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -32,7 +34,8 @@ export const v27 = {
         )
       `);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_audit_log_tenant_ts ON audit_log(tenant_id, ts DESC)`);
-        // Belt-and-braces: backfill role on an api_keys table that exists without it (v16-shape table that v26's ALTER skipped on an earlier broken run).
+        // Belt-and-braces: backfill role on an api_keys table that exists without it (v16-shape table that v26's ALTER
+        // skipped on an earlier broken run).
         if (tableExists(db, 'api_keys') && !tableHasColumn(db, 'api_keys', 'role')) {
             db.exec(`ALTER TABLE api_keys ADD COLUMN role TEXT NOT NULL DEFAULT 'admin'`);
         }

package/dist/db/migrations/v28.js

@@ -2,8 +2,10 @@ import { tableHasColumn } from '../tables.js';
 export const v28 = {
     version: 28,
     up: (db) => {
-        // Dirty-flag persistence for level-2 DAG summaries; dag_level_3_built_at lands now so the entity-profile path needs no second migration.
-        // Columns are additive and DEFAULTed/nullable, so no min_compatible_binary bump. Column-only guard: memories comes from v1 and always exists.
+        // Dirty-flag persistence for level-2 DAG summaries; dag_level_3_built_at lands now so the entity-profile path
+        // needs no second migration.
+        // Columns are additive and DEFAULTed/nullable, so no min_compatible_binary bump. Column-only guard: memories
+        // comes from v1 and always exists.
         if (!tableHasColumn(db, 'memories', 'summary_dirty')) {
             db.exec(`ALTER TABLE memories ADD COLUMN summary_dirty INTEGER NOT NULL DEFAULT 0`);
         }

package/dist/db/migrations/v29.js

@@ -52,8 +52,10 @@ const CREATE_TRIGGER_TRG_PREDICTIONS_TENANT_MATCH_UPDATE_SQL = `
 export const v29 = {
     version: 29,
     up: (db) => {
-        // Prediction first-class object: claim_text is duplicated so deleting the memory loses nothing; memory_id is NULLABLE ON DELETE SET NULL.
-        // Tenant-match triggers replace a composite FK, which is incompatible with ON DELETE SET NULL; closure_state is CHECKed to open|closed|closed-unknown.
+        // Prediction first-class object: claim_text is duplicated so deleting the memory loses nothing; memory_id is
+        // NULLABLE ON DELETE SET NULL.
+        // Tenant-match triggers replace a composite FK, which is incompatible with ON DELETE SET NULL; closure_state is
+        // CHECKed to open|closed|closed-unknown.
         if (!tableExists(db, 'predictions')) {
             db.exec(CREATE_TABLE_PREDICTIONS_SQL);
             db.exec(CREATE_INDEX_IDX_PREDICTIONS_TENANT_CLASS_SQL);

package/dist/db/migrations/v30.js

@@ -48,7 +48,8 @@ const TRG_DECISIONS_TENANT_MATCH_UPDATE = `
             END;
           END
         `;
-// Cross-tenant safety vs the successor decision (self-FK): superseded_by is set only via the supersede UPDATE and the successor,
+// Cross-tenant safety vs the successor decision (self-FK): superseded_by is set only via the supersede UPDATE and the
+// successor,
 // which already exists in the same transaction when this fires, must share the tenant.
 const TRG_DECISIONS_SUPERSEDE_TENANT_MATCH_UPDATE = `
           CREATE TRIGGER IF NOT EXISTS trg_decisions_supersede_tenant_match_update
@@ -65,8 +66,10 @@ const TRG_DECISIONS_SUPERSEDE_TENANT_MATCH_UPDATE = `
 export const v30 = {
     version: 30,
     up: (db) => {
-        // Decision first-class object, the source of truth for `hippo decide`; the memory mirror serves recall only, memory_id NULLABLE ON DELETE SET NULL.
-        // status active|superseded|closed (closed = retired without successor); a same-tenant trigger on superseded_by blocks cross-tenant supersession.
+        // Decision first-class object, the source of truth for `hippo decide`; the memory mirror serves recall only,
+        // memory_id NULLABLE ON DELETE SET NULL.
+        // status active|superseded|closed (closed = retired without successor); a same-tenant trigger on superseded_by
+        // blocks cross-tenant supersession.
         if (!tableExists(db, 'decisions')) {
             db.exec(DECISIONS_TABLE);
             db.exec(IDX_DECISIONS_TENANT_STATUS);

package/dist/db/migrations/v31.js

@@ -50,8 +50,10 @@ const CREATE_TRIGGER_TRG_INCIDENTS_TENANT_MATCH_UPDATE_SQL = `
 export const v31 = {
     version: 31,
     up: (db) => {
-        // Incident first-class object: a postmortem capsule with an open -> resolved -> closed lifecycle (no supersede) and linked receipts (JSON ids).
-        // Memory mirror is for recall only (memory_id NULLABLE ON DELETE SET NULL); BEFORE INSERT/UPDATE triggers mirror the v30 tenant-match triggers.
+        // Incident first-class object: a postmortem capsule with an open -> resolved -> closed lifecycle (no supersede)
+        // and linked receipts (JSON ids).
+        // Memory mirror is for recall only (memory_id NULLABLE ON DELETE SET NULL); BEFORE INSERT/UPDATE triggers mirror
+        // the v30 tenant-match triggers.
         if (!tableExists(db, 'incidents')) {
             db.exec(CREATE_TABLE_INCIDENTS_SQL);
             db.exec(CREATE_INDEX_IDX_INCIDENTS_TENANT_STATUS_SQL);

package/dist/db/migrations/v32.js

@@ -52,7 +52,8 @@ const TRG_PROCESSES_TENANT_MATCH_UPDATE = `
             END;
           END
         `;
-// Cross-tenant safety vs the successor process (self-FK; mirrors the v30 supersede trigger): superseded_by is set only via the supersede UPDATE
+// Cross-tenant safety vs the successor process (self-FK; mirrors the v30 supersede trigger): superseded_by is set only
+// via the supersede UPDATE
 // and the successor, already present in the same transaction, must share the tenant.
 const TRG_PROCESSES_SUPERSEDE_TENANT_MATCH_UPDATE = `
           CREATE TRIGGER IF NOT EXISTS trg_processes_supersede_tenant_match_update
@@ -69,8 +70,10 @@ const TRG_PROCESSES_SUPERSEDE_TENANT_MATCH_UPDATE = `
 export const v32 = {
     version: 32,
     up: (db) => {
-        // Process first-class object (living process map): it evolves via the v30 supersede path, each version recording change_summary and full steps (JSON).
-        // Combines the v31 tenant-match trigger pair with the v30 superseded_by self-FK; version is server-derived (predecessor + 1); only an active head closes.
+        // Process first-class object (living process map): it evolves via the v30 supersede path, each version recording
+        // change_summary and full steps (JSON).
+        // Combines the v31 tenant-match trigger pair with the v30 superseded_by self-FK; version is server-derived
+        // (predecessor + 1); only an active head closes.
         if (!tableExists(db, 'processes')) {
             db.exec(PROCESSES_TABLE);
             db.exec(IDX_PROCESSES_TENANT_STATUS);

package/dist/db/migrations/v33.js

@@ -75,8 +75,10 @@ const TRG_POLICIES_SUPERSEDE_TENANT_MATCH_UPDATE = `
 export const v33 = {
     version: 33,
     up: (db) => {
-        // Policy first-class object: a rule in force over an effective-time range (valid_to nullable = open-ended); supersedes like v32 processes.
-        // Dates are ISO-8601 (toISOString) at the store boundary so values sort lexically and the half-open [valid_from, valid_to) as-of comparison is correct.
+        // Policy first-class object: a rule in force over an effective-time range (valid_to nullable = open-ended);
+        // supersedes like v32 processes.
+        // Dates are ISO-8601 (toISOString) at the store boundary so values sort lexically and the half-open [valid_from,
+        // valid_to) as-of comparison is correct.
         if (!tableExists(db, 'policies')) {
             db.exec(POLICIES_TABLE);
             db.exec(IDX_POLICIES_TENANT_STATUS);

package/dist/db/migrations/v34.js

@@ -69,7 +69,8 @@ const TRG_SKILLS_SUPERSEDE_TENANT_MATCH_UPDATE = `
 export const v34 = {
     version: 34,
     up: (db) => {
-        // Skill first-class object: `instructions` plus optional `trigger_text`, superseding like v32 processes; exportSkills writes it to AGENTS.md / CLAUDE.md.
+        // Skill first-class object: `instructions` plus optional `trigger_text`, superseding like v32 processes;
+        // exportSkills writes it to AGENTS.md / CLAUDE.md.
         // The column is `trigger_text`, not `trigger`, because TRIGGER is a SQLite reserved keyword.
         if (!tableExists(db, 'skills')) {
             db.exec(SKILLS_TABLE);

package/dist/db/migrations/v35.js

@@ -72,7 +72,8 @@ const TRG_PROJECT_BRIEFS_SUPERSEDE_TENANT_MATCH_UPDATE = `
 export const v35 = {
     version: 35,
     up: (db) => {
-        // project_brief first-class object: repo-scoped `summary` superseding like v34 skills; refreshBrief (objects/project-briefs.ts) builds it from receipts.
+        // project_brief first-class object: repo-scoped `summary` superseding like v34 skills; refreshBrief
+        // (objects/project-briefs.ts) builds it from receipts.
         // The schema needs only `repo`; column names were checked against SQLite reserved words.
         if (!tableExists(db, 'project_briefs')) {
             db.exec(PROJECT_BRIEFS_TABLE);

package/dist/db/migrations/v36.js

@@ -72,7 +72,8 @@ const TRG_CUSTOMER_NOTES_SUPERSEDE_TENANT_MATCH_UPDATE = `
 export const v36 = {
     version: 36,
     up: (db) => {
-        // customer_note first-class object: a note on a customer, superseding like v35 project_briefs; `customer` is a free-form id (no FK: no entities table).
+        // customer_note first-class object: a note on a customer, superseding like v35 project_briefs; `customer` is a
+        // free-form id (no FK: no entities table).
         // Many notes per customer, each its own supersede chain. Column names were checked against SQLite reserved words.
         if (!tableExists(db, 'customer_notes')) {
             db.exec(CUSTOMER_NOTES_TABLE);

package/dist/db/migrations/v37.js

@@ -41,7 +41,8 @@ const GRAPH_EXTRACTION_QUEUE_TABLE = `
             FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
           )
         `;
-// entities guard: source_kind must equal the FK'd memory's actual kind (raw or a lying source_kind ABORTs) and tenant must match,
+// entities guard: source_kind must equal the FK'd memory's actual kind (raw or a lying source_kind ABORTs) and tenant
+// must match,
 // on INSERT and on UPDATE (when memory_id/source_kind/tenant_id change).
 const TRG_ENTITIES_CONSOLIDATED_ONLY_INSERT = `
           CREATE TRIGGER IF NOT EXISTS trg_entities_consolidated_only_insert
@@ -138,7 +139,8 @@ const TRG_GRAPH_QUEUE_CONSOLIDATED_ONLY_UPDATE = `
             END;
           END
         `;
-// Reverse guard: graph triggers fire only on graph-table writes, so reclassifying an indexed memory to raw (or tenant) would break the no-raw invariant.
+// Reverse guard: graph triggers fire only on graph-table writes, so reclassifying an indexed memory to raw (or tenant)
+// would break the no-raw invariant.
 // Block both while the graph references the memory; the EXISTS checks run only when kind becomes raw or tenant changes.
 const TRG_MEMORIES_GRAPH_REFERENCED_GUARD = `
           CREATE TRIGGER IF NOT EXISTS trg_memories_graph_referenced_guard
@@ -153,7 +155,8 @@ const TRG_MEMORIES_GRAPH_REFERENCED_GUARD = `
             SELECT RAISE(ABORT, 'cannot change the kind or tenant of a memory while the graph references it (E3.3 graph-on-consolidated guard); a graph-referenced memory is immutable in kind/tenant - rebuild/remove the graph rows first, or rebuild them after supersession');
           END
         `;
-// Second reverse guard: the entity UPDATE trigger does not re-validate existing relations, so a cross-tenant entity move would leave a tenant-A relation
+// Second reverse guard: the entity UPDATE trigger does not re-validate existing relations, so a cross-tenant entity
+// move would leave a tenant-A relation
 // pointing at a tenant-B entity. Block the tenant move while any relation references the entity.
 const TRG_ENTITIES_NO_TENANT_MOVE_WHEN_REFERENCED = `
           CREATE TRIGGER IF NOT EXISTS trg_entities_no_tenant_move_when_referenced
@@ -167,8 +170,10 @@ const TRG_ENTITIES_NO_TENANT_MOVE_WHEN_REFERENCED = `
 export const v37 = {
     version: 37,
     up: (db) => {
-        // Graph-on-consolidated guard: entities, relations and graph_extraction_queue may reference only consolidated memories (distilled|superseded), never raw.
-        // The kind match needs a subquery, so it is a BEFORE INSERT and UPDATE trigger (INSERT-only is bypassable). rel_type avoids the reserved word REFERENCES.
+        // Graph-on-consolidated guard: entities, relations and graph_extraction_queue may reference only consolidated
+        // memories (distilled|superseded), never raw.
+        // The kind match needs a subquery, so it is a BEFORE INSERT and UPDATE trigger (INSERT-only is bypassable).
+        // rel_type avoids the reserved word REFERENCES.
         if (!tableExists(db, 'entities')) {
             db.exec(ENTITIES_TABLE);
             db.exec(`CREATE INDEX IF NOT EXISTS idx_entities_tenant ON entities(tenant_id)`);