ahok-skill 1.3.1

package/dist/core/vector/valkey.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValkeyVectorStore = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const cfg_1 = require("../cfg");
+const embed_1 = require("../../memory/embed");
+class ValkeyVectorStore {
+    client;
+    constructor() {
+        this.client = new ioredis_1.default({
+            host: cfg_1.env.valkey_host || "localhost",
+            port: cfg_1.env.valkey_port || 6379,
+            password: cfg_1.env.valkey_password,
+        });
+    }
+    getKey(id, sector) {
+        return `vec:${sector}:${id}`;
+    }
+    async storeVector(id, sector, vector, dim, user_id) {
+        const key = this.getKey(id, sector);
+        const buf = (0, embed_1.vectorToBuffer)(vector);
+        // Store as Hash: v (blob), dim (int), user_id (string)
+        await this.client.hset(key, {
+            v: buf,
+            dim: dim,
+            user_id: user_id || "anonymous",
+            id: id,
+            sector: sector
+        });
+    }
+    async deleteVector(id, sector) {
+        const key = this.getKey(id, sector);
+        await this.client.del(key);
+    }
+    async deleteVectors(id) {
+        // This is inefficient in Redis without an index on ID across sectors.
+        // We might need to track which sectors an ID has.
+        // For now, we can scan or just assume we know the sectors?
+        // The interface implies we delete ALL vectors for this ID.
+        // In Postgres we did `delete from vectors where id=$1`.
+        // In Redis, we might need to know the sectors.
+        // Or we can use `keys vec:*:${id}` which is slow.
+        // Better approach: maintain a set of sectors for each ID?
+        // Or just iterate over known sectors (from hsg.ts sectors list).
+        // I'll import `sectors` from `../../memory/hsg`? No, circular dependency risk.
+        // I'll use a scan for now as it's safer, or just accept it might be slow.
+        // Actually, `keys` is blocking. `scan` is better.
+        // But `id` is at the end of the key `vec:{sector}:{id}`.
+        // Pattern: `vec:*:${id}`.
+        let cursor = "0";
+        do {
+            const res = await this.client.scan(cursor, "MATCH", `vec:*:${id}`, "COUNT", 100);
+            cursor = res[0];
+            const keys = res[1];
+            if (keys.length)
+                await this.client.del(...keys);
+        } while (cursor !== "0");
+    }
+    async searchSimilar(sector, queryVec, topK) {
+        // Try to use FT.SEARCH if index exists.
+        // Index name assumption: `idx:{sector}`
+        // Query: `*=>[KNN {k} @v $blob AS score]`
+        const indexName = `idx:${sector}`;
+        const blob = (0, embed_1.vectorToBuffer)(queryVec);
+        try {
+            // Check if index exists (optional, or just try search)
+            // We'll try the search.
+            // FT.SEARCH idx:sector "*=>[KNN 10 @v $blob AS score]" PARAMS 2 blob "\x..." DIALECT 2
+            const res = await this.client.call("FT.SEARCH", indexName, `*=>[KNN ${topK} @v $blob AS score]`, "PARAMS", "2", "blob", blob, "DIALECT", "2");
+            // Parse result
+            // [total_results, key1, [field1, val1, ...], key2, ...]
+            // We need to parse the array.
+            const count = res[0];
+            const results = [];
+            for (let i = 1; i < res.length; i += 2) {
+                const key = res[i]; // e.g. vec:semantic:123
+                const fields = res[i + 1];
+                let id = "";
+                let score = 0;
+                // fields is array [k, v, k, v...]
+                for (let j = 0; j < fields.length; j += 2) {
+                    const f = fields[j];
+                    const v = fields[j + 1];
+                    if (f === "id")
+                        id = v;
+                    if (f === "score")
+                        score = 1 - (parseFloat(v) / 2); // Cosine distance to similarity?
+                    // Valkey HNSW usually returns distance.
+                    // If metric is COSINE, distance is 1 - cosine_sim.
+                    // So sim = 1 - dist.
+                    // Wait, standard RediSearch KNN distance depends on metric.
+                    // Assuming COSINE metric.
+                }
+                // If id not in fields, extract from key
+                if (!id) {
+                    const parts = key.split(":");
+                    id = parts[parts.length - 1];
+                }
+                // If score not found (should be there as 'score'), default 0
+                // Actually, 'score' is the alias we gave.
+                // Wait, in FT.SEARCH response, the score is returned if we ask for it?
+                // Yes, "AS score" puts it in the fields.
+                // Correction: RediSearch returns distance by default for KNN?
+                // Yes, but we aliased it "AS score".
+                // So it should be in the fields as "score".
+                // Distance conversion:
+                // If distance is d, and we want cosine similarity.
+                // Cosine distance = 1 - cosine similarity.
+                // So similarity = 1 - distance.
+                results.push({ id, score: 1 - parseFloat(fields.find((f, idx) => f === "score" && idx % 2 === 0 ? false : fields[idx - 1] === "score") || "0") });
+                // The find logic above is tricky.
+                // Let's just loop.
+            }
+            // Fix score parsing loop
+            results.length = 0; // clear
+            for (let i = 1; i < res.length; i += 2) {
+                const key = res[i];
+                const fields = res[i + 1];
+                let id = "";
+                let dist = 0;
+                for (let j = 0; j < fields.length; j += 2) {
+                    if (fields[j] === "id")
+                        id = fields[j + 1];
+                    if (fields[j] === "score")
+                        dist = parseFloat(fields[j + 1]);
+                }
+                if (!id)
+                    id = key.split(":").pop();
+                results.push({ id, score: 1 - dist });
+            }
+            return results;
+        }
+        catch (e) {
+            console.warn(`[Valkey] FT.SEARCH failed for ${sector}, falling back to scan (slow):`, e);
+            // Fallback: Scan all vectors in sector and compute cosine sim
+            // This is very slow but ensures correctness if index is missing.
+            let cursor = "0";
+            const allVecs = [];
+            do {
+                const res = await this.client.scan(cursor, "MATCH", `vec:${sector}:*`, "COUNT", 100);
+                cursor = res[0];
+                const keys = res[1];
+                if (keys.length) {
+                    // Pipeline get all
+                    const pipe = this.client.pipeline();
+                    keys.forEach(k => pipe.hget(k, "v"));
+                    const buffers = await pipe.exec();
+                    buffers?.forEach((b, idx) => {
+                        if (b && b[1]) {
+                            const buf = b[1];
+                            const id = keys[idx].split(":").pop();
+                            allVecs.push({ id, vector: (0, embed_1.bufferToVector)(buf) });
+                        }
+                    });
+                }
+            } while (cursor !== "0");
+            const sims = allVecs.map(v => ({
+                id: v.id,
+                score: this.cosineSimilarity(queryVec, v.vector)
+            }));
+            sims.sort((a, b) => b.score - a.score);
+            return sims.slice(0, topK);
+        }
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dot = 0, na = 0, nb = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            na += a[i] * a[i];
+            nb += b[i] * b[i];
+        }
+        return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+    }
+    async getVector(id, sector) {
+        const key = this.getKey(id, sector);
+        const res = await this.client.hmget(key, "v", "dim");
+        if (!res[0])
+            return null;
+        return {
+            vector: (0, embed_1.bufferToVector)(res[0]),
+            dim: parseInt(res[1])
+        };
+    }
+    async getVectorsById(id) {
+        // Scan for vec:*:{id}
+        const results = [];
+        let cursor = "0";
+        do {
+            const res = await this.client.scan(cursor, "MATCH", `vec:*:${id}`, "COUNT", 100);
+            cursor = res[0];
+            const keys = res[1];
+            if (keys.length) {
+                const pipe = this.client.pipeline();
+                keys.forEach(k => pipe.hmget(k, "v", "dim"));
+                const res = await pipe.exec();
+                res?.forEach((r, idx) => {
+                    if (r && r[1]) {
+                        const [v, dim] = r[1];
+                        const key = keys[idx];
+                        const parts = key.split(":");
+                        const sector = parts[1];
+                        results.push({
+                            sector,
+                            vector: (0, embed_1.bufferToVector)(v),
+                            dim: parseInt(dim)
+                        });
+                    }
+                });
+            }
+        } while (cursor !== "0");
+        return results;
+    }
+    async getVectorsBySector(sector) {
+        const results = [];
+        let cursor = "0";
+        do {
+            const res = await this.client.scan(cursor, "MATCH", `vec:${sector}:*`, "COUNT", 100);
+            cursor = res[0];
+            const keys = res[1];
+            if (keys.length) {
+                const pipe = this.client.pipeline();
+                keys.forEach(k => pipe.hmget(k, "v", "dim"));
+                const res = await pipe.exec();
+                res?.forEach((r, idx) => {
+                    if (r && r[1]) {
+                        const [v, dim] = r[1];
+                        const key = keys[idx];
+                        const id = key.split(":").pop();
+                        results.push({
+                            id,
+                            vector: (0, embed_1.bufferToVector)(v),
+                            dim: parseInt(dim)
+                        });
+                    }
+                });
+            }
+        } while (cursor !== "0");
+        return results;
+    }
+}
+exports.ValkeyVectorStore = ValkeyVectorStore;

package/dist/core/vector_store.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.sources = void 0;
+// Export core functionality for use as a package
+__exportStar(require("./core/memory"), exports);
+__exportStar(require("./server/index"), exports);
+__exportStar(require("./ops/ingest"), exports);
+exports.sources = __importStar(require("./sources"));

package/dist/memory/decay.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.on_query_hit = exports.apply_decay = exports.dec_q = exports.inc_q = void 0;
+const db_1 = require("../core/db");
+const utils_1 = require("../utils");
+const cfg_1 = require("../core/cfg");
+const parse_int = (x, d) => Number.isFinite(+x) ? Math.floor(+x) : d;
+const parse_f = (x, d) => (Number.isFinite(+x) ? +x : d);
+const parse_bool = (x, d) => x === "true" ? true : x === "false" ? false : d;
+const clamp_f = (v, a, b) => Math.min(b, Math.max(a, v));
+const clamp_i = (v, a, b) => Math.min(b, Math.max(a, Math.floor(v)));
+const tick = () => new Promise((r) => setImmediate(r));
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const mean = (arr) => arr.length ? arr.reduce((a, b) => a + b, 0) / arr.length : 0;
+const l2 = (v) => Math.sqrt(v.reduce((s, x) => s + x * x, 0));
+const normalize = (v) => {
+    const n = l2(v) || 1;
+    for (let i = 0; i < v.length; i++)
+        v[i] /= n;
+    return v;
+};
+const chunkz = (arr, k) => {
+    const n = Math.max(1, k | 0), out = Array.from({ length: n }, () => []);
+    for (let i = 0; i < arr.length; i++)
+        out[i % n].push(arr[i]);
+    return out;
+};
+const make_decay_cfg = () => ({
+    threads: parse_int(process.env.OM_DECAY_THREADS, 3),
+    cold_threshold: parse_f(process.env.OM_DECAY_COLD_THRESHOLD, 0.25),
+    reinforce_on_query: parse_bool(process.env.OM_DECAY_REINFORCE_ON_QUERY, true),
+    regeneration_enabled: parse_bool(process.env.OM_REGENERATION_ENABLED, true),
+    max_vec_dim: parse_int(process.env.OM_MAX_VECTOR_DIM, cfg_1.env.vec_dim || 1536),
+    min_vec_dim: parse_int(process.env.OM_MIN_VECTOR_DIM, 64),
+    summary_layers: clamp_i(parse_int(process.env.OM_SUMMARY_LAYERS, 3), 1, 3),
+    lambda_hot: 0.005,
+    lambda_warm: 0.02,
+    lambda_cold: 0.05,
+    time_unit_ms: 86_400_000,
+});
+const cfg = make_decay_cfg();
+let active_q = 0;
+let last_decay = 0;
+const cooldown = 60000;
+const inc_q = () => active_q++;
+exports.inc_q = inc_q;
+const dec_q = () => active_q--;
+exports.dec_q = dec_q;
+const pick_tier = (m, now_ts) => {
+    const dt = Math.max(0, now_ts - (m.last_seen_at || m.updated_at || now_ts));
+    const recent = dt < 6 * 86_400_000;
+    const high = (m.coactivations || 0) > 5 || (m.salience || 0) > 0.7;
+    if (recent && high)
+        return "hot";
+    if (recent || (m.salience || 0) > 0.4)
+        return "warm";
+    return "cold";
+};
+const compress_vector = (vec, f, min_dim = 64, max_dim = 1536) => {
+    const src = vec.length ? vec : [1];
+    const tgt_dim = Math.max(min_dim, Math.min(max_dim, Math.floor(src.length * clamp_f(f, 0.0, 1.0))));
+    const dim = Math.max(min_dim, Math.min(src.length, tgt_dim));
+    if (dim >= src.length)
+        return src.slice(0);
+    const pooled = [];
+    const bucket = Math.ceil(src.length / dim);
+    for (let i = 0; i < src.length; i += bucket)
+        pooled.push(mean(src.slice(i, i + bucket)));
+    normalize(pooled);
+    return pooled;
+};
+const compress_summary = (txt, f, layers = 3) => {
+    const t = (txt || "").trim();
+    if (!t)
+        return "";
+    const lay = clamp_i(layers, 1, 3);
+    const trunc = (s, n) => s.length <= n ? s : s.slice(0, n - 1).trimEnd() + "…";
+    const sumz = (s) => summarize_quick(s);
+    const keys = (s, k = 5) => top_keywords(s, k).join(" ");
+    if (f > 0.8)
+        return trunc(t, 200);
+    if (f > 0.4)
+        return trunc(sumz(t), lay >= 2 ? 80 : 200);
+    return keys(t, lay >= 3 ? 5 : 3);
+};
+const fingerprint_mem = (m) => {
+    const base = (m.id + "|" + (m.summary || m.content || "")).trim();
+    const vec = hash_to_vec(base, 32);
+    normalize(vec);
+    const summary = top_keywords(m.summary || m.content || "", 3).join(" ");
+    return { vector: vec, summary };
+};
+const hash_to_vec = (s, d = 32) => {
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+    }
+    const out = new Array(Math.max(2, d | 0)).fill(0);
+    let x = h || 1;
+    for (let i = 0; i < out.length; i++) {
+        x ^= x << 13;
+        x ^= x >>> 17;
+        x ^= x << 5;
+        out[i] = ((x >>> 0) / 0xffffffff) * 2 - 1;
+    }
+    normalize(out);
+    return out;
+};
+const summarize_quick = (t) => {
+    const sents = t.split(/(?<=[.!?])\s+/).filter(Boolean);
+    if (!sents.length)
+        return t;
+    const score = (s) => top_keywords(s, 6).length + Math.min(3, s.match(/[,;:]/g)?.length || 0);
+    const top = sents
+        .map((s, i) => ({ s, i, sc: score(s) }))
+        .sort((a, b) => b.sc - a.sc || a.i - b.i)
+        .slice(0, Math.min(3, Math.ceil(sents.length / 3)))
+        .sort((a, b) => a.i - b.i)
+        .map((x) => x.s)
+        .join(" ");
+    return top || sents[0];
+};
+const stop = new Set([
+    "the",
+    "a",
+    "an",
+    "to",
+    "of",
+    "and",
+    "or",
+    "in",
+    "on",
+    "for",
+    "with",
+    "at",
+    "by",
+    "is",
+    "it",
+    "be",
+    "as",
+    "are",
+    "was",
+    "were",
+    "from",
+    "that",
+    "this",
+    "these",
+    "those",
+    "but",
+    "if",
+    "then",
+    "so",
+    "than",
+    "into",
+    "over",
+    "under",
+    "about",
+    "via",
+    "vs",
+    "not",
+]);
+const top_keywords = (t, k = 5) => {
+    const words = (t.toLowerCase().match(/[a-z0-9]+/g) || []).filter((w) => !stop.has(w));
+    if (!words.length)
+        return [];
+    const freq = new Map();
+    for (const w of words)
+        freq.set(w, (freq.get(w) || 0) + 1);
+    return Array.from(freq.entries())
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))
+        .slice(0, k)
+        .map(([w]) => w);
+};
+const apply_decay = async () => {
+    if (active_q > 0) {
+        console.log(`[decay] skipped - ${active_q} active queries`);
+        return;
+    }
+    const now_ts = Date.now();
+    if (now_ts - last_decay < cooldown) {
+        console.log(`[decay] skipped - cooldown active (${((cooldown - (now_ts - last_decay)) / 1000).toFixed(0)}s remaining)`);
+        return;
+    }
+    last_decay = now_ts;
+    const t0 = performance.now();
+    const segments = await db_1.q.get_segments.all();
+    let tot_proc = 0, tot_chg = 0, tot_comp = 0, tot_fp = 0;
+    const tier_counts = { hot: 0, warm: 0, cold: 0 };
+    for (const seg of segments) {
+        const segment = seg.segment;
+        const rows = await (0, db_1.all_async)("select id,content,summary,salience,decay_lambda,last_seen_at,updated_at,primary_sector,coactivations from memories where segment=?", [segment]);
+        const decay_ratio = cfg_1.env.decay_ratio;
+        const batch_sz = Math.max(1, Math.floor(rows.length * decay_ratio));
+        const start_idx = Math.floor(Math.random() * Math.max(1, rows.length - batch_sz + 1));
+        const batch = rows.slice(start_idx, start_idx + batch_sz);
+        const parts = chunkz(batch, cfg.threads);
+        await Promise.all(parts.map(async (part) => {
+            for (const m of part) {
+                const tier = pick_tier(m, now_ts);
+                tier_counts[tier]++;
+                const lam = tier === "hot"
+                    ? cfg.lambda_hot
+                    : tier === "warm"
+                        ? cfg.lambda_warm
+                        : cfg.lambda_cold;
+                const dt = Math.max(0, (now_ts - (m.last_seen_at || m.updated_at)) /
+                    cfg.time_unit_ms);
+                const act = Math.max(0, m.coactivations || 0);
+                const sal = clamp_f((m.salience || 0.5) * (1 + Math.log1p(act)), 0, 1);
+                const f = Math.exp(-lam * (dt / (sal + 0.1)));
+                let new_sal = clamp_f(sal * f, 0, 1);
+                let changed = Math.abs(new_sal - m.salience) > 0.001;
+                let compressed = false;
+                let fingerprinted = false;
+                if (f < 0.7) {
+                    const sector = m.primary_sector || "semantic";
+                    const vec_row = await db_1.vector_store.getVector(m.id, sector);
+                    if (vec_row && vec_row.vector) {
+                        const vec = typeof vec_row.vector === "string"
+                            ? JSON.parse(vec_row.vector)
+                            : vec_row.vector;
+                        const before_len = Array.isArray(vec)
+                            ? vec.length
+                            : 0;
+                        if (before_len > 0) {
+                            const new_vec = compress_vector(vec, f, cfg.min_vec_dim, cfg.max_vec_dim);
+                            const new_summary = compress_summary(m.summary || m.content || "", f, cfg.summary_layers);
+                            if (new_vec.length < before_len) {
+                                await db_1.vector_store.storeVector(m.id, sector, new_vec, new_vec.length);
+                                compressed = true;
+                                tot_comp++;
+                            }
+                            if (new_summary !== (m.summary || "")) {
+                                await (0, db_1.run_async)("update memories set summary=? where id=?", [new_summary, m.id]);
+                            }
+                        }
+                    }
+                    changed = true;
+                }
+                if (f < Math.max(0.3, cfg.cold_threshold)) {
+                    const sector = m.primary_sector || "semantic";
+                    const fp = fingerprint_mem(m);
+                    await db_1.vector_store.storeVector(m.id, sector, fp.vector, fp.vector.length);
+                    await (0, db_1.run_async)("update memories set summary=? where id=?", [fp.summary, m.id]);
+                    fingerprinted = true;
+                    tot_fp++;
+                    changed = true;
+                }
+                if (changed) {
+                    await (0, db_1.run_async)(`update ${db_1.memories_table} set salience=?,updated_at=? where id=?`, [new_sal, (0, utils_1.now)(), m.id]);
+                    tot_chg++;
+                }
+                tot_proc++;
+                await tick();
+            }
+        }));
+        if (seg !== segments[segments.length - 1]) {
+            await sleep(cfg_1.env.decay_sleep_ms);
+        }
+    }
+    const tot = performance.now() - t0;
+    // Use stderr for debug output to avoid breaking MCP JSON-RPC protocol
+    console.error(`[decay-2.0] ${tot_chg}/${tot_proc} | tiers: hot=${tier_counts.hot} warm=${tier_counts.warm} cold=${tier_counts.cold} | compressed=${tot_comp} fingerprinted=${tot_fp} | ${tot.toFixed(1)}ms across ${segments.length} segments`);
+};
+exports.apply_decay = apply_decay;
+const on_query_hit = async (mem_id, sector, reembed) => {
+    if (!cfg.regeneration_enabled && !cfg.reinforce_on_query)
+        return;
+    const m = await db_1.q.get_mem.get(mem_id);
+    if (!m)
+        return;
+    let updated = false;
+    if (cfg.regeneration_enabled && reembed) {
+        const vec_row = await db_1.vector_store.getVector(mem_id, sector);
+        if (vec_row && vec_row.vector) {
+            const vec = typeof vec_row.vector === "string"
+                ? JSON.parse(vec_row.vector)
+                : vec_row.vector;
+            if (Array.isArray(vec) && vec.length <= 64) {
+                try {
+                    const base = m.summary || m.content || "";
+                    const new_vec = await reembed(base);
+                    await db_1.vector_store.storeVector(mem_id, sector, new_vec, new_vec.length);
+                    updated = true;
+                }
+                catch (e) { }
+            }
+        }
+    }
+    if (cfg.reinforce_on_query) {
+        const new_sal = clamp_f((m.salience || 0.5) + 0.5, 0, 1);
+        await (0, db_1.run_async)(`update ${db_1.memories_table} set salience=?,last_seen_at=? where id=?`, [new_sal, (0, utils_1.now)(), mem_id]);
+        updated = true;
+    }
+    if (updated) {
+        // Use stderr for debug output to avoid breaking MCP JSON-RPC protocol
+        console.error(`[decay-2.0] regenerated/reinforced memory ${mem_id}`);
+    }
+};
+exports.on_query_hit = on_query_hit;