@gamaze/hicortex 0.21.0 → 0.22.1

package/dist/mcp-server.js

@@ -787,7 +787,8 @@ async function startServer(options = {}) {
         `/novelty=${CALIBRATION.NOVELTY_FLOOR_SLOTS}` +
         ` · ` +
         `score sim=${scoringCfg.similarity}/str=${scoringCfg.strength}/conn=${scoringCfg.connections}` +
-        `/rec=${scoringCfg.recency}, fresh=${scoringCfg.freshnessBoostWeight}@${scoringCfg.freshnessBoostDays}d, ` +
+        `/K=${scoringCfg.connectionsSaturation}` +
+        `/rec=${scoringCfg.recency}, head=${scoringCfg.recencyHead}@${scoringCfg.recencyHeadDays}d, ` +
         `superseded×${scoringCfg.supersededDemotion}` +
         `, intent w=${sessionIntentCfg.weight}` +
         (sessionIntentCfg.weight === 0 ? " (disabled)" : ""));
@@ -1548,7 +1549,7 @@ async function startServer(options = {}) {
     //
     // An enrich is EVIDENCE ABOUT IMPORTANCE: it bumps corroboration_count and
     // base_strength (+the calibration delta, capped at 1.0) — the same anchor
-    // the nightly's LLM scoring and hub-boost write. It must NOT touch
+    // the nightly's LLM scoring writes. It must NOT touch
     // access_count (reserved for real recall use) or shown_count (index
     // exposure) — faking either corrupts the uses-per-showing adoption metric.
     // Never a stage write: stages are derived presentation (the E-reframe).

package/dist/nofit.d.ts

@@ -38,7 +38,8 @@
  *     memory from pruning. Halving does not touch last_accessed/access_count.
  *   - Re-classification: a later run whose LLM tags it, or whose evolved
  *     prototypes clear the floor, gives it a (weak) primary — halving stops.
- *     Its strength is NOT restored; only access does that job.
+ *     Its strength is restored only by the nightly promotion stage (#448),
+ *     which converts each new access_count delta into a base_strength bump.
  *
  * PRUNE INTERACTION (verified against stageDecayPrune + effectiveStrength):
  * prune fires when effectiveStrength < 0.01 for a >90-day-old, never-accessed

package/dist/nofit.js

@@ -39,7 +39,8 @@
  *     memory from pruning. Halving does not touch last_accessed/access_count.
  *   - Re-classification: a later run whose LLM tags it, or whose evolved
  *     prototypes clear the floor, gives it a (weak) primary — halving stops.
- *     Its strength is NOT restored; only access does that job.
+ *     Its strength is restored only by the nightly promotion stage (#448),
+ *     which converts each new access_count delta into a base_strength bump.
  *
  * PRUNE INTERACTION (verified against stageDecayPrune + effectiveStrength):
  * prune fires when effectiveStrength < 0.01 for a >90-day-old, never-accessed

package/dist/recall-index.d.ts

@@ -10,8 +10,9 @@
  * Strengthening semantics (the recall/decay alignment):
  *   - Appearing in the index = exposure: shown_count + last_accessed refresh
  *     (mild, temporary strengthen — the decay clock resets) via
- *     storage.touchMemoriesShown. NO access_count bump: hardening, the prune
- *     shield, and the adoption metric stay driven by real use.
+ *     storage.touchMemoriesShown. NO access_count bump: the promotion signal
+ *     (#448), the prune shield, and the adoption metric stay driven by real
+ *     use.
  *   - hicortex_get = use: full strengthen (access_count + 1).
  *
  * Anti-bloat gates: relevance floor (measured cosine, or a real BM25 match),

package/dist/recall-index.js

@@ -11,8 +11,9 @@
  * Strengthening semantics (the recall/decay alignment):
  *   - Appearing in the index = exposure: shown_count + last_accessed refresh
  *     (mild, temporary strengthen — the decay clock resets) via
- *     storage.touchMemoriesShown. NO access_count bump: hardening, the prune
- *     shield, and the adoption metric stay driven by real use.
+ *     storage.touchMemoriesShown. NO access_count bump: the promotion signal
+ *     (#448), the prune shield, and the adoption metric stay driven by real
+ *     use.
  *   - hicortex_get = use: full strengthen (access_count + 1).
  *
  * Anti-bloat gates: relevance floor (measured cosine, or a real BM25 match),

package/dist/retrieval.d.ts

@@ -55,14 +55,26 @@ export interface ScoringWeights {
     similarity: number;
     strength: number;
     connections: number;
+    /**
+     * #449 log-saturation degree K for the connections term: the credit is
+     * min(1, log1p(k)/log1p(K)) — full at k = K, exactly +0 at k = 0. A count,
+     * not a weight: validated ≥ 1 (the rrfK non-weight seam precedent); no
+     * upper bound (the eval sweep widens K past the planted fixture degrees).
+     */
+    connectionsSaturation: number;
     recency: number;
-    freshnessBoostDays: number;
-    freshnessBoostWeight: number;
+    /** #430 merged time curve: head amplitude at age 0 — the merged freshness
+     *  job. A deliberate overshoot (max total 1.15 pre-clamp), NOT a fifth
+     *  blend weight; the four blend weights still sum to 1.0. */
+    recencyHead: number;
+    /** #430 merged time curve: head window / join age in days. */
+    recencyHeadDays: number;
     supersededDemotion: number;
-    /** #203 soft affinity boost on exact project match. */
-    projectAffinity: number;
-    /** #203 soft affinity boost multiplier on max overlapping domain-tag weight. */
-    domainAffinity: number;
+    /** #430 merged scope affinity: ONE term — max() of the project-match
+     *  indicator (1 on exact match) and the max overlapping domain-tag weight,
+     *  × this weight (born from #203's two additive boosts at their shared
+     *  value). 0 (via the seam) disables the whole term. */
+    scopeAffinity: number;
     /** #205 RRF k parameter (1/(k+rank+1)). Larger ⇒ shallower rank curve. */
     rrfK: number;
     /** #205 composite-score share of the final blend (RRF gets the remainder). */
@@ -208,7 +220,7 @@ export declare function l2ToCosine(distance: number): number;
  */
 export declare function cosineBetweenVectors(a: Float32Array, b: Float32Array): number;
 /**
- * Compute decayed strength with adaptive decay (B+E+D model).
+ * Compute decayed strength with adaptive decay (B+D model).
  * Exported for use by consolidation decay/prune stage.
  *
  * #425 read-side law: the decay-relevant importance is CLAMPED at the
@@ -216,22 +228,29 @@ export declare function cosineBetweenVectors(a: Float32Array, b: Float32Array):
  * exactly 1.0 the decay rate is exactly 1.0 and the row never decays, so
  * legacy base-1.0 rows (and any write site that predates the cap) decay
  * again. The clamp applies to explicit importance passes too.
+ *
+ * #448: the access/connectivity HARDENING terms are REMOVED — the fade rate
+ * no longer depends on access or link history (a briefly-used memory was
+ * near-immortal: 10 accesses cut the decay rate to 3% of normal). Real use
+ * now raises the STORED score via the nightly promotion stage
+ * (consolidate.ts stagePromotion) instead of slowing future decay, so a
+ * promoted-then-abandoned memory fades on the same 365-day clock as any
+ * other, from a higher anchor.
  */
 export declare function effectiveStrength(baseStrength: number, lastAccessed: string | null, now: Date, options?: {
     importance?: number;
-    accessCount?: number;
-    linkCount?: number;
 }): number;
 /**
  * Return a composite relevance score in [0, 1] for a candidate memory.
  * Exported for exact-value tests of the similarity component (#145).
  *
- * #203 soft affinity (options.scope + options.tagWeights): two additive,
- * graded, zero-boost-neutral terms — project affinity (exact project match)
- * and domain affinity (max overlapping memory_tags.weight × scope). Both are
- * 0 when the scope is absent (byte-identical to pre-#203) and NEVER negative
- * (a foreign memory adds 0, never a penalty — penalties re-introduce
- * soft-exclusion). See `AffinityScope`.
+ * Scope affinity (options.scope + options.tagWeights; #203, merged #430):
+ * ONE additive, graded, zero-boost-neutral term — max() of the project-match
+ * indicator (exact match ⇒ 1) and the max overlapping memory_tags.weight,
+ * × the scopeAffinity weight. It is 0 when the scope is absent
+ * (byte-identical to pre-#203) and NEVER negative (a foreign memory adds 0,
+ * never a penalty — penalties re-introduce soft-exclusion). See
+ * `AffinityScope`.
  */
 export interface AffinityScope {
     /** Exact-match project from the client (CC/OC cwd-derived; /search project). */
@@ -240,12 +259,13 @@ export interface AffinityScope {
      *  vocabulary as memory_tags (config `domains`). */
     missionDomains?: string[];
 }
-export declare function computeScore(memory: Memory, distance: number, connectionCount: number, maxConnections: number, now: Date, options?: {
+export declare function computeScore(memory: Memory, distance: number, connectionCount: number, now: Date, options?: {
     superseded?: boolean;
-    /** #203: when present, project/domain affinity boosts are applied. */
+    /** #203/#430: when present, the scope-affinity boost is applied. */
     scope?: AffinityScope;
     /** Candidate's graded domain tags (memory_tags rows). Loaded batched for
-     *  the whole candidate set in retrieve(); used for domain affinity. */
+     *  the whole candidate set in retrieve(); used for the scope-affinity
+     *  term's domain signal. */
     tagWeights?: Array<{
         tag: string;
         weight: number | null;
@@ -302,6 +322,11 @@ export declare function retrieve(db: Database.Database, embedFn: EmbedFn, query:
     ftsCandidates?: (fetchLimit: number, sourceAgent?: string) => Array<Memory & {
         rank: number;
     }>;
+    /** #458 eval clock pin — the instant the decay/recency terms score
+     *  against. Eval-only: no production caller passes it, and unset means
+     *  the live clock (byte-identical to pre-#458). Mirrors the
+     *  injectable-clock idiom of run-deadline.ts; see eval/eval-clock.ts. */
+    now?: Date;
 }): Promise<MemorySearchResult[]>;
 /**
  * Get recent context, optionally filtered by project.

package/dist/retrieval.js

@@ -131,12 +131,14 @@ const SCORING_DEFAULTS = {
     similarity: CALIBRATION.SCORE_SIMILARITY_WEIGHT,
     strength: CALIBRATION.SCORE_STRENGTH_WEIGHT,
     connections: CALIBRATION.SCORE_CONNECTIONS_WEIGHT,
+    // #449: the p99 of the real undirected degree distribution (see
+    // calibration.ts provenance) — saturates the top ~1% of linked memories.
+    connectionsSaturation: CALIBRATION.CONNECTIONS_SATURATION_DEGREE,
     recency: CALIBRATION.SCORE_RECENCY_WEIGHT,
-    freshnessBoostDays: CALIBRATION.FRESHNESS_BOOST_DAYS,
-    freshnessBoostWeight: CALIBRATION.FRESHNESS_BOOST_WEIGHT,
+    recencyHead: CALIBRATION.RECENCY_HEAD_WEIGHT,
+    recencyHeadDays: CALIBRATION.RECENCY_HEAD_DAYS,
     supersededDemotion: CALIBRATION.SUPERSEDED_DEMOTION,
-    projectAffinity: CALIBRATION.PROJECT_AFFINITY_WEIGHT,
-    domainAffinity: CALIBRATION.DOMAIN_AFFINITY_WEIGHT,
+    scopeAffinity: CALIBRATION.SCOPE_AFFINITY_WEIGHT,
     // #205 (calibration.ts): rrfK + rrfCompositeWeight match the pre-#205
     // hardcoded values (60 and 0.8); the FTS per-list weight (1.0 → 0.5) is the
     // one deliberate nudge toward vector — the bisection point where BM25F +
@@ -172,22 +174,36 @@ function configureScoring(overrides) {
         const n = Number(v);
         return Number.isFinite(n) && n >= 0 ? n : dflt;
     };
+    // #449: the connections saturation degree is a COUNT ≥ 1 (log1p(K) must
+    // not divide by zero; K < 1 would saturate every k > 0 instantly). No
+    // upper bound — the rrfK non-weight precedent.
+    const numMin1 = (v, dflt) => {
+        const n = Number(v);
+        return Number.isFinite(n) && n >= 1 ? n : dflt;
+    };
     scoringWeights = {
         similarity: num(overrides?.similarity, SCORING_DEFAULTS.similarity, 0, 1),
         strength: num(overrides?.strength, SCORING_DEFAULTS.strength, 0, 1),
         connections: num(overrides?.connections, SCORING_DEFAULTS.connections, 0, 1),
+        connectionsSaturation: numMin1(overrides?.connectionsSaturation, SCORING_DEFAULTS.connectionsSaturation),
         recency: num(overrides?.recency, SCORING_DEFAULTS.recency, 0, 1),
-        freshnessBoostDays: num(overrides?.freshnessBoostDays, SCORING_DEFAULTS.freshnessBoostDays, 0, 365),
-        freshnessBoostWeight: num(overrides?.freshnessBoostWeight, SCORING_DEFAULTS.freshnessBoostWeight, 0, 1),
+        recencyHead: num(overrides?.recencyHead, SCORING_DEFAULTS.recencyHead, 0, 1),
+        recencyHeadDays: num(overrides?.recencyHeadDays, SCORING_DEFAULTS.recencyHeadDays, 0, 365),
         supersededDemotion: num(overrides?.supersededDemotion, SCORING_DEFAULTS.supersededDemotion, 0, 1),
-        projectAffinity: num(overrides?.projectAffinity, SCORING_DEFAULTS.projectAffinity, 0, 1),
-        domainAffinity: num(overrides?.domainAffinity, SCORING_DEFAULTS.domainAffinity, 0, 1),
+        scopeAffinity: num(overrides?.scopeAffinity, SCORING_DEFAULTS.scopeAffinity, 0, 1),
         rrfK: numW(overrides?.rrfK, SCORING_DEFAULTS.rrfK),
         rrfCompositeWeight: num(overrides?.rrfCompositeWeight, SCORING_DEFAULTS.rrfCompositeWeight, 0, 1),
         rrfFtsWeight: numW(overrides?.rrfFtsWeight, SCORING_DEFAULTS.rrfFtsWeight),
         rrfVectorWeight: numW(overrides?.rrfVectorWeight, SCORING_DEFAULTS.rrfVectorWeight),
         bothChannelBoost: num(overrides?.bothChannelBoost, SCORING_DEFAULTS.bothChannelBoost, 0, 1),
     };
+    // #430: a head weaker than the slow weight it must join is nonsensical (the
+    // head curve would dive below the tail inside the window). Floor it at the
+    // resolved slow weight, defaulting to the shipped amplitude — the normal
+    // invalid case falls back to 0.30 rather than degrading the curve silently.
+    if (scoringWeights.recencyHead < scoringWeights.recency) {
+        scoringWeights.recencyHead = Math.max(SCORING_DEFAULTS.recencyHead, scoringWeights.recency);
+    }
     return { ...scoringWeights };
 }
 /** Current resolved weights (tests + status output). */
@@ -486,7 +502,7 @@ function parseTimestamp(ts) {
 // Scoring helpers
 // ---------------------------------------------------------------------------
 /**
- * Compute decayed strength with adaptive decay (B+E+D model).
+ * Compute decayed strength with adaptive decay (B+D model).
  * Exported for use by consolidation decay/prune stage.
  *
  * #425 read-side law: the decay-relevant importance is CLAMPED at the
@@ -494,25 +510,73 @@ function parseTimestamp(ts) {
  * exactly 1.0 the decay rate is exactly 1.0 and the row never decays, so
  * legacy base-1.0 rows (and any write site that predates the cap) decay
  * again. The clamp applies to explicit importance passes too.
+ *
+ * #448: the access/connectivity HARDENING terms are REMOVED — the fade rate
+ * no longer depends on access or link history (a briefly-used memory was
+ * near-immortal: 10 accesses cut the decay rate to 3% of normal). Real use
+ * now raises the STORED score via the nightly promotion stage
+ * (consolidate.ts stagePromotion) instead of slowing future decay, so a
+ * promoted-then-abandoned memory fades on the same 365-day clock as any
+ * other, from a higher anchor.
  */
 function effectiveStrength(baseStrength, lastAccessed, now, options) {
     const rawImportance = options?.importance ?? baseStrength;
     const importance = Math.min(rawImportance, CALIBRATION.IMPORTANCE_CEILING);
-    const accessCount = options?.accessCount ?? 0;
-    const linkCount = options?.linkCount ?? 0;
     const hours = Math.max((now.getTime() - parseTimestamp(lastAccessed).getTime()) / 3_600_000, 0);
     // B: Importance slows decay
-    let decayRate = 1.0 - BASE_DECAY * (1.0 - importance);
-    // E: Access hardening
-    const hardening = 0.7;
-    decayRate = 1.0 - (1.0 - decayRate) * Math.pow(hardening, accessCount);
-    // E: Connectivity hardening
-    decayRate = 1.0 - (1.0 - decayRate) * Math.pow(hardening, linkCount);
+    const decayRate = 1.0 - BASE_DECAY * (1.0 - importance);
     // D: Asymptotic floor
     const floor = baseStrength * importance * 0.1;
     return floor + (baseStrength - floor) * Math.pow(decayRate, hours);
 }
-function computeScore(memory, distance, connectionCount, maxConnections, now, options) {
+/**
+ * #430 merged time curve — ONE additive score term, two timescales. The
+ * pre-#430 pair (slow recency blend + linear fresh-memory bonus) is now a
+ * single piecewise exponential: a steep head with amplitude `recencyHead` at
+ * age 0, joined value-continuously onto the unchanged slow curve at
+ * `recencyHeadDays`. The head rate is DERIVED from value-continuity at the
+ * join (never a free constant), so the join cannot be mis-tuned and the eval
+ * seam retunes it automatically.
+ *
+ * A memory is born highly available and settles into the normal ranking over
+ * the head window. Age is measured from created_at, which the nightly sets
+ * from the session's own date — so a session captured last night ranks as
+ * ~1 day old (not 0), and backfilled older content correctly gets no head.
+ * The slow tail alone (≈58-day half-life at weight 0.15) could never lift a
+ * day-old memory past an old high-strength one — measured case: an
+ * exact-match 1-day-old memory (strength 0.50) lost to an unrelated memory
+ * at strength 0.80. That job is now the head's, so ranking among memories
+ * that are all old (at or beyond the join) is untouched.
+ */
+function timeScore(hoursSinceCreated, hasCreatedAt) {
+    const w = scoringWeights;
+    // Zero slow weight disables the WHOLE term (the term-isolation semantics
+    // the tests rely on). Also the NaN guard: with w.recency = 0 the derived
+    // head rate is ln(0)/join = −Inf and exp(−Inf · 0) = NaN at age 0.
+    if (w.recency === 0)
+        return 0;
+    // Absent created_at keeps the pre-#430 behavior exactly: the slow term at
+    // its age-0 value, no head. The guard is TRUTHINESS (the pre-#430 freshness
+    // guard was `memory.created_at && …`), so an empty string counts as absent
+    // too — and parseTimestamp("") falls back to now just like null (hours 0 →
+    // pow(·, 0) = 1 → exactly the slow weight).
+    if (!hasCreatedAt)
+        return w.recency;
+    const joinHours = w.recencyHeadDays * 24;
+    // The boundary belongs to the slow branch — at and beyond the join the
+    // expression is bit-identical to the pre-#430 slow term (IEEE754
+    // multiplication is commutative, so the operand order vs the old
+    // `recency * w.recency` is float-identical).
+    if (joinHours <= 0 || hoursSinceCreated >= joinHours) {
+        return w.recency * Math.pow(CALIBRATION.RECENCY_HOURLY_DECAY, hoursSinceCreated);
+    }
+    // Head branch (created_at present, 0 ≤ hours < joinHours): amplitude
+    // w.recencyHead decaying at the continuity-derived rate (≈ −0.004626/h —
+    // head half-life ≈ 6.24 d at the shipped constants).
+    const headRate = Math.log((w.recency * Math.pow(CALIBRATION.RECENCY_HOURLY_DECAY, joinHours)) / w.recencyHead) / joinHours;
+    return w.recencyHead * Math.exp(headRate * hoursSinceCreated);
+}
+function computeScore(memory, distance, connectionCount, now, options) {
     // TRUE cosine similarity (#145). The old `1 − distance` compressed real
     // cosines (cos 0.8 scored 0.37) and the 0-clamp at that scale flattened
     // everything below cos 0.5 to exactly 0, killing mid-relevance
@@ -529,67 +593,66 @@ function computeScore(memory, distance, connectionCount, maxConnections, now, op
         // time — now stated at the call site so the triple-win coupling
         // (score share, decay rate, floor) is visible and single-sourced).
         importance: memory.base_strength ?? 0.5,
-        accessCount: memory.access_count ?? 0,
-        linkCount: connectionCount,
     });
-    const connScore = maxConnections > 0 ? connectionCount / maxConnections : 0;
     const hoursSinceCreated = Math.max((now.getTime() - parseTimestamp(memory.created_at).getTime()) / 3_600_000, 0);
-    const recency = Math.pow(0.9995, hoursSinceCreated);
     const w = scoringWeights;
+    // #449 (PR E, items 1+3): LOG-SATURATING connection credit on the
+    // ABSOLUTE degree scale — min(1, log1p(k)/log1p(K)), K = the resolved
+    // connectionsSaturation (default 16, the p99 of the real undirected
+    // degree distribution; calibration.ts carries the provenance). Shape per
+    // the #449 research base: ACT-R fan saturation (Anderson & Reder 1999 —
+    // activation falls with the LOG of fan, not linearly), SAM's saturating
+    // returns, cue overload (Watkins & Watkins 1975) — returns per
+    // additional link compress, and the top ~1% of hubs tie at full credit.
+    // This REPLACED the pre-#449 candidate-set normalization
+    // (connectionCount / maxConnections), which is deleted from this
+    // signature and every call site: a row's score no longer depends on
+    // which OTHER rows happened to match (set-relative scores were not
+    // reproducible, and the ~40-degree global hubs sat in nearly every
+    // 2-hop neighborhood — per-query max p50 = 36 — so the median linked
+    // candidate earned only k/36 of the term). k = 0 contributes exactly +0
+    // (log1p(0) = 0): unlinked rows score bit-identically to pre-#449.
+    const connScore = Math.min(1, Math.log1p(connectionCount) / Math.log1p(w.connectionsSaturation));
     let score = similarity * w.similarity +
         effStrength * w.strength +
         connScore * w.connections +
-        recency * w.recency;
-    // Fresh-memory window (#191 Phase B): a memory is born highly available and
-    // settles into the normal ranking over `freshnessBoostDays`. Age is measured
-    // from created_at, which the nightly sets from the session's own date — so a
-    // session captured last night ranks as ~1 day old (not 0), and backfilled
-    // older content correctly gets no boost. The slow
-    // `recency` term above (≈58-day half-life at weight 0.15) could never lift a
-    // day-old memory past a hardened old one — measured case: an exact-match
-    // 1-day-old memory (strength 0.50) lost to an unrelated memory at strength
-    // 0.80. This is an ADDITIVE bonus that decays linearly to zero at the window
-    // edge, so it cannot distort ranking among memories that are all old.
-    const ageDays = hoursSinceCreated / 24;
-    if (memory.created_at && ageDays < scoringWeights.freshnessBoostDays) {
-        const freshness = 1 - ageDays / scoringWeights.freshnessBoostDays;
-        score += freshness * scoringWeights.freshnessBoostWeight;
-    }
-    // #203 soft affinity (retrieval scoping). Two graded, additive terms — both
-    // ZERO when the scope is absent (byte-identical ranking) and ZERO for a
-    // non-matching memory (never a penalty). Project affinity is a flat boost on
-    // exact project match; domain affinity is max(overlapping tag weight) × the
-    // domain weight. NULL tag weights (not yet computed by the nightly
-    // reconsolidation) count as 0 — we never invent a boost from missing
-    // association strength. Affinity rides the 0.8 composite side only (the RRF
-    // 0.2 side is #205 territory and untouched here).
+        timeScore(hoursSinceCreated, Boolean(memory.created_at));
+    // #430 scope affinity (retrieval scoping; born from #203's two boosts).
+    // ONE graded, additive term — max() of the strongest single scope signal:
+    // the project-match indicator (exact project match ⇒ 1) and the max
+    // overlapping domain-tag weight. ZERO when the scope is absent
+    // (byte-identical ranking) and ZERO for a non-matching memory (never a
+    // penalty). The signals are never stacked — they are largely the same
+    // evidence and the domain one is the weaker, so the strongest counts once
+    // (single-signal scopes reproduce #203's exact floats). NULL tag weights
+    // (not yet computed by the nightly reconsolidation) count as 0 — we never
+    // invent a boost from missing association strength. Affinity rides the 0.8
+    // composite side only (the RRF 0.2 side is #205 territory and untouched
+    // here).
     const scope = options?.scope;
     if (scope) {
-        if (scope.project && memory.project === scope.project) {
-            score += scoringWeights.projectAffinity;
-        }
+        const projectMatch = scope.project && memory.project === scope.project;
+        let maxOverlapTagWeight = 0;
         const domains = scope.missionDomains;
         if (domains && domains.length > 0 && options.tagWeights && options.tagWeights.length > 0) {
             const domainSet = domains.length === 1 ? null : new Set(domains);
-            let maxWeight = 0;
             for (const tw of options.tagWeights) {
                 const overlaps = domainSet ? domainSet.has(tw.tag) : tw.tag === domains[0];
                 if (overlaps) {
                     const w = tw.weight ?? 0;
-                    if (w > maxWeight)
-                        maxWeight = w;
+                    if (w > maxOverlapTagWeight)
+                        maxOverlapTagWeight = w;
                 }
             }
-            if (maxWeight > 0)
-                score += maxWeight * scoringWeights.domainAffinity;
         }
+        score += Math.max(projectMatch ? 1 : 0, maxOverlapTagWeight) * scoringWeights.scopeAffinity;
     }
     // #425 both-channel boost: vector KNN and BM25 FTS AGREEING on a candidate
     // is the genuine-match signature (a distinctive proper noun the user knows
     // exists — the field failure this fixes: 0.90/0.95-strength domain-adjacent
     // memories outranked the best-similarity exact-token match). ADDITIVE,
     // zero-boost neutral, never a penalty; rides the composite side only (like
-    // projectAffinity — the RRF side is #205 territory); applied BEFORE the
+    // scopeAffinity — the RRF side is #205 territory); applied BEFORE the
     // superseded multiplier so a superseded both-channel row still demotes.
     if (options?.bothChannel)
         score += scoringWeights.bothChannelBoost;
@@ -605,6 +668,18 @@ function computeScore(memory, distance, connectionCount, maxConnections, now, op
 // ---------------------------------------------------------------------------
 // Graph traversal
 // ---------------------------------------------------------------------------
+/**
+ * #466 — truth-management relationships that never pay connection credit.
+ * A superseded/corrected memory remains part of its knowledge neighborhood
+ * as EVIDENCE, but the administrative edge itself is not a semantic
+ * connection: "this memory was replaced" must not add ranking credit to the
+ * memory it replaced. Scoped to exactly the #463 audit's administrative set
+ * (`superseded_by`, `corrected_by`); every semantic edge — `extends`,
+ * `relates_to`, and the legacy vocabulary — still counts. Graph traversal
+ * (frontier expansion below, the belief walk, /graph queries) is untouched:
+ * those are discovery mechanisms, and only the credit stops.
+ */
+const ADMIN_RELATIONSHIPS = new Set(["superseded_by", "corrected_by"]);
 function collectLinks(db, seedIds, maxHops = 2) {
     const visited = new Set(seedIds);
     const connectionCounts = new Map();
@@ -613,7 +688,9 @@ function collectLinks(db, seedIds, maxHops = 2) {
         const nextFrontier = new Set();
         for (const mid of frontier) {
             const links = storage.getLinks(db, mid, "both");
-            const count = links.length;
+            // #466: the degree feeding computeScore's connections term counts
+            // semantic edges only — administrative edges do not pay credit.
+            const count = links.filter((l) => !ADMIN_RELATIONSHIPS.has(l.relationship)).length;
             connectionCounts.set(mid, (connectionCounts.get(mid) ?? 0) + count);
             for (const link of links) {
                 const linkedId = link.source_id === mid ? link.target_id : link.source_id;
@@ -631,7 +708,7 @@ function collectLinks(db, seedIds, maxHops = 2) {
     for (const mid of visited) {
         if (!connectionCounts.has(mid)) {
             const links = storage.getLinks(db, mid, "both");
-            connectionCounts.set(mid, links.length);
+            connectionCounts.set(mid, links.filter((l) => !ADMIN_RELATIONSHIPS.has(l.relationship)).length);
         }
     }
     return connectionCounts;
@@ -718,7 +795,7 @@ async function retrieve(db, embedFn, query, options) {
     const project = options?.project;
     const sourceAgent = options?.sourceAgent;
     const missionDomains = options?.missionDomains;
-    const now = new Date();
+    const now = options?.now ?? new Date();
     // #203 affinity scope — passed to computeScore for every candidate. Built
     // once; absent fields yield no boost (zero-boost neutral).
     const scope = project || (missionDomains && missionDomains.length > 0)
@@ -804,10 +881,9 @@ async function retrieve(db, embedFn, query, options) {
             continue;
         candidateMap.set(gid, { mem, distance: DEFAULT_GRAPH_DISTANCE, source: "graph" });
     }
-    // 5. Compute composite scores
-    const maxConnections = Math.max(...([...connectionCounts.values()].length > 0
-        ? [...connectionCounts.values()]
-        : [0]));
+    // 5. Compute composite scores (the connections term reads each row's own
+    // degree only — #449 deleted the candidate-set-max normalization: a
+    // row's score no longer depends on which other rows matched).
     const scored = [];
     const maxRrf = Math.max(...([...rrfScores.values()].length > 0 ? [...rrfScores.values()] : [1]));
     // One query for the whole candidate set (#191 Phase B): superseded memories
@@ -824,7 +900,7 @@ async function retrieve(db, embedFn, query, options) {
         : undefined;
     for (const [mid, { mem, distance, source }] of candidateMap) {
         const connCount = connectionCounts.get(mid) ?? 0;
-        const composite = computeScore(mem, distance, connCount, maxConnections, now, {
+        const composite = computeScore(mem, distance, connCount, now, {
             superseded: supersededIds.has(mid),
             scope,
             tagWeights: tagWeightsByMemory?.get(mid),
@@ -832,10 +908,7 @@ async function retrieve(db, embedFn, query, options) {
             // signature — graph-only and single-channel candidates add nothing.
             bothChannel: source === "both",
         });
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connectionCounts.get(mem.id) ?? 0,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         const rrf = rrfScores.get(mid) ?? 0;
         const normalizedRrf = maxRrf > 0 ? rrf / maxRrf : 0;
         // #205: composite/RRF blend is now config-driven (rrfCompositeWeight, 0.8
@@ -851,7 +924,8 @@ async function retrieve(db, embedFn, query, options) {
         scored.push({ mem, finalScore, effStr, connCount, similarity, source });
     }
     // 6. Sort and take top N — with cold-exposure slots (#192).
-    // Access hardening + effective strength make past winners self-reinforcing:
+    // Effective strength + the promotion stage (#448) make past winners
+    // self-reinforcing:
     // 88% of the production corpus had never been returned by any query. Reserve
     // up to 2 of k for the best-scoring never-accessed candidates so the long
     // tail gets nonzero exposure whenever it is semantically in range. Slots are
@@ -897,12 +971,9 @@ async function retrieve(db, embedFn, query, options) {
         if (sourceAgent && mem.source_agent !== sourceAgent)
             return null;
         const connCount = storage.getLinks(db, terminalId, "both").length;
-        const composite = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, maxConnections, now, { superseded: supersededIds.has(terminalId) });
+        const composite = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, now, { superseded: supersededIds.has(terminalId) });
         const finalScore = composite * scoringWeights.rrfCompositeWeight;
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connCount,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         return { mem, finalScore, effStr, connCount, similarity: null, source: "graph" };
     });
     const results = top.map((t) => formatResult(t.mem, t.finalScore, t.effStr, t.connCount, {
@@ -936,22 +1007,16 @@ function searchRecent(db, options) {
         return [];
     const allIds = candidates.map((c) => c.id);
     const connectionCounts = collectLinks(db, allIds, 1);
-    const maxConnections = Math.max(...([...connectionCounts.values()].length > 0
-        ? [...connectionCounts.values()]
-        : [0]));
     const scored = [];
     // #384: same full demotion set as retrieve() — link-driven supersessions
     // UNION status-marked superseded/retracted rows (findDemotedIds).
     const supersededRecent = findDemotedIds(db, candidates.map((c) => c.id));
     for (const mem of candidates) {
         const connCount = connectionCounts.get(mem.id) ?? 0;
-        const score = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, maxConnections, now, {
+        const score = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, now, {
             superseded: supersededRecent.has(mem.id),
         });
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connectionCounts.get(mem.id) ?? 0,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         scored.push({ mem, score, effStr, connCount });
     }
     scored.sort((a, b) => b.score - a.score);
@@ -976,11 +1041,8 @@ function searchRecent(db, options) {
         if (project && mem.project !== project)
             return null;
         const connCount = storage.getLinks(db, terminalId, "both").length;
-        const score = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, maxConnections, now, { superseded: supersededRecent.has(terminalId) });
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connCount,
-        });
+        const score = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, now, { superseded: supersededRecent.has(terminalId) });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         return { mem, score, effStr, connCount };
     });
     const results = top.map((t) => formatResult(t.mem, t.score, t.effStr, t.connCount));

package/dist/status.js

@@ -66,6 +66,24 @@ async function runStatus() {
             console.log(`Memories:     ${stats.memories} (${typeStr || "none"})`);
             console.log(`Links:        ${stats.links}`);
             console.log(`DB size:      ${(stats.db_size_bytes / 1024).toFixed(1)} KB`);
+            // 0.21 migration detection (#425): pre-0.21 stores have inflated importance
+            // scores (median ~0.80 vs the honest ~0.40). If the live median is high,
+            // recommend the one-shot rescore.
+            if (stats.memories > 0) {
+                try {
+                    const live = db.prepare("SELECT base_strength FROM memories WHERE base_strength IS NOT NULL AND (status IS NULL OR status NOT IN ('absorbed','superseded','retracted')) ORDER BY base_strength").all();
+                    if (live.length >= 10) {
+                        const median = live[Math.floor(live.length / 2)].base_strength;
+                        if (median >= 0.6) {
+                            console.log(``);
+                            console.log(`⚠  Pre-0.21 importance scores detected (median ${median.toFixed(2)}).`);
+                            console.log(`   Run: npx @gamaze/hicortex rescore-importance --apply`);
+                            console.log(`   to re-score your store under the honest rubric.`);
+                        }
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
             db.close();
         }
         catch (err) {

package/dist/storage.d.ts

@@ -68,7 +68,8 @@ export declare function enrichMemory(db: Database.Database, memoryId: string, no
  * Record that memories appeared in a pushed recall index (#192): bump
  * shown_count and refresh last_accessed (a mild strengthen — the decay clock
  * resets so topically-live memories stop sinking) WITHOUT touching
- * access_count, which stays reserved for real use (hardening + prune shield).
+ * access_count, which stays reserved for real use (the promotion signal
+ * #448 + the prune shield).
  */
 export declare function touchMemoriesShown(db: Database.Database, memoryIds: string[], nowIsoStr: string): void;
 /**

package/dist/storage.js

@@ -190,6 +190,10 @@ const ALLOWED_UPDATE_FIELDS = new Set([
     // stageImportance, the enrich path, and the rescore-importance backfill —
     // the moment a row's base_strength is settled under some rubric.
     "importance_scored_at",
+    // Promotion baseline (#448, migration v20): written by the nightly
+    // promotion stage and dedup merges (which sum a cluster's counters onto
+    // the canonical — the baseline must move with the summed access_count).
+    "promotion_last_count",
 ]);
 /**
  * Update specific fields on a memory.
@@ -256,7 +260,8 @@ function enrichMemory(db, memoryId, nowIsoStr) {
  * Record that memories appeared in a pushed recall index (#192): bump
  * shown_count and refresh last_accessed (a mild strengthen — the decay clock
  * resets so topically-live memories stop sinking) WITHOUT touching
- * access_count, which stays reserved for real use (hardening + prune shield).
+ * access_count, which stays reserved for real use (the promotion signal
+ * #448 + the prune shield).
  */
 function touchMemoriesShown(db, memoryIds, nowIsoStr) {
     if (memoryIds.length === 0)