hippo-memory 1.72.0 → 2.1.0

package/dist/core/search-types.js

@@ -1,4 +1,15 @@
 export const DEFAULT_RECALL_BUDGET = 4000;
 // Local memories outrank global ones by this factor; getContext applies it as a 1/x global discount.
 export const DEFAULT_LOCAL_BUMP = 1.2;
+// The relevance side of the MMR relevance-versus-diversity trade; config and hybrid recall both default to it.
+export const DEFAULT_MMR_LAMBDA = 0.7;
+// A recorded conflict peer in the same result list is cut to this share of its score.
+export const CONFLICT_PEER_MULTIPLIER = 0.3;
+// The value-aware clamp is wider than the always-on outcome nudge, so outcome history can decide the order.
+export const VALUE_MULT_SLOPE = 0.3;
+export const VALUE_MULT_MIN = 0.7;
+export const VALUE_MULT_MAX = 1.3;
+export const UTILITY_LENGTH_PENALTY_CAP = 0.3;
+export const UTILITY_LENGTH_TOKENS = 10000;
+export const SALIENCE_MIN_MULTIPLIER = 0.5;
 //# sourceMappingURL=search-types.js.map

package/dist/dashboard/dashboard-actions.d.ts

@@ -12,9 +12,9 @@ export interface ActionResult {
 /** Sets `pinned`; the audit row says `remember` with actor `dashboard`, the same op the old star toggle wrote. */
 export declare function pinMemory(hippoRoot: string, tenantId: string, rawId: string, body: ActionBody): ActionResult;
 /** Marks a memory wrong, the same signal as `hippo outcome --bad`. */
-export declare function markWrong(hippoRoot: string, tenantId: string, rawId: string): ActionResult;
+export declare function markWrong(hippoRoot: string, tenantId: string, rawId: string): Promise<ActionResult>;
 /** Deletes a memory like `hippo forget`; a raw receipt is append-only and answers 409 with the archive hint. */
-export declare function forgetMemory(hippoRoot: string, tenantId: string, rawId: string): ActionResult;
+export declare function forgetMemory(hippoRoot: string, tenantId: string, rawId: string): Promise<ActionResult>;
 /** Keeps one side of an open conflict and weakens the other; every refusal maps to its own status. */
 export declare function resolveOpenConflict(hippoRoot: string, tenantId: string, conflictId: number, body: ActionBody): ActionResult;
 //# sourceMappingURL=dashboard-actions.d.ts.map

package/dist/dashboard/dashboard-actions.js

@@ -5,6 +5,7 @@ import { RawAppendOnlyError } from '../core/raw-append-only.js';
 import { listTouchableConflicts, resolveConflict } from '../store/conflicts.js';
 import { readEntry } from '../store/entry-reads.js';
 import { writeEntry } from '../store/entry-writes.js';
+import { sqliteStore } from '../store/sqlite/store.js';
 import { ParamError, parseMemoryId } from './dashboard-params.js';
 import { isLiveMemory } from './dashboard-snapshot.js';
 const ACTOR = 'dashboard';
@@ -29,25 +30,35 @@ export function pinMemory(hippoRoot, tenantId, rawId, body) {
     return { status: 200, body: null, changed: true, entry: next };
 }
 /** Marks a memory wrong, the same signal as `hippo outcome --bad`. */
-export function markWrong(hippoRoot, tenantId, rawId) {
+export async function markWrong(hippoRoot, tenantId, rawId) {
     const id = parseMemoryId(rawId);
     if (liveEntry(hippoRoot, tenantId, id) === null)
         return notFound();
-    const ctx = { hippoRoot, tenantId, actor: api.adminActor(ACTOR) };
+    const ctx = {
+        hippoRoot,
+        tenantId,
+        actor: api.adminActor(ACTOR),
+        store: sqliteStore(hippoRoot),
+    };
     // outcome() answers `applied: 0` for a missing or other-tenant id instead of throwing.
-    if (api.outcome(ctx, [id], false).applied === 0)
+    if ((await api.outcome(ctx, [id], false)).applied === 0)
         return notFound();
     const entry = readEntry(hippoRoot, id, tenantId);
     return entry === null ? notFound() : { status: 200, body: null, changed: true, entry };
 }
 /** Deletes a memory like `hippo forget`; a raw receipt is append-only and answers 409 with the archive hint. */
-export function forgetMemory(hippoRoot, tenantId, rawId) {
+export async function forgetMemory(hippoRoot, tenantId, rawId) {
     const id = parseMemoryId(rawId);
     if (liveEntry(hippoRoot, tenantId, id) === null)
         return notFound();
-    const ctx = { hippoRoot, tenantId, actor: api.adminActor(ACTOR) };
+    const ctx = {
+        hippoRoot,
+        tenantId,
+        actor: api.adminActor(ACTOR),
+        store: sqliteStore(hippoRoot),
+    };
     try {
-        const done = api.forget(ctx, id);
+        const done = await api.forget(ctx, id);
         return { status: 200, body: done, changed: true };
     }
     catch (err) {
@@ -79,7 +90,7 @@ export function resolveOpenConflict(hippoRoot, tenantId, conflictId, body) {
     if (liveEntry(hippoRoot, tenantId, conflict.memory_a_id) === null || liveEntry(hippoRoot, tenantId, conflict.memory_b_id) === null) {
         return notFound();
     }
-    const resolved = resolveConflict(hippoRoot, conflictId, keep, false, tenantId, { rejectedBy: ACTOR });
+    const resolved = resolveConflict(hippoRoot, { conflictId, keepId: keep, tenantId }, { rejectedBy: ACTOR });
     // Both guards passed above, so null here is a race with another resolver.
     if (resolved === null)
         return already();

package/dist/dashboard/dashboard-queries.js

@@ -2,6 +2,7 @@
 import { calculateStrength } from '../core/memory.js';
 import { loadOpenConflictsOf } from '../store/conflicts.js';
 import { BANDS, DAY_MS, LAYERS, isLiveMemory, memoryFacts, projectIdentity, } from './dashboard-snapshot.js';
+import { pct, round1 } from '../util/format.js';
 const SERIES_DAYS = 90;
 /** The server words each delta for this range; the client re-slices the series for 7d and 90d. */
 const DELTA_DAYS = 30;
@@ -9,9 +10,6 @@ const POINTS_MAX = 4_000;
 const GRID_COLS = 64;
 const GRID_ROWS = 32;
 const NAME_MATCHES = 3;
-function round1(value) {
-    return Math.round(value * 10) / 10;
-}
 function round3(value) {
     return Math.round(value * 1000) / 1000;
 }
@@ -32,9 +30,6 @@ function cumulativeSeries(times, nowMs) {
 function addedWithin(series) {
     return series[SERIES_DAYS] - series[SERIES_DAYS - DELTA_DAYS];
 }
-function pct(share) {
-    return `${(share * 100).toFixed(1)}%`;
-}
 function plural(n, one, many) {
     return `${n} ${n === 1 ? one : many}`;
 }
@@ -342,7 +337,7 @@ export function buildMemoryDetail(hippoRoot, tenantId, entry, options) {
         projectKey: project.key,
         projectName: project.name,
         scope: entry.scope,
-        tenant: entry.tenantId,
+        tenant: entry.tenant_id,
         kind: entry.kind,
         embedded,
         conflicts: openConflictsOf(hippoRoot, tenantId, entry, nowMs),

package/dist/dashboard/dashboard-snapshot.d.ts

@@ -129,8 +129,8 @@ export interface SnapshotService {
     invalidate(): void;
     /** Id of the most recent build, which is what a client holding the last response still has. */
     currentId(): number;
-    /** Ids with a vector as of the last build (a direct read before any build), so a detail read never rescans the vector table. */
-    embeddedIds(): ReadonlySet<string> | null;
+    /** Whether a row of the last build's tenant had a vector at that build (a point read before any build), so a detail read never scans vectors. */
+    isEmbedded(id: string): boolean;
     close(): void;
 }
 /** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the

package/dist/dashboard/dashboard-snapshot.js

@@ -5,6 +5,7 @@ import { isQuarantineScope } from '../trust/quarantine.js';
 import { listMemoryConflicts } from '../store/conflicts.js';
 import { DashboardConnection, loadDashboardRows } from '../store/dashboard-reads.js';
 import { DAY_MS } from '../util/time.js';
+import { round1 } from '../util/format.js';
 export { DAY_MS };
 export const LAYERS = ['buffer', 'episodic', 'semantic', 'trace'];
 // Wire order of `Band`, and the order the mockup sorts bands in.
@@ -99,9 +100,6 @@ function cutHead(content) {
         end -= 1;
     return { head: content.slice(0, end), truncated: true };
 }
-function round1(value) {
-    return Math.round(value * 10) / 10;
-}
 function newDraft(identity) {
     return {
         summary: {
@@ -262,7 +260,7 @@ class SnapshotCacheService {
         this.lastId += 1;
         highestIssuedId = Math.max(highestIssuedId, this.lastId);
         // After loadDashboardRows, whose writable open has run any pending migration and legacy embeddings.json import.
-        this.lastEmbeddedIds = this.connection.embeddedIds();
+        this.lastEmbeddedIds = this.connection.embeddedIds(tenantId);
         return buildSnapshot({
             id: this.lastId,
             tenantId,
@@ -294,11 +292,11 @@ class SnapshotCacheService {
     currentId() {
         return this.lastId;
     }
-    embeddedIds() {
+    isEmbedded(id) {
         if (this.lastEmbeddedIds !== undefined)
-            return this.lastEmbeddedIds;
+            return this.lastEmbeddedIds?.has(id) ?? false;
         this.connection.dataVersion();
-        return this.connection.embeddedIds();
+        return this.connection.hasVector(id);
     }
     close() {
         this.connection.close();

package/dist/dashboard/dashboard.js

@@ -19,6 +19,7 @@ import { installSignalHandlers } from '../util/crash-handlers.js';
 import { DEFAULT_SHUTDOWN_DRAIN_MS, drainAndClose, setKeepAliveTimeouts, shutdownBoundMs } from '../server/lifecycle.js';
 import { printError } from '../cli/output.js';
 import { PACKAGE_ROOT } from '../core/package-root.js';
+import { DAY_MS } from '../util/time.js';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'application/javascript; charset=utf-8',
@@ -132,7 +133,7 @@ function handleRead(ctx, segments) {
         if (entry === null || !isLiveMemory(entry))
             return sendOrNotFound(res, null);
         const snapshotId = snapshots.get(tenantId, fresh).id;
-        const embedded = snapshots.embeddedIds()?.has(entry.id) ?? false;
+        const embedded = snapshots.isEmbedded(entry.id);
         return sendOrNotFound(res, buildMemoryDetail(hippoRoot, tenantId, entry, { snapshotId, nowMs: ctx.now(), embedded }));
     }
     if (head === 'search' && segments.length === 2) {
@@ -179,12 +180,12 @@ async function handlePost(ctx, segments) {
     }
     const body = await readActionBody(req);
     const tenantId = resolveTenantId({});
-    const result = action(hippoRoot, tenantId, body);
+    const result = await action(hippoRoot, tenantId, body);
     if (result.changed)
         snapshots.invalidate();
     if (result.entry) {
         // The write is committed, so a rebuild failure must not turn it into a 500: the next read rebuilds.
-        const embedded = snapshots.embeddedIds()?.has(result.entry.id) ?? false;
+        const embedded = snapshots.isEmbedded(result.entry.id);
         const detail = buildMemoryDetail(hippoRoot, tenantId, result.entry, { snapshotId: snapshots.currentId(), nowMs: ctx.now(), embedded });
         jsonResponse(res, detail, result.status);
     }
@@ -279,13 +280,15 @@ function leaveTokenUrl(req, res, url) {
     res.end(`<!doctype html>\n<html lang="en"><head><meta charset="utf-8"><meta http-equiv="refresh" content="0;url=${target}"><title>Hippo Dashboard</title></head><body></body></html>`);
     return true;
 }
+// A browser that restores its session keeps a cookie with no Max-Age for good; no Secure, since this server speaks plain HTTP on loopback only.
+const DASHBOARD_COOKIE_MAX_AGE_S = DAY_MS / 1000;
 /** True when the request may proceed; false when this already answered it (redirect off the token URL, or 401). */
 function admitDashboardRequest(req, res, url, access) {
     const { token, port } = access;
     // Cookies ignore the port, so the name carries it: two dashboards on one host keep separate tokens.
     const cookieName = `hippo_dashboard_${req.socket.localPort ?? port}`;
     if (sameToken(url.searchParams.get('token') ?? undefined, token)) {
-        res.setHeader('Set-Cookie', `${cookieName}=${token}; HttpOnly; SameSite=Strict; Path=/`);
+        res.setHeader('Set-Cookie', `${cookieName}=${token}; HttpOnly; SameSite=Strict; Path=/; Max-Age=${DASHBOARD_COOKIE_MAX_AGE_S}`);
         if (leaveTokenUrl(req, res, url))
             return false;
     }
@@ -300,7 +303,7 @@ function answerDashboardFailure(req, res, err) {
     const clientFault = err instanceof ParamError || err instanceof URIError || err instanceof BodyTimeoutError;
     // A cut-short response is logged even for a client fault; a bare 400 is not.
     if (res.headersSent || !clientFault) {
-        log.error('dashboard request failed', { ...errorFields(err), error: errorMessage(err), path: req.url });
+        log.error('dashboard request failed', { ...errorFields(err), error: errorMessage(err), path: (req.url ?? '/').split('?')[0] });
     }
     if (res.headersSent) {
         res.end();
@@ -318,9 +321,20 @@ function answerDashboardFailure(req, res, err) {
         return jsonResponse(res, { error: 'Malformed URL path' }, 400);
     jsonResponse(res, { error: 'Internal error' }, 500);
 }
-function printDashboardBanner(boundPort, token, distUiDir) {
+const DASHBOARD_URL_FILE = 'dashboard.url';
+function printDashboardBanner(hippoRoot, boundPort, token, distUiDir) {
     // The banner is the `hippo dashboard` command's printed result, so it stays on stdout.
-    console.log(`Hippo Dashboard running at http://localhost:${boundPort}/?token=${token}`);
+    const url = `http://localhost:${boundPort}/?token=${token}`;
+    if (process.stdout.isTTY) {
+        console.log(`Hippo Dashboard running at ${url}`);
+    }
+    else {
+        // Captured stdout lands in logs, so the token goes to an owner-only file, created fresh so its mode holds.
+        const file = path.join(hippoRoot, DASHBOARD_URL_FILE);
+        fs.rmSync(file, { force: true });
+        fs.writeFileSync(file, `${url}\n`, { flag: 'wx', mode: 0o600 });
+        console.log(`Hippo Dashboard running at http://localhost:${boundPort}/ (open the URL with its token from ${file})`);
+    }
     if (distUiDir !== null)
         console.log(`Serving React UI from ${distUiDir}`);
     console.log('Press Ctrl+C to stop.');
@@ -406,7 +420,7 @@ export function serveDashboard(hippoRoot, port = 3333, token = randomBytes(32).t
     server.listen(port, '127.0.0.1', () => {
         // SAFETY: listen() was given a TCP port, so address() is AddressInfo, never a pipe name.
         const boundPort = server.address().port;
-        printDashboardBanner(boundPort, token, hasDistUi ? distUiDir : null);
+        printDashboardBanner(hippoRoot, boundPort, token, hasDistUi ? distUiDir : null);
     });
     return server;
 }

package/dist/db/backup.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { log } from '../util/log.js';
+import { log, errorFields } from '../util/log.js';
 /** Copies the database before a repair writes, so the audit ids plus this file are the way back. */
 export function backupStore(db, hippoRoot, label, now = new Date()) {
     const dir = path.join(hippoRoot, 'backups');
@@ -21,7 +21,7 @@ export function withBackup(db, hippoRoot, label, transaction) {
             fs.rmSync(backup, { force: true });
         }
         catch (cleanupError) {
-            log.warn(`Could not delete the unused backup ${backup}: ${String(cleanupError)}`);
+            log.warn(`Could not delete the unused backup ${backup}: ${String(cleanupError)}`, errorFields(cleanupError));
         }
         throw err;
     }

package/dist/db/busy.d.ts

@@ -8,18 +8,25 @@ export interface WriteScopeOptions {
     readonly busyWaitMs?: number;
 }
 /** Runs `fn` as one write: BEGIN IMMEDIATE on an idle handle, else SAVEPOINT `name` inside the caller's transaction.
- *  A deferred scope that reads first cannot wait out another writer, while BEGIN IMMEDIATE waits the open's busy_timeout. */
+ * A deferred scope that reads first cannot wait out another writer, while BEGIN IMMEDIATE waits the open's
+ * busy_timeout.
+ */
 export declare function withWriteScope<T>(db: DatabaseSyncLike, name: string, fn: () => T, opts?: WriteScopeOptions): T;
 /** Runs the reads in `fn` against one snapshot, so two statements cannot straddle another process's write. */
 export declare function withReadSnapshot<T>(db: DatabaseSyncLike, fn: () => T): T;
-/** Runs `fn` and undoes every write it made, throw or not: a dry run that reports what a real run would do. Takes no write lock up front. */
+/**
+ * Runs `fn` and undoes every write it made, throw or not: a dry run that reports what a real run would do. Takes no
+ * write lock up front.
+ */
 export declare function withTrialScope<T>(db: DatabaseSyncLike, name: string, fn: () => T): T;
 /** What `withWriteScopeOr` hands its callback's `rollback(value)`; a class so no stored value can pass for one. */
 declare class RolledBack<V> {
     readonly value: V;
     constructor(value: V);
 }
-/** `withWriteScope` for a write that can refuse: a callback that returns `rollback(value)` gets the scope's writes undone
+/**
+ * `withWriteScope` for a write that can refuse: a callback that returns `rollback(value)` gets the scope's writes
+ * undone
  *  and `value` back, with no throw. Any other return commits. */
 export declare function withWriteScopeOr<T, R>(db: DatabaseSyncLike, name: string, fn: (rollback: <V>(value: V) => RolledBack<V>) => T | RolledBack<R>): T | R;
 export {};

package/dist/db/busy.js

@@ -8,7 +8,8 @@ export function isSqliteBusy(cause) {
 }
 /** The lock wait of an open that names none: its busy_timeout and every explicit wait below. */
 export const DEFAULT_BUSY_WAIT_MS = 5000;
-// busy_timeout covers neither contended statement here: SQLite skips the busy handler for `PRAGMA journal_mode` and for a write
+// busy_timeout covers neither contended statement here: SQLite skips the busy handler for `PRAGMA journal_mode` and for
+// a write
 // that upgrades a deferred read snapshot, so both need an explicit wait.
 export function execWithBusyRetry(db, sql, timeoutMs = DEFAULT_BUSY_WAIT_MS) {
     const deadline = Date.now() + timeoutMs;
@@ -25,6 +26,14 @@ export function execWithBusyRetry(db, sql, timeoutMs = DEFAULT_BUSY_WAIT_MS) {
         }
     }
 }
+// SQLite cannot bind a savepoint name as a parameter, so the name is spliced into the SQL and must be a bare
+// identifier.
+const SAVEPOINT_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSavepointName(name) {
+    if (!SAVEPOINT_NAME_RE.test(name)) {
+        throw new Error(`invalid savepoint name ${JSON.stringify(name)}: use letters, digits and _ only`);
+    }
+}
 function undoScope(db, top, name) {
     if (top) {
         db.exec('ROLLBACK');
@@ -34,7 +43,10 @@ function undoScope(db, top, name) {
         db.exec(`RELEASE SAVEPOINT ${name}`);
     }
 }
-/** Undo after a failure without letting a failed undo replace the caller's error; an idle handle means SQLite already unwound the scope. */
+/**
+ * Undo after a failure without letting a failed undo replace the caller's error; an idle handle means SQLite already
+ * unwound the scope.
+ */
 function undoAfterFailure(db, top, name) {
     if (db.isTransaction === false)
         return;
@@ -46,8 +58,11 @@ function undoAfterFailure(db, top, name) {
     }
 }
 /** Runs `fn` as one write: BEGIN IMMEDIATE on an idle handle, else SAVEPOINT `name` inside the caller's transaction.
- *  A deferred scope that reads first cannot wait out another writer, while BEGIN IMMEDIATE waits the open's busy_timeout. */
+ * A deferred scope that reads first cannot wait out another writer, while BEGIN IMMEDIATE waits the open's
+ * busy_timeout.
+ */
 export function withWriteScope(db, name, fn, opts) {
+    assertSavepointName(name);
     const top = db.isTransaction === false;
     if (top && opts)
         execWithBusyRetry(db, 'BEGIN IMMEDIATE', opts.busyWaitMs);
@@ -84,8 +99,12 @@ export function withReadSnapshot(db, fn) {
     db.exec('COMMIT');
     return result;
 }
-/** Runs `fn` and undoes every write it made, throw or not: a dry run that reports what a real run would do. Takes no write lock up front. */
+/**
+ * Runs `fn` and undoes every write it made, throw or not: a dry run that reports what a real run would do. Takes no
+ * write lock up front.
+ */
 export function withTrialScope(db, name, fn) {
+    assertSavepointName(name);
     const top = db.isTransaction === false;
     db.exec(top ? 'BEGIN' : `SAVEPOINT ${name}`);
     let result;
@@ -106,9 +125,12 @@ class RolledBack {
         this.value = value;
     }
 }
-/** `withWriteScope` for a write that can refuse: a callback that returns `rollback(value)` gets the scope's writes undone
+/**
+ * `withWriteScope` for a write that can refuse: a callback that returns `rollback(value)` gets the scope's writes
+ * undone
  *  and `value` back, with no throw. Any other return commits. */
 export function withWriteScopeOr(db, name, fn) {
+    assertSavepointName(name);
     const top = db.isTransaction === false;
     db.exec(top ? 'BEGIN IMMEDIATE' : `SAVEPOINT ${name}`);
     try {

package/dist/db/connect.d.ts

@@ -3,11 +3,19 @@ import { type OpenFacts } from './migrate.js';
 export declare function getHippoDbPath(hippoRoot: string): string;
 /** Runs `step` on this store unless it already ran to the end in this process; a throw leaves it due. */
 export declare function oncePerStore(hippoRoot: string, name: string, step: () => void): void;
-/** A connection with what its own open's probe read; facts go stale with the next statement, so a handle made by an earlier call carries null. */
+/**
+ * A connection with what its own open's probe read; facts go stale with the next statement, so a handle made by an
+ * earlier call carries null.
+ */
 export interface OpenedDb {
     readonly db: DatabaseSyncLike;
     readonly facts: OpenFacts | null;
 }
-/** A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the caller owns and closes it. */
+/**
+ * A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the
+ * caller owns and closes it.
+ * Outside any request scope (CLI start-up, timers) this is the only handle there is; openHippoDb reuses the scope's
+ * when one exists.
+ */
 export declare function connectWithFacts(hippoRoot: string, busyWaitMs?: number): OpenedDb;
 //# sourceMappingURL=connect.d.ts.map

package/dist/db/connect.js

@@ -37,7 +37,8 @@ function createStoreFilesOwnerOnly(hippoRoot) {
             throw err;
     }
 }
-// The archive only grows and its ids never repeat, so an unchanged top id means no row this process has not swept; a failed sweep stays due.
+// The archive only grows and its ids never repeat, so an unchanged top id means no row this process has not swept; a
+// failed sweep stays due.
 function sweepArchivedMirrorsIfDue(hippoRoot, db, probedTop) {
     const top = probedTop ?? archiveTop(db);
     const key = storeKey(hippoRoot);
@@ -51,7 +52,12 @@ function archiveTop(db) {
     const row = db.prepare('SELECT MAX(id) AS top FROM raw_archive').get();
     return Number(row?.top ?? 0);
 }
-/** A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the caller owns and closes it. */
+/**
+ * A new connection with the store's pragmas and migrations applied and the mirror cleanup run when it is due; the
+ * caller owns and closes it.
+ * Outside any request scope (CLI start-up, timers) this is the only handle there is; openHippoDb reuses the scope's
+ * when one exists.
+ */
 export function connectWithFacts(hippoRoot, busyWaitMs = DEFAULT_BUSY_WAIT_MS) {
     createStoreFilesOwnerOnly(hippoRoot);
     const db = new DatabaseSync(getHippoDbPath(hippoRoot));

package/dist/db/continuity.d.ts

@@ -2,7 +2,7 @@ import type { DatabaseSyncLike } from './sqlite.js';
 export declare const MEMORY_QUARANTINE_DDL = "\n    CREATE TABLE IF NOT EXISTS memory_quarantine (\n      tenant_id      TEXT NOT NULL DEFAULT 'default',\n      memory_id      TEXT NOT NULL,\n      original_scope TEXT,\n      reason         TEXT NOT NULL,\n      status         TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','approved','rejected')),\n      quarantined_at TEXT NOT NULL,\n      decided_at     TEXT,\n      decided_by     TEXT,\n      PRIMARY KEY (tenant_id, memory_id)\n    ) WITHOUT ROWID;\n    CREATE INDEX IF NOT EXISTS idx_memory_quarantine_status\n      ON memory_quarantine(tenant_id, status, quarantined_at DESC);\n";
 export declare const SESSION_OWNERS_DDL = "\n    CREATE TABLE IF NOT EXISTS session_owners (\n      tenant_id TEXT NOT NULL,\n      session_id TEXT NOT NULL,\n      owner_subject TEXT NOT NULL,\n      created_at TEXT NOT NULL,\n      PRIMARY KEY (tenant_id, session_id)\n    )\n  ";
 export declare function ensureContinuityTables(db: DatabaseSyncLike): void;
-export declare const MEMORIES_FTS_DDL = "CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(id UNINDEXED, content, tags)";
+export declare const MEMORIES_FTS_DDL: string;
 /** Names of every table and index a `CREATE ... IF NOT EXISTS` in `ddl` makes. */
 export declare function createdObjectNames(ddl: string): string[];
 /** Every object runMigrations re-asserts on a stamped store; the open fast path requires all of them. */

package/dist/db/continuity.js

@@ -149,35 +149,51 @@ const CONTINUITY_INDEX_DDL = [
     `CREATE INDEX IF NOT EXISTS idx_task_snapshots_status_updated ON task_snapshots(status, updated_at DESC, id DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_task_snapshots_tenant_status ON task_snapshots(tenant_id, status, updated_at DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_task_snapshots_tenant_scope ON task_snapshots(tenant_id, scope, status)`,
-    `CREATE INDEX IF NOT EXISTS idx_session_events_session_created ON session_events(session_id, created_at DESC, id DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_session_events_session_created ON session_events(session_id, created_at DESC, id ` +
+        `DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_session_events_task_created ON session_events(task, created_at DESC, id DESC)`,
-    `CREATE INDEX IF NOT EXISTS idx_session_events_tenant_session ON session_events(tenant_id, session_id, created_at DESC, id DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_session_events_tenant_session ON session_events(tenant_id, session_id, created_at ` +
+        `DESC, id DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_session_handoffs_session ON session_handoffs(session_id, created_at DESC)`,
-    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_session ON session_handoffs(tenant_id, session_id, created_at DESC)`,
-    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_outcome ON session_handoffs(tenant_id, outcome, created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_session ON session_handoffs(tenant_id, session_id, ` +
+        `created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_outcome ON session_handoffs(tenant_id, outcome, created_at ` +
+        `DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_cards_tenant_status ON cards(tenant_id, status, updated_at DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_card_deps_tenant_child ON card_deps(tenant_id, child)`,
     `CREATE INDEX IF NOT EXISTS idx_card_deps_tenant_parent ON card_deps(tenant_id, parent)`,
     `CREATE INDEX IF NOT EXISTS idx_card_runs_tenant_card ON card_runs(tenant_id, card, started DESC)`,
     `CREATE INDEX IF NOT EXISTS idx_card_comments_tenant_card ON card_comments(tenant_id, card_id, created_at DESC)`,
-    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_card ON session_handoffs(tenant_id, card_id, created_at DESC)`,
-    `CREATE INDEX IF NOT EXISTS idx_task_snapshots_owner ON task_snapshots(tenant_id, owner_subject, origin_project, status, updated_at DESC)`,
-    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_owner ON session_handoffs(tenant_id, owner_subject, origin_project, created_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_tenant_card ON session_handoffs(tenant_id, card_id, created_at ` +
+        `DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_task_snapshots_owner ON task_snapshots(tenant_id, owner_subject, origin_project, ` +
+        `status, updated_at DESC)`,
+    `CREATE INDEX IF NOT EXISTS idx_session_handoffs_owner ON session_handoffs(tenant_id, owner_subject, ` +
+        `origin_project, created_at DESC)`,
 ];
 // A client retry carries the same request id, so a repeat finds the earlier row instead of writing again.
 const REQUEST_INDEX_DDL = {
-    compactions: `CREATE UNIQUE INDEX IF NOT EXISTS idx_compactions_request ON compactions(tenant_id, request_id) WHERE request_id IS NOT NULL`,
-    failure_log: `CREATE UNIQUE INDEX IF NOT EXISTS idx_failure_log_request ON failure_log(tenant_id, request_id) WHERE request_id IS NOT NULL`,
+    compactions: `CREATE UNIQUE INDEX IF NOT EXISTS idx_compactions_request ON compactions(tenant_id, request_id) ` +
+        `WHERE request_id IS NOT NULL`,
+    failure_log: `CREATE UNIQUE INDEX IF NOT EXISTS idx_failure_log_request ON failure_log(tenant_id, request_id) ` +
+        `WHERE request_id IS NOT NULL`,
 };
 // Lives with the other re-asserted DDL so the required-object list below derives from one place.
-export const MEMORIES_FTS_DDL = `CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(id UNINDEXED, content, tags)`;
+export const MEMORIES_FTS_DDL = `CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts ` +
+    `USING fts5(id UNINDEXED, content, tags)`;
 const CREATED_NAME = /CREATE\s+(?:VIRTUAL\s+|UNIQUE\s+)?(?:TABLE|INDEX)\s+IF\s+NOT\s+EXISTS\s+(\w+)/gi;
 /** Names of every table and index a `CREATE ... IF NOT EXISTS` in `ddl` makes. */
 export function createdObjectNames(ddl) {
     return [...ddl.matchAll(CREATED_NAME)].map((m) => m[1]);
 }
 /** Every object runMigrations re-asserts on a stamped store; the open fast path requires all of them. */
-export const REQUIRED_SCHEMA_OBJECTS = Object.freeze([META_TABLE_DDL, ...CONTINUITY_TABLE_DDL, ...CONTINUITY_INDEX_DDL, ...Object.values(REQUEST_INDEX_DDL), MEMORIES_FTS_DDL].flatMap(createdObjectNames));
+export const REQUIRED_SCHEMA_OBJECTS = Object.freeze([
+    META_TABLE_DDL,
+    ...CONTINUITY_TABLE_DDL,
+    ...CONTINUITY_INDEX_DDL,
+    ...Object.values(REQUEST_INDEX_DDL),
+    MEMORIES_FTS_DDL,
+].flatMap(createdObjectNames));
 // After the loop: tenant_id (v16) and scope (v23) do not exist yet on a genuine old store.
 export function ensureContinuityIndexes(db) {
     for (const ddl of CONTINUITY_INDEX_DDL)

package/dist/db/meta.d.ts

@@ -9,7 +9,10 @@ export declare function pragmaDataVersion(db: DatabaseSyncLike): number;
 export declare function setSchemaVersion(db: DatabaseSyncLike, version: number): void;
 export declare function getMeta(db: DatabaseSyncLike, key: string, fallback?: string): string;
 export declare function setMeta(db: DatabaseSyncLike, key: string, value: string): void;
-/** Raise min_compatible_binary to `version`; never lowers it, since an older floor would let back in a binary a newer write already shut out. */
+/**
+ * Raise min_compatible_binary to `version`; never lowers it, since an older floor would let back in a binary a newer
+ * write already shut out.
+ */
 export declare function raiseMinBinary(db: DatabaseSyncLike, version: string): void;
 export declare function isFtsAvailable(db: DatabaseSyncLike): boolean;
 //# sourceMappingURL=meta.d.ts.map

package/dist/db/meta.js

@@ -41,7 +41,10 @@ export function getMeta(db, key, fallback = '') {
 export function setMeta(db, key, value) {
     db.prepare(`INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(key, value);
 }
-/** Raise min_compatible_binary to `version`; never lowers it, since an older floor would let back in a binary a newer write already shut out. */
+/**
+ * Raise min_compatible_binary to `version`; never lowers it, since an older floor would let back in a binary a newer
+ * write already shut out.
+ */
 export function raiseMinBinary(db, version) {
     const existing = getMeta(db, 'min_compatible_binary');
     if (!existing || compareSemver(version, existing) > 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