@gamaze/hicortex 0.22.0 → 0.22.2

package/dist/calibration.js

@@ -24,7 +24,8 @@
  * the removal is never silent.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIAGNOSTIC_ENV_TIER = exports.OLLAMA_FLUSH_WAIT_MS = exports.OLLAMA_FLUSH_EVERY = exports.NUM_CTX = exports.DEFAULT_FIRST_RUN_LOOKBACK_DAYS = exports.ENRICH_STRENGTH_DELTA = exports.STAGE_TRUTH_STRENGTH = exports.STAGE_BELIEF_STRENGTH = exports.STAGE_FADING_STRENGTH = exports.STAGE_FADING_DAYS = exports.WEAK_PRIMARY_FLOOR = exports.CORRECTION_REWRITE_MIN_CONFIDENCE = exports.CORRECTION_MIN_SIMILARITY = exports.SUPERSESSION_MIN_SIMILARITY = exports.DEDUP_AUTO_MERGE_THRESHOLD = exports.IMPORTANCE_CEILING = exports.BM25_WEIGHT_DOMAIN = exports.BM25_WEIGHT_PROJECT = exports.BM25_WEIGHT_BODY = exports.BOTH_CHANNEL_BOOST = exports.RRF_VECTOR_WEIGHT = exports.RRF_FTS_WEIGHT = exports.RRF_COMPOSITE_WEIGHT = exports.RRF_K = exports.DOMAIN_AFFINITY_WEIGHT = exports.PROJECT_AFFINITY_WEIGHT = exports.SUPERSEDED_DEMOTION = exports.FRESHNESS_BOOST_WEIGHT = exports.FRESHNESS_BOOST_DAYS = exports.SCORE_RECENCY_WEIGHT = exports.SCORE_CONNECTIONS_WEIGHT = exports.SCORE_STRENGTH_WEIGHT = exports.SCORE_SIMILARITY_WEIGHT = exports.RECALL_USES_AXIS_MAX = exports.RECALL_USES_NORMAL_MAX = exports.RECALL_USES_LOW_MAX = exports.RECALL_RESHOW_TURNS = exports.NOVELTY_FLOOR_SLOTS = exports.RECALL_TITLE_CHARS = exports.RECALL_MIN_PROMPT_CHARS = exports.RECALL_MAX_ITEMS = exports.RECALL_MIN_SIMILARITY = exports.SESSION_INTENT_WEIGHT = exports.COLD_EXPOSURE_SLOTS = exports.RECENT_WINDOW_DAYS = exports.RECENT_LIMIT = exports.SEARCH_LIMIT = exports.PROMOTION_STRENGTH_FLOOR = exports.PROMOTION_RATE = exports.DECAY_HALF_LIFE_DAYS = void 0;
+exports.STAGE_TRUTH_STRENGTH = exports.STAGE_BELIEF_STRENGTH = exports.STAGE_FADING_STRENGTH = exports.STAGE_FADING_DAYS = exports.WEAK_PRIMARY_FLOOR = exports.CORRECTION_REWRITE_MIN_CONFIDENCE = exports.CORRECTION_MIN_SIMILARITY = exports.SUPERSESSION_MIN_SIMILARITY = exports.DEDUP_AUTO_MERGE_THRESHOLD = exports.IMPORTANCE_SETTLE_WINDOW_DAYS = exports.IMPORTANCE_CEILING = exports.BM25_WEIGHT_DOMAIN = exports.BM25_WEIGHT_PROJECT = exports.BM25_WEIGHT_BODY = exports.BOTH_CHANNEL_BOOST = exports.RRF_VECTOR_WEIGHT = exports.RRF_FTS_WEIGHT = exports.RRF_COMPOSITE_WEIGHT = exports.RRF_K = exports.SCOPE_AFFINITY_WEIGHT = exports.SUPERSEDED_DEMOTION = exports.RECENCY_HEAD_DAYS = exports.RECENCY_HEAD_WEIGHT = exports.RECENCY_HOURLY_DECAY = exports.SCORE_RECENCY_WEIGHT = exports.CONNECTIONS_SATURATION_DEGREE = exports.SCORE_CONNECTIONS_WEIGHT = exports.SCORE_STRENGTH_WEIGHT = exports.SCORE_SIMILARITY_WEIGHT = exports.MEMORY_PRECISION_PROMPT_EXCERPT_CHARS = exports.MEMORY_PRECISION_DIVERGENCE_MIN_SHOWN = exports.MEMORY_PRECISION_REDUNDANT_ABOVE = exports.MEMORY_PRECISION_WINDOW_DAYS = exports.RECALL_USES_AXIS_MAX = exports.RECALL_USES_NORMAL_MAX = exports.RECALL_USES_LOW_MAX = exports.RECALL_RESHOW_TURNS = exports.NOVELTY_FLOOR_SLOTS = exports.RECALL_TITLE_CHARS = exports.RECALL_MIN_PROMPT_CHARS = exports.RECALL_MAX_ITEMS = exports.RECALL_MIN_SIMILARITY = exports.SESSION_INTENT_WEIGHT = exports.COLD_EXPOSURE_SLOTS = exports.RECENT_WINDOW_DAYS = exports.RECENT_LIMIT = exports.SEARCH_LIMIT = exports.PROMOTION_STRENGTH_FLOOR = exports.PROMOTION_RATE = exports.DECAY_HALF_LIFE_DAYS = void 0;
+exports.DIAGNOSTIC_ENV_TIER = exports.OLLAMA_FLUSH_WAIT_MS = exports.OLLAMA_FLUSH_EVERY = exports.NUM_CTX = exports.DEFAULT_FIRST_RUN_LOOKBACK_DAYS = exports.ENRICH_STRENGTH_DELTA = void 0;
 exports.resolveNumCtx = resolveNumCtx;
 exports.resolveOllamaFlushEvery = resolveOllamaFlushEvery;
 exports.resolveOllamaFlushWaitMs = resolveOllamaFlushWaitMs;
@@ -126,9 +127,48 @@ exports.RECALL_USES_NORMAL_MAX = 0.25;
  *  PROVISIONAL (owner anchor 2026-09-13, #426) — chosen so Overfetching
  *  keeps a visible span, not a measured bound. */
 exports.RECALL_USES_AXIS_MAX = 0.30;
+// Memory-precision family (#476) — the console card's deterministic proxies.
+// All four are release-managed per this module's evolution contract: no config
+// keys, nothing hardcoded elsewhere. Values are stored THRESHOLD-FREE (raw
+// cosines in recall_events); the thresholds below are applied at RENDER time
+// only, so recalibrating them never rewrites history.
+/**
+ * Retention horizon for the recall_pushes/recall_events sidecar tables AND the
+ * longest window the Memory Precision card shows — ONE constant feeds both
+ * (the CAPTURE_HEALTH_WINDOW_DAYS single-constant law: the card can never
+ * claim a window the store no longer has rows for). 90 = the longest #452
+ * range option that the retention can honestly serve; 180d and all clamp to
+ * it server-side and the payload echoes the effective window_days.
+ */
+exports.MEMORY_PRECISION_WINDOW_DAYS = 90;
+/**
+ * Cosine at/above which a pushed line reads "redundant" (restating the
+ * session's standing context — the top lessons + identity every session-start
+ * hook injects). Direction-only display guidance, never a gate. 0.80 mirrors
+ * SUPERSESSION_MIN_SIMILARITY: at/above it a pair reads as the same
+ * statement, below it as topical overlap — a reasonable first anchor until
+ * the judged-calibration follow-up measures the real distribution (the
+ * #426 provisional-anchor posture).
+ */
+exports.MEMORY_PRECISION_REDUNDANT_ABOVE = 0.8;
+/**
+ * Window showings a live memory needs (with zero window fetches) to count as
+ * DIVERGING — the index keeps pushing it, nothing ever reads it. 5 is the
+ * spec's anchor (#476): enough showings that the silence is a pattern, not
+ * one prompt's turn-suppression.
+ */
+exports.MEMORY_PRECISION_DIVERGENCE_MIN_SHOWN = 5;
+/**
+ * Cap on the prompt excerpt persisted per recall_pushes row (Option A,
+ * owner-blessed 2026-09-19: the first-ever server-side persistence of raw
+ * prompt text, bounded to 256 chars and pruned at the retention horizon —
+ * the same trust boundary as /distill's denoised conversation text).
+ */
+exports.MEMORY_PRECISION_PROMPT_EXCERPT_CHARS = 256;
 // ---------------------------------------------------------------------------
-// Composite ranking weights (was: score*Weight, freshnessBoost*,
-// supersededDemotion, *AffinityWeight, rrf*)
+// Composite ranking weights (was: score*Weight, supersededDemotion,
+// *AffinityWeight, rrf*; the pre-#430 freshness bonus constants merged into
+// the RECENCY family below)
 // ---------------------------------------------------------------------------
 /** Semantic-similarity share of the composite score. 0.50 (raised from 0.40
  *  in the 0.15.2 rebalance, #191 Phase B): on the production corpus effective
@@ -140,23 +180,58 @@ exports.SCORE_SIMILARITY_WEIGHT = 0.50;
 exports.SCORE_STRENGTH_WEIGHT = 0.20;
 /** Graph-centrality share of the composite score (was 0.20; see above). */
 exports.SCORE_CONNECTIONS_WEIGHT = 0.15;
-/** Slow recency curve share of the composite score (was 0.10; see above). */
+/**
+ * Log-saturation degree K for the connections term (#449 PR E, items 1+3):
+ * the credit is min(1, log1p(k) / log1p(K)) × SCORE_CONNECTIONS_WEIGHT on
+ * the ABSOLUTE undirected-degree scale k — full at k = K, exactly +0 at
+ * k = 0 (unlinked rows score bit-identically to the linear term they
+ * replace). Provenance: p99 of the REAL undirected degree distribution
+ * (read-only audit 2026-09-17 of the canonical wave snapshot, 18,798
+ * memories / 14,600 linked: p50 = 4, p90 = 8, p95 = 9, p99 = 15, p99.9 =
+ * 28.4, max = 40; 135 memories ≥ 16 links = 0.92% of linked) — so the top
+ * ~1% of hubs tie at full credit and everything below differentiates
+ * modestly. Shape grounded in the #449 research base: ACT-R fan saturation
+ * (Anderson & Reder 1999 — activation falls with the LOG of fan), SAM's
+ * saturating returns, cue overload (Watkins & Watkins 1975). Replaces the
+ * candidate-set-relative normalization #449 deleted (k / the per-query max
+ * degree) — a row's score no longer depends on which other rows happened
+ * to match. Alternatives K = 8 (p90 — collapses all p90+ rows to
+ * full credit) and K = 32 (≈p99.9 — leaves the p99 hub at 0.12 of the
+ * term) were tabled in the #449 spec. RELEASE-MANAGED per this module's
+ * evolution contract — overridable only through the configureScoring seam.
+ */
+exports.CONNECTIONS_SATURATION_DEGREE = 16;
+/** Time-curve share of the composite score — the merged curve's blend weight
+ *  AND slow-region amplitude (was 0.10; see above). The four blend weights
+ *  still sum to 1.0; the head amplitude below is a documented overshoot, NOT
+ *  a fifth blend weight (#430). Zero (via the seam) disables the whole term. */
 exports.SCORE_RECENCY_WEIGHT = 0.15;
-/** Fresh-memory window: the additive bonus fades linearly to 0 over this
- *  many days. 7 — nightly capture means 1 day is the floor of "fresh"
- *  (#191 Phase B). */
-exports.FRESHNESS_BOOST_DAYS = 7;
-/** Fresh-memory bonus size at age 0 (#191 Phase B; 0 = disabled via seam). */
-exports.FRESHNESS_BOOST_WEIGHT = 0.15;
+/** Hourly decay of the merged curve's slow region (#430) — promoted from the
+ *  inline literal computeScore carried; half-life ≈ 57.7 days. At and beyond
+ *  RECENCY_HEAD_DAYS the curve is bit-identical to the pre-#430 slow term
+ *  (SCORE_RECENCY_WEIGHT × RECENCY_HOURLY_DECAY^hours). */
+exports.RECENCY_HOURLY_DECAY = 0.9995;
+/** Merged time-curve head amplitude at age 0 (#430) — the pre-#430 slow
+ *  weight 0.15 + fresh bonus 0.15: the freshness job is now the early steep
+ *  part of ONE curve. The head joins value-continuously onto the slow region
+ *  at RECENCY_HEAD_DAYS; its rate is DERIVED from that continuity, never a
+ *  free constant. */
+exports.RECENCY_HEAD_WEIGHT = 0.30;
+/** Join age in days of the merged time curve (#430) — the head window edge,
+ *  carried over from the pre-#430 freshness window. Nightly capture means
+ *  1 day is the floor of "fresh" (#191 Phase B). */
+exports.RECENCY_HEAD_DAYS = 7;
 /** Score multiplier for a memory a later decision superseded (0.15.2; the
  *  belief walk (#393 D) is the primary mechanism — this is the safety net
  *  for rows the walk does not reach). */
 exports.SUPERSEDED_DEMOTION = 0.50;
-/** #203 soft boost on exact project match. ADDITIVE, zero-boost neutral,
- *  never a penalty — a foreign memory ranks equal, not lower. */
-exports.PROJECT_AFFINITY_WEIGHT = 0.15;
-/** #203 soft boost multiplier on max overlapping domain-tag weight. */
-exports.DOMAIN_AFFINITY_WEIGHT = 0.15;
+/** #430 merged scope affinity — ONE term replacing #203's two boosts (the
+ *  project-affinity and domain-affinity constants) at their shared value.
+ *  Boost = max(project-match indicator (1 on exact match), max overlapping
+ *  domain-tag weight) × this weight: the strongest single scope signal counts
+ *  once, never stacked. ADDITIVE, zero-boost neutral, never a penalty — an
+ *  absent scope adds exactly 0; a foreign memory ranks equal, not lower. */
+exports.SCOPE_AFFINITY_WEIGHT = 0.15;
 /** #205 RRF k parameter (1/(k+rank+1)) — matches the pre-#205 hardcoded 60
  *  so the no-config path was byte-identical to 0.15.3. */
 exports.RRF_K = 60;
@@ -223,6 +298,18 @@ exports.BM25_WEIGHT_DOMAIN = 2.0;
  * base-1.0 rows decay again.
  */
 exports.IMPORTANCE_CEILING = 0.95;
+/**
+ * How many days a memory stays in the nightly importance-settle pool after
+ * ingest (#478): a row's importance re-settles nightly while young — keyed
+ * on PER-ROW age (ingested_at), never the global lastConsolidated
+ * watermark, which sticks whenever a run defers and used to drag a growing
+ * cohort back through re-scoring (each re-settle overwrites base_strength,
+ * erasing promotion gains). Rows leave the pool after the window; promoted
+ * or enriched rows leave earlier via the paid-gain guard. Release-managed
+ * (#408 discipline): moving it is a release decision with soak evidence,
+ * not a config knob.
+ */
+exports.IMPORTANCE_SETTLE_WINDOW_DAYS = 3;
 /** Deterministic merge ceiling of the unified resolution pass (#392): pairs
  *  at/above this cosine merge LLM-free; [CORRECTION_MIN_SIMILARITY, this)
  *  get the one verdict call. 0.92 — measured on the #191 mechanical audit

package/dist/classify-domains.js

@@ -175,10 +175,15 @@ async function runClassifyDomains(options = {}) {
         // everything from the final tag sets.
         const { prototypes } = await (0, schema_prototypes_js_1.computeDomainPrototypes)(db, domains, getEmbedFn);
         // Scope filter: default = NULL / not-in-set / no tags yet; --all = everything.
+        // #477: absorbed dedup losers are excluded from the default scope (dead
+        // evidence — the merge already cleared their tags and nulled domain);
+        // conjoined OUTSIDE the parenthesized OR group, same as the nightly
+        // stageContentDomains twin. --all stays a wholesale operator re-judge.
         const placeholders = domains.map(() => "?").join(", ");
         const scopeSql = all
             ? "rowid > ?"
-            : `rowid > ? AND (domain IS NULL OR domain NOT IN (${placeholders}) ` +
+            : `rowid > ? AND COALESCE(status, '') != 'absorbed' ` +
+                `AND (domain IS NULL OR domain NOT IN (${placeholders}) ` +
                 `OR id NOT IN (SELECT DISTINCT memory_id FROM memory_tags))`;
         const batchStmt = db.prepare(`SELECT rowid AS __rowid, id, content, project, domain FROM memories
        WHERE ${scopeSql} ORDER BY rowid ASC LIMIT ?`);

package/dist/consolidate.js

@@ -467,8 +467,13 @@ async function scoreMemoriesImportance(db, memories, llm, opts = {}) {
     }
     return { scored, failed, skipped_budget: skippedBudget };
 }
-async function stageImportance(db, memories, llm, budget, dryRun, deadline) {
-    return scoreMemoriesImportance(db, memories, llm, { budget, deadline, dryRun });
+async function stageImportance(db, memories, llm, budget, dryRun, deadline, 
+/** #478: pool candidates the paid-gain guard dropped at the stage
+ *  boundary — reported, not scored, so the run's evidence shows the
+ *  promotion/enrichment gains that survived the nightly. */
+guardSkipped = 0) {
+    const r = await scoreMemoriesImportance(db, memories, llm, { budget, deadline, dryRun });
+    return { ...r, guard_skipped: guardSkipped };
 }
 // ---------------------------------------------------------------------------
 // Stage 2.5: Reflection
@@ -639,12 +644,18 @@ async function stageContentDomains(db, domains, llm, budget, embedFn, dryRun, st
     //   - domain NOT IN the current vocabulary (a rename/removal re-files), OR
     //   - no memory_tags rows yet (single-domain memories from feat/content-domains
     //     that have a primary but no tag set — backfill them to multi-tag).
+    // #477: absorbed dedup losers are excluded — the merge clears their tags
+    // and nulls domain before absorbing, so without the predicate every dead
+    // loser re-enters this scope nightly (one classify call + a halving on
+    // evidence no recall can ever see). Conjoined OUTSIDE the parenthesized OR
+    // group so SQL precedence cannot let an OR arm absorb it.
     const placeholders = domains.map(() => "?").join(", ");
     const rows = db
         .prepare(`SELECT id, content, project FROM memories
-       WHERE domain IS NULL
-          OR domain NOT IN (${placeholders})
-          OR id NOT IN (SELECT DISTINCT memory_id FROM memory_tags)`)
+       WHERE COALESCE(status, '') != 'absorbed'
+         AND (domain IS NULL
+              OR domain NOT IN (${placeholders})
+              OR id NOT IN (SELECT DISTINCT memory_id FROM memory_tags))`)
         .all(...domains.map((d) => d.name));
     if (dryRun) {
         return { curated: false, domains: domains.length, classified: 0, reason: `dry_run (${rows.length} would classify)` };
@@ -1376,6 +1387,7 @@ function stagePromotion(db, dryRun) {
     const demoted = (0, retrieval_js_1.findDemotedIds)(db, rows.map((r) => r.id));
     let promoted = 0;
     let demotedSkipped = 0;
+    let totalGain = 0;
     const writes = [];
     for (const row of rows) {
         const accessCount = row.access_count ?? 0;
@@ -1389,18 +1401,25 @@ function stagePromotion(db, dryRun) {
         }
         // base_strength is NOT NULL after scoring; the `?? 0.5` mirrors
         // stageDecayPrune's defensive default for unscored rows (inserts at 0.5).
-        let strength = row.base_strength ?? 0.5;
+        const startStrength = row.base_strength ?? 0.5;
+        let strength = startStrength;
         for (let i = 0; i < row.delta; i++)
             strength = applyStrengthPromotion(strength);
+        totalGain += strength - startStrength;
         promoted++;
         writes.push({
             id: row.id,
             fields: { base_strength: strength, promotion_last_count: accessCount },
         });
     }
+    // #459: the stage's one-line summary in the shared stage idiom (rows
+    // examined / promoted / total gain, like the supersession summary) — the
+    // stage writes its report in-memory only, so the log line is the soak-time
+    // health signal. Zero examined rows stay silent (the supersession gate).
     if (dryRun) {
-        console.log(`[hicortex] Strength promotion (dry-run): would promote ${promoted} memories ` +
-            `(${demotedSkipped} demotion-set rows advance their baseline only).`);
+        console.log(`[hicortex] Strength promotion (dry-run): ${rows.length} examined, would promote ` +
+            `${promoted} (+${totalGain.toFixed(3)} total strength, ` +
+            `${demotedSkipped} demotion-set rows advance their baseline only).`);
         return { promoted, demoted_skipped: demotedSkipped };
     }
     // One transaction for the whole stage (the stageMemoryCapEviction pattern):
@@ -1411,8 +1430,9 @@ function stagePromotion(db, dryRun) {
             storage.updateMemory(db, w.id, w.fields);
     });
     tx();
-    console.log(`[hicortex] Strength promotion: promoted ${promoted} memories ` +
-        `(${demotedSkipped} demotion-set rows advance their baseline only).`);
+    console.log(`[hicortex] Strength promotion: ${rows.length} examined, promoted ${promoted} ` +
+        `(+${totalGain.toFixed(3)} total strength, ` +
+        `${demotedSkipped} demotion-set rows advance their baseline only).`);
     return { promoted, demoted_skipped: demotedSkipped };
 }
 // ---------------------------------------------------------------------------
@@ -1655,12 +1675,29 @@ deadline) {
     };
     // Stage 1: Pre-check
     const precheck = stagePrecheck(db, stateDir);
-    // Also check for unscored memories
+    // #478: the importance pool is ROW-AGE bound — young (ingested within
+    // IMPORTANCE_SETTLE_WINDOW_DAYS) ∪ never-scored. The lastConsolidated
+    // watermark no longer defines any part of it: a deferred run's stuck
+    // watermark used to re-settle a growing cohort nightly, and every
+    // re-settle overwrites base_strength outright (erasing gains
+    // stagePromotion had already paid — 5/5 observed erasures). The watermark
+    // cohort (precheck.newMemories) STILL feeds reflection + links below —
+    // their work is batch retry by design; only importance's per-row settling
+    // was mis-bound to the batch marker.
+    const settleCutoff = new Date(Date.now() - CALIBRATION.IMPORTANCE_SETTLE_WINDOW_DAYS * 86_400_000).toISOString();
+    // getMemoriesSince keys on ingested_at only — absorbed rows (invisible to
+    // recall) are filtered here in the same vocabulary getUnscoredMemories
+    // uses in SQL: no LLM call on dead evidence.
+    const young = storage
+        .getMemoriesSince(db, settleCutoff)
+        .filter((m) => m.status !== "absorbed");
+    const youngIds = new Set(young.map((m) => m.id));
+    // Also check for unscored memories (#425 watermark pool) — first settle is
+    // age-independent, so a row used before its first score is never stranded.
     const unscored = storage.getUnscoredMemories(db);
-    const newIds = new Set(precheck.newMemories.map((m) => m.id));
     const scoreMemories = [
-        ...precheck.newMemories,
-        ...unscored.filter((m) => !newIds.has(m.id)),
+        ...young,
+        ...unscored.filter((m) => !youngIds.has(m.id)),
     ];
     // #194 no-fit scope: untagged rows (domain IS NULL) stay in the
     // re-evaluation scope — the decay/re-attempt contract ("re-halves once per
@@ -1669,15 +1706,26 @@ deadline) {
     // never caught because stagePrecheck used to read the AMBIENT (always
     // empty in the suite) state instead of the run's own watermark — threading
     // stateDir (#357) exposed the divergence between test and production.
-    const nofitInScope = db.prepare("SELECT COUNT(*) AS n FROM memories WHERE domain IS NULL").get().n;
-    const skip = scoreMemories.length === 0 && nofitInScope === 0;
+    // #477: absorbed dedup losers (tags cleared, domain NULLed by the merge)
+    // are dead evidence — they must not keep the no-fit scope (and the run)
+    // alive every night. Same predicate spelling as getUnscoredMemories.
+    const nofitInScope = db
+        .prepare("SELECT COUNT(*) AS n FROM memories WHERE domain IS NULL AND COALESCE(status, '') != 'absorbed'")
+        .get().n;
+    // #478: the quiet-night gate is the UNION — watermark cohort OR young OR
+    // unscored OR no-fit scope. A stuck watermark alone must never silence
+    // reflection/links (their pool is the watermark cohort, and their retry
+    // semantics are the reason a deferred run holds the watermark at all).
+    const skip = scoreMemories.length === 0 &&
+        precheck.newMemories.length === 0 &&
+        nofitInScope === 0;
     report.stages.precheck = {
         skip,
         reason: skip
             ? precheck.reason
-            : `${precheck.newMemories.length} new + ${scoreMemories.length - precheck.newMemories.length} unscored memories`,
+            : `${precheck.newMemories.length} new (watermark) + ${young.length} young + ${scoreMemories.length - young.length} unscored memories`,
         new_memory_count: precheck.newMemories.length,
-        unscored_count: scoreMemories.length - precheck.newMemories.length,
+        unscored_count: unscored.length,
     };
     // Strength promotion (#448) — runs in the pre-skip deterministic zone, in
     // the same placement discipline as memory_cap BELOW it: accesses happen on
@@ -1715,7 +1763,27 @@ deadline) {
         // deferred. Deferred stages drain next run (cursors hold below them).
         // Stage 2: Importance Scoring
         if (!deadline?.hit("importance")) {
-            report.stages.importance = await stageImportance(db, scoreMemories, llm, budget, dryRun, deadline);
+            // #478 paid-gain guard — evaluated HERE, at the stage boundary, not at
+            // pool-build time: the pool above was built before this run's
+            // stagePromotion payment, so a row whose FIRST use lands this run
+            // passes a pool-build check and its just-paid gain is overwritten at
+            // the first re-settle. This read sits after promotion by construction
+            // and sees the advanced baseline. Already-scored rows carrying a paid
+            // gain (promotion baseline advanced OR owner corroboration) keep it —
+            // re-settling would stomp base_strength; `hicortex rescore-importance`
+            // remains the wholesale operator re-judge. Never-scored rows
+            // (importance_scored_at IS NULL) are NEVER skipped: first settle
+            // always happens, whatever their use history.
+            const paidGainIds = scoreMemories.length
+                ? new Set(db.prepare(`SELECT id FROM memories
+                WHERE importance_scored_at IS NOT NULL
+                  AND (COALESCE(promotion_last_count, 0) > 0
+                       OR COALESCE(corroboration_count, 0) > 0)
+                  AND id IN (${scoreMemories.map(() => "?").join(", ")})`).all(...scoreMemories.map((m) => m.id))
+                    .map((r) => r.id))
+                : new Set();
+            const settleCandidates = scoreMemories.filter((m) => !paidGainIds.has(m.id));
+            report.stages.importance = await stageImportance(db, settleCandidates, llm, budget, dryRun, deadline, scoreMemories.length - settleCandidates.length);
         }
         // Stage 2.5: Reflection
         if (deadline?.hit("reflection")) {

package/dist/dashboard.d.ts

@@ -23,6 +23,7 @@
 import type express from "express";
 import type Database from "better-sqlite3";
 import { type CaptureHealthRow } from "./capture-health.js";
+import { type MemoryPrecision } from "./recall-precision.js";
 import { type Stage } from "./stages.js";
 /** Corpus-shape snapshot. `adoption` is null in backfilled rows (point-in-time,
  *  can't be reconstructed from created_at). */
@@ -257,6 +258,16 @@ export interface DashboardData {
             last_outcome: string;
         }>;
     };
+    /**
+     * #476 — the Memory Precision card: Level 1 (pushed-index precision
+     * proxies over the recall_pushes/recall_events window) beside Level 2
+     * (recall depth = the uses-per-showing ratio over the SAME window, from
+     * snapshot deltas) + the divergence list. ALWAYS present; edges echoed
+     * like every threshold (the page never hardcodes), and the block measures
+     * ≤ 2 KB against the live 30-day payload. The page degrades to the
+     * pre-#476 recall-card rendering when the block is absent.
+     */
+    memory_precision: MemoryPrecision;
     digest: {
         date: string | null;
         run_at: string | null;

package/dist/dashboard.js

@@ -45,6 +45,7 @@ const recall_index_js_1 = require("./recall-index.js");
 const config_read_js_1 = require("./config-read.js");
 const consolidate_js_1 = require("./consolidate.js");
 const capture_health_js_1 = require("./capture-health.js");
+const recall_precision_js_1 = require("./recall-precision.js");
 const capture_pause_js_1 = require("./capture-pause.js");
 const state_js_1 = require("./state.js");
 const retrieval_js_1 = require("./retrieval.js");
@@ -576,6 +577,14 @@ function handleDashboardData(db, query, config) {
                 by_source_machine: live.by_source_machine,
             },
             capture_health: { ...(0, capture_health_js_1.readCaptureHealth)(db), ...(0, capture_health_js_1.readCaptureHealthWindow)(db) },
+            // #476 Memory Precision: the window aggregation over the precision
+            // event tables + snapshot deltas. Level 2's "latest" is the SAME live
+            // adoption this handler already computed (one definition of corpus
+            // shape — computeDashboardMetrics); readMemoryPrecision owns the rest.
+            memory_precision: (0, recall_precision_js_1.readMemoryPrecision)(db, rangeParam, {
+                shown_sum: live.adoption?.shown_sum ?? 0,
+                used_sum: live.adoption?.used_sum ?? 0,
+            }),
             // #423 phase 3: pauses + presence in one block — one source of truth
             // for the rail's dots, toggles and the capture card's PAUSED badges.
             fleet: {

package/dist/db.js

@@ -668,6 +668,80 @@ const MIGRATIONS = [
             db.exec("UPDATE memories SET promotion_last_count = access_count WHERE promotion_last_count IS NULL");
         },
     },
+    {
+        version: 21,
+        name: "memory_layout",
+        up: (db) => {
+            // #464 — the console field's server-computed placement. One row per
+            // placed memory at one epoch; the CURRENT epoch is MAX(epoch) and the
+            // payload (dashboard.ts handleDashboardField) LEFT JOINs on it. A full
+            // re-projection (`hicortex layout --reproject`) writes a NEW epoch and
+            // drops older ones in the SAME transaction (atomic swap — a mid-write
+            // failure leaves the previous epoch fully intact). Epochs exist so the
+            // whole store moves at once (one announced visual shift), never as a
+            // mix of projections. Idempotent: IF NOT EXISTS (the v18 pattern —
+            // plain CREATE, no ALTER).
+            // Kept after the #464/#475 field revert (#474): nothing reads or writes
+            // this table now — a dormant orphan. Rc databases already applied v21
+            // (user_version 21), so removing it would fork schema versions; it
+            // stays per the append-only migration discipline.
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_layout (
+            memory_id TEXT PRIMARY KEY,
+            x REAL NOT NULL,
+            y REAL NOT NULL,
+            epoch INTEGER NOT NULL
+        )
+      `);
+            db.exec("CREATE INDEX IF NOT EXISTS idx_memory_layout_epoch ON memory_layout(epoch)");
+        },
+    },
+    {
+        version: 22,
+        name: "recall_precision_events",
+        up: (db) => {
+            // #476 — the Memory Precision card's event store (Option A, owner
+            // decision 2026-09-19: per-push event rows incl. a ≤256-char prompt
+            // excerpt — the exact-window Level-1 measures + the judge follow-up's
+            // sample frame). Two sidecar tables, the v16 distill_activity pattern:
+            // OPERATIONS telemetry, no memories FK — recall_events.memory_id is
+            // DATA (absorbed memories' history stays queryable; rows outliving
+            // their memory are valid). recall_pushes: one row per NON-skipped
+            // /recall-index call (short-prompt skips and resets record nothing; a
+            // silent turn records its push row with zero events — the silence rate
+            // is computable). recall_events: one kind='shown' row per pushed line
+            // (similarity = cosine vs the PURE prompt embedding, redundancy = max
+            // cosine vs the standing-context basis — both RAW, verdicts computed at
+            // render so recalibration never rewrites history) + one kind='fetch'
+            // row per handleMemoryGet (push_id NULL). Pruned nightly at the
+            // retention horizon (= the longest window, the capture-health
+            // single-constant law). Idempotent: IF NOT EXISTS everywhere.
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS recall_pushes (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts TEXT NOT NULL,
+          day TEXT NOT NULL,
+          session_id TEXT,
+          prompt_excerpt TEXT
+        )
+      `);
+            db.exec("CREATE INDEX IF NOT EXISTS idx_recall_pushes_day ON recall_pushes(day)");
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS recall_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts TEXT NOT NULL,
+          day TEXT NOT NULL,
+          push_id INTEGER,
+          memory_id TEXT NOT NULL,
+          similarity REAL,
+          redundancy REAL,
+          kind TEXT NOT NULL
+        )
+      `);
+            db.exec("CREATE INDEX IF NOT EXISTS idx_recall_events_day ON recall_events(day)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_recall_events_memory_kind ON recall_events(memory_id, kind)");
+        },
+    },
 ];
 /**
  * Run all pending migrations against the database.

package/dist/eval/decay-eval.d.ts

@@ -70,8 +70,10 @@ export interface StructuralStrengthStats {
  * "if nothing changes" projection), plus the asymptotic floor per memory.
  * Requires `configureDecay` to already reflect the desired half-life (call
  * `runPruneDryRun` first, or `configureDecay` directly, in the same process).
+ * `now` (#458): the instant "now" means — pinned by run-eval's --now for
+ * wall-clock-independent before/after audits; default the live clock.
  */
-export declare function runStructuralStrengthStats(db: Database.Database): StructuralStrengthStats;
+export declare function runStructuralStrengthStats(db: Database.Database, now?: Date): StructuralStrengthStats;
 export interface AdoptionStats {
     totalMemories: number;
     shownCountHistogram: Record<string, number>;
@@ -106,4 +108,4 @@ export interface AdoptionStats {
  * feature's youth as much as its effectiveness. Report callers should state
  * that caveat alongside the numbers, not just the numbers.
  */
-export declare function runAdoptionStats(db: Database.Database): AdoptionStats;
+export declare function runAdoptionStats(db: Database.Database, now?: Date): AdoptionStats;

package/dist/eval/decay-eval.js

@@ -97,12 +97,13 @@ function histogram(values, edges = STRENGTH_BUCKET_EDGES) {
  * "if nothing changes" projection), plus the asymptotic floor per memory.
  * Requires `configureDecay` to already reflect the desired half-life (call
  * `runPruneDryRun` first, or `configureDecay` directly, in the same process).
+ * `now` (#458): the instant "now" means — pinned by run-eval's --now for
+ * wall-clock-independent before/after audits; default the live clock.
  */
-function runStructuralStrengthStats(db) {
+function runStructuralStrengthStats(db, now = new Date()) {
     const rows = db
         .prepare("SELECT id, base_strength, last_accessed FROM memories")
         .all();
-    const now = new Date();
     const nowVals = [];
     const at180 = [];
     const at365 = [];
@@ -147,11 +148,10 @@ function ageBucketLabel(ageDays) {
  * feature's youth as much as its effectiveness. Report callers should state
  * that caveat alongside the numbers, not just the numbers.
  */
-function runAdoptionStats(db) {
+function runAdoptionStats(db, now = new Date()) {
     const rows = db
         .prepare("SELECT id, shown_count, access_count, source_agent, created_at FROM memories")
         .all();
-    const now = new Date();
     const shownVals = [];
     const accessVals = [];
     let totalShown = 0;

package/dist/eval/eval-clock.d.ts

@@ -0,0 +1,32 @@
+/**
+ * #458 — the shared pinned-clock helper for eval harnesses.
+ *
+ * The recall evals score against wall-clock time (recency + decay terms in
+ * computeScore/effectiveStrength), so a pre-photo and a post-run hours apart
+ * drift even on identical code — PR D evidenced mode-OFF units moving with no
+ * changed code in the path. The fix is a harness-visible pin: every eval that
+ * calls retrieve() (or the decay/adoption stats) accepts a `--now <ISO>` flag
+ * and threads the SAME instant into the retrieve() `now` seam (retrieval.ts —
+ * the injectable-clock idiom of run-deadline.ts), making before/after runs
+ * wall-clock-independent. Default stays the live clock — pinning is opt-in,
+ * for comparability.
+ *
+ * Fail-explicit by design (the repo convention): an invalid pin THROWS with a
+ * clear message rather than silently falling back to the live clock — a run
+ * that believed it was pinned but wasn't would silently reintroduce the drift
+ * class this helper exists to remove.
+ */
+/**
+ * Parse a `--now` flag value into the pinned instant.
+ *
+ * @param raw the raw flag value. undefined or empty/whitespace → null (the
+ *        live clock — the flag was not passed). Anything else must parse as a
+ *        Date; garbage or an invalid instant (e.g. month 13) throws.
+ * @returns the pinned Date, or null for the live clock.
+ */
+export declare function parsePinnedNow(raw: string | undefined): Date | null;
+/**
+ * Human-readable clock mode for report headers / photo JSON: "pinned <ISO>"
+ * or "live" — so artifacts are self-describing about which clock produced them.
+ */
+export declare function clockLabel(now: Date | null): string;

package/dist/eval/eval-clock.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * #458 — the shared pinned-clock helper for eval harnesses.
+ *
+ * The recall evals score against wall-clock time (recency + decay terms in
+ * computeScore/effectiveStrength), so a pre-photo and a post-run hours apart
+ * drift even on identical code — PR D evidenced mode-OFF units moving with no
+ * changed code in the path. The fix is a harness-visible pin: every eval that
+ * calls retrieve() (or the decay/adoption stats) accepts a `--now <ISO>` flag
+ * and threads the SAME instant into the retrieve() `now` seam (retrieval.ts —
+ * the injectable-clock idiom of run-deadline.ts), making before/after runs
+ * wall-clock-independent. Default stays the live clock — pinning is opt-in,
+ * for comparability.
+ *
+ * Fail-explicit by design (the repo convention): an invalid pin THROWS with a
+ * clear message rather than silently falling back to the live clock — a run
+ * that believed it was pinned but wasn't would silently reintroduce the drift
+ * class this helper exists to remove.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePinnedNow = parsePinnedNow;
+exports.clockLabel = clockLabel;
+/**
+ * Parse a `--now` flag value into the pinned instant.
+ *
+ * @param raw the raw flag value. undefined or empty/whitespace → null (the
+ *        live clock — the flag was not passed). Anything else must parse as a
+ *        Date; garbage or an invalid instant (e.g. month 13) throws.
+ * @returns the pinned Date, or null for the live clock.
+ */
+function parsePinnedNow(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return null;
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`eval clock: invalid --now value "${raw}" — pass a full ISO 8601 instant ` +
+            `(e.g. 2026-09-17T09:00:00.000Z) or omit the flag to run on the live clock`);
+    }
+    return parsed;
+}
+/**
+ * Human-readable clock mode for report headers / photo JSON: "pinned <ISO>"
+ * or "live" — so artifacts are self-describing about which clock produced them.
+ */
+function clockLabel(now) {
+    return now === null ? "live" : `pinned ${now.toISOString()}`;
+}