hippo-memory 1.70.0 → 1.72.0

package/dist/store/sqlite/held-connection.d.ts

@@ -0,0 +1,9 @@
+/** What the server calls around its responses to keep its store connection. */
+export interface StoreHolder {
+    hold: () => void;
+    afterResponse: () => void;
+    release: () => Promise<void>;
+}
+/** Holds a connection to the hippo.db under `hippoRoot` once it exists, so serving never creates one. */
+export declare function holdSqliteConnection(hippoRoot: string): StoreHolder;
+//# sourceMappingURL=held-connection.d.ts.map

package/dist/store/sqlite/held-connection.js

@@ -0,0 +1,41 @@
+// A served hippo.db keeps one connection open for the life of the server, beside the worker that checkpoints its WAL.
+import { existsSync } from 'node:fs';
+import { closeHippoDb, getHippoDbPath, openHippoDb, outsideRequestStores, outsideSqliteOffLoop, SERVER_DB_WAIT_MS, } from '../../db/index.js';
+import { startWalCheckpointer } from '../../db/wal-checkpointer.js';
+import { errorMessage, log } from '../../util/log.js';
+/** Holds a connection to the hippo.db under `hippoRoot` once it exists, so serving never creates one. */
+export function holdSqliteConnection(hippoRoot) {
+    // Handlers open and close their own connections; while this one is held, none of those closes is SQLite's last,
+    // which checkpoints and deletes the WAL.
+    let heldDb;
+    let checkpointer;
+    let stopHolding = false;
+    const hold = () => {
+        if (heldDb || stopHolding || !existsSync(getHippoDbPath(hippoRoot)))
+            return;
+        try {
+            // The 'finish' listener can fire inside a request scope (closing this connection with the request) and inside a `loop: 'off'` block (refusing the open).
+            // The server's lock wait: this open runs on the event loop, where SQLite's 5 s default and the 30 s journal-mode retry would stall every request.
+            heldDb = outsideSqliteOffLoop(() => outsideRequestStores(() => openHippoDb(hippoRoot, { busyWaitMs: SERVER_DB_WAIT_MS })));
+            checkpointer = startWalCheckpointer(getHippoDbPath(hippoRoot));
+        }
+        catch (err) {
+            stopHolding = true;
+            log.warn(`serve: could not hold a store connection; requests still work, only slower: ${errorMessage(err)}`);
+        }
+    };
+    const afterResponse = () => {
+        hold();
+        checkpointer?.noteResponse();
+    };
+    const release = async () => {
+        stopHolding = true;
+        // The worker's connection closes first, so the held one is SQLite's last and its close checkpoints and deletes the WAL.
+        await checkpointer?.stop();
+        if (heldDb)
+            closeHippoDb(heldDb);
+        heldDb = undefined;
+    };
+    return { hold, afterResponse, release };
+}
+//# sourceMappingURL=held-connection.js.map

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

@@ -8,9 +8,9 @@ export interface SqliteLocal {
     applyOutcome(outcome: OutcomeWrite, traceId: number): string[];
     /** applyOutcome on the ids of the last recall, which hippo.db's meta table holds with that recall's trace; answers the ids applied. */
     applyOutcomeToLastRecall(target: EntryTarget, good: boolean): string[];
-    /** finishRecall, then the ids this root lacks strengthened under `globalRoot`, then the ids and their trace saved as the last recall.
-     *  A store of another kind keeps no last recall, so its stand-in is its own finishRecall, hence the Promise. */
-    finishLastRecall(writes: LastRecallWrites, globalRoot: string | undefined): void | Promise<void>;
+    /** finishRecall, then the ids this root lacks strengthened under `globalRoot`, then the ids and their trace saved as the last recall;
+     *  answers the trace id. A store of another kind keeps no last recall, so its stand-in is its own finishRecall, answering null. */
+    finishLastRecall(writes: LastRecallWrites, globalRoot: string | undefined): number | null | Promise<number | null>;
 }
 export declare function sqliteLocal(hippoRoot: string): SqliteLocal;
 /** What a served store answers for each write that needs hippo.db's own handle: a refusal. */

package/dist/store/sqlite/local.js

@@ -22,6 +22,7 @@ export function sqliteLocal(hippoRoot) {
                 strengthenRetrieved(globalRoot, ids.filter((id) => !strengthened.has(id)), opts);
             // One write for both keys, so an outcome never pairs these ids with an older trace; a lost trace saves null.
             saveIndex(hippoRoot, { last_retrieval_ids: [...ids], last_trace_id: traceId === null ? null : String(traceId) });
+            return traceId;
         },
     };
 }

package/dist/store/sqlite/object-rows.d.ts

@@ -1,7 +1,7 @@
 import type { AuditOp } from '../audit.js';
 import type { JsonObject } from '../working-memory.js';
 import type { SourceObjectType } from '../graph-rows.js';
-import type { BriefStatus, DecisionStatus, IncidentStatus, NoteStatus, ObjectByKind, ObjectFields, ObjectKind, PolicyStatus, ProcessStatus, SavableKind, SkillStatus } from '../object-types.js';
+import type { BriefStatus, DecisionStatus, IncidentStatus, NoteStatus, ObjectByKind, ObjectFields, ObjectKind, PolicyStatus, ProcessStatus, SavableKind, SkillStatus } from '../../core/object-types.js';
 interface HeadRow {
     id: number;
     memory_id: string | null;

package/dist/store/sqlite/object-rows.js

@@ -52,21 +52,24 @@ function rowToIncident(row) {
         createdAt: row.created_at,
     };
 }
-/** A malformed stored steps value reads back as no steps. */
-function parseSteps(raw) {
+/** A malformed stored steps value warns and reads back as no steps. */
+function parseSteps(raw, id) {
+    const site = { table: 'processes', id, column: 'steps' };
     try {
         const parsed = JSON.parse(raw);
         if (Array.isArray(parsed) && parsed.every(isJsonString)) {
             return parsed;
         }
+        warnDamagedColumn(site, 'wrong shape');
         return [];
     }
     catch {
         // Unreadable steps read back as none instead of failing the process read.
+        warnDamagedColumn(site, 'not valid JSON');
         return [];
     }
 }
-const rowToProcess = (row) => ({ ...head(row), processName: row.process_name, description: row.description, steps: parseSteps(row.steps), ...versionedTail(row) });
+const rowToProcess = (row) => ({ ...head(row), processName: row.process_name, description: row.description, steps: parseSteps(row.steps, row.id), ...versionedTail(row) });
 const rowToPolicy = (row) => ({ ...head(row), policyName: row.policy_name, policyText: row.policy_text, validFrom: row.valid_from, validTo: row.valid_to, ...versionedTail(row) });
 const rowToSkill = (row) => ({ ...head(row), skillName: row.skill_name, instructions: row.instructions, trigger: row.trigger_text, ...versionedTail(row) });
 const rowToProjectBrief = (row) => ({ ...head(row), repo: row.repo, summary: row.summary, ...versionedTail(row) });

package/dist/store/sqlite/objects-group.d.ts

@@ -1,4 +1,4 @@
-import type { BriefReceipt, Incident, ObjectByKind, ObjectKind, Policy, SavableKind, Skill } from '../object-types.js';
+import type { BriefReceipt, Incident, ObjectByKind, ObjectKind, Policy, SavableKind, Skill } from '../../core/object-types.js';
 import { type IncidentOpen, type IncidentOpenRefusal, type IncidentResolve, type ObjectClose, type ObjectListQuery, type ObjectRefusal, type Objects, type ObjectSave, type PoliciesInForceQuery } from '../port.js';
 /** The group with each answer as its value; spelled out because `Sync<Objects>` would widen each method's kind to every kind. */
 export interface SyncObjects {

package/dist/store/sqlite/objects-group.js

@@ -4,7 +4,7 @@ import { getMeta, withWriteScopeOr } from '../../db/index.js';
 import { escapeLike } from '../../util/escape.js';
 import { keysetAfter } from '../../util/keyset.js';
 import { calculateStrength, deriveHalfLife } from '../../core/memory.js';
-import { scopeAdmitSql } from '../recall-scope.js';
+import { scopeAdmitSql } from '../rule-sql.js';
 import { stampOriginProject, upsertEntryRow } from '../entry-row.js';
 import { auditEntryWrite, writeEntryMirrors } from '../entry-writes.js';
 import { markGraphDirty } from '../graph-queue.js';
@@ -100,7 +100,8 @@ function closeAt(hippoRoot, tenantId, kind, id, close) {
         const closed = closeRow(db, tenantId, kind, id, close);
         if (isObjectRefusal(closed) || !graphType)
             return closed;
-        // Each graph write takes its own write lock, so both wait for the commit. The rows go at once because the rebuild queue is keyed by a mirror memory that may be gone.
+        // Each graph write takes its own write lock, so both wait for the commit. The rows
+        // go at once because the rebuild queue is keyed by a mirror memory that may be gone.
         removeGraphEntitiesForObject(hippoRoot, tenantId, graphType, closed.id);
         markGraphDirty(hippoRoot, tenantId, closed.memoryId);
         return closed;
@@ -177,7 +178,8 @@ function writeObjectRow(db, tenantId, kind, memoryId, save) {
 function refusalOf(written) {
     return 'refused' in written;
 }
-/** Until the typed migration has run, a mirror goes in on the flat half-life that migration moves; the flag is read under the save's write lock, so the two cannot interleave. */
+/** Until the typed migration has run, a mirror goes in on the flat half-life that migration
+ * moves; the flag is read under the save's write lock, so the two cannot interleave. */
 function onStoreHalfLife(db, mirror) {
     if (getMeta(db, TYPED_HALF_LIFE_META_KEY, '') !== '')
         return mirror;

package/dist/store/sqlite/quarantine-group.js

@@ -1,5 +1,5 @@
 // hippo.db's half of the Quarantine store group: each method is one call on its own handle.
-import { errorMessage, log } from '../../util/log.js';
+import { errorFields, errorMessage, log } from '../../util/log.js';
 import { readEntry } from '../entry-reads.js';
 import { writeEntryMirrors } from '../entry-writes.js';
 import { onHandle } from '../open.js';
@@ -12,7 +12,7 @@ function rewriteMirror(hippoRoot, tenantId, id) {
             writeEntryMirrors(hippoRoot, restored);
     }
     catch (err) {
-        log.error(`quarantine: mirror rewrite failed for ${id}: ${errorMessage(err)}`);
+        log.error(`quarantine: mirror rewrite failed for ${id}: ${errorMessage(err)}`, errorFields(err));
     }
 }
 export function sqliteQuarantine(hippoRoot) {

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

@@ -1,5 +1,4 @@
-import type { ContinuityBlock, HippoStore, RecallWrites, StoreGroups, Sync } from '../port.js';
-import { type ContinuityKey } from '../sessions.js';
+import type { HippoStore, RecallWrites, StoreGroups, Sync } from '../port.js';
 /** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
 export declare function storeFor(ctx: {
     readonly hippoRoot: string;
@@ -13,8 +12,6 @@ export type SqliteSyncStore = Sync<Omit<HippoStore, AsyncOnly>>;
 export declare function sqliteSyncStore(hippoRoot: string): SqliteSyncStore & Sync<Omit<StoreGroups, AsyncOnly>>;
 /** `sqliteSyncStore` as a served store: each method runs at once and answers through a Promise, so a throw rejects as another store's would. */
 export declare function sqliteStore(hippoRoot: string): HippoStore & StoreGroups;
-/** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
-export declare function continuityAt(hippoRoot: string, tenantId: string, eventLimit: number, key: ContinuityKey | null): ContinuityBlock;
 /** What a finished recall wrote after its audit rows: the trace's id, null when none was asked or its write failed, and the ids strengthened. */
 interface RecallFinish {
     readonly traceId: number | null;

package/dist/store/sqlite/store.js

@@ -4,7 +4,6 @@ import { listApiKeyRows, readApiKeyRecord } from '../auth.js';
 import { existsSync } from 'node:fs';
 import { appendAuditEvent, listAuditEventsAfter, queryAuditEvents } from '../audit.js';
 import { getHippoDbPath, withWriteScope } from '../../db/index.js';
-import { loadStoredVectorViews } from '../embeddings/index.js';
 import { activeGoalsWithPolicies, localGoalRecallRows, writeGoalRecallLog } from '../goals.js';
 import { planningFallacyEvidenceAt } from '../planning-fallacy-evidence.js';
 import { writeRecallTrace } from '../recall-trace.js';
@@ -28,7 +27,7 @@ import { createKeyAt, createSelfKeyAt } from '../key-writes.js';
 import { onHandle } from '../open.js';
 import { loadRecallSearchEntries } from '../search-rows.js';
 import { listSessionEvents, loadActiveTaskSnapshot } from '../sessions.js';
-import { entriesWithoutVectorAt, writeVectorsAt } from '../vector-writes.js';
+import { entriesWithoutVectorAt, loadStoredVectorViews, writeVectorsAt } from '../vector-index.js';
 /** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
 export function storeFor(ctx) {
     return ctx.store ?? sqliteStore(ctx.hippoRoot);
@@ -266,7 +265,7 @@ function sqliteKeyAudit(hippoRoot) {
     };
 }
 /** sqliteStore's continuity read, for the synchronous recall that cannot await the port. */
-export function continuityAt(hippoRoot, tenantId, eventLimit, key) {
+function continuityAt(hippoRoot, tenantId, eventLimit, key) {
     const activeSnapshot = loadActiveTaskSnapshot(hippoRoot, tenantId, key ?? undefined);
     const sessionId = activeSnapshot?.session_id ?? undefined;
     return {
@@ -278,18 +277,20 @@ export function continuityAt(hippoRoot, tenantId, eventLimit, key) {
 /** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */
 export function finishRecallAt(hippoRoot, writes) {
     return onHandle(hippoRoot, (db) => {
-        // With no row to write the scope would only take the write lock.
-        if (writes.goalLog.length > 0 || writes.audit.length > 0) {
-            withWriteScope(db, 'finish_recall', () => {
-                writeGoalRecallLog(db, localGoalRecallRows(db, writes.goalLog));
-                for (const event of writes.audit)
-                    appendAuditEvent(db, event);
-            });
-        }
-        // Each opens its own transaction, so neither can share the scope above.
-        const traceId = writes.trace ? writeRecallTrace(db, writes.trace) : null;
-        const strengthened = writes.strengthen ? strengthenRetrievedInOwnTx(db, writes.strengthen.ids, writes.strengthen.opts) : new Set();
-        return { traceId, strengthened };
+        const traceAndStrengthen = () => ({
+            traceId: writes.trace ? writeRecallTrace(db, writes.trace) : null,
+            strengthened: writes.strengthen ? strengthenRetrievedInOwnTx(db, writes.strengthen.ids, writes.strengthen.opts) : new Set(),
+        });
+        // Alone, the fail-soft trace and strengthen keep their own scopes so a busy lock loses them, never the read.
+        if (writes.goalLog.length === 0 && writes.audit.length === 0)
+            return traceAndStrengthen();
+        // Inside this scope both run as savepoints, so one recall commits once and a failed trace or strengthen still unwinds alone.
+        return withWriteScope(db, 'finish_recall', () => {
+            writeGoalRecallLog(db, localGoalRecallRows(db, writes.goalLog));
+            for (const event of writes.audit)
+                appendAuditEvent(db, event);
+            return traceAndStrengthen();
+        });
     });
 }
 //# sourceMappingURL=store.js.map

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

@@ -1,12 +1,12 @@
 // hippo.db's vector reads. Async only: the nearest-row scan yields between chunks, so a store worker awaits these where it runs every other method to its end.
 import { loadPhysicsState } from '../../db/physics-state.js';
-import { embeddingIndexStateAt, loadStoredVectors } from '../embeddings/index.js';
 import { onHandle } from '../open.js';
 import { loadVectorCandidateEntries } from '../search-rows.js';
+import { loadStoredVectors, storedIndexState } from '../vector-index.js';
 export function sqliteVectorReads(hippoRoot) {
     return {
         async embeddingIndexState() {
-            return embeddingIndexStateAt(hippoRoot);
+            return storedIndexState(hippoRoot);
         },
         async storedVectors(ids) {
             return loadStoredVectors(hippoRoot, ids);

package/dist/store/sqlite/worker-jobs.js

@@ -1,6 +1,6 @@
 import { auditWriteFailureCount } from '../audit.js';
 import { RequestStores } from '../../db/index.js';
-import { loadStoredVectorViews } from '../embeddings/index.js';
+import { loadStoredVectorViews } from '../vector-index.js';
 import { requestScopes } from '../../util/request-scope.js';
 import { initStore } from '../open.js';
 import { watchCommits } from './commit-watch.js';

package/dist/store/sqlite/worker-ops.d.ts

@@ -7,8 +7,8 @@ export type OpPlace = OpMode | 'server';
 export type OpPlaces<G> = {
     readonly [M in keyof G]: OpPlace;
 };
-/** The store methods that answer from a worker, the base ones under `base`. Tagged by effect, not by name: predictionBaserate appends an audit row and
- *  bumpRecallStats rewrites stats.json, so both are writes. A read that opens through `openStore` is a read: the writer runs that open's setup before any reader serves. */
+/** Store methods answered by a worker, base ones under `base`. Tagged by effect, not name: predictionBaserate (audit row) and bumpRecallStats
+ * (stats.json) are writes. A read that opens through `openStore` is a read: the writer runs that open's setup before any reader serves. */
 export declare const WORKER_OPS: {
     readonly base: {
         readonly findApiKey: "read";
@@ -82,6 +82,17 @@ export declare const WORKER_OPS: {
     readonly graphReads: {
         readonly graphRows: "read";
     };
+    readonly objects: {
+        readonly listObjects: "read";
+        readonly objectById: "read";
+        readonly closeObject: "write";
+        readonly saveObject: "write";
+        readonly openIncident: "write";
+        readonly resolveIncident: "write";
+        readonly policiesInForce: "read";
+        readonly activeSkillsByName: "read";
+        readonly briefReceipts: "read";
+    };
     readonly readiness: {
         readonly ping: "read";
     };

package/dist/store/sqlite/worker-ops.js

@@ -1,5 +1,5 @@
-/** The store methods that answer from a worker, the base ones under `base`. Tagged by effect, not by name: predictionBaserate appends an audit row and
- *  bumpRecallStats rewrites stats.json, so both are writes. A read that opens through `openStore` is a read: the writer runs that open's setup before any reader serves. */
+/** Store methods answered by a worker, base ones under `base`. Tagged by effect, not name: predictionBaserate (audit row) and bumpRecallStats
+ * (stats.json) are writes. A read that opens through `openStore` is a read: the writer runs that open's setup before any reader serves. */
 export const WORKER_OPS = {
     base: {
         findApiKey: 'read',
@@ -73,6 +73,17 @@ export const WORKER_OPS = {
     graphReads: {
         graphRows: 'read',
     },
+    objects: {
+        listObjects: 'read',
+        objectById: 'read',
+        closeObject: 'write',
+        saveObject: 'write',
+        openIncident: 'write',
+        resolveIncident: 'write',
+        policiesInForce: 'read',
+        activeSkillsByName: 'read',
+        briefReceipts: 'read',
+    },
     readiness: {
         ping: 'read',
     },

package/dist/store/sqlite/worker-store.js

@@ -35,7 +35,9 @@ function vectorGroups(executor, inProcess) {
             storedVectors: async (ids) => (ids.length === 0 ? new Map() : vectorCopiesOf(await pack('vectors.storedVectors', ids, vectors.storedVectors))),
         },
         vectorViews: {
-            storedVectorViews: async (ids) => (ids.length === 0 ? new Map() : vectorViewsOf(await pack('vectorViews.storedVectorViews', ids, vectorViews.storedVectorViews))),
+            storedVectorViews: async (ids) => (ids.length === 0
+                ? new Map()
+                : vectorViewsOf(await pack('vectorViews.storedVectorViews', ids, vectorViews.storedVectorViews))),
         },
     };
 }
@@ -52,7 +54,7 @@ function probing(hippoRoot, served) {
  *  `executor` defaults to threads of the store's own, with the server's lock wait. */
 export function workerSqliteStore(hippoRoot, executor = createSqliteExecutor(hippoRoot)) {
     const inProcess = sqliteStore(hippoRoot);
-    const { keyAudit, keyWrites, vectorWrites, entryWrites, contextReads, predictions, dagReads, auditLog, quarantine, graphReads } = WORKER_OPS;
+    const { keyAudit, keyWrites, vectorWrites, entryWrites, contextReads, predictions, dagReads, auditLog, quarantine, graphReads, objects } = WORKER_OPS;
     const store = {
         ...inProcess,
         ...onWorkers(executor, 'base', WORKER_OPS.base, inProcess),
@@ -67,6 +69,7 @@ export function workerSqliteStore(hippoRoot, executor = createSqliteExecutor(hip
         auditLog: onWorkers(executor, 'auditLog', auditLog, inProcess.auditLog),
         quarantine: onWorkers(executor, 'quarantine', quarantine, inProcess.quarantine),
         graphReads: onWorkers(executor, 'graphReads', graphReads, inProcess.graphReads),
+        objects: onWorkers(executor, 'objects', objects, inProcess.objects),
         readiness: probing(hippoRoot, onWorkers(executor, 'readiness', WORKER_OPS.readiness, inProcess.readiness)),
         close: () => executor.close(),
     };

package/dist/store/summaries.d.ts

@@ -1,50 +1,13 @@
 import type { MemoryEntry } from '../core/memory.js';
-/**
- * Mark a summary as dirty. Idempotent (re-marking dirty is a no-op + no
- * second audit row). Tenant-scoped to prevent cross-tenant writes via
- * parent-lookup. Called from invalidation.ts / writeEntry /
- * forgetMemory / archiveRawMemory whenever a child is invalidated,
- * superseded, forgotten, or archived.
- *
- * Quietly no-ops if the target row doesn't exist or isn't a level-2/3
- * summary. Emits a 'summary_marked_dirty' audit row on actual
- * state transitions (0 -> 1) via the audit() helper, which try/catches
- * for missing audit_log (the v27 self-heal scenario).
- */
-export declare function markSummaryDirty(hippoRoot: string, summaryId: string, tenantId: string, actor?: string): void;
-/**
- * Host-wide loader for L2 topic summaries without an L3 parent.
- * Used by consolidate phase 1.9 (buildEntityProfiles) to cluster L2s into
- * L3 entity profiles. Mirrors loadAllDirtySummaries: SQL-level
- * filter is cheaper than reusing in-memory `survivors` (which doesn't
- * contain L2s freshly created by phase 1.7 buildDag).
- *
- * Returns entries with tenantId attached so per-cluster writes stay
- * tenant-scoped via summary.tenantId.
- */
+/** Host-wide loader for L2 topic summaries without an L3 parent, for consolidate phase 1.9 (buildEntityProfiles); SQL-level filter, since in-memory
+ * `survivors` lacks L2s created by phase 1.7. Entries carry tenantId so per-cluster writes stay tenant-scoped. */
 export declare function loadAllL2Summaries(hippoRoot: string): MemoryEntry[];
-/**
- * Dirty summaries, newest change first. Iterates all tenants
- * in one query so consolidate.ts (host-wide per L106-109) does not need a
- * per-tenant loop. Each returned MemoryEntry carries its own tenantId (via
- * rowToEntry), so per-summary children + rebuild UPDATE stay tenant-scoped.
- *
- * Sort: latest_at DESC NULLS LAST, id ASC — same as per-tenant variant so
- * HIPPO_DAG_REBUILD_CAP takes most-recently-changed summaries first.
- */
-export declare function loadAllDirtySummaries(hippoRoot: string): MemoryEntry[];
-/**
- * Load live children of a DAG summary. Used by
- * rebuildDirtySummaries to regenerate content from the CURRENT child set
- * (not the children at create-time). Skips archived. Tenant-scoped
- * (defence in depth — dag_parent_id is unique-ish but tenant guard is
- * cheap). created column is TEXT NOT NULL since db.ts schema v1.
- */
+/** Dirty summaries across all tenants, newest change first (latest_at DESC NULLS LAST, id ASC), at most `limit` (all when omitted)
+ * so HIPPO_DAG_REBUILD_CAP reads only the most recently changed. Each entry carries its tenantId so later writes stay tenant-scoped. */
+export declare function loadAllDirtySummaries(hippoRoot: string, limit?: number): MemoryEntry[];
+/** Live (non-archived) children of a DAG summary, so a rebuild regenerates from the CURRENT child set; tenant-scoped as defence in depth. */
 export declare function loadChildrenOfSummary(hippoRoot: string, summaryId: string, tenantId: string): MemoryEntry[];
-/**
- * Patch applied by applyRebuildResult. Two-branch shape
- * (bumpRebuildCount false for zero-child case, true for normal rebuild).
- */
+/** Patch applied by applyRebuildResult; `bumpRebuildCount` is false for the zero-child case, true for a normal rebuild. */
 export interface RebuildPatch {
     content: string;
     descendant_count: number;
@@ -54,28 +17,13 @@ export interface RebuildPatch {
     zeroChildren: boolean;
     actor: string;
 }
-/**
- * Apply a rebuild result to a dirty summary. Atomic: one
- * prepared UPDATE statement plus syncFtsRow inside one write scope.
- * WHERE includes `AND summary_dirty = 1` so concurrent sleep's race-loser
- * becomes a no-op (no rebuild_count bump, no audit row).
- *
- * Returns `{ changed, refused }`. `changed` is true when this call's UPDATE
- * (content or metadata-only) affected a row; false on race-loss / unknown id
- * / archived / wrong dag_level. `refused` is true only when a tombstone hit
- * suppressed the content write AND the metadata UPDATE still landed — see
- * the return-semantics comment below for the full contract.
- */
+/** Apply a rebuild result to a dirty summary in one write scope (UPDATE plus syncFtsRow); `AND summary_dirty = 1` makes a concurrent race-loser a no-op.
+ * Returns `{ changed, refused }`: `refused` only when a tombstone hit suppressed the content write while the metadata UPDATE still landed. */
 export declare function applyRebuildResult(hippoRoot: string, summary: MemoryEntry, patch: RebuildPatch): {
     changed: boolean;
     refused: boolean;
 };
-/**
- * Clear summary_dirty on a freshly-built summary. Called by buildDag right after the child-link loop:
- * each member's writeEntry marks the new parent dirty, so the same cycle's rebuild would redo every new summary.
- *
- * Idempotent: no-op + no audit if summary isn't dirty. Audit
- * source='buildDag-clean' distinguishes it from the rebuild's source.
- */
+/** Clear summary_dirty on a new summary after buildDag's child-link loop (each member's writeEntry marks the parent dirty, so the same cycle would rebuild it).
+ * Idempotent (no-op, no audit if not dirty); audit source='buildDag-clean' distinguishes it from the rebuild's. */
 export declare function clearSummaryDirtyAfterBuild(hippoRoot: string, summaryId: string, tenantId: string, actor?: string, source?: string): void;
 //# sourceMappingURL=summaries.d.ts.map