@gamaze/hicortex 0.21.0 → 0.22.1

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,12 +66,14 @@ 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).
+ * `now` (#458): the instant "now" means — pinned by run-eval's --now for
+ * wall-clock-independent before/after audits; default the live clock.
  */
-export declare function runStructuralStrengthStats(db: Database.Database): StructuralStrengthStats;
+export declare function runStructuralStrengthStats(db: Database.Database, now?: Date): StructuralStrengthStats;
 export interface AdoptionStats {
     totalMemories: number;
     shownCountHistogram: Record<string, number>;
@@ -107,4 +108,4 @@ export interface AdoptionStats {
  * feature's youth as much as its effectiveness. Report callers should state
  * that caveat alongside the numbers, not just the numbers.
  */
-export declare function runAdoptionStats(db: Database.Database): AdoptionStats;
+export declare function runAdoptionStats(db: Database.Database, now?: Date): AdoptionStats;

package/dist/eval/decay-eval.js

@@ -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,17 +93,17 @@ 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).
+ * `now` (#458): the instant "now" means — pinned by run-eval's --now for
+ * wall-clock-independent before/after audits; default the live clock.
  */
-function runStructuralStrengthStats(db) {
+function runStructuralStrengthStats(db, now = new Date()) {
     const rows = db
-        .prepare("SELECT id, base_strength, last_accessed, 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 = [];
     const at365 = [];
@@ -148,11 +113,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 {
@@ -185,11 +148,10 @@ function ageBucketLabel(ageDays) {
  * feature's youth as much as its effectiveness. Report callers should state
  * that caveat alongside the numbers, not just the numbers.
  */
-function runAdoptionStats(db) {
+function runAdoptionStats(db, now = new Date()) {
     const rows = db
         .prepare("SELECT id, shown_count, access_count, source_agent, created_at FROM memories")
         .all();
-    const now = new Date();
     const shownVals = [];
     const accessVals = [];
     let totalShown = 0;

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

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

package/dist/eval/eval-clock.js

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

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

@@ -8,6 +8,13 @@
  * corrected cosine formula, #145).
  */
 import type Database from "better-sqlite3";
+/**
+ * Deterministic sample of `rows` (#460): a seeded partial Fisher–Yates
+ * shuffles the LAST `size` slots from the back, and that shuffled tail is
+ * the sample. Rows must already be in a stable order (the caller sorts by
+ * PK) so the draw does not depend on SQLite's scan order.
+ */
+export declare function seededSample<T>(rows: T[], size: number, seed: number): T[];
 export interface LinkRow {
     source_id: string;
     target_id: string;
@@ -50,8 +57,14 @@ export interface DriftReport {
     maxAbsDrift: number;
     skippedMissingEmbedding: number;
 }
-/** Recompute cosine for a random link sample and compare to stored `strength` (post migration-5 rescale, should track closely). */
-export declare function runDriftSample(db: Database.Database, embeddings: Map<string, Float32Array>, sampleSize?: number): DriftReport;
+/**
+ * Recompute cosine for a link sample and compare to stored `strength` (post
+ * migration-5 rescale, should track closely). The sample is deterministic
+ * (#460): all link rows in stable PK order, drawn by a seeded Fisher–Yates —
+ * two runs on the same build + snapshot produce an identical report, so
+ * before/after comparisons can require full-output identity.
+ */
+export declare function runDriftSample(db: Database.Database, embeddings: Map<string, Float32Array>, sampleSize?: number, seed?: number): DriftReport;
 export interface PartitionStats {
     linkCount: number;
     byRelationship: Record<string, number>;