@gamaze/hicortex 0.20.10 → 0.22.0

package/dist/mcp-server.js

@@ -1548,7 +1548,7 @@ async function startServer(options = {}) {
     //
     // An enrich is EVIDENCE ABOUT IMPORTANCE: it bumps corroboration_count and
     // base_strength (+the calibration delta, capped at 1.0) — the same anchor
-    // the nightly's LLM scoring and hub-boost write. It must NOT touch
+    // the nightly's LLM scoring writes. It must NOT touch
     // access_count (reserved for real recall use) or shown_count (index
     // exposure) — faking either corrupts the uses-per-showing adoption metric.
     // Never a stage write: stages are derived presentation (the E-reframe).

package/dist/nofit.d.ts

@@ -38,7 +38,8 @@
  *     memory from pruning. Halving does not touch last_accessed/access_count.
  *   - Re-classification: a later run whose LLM tags it, or whose evolved
  *     prototypes clear the floor, gives it a (weak) primary — halving stops.
- *     Its strength is NOT restored; only access does that job.
+ *     Its strength is restored only by the nightly promotion stage (#448),
+ *     which converts each new access_count delta into a base_strength bump.
  *
  * PRUNE INTERACTION (verified against stageDecayPrune + effectiveStrength):
  * prune fires when effectiveStrength < 0.01 for a >90-day-old, never-accessed

package/dist/nofit.js

@@ -39,7 +39,8 @@
  *     memory from pruning. Halving does not touch last_accessed/access_count.
  *   - Re-classification: a later run whose LLM tags it, or whose evolved
  *     prototypes clear the floor, gives it a (weak) primary — halving stops.
- *     Its strength is NOT restored; only access does that job.
+ *     Its strength is restored only by the nightly promotion stage (#448),
+ *     which converts each new access_count delta into a base_strength bump.
  *
  * PRUNE INTERACTION (verified against stageDecayPrune + effectiveStrength):
  * prune fires when effectiveStrength < 0.01 for a >90-day-old, never-accessed

package/dist/recall-index.d.ts

@@ -10,8 +10,9 @@
  * Strengthening semantics (the recall/decay alignment):
  *   - Appearing in the index = exposure: shown_count + last_accessed refresh
  *     (mild, temporary strengthen — the decay clock resets) via
- *     storage.touchMemoriesShown. NO access_count bump: hardening, the prune
- *     shield, and the adoption metric stay driven by real use.
+ *     storage.touchMemoriesShown. NO access_count bump: the promotion signal
+ *     (#448), the prune shield, and the adoption metric stay driven by real
+ *     use.
  *   - hicortex_get = use: full strengthen (access_count + 1).
  *
  * Anti-bloat gates: relevance floor (measured cosine, or a real BM25 match),

package/dist/recall-index.js

@@ -11,8 +11,9 @@
  * Strengthening semantics (the recall/decay alignment):
  *   - Appearing in the index = exposure: shown_count + last_accessed refresh
  *     (mild, temporary strengthen — the decay clock resets) via
- *     storage.touchMemoriesShown. NO access_count bump: hardening, the prune
- *     shield, and the adoption metric stay driven by real use.
+ *     storage.touchMemoriesShown. NO access_count bump: the promotion signal
+ *     (#448), the prune shield, and the adoption metric stay driven by real
+ *     use.
  *   - hicortex_get = use: full strengthen (access_count + 1).
  *
  * Anti-bloat gates: relevance floor (measured cosine, or a real BM25 match),

package/dist/retrieval.d.ts

@@ -208,7 +208,7 @@ export declare function l2ToCosine(distance: number): number;
  */
 export declare function cosineBetweenVectors(a: Float32Array, b: Float32Array): number;
 /**
- * Compute decayed strength with adaptive decay (B+E+D model).
+ * Compute decayed strength with adaptive decay (B+D model).
  * Exported for use by consolidation decay/prune stage.
  *
  * #425 read-side law: the decay-relevant importance is CLAMPED at the
@@ -216,11 +216,17 @@ export declare function cosineBetweenVectors(a: Float32Array, b: Float32Array):
  * exactly 1.0 the decay rate is exactly 1.0 and the row never decays, so
  * legacy base-1.0 rows (and any write site that predates the cap) decay
  * again. The clamp applies to explicit importance passes too.
+ *
+ * #448: the access/connectivity HARDENING terms are REMOVED — the fade rate
+ * no longer depends on access or link history (a briefly-used memory was
+ * near-immortal: 10 accesses cut the decay rate to 3% of normal). Real use
+ * now raises the STORED score via the nightly promotion stage
+ * (consolidate.ts stagePromotion) instead of slowing future decay, so a
+ * promoted-then-abandoned memory fades on the same 365-day clock as any
+ * other, from a higher anchor.
  */
 export declare function effectiveStrength(baseStrength: number, lastAccessed: string | null, now: Date, options?: {
     importance?: number;
-    accessCount?: number;
-    linkCount?: number;
 }): number;
 /**
  * Return a composite relevance score in [0, 1] for a candidate memory.

package/dist/retrieval.js

@@ -486,7 +486,7 @@ function parseTimestamp(ts) {
 // Scoring helpers
 // ---------------------------------------------------------------------------
 /**
- * Compute decayed strength with adaptive decay (B+E+D model).
+ * Compute decayed strength with adaptive decay (B+D model).
  * Exported for use by consolidation decay/prune stage.
  *
  * #425 read-side law: the decay-relevant importance is CLAMPED at the
@@ -494,20 +494,21 @@ function parseTimestamp(ts) {
  * exactly 1.0 the decay rate is exactly 1.0 and the row never decays, so
  * legacy base-1.0 rows (and any write site that predates the cap) decay
  * again. The clamp applies to explicit importance passes too.
+ *
+ * #448: the access/connectivity HARDENING terms are REMOVED — the fade rate
+ * no longer depends on access or link history (a briefly-used memory was
+ * near-immortal: 10 accesses cut the decay rate to 3% of normal). Real use
+ * now raises the STORED score via the nightly promotion stage
+ * (consolidate.ts stagePromotion) instead of slowing future decay, so a
+ * promoted-then-abandoned memory fades on the same 365-day clock as any
+ * other, from a higher anchor.
  */
 function effectiveStrength(baseStrength, lastAccessed, now, options) {
     const rawImportance = options?.importance ?? baseStrength;
     const importance = Math.min(rawImportance, CALIBRATION.IMPORTANCE_CEILING);
-    const accessCount = options?.accessCount ?? 0;
-    const linkCount = options?.linkCount ?? 0;
     const hours = Math.max((now.getTime() - parseTimestamp(lastAccessed).getTime()) / 3_600_000, 0);
     // B: Importance slows decay
-    let decayRate = 1.0 - BASE_DECAY * (1.0 - importance);
-    // E: Access hardening
-    const hardening = 0.7;
-    decayRate = 1.0 - (1.0 - decayRate) * Math.pow(hardening, accessCount);
-    // E: Connectivity hardening
-    decayRate = 1.0 - (1.0 - decayRate) * Math.pow(hardening, linkCount);
+    const decayRate = 1.0 - BASE_DECAY * (1.0 - importance);
     // D: Asymptotic floor
     const floor = baseStrength * importance * 0.1;
     return floor + (baseStrength - floor) * Math.pow(decayRate, hours);
@@ -529,8 +530,6 @@ function computeScore(memory, distance, connectionCount, maxConnections, now, op
         // time — now stated at the call site so the triple-win coupling
         // (score share, decay rate, floor) is visible and single-sourced).
         importance: memory.base_strength ?? 0.5,
-        accessCount: memory.access_count ?? 0,
-        linkCount: connectionCount,
     });
     const connScore = maxConnections > 0 ? connectionCount / maxConnections : 0;
     const hoursSinceCreated = Math.max((now.getTime() - parseTimestamp(memory.created_at).getTime()) / 3_600_000, 0);
@@ -546,10 +545,11 @@ function computeScore(memory, distance, connectionCount, maxConnections, now, op
     // session captured last night ranks as ~1 day old (not 0), and backfilled
     // older content correctly gets no boost. The slow
     // `recency` term above (≈58-day half-life at weight 0.15) could never lift a
-    // day-old memory past a hardened old one — measured case: an exact-match
-    // 1-day-old memory (strength 0.50) lost to an unrelated memory at strength
-    // 0.80. This is an ADDITIVE bonus that decays linearly to zero at the window
-    // edge, so it cannot distort ranking among memories that are all old.
+    // day-old memory past an old high-strength one — measured case: an
+    // exact-match 1-day-old memory (strength 0.50) lost to an unrelated memory
+    // at strength 0.80. This is an ADDITIVE bonus that decays linearly to zero
+    // at the window edge, so it cannot distort ranking among memories that are
+    // all old.
     const ageDays = hoursSinceCreated / 24;
     if (memory.created_at && ageDays < scoringWeights.freshnessBoostDays) {
         const freshness = 1 - ageDays / scoringWeights.freshnessBoostDays;
@@ -832,10 +832,7 @@ async function retrieve(db, embedFn, query, options) {
             // signature — graph-only and single-channel candidates add nothing.
             bothChannel: source === "both",
         });
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connectionCounts.get(mem.id) ?? 0,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         const rrf = rrfScores.get(mid) ?? 0;
         const normalizedRrf = maxRrf > 0 ? rrf / maxRrf : 0;
         // #205: composite/RRF blend is now config-driven (rrfCompositeWeight, 0.8
@@ -851,7 +848,8 @@ async function retrieve(db, embedFn, query, options) {
         scored.push({ mem, finalScore, effStr, connCount, similarity, source });
     }
     // 6. Sort and take top N — with cold-exposure slots (#192).
-    // Access hardening + effective strength make past winners self-reinforcing:
+    // Effective strength + the promotion stage (#448) make past winners
+    // self-reinforcing:
     // 88% of the production corpus had never been returned by any query. Reserve
     // up to 2 of k for the best-scoring never-accessed candidates so the long
     // tail gets nonzero exposure whenever it is semantically in range. Slots are
@@ -899,10 +897,7 @@ async function retrieve(db, embedFn, query, options) {
         const connCount = storage.getLinks(db, terminalId, "both").length;
         const composite = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, maxConnections, now, { superseded: supersededIds.has(terminalId) });
         const finalScore = composite * scoringWeights.rrfCompositeWeight;
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connCount,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         return { mem, finalScore, effStr, connCount, similarity: null, source: "graph" };
     });
     const results = top.map((t) => formatResult(t.mem, t.finalScore, t.effStr, t.connCount, {
@@ -948,10 +943,7 @@ function searchRecent(db, options) {
         const score = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, maxConnections, now, {
             superseded: supersededRecent.has(mem.id),
         });
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connectionCounts.get(mem.id) ?? 0,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         scored.push({ mem, score, effStr, connCount });
     }
     scored.sort((a, b) => b.score - a.score);
@@ -977,10 +969,7 @@ function searchRecent(db, options) {
             return null;
         const connCount = storage.getLinks(db, terminalId, "both").length;
         const score = computeScore(mem, DEFAULT_GRAPH_DISTANCE, connCount, maxConnections, now, { superseded: supersededRecent.has(terminalId) });
-        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now, {
-            accessCount: mem.access_count ?? 0,
-            linkCount: connCount,
-        });
+        const effStr = effectiveStrength(mem.base_strength ?? 0.5, mem.last_accessed, now);
         return { mem, score, effStr, connCount };
     });
     const results = top.map((t) => formatResult(t.mem, t.score, t.effStr, t.connCount));

package/dist/status.js

@@ -66,6 +66,24 @@ async function runStatus() {
             console.log(`Memories:     ${stats.memories} (${typeStr || "none"})`);
             console.log(`Links:        ${stats.links}`);
             console.log(`DB size:      ${(stats.db_size_bytes / 1024).toFixed(1)} KB`);
+            // 0.21 migration detection (#425): pre-0.21 stores have inflated importance
+            // scores (median ~0.80 vs the honest ~0.40). If the live median is high,
+            // recommend the one-shot rescore.
+            if (stats.memories > 0) {
+                try {
+                    const live = db.prepare("SELECT base_strength FROM memories WHERE base_strength IS NOT NULL AND (status IS NULL OR status NOT IN ('absorbed','superseded','retracted')) ORDER BY base_strength").all();
+                    if (live.length >= 10) {
+                        const median = live[Math.floor(live.length / 2)].base_strength;
+                        if (median >= 0.6) {
+                            console.log(``);
+                            console.log(`⚠  Pre-0.21 importance scores detected (median ${median.toFixed(2)}).`);
+                            console.log(`   Run: npx @gamaze/hicortex rescore-importance --apply`);
+                            console.log(`   to re-score your store under the honest rubric.`);
+                        }
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
             db.close();
         }
         catch (err) {

package/dist/storage.d.ts

@@ -68,7 +68,8 @@ export declare function enrichMemory(db: Database.Database, memoryId: string, no
  * Record that memories appeared in a pushed recall index (#192): bump
  * shown_count and refresh last_accessed (a mild strengthen — the decay clock
  * resets so topically-live memories stop sinking) WITHOUT touching
- * access_count, which stays reserved for real use (hardening + prune shield).
+ * access_count, which stays reserved for real use (the promotion signal
+ * #448 + the prune shield).
  */
 export declare function touchMemoriesShown(db: Database.Database, memoryIds: string[], nowIsoStr: string): void;
 /**

package/dist/storage.js

@@ -190,6 +190,10 @@ const ALLOWED_UPDATE_FIELDS = new Set([
     // stageImportance, the enrich path, and the rescore-importance backfill —
     // the moment a row's base_strength is settled under some rubric.
     "importance_scored_at",
+    // Promotion baseline (#448, migration v20): written by the nightly
+    // promotion stage and dedup merges (which sum a cluster's counters onto
+    // the canonical — the baseline must move with the summed access_count).
+    "promotion_last_count",
 ]);
 /**
  * Update specific fields on a memory.
@@ -256,7 +260,8 @@ function enrichMemory(db, memoryId, nowIsoStr) {
  * Record that memories appeared in a pushed recall index (#192): bump
  * shown_count and refresh last_accessed (a mild strengthen — the decay clock
  * resets so topically-live memories stop sinking) WITHOUT touching
- * access_count, which stays reserved for real use (hardening + prune shield).
+ * access_count, which stays reserved for real use (the promotion signal
+ * #448 + the prune shield).
  */
 function touchMemoriesShown(db, memoryIds, nowIsoStr) {
     if (memoryIds.length === 0)

package/dist/types.d.ts

@@ -62,6 +62,16 @@ export interface Memory {
      * rows, which stay NULL for exactly one scoring under the new rubric).
      */
     importance_scored_at?: string | null;
+    /**
+     * Promotion baseline (#448, migration v20): the access_count the nightly
+     * promotion stage (stagePromotion) last consumed — the delta
+     * access_count − promotion_last_count drives the per-use strength bump.
+     * Written by the stage, the migration backfill, and dedup merges (the
+     * baseline moves with the summed counter so a merge never replays the
+     * losers' lifetime accesses as fresh promotions). Optional because
+     * rowToMemory is a cast over SELECT * rows.
+     */
+    promotion_last_count?: number | null;
 }
 /** A link between two memories. */
 export interface MemoryLink {
@@ -228,10 +238,6 @@ export interface ConsolidationReport {
             no_association_decayed?: number;
             reason?: string;
         };
-        hub_boost?: {
-            hubs_found: number;
-            boosted: number;
-        };
         links?: {
             auto_linked: number;
             llm_classified?: number;
@@ -391,6 +397,21 @@ export interface ConsolidationReport {
             pruned: number;
             failed: number;
         };
+        /**
+         * Strength promotion (#448) — runs PRE-SKIP (quiet nights still promote
+         * the day's uses), BEFORE memory_cap eviction (a promoted row survives a
+         * cap it would otherwise lose). Zero LLM: it sits in the deterministic
+         * zone, before the BudgetTracker exists.
+         */
+        promotion?: {
+            /** Memories whose base_strength was bumped this run (delta iterations). */
+            promoted: number;
+            /**
+             * Demotion-set rows (superseded/retracted/absorbed + superseded_by-link
+             * sources) with a use delta — no bump, baseline advanced only.
+             */
+            demoted_skipped: number;
+        };
         /** Capacity eviction (#245) — runs after decay_prune. When the corpus
          *  exceeds `memorySoftCap`, the lowest-effectiveStrength memories are
          *  evicted until under the cap. `cap = 0` (disabled) → evicted = 0. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.20.10",
+  "version": "0.22.0",
   "description": "Persistent agent identity for AI agents \u2014 a hand-edited identity layer, nightly-distilled experience, and lessons injected every session, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, Pi, and opencode.",
   "main": "dist/index.js",
   "bin": {

package/server.json

@@ -1,14 +1,14 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.gamaze-labs/hicortex",
-  "title": "Hicortex",
+  "title": "Hicortex \u2014 AI Fleet Memory",
   "description": "Shared fleet memory for AI agents: nightly self-correction, recall every prompt (supported agents).",
-  "version": "0.20.9",
+  "version": "0.22.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@gamaze/hicortex",
-      "version": "0.20.9",
+      "version": "0.22.0",
       "transport": {
         "type": "stdio",
         "command": "npx",
@@ -41,4 +41,4 @@
     "source": "github"
   },
   "websiteUrl": "https://hicortex.gamaze.com"
-}
+}