hippo-memory 1.60.0 → 1.62.0

package/dist/connectors/slack/ingest.js

@@ -54,57 +54,64 @@ export function ingestMessage(ctx, input) {
     // together. Slack's 1-minute retry window can no longer produce a duplicate
     // via the crash-between-handles race.
     try {
-        // v1.12.0: drop the legacy `|| 'connector:slack'` fallback — ctx is always
-        // provided by server.ts:1039 which constructs it with the connector subject.
-        // Under the new object-shaped Context.actor, an OR-fallback would evaluate
-        // an object as truthy and skip the fallback anyway (logic bug if ctx were
-        // ever missing); explicit reliance on the caller is safer.
-        const result = remember(ctx, {
-            ...opts,
-            untrusted: true,
-            afterWrite: (innerDb, memoryId) => {
-                const inserted = innerDb
-                    .prepare(`INSERT OR IGNORE INTO slack_event_log (event_id, ingested_at, memory_id) VALUES (?, ?, ?)`)
-                    .run(input.eventId, new Date().toISOString(), memoryId);
-                if ((Number(inserted.changes ?? 0)) === 0) {
-                    // Two-worker race: another writer reserved this event_id between
-                    // the pre-check and the write. Throw to roll back the SAVEPOINT
-                    // in writeEntry — the memory row gets discarded, idempotency
-                    // holds, exactly one memory exists for this event_id.
-                    throw new DuplicateEventError(input.eventId);
-                }
-            },
-        });
-        return { status: 'ingested', memoryId: result.id };
+        return rememberWithEventLog(ctx, input.eventId, opts);
     }
     catch (e) {
-        if (e instanceof DuplicateEventError) {
-            // The other worker's memory row is already committed. Return its id
-            // so the caller behaves identically to the fast-path 'duplicate' branch.
-            const db3 = openHippoDb(ctx.hippoRoot);
-            try {
-                const cachedId = lookupMemoryByEvent(db3, input.eventId);
-                return { status: 'skipped_duplicate', memoryId: cachedId };
-            }
-            finally {
-                closeHippoDb(db3);
-            }
-        }
-        if (e instanceof RejectedValueError) {
-            // AT1 (plan §3 containment): a tombstone hit is a PERMANENT skip, not
-            // a transient failure — never DLQ-retry it (retrying would just hit
-            // the same refusal forever). Mark the event seen exactly like the
-            // empty-body branch above so a Slack retry acks as done, not error.
-            const db4 = openHippoDb(ctx.hippoRoot);
-            try {
-                markEventSeen(db4, input.eventId, null);
-            }
-            finally {
-                closeHippoDb(db4);
-            }
-            return { status: 'skipped', memoryId: null };
-        }
+        if (e instanceof DuplicateEventError)
+            return lostRaceResult(ctx, input.eventId);
+        if (e instanceof RejectedValueError)
+            return rejectedValueResult(ctx, input.eventId);
         throw e;
     }
 }
+function rememberWithEventLog(ctx, eventId, opts) {
+    // v1.12.0: drop the legacy `|| 'connector:slack'` fallback — ctx is always
+    // provided by server.ts:1039 which constructs it with the connector subject.
+    // Under the new object-shaped Context.actor, an OR-fallback would evaluate
+    // an object as truthy and skip the fallback anyway (logic bug if ctx were
+    // ever missing); explicit reliance on the caller is safer.
+    const result = remember(ctx, {
+        ...opts,
+        untrusted: true,
+        afterWrite: (innerDb, memoryId) => {
+            const inserted = innerDb
+                .prepare(`INSERT OR IGNORE INTO slack_event_log (event_id, ingested_at, memory_id) VALUES (?, ?, ?)`)
+                .run(eventId, new Date().toISOString(), memoryId);
+            if ((Number(inserted.changes ?? 0)) === 0) {
+                // Two-worker race: another writer reserved this event_id between
+                // the pre-check and the write. Throw to roll back the SAVEPOINT
+                // in writeEntry — the memory row gets discarded, idempotency
+                // holds, exactly one memory exists for this event_id.
+                throw new DuplicateEventError(eventId);
+            }
+        },
+    });
+    return { status: 'ingested', memoryId: result.id };
+}
+function lostRaceResult(ctx, eventId) {
+    // The other worker's memory row is already committed. Return its id
+    // so the caller behaves identically to the fast-path 'duplicate' branch.
+    const db3 = openHippoDb(ctx.hippoRoot);
+    try {
+        const cachedId = lookupMemoryByEvent(db3, eventId);
+        return { status: 'skipped_duplicate', memoryId: cachedId };
+    }
+    finally {
+        closeHippoDb(db3);
+    }
+}
+function rejectedValueResult(ctx, eventId) {
+    // AT1 (plan §3 containment): a tombstone hit is a PERMANENT skip, not
+    // a transient failure — never DLQ-retry it (retrying would just hit
+    // the same refusal forever). Mark the event seen exactly like the
+    // empty-body branch above so a Slack retry acks as done, not error.
+    const db4 = openHippoDb(ctx.hippoRoot);
+    try {
+        markEventSeen(db4, eventId, null);
+    }
+    finally {
+        closeHippoDb(db4);
+    }
+    return { status: 'skipped', memoryId: null };
+}
 //# sourceMappingURL=ingest.js.map

package/dist/connectors/slack/tenant-routing.js

@@ -1,3 +1,4 @@
+import { envSlackAllowUnknownTeamFallback, envTenant } from '../../env.js';
 /**
  * Look up the tenant_id for a Slack team_id.
  *
@@ -31,10 +32,10 @@ export function resolveTenantForTeam(db, teamId) {
         .get().c;
     if (Number(total) === 0) {
         // Single-workspace install: env fallback is safe.
-        return process.env.HIPPO_TENANT?.trim() || 'default';
+        return envTenant();
     }
-    if (process.env.SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK === '1') {
-        return process.env.HIPPO_TENANT?.trim() || 'default';
+    if (envSlackAllowUnknownTeamFallback()) {
+        return envTenant();
     }
     return null; // fail closed
 }

package/dist/connectors/slack/webhook.js

@@ -1,3 +1,4 @@
+import { envSlackSigningSecret, envSlackSigningSecretPrevious } from '../../env.js';
 import { verifySlackSignature } from './signature.js';
 import { isSlackEventEnvelope, isSlackMessageEvent } from './types.js';
 import { ingestMessage } from './ingest.js';
@@ -6,7 +7,6 @@ import { writeToDlq } from './dlq.js';
 import { resolveTenantForTeam } from './tenant-routing.js';
 import { resolveTenantId } from '../../tenant.js';
 import { openHippoDb, closeHippoDb } from '../../db.js';
-import { adminActor } from '../../api.js';
 import { HttpError, JSON_HEADERS, isHeaderString, isJsonObjectRecord, readBody, sendJson, } from '../../http-util.js';
 /**
  * Slack Events API webhook. Auth is signature-based (HMAC over the raw
@@ -29,13 +29,13 @@ import { HttpError, JSON_HEADERS, isHeaderString, isJsonObjectRecord, readBody,
  */
 export async function handleSlackEventsWebhook({ req, res, opts }) {
     const rawBody = await readBody(req);
-    const secret = process.env.SLACK_SIGNING_SECRET;
+    const secret = envSlackSigningSecret();
     if (!secret) {
         res.writeHead(404, JSON_HEADERS);
         res.end(JSON.stringify({ error: 'not found' }));
         return;
     }
-    const previousSecret = process.env.SLACK_SIGNING_SECRET_PREVIOUS;
+    const previousSecret = envSlackSigningSecretPrevious();
     const sig = req.headers['x-slack-signature'];
     const tsHdr = req.headers['x-slack-request-timestamp'];
     const sigStr = isHeaderString(sig) ? sig : null;
@@ -51,6 +51,28 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
         })) {
         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);
+    }
+    sendJson(d.res, 200, { ok: true, status: 'dlq' });
+}
+function routeSignedSlackPayload(d) {
+    const { rawBody, res } = d;
     // 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 = (() => {
@@ -62,25 +84,7 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
         body = JSON.parse(rawBody);
     }
     catch {
-        // 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(opts.hippoRoot);
-        try {
-            const parseFailTenant = teamIdFromRaw !== null ? resolveTenantForTeam(db, teamIdFromRaw) : null;
-            writeToDlq(db, {
-                tenantId: parseFailTenant, // null → '__unroutable__' sentinel
-                teamId: teamIdFromRaw,
-                rawPayload: rawBody,
-                error: 'invalid JSON',
-                bucket: 'parse_error',
-                signature: sigStr,
-                slackTimestamp: tsStr,
-            });
-        }
-        finally {
-            closeHippoDb(db);
-        }
-        sendJson(res, 200, { ok: true, status: 'dlq' });
+        parkUnparseable(d, teamIdFromRaw);
         return;
     }
     if (isJsonObjectRecord(body)) {
@@ -98,7 +102,7 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
     // 200 so Slack stops retrying; do NOT call ingest.
     let resolvedTenant = null;
     if (body !== undefined && isSlackEventEnvelope(body)) {
-        const db = openHippoDb(opts.hippoRoot);
+        const db = openHippoDb(d.hippoRoot);
         try {
             resolvedTenant = resolveTenantForTeam(db, body.team_id);
         }
@@ -106,22 +110,12 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
             closeHippoDb(db);
         }
         if (resolvedTenant === null) {
-            const db2 = openHippoDb(opts.hippoRoot);
-            try {
-                writeToDlq(db2, {
-                    tenantId: null, // unroutable - stored as '__unroutable__'
-                    teamId: body.team_id,
-                    rawPayload: rawBody,
-                    error: `unroutable team_id: ${body.team_id}`,
-                    bucket: 'unroutable',
-                    signature: sigStr,
-                    slackTimestamp: tsStr,
-                });
-            }
-            finally {
-                closeHippoDb(db2);
-            }
-            sendJson(res, 200, { ok: true, status: 'dlq' });
+            parkInDlq(d, {
+                tenantId: null, // unroutable - stored as '__unroutable__'
+                teamId: body.team_id,
+                error: `unroutable team_id: ${body.team_id}`,
+                bucket: 'unroutable',
+            });
             return;
         }
     }
@@ -130,29 +124,44 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
         resolvedTenant = resolveTenantId({});
     }
     const ctx = {
-        hippoRoot: opts.hippoRoot,
+        hippoRoot: d.hippoRoot,
         tenantId: resolvedTenant,
-        actor: adminActor('connector:slack'),
+        actor: { subject: 'connector:slack', role: 'admin' },
     };
     if (body === undefined || !isSlackEventEnvelope(body)) {
-        const db = openHippoDb(ctx.hippoRoot);
-        try {
-            writeToDlq(db, {
-                tenantId: ctx.tenantId,
-                teamId: teamIdFromRaw,
-                rawPayload: rawBody,
-                error: 'not an event_callback envelope',
-                bucket: 'parse_error',
-                signature: sigStr,
-                slackTimestamp: tsStr,
-            });
-        }
-        finally {
-            closeHippoDb(db);
-        }
-        sendJson(res, 200, { ok: true, status: 'dlq' });
+        parkInDlq(d, {
+            tenantId: ctx.tenantId,
+            teamId: teamIdFromRaw,
+            error: 'not an event_callback envelope',
+            bucket: 'parse_error',
+        });
         return;
     }
+    dispatchSlackEvent(d, ctx, body);
+}
+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' });
+}
+function dispatchSlackEvent(d, ctx, body) {
+    const { res } = d;
     const inner = body.event;
     if (isSlackMessageEvent(inner)) {
         if (inner.subtype === 'message_deleted' && inner.deleted_ts) {
@@ -182,22 +191,11 @@ export async function handleSlackEventsWebhook({ req, res, opts }) {
         sendJson(res, 200, { ok: true, status: r.status, memoryId: r.memoryId });
         return;
     }
-    const db = openHippoDb(ctx.hippoRoot);
-    try {
-        writeToDlq(db, {
-            tenantId: ctx.tenantId,
-            teamId: body.team_id,
-            rawPayload: rawBody,
-            error: `unhandled event type: ${inner.type ?? 'unknown'}`,
-            bucket: 'parse_error',
-            signature: sigStr,
-            slackTimestamp: tsStr,
-        });
-    }
-    finally {
-        closeHippoDb(db);
-    }
-    sendJson(res, 200, { ok: true, status: 'dlq' });
-    return;
+    parkInDlq(d, {
+        tenantId: ctx.tenantId,
+        teamId: body.team_id,
+        error: `unhandled event type: ${inner.type ?? 'unknown'}`,
+        bucket: 'parse_error',
+    });
 }
 //# sourceMappingURL=webhook.js.map

package/dist/consolidate/conflicts.d.ts

@@ -0,0 +1,10 @@
+import { MemoryEntry, type DecayOptions } from '../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;
+    memory_b_id: string;
+    reason: string;
+    score: number;
+}>;
+export declare function jaccardSets(a: Set<string>, b: Set<string>): number;
+//# sourceMappingURL=conflicts.d.ts.map

package/dist/consolidate/conflicts.js

@@ -0,0 +1,178 @@
+import { Layer, calculateStrength } from '../memory.js';
+import { jaccardMinShared, overlapPartners } from '../overlap-index.js';
+import { isQuarantineScope } from '../quarantine.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
+// conflicts before the polarity heuristics run.
+// Jaccard threshold on stopword-filtered tokens. Only applied after a polarity
+// signal has already been detected (explicit pair or inferred negation), so
+// this just filters out drive-by topic similarity, not semantic drift.
+const CONFLICT_OVERLAP_THRESHOLD = 0.5;
+// Minimum distinctive shared tokens before we trust an overlap score. Filters
+// out cases where two memories share only common English + a project name.
+const CONFLICT_MIN_RARE_SHARED = 2;
+// Polarity is detected on the first N words only. A stray "not" in the middle
+// of a long memory shouldn't flip the whole thing negative.
+const POLARITY_WINDOW_WORDS = 40;
+const CONFLICT_STOPWORDS = new Set([
+    'the', 'a', 'an', 'is', 'was', 'are', 'were', 'be', 'been', 'being', 'to', 'of', 'in',
+    'for', 'on', 'with', 'at', 'by', 'from', 'it', 'this', 'that', 'and', 'or', 'but', 'so',
+    'if', 'as', 'we', 'i', 'you', 'they', 'he', 'she', 'my', 'our', 'your', 'its', 'his',
+    'her', 'their', 'up', 'out', 'just', 'also', 'then', 'than', 'some', 'all', 'any',
+    'each', 'very', 'too', 'do', 'did', 'does', 'has', 'had', 'have', 'will', 'would',
+    'could', 'should', 'may', 'might', 'can', 'shall', 'when', 'where', 'what', 'which',
+    'who', 'how', 'why', 'there', 'here', 'about', 'into', 'over', 'after', 'before',
+    'between', 'through', 'during', 'against', 'within', 'without', 'toward', 'upon',
+    'more', 'most', 'less', 'least', 'other', 'such', 'same', 'new', 'old', 'one', 'two',
+]);
+/** Pairs of live non-semantic memories that contradict each other, in survivor order. */
+export function detectConflicts(entries, now, decayOpts = {}, 
+// LC2-E3 (opt-in, default off): ids rescued by this cycle's decay pass.
+// detectConflicts recomputes its own strength>=DECAY_THRESHOLD survivor
+// filter independently of the decay pass above; without this bypass,
+// rescued entries would be silently re-excluded from conflict detection
+// every cycle even though the decay pass just decided to keep them.
+// Default empty set: flag-off behavior is unchanged.
+rescuedIds = new Set()) {
+    const survivors = entries.filter((entry) => entry.layer !== Layer.Semantic
+        // CD5: an unreviewed quarantined row must not taint a visible memory as conflicted.
+        && !isQuarantineScope(entry.scope ?? null)
+        && (rescuedIds.has(entry.id) || calculateStrength(entry, now, decayOpts) >= DECAY_THRESHOLD));
+    const detected = [];
+    const profiles = survivors.map((entry) => conflictProfile(entry.content));
+    const partnersOf = overlapPartners(profiles.map((p) => p.distinct), jaccardMinShared(CONFLICT_OVERLAP_THRESHOLD, CONFLICT_MIN_RARE_SHARED));
+    for (let i = 0; i < survivors.length; i++) {
+        for (const j of partnersOf(i)) {
+            // Traces are variants of each other, not contradictions. Two
+            // strategies for the same task can both be valid; conflict detection
+            // exists for stated-rule disagreement, not strategy diversity.
+            if (survivors[i].layer === Layer.Trace && survivors[j].layer === Layer.Trace)
+                continue;
+            if (survivors[i].superseded_by || survivors[j].superseded_by)
+                continue;
+            if (!recalledTogether(survivors[i], survivors[j]))
+                continue;
+            if ([survivors[i], survivors[j]].some((e) => e.tags.includes('extracted') || e.tags.includes('session-digest')))
+                continue;
+            const reasonAndScore = describeConflict(profiles[i], profiles[j]);
+            if (!reasonAndScore)
+                continue;
+            detected.push({
+                memory_a_id: survivors[i].id,
+                memory_b_id: survivors[j].id,
+                reason: reasonAndScore.reason,
+                score: reasonAndScore.score,
+            });
+        }
+    }
+    return detected;
+}
+/** One project's ambient context can show both: same tenant, and the same project or a user-global row beside a project's. */
+function recalledTogether(a, b) {
+    if (a.tenantId !== b.tenantId)
+        return false;
+    const [x, y] = [a.origin_project ?? null, b.origin_project ?? null];
+    return x === y || (x === '' && y !== null) || (y === '' && x !== null);
+}
+function conflictProfile(text) {
+    const opening = openingWindow(text);
+    // Polarity is measured only in the first POLARITY_WINDOW_WORDS, so a stray
+    // negation deep in a prose memory doesn't flip the intent.
+    // Pad with spaces so space-delimited patterns match words at the start/end.
+    return { distinct: distinctiveTokens(text), polarity: inferConflictPolarity(opening), window: ' ' + opening.toLowerCase() + ' ' };
+}
+function describeConflict(a, b) {
+    // Jaccard on stopword-stripped tokens. Defer the threshold check until we
+    // know whether an explicit polarity pair is present (lower bar for those).
+    const overlapScore = jaccardSets(a.distinct, b.distinct);
+    // Require at least N shared distinctive tokens so two short memories sharing
+    // only "the project name" don't register.
+    let shared = 0;
+    for (const t of a.distinct)
+        if (b.distinct.has(t))
+            shared++;
+    if (shared < CONFLICT_MIN_RARE_SHARED)
+        return null;
+    const conflictType = classifyConflictType(a.window, b.window, a.polarity, b.polarity);
+    if (!conflictType)
+        return null;
+    if (overlapScore < CONFLICT_OVERLAP_THRESHOLD)
+        return null;
+    return {
+        reason: conflictType,
+        score: overlapScore,
+    };
+}
+function distinctiveTokens(text) {
+    return new Set(text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter((t) => t.length > 2 && !CONFLICT_STOPWORDS.has(t)));
+}
+export function jaccardSets(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const t of a)
+        if (b.has(t))
+            inter++;
+    const union = a.size + b.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
+function openingWindow(text) {
+    return text.split(/\s+/).slice(0, POLARITY_WINDOW_WORDS).join(' ');
+}
+// Takes opening windows only, so " on " and " off " as prepositions deep in long prose don't read as enabled/disabled.
+function classifyConflictType(a, b, aPolarity, bPolarity) {
+    // Tightened tokens: require whole-word boundaries so " on " alone doesn't
+    // match "on/off". Pair only `enabled` ↔ `disabled` and explicit on/off in
+    // imperative context.
+    const enabledDisabled = (containsAny(a, [' enabled ', ' enable ']) && containsAny(b, [' disabled ', ' disable ']))
+        || (containsAny(b, [' enabled ', ' enable ']) && containsAny(a, [' disabled ', ' disable ']));
+    if (enabledDisabled)
+        return 'enabled/disabled mismatch on overlapping statement';
+    const trueFalse = (containsAny(a, [' true ', ' true.', ' true,', ' yes ']) && containsAny(b, [' false ', ' false.', ' false,', ' no ']))
+        || (containsAny(b, [' true ', ' true.', ' true,', ' yes ']) && containsAny(a, [' false ', ' false.', ' false,', ' no ']));
+    if (trueFalse)
+        return 'true/false mismatch on overlapping statement';
+    const alwaysNever = (containsAny(a, [' always ', ' must ']) && containsAny(b, [' never ', ' must not ']))
+        || (containsAny(b, [' always ', ' must ']) && containsAny(a, [' never ', ' must not ']));
+    if (alwaysNever)
+        return 'always/never mismatch on overlapping statement';
+    if ((aPolarity === 'positive' && bPolarity === 'negative') || (aPolarity === 'negative' && bPolarity === 'positive')) {
+        return 'negation polarity mismatch on overlapping statement';
+    }
+    return null;
+}
+function inferConflictPolarity(text) {
+    const lowered = ` ${text.toLowerCase()} `;
+    const negativePatterns = [
+        ' not ', ' never ', ' no ', " don't ", ' do not ', " doesn't ", ' does not ',
+        " can't ", ' cannot ', " shouldn't ", ' should not ', ' disabled ', ' disable ', ' off ',
+        ' false ', ' missing ', ' broken ', ' failed ',
+    ];
+    const positivePatterns = [
+        ' enabled ', ' enable ', ' works ', ' working ', ' true ', ' available ', ' present ', ' on ',
+        ' always ', ' must ',
+    ];
+    if (containsAny(lowered, negativePatterns))
+        return 'negative';
+    if (containsAny(lowered, positivePatterns))
+        return 'positive';
+    return 'neutral';
+}
+function stripConflictPolarity(text) {
+    return text
+        .toLowerCase()
+        .replace(/\b(?:not|never|no|don['’]?t|do\s+not|doesn['’]?t|does\s+not|can['’]?t|cannot|shouldn['’]?t|should\s+not|enabled|enable|disabled|disable|on|off|true|false|always|must|must\s+not|works?|working|missing|broken|failed|available|present)\b/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function containsAny(text, needles) {
+    return needles.some((needle) => text.includes(needle));
+}
+//# sourceMappingURL=conflicts.js.map

package/dist/consolidate/decay.d.ts

@@ -0,0 +1,12 @@
+import { MemoryEntry } from '../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. */
+export interface DecayOutcome {
+    rescuedIds: Set<string>;
+    rescuedEntries: MemoryEntry[];
+    rankById: Map<string, MvRankInfo>;
+}
+export declare function decayPass(run: SleepRun): DecayOutcome;
+//# sourceMappingURL=decay.d.ts.map