hippo-memory 1.71.0 → 2.0.0

package/dist/core/ablation.js

@@ -2,7 +2,10 @@
  * Not a production surface. Env is read once per process; tests that mutate these vars MUST call _resetAblationCacheForTests() in beforeEach AND afterEach. See
  * docs/ARCHITECTURE.md#srccoreablationts. */
 import { envAblateDecay, envAblateOutcome, envAblateOutcomeFast, envAblateOutcomeSlow, envAblateRecallBoost, envAblateRecency, envEvalRecencyDays, envFakeNowMs, } from '../util/env.js';
+/** Production scoring: nothing ablated. Core falls back to this, so it never reads the environment. */
+export const NO_STRENGTH_ABLATION = Object.freeze({ decay: false, recallBoost: false, outcomeSlow: false });
 let _cache;
+let _strengthCache;
 function readFlags() {
     if (_cache !== undefined)
         return _cache;
@@ -18,6 +21,14 @@ function readFlags() {
     };
     return _cache;
 }
+/** The frozen strength switches for this process; entry-layer callers pass them as `DecayOptions.ablation`. */
+export function strengthAblation() {
+    if (_strengthCache === undefined) {
+        const f = readFlags();
+        _strengthCache = Object.freeze({ decay: f.decay, recallBoost: f.recallBoost, outcomeSlow: f.outcomeSlow });
+    }
+    return _strengthCache;
+}
 export function isDecayAblated() {
     return readFlags().decay;
 }
@@ -45,5 +56,6 @@ export function evalNow() {
 /** Test-only. See module JSDoc: call in BOTH beforeEach AND afterEach. */
 export function _resetAblationCacheForTests() {
     _cache = undefined;
+    _strengthCache = undefined;
 }
 //# sourceMappingURL=ablation.js.map

package/dist/{sharing/scope.d.ts → core/active-scope.d.ts}

@@ -4,4 +4,4 @@ export declare function detectScope(): string | null;
 /** Compute scope match between a memory's scope tags and the active scope.
  *  Returns: 1 if matching scope, -1 if mismatching scope, 0 if neutral (no scope on either side). */
 export declare function scopeMatch(memoryTags: string[], activeScope: string | null): -1 | 0 | 1;
-//# sourceMappingURL=scope.d.ts.map
+//# sourceMappingURL=active-scope.d.ts.map

package/dist/{sharing/scope.js → core/active-scope.js}

@@ -26,4 +26,4 @@ export function scopeMatch(memoryTags, activeScope) {
         return 1; // match
     return -1; // mismatch
 }
-//# sourceMappingURL=scope.js.map
+//# sourceMappingURL=active-scope.js.map

package/dist/core/ambient.d.ts

@@ -13,6 +13,10 @@ export interface AmbientState {
     dagDepth: number;
     totalMemories: number;
 }
+/** A memory is fresh when created within this window. */
+export declare const AMBIENT_FRESH_WINDOW_MS: number;
+/** A memory counts as high schema fit strictly above this. */
+export declare const HIGH_SCHEMA_FIT_ABOVE = 0.7;
 /** Row counts and sums an AmbientState is derived from; two stores' tallies add with addAmbientTallies. */
 export interface AmbientTallies {
     total: number;

package/dist/core/ambient.js

@@ -1,9 +1,29 @@
 /** Ambient state vector: a compact O(N) summary of the corpus telling the agent "where it is" in knowledge-space without retrieving specific memories. */
-import { evalNow } from './ablation.js';
+import { evalNow, strengthAblation } from './ablation.js';
 import { Layer } from './memory.js';
 import { calculateStrength } from './memory.js';
 import { DAY_MS } from '../util/time.js';
 const STATE_DECIMALS = 3;
+// Cut points renderAmbientSummary uses to turn the state vector into words.
+const SUMMARY_THRESHOLD = {
+    freshHigh: 0.5,
+    freshLow: 0.1,
+    skewHigh: 0.3,
+    skewLow: -0.3,
+    consolidatedHigh: 0.4,
+    consolidatedLow: 0.1,
+    extractionHigh: 0.5,
+    conflictShown: 0.1,
+    dagDepthShown: 2,
+    strengthLow: 0.3,
+    strengthHigh: 0.7,
+    entropyHigh: 0.8,
+    entropyLow: 0.3,
+};
+/** A memory is fresh when created within this window. */
+export const AMBIENT_FRESH_WINDOW_MS = 7 * DAY_MS;
+/** A memory counts as high schema fit strictly above this. */
+export const HIGH_SCHEMA_FIT_ABOVE = 0.7;
 /** The tallies of two disjoint row sets taken together. */
 export function addAmbientTallies(a, b) {
     const tagCounts = new Map(a.tagCounts);
@@ -31,7 +51,7 @@ export function isErrorTagged(tags) {
 /** Tallies over loaded entries; superseded rows count toward the total only, as they always have here. */
 export function tallyAmbientEntries(entries, now) {
     const currentTime = now ?? evalNow(); // honors HIPPO_FAKE_NOW (eval-only)
-    const sevenDaysAgo = currentTime.getTime() - 7 * DAY_MS;
+    const freshAfter = currentTime.getTime() - AMBIENT_FRESH_WINDOW_MS;
     const t = {
         total: entries.length, strengthSum: 0, fresh: 0, negative: 0, highSchemaFit: 0, errors: 0,
         semantic: 0, episodic: 0, conflicts: 0, extracted: 0, maxDagLevel: 0, tagCounts: new Map(),
@@ -41,14 +61,14 @@ export function tallyAmbientEntries(entries, now) {
             continue;
         for (const tag of entry.tags)
             t.tagCounts.set(tag, (t.tagCounts.get(tag) ?? 0) + 1);
-        t.strengthSum += calculateStrength(entry, currentTime);
-        if (new Date(entry.created).getTime() > sevenDaysAgo)
+        t.strengthSum += calculateStrength(entry, currentTime, { ablation: strengthAblation() });
+        if (new Date(entry.created).getTime() > freshAfter)
             t.fresh++;
         if (entry.emotional_valence === 'negative' || entry.emotional_valence === 'critical')
             t.negative++;
         if (isErrorTagged(entry.tags))
             t.errors++;
-        if (entry.schema_fit > 0.7)
+        if (entry.schema_fit > HIGH_SCHEMA_FIT_ABOVE)
             t.highSchemaFit++;
         if (entry.layer === Layer.Semantic)
             t.semantic++;
@@ -116,33 +136,34 @@ function shannonEntropy(counts, total) {
 export function renderAmbientSummary(state) {
     if (state.totalMemories === 0)
         return 'Memory state: empty store, no memories yet.';
+    const T = SUMMARY_THRESHOLD;
     const parts = [];
     parts.push(`${state.totalMemories} memories`);
-    if (state.recencyFreshness > 0.5)
+    if (state.recencyFreshness > T.freshHigh)
         parts.push('mostly fresh (<7d)');
-    else if (state.recencyFreshness < 0.1)
+    else if (state.recencyFreshness < T.freshLow)
         parts.push('mostly aged');
-    if (state.emotionalSkew > 0.3)
+    if (state.emotionalSkew > T.skewHigh)
         parts.push('error-focused');
-    else if (state.emotionalSkew < -0.3)
+    else if (state.emotionalSkew < T.skewLow)
         parts.push('steady operation');
-    if (state.consolidationRatio > 0.4)
+    if (state.consolidationRatio > T.consolidatedHigh)
         parts.push('well-consolidated');
-    else if (state.consolidationRatio < 0.1)
+    else if (state.consolidationRatio < T.consolidatedLow)
         parts.push('mostly episodic');
-    if (state.extractionCoverage > 0.5)
+    if (state.extractionCoverage > T.extractionHigh)
         parts.push('high extraction coverage');
-    if (state.conflictIntensity > 0.1)
+    if (state.conflictIntensity > T.conflictShown)
         parts.push(`${(state.conflictIntensity * 100).toFixed(0)}% conflict rate`);
-    if (state.dagDepth >= 2)
+    if (state.dagDepth >= T.dagDepthShown)
         parts.push(`DAG depth ${state.dagDepth}`);
-    if (state.avgStrength < 0.3)
+    if (state.avgStrength < T.strengthLow)
         parts.push('low avg strength (aging corpus)');
-    else if (state.avgStrength > 0.7)
+    else if (state.avgStrength > T.strengthHigh)
         parts.push('high avg strength');
-    if (state.tagEntropy > 0.8)
+    if (state.tagEntropy > T.entropyHigh)
         parts.push('diverse topics');
-    else if (state.tagEntropy < 0.3)
+    else if (state.tagEntropy < T.entropyLow)
         parts.push('narrow focus');
     return `Memory state: ${parts.join(', ')}.`;
 }

package/dist/core/api-errors.d.ts

@@ -24,4 +24,20 @@ export declare class ConflictError extends ApiError {
     readonly status = 409;
     constructor(message: 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;
+    });
+}
 //# sourceMappingURL=api-errors.d.ts.map

package/dist/core/api-errors.js

@@ -1,4 +1,5 @@
 /** Errors whose HTTP status is part of the API contract; the server maps by class, so message text can change freely. */
+import { DIGEST_DISPLAY_CHARS } from '../util/token-text.js';
 /** Base class: an error the caller caused, carrying the status the HTTP layer answers with. */
 export class ApiError extends Error {
 }
@@ -34,4 +35,23 @@ export class ConflictError extends ApiError {
         this.name = 'ConflictError';
     }
 }
+/** 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;
+    }
+}
 //# sourceMappingURL=api-errors.js.map

package/dist/core/card.js

@@ -1,3 +1,5 @@
+// Work-queue card types: a claimable unit of work, N candidates claim one row, first wins.
+import { HOUR_MS } from '../util/time.js';
 const CARD_STATUSES = ['backlog', 'ready', 'running', 'blocked', 'review', 'done', 'shelved'];
 /** Narrows a raw string, such as a CLI flag value, to a CardStatus. */
 export function isCardStatus(v) {
@@ -15,7 +17,7 @@ export const CARD_TRANSITIONS = {
 };
 // SHORTCUT: one fixed lease for every claim; add a per-claim lease when the W3 dispatcher heartbeats on a timer.
 /** How long a claim or a heartbeat keeps a running card's lease before reclaimExpiredCards may return it to ready. */
-export const CARD_LEASE_MS = 4 * 60 * 60 * 1000;
+export const CARD_LEASE_MS = 4 * HOUR_MS;
 /** Throws on any move CARD_TRANSITIONS does not allow, before a status write touches the row. */
 export function assertCardTransition(from, to) {
     for (const status of from) {

package/dist/core/compaction-timing.d.ts

@@ -0,0 +1,7 @@
+/** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
+export declare const COMPACTION_DB_WAIT_MS = 2000;
+/** Long enough that a live hook has finished with its own record. */
+export declare const REPLAY_AFTER_MS: number;
+/** Claude Code deletes transcripts after 30 days, so an older gap can never be filled. */
+export declare const TRANSCRIPT_FILL_WINDOW_MS: number;
+//# sourceMappingURL=compaction-timing.d.ts.map

package/dist/core/compaction-timing.js

@@ -0,0 +1,9 @@
+// Waits and windows shared by the compaction record's SQL (src/store) and the hooks and CLI that schedule it.
+import { DAY_MS, MINUTE_MS } from '../util/time.js';
+/** PostCompact has 10 s in all (PreCompact 30 s), so a locked store must be given up on early. */
+export const COMPACTION_DB_WAIT_MS = 2000;
+/** Long enough that a live hook has finished with its own record. */
+export const REPLAY_AFTER_MS = 10 * MINUTE_MS;
+/** Claude Code deletes transcripts after 30 days, so an older gap can never be filled. */
+export const TRANSCRIPT_FILL_WINDOW_MS = 30 * DAY_MS;
+//# sourceMappingURL=compaction-timing.js.map

package/dist/core/config.d.ts

@@ -20,7 +20,7 @@ export interface HippoConfig {
         model: string;
         hybridWeight: number;
         /** Embedding backend: 'local' (default) = zero-dependency transformers.js; 'openai' | 'voyage' | 'cohere' = opt-in API embedder needing the provider's
-         *  API key in env (OPENAI_API_KEY / VOYAGE_API_KEY / COHERE_API_KEY). See src/store/embeddings/provider.ts. */
+         *  API key in env (OPENAI_API_KEY / VOYAGE_API_KEY / COHERE_API_KEY). See src/embeddings/provider.ts. */
         provider?: 'local' | 'openai' | 'voyage' | 'cohere';
         /** Optional API base-URL override (self-host / proxy). HTTPS only (localhost
          *  may use http). Ignored by the local provider. */

package/dist/core/config.js

@@ -6,7 +6,7 @@ import * as path from 'path';
 import { DEFAULT_PHYSICS_CONFIG, mergePhysicsConfig } from './physics-config.js';
 import { DEFAULT_HALF_LIFE_DAYS } from './memory.js';
 import { DEFAULT_LOCAL_BUMP, DEFAULT_RECALL_BUDGET } from './search-types.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorCode, errorMessage, log } from '../util/log.js';
 import { isJsonObject } from '../util/json.js';
 export const DEFAULT_CONFIG = {
     defaultHalfLifeDays: DEFAULT_HALF_LIFE_DAYS,
@@ -243,21 +243,32 @@ function fileStamp(file) {
         return stat === undefined ? null : `${stat.mtimeMs}:${stat.size}`;
     }
     catch (err) {
-        log.debug(`config: ${file} could not be reached, read as missing: ${errorMessage(err)}`);
+        const code = errorCode(err);
+        const message = `config: ${file} could not be reached, read as missing: ${errorMessage(err)}`;
+        if (code === 'EACCES' || code === 'EPERM')
+            log.warnThenDebug(`config-unreachable:${file}:${code}`, message, { path: file, code });
+        else
+            log.debug(message);
         return null;
     }
 }
-function parseConfigFile(configPath) {
+/** A config.json that exists must load: running on defaults would silently drop the user's settings, such as `sharedStore`. */
+function readConfigFile(configPath) {
+    let raw;
     try {
-        const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        return configOverDefaults(raw);
+        raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     }
     catch (err) {
-        if (fs.existsSync(configPath)) {
-            log.warn(`failed to parse ${configPath}: ${errorMessage(err)}`);
-        }
-        return { ...DEFAULT_CONFIG };
+        throw new Error(`${configPath} could not be loaded: ${errorMessage(err)}. Fix the file or delete it to use the defaults.`, { cause: err });
     }
+    if (!isJsonObject(raw)) {
+        throw new Error(`${configPath} must hold a JSON object. Fix the file or delete it to use the defaults.`);
+    }
+    // SAFETY: an object is all the shape check proves; configOverDefaults validates each key it reads.
+    return raw;
+}
+function parseConfigFile(configPath) {
+    return configOverDefaults(readConfigFile(configPath));
 }
 function configOverDefaults(raw) {
     const basis = raw.decayBasis;
@@ -329,15 +340,8 @@ export function isSharedStore(hippoRoot) {
     const stamp = fileStamp(configPath);
     if (stamp === null || notSharedStamps.get(configPath) === stamp)
         return false;
-    let raw;
-    try {
-        raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    }
-    catch (err) {
-        log.warn(`failed to read ${configPath}: ${errorMessage(err)} - sharedStore read as false.`);
-        return false;
-    }
-    if (raw?.sharedStore !== true) {
+    const raw = readConfigFile(configPath);
+    if (raw.sharedStore !== true) {
         if (notSharedStamps.size >= PARSED_CONFIGS_MAX)
             notSharedStamps.clear();
         notSharedStamps.set(configPath, stamp);

package/dist/core/cosine.d.ts

@@ -0,0 +1,3 @@
+/** Cosine over any indexable vectors (a Float32 view scores as its number[] copy); 0 for empty, mismatched or zero-norm input. */
+export declare function cosineOf(a: ArrayLike<number>, b: ArrayLike<number>): number;
+//# sourceMappingURL=cosine.d.ts.map

package/dist/core/cosine.js

@@ -0,0 +1,19 @@
+/** Cosine over any indexable vectors (a Float32 view scores as its number[] copy); 0 for empty, mismatched or zero-norm input. */
+export function cosineOf(a, b) {
+    if (a.length === 0 || b.length === 0 || a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denom < 1e-10)
+        return 0;
+    // Clamp to [-1, 1] to handle floating point drift
+    return Math.min(1, Math.max(-1, dot / denom));
+}
+//# sourceMappingURL=cosine.js.map

package/dist/{store → core}/markdown.d.ts

@@ -1,4 +1,4 @@
-import { type MemoryEntry } from '../core/memory.js';
+import { type MemoryEntry } from './memory.js';
 /** Serialize a MemoryEntry to markdown with YAML frontmatter. */
 export declare function serializeEntry(entry: MemoryEntry): string;
 /** Deserialize a markdown file to a MemoryEntry. */

package/dist/{store → core}/markdown.js

@@ -1,6 +1,6 @@
 import { DEFAULT_TENANT_ID } from '../util/env.js';
-import { FALLBACK_HALF_LIFE_DAYS, DEFAULT_SCHEMA_FIT } from '../core/memory.js';
-import { dumpFrontmatter, parseFrontmatter } from './yaml.js';
+import { FALLBACK_HALF_LIFE_DAYS, DEFAULT_SCHEMA_FIT } from './memory.js';
+import { dumpFrontmatter, parseFrontmatter } from '../util/yaml.js';
 /** The fields every mirror file carries; serializeEntry adds the optional ones. */
 function entryFrontmatter(entry) {
     return {
@@ -42,7 +42,7 @@ export function serializeEntry(entry) {
     const frontmatter = entryFrontmatter(entry);
     // Emit tenant_id only when not 'default' to keep diffs clean for the dominant
     // single-tenant case (mirrors the plan's task 7 guidance).
-    const tenantId = entry.tenantId ?? DEFAULT_TENANT_ID;
+    const tenantId = entry.tenant_id ?? DEFAULT_TENANT_ID;
     if (tenantId !== DEFAULT_TENANT_ID) {
         frontmatter['tenant_id'] = tenantId;
     }
@@ -98,7 +98,7 @@ export function deserializeEntry(raw) {
         scope: data['scope'] === null || data['scope'] === undefined ? null : String(data['scope']),
         owner: data['owner'] === null || data['owner'] === undefined ? null : String(data['owner']),
         artifact_ref: data['artifact_ref'] === null || data['artifact_ref'] === undefined ? null : String(data['artifact_ref']),
-        tenantId: data['tenant_id'] === null || data['tenant_id'] === undefined ? DEFAULT_TENANT_ID : String(data['tenant_id']),
+        tenant_id: data['tenant_id'] === null || data['tenant_id'] === undefined ? DEFAULT_TENANT_ID : String(data['tenant_id']),
         origin_project: !('origin_project' in data) ? undefined : data['origin_project'] === null ? null : String(data['origin_project']),
     };
 }

package/dist/core/memory-audit.d.ts

@@ -0,0 +1,17 @@
+import { type MemoryEntry } from './memory.js';
+export type AuditSeverity = 'warning' | 'error';
+export interface AuditIssue {
+    memoryId: string;
+    content: string;
+    severity: AuditSeverity;
+    reason: string;
+}
+export interface AuditResult {
+    total: number;
+    issues: AuditIssue[];
+    clean: number;
+}
+export declare function auditMemory(entry: MemoryEntry, backsObject?: boolean): AuditIssue | null;
+/** `backing`: ids of memories that back an object (store.memoriesBackingObjects). */
+export declare function auditMemories(entries: MemoryEntry[], backing: ReadonlySet<string>): AuditResult;
+//# sourceMappingURL=memory-audit.d.ts.map

package/dist/core/memory-audit.js

@@ -0,0 +1,54 @@
+// The memory-quality audit rules: pure functions of a row, so any store can be audited by them.
+import { canAutoDelete } from './memory.js';
+import { automaticDefect, hasNoSpecificity, isFragment, isReleaseCommitNoise, substantiveWordCount, } from './memory-quality.js';
+export function auditMemory(entry, backsObject = false) {
+    const issue = classifyMemory(entry);
+    // Error means "auto-remove"; a pinned, raw, kept-for-good or object-backing row is never auto-removed, so it can only warn.
+    if (issue?.severity === 'error' && (!canAutoDelete(entry) || backsObject)) {
+        const why = entry.pinned ? 'pinned' : entry.kind === 'raw' ? 'raw' : backsObject ? 'backs an object' : 'keep rule';
+        return { ...issue, severity: 'warning', reason: `${issue.reason} (${why}, kept)` };
+    }
+    return issue;
+}
+function classifyMemory(entry) {
+    const content = entry.content.trim();
+    if (content.length < 3) {
+        return { memoryId: entry.id, content, severity: 'error', reason: 'too short (< 3 chars)' };
+    }
+    if (content.length < 10) {
+        return { memoryId: entry.id, content, severity: 'error', reason: 'too short (< 10 chars)' };
+    }
+    if (isReleaseCommitNoise(content)) {
+        return { memoryId: entry.id, content, severity: 'error', reason: 'release/commit noise, not a useful memory' };
+    }
+    if (isFragment(content)) {
+        return { memoryId: entry.id, content, severity: 'warning', reason: 'sentence fragment — lacks context' };
+    }
+    const substantive = substantiveWordCount(content);
+    if (substantive < 2) {
+        return { memoryId: entry.id, content, severity: 'warning', reason: `only ${substantive} substantive word(s) — too vague` };
+    }
+    if (content.length < 40 && hasNoSpecificity(content)) {
+        return { memoryId: entry.id, content, severity: 'warning', reason: 'no specific details (names, paths, numbers, code)' };
+    }
+    const reason = automaticDefect(entry);
+    if (reason !== null) {
+        return { memoryId: entry.id, content, severity: 'warning', reason: `automatic memory defect: ${reason}` };
+    }
+    return null;
+}
+/** `backing`: ids of memories that back an object (store.memoriesBackingObjects). */
+export function auditMemories(entries, backing) {
+    const issues = [];
+    for (const entry of entries) {
+        const issue = auditMemory(entry, backing.has(entry.id));
+        if (issue)
+            issues.push(issue);
+    }
+    return {
+        total: entries.length,
+        issues,
+        clean: entries.length - issues.length,
+    };
+}
+//# sourceMappingURL=memory-audit.js.map

package/dist/core/memory.d.ts

@@ -1,4 +1,5 @@
 /** Core data model for Hippo memory entries, based on the strength formula from PLAN.md. */
+import { type StrengthAblation } from './ablation.js';
 export declare const DEFAULT_SCHEMA_FIT = 0.5;
 export declare const FALLBACK_HALF_LIFE_DAYS = 7;
 export declare enum Layer {
@@ -10,7 +11,8 @@ export declare enum Layer {
 export type EmotionalValence = 'neutral' | 'positive' | 'negative' | 'critical';
 export type ConfidenceLevel = 'verified' | 'observed' | 'inferred' | 'stale';
 export type TraceOutcome = 'success' | 'failure' | 'partial' | null;
-export type MemoryKind = 'raw' | 'distilled' | 'superseded' | 'archived';
+export declare const MEMORY_KINDS: readonly ["raw", "distilled", "superseded", "archived"];
+export type MemoryKind = (typeof MEMORY_KINDS)[number];
 export interface MemoryEntry {
     id: string;
     created: string;
@@ -42,8 +44,8 @@ export interface MemoryEntry {
     descendant_count?: number;
     earliest_at?: string | null;
     latest_at?: string | null;
-    /** 1 when a child was invalidated, superseded, forgotten or archived since the last rebuild; sleep clears it. Always 0 below level 2. */
-    summary_dirty?: 0 | 1;
+    /** True when a child was invalidated, superseded, forgotten or archived since the last rebuild; sleep clears it. Always false below level 2. */
+    summary_dirty?: boolean;
     /** ISO 8601 time of the last successful rebuild, or null if never rebuilt. */
     last_rebuilt_at?: string | null;
     /** Count of successful rebuilds: 0 at the first buildDag write, bumped by each rebuild. */
@@ -54,7 +56,7 @@ export interface MemoryEntry {
     scope: string | null;
     owner: string | null;
     artifact_ref: string | null;
-    tenantId: string;
+    tenant_id: string;
     /** Owning project, lowercased; '' = user-global (injectable everywhere), null = none known (legacy or unnamed write), denied by ambient context.
      *  Stamped at write time by stampOriginProject (src/store/entry-row.ts); undefined only before the first write. */
     origin_project?: string | null;
@@ -75,14 +77,14 @@ export declare function _resetLossAversionRatioCacheForTests(): void;
 /** Scales only the `negative` multiplier; `critical` stays unscaled so the knob moves just the losses-vs-gains claim. */
 export declare function applyLossAversionRatio(valence: EmotionalValence, baseMultiplier: number): number;
 /** 1 + REWARD_SLOPE * (pos - neg) / (pos + neg + 1), in (0.5, 1.5), 1.0 with no outcomes; it scales the effective half-life. */
-export declare function calculateRewardFactor(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>): number;
+export declare function calculateRewardFactor(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>, ablation?: StrengthAblation): number;
 /** Bad marks alone never push a memory under sleep's 0.05 retire line; supersede is the hard correction. */
 export declare const MAX_WRONG_HALVINGS = 3;
 export declare const DECAY_BASE = 0.5;
 export declare const REWARD_SLOPE = 0.5;
 export declare const RETRIEVAL_BOOST_SLOPE = 0.1;
 /** Bad outcome marks past good ones, floored at zero; each halves strength and stops recall strengthening, so a correction outranks pinning. */
-export declare function netWrong(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>): number;
+export declare function netWrong(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>, ablation?: StrengthAblation): number;
 /** What calculateStrength reads, so a caller can score a row without loading its text. */
 export type StrengthInputs = Pick<MemoryEntry, 'pinned' | 'created' | 'last_retrieved' | 'half_life_days' | 'retrieval_count' | 'emotional_valence' | 'outcome_positive' | 'outcome_negative'>;
 /** Decay basis: clock = wall time, session = per sleep cycle (intermittent agents), adaptive = half-life scaled by session frequency. */
@@ -92,6 +94,8 @@ export interface DecayOptions {
     avgSessionIntervalDays?: number;
     /** Total sleep cycles completed. Used by consolidation tracking. */
     sleepCount?: number;
+    /** EVAL-ONLY switches resolved once at the entry layer (`strengthAblation()`); absent means production scoring. */
+    ablation?: StrengthAblation;
 }
 /** Strength at `now` = decay * retrieval boost * emotional multiplier, clamped to [0, 1]; the basis modes are on DecayOptions.
  *  Pinned memories skip time decay, but being marked wrong still fades them (netWrong). */
@@ -110,7 +114,7 @@ export interface ConfidenceFacets {
     tier: ConfidenceLevel;
     agedOut: boolean;
 }
-export declare function confidenceFacets(entry: MemoryEntry, now?: Date): ConfidenceFacets;
+export declare function confidenceFacets(entry: ConfidenceInputs, now?: Date): ConfidenceFacets;
 export declare function facetsOf(entry: ConfidenceInputs, now: Date): ConfidenceFacets;
 export declare function confidenceLabel(entry: MemoryEntry, now?: Date): {
     text: string;
@@ -167,6 +171,8 @@ export declare function createSuccessor(old: MemoryEntry, content: string, opts:
 /** How well new content fits existing knowledge, 0..1: above 0.7 consolidates faster, below 0.3 is novel and decays faster if unused.
  *  Tags shared with existing memories count by rarity (a rare shared tag fits more), plus content-token overlap. */
 export declare function computeSchemaFit(content: string, tags: string[], existingEntries: MemoryEntry[]): number;
+/** What schema fit reads from `entries`, built once for a caller that scores many contents against the same rows. */
+export declare function schemaFitSourceOf(entries: readonly MemoryEntry[]): SchemaFitSource;
 /** What schema fit reads from a set of memories, so a store can answer without loading its rows. */
 export interface SchemaFitSource {
     readonly rows: number;
@@ -179,5 +185,5 @@ export interface SchemaFitSource {
 export declare function schemaFitFrom(content: string, tags: readonly string[], source: SchemaFitSource): number;
 /** Returns copies with the retrieval count, clock and half-life updated; the caller persists them.
  *  Under HIPPO_ABLATE_RECALL_BOOST (eval-only) the entries come back unchanged, not empty, since callers derive last_retrieval_ids from them. */
-export declare function markRetrieved(entries: MemoryEntry[], now?: Date): MemoryEntry[];
+export declare function markRetrieved(entries: MemoryEntry[], now?: Date, options?: Pick<DecayOptions, 'ablation'>): MemoryEntry[];
 //# sourceMappingURL=memory.d.ts.map