@gamaze/hicortex 0.21.0 → 0.22.0

package/dist/capture-health.d.ts

@@ -17,10 +17,19 @@
  *    `capture_health`: the most recent day with rows, grouped by machine ×
  *    agent (posts / sessions / bytes / held / retried), bytes DESC.
  *
- * Retention: 7 days, pruned inside recordDistillActivity at most ONCE per
- * process per UTC day (in-module memo) — the insert path must not pay a
- * DELETE on every POST. Old rows exist to explain recent nights, nothing
- * else; the durable record of WHAT was captured is the memories themselves.
+ *  - readCaptureHealthWindow(db) — the same grouping over the ROLLING
+ *    capture window (#409 fix round 7, owner ruling 2026-09-14: the card
+ *    shows the normal 30 days like the band's other cards). The newest
+ *    night's rows stay on the payload too (secondary info: the card's
+ *    "tonight" suffix); the window sums are the card's face.
+ *
+ * Retention: CAPTURE_HEALTH_WINDOW_DAYS (30), pruned inside
+ * recordDistillActivity at most ONCE per process per UTC day (in-module
+ * memo) — the insert path must not pay a DELETE on every POST. Retention and
+ * the window aggregate share the ONE constant, so the card can never claim a
+ * window the store no longer has rows for. Old rows exist to feed the card's
+ * rolling window, nothing else; the durable record of WHAT was captured is
+ * the memories themselves.
  */
 import type Database from "better-sqlite3";
 /** A /distill POST outcome. 'held' = the client will retry (cursor held):
@@ -64,6 +73,13 @@ export interface CaptureHealth {
     day: string | null;
     rows: CaptureHealthRow[];
 }
+/** The rolling capture window the console's card shows, in days — ALSO the
+ *  retention horizon for distill_activity (the recorder prunes past it).
+ *  Owner ruling 2026-09-14: the capture card shows the normal 30 day like
+ *  the band's other cards, so the store must retain enough nights to sum
+ *  one. ONE constant feeds both the window aggregate and the prune: the card
+ *  can never claim a window the store no longer has rows for. */
+export declare const CAPTURE_HEALTH_WINDOW_DAYS = 30;
 /** Test-only: re-arm the once-per-day prune memo. The memo is deliberately
  *  process-global (production must not DELETE per insert); the test suite
  *  needs it fresh per case. Exported for testability, same precedent as
@@ -75,7 +91,8 @@ export declare function resetDistillPruneMemoForTests(): void;
  * COALESCE(segment_id, '') so legacy whole-session POSTs — no segment_id —
  * retry-match on the empty key). A NULL session_id never matches anything:
  * without a session id the POST has no identity to be a retry OF. Also prunes
- * rows older than 7 days, at most once per process per UTC day.
+ * rows outside the rolling capture window (CAPTURE_HEALTH_WINDOW_DAYS), at
+ * most once per process per UTC day.
  */
 export declare function recordDistillActivity(db: Database.Database, entry: DistillActivityEntry): void;
 /**
@@ -85,3 +102,23 @@ export declare function recordDistillActivity(db: Database.Database, entry: Dist
  * ids don't count (no identity). Sorted bytes DESC (the card's bar scale).
  */
 export declare function readCaptureHealth(db: Database.Database): CaptureHealth;
+/** The /dashboard/data capture_health window block: the echoed window length
+ *  + the per machine × agent rows over it. Field names are the WIRE keys —
+ *  dashboard.ts spreads this over the newest-night shape, so the keys must
+ *  not collide with {day, rows}. window_rows=[] when the window is empty
+ *  (fresh install, static snapshot without activity rows — the page keeps its
+ *  counts fallback). */
+export interface CaptureHealthWindow {
+    window_days: number;
+    window_rows: CaptureHealthRow[];
+}
+/**
+ * Aggregate the ROLLING capture window (CAPTURE_HEALTH_WINDOW_DAYS calendar
+ * days, today inclusive) into per machine × agent bundles — the card's face
+ * (#409 fix round 7: the band's other cards are all 30-day; the newest night
+ * moves to secondary info). Same shape as readCaptureHealth's rows, but
+ * summed across nights: sessions stays COUNT(DISTINCT session_id), so a
+ * session retried on a later night counts once (identity, not occurrences).
+ * Sorted bytes DESC (the card's bar scale).
+ */
+export declare function readCaptureHealthWindow(db: Database.Database): CaptureHealthWindow;

package/dist/capture-health.js

@@ -18,20 +18,43 @@
  *    `capture_health`: the most recent day with rows, grouped by machine ×
  *    agent (posts / sessions / bytes / held / retried), bytes DESC.
  *
- * Retention: 7 days, pruned inside recordDistillActivity at most ONCE per
- * process per UTC day (in-module memo) — the insert path must not pay a
- * DELETE on every POST. Old rows exist to explain recent nights, nothing
- * else; the durable record of WHAT was captured is the memories themselves.
+ *  - readCaptureHealthWindow(db) — the same grouping over the ROLLING
+ *    capture window (#409 fix round 7, owner ruling 2026-09-14: the card
+ *    shows the normal 30 days like the band's other cards). The newest
+ *    night's rows stay on the payload too (secondary info: the card's
+ *    "tonight" suffix); the window sums are the card's face.
+ *
+ * Retention: CAPTURE_HEALTH_WINDOW_DAYS (30), pruned inside
+ * recordDistillActivity at most ONCE per process per UTC day (in-module
+ * memo) — the insert path must not pay a DELETE on every POST. Retention and
+ * the window aggregate share the ONE constant, so the card can never claim a
+ * window the store no longer has rows for. Old rows exist to feed the card's
+ * rolling window, nothing else; the durable record of WHAT was captured is
+ * the memories themselves.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPTURE_HEALTH_WINDOW_DAYS = void 0;
 exports.resetDistillPruneMemoForTests = resetDistillPruneMemoForTests;
 exports.recordDistillActivity = recordDistillActivity;
 exports.readCaptureHealth = readCaptureHealth;
+exports.readCaptureHealthWindow = readCaptureHealthWindow;
 const storage_js_1 = require("./storage.js");
 /** Once-per-process-per-UTC-day prune memo (see module doc). The UTC day of
  *  the last insert that ran the DELETE. Tests reset it because vitest runs
  *  every suite in ONE process — see resetDistillPruneMemoForTests. */
 let lastPruneDay = null;
+/** The rolling capture window the console's card shows, in days — ALSO the
+ *  retention horizon for distill_activity (the recorder prunes past it).
+ *  Owner ruling 2026-09-14: the capture card shows the normal 30 day like
+ *  the band's other cards, so the store must retain enough nights to sum
+ *  one. ONE constant feeds both the window aggregate and the prune: the card
+ *  can never claim a window the store no longer has rows for. */
+exports.CAPTURE_HEALTH_WINDOW_DAYS = 30;
+/** Inclusive window cutoff as SQL: day >= today−(N−1) — the last N calendar
+ *  days with today counted (the same inclusive convention as
+ *  /dashboard/events' days param). The prune keeps exactly this predicate's
+ *  complement (day < cutoff is deleted), so retained rows == window rows. */
+const WINDOW_CUTOFF_SQL = `date('now', '-${exports.CAPTURE_HEALTH_WINDOW_DAYS - 1} days')`;
 /** Test-only: re-arm the once-per-day prune memo. The memo is deliberately
  *  process-global (production must not DELETE per insert); the test suite
  *  needs it fresh per case. Exported for testability, same precedent as
@@ -52,7 +75,8 @@ function optString(v) {
  * COALESCE(segment_id, '') so legacy whole-session POSTs — no segment_id —
  * retry-match on the empty key). A NULL session_id never matches anything:
  * without a session id the POST has no identity to be a retry OF. Also prunes
- * rows older than 7 days, at most once per process per UTC day.
+ * rows outside the rolling capture window (CAPTURE_HEALTH_WINDOW_DAYS), at
+ * most once per process per UTC day.
  */
 function recordDistillActivity(db, entry) {
     const ts = entry.ts ?? new Date().toISOString();
@@ -72,9 +96,11 @@ function recordDistillActivity(db, entry) {
     db.prepare(`INSERT INTO distill_activity (ts, day, machine, agent, session_id, segment_id, bytes, outcome, retried)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(ts, day, (0, storage_js_1.sanitizeSourceMachine)(entry.machine) ?? "", optString(entry.agent) ?? "unknown", sessionId, segmentId, entry.bytes, entry.outcome, retried);
     // Prune, at most once per process per UTC day. Runs AFTER the insert so the
-    // triggering row is subject to the same window as everything else.
+    // triggering row is subject to the same window as everything else. The
+    // cutoff is the capture window's own edge — retention keeps exactly the
+    // nights the card's rolling view sums (see CAPTURE_HEALTH_WINDOW_DAYS).
     if (lastPruneDay !== day) {
-        db.prepare("DELETE FROM distill_activity WHERE day < date('now', '-7 days')").run();
+        db.prepare(`DELETE FROM distill_activity WHERE day < ${WINDOW_CUTOFF_SQL}`).run();
         lastPruneDay = day;
     }
 }
@@ -104,3 +130,27 @@ function readCaptureHealth(db) {
         .all(dayRow.day);
     return { day: dayRow.day, rows };
 }
+/**
+ * Aggregate the ROLLING capture window (CAPTURE_HEALTH_WINDOW_DAYS calendar
+ * days, today inclusive) into per machine × agent bundles — the card's face
+ * (#409 fix round 7: the band's other cards are all 30-day; the newest night
+ * moves to secondary info). Same shape as readCaptureHealth's rows, but
+ * summed across nights: sessions stays COUNT(DISTINCT session_id), so a
+ * session retried on a later night counts once (identity, not occurrences).
+ * Sorted bytes DESC (the card's bar scale).
+ */
+function readCaptureHealthWindow(db) {
+    const rows = db
+        .prepare(`SELECT machine, agent,
+              COUNT(*) AS posts,
+              COUNT(DISTINCT session_id) AS sessions,
+              COALESCE(SUM(bytes), 0) AS bytes,
+              COALESCE(SUM(outcome = 'held'), 0) AS held,
+              COALESCE(SUM(retried), 0) AS retried
+         FROM distill_activity
+        WHERE day >= ${WINDOW_CUTOFF_SQL}
+        GROUP BY machine, agent
+        ORDER BY bytes DESC`)
+        .all();
+    return { window_days: exports.CAPTURE_HEALTH_WINDOW_DAYS, window_rows: rows };
+}

package/dist/capture-pause.d.ts

@@ -22,9 +22,11 @@
  * /recall-index, /memory) carries no agent/machine identity on the wire, so
  * attributing it would need new client fields — the heartbeats the spec
  * forbids. Thresholds (green ≤36h — a nightly poster reads online through
- * the following day; amber ≤7d — the distill_activity retention window; none
- * beyond or with no rows) are page-side presentation; this module just
- * reports the newest ts per bundle.
+ * the following day; amber ≤7d; none beyond or with no rows) are page-side
+ * presentation; this module just reports the newest ts per bundle. (Amber's
+ * 7d predates and outlives the old 7-day retention — activity rows are now
+ * kept for the capture card's 30-day window, CAPTURE_HEALTH_WINDOW_DAYS;
+ * the dot's thresholds are a design choice, not a retention artifact.)
  *
  * Pure, unit-testable without express (the capture-health.ts layering):
  * mcp-server.ts and dashboard.ts wire these functions to the live db.
@@ -81,6 +83,7 @@ export declare function listCapturePauses(db: Database.Database): CapturePause[]
  * MAX(ts) with that latest row's outcome, derive the harness per agent, then
  * merge same-bundle agents keeping the newest ts (one dot per bundle, not
  * per profile). Reads only distill_activity, which the recorder prunes to
- * 7 days — older-than-window bundles simply have no rows and no dot.
+ * the capture card's rolling window (CAPTURE_HEALTH_WINDOW_DAYS) —
+ * older-than-window bundles simply have no rows and no dot.
  */
 export declare function readFleetLastSeen(db: Database.Database): FleetLastSeen[];

package/dist/capture-pause.js

@@ -23,9 +23,11 @@
  * /recall-index, /memory) carries no agent/machine identity on the wire, so
  * attributing it would need new client fields — the heartbeats the spec
  * forbids. Thresholds (green ≤36h — a nightly poster reads online through
- * the following day; amber ≤7d — the distill_activity retention window; none
- * beyond or with no rows) are page-side presentation; this module just
- * reports the newest ts per bundle.
+ * the following day; amber ≤7d; none beyond or with no rows) are page-side
+ * presentation; this module just reports the newest ts per bundle. (Amber's
+ * 7d predates and outlives the old 7-day retention — activity rows are now
+ * kept for the capture card's 30-day window, CAPTURE_HEALTH_WINDOW_DAYS;
+ * the dot's thresholds are a design choice, not a retention artifact.)
  *
  * Pure, unit-testable without express (the capture-health.ts layering):
  * mcp-server.ts and dashboard.ts wire these functions to the live db.
@@ -97,7 +99,8 @@ function listCapturePauses(db) {
  * MAX(ts) with that latest row's outcome, derive the harness per agent, then
  * merge same-bundle agents keeping the newest ts (one dot per bundle, not
  * per profile). Reads only distill_activity, which the recorder prunes to
- * 7 days — older-than-window bundles simply have no rows and no dot.
+ * the capture card's rolling window (CAPTURE_HEALTH_WINDOW_DAYS) —
+ * older-than-window bundles simply have no rows and no dot.
  */
 function readFleetLastSeen(db) {
     const rows = db

package/dist/consolidate.d.ts

@@ -328,6 +328,25 @@ export declare function stageDecayPrune(db: Database.Database, dryRun: boolean):
     pruned: number;
     failed: number;
 };
+/**
+ * ONE application of the #448 promotion formula:
+ * `S + PROMOTION_RATE × (1 − S / IMPORTANCE_CEILING) × S^(−0.3)`, clamped at
+ * the ceiling. Pure + exported for exact-value tests; the stage applies it
+ * iterated once per new use — iteration is what makes the ceiling asymptotic
+ * (a count-sized single shot would overshoot it).
+ *
+ * The formula's S input is floored at PROMOTION_STRENGTH_FLOOR (#453 review,
+ * owner decision 2026-09-16): S^(−0.3) has a zero-singularity, and a writable
+ * base_strength of 0.0 would otherwise leap to the ceiling via Infinity→clamp
+ * on a single access. The floor bounds the first boost at ≈+0.13; it clamps
+ * the INPUT only — the stored 0.0 row is not rewritten, and the promoted
+ * result is nonzero from then on.
+ */
+export declare function applyStrengthPromotion(baseStrength: number): number;
+export declare function stagePromotion(db: Database.Database, dryRun: boolean): {
+    promoted: number;
+    demoted_skipped: number;
+};
 /**
  * Default soft cap on the memory corpus (#245). Above this the lowest-value
  * memories are evicted each nightly. 10000 balances headroom for a busy

package/dist/consolidate.js

@@ -54,6 +54,8 @@ exports.buildSupersessionPrompt = buildSupersessionPrompt;
 exports.parseSupersessionReply = parseSupersessionReply;
 exports.stageSupersession = stageSupersession;
 exports.stageDecayPrune = stageDecayPrune;
+exports.applyStrengthPromotion = applyStrengthPromotion;
+exports.stagePromotion = stagePromotion;
 exports.resolveMemorySoftCap = resolveMemorySoftCap;
 exports.stageMemoryCapEviction = stageMemoryCapEviction;
 exports.runConsolidation = runConsolidation;
@@ -1018,37 +1020,6 @@ function classifyRelationship(source, target, similarity) {
     return "relates_to";
 }
 // ---------------------------------------------------------------------------
-// Stage 3.5: Hub Detection & Strength Boost
-// ---------------------------------------------------------------------------
-const HUB_BOOST = 0.1;
-// #425: the release-managed importance ceiling (calibration.ts) — hub boosts
-// can no longer push a row to base 1.0 (decay rate exactly 1.0 = immortal).
-const HUB_STRENGTH_CAP = CALIBRATION.IMPORTANCE_CEILING;
-function stageHubBoost(db, dryRun) {
-    const hubs = (0, graph_js_1.detectHubs)(db);
-    if (hubs.length === 0)
-        return { hubs_found: 0, boosted: 0 };
-    let boosted = 0;
-    if (!dryRun) {
-        const stmt = db.prepare("UPDATE memories SET base_strength = MIN(?, base_strength + ?) WHERE id = ? AND base_strength < ?");
-        const tx = db.transaction(() => {
-            for (const hub of hubs) {
-                const result = stmt.run(HUB_STRENGTH_CAP, HUB_BOOST, hub.id, HUB_STRENGTH_CAP);
-                if (result.changes > 0)
-                    boosted++;
-            }
-        });
-        tx();
-    }
-    else {
-        boosted = hubs.length;
-    }
-    if (hubs.length > 0) {
-        console.log(`[hicortex] Hub detection: ${hubs.length} hubs found, ${boosted} boosted (+${HUB_BOOST})`);
-    }
-    return { hubs_found: hubs.length, boosted };
-}
-// ---------------------------------------------------------------------------
 // Stage 3.7: Supersession Detection (#191 Phase B)
 // ---------------------------------------------------------------------------
 //
@@ -1327,16 +1298,11 @@ function stageDecayPrune(db, dryRun) {
     const now = new Date();
     const cutoff = new Date(now.getTime() - CONSOLIDATE_PRUNE_MIN_AGE_DAYS * 24 * 60 * 60 * 1000);
     const oldUnaccessed = storage.getPruneCandidates(db, cutoff.toISOString());
-    const linkCounts = storage.getAllLinkCounts(db);
     let candidates = 0;
     let pruned = 0;
     let failed = 0;
     for (const mem of oldUnaccessed) {
-        const memLinkCount = linkCounts.get(mem.id) ?? 0;
-        const eff = (0, retrieval_js_1.effectiveStrength)(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: 0,
-            linkCount: memLinkCount,
-        });
+        const eff = (0, retrieval_js_1.effectiveStrength)(mem.base_strength ?? 0.5, mem.last_accessed, now);
         if (eff >= 0.01)
             continue;
         candidates++;
@@ -1353,6 +1319,103 @@ function stageDecayPrune(db, dryRun) {
     return { candidates, pruned, failed };
 }
 // ---------------------------------------------------------------------------
+// Stage: Strength promotion (#448) — the strength model's upward path
+// ---------------------------------------------------------------------------
+//
+// Real use of a memory (a surfaced /search or /recent hit, a hicortex_get)
+// bumps access_count (storage.strengthenMemory). This stage converts that use
+// signal into STRENGTH: every run, each memory whose access_count exceeds its
+// stored baseline (promotion_last_count, migration v20 — backfilled to
+// access_count at upgrade so lifetime counts are never replayed) is promoted
+// once per new use by the calibration formula, capped at the importance
+// ceiling. Decay stays untouched and uniform (#448 removed the hardening
+// terms) — promotion is the only way use raises a score.
+//
+// Deterministic (zero LLM) and idempotent: the baseline advances to
+// access_count in the same write, so a delta-less night is a no-op and a
+// crashed run replays exactly the unconsumed delta. The demotion set
+// (findDemotedIds: superseded/retracted rows + superseded_by-link sources)
+// plus status 'absorbed' rows (named explicitly — findDemotedIds excludes
+// them by design; they are filtered at candidacy elsewhere, but this stage
+// reads the memories table directly) get NO bump — hidden evidence must not
+// rise — but their baseline still advances, so a later un-mark never replays
+// a stale delta.
+/**
+ * ONE application of the #448 promotion formula:
+ * `S + PROMOTION_RATE × (1 − S / IMPORTANCE_CEILING) × S^(−0.3)`, clamped at
+ * the ceiling. Pure + exported for exact-value tests; the stage applies it
+ * iterated once per new use — iteration is what makes the ceiling asymptotic
+ * (a count-sized single shot would overshoot it).
+ *
+ * The formula's S input is floored at PROMOTION_STRENGTH_FLOOR (#453 review,
+ * owner decision 2026-09-16): S^(−0.3) has a zero-singularity, and a writable
+ * base_strength of 0.0 would otherwise leap to the ceiling via Infinity→clamp
+ * on a single access. The floor bounds the first boost at ≈+0.13; it clamps
+ * the INPUT only — the stored 0.0 row is not rewritten, and the promoted
+ * result is nonzero from then on.
+ */
+function applyStrengthPromotion(baseStrength) {
+    const s = Math.max(baseStrength, CALIBRATION.PROMOTION_STRENGTH_FLOOR);
+    return Math.min(s +
+        CALIBRATION.PROMOTION_RATE *
+            (1 - s / CALIBRATION.IMPORTANCE_CEILING) *
+            Math.pow(s, -0.3), CALIBRATION.IMPORTANCE_CEILING);
+}
+function stagePromotion(db, dryRun) {
+    // Candidates: rows with at least one use since their stored baseline.
+    // COALESCE treats a NULL baseline as 0 — dup-over-loss: an unknown baseline
+    // promotes once, a held one never forgets a use.
+    const rows = db
+        .prepare(`SELECT id, base_strength, access_count, status,
+              access_count - COALESCE(promotion_last_count, 0) AS delta
+         FROM memories
+        WHERE access_count > COALESCE(promotion_last_count, 0)`)
+        .all();
+    if (rows.length === 0)
+        return { promoted: 0, demoted_skipped: 0 };
+    const demoted = (0, retrieval_js_1.findDemotedIds)(db, rows.map((r) => r.id));
+    let promoted = 0;
+    let demotedSkipped = 0;
+    const writes = [];
+    for (const row of rows) {
+        const accessCount = row.access_count ?? 0;
+        // Absorbed rows are invisible to recall but sit in the memories table —
+        // they are demotion-set members this query CAN see (findDemotedIds
+        // deliberately excludes them), so name them here.
+        if (demoted.has(row.id) || row.status === "absorbed") {
+            demotedSkipped++;
+            writes.push({ id: row.id, fields: { promotion_last_count: accessCount } });
+            continue;
+        }
+        // base_strength is NOT NULL after scoring; the `?? 0.5` mirrors
+        // stageDecayPrune's defensive default for unscored rows (inserts at 0.5).
+        let strength = row.base_strength ?? 0.5;
+        for (let i = 0; i < row.delta; i++)
+            strength = applyStrengthPromotion(strength);
+        promoted++;
+        writes.push({
+            id: row.id,
+            fields: { base_strength: strength, promotion_last_count: accessCount },
+        });
+    }
+    if (dryRun) {
+        console.log(`[hicortex] Strength promotion (dry-run): would promote ${promoted} memories ` +
+            `(${demotedSkipped} demotion-set rows advance their baseline only).`);
+        return { promoted, demoted_skipped: demotedSkipped };
+    }
+    // One transaction for the whole stage (the stageMemoryCapEviction pattern):
+    // strength + baseline move together or not at all — a baseline that
+    // advanced without its bump (or vice versa) would lose or replay a use.
+    const tx = db.transaction(() => {
+        for (const w of writes)
+            storage.updateMemory(db, w.id, w.fields);
+    });
+    tx();
+    console.log(`[hicortex] Strength promotion: promoted ${promoted} memories ` +
+        `(${demotedSkipped} demotion-set rows advance their baseline only).`);
+    return { promoted, demoted_skipped: demotedSkipped };
+}
+// ---------------------------------------------------------------------------
 // Stage 4.5: Memory cap eviction (#245)
 // ---------------------------------------------------------------------------
 //
@@ -1365,10 +1428,13 @@ function stageDecayPrune(db, dryRun) {
 //
 // Eviction reuses the SAME effectiveStrength() the recall ranker uses — no
 // formula duplication, so the eviction criterion cannot drift from what
-// surfaces in the top-k. The evicted tail is, by construction, the tail that
-// was not surfacing anyway (cold, decayed). Ties are broken by oldest
-// COALESCE(last_accessed, created_at) — i.e. the memories that have gone
-// longest without anyone looking at them.
+// surfaces in the top-k. #448: the ordering is base + recency ONLY (the
+// access/link hardening terms are gone), and a row used since the last run
+// was promoted by stagePromotion earlier in the SAME run — a promoted row
+// survives a cap it would otherwise have lost. The evicted tail is, by
+// construction, the tail that was not surfacing anyway (cold, decayed). Ties
+// are broken by oldest COALESCE(last_accessed, created_at) — i.e. the
+// memories that have gone longest without anyone looking at them.
 //
 // `cap = 0` disables the stage (indefinite growth — the pre-#245 default is
 // preserved opt-out). The JS-side sort is O(n log n); at 10K memories the
@@ -1440,19 +1506,15 @@ function stageMemoryCapEviction(db, dryRun, cap) {
     // never-shown memories sort by when they entered the corpus. Same
     // non-absorbed predicate as the count above.
     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 linkCounts = storage.getAllLinkCounts(db);
     const now = new Date();
     // Decorate + sort: lowest effectiveStrength first; ties broken by oldest
     // COALESCE(last_accessed, created_at). The victims are the first `surplus`.
     const decorated = rows.map((r) => {
-        const eff = (0, retrieval_js_1.effectiveStrength)(r.base_strength ?? 0.5, r.last_accessed, now, {
-            accessCount: r.access_count ?? 0,
-            linkCount: linkCounts.get(r.id) ?? 0,
-        });
+        const eff = (0, retrieval_js_1.effectiveStrength)(r.base_strength ?? 0.5, r.last_accessed, now);
         return {
             id: r.id,
             eff,
@@ -1617,6 +1679,13 @@ deadline) {
         new_memory_count: precheck.newMemories.length,
         unscored_count: scoreMemories.length - precheck.newMemories.length,
     };
+    // Strength promotion (#448) — runs in the pre-skip deterministic zone, in
+    // the same placement discipline as memory_cap BELOW it: accesses happen on
+    // quiet nights too (no new memories must still promote the day's uses),
+    // and a used row must be promoted BEFORE eviction victims are chosen (a
+    // promoted row survives a cap it would otherwise lose). Zero LLM — it sits
+    // before the BudgetTracker exists, ungated by budget and deadline.
+    report.stages.promotion = stagePromotion(db, dryRun);
     // Memory cap eviction (#245) — runs BEFORE the precheck skip so the corpus
     // is bounded even on quiet nights (no new memories → precheck would skip,
     // but the cap stage is pure DB: cheap, idempotent when under cap).
@@ -1689,10 +1758,6 @@ deadline) {
         if (!deadline?.hit("links")) {
             report.stages.links = await stageLinks(db, precheck.newMemories, embedFn, dryRun, llm, budget);
         }
-        // Stage 3.5: Hub Detection — boost highly-connected memories
-        if (!deadline?.hit("hub_boost")) {
-            report.stages.hub_boost = stageHubBoost(db, dryRun);
-        }
         // Stage 3.7: Supersession Detection (#191 Phase B)
         if (!deadline?.hit("supersession")) {
             report.stages.supersession = await stageSupersession(db, llm, budget, embedFn, dryRun, stateDir, { ...supersessionOptions, deadline });

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;