@gamaze/hicortex 0.21.0 → 0.22.1

package/dist/calibration.js

@@ -24,7 +24,8 @@
  * the removal is never silent.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIAGNOSTIC_ENV_TIER = exports.OLLAMA_FLUSH_WAIT_MS = exports.OLLAMA_FLUSH_EVERY = exports.NUM_CTX = exports.DEFAULT_FIRST_RUN_LOOKBACK_DAYS = exports.ENRICH_STRENGTH_DELTA = exports.STAGE_TRUTH_STRENGTH = exports.STAGE_BELIEF_STRENGTH = exports.STAGE_FADING_STRENGTH = exports.STAGE_FADING_DAYS = exports.WEAK_PRIMARY_FLOOR = exports.CORRECTION_REWRITE_MIN_CONFIDENCE = exports.CORRECTION_MIN_SIMILARITY = exports.SUPERSESSION_MIN_SIMILARITY = exports.DEDUP_AUTO_MERGE_THRESHOLD = exports.IMPORTANCE_CEILING = exports.BM25_WEIGHT_DOMAIN = exports.BM25_WEIGHT_PROJECT = exports.BM25_WEIGHT_BODY = exports.BOTH_CHANNEL_BOOST = exports.RRF_VECTOR_WEIGHT = exports.RRF_FTS_WEIGHT = exports.RRF_COMPOSITE_WEIGHT = exports.RRF_K = exports.DOMAIN_AFFINITY_WEIGHT = exports.PROJECT_AFFINITY_WEIGHT = exports.SUPERSEDED_DEMOTION = exports.FRESHNESS_BOOST_WEIGHT = exports.FRESHNESS_BOOST_DAYS = exports.SCORE_RECENCY_WEIGHT = exports.SCORE_CONNECTIONS_WEIGHT = exports.SCORE_STRENGTH_WEIGHT = exports.SCORE_SIMILARITY_WEIGHT = exports.RECALL_USES_AXIS_MAX = exports.RECALL_USES_NORMAL_MAX = exports.RECALL_USES_LOW_MAX = exports.RECALL_RESHOW_TURNS = exports.NOVELTY_FLOOR_SLOTS = exports.RECALL_TITLE_CHARS = exports.RECALL_MIN_PROMPT_CHARS = exports.RECALL_MAX_ITEMS = exports.RECALL_MIN_SIMILARITY = exports.SESSION_INTENT_WEIGHT = exports.COLD_EXPOSURE_SLOTS = exports.RECENT_WINDOW_DAYS = exports.RECENT_LIMIT = exports.SEARCH_LIMIT = exports.DECAY_HALF_LIFE_DAYS = void 0;
+exports.OLLAMA_FLUSH_WAIT_MS = exports.OLLAMA_FLUSH_EVERY = exports.NUM_CTX = exports.DEFAULT_FIRST_RUN_LOOKBACK_DAYS = exports.ENRICH_STRENGTH_DELTA = exports.STAGE_TRUTH_STRENGTH = exports.STAGE_BELIEF_STRENGTH = exports.STAGE_FADING_STRENGTH = exports.STAGE_FADING_DAYS = exports.WEAK_PRIMARY_FLOOR = exports.CORRECTION_REWRITE_MIN_CONFIDENCE = exports.CORRECTION_MIN_SIMILARITY = exports.SUPERSESSION_MIN_SIMILARITY = exports.DEDUP_AUTO_MERGE_THRESHOLD = exports.IMPORTANCE_CEILING = exports.BM25_WEIGHT_DOMAIN = exports.BM25_WEIGHT_PROJECT = exports.BM25_WEIGHT_BODY = exports.BOTH_CHANNEL_BOOST = exports.RRF_VECTOR_WEIGHT = exports.RRF_FTS_WEIGHT = exports.RRF_COMPOSITE_WEIGHT = exports.RRF_K = exports.SCOPE_AFFINITY_WEIGHT = exports.SUPERSEDED_DEMOTION = exports.RECENCY_HEAD_DAYS = exports.RECENCY_HEAD_WEIGHT = exports.RECENCY_HOURLY_DECAY = exports.SCORE_RECENCY_WEIGHT = exports.CONNECTIONS_SATURATION_DEGREE = exports.SCORE_CONNECTIONS_WEIGHT = exports.SCORE_STRENGTH_WEIGHT = exports.SCORE_SIMILARITY_WEIGHT = exports.RECALL_USES_AXIS_MAX = exports.RECALL_USES_NORMAL_MAX = exports.RECALL_USES_LOW_MAX = exports.RECALL_RESHOW_TURNS = exports.NOVELTY_FLOOR_SLOTS = exports.RECALL_TITLE_CHARS = exports.RECALL_MIN_PROMPT_CHARS = exports.RECALL_MAX_ITEMS = exports.RECALL_MIN_SIMILARITY = exports.SESSION_INTENT_WEIGHT = exports.COLD_EXPOSURE_SLOTS = exports.RECENT_WINDOW_DAYS = exports.RECENT_LIMIT = exports.SEARCH_LIMIT = exports.PROMOTION_STRENGTH_FLOOR = exports.PROMOTION_RATE = exports.DECAY_HALF_LIFE_DAYS = void 0;
+exports.DIAGNOSTIC_ENV_TIER = void 0;
 exports.resolveNumCtx = resolveNumCtx;
 exports.resolveOllamaFlushEvery = resolveOllamaFlushEvery;
 exports.resolveOllamaFlushWaitMs = resolveOllamaFlushWaitMs;
@@ -39,6 +40,36 @@ exports.resolveOllamaFlushWaitMs = resolveOllamaFlushWaitMs;
  * ranking. Long-term remembering is the product; time preference stays mild.
  */
 exports.DECAY_HALF_LIFE_DAYS = 365;
+/**
+ * Per-use strength promotion rate (#448, the strength model's upward path):
+ * one application of `promotion = PROMOTION_RATE × (1 − S / IMPORTANCE_CEILING)
+ * × S^(−0.3)` per new use (S = stored base_strength), iterated once per
+ * access-count delta by the nightly stagePromotion stage and clamped at the
+ * ceiling. Calibrated so the first access on a median-0.35 memory gives ~+0.03
+ * (0.35 → 0.3786). Shape grounded in LTP saturation curves (Cao & Harris
+ * 2014), the power law of practice (α ≈ 0.3, Newell & Rosenbloom 1981), and
+ * spaced-repetition stability multipliers (S^−0.53, SuperMemo SM-17,
+ * n > 60,000 real repetitions): bigger boosts for weaker memories,
+ * saturating near the ceiling, never fully stopping (asymptotic). The decay
+ * side is untouched — a memory's fade RATE no longer depends on its use or
+ * link history (the #448 hardening removal); use raises the STORED score
+ * instead, and abandonment fades it on the same 365-day clock as everything
+ * else. RELEASE-MANAGED per this module's evolution contract — no config key.
+ */
+exports.PROMOTION_RATE = 0.033;
+/**
+ * Lower bound on the promotion formula's S input (#453 review Minor finding,
+ * owner decision 2026-09-16). base_strength 0.0 is a writable value (legacy
+ * rows, operator edits), and S^(−0.3) has a zero-singularity: unfloored, one
+ * access on a 0.0 row computed delta = 0.033 × (1 − 0/0.95) × 0^−0.3 =
+ * Infinity, and the ceiling clamp turned that into a leap straight to 0.95.
+ * Floored at 0.01, the same access lands at 0.033 × (1 − 0.01/0.95) ×
+ * 0.01^(−0.3) ≈ +0.13 (0.0 → ≈0.14) — the biggest first boost the formula
+ * can give, bounded and far from the ceiling. The floor clamps the FORMULA
+ * INPUT only: storage keeps a 0.0 row at 0.0 until it is used, and the
+ * promoted result is nonzero from then on. RELEASE-MANAGED like PROMOTION_RATE.
+ */
+exports.PROMOTION_STRENGTH_FLOOR = 0.01;
 /** Default k for retrieve() (/search without an explicit limit). #192. */
 exports.SEARCH_LIMIT = 8;
 /** Default k for searchRecent() (/recent without an explicit limit). #192. */
@@ -97,8 +128,9 @@ exports.RECALL_USES_NORMAL_MAX = 0.25;
  *  keeps a visible span, not a measured bound. */
 exports.RECALL_USES_AXIS_MAX = 0.30;
 // ---------------------------------------------------------------------------
-// Composite ranking weights (was: score*Weight, freshnessBoost*,
-// supersededDemotion, *AffinityWeight, rrf*)
+// Composite ranking weights (was: score*Weight, supersededDemotion,
+// *AffinityWeight, rrf*; the pre-#430 freshness bonus constants merged into
+// the RECENCY family below)
 // ---------------------------------------------------------------------------
 /** Semantic-similarity share of the composite score. 0.50 (raised from 0.40
  *  in the 0.15.2 rebalance, #191 Phase B): on the production corpus effective
@@ -110,23 +142,58 @@ exports.SCORE_SIMILARITY_WEIGHT = 0.50;
 exports.SCORE_STRENGTH_WEIGHT = 0.20;
 /** Graph-centrality share of the composite score (was 0.20; see above). */
 exports.SCORE_CONNECTIONS_WEIGHT = 0.15;
-/** Slow recency curve share of the composite score (was 0.10; see above). */
+/**
+ * Log-saturation degree K for the connections term (#449 PR E, items 1+3):
+ * the credit is min(1, log1p(k) / log1p(K)) × SCORE_CONNECTIONS_WEIGHT on
+ * the ABSOLUTE undirected-degree scale k — full at k = K, exactly +0 at
+ * k = 0 (unlinked rows score bit-identically to the linear term they
+ * replace). Provenance: p99 of the REAL undirected degree distribution
+ * (read-only audit 2026-09-17 of the canonical wave snapshot, 18,798
+ * memories / 14,600 linked: p50 = 4, p90 = 8, p95 = 9, p99 = 15, p99.9 =
+ * 28.4, max = 40; 135 memories ≥ 16 links = 0.92% of linked) — so the top
+ * ~1% of hubs tie at full credit and everything below differentiates
+ * modestly. Shape grounded in the #449 research base: ACT-R fan saturation
+ * (Anderson & Reder 1999 — activation falls with the LOG of fan), SAM's
+ * saturating returns, cue overload (Watkins & Watkins 1975). Replaces the
+ * candidate-set-relative normalization #449 deleted (k / the per-query max
+ * degree) — a row's score no longer depends on which other rows happened
+ * to match. Alternatives K = 8 (p90 — collapses all p90+ rows to
+ * full credit) and K = 32 (≈p99.9 — leaves the p99 hub at 0.12 of the
+ * term) were tabled in the #449 spec. RELEASE-MANAGED per this module's
+ * evolution contract — overridable only through the configureScoring seam.
+ */
+exports.CONNECTIONS_SATURATION_DEGREE = 16;
+/** Time-curve share of the composite score — the merged curve's blend weight
+ *  AND slow-region amplitude (was 0.10; see above). The four blend weights
+ *  still sum to 1.0; the head amplitude below is a documented overshoot, NOT
+ *  a fifth blend weight (#430). Zero (via the seam) disables the whole term. */
 exports.SCORE_RECENCY_WEIGHT = 0.15;
-/** Fresh-memory window: the additive bonus fades linearly to 0 over this
- *  many days. 7 — nightly capture means 1 day is the floor of "fresh"
- *  (#191 Phase B). */
-exports.FRESHNESS_BOOST_DAYS = 7;
-/** Fresh-memory bonus size at age 0 (#191 Phase B; 0 = disabled via seam). */
-exports.FRESHNESS_BOOST_WEIGHT = 0.15;
+/** Hourly decay of the merged curve's slow region (#430) — promoted from the
+ *  inline literal computeScore carried; half-life ≈ 57.7 days. At and beyond
+ *  RECENCY_HEAD_DAYS the curve is bit-identical to the pre-#430 slow term
+ *  (SCORE_RECENCY_WEIGHT × RECENCY_HOURLY_DECAY^hours). */
+exports.RECENCY_HOURLY_DECAY = 0.9995;
+/** Merged time-curve head amplitude at age 0 (#430) — the pre-#430 slow
+ *  weight 0.15 + fresh bonus 0.15: the freshness job is now the early steep
+ *  part of ONE curve. The head joins value-continuously onto the slow region
+ *  at RECENCY_HEAD_DAYS; its rate is DERIVED from that continuity, never a
+ *  free constant. */
+exports.RECENCY_HEAD_WEIGHT = 0.30;
+/** Join age in days of the merged time curve (#430) — the head window edge,
+ *  carried over from the pre-#430 freshness window. Nightly capture means
+ *  1 day is the floor of "fresh" (#191 Phase B). */
+exports.RECENCY_HEAD_DAYS = 7;
 /** Score multiplier for a memory a later decision superseded (0.15.2; the
  *  belief walk (#393 D) is the primary mechanism — this is the safety net
  *  for rows the walk does not reach). */
 exports.SUPERSEDED_DEMOTION = 0.50;
-/** #203 soft boost on exact project match. ADDITIVE, zero-boost neutral,
- *  never a penalty — a foreign memory ranks equal, not lower. */
-exports.PROJECT_AFFINITY_WEIGHT = 0.15;
-/** #203 soft boost multiplier on max overlapping domain-tag weight. */
-exports.DOMAIN_AFFINITY_WEIGHT = 0.15;
+/** #430 merged scope affinity — ONE term replacing #203's two boosts (the
+ *  project-affinity and domain-affinity constants) at their shared value.
+ *  Boost = max(project-match indicator (1 on exact match), max overlapping
+ *  domain-tag weight) × this weight: the strongest single scope signal counts
+ *  once, never stacked. ADDITIVE, zero-boost neutral, never a penalty — an
+ *  absent scope adds exactly 0; a foreign memory ranks equal, not lower. */
+exports.SCOPE_AFFINITY_WEIGHT = 0.15;
 /** #205 RRF k parameter (1/(k+rank+1)) — matches the pre-#205 hardcoded 60
  *  so the no-config path was byte-identical to 0.15.3. */
 exports.RRF_K = 60;

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,112 @@ 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;
+    let totalGain = 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).
+        const startStrength = row.base_strength ?? 0.5;
+        let strength = startStrength;
+        for (let i = 0; i < row.delta; i++)
+            strength = applyStrengthPromotion(strength);
+        totalGain += strength - startStrength;
+        promoted++;
+        writes.push({
+            id: row.id,
+            fields: { base_strength: strength, promotion_last_count: accessCount },
+        });
+    }
+    // #459: the stage's one-line summary in the shared stage idiom (rows
+    // examined / promoted / total gain, like the supersession summary) — the
+    // stage writes its report in-memory only, so the log line is the soak-time
+    // health signal. Zero examined rows stay silent (the supersession gate).
+    if (dryRun) {
+        console.log(`[hicortex] Strength promotion (dry-run): ${rows.length} examined, would promote ` +
+            `${promoted} (+${totalGain.toFixed(3)} total strength, ` +
+            `${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: ${rows.length} examined, promoted ${promoted} ` +
+        `(+${totalGain.toFixed(3)} total strength, ` +
+        `${demotedSkipped} demotion-set rows advance their baseline only).`);
+    return { promoted, demoted_skipped: demotedSkipped };
+}
+// ---------------------------------------------------------------------------
 // Stage 4.5: Memory cap eviction (#245)
 // ---------------------------------------------------------------------------
 //
@@ -1365,10 +1437,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 +1515,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 +1688,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 +1767,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 });