@gamaze/hicortex 0.20.10 → 0.22.0

package/dist/dashboard.d.ts

@@ -22,6 +22,7 @@
  */
 import type express from "express";
 import type Database from "better-sqlite3";
+import { type CaptureHealthRow } from "./capture-health.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). */
@@ -202,7 +203,7 @@ export interface DashboardData {
             period_start: string | null;
         };
     };
-    range: "7d" | "30d" | "90d" | "all";
+    range: "7d" | "30d" | "90d" | "180d" | "all";
     series: DashboardSnapshot[];
     composition: {
         by_type: Record<string, number>;
@@ -213,22 +214,28 @@ export interface DashboardData {
     };
     /**
      * #422 Phase 2 — capture health: per machine × agent /distill outcome
-     * accounting for the most recent day with rows (posts / sessions / bytes /
-     * held / retried). ALWAYS present; {day: null, rows: []} when nothing is
+     * accounting. ALWAYS present; {day: null, rows: []} when nothing is
      * recorded (fresh install / all rows pruned — the page degrades to the
      * phase-1 counts-only rows).
+     *
+     * #409 fix round 7 (owner ruling 2026-09-14: "the normal 30 day as the
+     * other cards"): `day`/`rows` keep the NEWEST night with rows (secondary
+     * info — the card's "tonight" suffix), while `window_days`/`window_rows`
+     * carry the ROLLING capture window's per machine × agent sums — the card's
+     * face. Both derive from the same distill_activity rows and the same
+     * CAPTURE_HEALTH_WINDOW_DAYS constant (retention == window). window_rows
+     * is [] exactly when rows is (same table) — the counts fallback then still
+     * applies. A pre-round-7 server sends neither window key; the page guards.
      */
     capture_health: {
         day: string | null;
-        rows: Array<{
-            machine: string;
-            agent: string;
-            posts: number;
-            sessions: number;
-            bytes: number;
-            held: number;
-            retried: number;
-        }>;
+        rows: CaptureHealthRow[];
+        /** Echoed window length (the page renders "last N days" from it — never
+         *  hardcoded client-side). */
+        window_days: number;
+        /** Per machine × agent sums over the rolling window (posts / sessions /
+         *  bytes / held / retried), bytes DESC. */
+        window_rows: CaptureHealthRow[];
     };
     /**
      * #423 phase 3 — fleet presence: the operator's capture pauses + per-bundle
@@ -565,7 +572,10 @@ export declare function handleDashboardField(db: Database.Database): {
 export declare function dashboardFieldHandler(getDb: () => Database.Database): express.RequestHandler;
 /** One night of the replay ledger. `by_agent` keys are source_agent strings
  *  ("(unknown)" when the memory row is gone); learned counts added, enriched
- *  counts distinct enriched memories, merged counts dedup losers. */
+ *  counts distinct enriched memories, merged counts dedup losers, and the
+ *  #452 truth-management keys count superseded/retracted sources and
+ *  reconsolidation rewrites (agent = the OLD memory's source — the event
+ *  belongs to the memory that was demoted). */
 export interface DashboardEventsNight {
     date: string;
     added: string[];
@@ -578,10 +588,25 @@ export interface DashboardEventsNight {
         a: string;
         b: string;
     }>;
+    /** #452 — superseded_by links born that night ({old, by} ids). */
+    superseded: Array<{
+        old: string;
+        by: string;
+    }>;
+    /** #452 — corrected_by links whose source is currently status='retracted'. */
+    retracted: Array<{
+        old: string;
+        by: string;
+    }>;
+    /** #452 — distinct memories reconsolidation rewrote that night. */
+    rewritten: string[];
     by_agent: Record<string, {
         learned: number;
         enriched: number;
         merged: number;
+        superseded: number;
+        retracted: number;
+        rewritten: number;
     }>;
 }
 /** The /dashboard/events response. */
@@ -589,9 +614,9 @@ export interface DashboardEvents {
     nights: DashboardEventsNight[];
 }
 /**
- * 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).
  */
 export declare function handleDashboardEvents(db: Database.Database, query: {
     days?: unknown;

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