hippo-memory 1.71.0 → 2.0.0

package/dist/store/rejected-values.js

@@ -5,25 +5,31 @@ import { heldTexts } from '../util/same-text.js';
 import { audit } from './audit-event.js';
 import { deleteEntryCore } from './delete-and-batch.js';
 import { deleteDormantRow, listDormantSnapshots, purgeDormantByDigest, replaceDormantEntry } from './dormant.js';
-import { entryRejectRowAt, selectAllEntries } from './entry-reads.js';
+import { entryRejectRowAt, selectEntriesByIds, selectTenantTexts } from './entry-reads.js';
 import { stampOriginProject } from './entry-row.js';
 import { writeEntryDbOnly, writeEntryMirrors } from './entry-writes.js';
 import { purgeMirrorBestEffort } from './mirrors.js';
 import { onHandle, openStore } from './open.js';
 import { archiveRawMemory, markMirrorCleaned } from './raw-archive.js';
-import { RejectedValueError, checkRejectionGuard, deleteRejectedValue, insertRejectedValue, listRejectedValues, normalizeValueForRejection, rejectionDigest, } from './rejection.js';
+import { checkRejectionGuard, deleteRejectedValue, insertRejectedValue, listRejectedValues, normalizeValueForRejection, rejectionDigest, } from './rejection.js';
+import { RejectedValueError } from '../core/api-errors.js';
 function removeLiveRows(db, hippoRoot, rejection, holdsValue, removal) {
     const { tenantId, actor, reason } = rejection;
     const { removedIds, removedRawIds, successors } = removal;
-    const merged = [];
-    for (const row of selectAllEntries(db, tenantId)) {
+    // Text columns decide which rows hold the value; only those rows are read whole.
+    const directIds = [];
+    const mergedIds = [];
+    for (const row of selectTenantTexts(db, tenantId)) {
         if (!rejection.inReach(row.scope))
             continue;
-        if (!holdsValue(row.content)) {
-            if (heldTexts(row).some(holdsValue))
-                merged.push(row);
-            continue;
-        }
+        if (holdsValue(row.content))
+            directIds.push(row.id);
+        else if (heldTexts(row).some(holdsValue))
+            mergedIds.push(row.id);
+    }
+    const held = selectEntriesByIds(db, [...directIds, ...mergedIds], tenantId);
+    const merged = mergedIds.flatMap((id) => held.get(id) ?? []);
+    for (const row of directIds.flatMap((id) => held.get(id) ?? [])) {
         if (row.kind === 'raw') {
             // A raw row is append-only: archiving is its one removal path, and its savepoint nests in this write scope.
             archiveRawMemory(db, row.id, { reason, who: actor });
@@ -96,7 +102,7 @@ export function applyRejection(hippoRoot, rejection) {
                 sourceMemoryId: memoryId ?? null,
                 normalizedChars: normalizeValueForRejection(content).length,
             });
-            // SHORTCUT: scans every row of the tenant, fine for a human-run command; a digest column on memories if stores grow a hundredfold.
+            // SHORTCUT: scans the tenant's text columns, fine for a human-run command; a digest column needs a schema migration, held until approved.
             const holdsValue = (text) => rejectionDigest(text) === digest;
             removeLiveRows(db, hippoRoot, rejection, holdsValue, removal);
             removeDormantCopies(db, rejection, digest, holdsValue, removal);

package/dist/store/rejection-probe.d.ts

@@ -0,0 +1,4 @@
+export type RejectionProbe = (tenantId: string, entryId: string, content: string) => boolean;
+/** Runs `fn` with a probe that says whether the write guard would refuse the content; the handle closes after. */
+export declare function withRejectionProbe<T>(hippoRoot: string, fn: (wouldReject: RejectionProbe) => T): T;
+//# sourceMappingURL=rejection-probe.d.ts.map

package/dist/store/rejection-probe.js

@@ -0,0 +1,19 @@
+// A rejected-value check for a dry run, on a handle the caller never sees.
+import { onHandle } from './open.js';
+import { checkRejectionGuard } from './rejection.js';
+import { RejectedValueError } from '../core/api-errors.js';
+/** Runs `fn` with a probe that says whether the write guard would refuse the content; the handle closes after. */
+export function withRejectionProbe(hippoRoot, fn) {
+    return onHandle(hippoRoot, (db) => fn((tenantId, entryId, content) => {
+        try {
+            checkRejectionGuard(db, tenantId, entryId, content);
+            return false;
+        }
+        catch (err) {
+            if (err instanceof RejectedValueError)
+                return true;
+            throw err;
+        }
+    }));
+}
+//# sourceMappingURL=rejection-probe.js.map

package/dist/store/rejection.d.ts

@@ -1,28 +1,11 @@
 /** Rejected-value tombstone: a human can refuse byte-stable re-ingestion of a rejected fact (exact normalized value); paraphrase matching is out of scope.
  * db-agnostic (helpers take a `DatabaseSyncLike`) and imports nothing from the store layer above it, which imports this (the reverse is a cycle). */
 import type { DatabaseSyncLike } from '../db/index.js';
-import { BadRequestError } from '../core/api-errors.js';
 /** Normalize content for rejection digests: NFC, lowercase, collapse whitespace runs, trim. No punctuation stripping: over-normalizing causes false
  * refusals, worse than misses. */
 export declare function normalizeValueForRejection(content: string): string;
 /** Full 64-char sha256 hex of the normalized content: a tombstone key needs collision resistance, not the 16-char redaction hash used for query hashing. */
 export declare function rejectionDigest(content: string): string;
-/** Thrown by the write-path guard (checkRejectionGuard, via upsertEntryRow) when a write would introduce a tombstoned value; carries what the
- * transaction-owner catch blocks (writeEntry, api.supersede) need to write the post-rollback `reject_refusal` audit row via `auditRejectionRefusal`. */
-export declare class RejectedValueError extends BadRequestError {
-    readonly digest: string;
-    readonly tenantId: string;
-    readonly entryId: string;
-    readonly reason: string | null;
-    readonly rejectedAt: string;
-    constructor(opts: {
-        digest: string;
-        tenantId: string;
-        entryId: string;
-        reason: string | null;
-        rejectedAt: string;
-    });
-}
 export interface RejectedValueRow {
     tenantId: string;
     digest: string;

package/dist/store/rejection.js

@@ -1,8 +1,7 @@
 /** Rejected-value tombstone: a human can refuse byte-stable re-ingestion of a rejected fact (exact normalized value); paraphrase matching is out of scope.
  * db-agnostic (helpers take a `DatabaseSyncLike`) and imports nothing from the store layer above it, which imports this (the reverse is a cycle). */
 import { createHash } from 'node:crypto';
-import { BadRequestError } from '../core/api-errors.js';
-import { DIGEST_DISPLAY_CHARS } from '../util/token-text.js';
+import { RejectedValueError } from '../core/api-errors.js';
 /** Normalize content for rejection digests: NFC, lowercase, collapse whitespace runs, trim. No punctuation stripping: over-normalizing causes false
  * refusals, worse than misses. */
 export function normalizeValueForRejection(content) {
@@ -12,25 +11,6 @@ export function normalizeValueForRejection(content) {
 export function rejectionDigest(content) {
     return createHash('sha256').update(normalizeValueForRejection(content)).digest('hex');
 }
-/** Thrown by the write-path guard (checkRejectionGuard, via upsertEntryRow) when a write would introduce a tombstoned value; carries what the
- * transaction-owner catch blocks (writeEntry, api.supersede) need to write the post-rollback `reject_refusal` audit row via `auditRejectionRefusal`. */
-export class RejectedValueError extends BadRequestError {
-    digest;
-    tenantId;
-    entryId;
-    reason;
-    rejectedAt;
-    constructor(opts) {
-        super(`Memory value refused: matches a rejected value (digest ${opts.digest.slice(0, DIGEST_DISPLAY_CHARS)}..., ` +
-            `reason: ${opts.reason ?? 'none given'}). Run "hippo unreject" to allow it again.`);
-        this.name = 'RejectedValueError';
-        this.digest = opts.digest;
-        this.tenantId = opts.tenantId;
-        this.entryId = opts.entryId;
-        this.reason = opts.reason;
-        this.rejectedAt = opts.rejectedAt;
-    }
-}
 function rowToRejectedValue(row) {
     return {
         tenantId: row.tenant_id,

package/dist/store/rows.js

@@ -61,12 +61,12 @@ function rowToPlacementFields(row) {
         scope: row.scope ?? null,
         owner: row.owner ?? null,
         artifact_ref: row.artifact_ref ?? null,
-        tenantId: row.tenant_id ?? DEFAULT_TENANT_ID,
+        tenant_id: row.tenant_id ?? DEFAULT_TENANT_ID,
         origin_project: row.origin_project ?? null,
         descendant_count: Number(row.descendant_count ?? 0),
         earliest_at: row.earliest_at ?? null,
         latest_at: row.latest_at ?? null,
-        summary_dirty: (Number(row.summary_dirty ?? 0) === 1 ? 1 : 0),
+        summary_dirty: Number(row.summary_dirty) === 1,
         last_rebuilt_at: row.last_rebuilt_at ?? null,
         rebuild_count: Number(row.rebuild_count ?? 0),
         dag_level_3_built_at: row.dag_level_3_built_at ?? null,

package/dist/store/rule-sql.d.ts

@@ -1,5 +1,16 @@
+/** calculateRewardFactor as SQL over `memories` columns; strengthSql and the context-candidate rank both build on it, so the slope has one source. */
+export declare function rewardFactorSql(): string;
 /** calculateStrength's clock-basis formula as SQL over `memories` columns, flags and multipliers baked in; keep in step.
  *  An unparseable date scores NULL here and 0 in JS, so sums agree. */
 export declare function strengthSql(now: Date): string;
 export declare const AUTO_DELETABLE_SQL: string;
+export interface SqlFragment {
+    sql: string;
+    params: string[];
+}
+/** SQL twin of the no-request arm of passesScopeFilterForRecall; `ownScope` is bound and compared with `=`, so `%` or `_` in an owner match nothing extra. */
+export declare function scopeAdmitSql(col: '' | 'm.', ownScope?: string | null): SqlFragment;
+/** SQL twin of canTouchScope, which is also canReadScope for an admin: every row but
+ * another person's personal one. LIKE folds ASCII case as isPersonalScope's /i does. */
+export declare function touchableScopeSql(col: '' | 'm.', ownScope?: string | null): SqlFragment;
 //# sourceMappingURL=rule-sql.d.ts.map

package/dist/store/rule-sql.js

@@ -1,8 +1,18 @@
-// The SQL twins of the model's strength and keep rules (src/core/memory.ts); keep in step with calculateStrength and canAutoDelete.
+// The SQL twins of the model's rules in src/core: strength and keep (memory.ts), recall scope (recall-scope.ts); keep each in step with its JS half.
 import { DAY_MS } from '../util/time.js';
 import { isDecayAblated, isOutcomeSlowAblated, isRecallBoostAblated } from '../core/ablation.js';
 import { DECAY_BASE, EMOTIONAL_MULTIPLIERS, FALLBACK_HALF_LIFE_DAYS, KEEP_PAIRS, MAX_WRONG_HALVINGS, RETRIEVAL_BOOST_SLOPE, REWARD_SLOPE, applyLossAversionRatio, } from '../core/memory.js';
+import { PERSONAL_SCOPE_PREFIX, RECALL_DEFAULT_DENY_SCOPES } from '../core/recall-scope.js';
+import { placeholders } from '../util/sql.js';
 const UNIX_EPOCH_JULIAN_DAY = 2440587.5;
+/** calculateRewardFactor as SQL over `memories` columns; strengthSql and the context-candidate rank both build on it, so the slope has one source. */
+export function rewardFactorSql() {
+    if (isOutcomeSlowAblated())
+        return '1.0';
+    const pos = 'COALESCE(outcome_positive, 0)';
+    const neg = 'COALESCE(outcome_negative, 0)';
+    return `(CASE WHEN ${pos} = 0 AND ${neg} = 0 THEN 1.0 ELSE 1.0 + ${REWARD_SLOPE} * (${pos} - ${neg}) / (${pos} + ${neg} + 1.0) END)`;
+}
 /** calculateStrength's clock-basis formula as SQL over `memories` columns, flags and multipliers baked in; keep in step.
  *  An unparseable date scores NULL here and 0 in JS, so sums agree. */
 export function strengthSql(now) {
@@ -10,10 +20,7 @@ export function strengthSql(now) {
     const pos = 'COALESCE(outcome_positive, 0)';
     const neg = 'COALESCE(outcome_negative, 0)';
     const wrong = isOutcomeSlowAblated() || isDecayAblated() ? '0' : `MAX(0, ${neg} - ${pos})`;
-    const reward = isOutcomeSlowAblated()
-        ? '1.0'
-        : `(CASE WHEN ${pos} = 0 AND ${neg} = 0 THEN 1.0 ELSE 1.0 + ${REWARD_SLOPE} * (${pos} - ${neg}) / (${pos} + ${neg} + 1.0) END)`;
-    const halfLife = `(COALESCE(half_life_days, ${FALLBACK_HALF_LIFE_DAYS}) * ${reward})`;
+    const halfLife = `(COALESCE(half_life_days, ${FALLBACK_HALF_LIFE_DAYS}) * ${rewardFactorSql()})`;
     const anchor = isRecallBoostAblated() ? 'created' : 'last_retrieved';
     const nowJulian = num(now.getTime() / DAY_MS + UNIX_EPOCH_JULIAN_DAY);
     const decay = isDecayAblated() ? '1.0' : `pow(${DECAY_BASE}, (${nowJulian} - julianday(${anchor})) / ${halfLife})`;
@@ -30,8 +37,26 @@ export function strengthSql(now) {
 }
 const sqlText = (s) => `'${s.replace(/'/g, "''")}'`;
 // json_each matches the tag as a whole element; substr, not LIKE, keeps the prefix case-sensitive like startsWith.
-const keepPairSql = (p) => `(COALESCE(superseded_by, '') = '' AND EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(tags_json) THEN tags_json ELSE '[]' END) WHERE value = ${sqlText(p.tag)}) AND substr(source, 1, ${p.sourcePrefix.length}) = ${sqlText(p.sourcePrefix)})`;
+const keepPairSql = (p) => `(COALESCE(superseded_by, '') = '' AND EXISTS (SELECT 1 FROM json_each(CASE WHEN json_valid(tags_json) THEN tags_json ELSE '[]' END) ` +
+    `WHERE value = ${sqlText(p.tag)}) AND substr(source, 1, ${p.sourcePrefix.length}) = ${sqlText(p.sourcePrefix)})`;
 // Pinned and kept rows stay (a superseded row is not kept: its successor carries the tag and
 // source); raw rows leave only through archiveRawMemory. The SQL twin guards the DELETE itself.
 export const AUTO_DELETABLE_SQL = `pinned = 0 AND kind != 'raw'${KEEP_PAIRS.map((p) => ` AND NOT ${keepPairSql(p)}`).join('')}`;
+/** SQL twin of the no-request arm of passesScopeFilterForRecall; `ownScope` is bound and compared with `=`, so `%` or `_` in an owner match nothing extra. */
+export function scopeAdmitSql(col, ownScope) {
+    const marks = placeholders(RECALL_DEFAULT_DENY_SCOPES.length);
+    const admitted = `${col}scope IS NULL OR (${col}scope NOT IN (${marks}) AND ${col}scope NOT LIKE '%:private:%')`;
+    if (ownScope == null)
+        return { sql: `(${admitted})`, params: [...RECALL_DEFAULT_DENY_SCOPES] };
+    // The own arm sits inside the outer parentheses so a caller's `AND ${sql}` cannot split it off.
+    return { sql: `(${admitted} OR ${col}scope = ?)`, params: [...RECALL_DEFAULT_DENY_SCOPES, ownScope] };
+}
+/** SQL twin of canTouchScope, which is also canReadScope for an admin: every row but
+ * another person's personal one. LIKE folds ASCII case as isPersonalScope's /i does. */
+export function touchableScopeSql(col, ownScope) {
+    const notPersonal = `${col}scope IS NULL OR ${col}scope NOT LIKE '${PERSONAL_SCOPE_PREFIX}%'`;
+    if (ownScope == null)
+        return { sql: `(${notPersonal})`, params: [] };
+    return { sql: `(${notPersonal} OR ${col}scope = ?)`, params: [ownScope] };
+}
 //# sourceMappingURL=rule-sql.js.map

package/dist/store/search-rows.d.ts

@@ -18,13 +18,8 @@ export type OriginFilter = string | readonly string[];
 /** Scope rule for recall: none requested is default-deny; 'exact' narrows to the request; 'additive' adds it to the default set, unless it is personal,
  * which only `ownScope` opens. */
 export declare function recallScopeFilter(requestedScope: string | undefined, mode: 'exact' | 'additive', ownScope?: string): RecallScopeFilter;
-/** Sends term queries down the LIKE path on a build that has FTS. Only tests call it. */
-export declare function _forceLikePathForTests(on: boolean): void;
 /** Load likely search candidates: FTS5 when available, else LIKE, then full-store fallback. With `tenantId` every SELECT filters by it; omitted = no filter. */
 export declare function loadSearchEntries(hippoRoot: string, query: string, limit?: number, tenantId?: string): MemoryEntry[];
-/** Recall-mode loader: scope predicate in SQL so `unknown:legacy` cannot leak. Empty `requestedScope` default-denies (admits `ownScope`); else exact match.
- * SQL `NOT LIKE '%:private:%'` runs before the LIMIT so private rows cannot starve admitted ones; `passesScopeFilterForRecall` is the exact post-filter. */
-export declare function loadRecallSearchEntries(hippoRoot: string, query: string, limit?: number, tenantId?: string, requestedScope?: string, explicitScopeMode?: 'exact' | 'additive', includeSuperseded?: boolean, originProjects?: OriginFilter, ownScope?: string): MemoryEntry[];
 export interface RecallSearchEntriesOptions {
     readonly limit?: number;
     readonly tenantId?: string;
@@ -34,6 +29,11 @@ export interface RecallSearchEntriesOptions {
     readonly originProjects?: OriginFilter;
     readonly ownScope?: string;
 }
+/** Recall-mode loader: scope predicate in SQL so `unknown:legacy` cannot leak. Empty `requestedScope` default-denies (admits `ownScope`); else exact match.
+ * SQL `NOT LIKE '%:private:%'` runs before the LIMIT so private rows cannot starve admitted ones; `passesScopeFilterForRecall` is the exact post-filter. */
+export declare function loadRecallEntries(hippoRoot: string, query: string, options?: RecallSearchEntriesOptions): MemoryEntry[];
+/** Positional form of `loadRecallEntries`, kept internal because the frozen q3b-ranker-floor benchmark imports it from dist. */
+export declare function loadRecallSearchEntries(hippoRoot: string, query: string, limit?: number, tenantId?: string, requestedScope?: string, explicitScopeMode?: 'exact' | 'additive', includeSuperseded?: boolean, originProjects?: OriginFilter, ownScope?: string): MemoryEntry[];
 export declare function loadRecallSearchEntriesFromDb(db: DatabaseSyncLike, query: string, options?: RecallSearchEntriesOptions): MemoryEntry[];
 /** Which rows the vector arm of hybrid search may add: the same tenant, scope and superseded rules as the lexical load. */
 export interface VectorCandidateSpec {

package/dist/store/search-rows.js

@@ -1,6 +1,7 @@
 import { isFtsAvailable, closeHippoDb } from '../db/index.js';
 import { tokenize } from '../util/tokenize.js';
-import { isPersonalScope, scopeAdmitSql } from './recall-scope.js';
+import { isPersonalScope } from '../core/recall-scope.js';
+import { scopeAdmitSql } from './rule-sql.js';
 import { ftsTermParts, RAREST_TERM_COUNT, rarestFtsQuery } from '../core/prompt-recall.js';
 import { errorMessage, log } from '../util/log.js';
 import { originInSql } from '../core/project-identity.js';
@@ -8,6 +9,7 @@ import { topVectorMatches } from '../db/vector-store.js';
 import { MEMORY_SELECT_COLUMNS, MEMORY_SEARCH_COLUMNS, DEFAULT_SEARCH_CANDIDATE_LIMIT, rowToEntry, } from './rows.js';
 import { onHandle, openStore } from './open.js';
 import { escapeLike } from '../util/escape.js';
+import { placeholders } from '../util/sql.js';
 /** The recall scope rule for a table column prefix (`m.` or none); `passesScopeFilterForRecall` in recall-scope.ts is its JS twin. */
 function recallScopeClause(col, scopeFilter) {
     if (scopeFilter === undefined)
@@ -26,7 +28,10 @@ function withProject(scope, col, origin) {
         return scope;
     // A string is the shape published callers passed before a project could carry several names.
     const originProjects = [origin].flat();
-    return { sql: `${scope.sql} AND (${col}origin_project = '' OR ${originInSql(originProjects, `${col}origin_project`)})`, params: [...scope.params, ...originProjects] };
+    return {
+        sql: `${scope.sql} AND (${col}origin_project = '' OR ${originInSql(originProjects, `${col}origin_project`)})`,
+        params: [...scope.params, ...originProjects],
+    };
 }
 /** Scope rule for recall: none requested is default-deny; 'exact' narrows to the request; 'additive' adds it to the default set, unless it is personal,
  * which only `ownScope` opens. */
@@ -36,11 +41,6 @@ export function recallScopeFilter(requestedScope, mode, ownScope) {
     return mode === 'additive' ? { mode: 'default-deny-or-exact', value: requestedScope, ownScope } : { mode: 'exact', value: requestedScope };
 }
 const FTS_QUERY_SYNTAX_RE = /fts5: syntax error|unterminated string/i;
-let forceLikePath = false;
-/** Sends term queries down the LIKE path on a build that has FTS. Only tests call it. */
-export function _forceLikePathForTests(on) {
-    forceLikePath = on;
-}
 function loadSearchRows(db, query, limit, tenantId, options = {}) {
     const { scopeFilter, includeSuperseded = true, originProjects } = options;
     const p = searchPredicates(tenantId, scopeFilter, includeSuperseded, originProjects);
@@ -49,8 +49,7 @@ function loadSearchRows(db, query, limit, tenantId, options = {}) {
         // LIMIT here too, so every candidate path honours the caller's cap.
         return selectAllCandidates(db, p, limit);
     }
-    // The test switch is read here, not in `isFtsAvailable`, so writes never skip FTS index sync.
-    if (!forceLikePath && isFtsAvailable(db)) {
+    if (isFtsAvailable(db)) {
         const rows = selectFtsCandidates(db, terms, p, limit);
         if (rows.length > 0)
             return rows;
@@ -85,7 +84,8 @@ function searchPredicates(tenantId, scopeFilter, includeSuperseded, originProjec
 }
 /** Every admitted row, oldest first; the no-terms path and the last-resort fallback share it. */
 function selectAllCandidates(db, p, limit) {
-    const sql = `SELECT ${MEMORY_SELECT_COLUMNS} FROM memories${p.tenantOnlyPredicate}${p.archivedClauseTenantOnly}${p.plainScope.sql}${p.currentNoAlias} ORDER BY created ASC, id ASC LIMIT ?`;
+    const sql = `SELECT ${MEMORY_SELECT_COLUMNS} FROM memories${p.tenantOnlyPredicate}${p.archivedClauseTenantOnly}` +
+        `${p.plainScope.sql}${p.currentNoAlias} ORDER BY created ASC, id ASC LIMIT ?`;
     // SAFETY: sql selects exactly MEMORY_SELECT_COLUMNS, whose column list
     // matches MemoryRow's field set.
     return db.prepare(sql).all(...p.tenantParams, ...p.scopeParams, limit);
@@ -147,15 +147,17 @@ export function loadSearchEntries(hippoRoot, query, limit = DEFAULT_SEARCH_CANDI
 }
 /** Recall-mode loader: scope predicate in SQL so `unknown:legacy` cannot leak. Empty `requestedScope` default-denies (admits `ownScope`); else exact match.
  * SQL `NOT LIKE '%:private:%'` runs before the LIMIT so private rows cannot starve admitted ones; `passesScopeFilterForRecall` is the exact post-filter. */
+export function loadRecallEntries(hippoRoot, query, options = {}) {
+    return onHandle(hippoRoot, (db) => loadRecallSearchEntriesFromDb(db, query, options), openStore);
+}
+/** Positional form of `loadRecallEntries`, kept internal because the frozen q3b-ranker-floor benchmark imports it from dist. */
 export function loadRecallSearchEntries(hippoRoot, query, limit = DEFAULT_SEARCH_CANDIDATE_LIMIT, tenantId, requestedScope, explicitScopeMode = 'exact', includeSuperseded = true, originProjects, ownScope) {
-    return onHandle(hippoRoot, (db) => {
-        return loadRecallSearchEntriesFromDb(db, query, { limit, tenantId, requestedScope, explicitScopeMode, includeSuperseded, originProjects, ownScope });
-    }, openStore);
+    return loadRecallEntries(hippoRoot, query, { limit, tenantId, requestedScope, explicitScopeMode, includeSuperseded, originProjects, ownScope });
 }
 // Split out so callers with an already-open db (the prompt-recall path) skip
 // the initStore+open/close cycle per store per call.
 export function loadRecallSearchEntriesFromDb(db, query, options = {}) {
-    const { limit = DEFAULT_SEARCH_CANDIDATE_LIMIT, tenantId, requestedScope, explicitScopeMode = 'exact', includeSuperseded = true, originProjects, ownScope } = options;
+    const { limit = DEFAULT_SEARCH_CANDIDATE_LIMIT, tenantId, requestedScope, explicitScopeMode = 'exact', includeSuperseded = true, originProjects, ownScope, } = options;
     const scopeFilter = recallScopeFilter(requestedScope, explicitScopeMode, ownScope);
     return loadSearchRows(db, query, limit, tenantId, { scopeFilter, includeSuperseded, originProjects }).map(rowToEntry);
 }
@@ -171,7 +173,7 @@ export async function loadVectorCandidateEntries(hippoRoot, queryVector, spec) {
         if (matches.length === 0)
             return [];
         // SAFETY: the SELECT names exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
-        const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id IN (${matches.map(() => '?').join(', ')})`)
+        const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE id IN (${placeholders(matches.length)})`)
             .all(...matches.map((m) => m.id));
         const byId = new Map(rows.map((r) => [r.id, rowToEntry(r)]));
         return matches.flatMap((m) => byId.get(m.id) ?? []);
@@ -192,7 +194,7 @@ export function pickRarestFtsQuery(db, terms, maxTerms = RAREST_TERM_COUNT) {
         return '';
     // SAFETY: rows' shape matches the two columns named in the SELECT.
     const rows = db
-        .prepare(`SELECT term, doc FROM temp.z1_rarest_vocab WHERE term IN (${vocab.map(() => '?').join(', ')})`)
+        .prepare(`SELECT term, doc FROM temp.z1_rarest_vocab WHERE term IN (${placeholders(vocab.length)})`)
         .all(...vocab);
     const counts = new Map(rows.map((r) => [r.term, r.doc]));
     return rarestFtsQuery(terms, (part) => counts.get(part) ?? 0, maxTerms);

package/dist/store/sessions.js

@@ -1,3 +1,4 @@
+import { HOUR_MS } from '../util/time.js';
 import { isSharedStore } from '../core/config.js';
 import { closeHippoDb, HOOK_DB_WAIT_MS, scopedBusyWait, withWriteScope } from '../db/index.js';
 import { raiseMinBinary } from '../db/meta.js';
@@ -24,8 +25,9 @@ export function continuityStamp(key) {
 }
 // An unkeyed write acts on the tenant's newest or every active row, which on a shared store belong to other owners.
 function assertKeyedOnSharedStore(fn, hippoRoot, key) {
-    if (!key && isSharedStore(hippoRoot))
+    if (!key && isSharedStore(hippoRoot)) {
         throw new Error(`${fn}: a shared store keeps one task snapshot per owner and project, so this write needs their continuity key`);
+    }
 }
 function insertSnapshot(db, tenantId, snapshot, now, stamp) {
     const result = db.prepare(`
@@ -95,7 +97,7 @@ export function loadActiveTaskSnapshot(hippoRoot, tenantId, key) {
 }
 /** Default freshness bound for AMBIENT active-task-snapshot reads: 72h rather than 48h so a Friday-evening orphan still offers continuity on Monday;
  * override via `loadFreshActiveTaskSnapshot`'s `opts.maxAgeMs`; deliberately no env knob. */
-export const SNAPSHOT_AMBIENT_MAX_AGE_MS = 72 * 60 * 60 * 1000;
+export const SNAPSHOT_AMBIENT_MAX_AGE_MS = 72 * HOUR_MS;
 /** A usable session id: non-null, non-empty string; named so the owner-match rule in `loadFreshActiveTaskSnapshot` states its contract once. */
 function isNonEmptySessionId(value) {
     return typeof value === 'string' && value.length > 0;

package/dist/store/set-aside.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseSyncLike } from '../db/index.js';
+import { type MemoryEntry } from '../core/memory.js';
+export declare const SYNC_ACTOR = "agent-memories";
+export type SetAsideWhy = 'note-gone' | 'note-changed' | 'handover' | 'project-merge' | 'project-repair';
+export type SetAsideResult = {
+    readonly kind: 'untagged';
+    readonly entry: MemoryEntry;
+} | {
+    readonly kind: 'dormant';
+    readonly id: string;
+};
+/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
+export declare function setAsideRow(db: DatabaseSyncLike, tag: string, row: MemoryEntry, why: SetAsideWhy): SetAsideResult;
+//# sourceMappingURL=set-aside.d.ts.map

package/dist/store/set-aside.js

@@ -0,0 +1,23 @@
+// Takes an imported agent note out of recall on the caller's transaction; the note sync and the project repair both use it.
+import { appendAuditEvent } from './audit.js';
+import { insertDormantRow } from './dormant.js';
+import { calculateStrength } from '../core/memory.js';
+import { deleteEntryRowInTx, setEntryTagsInTx } from './entry-writes.js';
+export const SYNC_ACTOR = 'agent-memories';
+/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
+export function setAsideRow(db, tag, row, why) {
+    const untagged = { ...row, tags: row.tags.filter((t) => t !== tag) };
+    const audit = (metadata) => appendAuditEvent(db, { tenantId: row.tenant_id, actor: SYNC_ACTOR, op: 'agent_memory_set_aside', targetId: row.id, metadata });
+    if (row.pinned) {
+        setEntryTagsInTx(db, untagged);
+        audit({ why, untagged: true });
+        return { kind: 'untagged', entry: untagged };
+    }
+    const now = new Date();
+    // Sleep's dormant move skips kept rows, so the steps are written out here without its filter.
+    insertDormantRow(db, { entry: untagged, strength: calculateStrength(row, now), reason: 'source-deleted', dormantAt: now.toISOString() });
+    deleteEntryRowInTx(db, row, SYNC_ACTOR);
+    audit({ why });
+    return { kind: 'dormant', id: row.id };
+}
+//# sourceMappingURL=set-aside.js.map

package/dist/store/sqlite/busy.d.ts

@@ -0,0 +1,3 @@
+/** A held lock in any store: SQLite's busy codes or a port's StoreBusyError. */
+export declare function isStoreBusy<E>(error: E): boolean;
+//# sourceMappingURL=busy.d.ts.map

package/dist/store/sqlite/busy.js

@@ -0,0 +1,8 @@
+// Busy detection lives with the adapter, so the port names no SQLite error code.
+import { isSqliteBusy } from '../../db/busy.js';
+import { StoreBusyError } from '../port.js';
+/** A held lock in any store: SQLite's busy codes or a port's StoreBusyError. */
+export function isStoreBusy(error) {
+    return error instanceof StoreBusyError || isSqliteBusy(error);
+}
+//# sourceMappingURL=busy.js.map

package/dist/store/sqlite/connector-events-group.js

@@ -1,22 +1,19 @@
 // hippo.db's half of the ConnectorEvents store group: each call on a handle of its own.
-import { archiveDeletedArtifact, eventSeenAt, githubRouting, insertGitHubDlq, logEvent, seenEvent } from '../connectors/github.js';
+import { archiveDeletedArtifact, githubEventRecord, githubEventSeenAt, githubRouting, insertGitHubDlq, markGitHubEventSeen } from '../connectors/github.js';
 import { insertSlackDlq, markSlackEventSeen, rawMemoryIdForArtifactAt, slackEventRecord, slackEventSeenAt, slackTeamRoute } from '../connectors/slack.js';
 import { onHandle } from '../open.js';
 function eventRecord(hippoRoot, event) {
-    if (event.connector === 'slack')
-        return slackEventRecord(hippoRoot, event.eventId);
-    const logged = seenEvent(hippoRoot, event.idempotencyKey);
-    return logged ? { seen: true, memoryId: logged.memoryId } : { seen: false };
+    return event.connector === 'slack' ? slackEventRecord(hippoRoot, event.eventId) : githubEventRecord(hippoRoot, event.idempotencyKey);
 }
 function markEventSeen(hippoRoot, event) {
     if (event.connector === 'slack')
         return markSlackEventSeen(hippoRoot, event.eventId, null);
     const { idempotencyKey, deliveryId, eventName } = event;
-    logEvent(hippoRoot, { idempotencyKey, deliveryId, eventName, memoryId: null });
+    markGitHubEventSeen(hippoRoot, { idempotencyKey, deliveryId, eventName, memoryId: null });
 }
 function deletionTarget(hippoRoot, { event, artifactRef, tenantId }) {
     return onHandle(hippoRoot, (db) => {
-        const seen = event.connector === 'slack' ? slackEventSeenAt(db, event.eventId) : eventSeenAt(db, event.idempotencyKey);
+        const seen = event.connector === 'slack' ? slackEventSeenAt(db, event.eventId) : githubEventSeenAt(db, event.idempotencyKey);
         return seen ? { seen: true } : { seen: false, memoryId: rawMemoryIdForArtifactAt(db, artifactRef, tenantId) };
     });
 }

package/dist/store/sqlite/connector-writes-group.js

@@ -1,4 +1,4 @@
-import { eventMemoryAt, logEventAt } from '../connectors/github.js';
+import { githubEventMemoryAt, markGitHubEventSeenAt } from '../connectors/github.js';
 import { markSlackEventSeenAt, slackEventMemoryAt } from '../connectors/slack.js';
 import { stampOriginProject } from '../entry-row.js';
 import { writeEntryMirrors } from '../entry-writes.js';
@@ -13,16 +13,18 @@ function logEvent(db, event, memoryId) {
     if (event.connector === 'slack')
         return markSlackEventSeenAt(db, event.eventId, memoryId);
     const { idempotencyKey, deliveryId, eventName } = event;
-    return logEventAt(db, { idempotencyKey, deliveryId, eventName, memoryId });
+    return markGitHubEventSeenAt(db, { idempotencyKey, deliveryId, eventName, memoryId });
 }
 function loggedMemory(db, event) {
-    return event.connector === 'slack' ? slackEventMemoryAt(db, event.eventId) : eventMemoryAt(db, event.idempotencyKey);
+    return event.connector === 'slack' ? slackEventMemoryAt(db, event.eventId) : githubEventMemoryAt(db, event.idempotencyKey);
 }
 /** The record, then the log row, go in after the memory row and ahead of its remember row, as a second store must order them. */
 function writeWithCompanions(db, { entry, actor, event, quarantine }) {
     writeInOwnTenant(db, entry, actor, (handle, memoryId) => {
         if (quarantine)
-            recordQuarantine(handle, { tenantId: entry.tenantId, memoryId, originalScope: quarantine.originalScope, reason: quarantine.reason, actor });
+            recordQuarantine(handle, {
+                tenantId: entry.tenant_id, memoryId, originalScope: quarantine.originalScope, reason: quarantine.reason, actor,
+            });
         if (event && !logEvent(handle, event, memoryId))
             throw new EventAlreadyLogged();
     });

package/dist/store/sqlite/entry-writes-group.d.ts

@@ -2,11 +2,11 @@ import { type DatabaseSyncLike } from '../../db/index.js';
 import { type MemoryEntry } from '../../core/memory.js';
 import { type ArchiveOpts } from '../raw-archive.js';
 import type { EntryWrite, EntryWrites, OutcomeWrite, RawArchive, Sync } from '../port.js';
-import { type WriteEntryOptions } from '../entry-writes.js';
+import { type WriteEntryInternalOptions } from '../entry-writes.js';
 /** Each call on its own handle; mirrors and the forgotten counter follow the commit, so a rolled-back write leaves neither. */
 export declare function sqliteEntryWrites(hippoRoot: string): Sync<EntryWrites>;
 /** A store-side hook writes on the row's handle inside its write scope, so its throw undoes the row. */
-export declare function writeEntryAt(hippoRoot: string, { entry, actor }: EntryWrite, afterWrite?: WriteEntryOptions['afterWrite']): void;
+export declare function writeEntryAt(hippoRoot: string, { entry, actor }: EntryWrite, afterWrite?: WriteEntryInternalOptions['afterWrite']): void;
 /** A trace link follows the commit on the same handle and names only the ids applied, so a rolled-back outcome leaves none. */
 export declare function applyOutcomeAt(hippoRoot: string, outcome: OutcomeWrite, traceId?: number): string[];
 /** Reach is checked inside the archive's write scope. A store-side hook writes on the same handle inside that scope, so its throw undoes the archive. */
@@ -14,5 +14,5 @@ export declare function archiveRawAt(hippoRoot: string, archive: RawArchive, aft
 /** The refusal row lands after `write` has rolled back, in a fresh implicit transaction the aborted one cannot undo. */
 export declare function auditingRefusal<T>(db: DatabaseSyncLike, actor: string, write: () => T): T;
 /** writeEntryAt on the caller's handle, so a sibling group can read on it after the scope has unwound. */
-export declare function writeInOwnTenant(db: DatabaseSyncLike, entry: MemoryEntry, actor: string, afterWrite?: WriteEntryOptions['afterWrite']): void;
+export declare function writeInOwnTenant(db: DatabaseSyncLike, entry: MemoryEntry, actor: string, afterWrite?: WriteEntryInternalOptions['afterWrite']): void;
 //# sourceMappingURL=entry-writes-group.d.ts.map

package/dist/store/sqlite/entry-writes-group.js

@@ -5,9 +5,9 @@ import { isSqliteBusy, withWriteScope } from '../../db/index.js';
 import { errorFields, errorMessage, log } from '../../util/log.js';
 import { entryAfterOutcome } from '../../core/memory.js';
 import { archiveRawMemory } from '../raw-archive.js';
-import { ownScopeTouches } from '../recall-scope.js';
+import { ownScopeTouches } from '../../core/recall-scope.js';
 import { recordTraceOutcome } from '../recall-trace.js';
-import { RejectedValueError } from '../rejection.js';
+import { RejectedValueError } from '../../core/api-errors.js';
 import { markSummaryDirtyInTx } from '../summary-dirty.js';
 import { auditRejectionRefusal } from '../audit-event.js';
 import { deleteEntryCore } from '../delete-and-batch.js';
@@ -91,7 +91,7 @@ function assertInReach(db, target, id) {
 /** hippo.db's upsert would move the row into the writer's tenant, so a store write refuses an id another tenant holds. */
 function assertIdInTenant(db, entry) {
     const holder = selectMemoryReach(db, entry.id)?.tenantId;
-    if (holder !== undefined && holder !== entry.tenantId)
+    if (holder !== undefined && holder !== entry.tenant_id)
         throw new ConflictError(`Memory ${entry.id} belongs to another tenant`);
 }
 /** The refusal row lands after `write` has rolled back, in a fresh implicit transaction the aborted one cannot undo. */

package/dist/store/sqlite/error-codec.js

@@ -2,11 +2,12 @@
 // of its class: the server's mappers test `instanceof`, `errcode` and fields.
 import { BadRequestError, ConflictError, ForbiddenError, NotFoundError } from '../../core/api-errors.js';
 import { RawAppendOnlyError } from '../../core/raw-append-only.js';
-import { IncompatibleBinaryError, StoreBusyError } from '../../db/index.js';
+import { IncompatibleBinaryError } from '../../db/index.js';
+import { StoreBusyError } from '../port.js';
 import { BodyTimeoutError, BodyTooLargeError, HttpError } from '../../util/http-util.js';
 import { errorMessage, log } from '../../util/log.js';
-import { ScopeForbiddenError } from '../recall-scope.js';
-import { RejectedValueError } from '../rejection.js';
+import { ScopeForbiddenError } from '../../core/recall-scope.js';
+import { RejectedValueError } from '../../core/api-errors.js';
 import { OtherStoreFolderError, SqliteBlockedError, StoreNotPortedError } from '../../util/sqlite-blocked.js';
 // Every class the server maps by, at or below the store layer. Abstract ApiError is absent: only its four subclasses are thrown.
 const CLASSES = [

package/dist/store/sqlite/executor.js

@@ -2,11 +2,12 @@
 import { fileURLToPath } from 'node:url';
 import { SHARE_ENV, Worker } from 'node:worker_threads';
 import { addAuditWriteFailures } from '../audit.js';
-import { getHippoDbPath, SERVER_DB_WAIT_MS, StoreBusyError } from '../../db/index.js';
+import { getHippoDbPath, SERVER_DB_WAIT_MS } from '../../db/index.js';
+import { StoreBusyError } from '../port.js';
 import { autoCheckpointPages } from '../../db/wal-checkpointer.js';
 import { envStoreQueueMax } from '../../util/env.js';
 import { DeadlineExceededError } from '../../util/http-util.js';
-import { errorMessage, log } from '../../util/log.js';
+import { errorFields, errorMessage, log } from '../../util/log.js';
 import { requestScopes } from '../../util/request-scope.js';
 import { decodeError } from './error-codec.js';
 import { workerCounts } from './executor-counts.js';
@@ -27,6 +28,10 @@ const DEFAULT_WRITE_GRACE_MS = 2000;
 function laneOf(mode) {
     return { mode, queue: [], running: undefined, worker: undefined, stopping: undefined, commitFlag: undefined };
 }
+// A thread that will not stop leaves a live worker behind, so the rejection is logged rather than dropped.
+function terminateLogged(worker) {
+    worker.terminate().catch((err) => log.warn('the store worker did not terminate cleanly', errorFields(err)));
+}
 /** Gives `pending`'s caller its one answer; a second call does nothing. */
 function finish(pending, answer) {
     if (pending.answered)
@@ -153,7 +158,7 @@ class WorkerPool {
     #stopReader(lane, worker, pending) {
         finish(pending, () => pending.fail(new DeadlineExceededError(READ_LATE)));
         lane.stopping = worker;
-        void worker.terminate();
+        terminateLogged(worker);
     }
     // Before its commit flag a stopped write is a known rollback; after it the thread is left to finish, since stopping it could not undo the write.
     #stopWriter(lane, worker, pending) {
@@ -195,7 +200,8 @@ class WorkerPool {
         return this.#exits.size;
     }
     terminateWriter() {
-        void this.#writer.worker?.terminate();
+        if (this.#writer.worker)
+            terminateLogged(this.#writer.worker);
     }
     #pump(lane) {
         if (lane.running !== undefined)

package/dist/store/sqlite/graph-reads-group.js

@@ -1,5 +1,5 @@
 // hippo.db's half of the GraphReads store group: one read snapshot around the walk the CLI graph commands run.
-import { canReadScope } from '../recall-scope.js';
+import { canReadScope } from '../../core/recall-scope.js';
 import { withGraphReadSnapshot } from '../graph-reads.js';
 import { graphViewRows } from '../graph-view-rows.js';
 export function sqliteGraphReads(hippoRoot) {