hippo-memory 1.70.0 → 1.72.0

package/dist/consolidate/sleep.js

@@ -1,14 +1,7 @@
-/**
- * Consolidation engine ("Sleep") for Hippo.
- *
- * Steps:
- * 1. Decay pass  - remove entries below strength threshold
- * 2. Merge pass  - find episodic entries with high text overlap, create semantic summaries
- * 3. Stats tracking
- */
-import { evalNow } from '../core/ablation.js';
+/** Consolidation engine ("Sleep"): decay pass (drop entries below the strength threshold), merge pass (semantic summaries of overlapping episodics), stats. */
+import { evalNow, strengthAblation } from '../core/ablation.js';
 import { canAutoDelete } from '../core/memory.js';
-import { loadAllEntries } from '../store/entry-reads.js';
+import { loadAllEntriesWithBase } from '../store/entry-reads.js';
 import { commitInChunks, memoriesBackingObjects } from '../store/delete-and-batch.js';
 import { appendConsolidationRun, loadSessionDecayContext, incrementSleepCount } from '../store/index-and-stats.js';
 import { replaceDetectedConflicts } from '../store/conflicts.js';
@@ -18,7 +11,7 @@ import { loadConfig } from '../core/config.js';
 import { recordAuditEventsRowByRow, reportAuditWriteFailure } from '../store/audit.js';
 import { lazyTombstoneChecks } from '../store/tombstone-checks.js';
 import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from './half-life-migration.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorFields, errorMessage, log } from '../util/log.js';
 import { WRITE_BUDGET } from '../util/write-budget.js';
 import { decayPass } from './decay.js';
 import { familyUnits, groupFlush } from './flush-units.js';
@@ -40,14 +33,13 @@ export async function consolidate(hippoRoot, options = {}) {
     syncFtsIndex(hippoRoot, dryRun, result);
     // Host-wide by design: per-tenant filtering would mean N runs per host and no cross-tenant dedup.
     // The api.sleep audit row tags this with the admin synthetic actor.
-    const all = loadAllEntries(hippoRoot);
+    const { entries: all, base: snapshot } = loadAllEntriesWithBase(hippoRoot);
     if (dryRun)
         for (const e of all)
             e.half_life_days = halfLife.halfLives.get(e.id) ?? e.half_life_days;
     const backingObjects = memoriesBackingObjects(hippoRoot);
     // Retirable: auto-deletable (never pinned, raw or kept for good) and not backing a first-class object.
     const retirable = (entry) => canAutoDelete(entry) && !backingObjects.has(entry.id);
-    const snapshot = new Map(structuredClone(all).map((e) => [e.id, e]));
     const config = loadConfig(hippoRoot);
     const decayOpts = sessionDecayOptions(hippoRoot, config);
     const run = {
@@ -76,6 +68,7 @@ function sessionDecayOptions(hippoRoot, config) {
         decayBasis: config.decayBasis,
         avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
         sleepCount: sessionCtx.sleepCount,
+        ablation: strengthAblation(),
     };
 }
 /** Every pass between decay and the flush; the tombstone-check handle closes whichever of them throws. */
@@ -104,7 +97,8 @@ function migrateHalfLives(hippoRoot, dryRun, result) {
         result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.rescaled} memories from the ${halfLife.from}-day to the ${halfLife.to}-day half-life`);
     }
     if (halfLife.typed > 0) {
-        result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.typed} memories of decisions, incidents and other objects from the ${LEGACY_TYPED_HALF_LIFE}-day to the ${halfLife.to}-day half-life`);
+        result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.typed} memories of decisions, incidents and other objects ` +
+            `from the ${LEGACY_TYPED_HALF_LIFE}-day to the ${halfLife.to}-day half-life`);
     }
     return halfLife;
 }
@@ -125,10 +119,8 @@ async function flushPending(run, snapshot, budget) {
     result.removed = result.removedIds.length;
     result.dormant = pendingDormant.filter((m) => left.has(m.entry.id)).length;
 }
-// Dormant retention: a dormant memory nobody restored within
-// dormant.retentionDays is deleted for good (0 keeps them forever). Runs
-// even when dormant.enabled is off, so turning it off still ages out what
-// earlier sleeps kept.
+// Dormant retention: a dormant memory nobody restored within dormant.retentionDays is deleted for good (0 keeps forever);
+// runs even when dormant.enabled is off, so turning it off still ages out what earlier sleeps kept.
 async function expireDormant(run, budget) {
     const { config, result, dryRun } = run;
     if (!(config.dormant.retentionDays > 0))
@@ -136,12 +128,11 @@ async function expireDormant(run, budget) {
     const cutoff = new Date(run.now.getTime() - config.dormant.retentionDays * DAY_MS).toISOString();
     result.dormantExpired = await expireDormantBefore(run.hippoRoot, cutoff, { dryRun, budget, busyWaitMs: SLEEP_DB_WAIT_MS });
     if (result.dormantExpired > 0) {
-        result.details.push(`  ⌛ ${dryRun ? 'would expire' : 'expired'} ${result.dormantExpired} dormant memor${result.dormantExpired === 1 ? 'y' : 'ies'} older than ${config.dormant.retentionDays} days`);
+        result.details.push(`  ⌛ ${dryRun ? 'would expire' : 'expired'} ${result.dormantExpired} dormant memor${result.dormantExpired === 1 ? 'y' : 'ies'} ` +
+            `older than ${config.dormant.retentionDays} days`);
     }
 }
-// -------------------------------------------------------------------------
 // 4. Log run
-// -------------------------------------------------------------------------
 function logRun(run, decay) {
     const { hippoRoot, now, result } = run;
     const detectedConflicts = detectConflicts(run.survivors, now, run.decayOpts, decay.rescuedIds);
@@ -187,7 +178,7 @@ function auditRescues(run, { rescuedEntries, rankById }) {
     }
     catch (err) {
         // An audit store that will not open must never crash the mutation it records.
-        log.debug(`mv_rescue audit unavailable: ${errorMessage(err)}`);
+        log.warn(`mv_rescue audit unavailable: ${errorMessage(err)}`, { errorClass: errorFields(err).errorClass });
         result.details.push(`  ⚠️ memory-value: mv_rescue audit unavailable this cycle ` +
             `(${rescuedEntries.length} rescue${rescuedEntries.length === 1 ? '' : 's'} not audited)`);
     }

package/dist/consolidate/trace.d.ts

@@ -1,10 +1,5 @@
-/**
- * Trace-layer helpers.
- *
- * A trace is a `MemoryEntry` with `layer === 'trace'` that captures an ordered
- * sequence of agent actions and their final outcome. v1 stores steps as
- * markdown in `content`; `renderTraceContent` is the canonical formatter.
- */
+/** Trace-layer helpers. A trace is a `MemoryEntry` with `layer === 'trace'`: ordered agent actions and their outcome, stored as markdown in `content`
+ * (`renderTraceContent` formats it). */
 export interface TraceStep {
     action: string;
     observation: string;
@@ -15,17 +10,7 @@ export interface TraceRecord {
     steps: TraceStep[];
     outcome: 'success' | 'failure' | 'partial';
 }
-/**
- * Render a trace record as agent-readable markdown.
- *
- * Format:
- *   Task: <task>
- *   Outcome: <outcome>
- *   Steps:
- *     1. <action>
- *        → <observation>   (omitted if observation is empty)
- *     2. ...
- */
+/** Render a trace record as agent-readable markdown: `Task:`, `Outcome:`, then numbered `Steps:` with each observation on an arrow line (omitted if empty). */
 export declare function renderTraceContent(rec: TraceRecord): string;
 /**
  * Parse a JSON string into an array of TraceStep. Throws on invalid shape.

package/dist/consolidate/trace.js

@@ -1,23 +1,8 @@
-/**
- * Trace-layer helpers.
- *
- * A trace is a `MemoryEntry` with `layer === 'trace'` that captures an ordered
- * sequence of agent actions and their final outcome. v1 stores steps as
- * markdown in `content`; `renderTraceContent` is the canonical formatter.
- */
+/** Trace-layer helpers. A trace is a `MemoryEntry` with `layer === 'trace'`: ordered agent actions and their outcome, stored as markdown in `content`
+ * (`renderTraceContent` formats it). */
 import { isJsonString, isJsonObject } from '../util/json.js';
 import { errorMessage } from '../util/log.js';
-/**
- * Render a trace record as agent-readable markdown.
- *
- * Format:
- *   Task: <task>
- *   Outcome: <outcome>
- *   Steps:
- *     1. <action>
- *        → <observation>   (omitted if observation is empty)
- *     2. ...
- */
+/** Render a trace record as agent-readable markdown: `Task:`, `Outcome:`, then numbered `Steps:` with each observation on an arrow line (omitted if empty). */
 export function renderTraceContent(rec) {
     const lines = [];
     lines.push(`Task: ${rec.task}`);

package/dist/consolidate/traces.js

@@ -1,4 +1,4 @@
-import { isRecallBoostAblated } from '../core/ablation.js';
+import { isRecallBoostAblated, strengthAblation } from '../core/ablation.js';
 import { Layer, createMemory, markRetrieved } from '../core/memory.js';
 import { findPromotableSessions, traceExistsForSession, listSessionEvents } from '../store/sessions.js';
 import { rejectionDigest } from '../store/rejection.js';
@@ -6,19 +6,13 @@ import { sampleForReplay } from './replay.js';
 import { renderTraceContent } from './trace.js';
 import { resolveTenantId } from '../store/tenant.js';
 import { reportAuditWriteFailure } from '../store/audit.js';
-import { commonDerivationScope } from '../store/recall-scope.js';
+import { commonDerivationScope } from '../core/recall-scope.js';
 import { log } from '../util/log.js';
 import { REPLAY_COUNT_DEFAULT } from './run.js';
 import { isJsonString } from '../util/json.js';
 import { DAY_MS } from '../util/time.js';
-// -------------------------------------------------------------------------
-// 1.4. Auto-promote complete sessions to traces
-// -------------------------------------------------------------------------
-//
-// For each session within the configured window that has a `session_complete`
-// event and no existing trace (idempotency via the source_session_id column),
-// render the action sequence as markdown and persist a Layer.Trace memory.
-// Traces inherit decay, search, replay, and physics from the base MemoryEntry.
+// 1.4. Auto-promote complete sessions to traces: each session in the window with a `session_complete` event and no trace (idempotent via source_session_id)
+// is rendered as markdown and persisted as a Layer.Trace memory, which inherits decay, search, replay and physics.
 export function promoteSessionTraces(run) {
     const { result } = run;
     if (run.dryRun || run.config.autoTraceCapture === false)
@@ -129,30 +123,20 @@ function traceRejected(run, trace, sessionId) {
     }
     return true;
 }
-// -------------------------------------------------------------------------
-// 1.5. Replay pass — rehearse high-value survivors
-// -------------------------------------------------------------------------
-//
-// Biologically-inspired counterpart to hippocampal replay during slow-wave
-// sleep: sample N memories weighted by outcome + valence + under-rehearsal
-// + idle time, then apply the same retrieval-strengthening `markRetrieved`
-// applies to real queries. Distinct from decay (removal), physics (motion),
-// and merge (compression) — this is the "rehearse the important stuff so
-// it doesn't fade" pass.
+// 1.5. Replay pass: rehearse high-value survivors by sampling N memories weighted by outcome, valence, under-rehearsal and idle time,
+// then applying the `markRetrieved` strengthening, so important memories don't fade.
 export function replayPass(run) {
     const { survivors, now } = run;
     const replayCount = run.config.replay?.count ?? REPLAY_COUNT_DEFAULT;
-    // EVAL-ONLY ablation (see ablation.ts): replay rehearsal IS recall
-    // strengthening (same markRetrieved dynamics), so the strengthen-off arm
-    // silences the whole pass - markRetrieved would return unmutated entries
-    // and persisting them anyway would still refresh updated_at / mirrors.
+    // EVAL-ONLY ablation (see ablation.ts): replay rehearsal is recall strengthening, so the strengthen-off arm silences the whole pass;
+    // persisting unmutated entries anyway would still refresh updated_at and mirrors.
     if (!(replayCount > 0 && survivors.length > 0 && !isRecallBoostAblated()))
         return;
     const seed = Math.floor(now.getTime() / 1000) & 0xffffffff;
     const picked = sampleForReplay(survivors, replayCount, now, seed);
     if (picked.length === 0)
         return;
-    const rehearsed = markRetrieved(picked, now);
+    const rehearsed = markRetrieved(picked, now, { ablation: strengthAblation() });
     const rehearsedById = new Map(rehearsed.map((e) => [e.id, e]));
     // Update survivors in place so downstream passes see rehearsed state.
     for (let i = 0; i < survivors.length; i++) {

package/dist/core/ablation.d.ts

@@ -1,89 +1,16 @@
-/**
- * EVAL-ONLY lifecycle ablation switches.
- *
- * These env flags exist for controlled experiments on hippo's memory-lifecycle
- * mechanisms (the "lifecycle, ablated" paper protocol): each switch neutralizes
- * exactly ONE mechanism so its causal contribution can be measured in isolation.
- *
- * They are NOT a production configuration surface:
- *   - no config-file equivalents, deliberately (config implies support);
- *   - undocumented in user-facing help;
- *   - semantics may change with the experiment design.
- * Production behavior with all flags unset is byte-identical to before this
- * module existed.
- *
- * Flags (set to '1' or 'true'):
- *   HIPPO_ABLATE_DECAY         time-decay term := 1 in calculateStrength.
- *   HIPPO_ABLATE_RECALL_BOOST  full recall-strengthening ablation:
- *                              - markRetrieved returns entries UNMUTATED (no
- *                                clock reset / count / half-life increment);
- *                                ids stay available so `hippo outcome`
- *                                attribution keeps working in this arm;
- *                              - persisting callers (CLI recall, api context,
- *                                MCP recall/context, consolidation replay)
- *                                skip their writeEntry loops (identical-row
- *                                writes still refresh updated_at / mirrors /
- *                                DAG dirty flags);
- *                              - the retrieval-count READ boost := 1;
- *                              - decay anchors at `created` instead of
- *                                `last_retrieved` (prior-run clock resets
- *                                cannot leak in);
- *                              - physics: computeMass ignores the count, and
- *                                physicsSearch recomputes loaded masses LIVE
- *                                under ablated strength rules (persisted
- *                                masses embed recall history in their frozen
- *                                strength component);
- *                              - replay rehearsal is silenced entirely (it IS
- *                                strengthening; use config replay.count=0 to
- *                                separate replay in unflagged arms).
- *                              CAVEAT: half_life increments persisted by
- *                              prior unflagged runs are NOT reconstructed
- *                              (consolidation legitimately writes half_life
- *                              too) - ablation arms run on FRESH stores, as
- *                              the experiment protocol mandates.
- *   HIPPO_ABLATE_OUTCOME       both outcome channels := neutral
- *                              (= _SLOW + _FAST together). The slow side also
- *                              silences replay's outcome reward bias
- *                              (replayPriority). NOT gated: the opt-in
- *                              `recall --value-aware` rerank (an explicit CLI
- *                              flag that also reads outcome counts) - ablated
- *                              arms must not pass it.
- *   HIPPO_ABLATE_OUTCOME_SLOW  rewardFactor := 1 (no half-life modulation).
- *   HIPPO_ABLATE_OUTCOME_FAST  hybridSearch outcomeBoost := 1.
- *   HIPPO_ABLATE_RECENCY       search recency factor := 1 (the creation-age
- *                              multiplier 0.8 + 0.2*exp(-age/30d)); decay,
- *                              strengthening and outcomes stay live.
- *   HIPPO_EVAL_RECENCY_DAYS    a positive number replaces the 30-day scale of
- *                              that recency factor (tuning grids only). Unset,
- *                              zero, negative or junk values keep 30.
- *   HIPPO_FAKE_NOW            timestamp injected as the default `now` for
- *                              strength computation and retrieval stamping
- *                              (simulated-time protocols). MUST be the exact
- *                              Date.toISOString() form
- *                              (YYYY-MM-DDTHH:mm:ss.sssZ); validated by
- *                              round-trip, so junk, locale dates, non-UTC
- *                              offsets, and rolled-over dates (2026-02-31)
- *                              all fall back to the real clock.
- *
- * Formula notes (load-bearing for the experiments) - ablating decay has TWO
- * intrinsic co-effects, because the unified formula routes other mechanisms
- * THROUGH the decay term. Both are real properties of the architecture, not
- * implementation accidents; experiment analysis must attribute accordingly
- * (the decay-off arm is "decay + its dependents off", see prereg amendment A1):
- *   1. Read-side strengthening flattens: raw = retrievalBoost * emotionalMult
- *      >= 1, and the [0,1] clamp caps it at 1.0 - the recall boost can only
- *      offset decay, never exceed baseline. (Write-side still runs.)
- *   2. Outcome-slow goes inert: rewardFactor only acts by scaling the
- *      effective half-life INSIDE the decay exponent; with decay := 1 there
- *      is no exponent for it to modulate. Outcome-slow is decay-rate
- *      modulation BY DESIGN, so "no decay" necessarily means "no slow
- *      channel" (the fast channel in hybridSearch is unaffected).
- *
- * Env caching follows the house pattern (see getLossAversionRatio in
- * memory.ts): read once per process, with a test-only reset helper. Tests
- * that mutate these env vars MUST call _resetAblationCacheForTests() in BOTH
- * beforeEach AND afterEach.
- */
+/** EVAL-ONLY ablation switches (HIPPO_ABLATE_*, HIPPO_EVAL_RECENCY_DAYS, HIPPO_FAKE_NOW): each cuts ONE mechanism (outcome also replayPriority bias).
+ * 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. */
+/** The three switches strength scoring honours, resolved by the entry layer and handed to core in DecayOptions. */
+export interface StrengthAblation {
+    readonly decay: boolean;
+    readonly recallBoost: boolean;
+    readonly outcomeSlow: boolean;
+}
+/** Production scoring: nothing ablated. Core falls back to this, so it never reads the environment. */
+export declare const NO_STRENGTH_ABLATION: StrengthAblation;
+/** The frozen strength switches for this process; entry-layer callers pass them as `DecayOptions.ablation`. */
+export declare function strengthAblation(): StrengthAblation;
 export declare function isDecayAblated(): boolean;
 export declare function isRecallBoostAblated(): boolean;
 export declare function isOutcomeSlowAblated(): boolean;
@@ -91,11 +18,7 @@ export declare function isOutcomeFastAblated(): boolean;
 export declare function isRecencyAblated(): boolean;
 /** HIPPO_EVAL_RECENCY_DAYS when it is a positive number, else null (callers keep their default). */
 export declare function evalRecencyScaleDays(): number | null;
-/**
- * The default `now` for lifecycle computations: HIPPO_FAKE_NOW when set and
- * parseable, else the real clock. Callers that already take an explicit `now`
- * parameter are unaffected (explicit always wins).
- */
+/** The default `now` for lifecycle computations: HIPPO_FAKE_NOW when set and parseable, else the real clock; an explicit `now` parameter always wins. */
 export declare function evalNow(): Date;
 /** Test-only. See module JSDoc: call in BOTH beforeEach AND afterEach. */
 export declare function _resetAblationCacheForTests(): void;

package/dist/core/ablation.js

@@ -1,91 +1,11 @@
-/**
- * EVAL-ONLY lifecycle ablation switches.
- *
- * These env flags exist for controlled experiments on hippo's memory-lifecycle
- * mechanisms (the "lifecycle, ablated" paper protocol): each switch neutralizes
- * exactly ONE mechanism so its causal contribution can be measured in isolation.
- *
- * They are NOT a production configuration surface:
- *   - no config-file equivalents, deliberately (config implies support);
- *   - undocumented in user-facing help;
- *   - semantics may change with the experiment design.
- * Production behavior with all flags unset is byte-identical to before this
- * module existed.
- *
- * Flags (set to '1' or 'true'):
- *   HIPPO_ABLATE_DECAY         time-decay term := 1 in calculateStrength.
- *   HIPPO_ABLATE_RECALL_BOOST  full recall-strengthening ablation:
- *                              - markRetrieved returns entries UNMUTATED (no
- *                                clock reset / count / half-life increment);
- *                                ids stay available so `hippo outcome`
- *                                attribution keeps working in this arm;
- *                              - persisting callers (CLI recall, api context,
- *                                MCP recall/context, consolidation replay)
- *                                skip their writeEntry loops (identical-row
- *                                writes still refresh updated_at / mirrors /
- *                                DAG dirty flags);
- *                              - the retrieval-count READ boost := 1;
- *                              - decay anchors at `created` instead of
- *                                `last_retrieved` (prior-run clock resets
- *                                cannot leak in);
- *                              - physics: computeMass ignores the count, and
- *                                physicsSearch recomputes loaded masses LIVE
- *                                under ablated strength rules (persisted
- *                                masses embed recall history in their frozen
- *                                strength component);
- *                              - replay rehearsal is silenced entirely (it IS
- *                                strengthening; use config replay.count=0 to
- *                                separate replay in unflagged arms).
- *                              CAVEAT: half_life increments persisted by
- *                              prior unflagged runs are NOT reconstructed
- *                              (consolidation legitimately writes half_life
- *                              too) - ablation arms run on FRESH stores, as
- *                              the experiment protocol mandates.
- *   HIPPO_ABLATE_OUTCOME       both outcome channels := neutral
- *                              (= _SLOW + _FAST together). The slow side also
- *                              silences replay's outcome reward bias
- *                              (replayPriority). NOT gated: the opt-in
- *                              `recall --value-aware` rerank (an explicit CLI
- *                              flag that also reads outcome counts) - ablated
- *                              arms must not pass it.
- *   HIPPO_ABLATE_OUTCOME_SLOW  rewardFactor := 1 (no half-life modulation).
- *   HIPPO_ABLATE_OUTCOME_FAST  hybridSearch outcomeBoost := 1.
- *   HIPPO_ABLATE_RECENCY       search recency factor := 1 (the creation-age
- *                              multiplier 0.8 + 0.2*exp(-age/30d)); decay,
- *                              strengthening and outcomes stay live.
- *   HIPPO_EVAL_RECENCY_DAYS    a positive number replaces the 30-day scale of
- *                              that recency factor (tuning grids only). Unset,
- *                              zero, negative or junk values keep 30.
- *   HIPPO_FAKE_NOW            timestamp injected as the default `now` for
- *                              strength computation and retrieval stamping
- *                              (simulated-time protocols). MUST be the exact
- *                              Date.toISOString() form
- *                              (YYYY-MM-DDTHH:mm:ss.sssZ); validated by
- *                              round-trip, so junk, locale dates, non-UTC
- *                              offsets, and rolled-over dates (2026-02-31)
- *                              all fall back to the real clock.
- *
- * Formula notes (load-bearing for the experiments) - ablating decay has TWO
- * intrinsic co-effects, because the unified formula routes other mechanisms
- * THROUGH the decay term. Both are real properties of the architecture, not
- * implementation accidents; experiment analysis must attribute accordingly
- * (the decay-off arm is "decay + its dependents off", see prereg amendment A1):
- *   1. Read-side strengthening flattens: raw = retrievalBoost * emotionalMult
- *      >= 1, and the [0,1] clamp caps it at 1.0 - the recall boost can only
- *      offset decay, never exceed baseline. (Write-side still runs.)
- *   2. Outcome-slow goes inert: rewardFactor only acts by scaling the
- *      effective half-life INSIDE the decay exponent; with decay := 1 there
- *      is no exponent for it to modulate. Outcome-slow is decay-rate
- *      modulation BY DESIGN, so "no decay" necessarily means "no slow
- *      channel" (the fast channel in hybridSearch is unaffected).
- *
- * Env caching follows the house pattern (see getLossAversionRatio in
- * memory.ts): read once per process, with a test-only reset helper. Tests
- * that mutate these env vars MUST call _resetAblationCacheForTests() in BOTH
- * beforeEach AND afterEach.
- */
+/** EVAL-ONLY ablation switches (HIPPO_ABLATE_*, HIPPO_EVAL_RECENCY_DAYS, HIPPO_FAKE_NOW): each cuts ONE mechanism (outcome also replayPriority bias).
+ * 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;
@@ -101,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;
 }
@@ -120,11 +48,7 @@ export function isRecencyAblated() {
 export function evalRecencyScaleDays() {
     return readFlags().recencyDays;
 }
-/**
- * The default `now` for lifecycle computations: HIPPO_FAKE_NOW when set and
- * parseable, else the real clock. Callers that already take an explicit `now`
- * parameter are unaffected (explicit always wins).
- */
+/** The default `now` for lifecycle computations: HIPPO_FAKE_NOW when set and parseable, else the real clock; an explicit `now` parameter always wins. */
 export function evalNow() {
     const ms = readFlags().fakeNowMs;
     return ms === null ? new Date() : new Date(ms);
@@ -132,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/core/active-scope.d.ts

@@ -0,0 +1,7 @@
+/** Detect the current operational scope from env (HIPPO_SCOPE > GSTACK_SKILL > OPENCLAW_SKILL); returns the name without prefix, or null.
+ *  Pure env reads, no I/O, so it is safe on hot paths such as the UserPromptSubmit hook. */
+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=active-scope.d.ts.map

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

@@ -1,11 +1,6 @@
 import { envGstackSkill, envOpenclawSkill, envScope } from '../util/env.js';
-/**
- * Detect the current operational scope from environment signals.
- * Returns a scope name string (no prefix), or null if no scope detected.
- * Priority: HIPPO_SCOPE > GSTACK_SKILL > OPENCLAW_SKILL.
- *
- * Pure env var reads: no I/O, safe to call from hot paths (e.g. UserPromptSubmit hook).
- */
+/** Detect the current operational scope from env (HIPPO_SCOPE > GSTACK_SKILL > OPENCLAW_SKILL); returns the name without prefix, or null.
+ *  Pure env reads, no I/O, so it is safe on hot paths such as the UserPromptSubmit hook. */
 export function detectScope() {
     const explicit = envScope();
     if (explicit && explicit.trim())
@@ -18,10 +13,8 @@ export function detectScope() {
         return openclawSkill.trim();
     return 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).
- */
+/** 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 function scopeMatch(memoryTags, activeScope) {
     const scopeTags = memoryTags.filter(t => t.startsWith('scope:'));
     if (scopeTags.length === 0)
@@ -33,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

@@ -1,11 +1,4 @@
-/**
- * Ambient state vector — a compact representation of the agent's memory
- * landscape, computed in O(N) from the current corpus.
- *
- * Inspired by the biological ambient neural state: a continuous background
- * representation that tells the agent "where it is" in knowledge-space
- * without retrieving specific memories.
- */
+/** 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 type { MemoryEntry } from './memory.js';
 export interface AmbientState {
     tagEntropy: number;
@@ -20,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;