hippo-memory 1.68.0 → 1.70.0

package/dist/connectors/slack/webhook.js

@@ -1,13 +1,14 @@
-import { envSlackSigningSecret, envSlackSigningSecretPrevious } from '../../env.js';
+import { envSlackSigningSecret, envSlackSigningSecretPrevious } from '../../util/env.js';
 import { verifySlackSignature } from './signature.js';
 import { isSlackEventEnvelope, isSlackMessageEvent } from './types.js';
 import { ingestMessage } from './ingest.js';
 import { handleMessageDeleted } from './deletion.js';
-import { writeToDlq } from './dlq.js';
-import { resolveTenantForTeam } from './tenant-routing.js';
-import { resolveTenantId } from '../../tenant.js';
-import { openHippoDb, closeHippoDb } from '../../db.js';
-import { HttpError, JSON_HEADERS, isHeaderString, isJsonObjectRecord, readBody, sendJson, } from '../../http-util.js';
+import { parkInDlq } from '../dlq.js';
+import { slackDlq } from './dlq.js';
+import { resolveTenantForSlackTeam } from './tenant-routing.js';
+import { resolveTenantId } from '../../store/tenant.js';
+import { HttpError, JSON_HEADERS, isHeaderString, closeIfBodyUnread, readWebhookBody, sendJson } from '../../util/http-util.js';
+import { isJsonObject } from '../../util/json.js';
 /**
  * Slack Events API webhook. Auth is signature-based (HMAC over the raw
  * body with SLACK_SIGNING_SECRET); Bearer is NOT required, which is why
@@ -27,10 +28,12 @@ import { HttpError, JSON_HEADERS, isHeaderString, isJsonObjectRecord, readBody,
  *
  * Bearer auth is skipped on purpose: server.ts checks isPublicRoute before calling this.
  */
-export async function handleSlackEventsWebhook({ req, res, opts }) {
-    const rawBody = await readBody(req);
+export async function handleSlackEventsWebhook(request, store) {
+    const { req, res, opts } = request;
+    // Secret and headers before the body, so a caller with neither cannot make the server buffer one.
     const secret = envSlackSigningSecret();
     if (!secret) {
+        closeIfBodyUnread(request);
         res.writeHead(404, JSON_HEADERS);
         res.end(JSON.stringify({ error: 'not found' }));
         return;
@@ -40,77 +43,76 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
     const tsHdr = req.headers['x-slack-request-timestamp'];
     const sigStr = isHeaderString(sig) ? sig : null;
     const tsStr = isHeaderString(tsHdr) ? tsHdr : null;
-    if (sigStr === null ||
-        tsStr === null ||
-        !verifySlackSignature({
-            rawBody,
-            timestamp: tsStr,
-            signature: sigStr,
-            signingSecret: secret,
-            previousSecret,
-        })) {
+    if (sigStr === null || tsStr === null) {
+        closeIfBodyUnread(request);
         throw new HttpError(401, 'invalid Slack signature');
     }
-    routeSignedSlackPayload({ hippoRoot: opts.hippoRoot, res, rawBody, signature: sigStr, slackTimestamp: tsStr });
-}
-function parkInDlq(d, park) {
-    const db = openHippoDb(d.hippoRoot);
-    try {
-        writeToDlq(db, {
-            tenantId: park.tenantId,
-            teamId: park.teamId,
-            rawPayload: d.rawBody,
-            error: park.error,
-            bucket: park.bucket,
-            signature: d.signature,
-            slackTimestamp: d.slackTimestamp,
-        });
-    }
-    finally {
-        closeHippoDb(db);
+    const rawBody = await readWebhookBody(request);
+    if (!verifySlackSignature({
+        rawBody,
+        timestamp: tsStr,
+        signature: sigStr,
+        signingSecret: secret,
+        previousSecret,
+    })) {
+        throw new HttpError(401, 'invalid Slack signature');
     }
+    await routeSignedSlackPayload({ hippoRoot: opts.hippoRoot, store, res, rawBody, signature: sigStr, slackTimestamp: tsStr });
+}
+async function parkAndAck(d, park) {
+    const row = {
+        tenantId: park.tenantId,
+        teamId: park.teamId,
+        rawPayload: d.rawBody,
+        error: park.error,
+        bucket: park.bucket,
+        signature: d.signature,
+        slackTimestamp: d.slackTimestamp,
+    };
+    await parkInDlq(slackDlq, d.hippoRoot, row, d.store);
     sendJson(d.res, 200, { ok: true, status: 'dlq' });
 }
-function routeSignedSlackPayload(d) {
-    const { rawBody, res } = d;
+function teamIdInRawBody(rawBody) {
     // Cheap regex extracts team_id from a (possibly malformed) raw body so the
     // DLQ row carries it for triage even when JSON.parse fails.
-    const teamIdFromRaw = (() => {
-        const m = rawBody.match(/"team_id"\s*:\s*"([^"]+)"/);
-        return m ? m[1] : null;
-    })();
-    let body;
-    try {
-        body = JSON.parse(rawBody);
-    }
-    catch {
-        parkUnparseable(d, teamIdFromRaw);
-        return;
-    }
-    if (isJsonObjectRecord(body)) {
+    const m = rawBody.match(/"team_id"\s*:\s*"([^"]+)"/);
+    return m ? m[1] : null;
+}
+/** Answers Slack's URL-verification handshake; false when the payload is anything else. */
+function answerUrlVerification(res, body) {
+    if (isJsonObject(body)) {
         const bodyRecord = body;
         if (bodyRecord.type === 'url_verification') {
             sendJson(res, 200, {
                 challenge: String(bodyRecord.challenge ?? ''),
             });
-            return;
+            return true;
         }
     }
+    return false;
+}
+async function routeSignedSlackPayload(d) {
+    const { rawBody, res } = d;
+    const teamIdFromRaw = teamIdInRawBody(rawBody);
+    let body;
+    try {
+        body = JSON.parse(rawBody);
+    }
+    catch {
+        await parkUnparseable(d, teamIdFromRaw);
+        return;
+    }
+    if (answerUrlVerification(res, body))
+        return;
     // Resolve tenant, failing closed: when slack_workspaces is non-empty
     // and the team_id is unknown, resolveTenantForTeam returns null and we
     // park the envelope in slack_dlq with bucket='unroutable'. Mandatory ACK
     // 200 so Slack stops retrying; do NOT call ingest.
     let resolvedTenant = null;
     if (body !== undefined && isSlackEventEnvelope(body)) {
-        const db = openHippoDb(d.hippoRoot);
-        try {
-            resolvedTenant = resolveTenantForTeam(db, body.team_id);
-        }
-        finally {
-            closeHippoDb(db);
-        }
+        resolvedTenant = await resolveTenantForSlackTeam(d.hippoRoot, body.team_id, d.store);
         if (resolvedTenant === null) {
-            parkInDlq(d, {
+            await parkAndAck(d, {
                 tenantId: null, // unroutable - stored as '__unroutable__'
                 teamId: body.team_id,
                 error: `unroutable team_id: ${body.team_id}`,
@@ -127,9 +129,10 @@ function routeSignedSlackPayload(d) {
         hippoRoot: d.hippoRoot,
         tenantId: resolvedTenant,
         actor: { subject: 'connector:slack', role: 'admin' },
+        store: d.store,
     };
     if (body === undefined || !isSlackEventEnvelope(body)) {
-        parkInDlq(d, {
+        await parkAndAck(d, {
             tenantId: ctx.tenantId,
             teamId: teamIdFromRaw,
             error: 'not an event_callback envelope',
@@ -137,35 +140,25 @@ function routeSignedSlackPayload(d) {
         });
         return;
     }
-    dispatchSlackEvent(d, ctx, body);
+    await dispatchSlackEvent(d, ctx, body);
 }
-function parkUnparseable(d, teamIdFromRaw) {
+async function parkUnparseable(d, teamIdFromRaw) {
     // Attribute the parse failure to the originating workspace via the regex-extracted
     // team_id; a null or unknown team writes tenantId=null, which lands as '__unroutable__'.
-    const db = openHippoDb(d.hippoRoot);
-    try {
-        const parseFailTenant = teamIdFromRaw !== null ? resolveTenantForTeam(db, teamIdFromRaw) : null;
-        writeToDlq(db, {
-            tenantId: parseFailTenant, // null → '__unroutable__' sentinel
-            teamId: teamIdFromRaw,
-            rawPayload: d.rawBody,
-            error: 'invalid JSON',
-            bucket: 'parse_error',
-            signature: d.signature,
-            slackTimestamp: d.slackTimestamp,
-        });
-    }
-    finally {
-        closeHippoDb(db);
-    }
-    sendJson(d.res, 200, { ok: true, status: 'dlq' });
+    const parseFailTenant = teamIdFromRaw !== null ? await resolveTenantForSlackTeam(d.hippoRoot, teamIdFromRaw, d.store) : null;
+    await parkAndAck(d, {
+        tenantId: parseFailTenant, // null → '__unroutable__' sentinel
+        teamId: teamIdFromRaw,
+        error: 'invalid JSON',
+        bucket: 'parse_error',
+    });
 }
-function dispatchSlackEvent(d, ctx, body) {
+async function dispatchSlackEvent(d, ctx, body) {
     const { res } = d;
     const inner = body.event;
     if (isSlackMessageEvent(inner)) {
         if (inner.subtype === 'message_deleted' && inner.deleted_ts) {
-            const r = handleMessageDeleted(ctx, {
+            const r = await handleMessageDeleted(ctx, {
                 teamId: body.team_id,
                 channelId: inner.channel,
                 deletedTs: inner.deleted_ts,
@@ -174,7 +167,7 @@ function dispatchSlackEvent(d, ctx, body) {
             sendJson(res, 200, { ok: true, status: r.status });
             return;
         }
-        const r = ingestMessage(ctx, {
+        const r = await ingestMessage(ctx, {
             teamId: body.team_id,
             // channel privacy isn't on the inner event; use channel_type as a
             // proxy. 'group'|'im'|'mpim' → private. 'channel' → public. Unknown
@@ -191,7 +184,7 @@ function dispatchSlackEvent(d, ctx, body) {
         sendJson(res, 200, { ok: true, status: r.status, memoryId: r.memoryId });
         return;
     }
-    parkInDlq(d, {
+    await parkAndAck(d, {
         tenantId: ctx.tenantId,
         teamId: body.team_id,
         error: `unhandled event type: ${inner.type ?? 'unknown'}`,

package/dist/connectors/slack/workspaces.d.ts

@@ -18,12 +18,9 @@
  *   - `remove` returns a boolean for the CLI to distinguish "removed"
  *     from "not found" without an extra SELECT.
  */
-import type { DatabaseSyncLike } from '../../db.js';
-export interface SlackWorkspace {
-    teamId: string;
-    tenantId: string;
-    addedAt: string;
-}
+import { type SlackWorkspace } from '../../store/connectors/slack.js';
+export type { SlackWorkspace };
+export { listSlackWorkspaces as listWorkspaces, removeSlackWorkspace as removeWorkspace } from '../../store/connectors/slack.js';
 export interface AddWorkspaceOpts {
     teamId: string;
     tenantId: string;
@@ -32,15 +29,5 @@ export interface AddWorkspaceOpts {
  * Register or re-register a Slack team → tenant mapping. Upserts on
  * team_id conflict (operators move workspaces between tenants).
  */
-export declare function addWorkspace(db: DatabaseSyncLike, opts: AddWorkspaceOpts): SlackWorkspace;
-/**
- * List all registered workspaces, sorted by team_id for stable output.
- */
-export declare function listWorkspaces(db: DatabaseSyncLike): SlackWorkspace[];
-/**
- * Remove a workspace registration by team_id. Returns true if a row was
- * deleted, false if no row matched (so the CLI can report not-found
- * without a separate lookup).
- */
-export declare function removeWorkspace(db: DatabaseSyncLike, teamId: string): boolean;
+export declare function addWorkspace(hippoRoot: string, opts: AddWorkspaceOpts): SlackWorkspace;
 //# sourceMappingURL=workspaces.d.ts.map

package/dist/connectors/slack/workspaces.js

@@ -18,43 +18,13 @@
  *   - `remove` returns a boolean for the CLI to distinguish "removed"
  *     from "not found" without an extra SELECT.
  */
+import { upsertSlackWorkspace } from '../../store/connectors/slack.js';
+export { listSlackWorkspaces as listWorkspaces, removeSlackWorkspace as removeWorkspace } from '../../store/connectors/slack.js';
 /**
  * Register or re-register a Slack team → tenant mapping. Upserts on
  * team_id conflict (operators move workspaces between tenants).
  */
-export function addWorkspace(db, opts) {
-    const addedAt = new Date().toISOString();
-    db.prepare(`INSERT INTO slack_workspaces (team_id, tenant_id, added_at)
-     VALUES (?, ?, ?)
-     ON CONFLICT(team_id) DO UPDATE SET
-       tenant_id = excluded.tenant_id,
-       added_at = excluded.added_at`).run(opts.teamId, opts.tenantId, addedAt);
-    return { teamId: opts.teamId, tenantId: opts.tenantId, addedAt };
-}
-/**
- * List all registered workspaces, sorted by team_id for stable output.
- */
-export function listWorkspaces(db) {
-    // SAFETY: query selects exactly team_id, tenant_id, added_at, all NOT NULL
-    // text columns in the slack_workspaces schema, so each row has this shape.
-    const rows = db
-        .prepare(`SELECT team_id, tenant_id, added_at FROM slack_workspaces ORDER BY team_id`)
-        .all();
-    return rows.map((r) => ({
-        teamId: r.team_id,
-        tenantId: r.tenant_id,
-        addedAt: r.added_at,
-    }));
-}
-/**
- * Remove a workspace registration by team_id. Returns true if a row was
- * deleted, false if no row matched (so the CLI can report not-found
- * without a separate lookup).
- */
-export function removeWorkspace(db, teamId) {
-    const result = db
-        .prepare(`DELETE FROM slack_workspaces WHERE team_id = ?`)
-        .run(teamId);
-    return Number(result.changes) > 0;
+export function addWorkspace(hippoRoot, opts) {
+    return upsertSlackWorkspace(hippoRoot, opts.teamId, opts.tenantId);
 }
 //# sourceMappingURL=workspaces.js.map

package/dist/consolidate/conflicts.d.ts

@@ -1,4 +1,4 @@
-import { MemoryEntry, type DecayOptions } from '../memory.js';
+import { MemoryEntry, type DecayOptions } from '../core/memory.js';
 /** Pairs of live non-semantic memories that contradict each other, in survivor order. */
 export declare function detectConflicts(entries: MemoryEntry[], now: Date, decayOpts?: DecayOptions, rescuedIds?: Set<string>): Array<{
     memory_a_id: string;

package/dist/consolidate/conflicts.js

@@ -1,7 +1,7 @@
-import { Layer, calculateStrength } from '../memory.js';
-import { jaccardMinShared, overlapPartners } from '../overlap-index.js';
-import { isQuarantineScope } from '../quarantine.js';
-import { isPersonalScope } from '../recall-scope.js';
+import { Layer, calculateStrength } from '../core/memory.js';
+import { jaccardMinShared, overlapPartners } from './overlap-index.js';
+import { isQuarantineScope } from '../trust/quarantine.js';
+import { isPersonalScope } from '../store/recall-scope.js';
 import { DECAY_THRESHOLD } from './decay.js';
 // Contradictions should be gated by content overlap, not shared tags. Tags like
 // `feedback` / `policy` are too coarse and can make unrelated rules look like

package/dist/{dag.d.ts → consolidate/dag.d.ts}

@@ -1,4 +1,4 @@
-import { type MemoryEntry } from './memory.js';
+import { type MemoryEntry } from '../core/memory.js';
 export interface FactCluster {
     label: string;
     members: MemoryEntry[];

package/dist/{dag.js → consolidate/dag.js}

@@ -1,14 +1,16 @@
-import { createMemory, Layer } from './memory.js';
-import { writeEntry } from './store/entry-writes.js';
-import { loadAllDirtySummaries, loadChildrenOfSummary, applyRebuildResult, clearSummaryDirtyAfterBuild, } from './store/summaries.js';
-import { RejectedValueError } from './rejection.js';
-import { redactSecretsStrict } from './secret-detect.js';
-import { fetchWithRetry, llmTimeoutMs } from './http-retry.js';
-import { derivationScope, derivationPartitionKey } from './recall-scope.js';
-import { loadConfig } from './config.js';
-import { neverAutoShareTags } from './shared.js';
-import { log } from './log.js';
-import { certainDefect } from './memory-quality.js';
+import { createMemory, Layer } from '../core/memory.js';
+import { writeEntry, writeEntriesTogether } from '../store/entry-writes.js';
+import { loadAllDirtySummaries, loadChildrenOfSummary, applyRebuildResult, clearSummaryDirtyAfterBuild, } from '../store/summaries.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { redactSecretsStrict } from '../util/secret-detect.js';
+import { describeMessageFailure, sendAnthropicMessage } from '../util/anthropic-messages.js';
+import { derivationScope, derivationPartitionKey } from '../store/recall-scope.js';
+import { loadConfig } from '../core/config.js';
+import { neverAutoShareTags } from '../sharing/shared.js';
+import { errorMessage, log } from '../util/log.js';
+import { certainDefect } from '../core/memory-quality.js';
+const SUMMARY_FALLBACK_CHARS = 40;
+const DEFAULT_REBUILD_CAP = 20;
 export function clusterFacts(facts) {
     if (facts.length === 0)
         return [];
@@ -35,7 +37,7 @@ export function clusterFacts(facts) {
         const sharedTags = entityTags[cluster[0]].filter((t) => cluster.every((idx) => entityTags[idx].includes(t)));
         const label = sharedTags
             .map((t) => t.split(':')[1])
-            .join(': ') || members[0].content.slice(0, 40);
+            .join(': ') || members[0].content.slice(0, SUMMARY_FALLBACK_CHARS);
         clusters.push({ label, members, entityTags: sharedTags });
     }
     return clusters;
@@ -47,51 +49,31 @@ Facts:
 {facts}
 
 Write a single concise paragraph (2-4 sentences) that captures all the key information from these facts. This summary will be used to quickly determine if this cluster is relevant to a future query, so include specific names, dates, numbers, and key details. Output ONLY the summary paragraph, no preamble.`;
+// Output budget for one summary paragraph, and the shortest reply kept as a summary.
+const SUMMARY_MAX_TOKENS = 400;
+const SUMMARY_MIN_CHARS = 20;
 export async function generateDagSummary(label, factContents, opts) {
-    const model = opts.model ?? 'claude-sonnet-4-6';
-    const fetchFn = opts.fetcher ?? fetch;
     const factsBlock = factContents.map((f, i) => `${i + 1}. ${redactSecretsStrict(f)}`).join('\n');
     const prompt = DAG_SUMMARY_PROMPT
         .replace('{label}', redactSecretsStrict(label))
         .replace('{facts}', factsBlock);
-    let res;
-    try {
-        res = await fetchWithRetry('https://api.anthropic.com/v1/messages', {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                'x-api-key': opts.apiKey,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: 400,
-                messages: [{ role: 'user', content: prompt }],
-            }),
-        }, { timeoutMs: llmTimeoutMs(), fetchFn });
-    }
-    catch (err) {
-        opts.onError?.(`request failed: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-    if (!res.ok) {
-        opts.onError?.(`HTTP ${res.status}`);
+    const reply = await sendAnthropicMessage({
+        apiKey: opts.apiKey,
+        model: opts.model,
+        maxTokens: SUMMARY_MAX_TOKENS,
+        prompt,
+        fetcher: opts.fetcher,
+    });
+    if (!reply.ok) {
+        opts.onError?.(describeMessageFailure(reply.failure));
         return null;
     }
-    try {
-        const data = await res.json();
-        const text = data.content?.[0]?.text?.trim() ?? '';
-        const defect = certainDefect(text);
-        if (defect !== null) {
-            opts.onError?.(`summary quality refused: ${defect}`);
-            return null;
-        }
-        return text.length >= 20 ? text : null;
-    }
-    catch (err) {
-        opts.onError?.(`unparseable response: ${err instanceof Error ? err.message : String(err)}`);
+    const defect = certainDefect(reply.text);
+    if (defect !== null) {
+        opts.onError?.(`summary quality refused: ${defect}`);
         return null;
     }
+    return reply.text.length >= SUMMARY_MIN_CHARS ? reply.text : null;
 }
 // Partition BEFORE clustering so one LLM summary never mixes facts from different tenants.
 // Map keeps insertion order, so a single-tenant store iterates in its original order.
@@ -152,11 +134,7 @@ async function summarizeCluster(hippoRoot, cluster, home, opts, result) {
         throw err;
     }
     result.summariesCreated++;
-    for (const member of cluster.members) {
-        const updated = { ...member, dag_parent_id: summaryEntry.id };
-        writeEntry(hippoRoot, updated);
-        result.factsLinked++;
-    }
+    result.factsLinked += writeEntriesTogether(hippoRoot, cluster.members.map((member) => ({ ...member, dag_parent_id: summaryEntry.id })));
     // Member writes just marked this fresh summary dirty; clear it, or the same sleep cycle's
     // rebuild pass would re-rebuild every new summary at twice the LLM cost.
     clearSummaryDirtyAfterBuild(hippoRoot, summaryEntry.id, summaryEntry.tenantId, 'buildDag');
@@ -185,29 +163,10 @@ export async function buildDag(hippoRoot, facts, opts) {
 async function rebuildOneSummary(hippoRoot, summary, opts, result) {
     const children = loadChildrenOfSummary(hippoRoot, summary.id, summary.tenantId);
     if (children.length === 0) {
-        // Zero-child case: clear dirty + zero counts, no LLM call, no rebuild_count bump.
-        const { changed } = applyRebuildResult(hippoRoot, summary, {
-            content: summary.content,
-            descendant_count: 0,
-            earliest_at: null,
-            latest_at: null,
-            bumpRebuildCount: false,
-            zeroChildren: true,
-            actor: 'sleep',
-        });
-        if (changed)
-            result.zeroChildSkipped++;
-        // changed=false → race lost / row vanished; silently skip. `refused`
-        // is always false here — applyRebuildResult only checks the
-        // tombstone when bumpRebuildCount is true (store/summaries.ts).
+        clearZeroChildSummary(hippoRoot, summary, result);
         return;
     }
-    // Derive label from summary's existing entity tags (mirrors clusterFacts)
-    const entityTags = summary.tags.filter((t) => t.startsWith('speaker:') || t.startsWith('topic:'));
-    const label = entityTags.length > 0
-        ? entityTags.map((t) => t.split(':')[1]).join(': ')
-        : summary.content.slice(0, 40);
-    const newContent = await generateDagSummary(label, children.map((c) => c.content), opts);
+    const newContent = await generateDagSummary(summaryLabel(summary), children.map((c) => c.content), opts);
     if (!newContent) {
         // LLM null / fetch error → leave dirty for next cycle
         result.failed++;
@@ -232,6 +191,30 @@ async function rebuildOneSummary(hippoRoot, summary, opts, result) {
     // changed=false (refused also false) → race lost; not failure, not
     // success, silently skip
 }
+/** Zero-child case: clear dirty + zero counts, no LLM call, no rebuild_count bump. */
+function clearZeroChildSummary(hippoRoot, summary, result) {
+    const { changed } = applyRebuildResult(hippoRoot, summary, {
+        content: summary.content,
+        descendant_count: 0,
+        earliest_at: null,
+        latest_at: null,
+        bumpRebuildCount: false,
+        zeroChildren: true,
+        actor: 'sleep',
+    });
+    if (changed)
+        result.zeroChildSkipped++;
+    // changed=false → race lost / row vanished; silently skip. `refused`
+    // is always false here — applyRebuildResult only checks the
+    // tombstone when bumpRebuildCount is true (store/summaries.ts).
+}
+// Derive label from summary's existing entity tags (mirrors clusterFacts)
+function summaryLabel(summary) {
+    const entityTags = summary.tags.filter((t) => t.startsWith('speaker:') || t.startsWith('topic:'));
+    return entityTags.length > 0
+        ? entityTags.map((t) => t.split(':')[1]).join(': ')
+        : summary.content.slice(0, SUMMARY_FALLBACK_CHARS);
+}
 /**
  * Sleep-cycle phase that drains the dirty L2 summary queue.
  * Thin orchestrator; the heavy lifting lives in store.ts (load + apply)
@@ -246,7 +229,7 @@ async function rebuildOneSummary(hippoRoot, summary, opts, result) {
  * A tombstone hit counts as `refused`, not `rebuilt`; dirty clears either way.
  */
 export async function rebuildDirtySummaries(hippoRoot, opts) {
-    const cap = opts.cap ?? 20;
+    const cap = opts.cap ?? DEFAULT_REBUILD_CAP;
     const dirty = loadAllDirtySummaries(hippoRoot);
     const capped = dirty.length > cap;
     const queue = dirty.slice(0, cap);
@@ -275,7 +258,7 @@ export async function rebuildDirtySummaries(hippoRoot, opts) {
             // One throw doesn't abort the queue; log enough to triage an exotic
             // failure (SQLite I/O, prepare), since audit() already catches its own.
             result.failed++;
-            log.error(`rebuildDirtySummaries: summary ${summary.id} (tenant ${summary.tenantId}) failed: ${err instanceof Error ? err.message : String(err)}`);
+            log.error(`rebuildDirtySummaries: summary ${summary.id} (tenant ${summary.tenantId}) failed: ${errorMessage(err)}`);
         }
     }
     return result;
@@ -321,11 +304,7 @@ async function profileCluster(hippoRoot, cluster, home, opts, result) {
         throw err;
     }
     result.profilesCreated++;
-    for (const member of cluster.members) {
-        const updated = { ...member, dag_parent_id: profileEntry.id };
-        writeEntry(hippoRoot, updated);
-        result.l2sLinked++;
-    }
+    result.l2sLinked += writeEntriesTogether(hippoRoot, cluster.members.map((member) => ({ ...member, dag_parent_id: profileEntry.id })));
     // Re-linking just marked the fresh L3 dirty; clear it so this cycle's rebuild skips it.
     // The distinct source tags the audit row.
     clearSummaryDirtyAfterBuild(hippoRoot, profileEntry.id, home.tenantId, 'buildEntityProfiles', 'buildEntityProfiles-clean');

package/dist/consolidate/decay.d.ts

@@ -1,5 +1,5 @@
-import { MemoryEntry } from '../memory.js';
-import { type MvRankInfo } from '../memory-value.js';
+import { MemoryEntry } from '../core/memory.js';
+import { type MvRankInfo } from './memory-value.js';
 import type { SleepRun } from './run.js';
 export declare const DECAY_THRESHOLD = 0.05;
 /** What the decay pass hands to the conflict check and the rescue audit at the end of the run. */