@gamaze/hicortex 0.21.0 → 0.22.0

package/dist/dashboard.js

@@ -113,38 +113,17 @@ function computeDashboardMetrics(db) {
         },
     };
 }
-/**
- * One grouped pass over memory_links for per-memory link counts (batch —
- * never per-row queries); shared by the field payload and stage_counts.
- * Counts BOTH directions (a memory's connectivity is symmetric).
- */
-function linkCountsByMemory(db) {
-    const rows = db
-        .prepare(`SELECT id, SUM(c) AS c FROM (
-         SELECT source_id AS id, COUNT(*) AS c FROM memory_links GROUP BY source_id
-         UNION ALL
-         SELECT target_id AS id, COUNT(*) AS c FROM memory_links GROUP BY target_id
-       ) GROUP BY id`)
-        .all();
-    const linkCounts = new Map();
-    for (const r of rows)
-        linkCounts.set(r.id, r.c);
-    return linkCounts;
-}
 /**
  * Derive one memory's {strength, stage} — the exact math of the field
- * payload: effectiveStrength (importance = base, access + link hardening)
- * rounded to the 1e-6 wire format, then the recency gate (days since
+ * payload: effectiveStrength (importance = base) rounded to the 1e-6 wire
+ * format, then the recency gate (days since
  * last_accessed, falling back to created_at; unparseable → null, the gate is
  * skipped rather than guessing "very old") and the calibrated strength bands.
  */
-function deriveStageForRow(row, linkCount, now, nowDay) {
+function deriveStageForRow(row, now, nowDay) {
     const base = row.base_strength ?? 0.5;
-    const accessCount = row.access_count ?? 0;
     const effStr = (0, retrieval_js_1.effectiveStrength)(base, row.last_accessed, now, {
         importance: base,
-        accessCount,
-        linkCount,
     });
     const strength = Math.round(effStr * 1e6) / 1e6;
     const refDay = utcDayNumber(row.last_accessed) ?? utcDayNumber(row.created_at);
@@ -160,15 +139,14 @@ function deriveStageForRow(row, linkCount, now, nowDay) {
 function computeStageCounts(db) {
     const now = new Date();
     const nowDay = Math.floor(now.getTime() / 86_400_000);
-    const linkCounts = linkCountsByMemory(db);
     const rows = db
-        .prepare(`SELECT id, base_strength, last_accessed, access_count, created_at
+        .prepare(`SELECT id, base_strength, last_accessed, created_at
          FROM memories
         WHERE COALESCE(status, '') != 'absorbed'`)
         .all();
     const counts = { forming: 0, belief: 0, truth: 0, fading: 0 };
     for (const r of rows) {
-        counts[deriveStageForRow(r, linkCounts.get(r.id) ?? 0, now, nowDay).stage]++;
+        counts[deriveStageForRow(r, now, nowDay).stage]++;
     }
     return counts;
 }
@@ -397,7 +375,7 @@ function backfillSnapshots(db) {
 // LIVE composition (so day-one, before any snapshot is written, still shows
 // the current corpus shape), and builds the digest for the selected day.
 // ---------------------------------------------------------------------------
-const VALID_RANGES = new Set(["7d", "30d", "90d", "all"]);
+const VALID_RANGES = new Set(["7d", "30d", "90d", "180d", "all"]);
 const DEFAULT_RANGE = "30d";
 const DEFAULT_DIGEST_LIMIT = 10;
 function rangeToCutoff(range) {
@@ -597,7 +575,7 @@ function handleDashboardData(db, query, config) {
                 by_source_agent: live.by_source_agent,
                 by_source_machine: live.by_source_machine,
             },
-            capture_health: (0, capture_health_js_1.readCaptureHealth)(db),
+            capture_health: { ...(0, capture_health_js_1.readCaptureHealth)(db), ...(0, capture_health_js_1.readCaptureHealthWindow)(db) },
             // #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: {
@@ -690,8 +668,6 @@ function utcDayNumber(iso) {
 function handleDashboardField(db) {
     const now = new Date();
     const nowDay = Math.floor(now.getTime() / 86_400_000);
-    // Shared derivation inputs (one batched pass — never per-row queries).
-    const linkCounts = linkCountsByMemory(db);
     const rows = db
         .prepare(`SELECT id, content, base_strength, last_accessed, access_count,
               created_at, domain, source_agent, source_machine
@@ -702,7 +678,7 @@ function handleDashboardField(db) {
     const memories = rows.map((r) => {
         // Shared per-row derivation — the SAME math the snapshot stage_counts
         // uses (deriveStageForRow); the field only adds its wire fields.
-        const { strength, stage } = deriveStageForRow(r, linkCounts.get(r.id) ?? 0, now, nowDay);
+        const { strength, stage } = deriveStageForRow(r, now, nowDay);
         return {
             id: r.id,
             title: (0, recall_index_js_1.memoryTitle)(r.content, calibration_js_1.RECALL_TITLE_CHARS),
@@ -787,9 +763,12 @@ function dashboardFieldHandler(getDb) {
         }
     };
 }
-const EVENTS_DEFAULT_DAYS = 90;
+// #452 (owner directive 2026-09-16): the default window is 30 days for ALL
+// views — longer ranges are opt-in via the page's selector. MAX stays 365:
+// it is the generic API cap and an explicit ?days= is honored up to it.
+const EVENTS_DEFAULT_DAYS = 30;
 const EVENTS_MAX_DAYS = 365;
-/** Parse the ?days= param: integer 1..365, default 90. Returns null when the
+/** Parse the ?days= param: integer 1..365, default 30. Returns null when the
  *  value is present but invalid (→ 400); undefined when absent (→ default). */
 function parseEventsDays(raw) {
     if (raw === undefined)
@@ -801,9 +780,9 @@ function parseEventsDays(raw) {
     return n;
 }
 /**
- * The pure data handler for GET /dashboard/events?days=N. Buckets the four
- * event sources into UTC nights (only nights with events, ascending) within
- * the last `days` calendar days (today inclusive).
+ * The pure data handler for GET /dashboard/events?days=N. Buckets the event
+ * sources into UTC nights (only nights with events, ascending) within the
+ * last `days` calendar days (today inclusive).
  */
 function handleDashboardEvents(db, query) {
     const parsed = parseEventsDays(query.days);
@@ -828,14 +807,31 @@ function handleDashboardEvents(db, query) {
     const nightFor = (date) => {
         let n = nights.get(date);
         if (!n) {
-            n = { date, added: [], enriched: [], merged: [], linked: [], by_agent: {} };
+            n = {
+                date,
+                added: [],
+                enriched: [],
+                merged: [],
+                linked: [],
+                superseded: [],
+                retracted: [],
+                rewritten: [],
+                by_agent: {},
+            };
             nights.set(date, n);
         }
         return n;
     };
     const bumpAgent = (n, agent, key) => {
         const k = agent ?? "(unknown)";
-        const rec = n.by_agent[k] ?? { learned: 0, enriched: 0, merged: 0 };
+        const rec = n.by_agent[k] ?? {
+            learned: 0,
+            enriched: 0,
+            merged: 0,
+            superseded: 0,
+            retracted: 0,
+            rewritten: 0,
+        };
         rec[key] += 1;
         n.by_agent[k] = rec;
     };
@@ -855,10 +851,12 @@ function handleDashboardEvents(db, query) {
     // enriched — memory_history rows, DISTINCT memory per night (one rewrite of
     // the same memory on a night is one enrichment). LEFT JOIN: the memory row
     // can be gone (hard-deleted legacy losers); those count under "(unknown)".
+    // #452: reconsolidation rewrites are EXCLUDED — they render as `rewritten`
+    // below, so one rewrite is one caption, never "Enriched"+"Rewritten".
     const enrichRows = db
         .prepare(`SELECT h.memory_id, h.created_at, m.source_agent AS agent
          FROM memory_history h LEFT JOIN memories m ON m.id = h.memory_id
-        WHERE h.created_at >= ?`)
+        WHERE h.created_at >= ? AND h.cause <> 'reconsolidation'`)
         .all(cutoffIso);
     const enrichedSeen = new Set(); // `${date}|${memory_id}` dedup
     for (const r of enrichRows) {
@@ -898,8 +896,79 @@ function handleDashboardEvents(db, query) {
             continue;
         nightFor(date).linked.push({ a: r.source_id, b: r.target_id });
     }
+    // superseded (#452) — superseded_by links born in the window; agent = the
+    // OLD memory's source (the event belongs to the demoted claim). The link
+    // ALSO stays in `linked` above — supersession is still a connection, the
+    // ring is unchanged.
+    const supersededRows = db
+        .prepare(`SELECT l.source_id, l.target_id, l.created_at, m.source_agent AS agent
+         FROM memory_links l LEFT JOIN memories m ON m.id = l.source_id
+        WHERE l.relationship = 'superseded_by' AND l.created_at >= ?`)
+        .all(cutoffIso);
+    for (const r of supersededRows) {
+        const date = inWindow(r.created_at);
+        if (date === null)
+            continue;
+        const n = nightFor(date);
+        n.superseded.push({ old: r.source_id, by: r.target_id });
+        bumpAgent(n, r.agent, "superseded");
+    }
+    // retracted (#452) — corrected_by links whose SOURCE's CURRENT status is
+    // 'retracted'. INNER JOIN so the status filter applies: rewrite-path
+    // corrected_by links leave status 'corrected' (or NULL on legacy rows) and
+    // are NOT retractions. Marks write no memory_history row (grounding: the
+    // only two INSERT sites are the reconsolidation rewrite + rollback), so
+    // the link + current status IS the retraction record. Dedup per
+    // (date, source_id) — the enriched pattern — in case a pair's link row was
+    // re-created on the same night.
+    const retractedRows = db
+        .prepare(`SELECT l.source_id, l.target_id, l.created_at, m.source_agent AS agent
+         FROM memory_links l JOIN memories m ON m.id = l.source_id
+        WHERE l.relationship = 'corrected_by' AND m.status = 'retracted' AND l.created_at >= ?`)
+        .all(cutoffIso);
+    const retractedSeen = new Set(); // `${date}|${source_id}` dedup
+    for (const r of retractedRows) {
+        const date = inWindow(r.created_at);
+        if (date === null)
+            continue;
+        const key = `${date}|${r.source_id}`;
+        if (retractedSeen.has(key))
+            continue;
+        retractedSeen.add(key);
+        const n = nightFor(date);
+        n.retracted.push({ old: r.source_id, by: r.target_id });
+        bumpAgent(n, r.agent, "retracted");
+    }
+    // rewritten (#452) — memory_history rows from the reconsolidation rewrite
+    // (cause='reconsolidation'; rollback rows keep their own cause and stay
+    // enriched-shaped). DISTINCT memory per night, the enriched pattern.
+    const rewrittenRows = db
+        .prepare(`SELECT h.memory_id, h.created_at, m.source_agent AS agent
+         FROM memory_history h LEFT JOIN memories m ON m.id = h.memory_id
+        WHERE h.cause = 'reconsolidation' AND h.created_at >= ?`)
+        .all(cutoffIso);
+    const rewrittenSeen = new Set(); // `${date}|${memory_id}` dedup
+    for (const r of rewrittenRows) {
+        const date = inWindow(r.created_at);
+        if (date === null)
+            continue;
+        const key = `${date}|${r.memory_id}`;
+        if (rewrittenSeen.has(key))
+            continue;
+        rewrittenSeen.add(key);
+        const n = nightFor(date);
+        n.rewritten.push(r.memory_id);
+        bumpAgent(n, r.agent, "rewritten");
+    }
     const sorted = Array.from(nights.values())
-        .filter((n) => n.added.length + n.enriched.length + n.merged.length + n.linked.length > 0)
+        .filter((n) => n.added.length +
+        n.enriched.length +
+        n.merged.length +
+        n.linked.length +
+        n.superseded.length +
+        n.retracted.length +
+        n.rewritten.length >
+        0)
         .sort((x, y) => (x.date < y.date ? -1 : x.date > y.date ? 1 : 0));
     return { status: 200, body: { nights: sorted } };
 }

package/dist/db.js

@@ -652,6 +652,22 @@ const MIGRATIONS = [
          WHERE importance_scored_at IS NULL AND base_strength != 0.5`);
         },
     },
+    {
+        version: 20,
+        name: "add_promotion_last_count",
+        up: (db) => {
+            // #448 — promotion baseline: the access_count the nightly promotion
+            // stage (stagePromotion) last consumed. Backfilled to access_count so
+            // the first post-upgrade nightly does not replay lifetime counts as
+            // promotions (v19 backfill precedent). Written by the stage, this
+            // backfill, and dedup merges (the baseline moves with the summed
+            // counter). Idempotent via hasColumn (the v8 pattern).
+            if (!hasColumn(db, "memories", "promotion_last_count")) {
+                db.exec("ALTER TABLE memories ADD COLUMN promotion_last_count INTEGER");
+            }
+            db.exec("UPDATE memories SET promotion_last_count = access_count WHERE promotion_last_count IS NULL");
+        },
+    },
 ];
 /**
  * Run all pending migrations against the database.

package/dist/dedup.js

@@ -347,7 +347,9 @@ function mergeCluster(db, canonical, losers, injectFailure) {
         clearLoserTags.run(loser.id);
         storage.updateMemory(db, loser.id, { domain: null });
     }
-    // 5. Merge counters onto the canonical.
+    // 5. Merge counters onto the canonical. promotion_last_count moves WITH the
+    // summed access_count (#448): a held baseline would replay the losers'
+    // lifetime accesses as fresh promotions on the next nightly run.
     const accessCount = canonical.access_count + losers.reduce((s, l) => s + l.access_count, 0);
     const shownCount = (canonical.shown_count ?? 0) + losers.reduce((s, l) => s + (l.shown_count ?? 0), 0);
     const lastAccessed = [canonical, ...losers]
@@ -361,6 +363,7 @@ function mergeCluster(db, canonical, losers, injectFailure) {
         shown_count: shownCount,
         ...(lastAccessed ? { last_accessed: lastAccessed } : {}),
         base_strength: baseStrength,
+        promotion_last_count: accessCount,
     });
     injectFailure?.(canonical.id);
     // 6. Audit trail (dedup_log is the merge record — and the only surviving

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

@@ -50,8 +50,7 @@ export declare function runPruneDryRun(db: Database.Database, decayHalfLifeDays?
  * with `importance` defaulting to `base_strength` (retrieval.ts). A memory
  * can EVER cross the prune floor (0.01, stageDecayPrune) only if that
  * asymptote is itself below it: base_strength² * 0.1 < 0.01, i.e.
- * base_strength < sqrt(0.1). Independent of access/link hardening — those
- * only slow the approach, they never raise the floor.
+ * base_strength < sqrt(0.1).
  */
 export declare const EVER_PRUNABLE_BASE_STRENGTH_CEILING: number;
 export declare function histogram(values: number[], edges?: number[]): Record<string, number>;
@@ -67,7 +66,7 @@ export interface StructuralStrengthStats {
 }
 /**
  * Compute effective-strength distributions now, and simulated further out
- * (same access/link counts, decay continuing with no further access — the
+ * (decay continuing with no further access or promotion — the
  * "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).

package/dist/eval/decay-eval.js

@@ -11,39 +11,6 @@
  *                             floor, now vs simulated further out
  *   (d) adoption            — #192 shown_count/access_count signal quality
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVER_PRUNABLE_BASE_STRENGTH_CEILING = void 0;
 exports.runDomainBacklogAudit = runDomainBacklogAudit;
@@ -53,7 +20,6 @@ exports.runStructuralStrengthStats = runStructuralStrengthStats;
 exports.runAdoptionStats = runAdoptionStats;
 const retrieval_js_1 = require("../retrieval.js");
 const consolidate_js_1 = require("../consolidate.js");
-const storage = __importStar(require("../storage.js"));
 const state_js_1 = require("../state.js");
 /**
  * Partition NULL-domain memories by the `domainCursor` rowid watermark.
@@ -106,8 +72,7 @@ function runPruneDryRun(db, decayHalfLifeDays = retrieval_js_1.DEFAULT_DECAY_HAL
  * with `importance` defaulting to `base_strength` (retrieval.ts). A memory
  * can EVER cross the prune floor (0.01, stageDecayPrune) only if that
  * asymptote is itself below it: base_strength² * 0.1 < 0.01, i.e.
- * base_strength < sqrt(0.1). Independent of access/link hardening — those
- * only slow the approach, they never raise the floor.
+ * base_strength < sqrt(0.1).
  */
 exports.EVER_PRUNABLE_BASE_STRENGTH_CEILING = Math.sqrt(0.1);
 const STRENGTH_BUCKET_EDGES = [0, 0.01, 0.05, 0.1, 0.2, 0.3, 0.5, 0.7, 1.0];
@@ -128,16 +93,15 @@ function histogram(values, edges = STRENGTH_BUCKET_EDGES) {
 }
 /**
  * Compute effective-strength distributions now, and simulated further out
- * (same access/link counts, decay continuing with no further access — the
+ * (decay continuing with no further access or promotion — the
  * "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).
  */
 function runStructuralStrengthStats(db) {
     const rows = db
-        .prepare("SELECT id, base_strength, last_accessed, access_count FROM memories")
+        .prepare("SELECT id, base_strength, last_accessed FROM memories")
         .all();
-    const linkCounts = storage.getAllLinkCounts(db);
     const now = new Date();
     const nowVals = [];
     const at180 = [];
@@ -148,11 +112,9 @@ function runStructuralStrengthStats(db) {
         const base = r.base_strength ?? 0.5;
         if (base < exports.EVER_PRUNABLE_BASE_STRENGTH_CEILING)
             everPrunable++;
-        const linkCount = linkCounts.get(r.id) ?? 0;
-        const opts = { accessCount: r.access_count ?? 0, linkCount };
-        nowVals.push((0, retrieval_js_1.effectiveStrength)(base, r.last_accessed, now, opts));
-        at180.push((0, retrieval_js_1.effectiveStrength)(base, r.last_accessed, new Date(now.getTime() + 180 * 86_400_000), opts));
-        at365.push((0, retrieval_js_1.effectiveStrength)(base, r.last_accessed, new Date(now.getTime() + 365 * 86_400_000), opts));
+        nowVals.push((0, retrieval_js_1.effectiveStrength)(base, r.last_accessed, now));
+        at180.push((0, retrieval_js_1.effectiveStrength)(base, r.last_accessed, new Date(now.getTime() + 180 * 86_400_000)));
+        at365.push((0, retrieval_js_1.effectiveStrength)(base, r.last_accessed, new Date(now.getTime() + 365 * 86_400_000)));
         neverVals.push(base * base * 0.1);
     }
     return {

package/dist/eval/ranking-eval.js

@@ -86,7 +86,7 @@ const ranking_battery_js_1 = require("./ranking-battery.js");
 const DEFAULT_PHOTO_PATH = (0, node_path_1.join)(process.cwd(), "data", "ranking-eval-photo.json");
 /** Battery gate thresholds (sweep protocol, issue #425 commit-3 gates). */
 const BATTERY_TOP1_STABILITY_MIN = 0.9;
-/** Plant one fixture corpus into a writable DB with its hardened metadata. */
+/** Plant one fixture corpus into a writable DB with its seeded strength metadata. */
 async function plantRankingFixture(db, fixture) {
     const idByKey = new Map();
     const now = Date.now();

package/dist/eval/ranking-fixtures.d.ts

@@ -5,7 +5,7 @@
  * issue (the owner's live console test, 2026-09-13): a user searches a
  * DISTINCTIVE PROPER NOUN they know exists; the one memory carrying that
  * token has the best similarity of all candidates AND the literal FTS hit,
- * yet ranks behind hardened but less-relevant memories that win on
+ * yet ranks behind high-strength but less-relevant memories that win on
  * effective strength + graph connections.
  *
  *   (a) sirnas_exact_match — the AC1 fixture: a low-strength, unlinked,
@@ -25,9 +25,9 @@
  *  - The texts are synthetic and generic (this package publishes to npm —
  *    no real infrastructure, people, or fleet detail), but SHAPED like the
  *    field failure: the proper noun is invented (it must appear nowhere
- *    else — verified by an invariant test), the rivals are hardened with
- *    metadata the production pipeline itself writes (base strength, access
- *    hardening, link counts).
+ *    else — verified by an invariant test), the rivals carry the metadata
+ *    the production pipeline itself writes (base strength, access history,
+ *    link counts).
  *  - Similarities are MEASURED at run time with the real bge-small-en-v1.5
  *    embedder (ranking-eval.ts) — never asserted into existence. The
  *    declared expectation is about ORDER under the shipped ranking, and
@@ -46,7 +46,7 @@ export interface RankingRow {
     memoryType: string;
     /** Birth base_strength — the value stageImportance would have written. */
     baseStrength: number;
-    /** Access history (hardening + the decay clock). */
+    /** Access history (the decay clock + the #448 promotion baseline). */
     accessCount: number;
     /** Days before the run's `now` of the last access (0 = touched today). */
     lastAccessedDaysAgo: number;

package/dist/eval/ranking-fixtures.js

@@ -6,7 +6,7 @@
  * issue (the owner's live console test, 2026-09-13): a user searches a
  * DISTINCTIVE PROPER NOUN they know exists; the one memory carrying that
  * token has the best similarity of all candidates AND the literal FTS hit,
- * yet ranks behind hardened but less-relevant memories that win on
+ * yet ranks behind high-strength but less-relevant memories that win on
  * effective strength + graph connections.
  *
  *   (a) sirnas_exact_match — the AC1 fixture: a low-strength, unlinked,
@@ -26,9 +26,9 @@
  *  - The texts are synthetic and generic (this package publishes to npm —
  *    no real infrastructure, people, or fleet detail), but SHAPED like the
  *    field failure: the proper noun is invented (it must appear nowhere
- *    else — verified by an invariant test), the rivals are hardened with
- *    metadata the production pipeline itself writes (base strength, access
- *    hardening, link counts).
+ *    else — verified by an invariant test), the rivals carry the metadata
+ *    the production pipeline itself writes (base strength, access history,
+ *    link counts).
  *  - Similarities are MEASURED at run time with the real bge-small-en-v1.5
  *    embedder (ranking-eval.ts) — never asserted into existence. The
  *    declared expectation is about ORDER under the shipped ranking, and
@@ -50,13 +50,13 @@ exports.RANKING_SOURCE_AGENT = "ranking-eval";
 // The target mirrors the field case's SHAPE with invented names: a home
 // harbour memory carrying one distinctive proper noun, born weak (base 0.35,
 // the "routine-but-curated" band), never accessed, unlinked, a few months
-// old. The rivals are what the decay model produces for early-hardened
+// old. The rivals are what the decay model produces for early high-strength
 // technical rows: base 0.90-0.95, mutual links, access history, created
 // BEFORE the target. They share the harbour/boating domain vocabulary — so
 // a bare proper-noun query lands in their neighborhood — but none carries
 // the proper noun.
 const SIRNAS_ROWS = [
-    // --- rivals: hardened, connected, older, domain-adjacent ---
+    // --- rivals: high-strength, connected, older, domain-adjacent ---
     {
         key: "rival_fees",
         content: "Harbour fees and guest dock rules: pay at the machine by the fuel quay, electricity on the guest dock is metered, " +
@@ -158,7 +158,7 @@ const SIRNAS_ROWS = [
 exports.SIRNAS_FIXTURE = {
     key: "sirnas_exact_match",
     description: "AC1: a distinctive proper-noun query must rank the exact-match (both-channel) memory first, " +
-        "ahead of hardened domain-adjacent rivals that win on strength + connections.",
+        "ahead of high-strength domain-adjacent rivals that win on strength + connections.",
     rows: SIRNAS_ROWS,
     query: "Vindarsvik",
     distinctiveToken: "vindarsvik",

package/dist/eval/run-eval.js

@@ -93,7 +93,7 @@ function renderDecay(backlog, prune, structural, adoption) {
     lines.push("### Structural strength — who can EVER prune\n");
     lines.push(`A memory can only ever cross the prune floor (effective strength < 0.01) if its asymptote is below that floor: ` +
         `\`base_strength < sqrt(0.1) ≈ ${round(structural.everPrunableCeiling, 4)}\` (floor = base_strength × importance × 0.1, ` +
-        `importance defaults to base_strength — independent of access/link hardening, which only slows the approach).\n`);
+        `importance defaults to base_strength).\n`);
     lines.push(`**Ever-prunable: ${structural.everPrunableCount} / ${structural.totalMemories} (${pct(structural.totalMemories > 0 ? structural.everPrunableCount / structural.totalMemories : 0)})** — everyone else has a strength floor that never drops low enough to prune, no matter how long it goes unaccessed.\n`);
     for (const [label, hist] of [
         ["Effective strength now", structural.effectiveStrengthNowHistogram],

package/dist/graph.d.ts

@@ -103,8 +103,7 @@ export interface ExportGraphOptions {
  * Nodes are ranked by effective (decayed) strength and capped at `limit`.
  * Edges include only links where BOTH endpoints made the cut.
  * Link counts come from one aggregate query over memory_links (no per-row
- * queries) and feed both the effectiveStrength hardening term and the
- * per-node linkCount field.
+ * queries) and feed the per-node linkCount field.
  */
 export declare function exportGraph(db: Database.Database, options?: ExportGraphOptions): VizGraph;
 export declare function shortestPath(db: Database.Database, fromId: string, toId: string, maxDepth?: number): string[] | null;

package/dist/graph.js

@@ -232,8 +232,7 @@ function makeLabel(content) {
  * Nodes are ranked by effective (decayed) strength and capped at `limit`.
  * Edges include only links where BOTH endpoints made the cut.
  * Link counts come from one aggregate query over memory_links (no per-row
- * queries) and feed both the effectiveStrength hardening term and the
- * per-node linkCount field.
+ * queries) and feed the per-node linkCount field.
  */
 function exportGraph(db, options = {}) {
     const limit = Math.min(Math.max(Math.floor(options.limit ?? exports.EXPORT_DEFAULT_LIMIT), 1), exports.EXPORT_MAX_LIMIT);
@@ -249,7 +248,7 @@ function exportGraph(db, options = {}) {
     const linkCounts = new Map(linkCountRows.map((r) => [r.id, r.cnt]));
     // Candidate memories — domain/type filters pushed into SQL
     let sql = `SELECT id, content, memory_type, domain, project, base_strength,
-            last_accessed, access_count, created_at
+            last_accessed, created_at
      FROM memories`;
     const where = [];
     const params = [];
@@ -275,7 +274,7 @@ function exportGraph(db, options = {}) {
     // Score, filter on effective strength, rank, cap
     const scored = rows.map((row) => {
         const linkCount = linkCounts.get(row.id) ?? 0;
-        const strength = (0, retrieval_js_1.effectiveStrength)(row.base_strength ?? 0.5, row.last_accessed, now, { accessCount: row.access_count ?? 0, linkCount });
+        const strength = (0, retrieval_js_1.effectiveStrength)(row.base_strength ?? 0.5, row.last_accessed, now);
         return { row, strength, linkCount };
     });
     const filtered = options.minStrength !== undefined

package/dist/mcp-server.js

@@ -1548,7 +1548,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

@@ -208,7 +208,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,11 +216,17 @@ 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.