ahok-skill 1.3.1

package/dist/memory/reflect.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stop_reflection = exports.start_reflection = exports.run_reflection = void 0;
+const db_1 = require("../core/db");
+const hsg_1 = require("./hsg");
+const cfg_1 = require("../core/cfg");
+const utils_1 = require("../utils");
+const sim = (t1, t2) => {
+    // Robust Jaccard overlap
+    const s1 = new Set(t1.toLowerCase().split(/\s+/).filter(x => x.length > 0));
+    const s2 = new Set(t2.toLowerCase().split(/\s+/).filter(x => x.length > 0));
+    if (s1.size === 0 || s2.size === 0)
+        return 0;
+    let inter = 0;
+    for (const token of s1) {
+        if (s2.has(token))
+            inter++;
+    }
+    const union = new Set([...s1, ...s2]).size;
+    return union > 0 ? inter / union : 0;
+};
+const cluster = (mems) => {
+    const cls = [];
+    const used = new Set();
+    for (const m of mems) {
+        if (used.has(m.id) ||
+            m.primary_sector === "reflective" ||
+            m.metadata?.consolidated)
+            continue;
+        const c = { mem: [m], n: 1 };
+        used.add(m.id);
+        for (const o of mems) {
+            if (used.has(o.id) || m.primary_sector !== o.primary_sector)
+                continue;
+            if (sim(m.content, o.content) > 0.8) {
+                c.mem.push(o);
+                c.n++;
+                used.add(o.id);
+            }
+        }
+        if (c.n >= 2)
+            cls.push(c);
+    }
+    return cls;
+};
+const sal = (c) => {
+    const now = Date.now();
+    const p = c.n / 10;
+    const r = c.mem.reduce((s, m) => s +
+        Math.exp(-(now - new Date(m.created_at).getTime()) / 43200000), 0) / c.n;
+    const e = c.mem.some((m) => m.sectors &&
+        Array.isArray(m.sectors) &&
+        m.sectors.includes("emotional"))
+        ? 1
+        : 0;
+    return Math.min(1, 0.6 * p + 0.3 * r + 0.1 * e);
+};
+const summ = (c) => {
+    const sec = c.mem[0].primary_sector;
+    const n = c.n;
+    const txt = c.mem.map((m) => m.content.substring(0, 60)).join("; ");
+    return `${n} ${sec} pattern: ${txt.substring(0, 200)}`;
+};
+const mark = async (ids) => {
+    for (const id of ids) {
+        const m = await db_1.q.get_mem.get(id);
+        if (m) {
+            const meta = JSON.parse(m.meta || "{}");
+            meta.consolidated = true;
+            await db_1.q.upd_mem.run(m.content, m.tags, JSON.stringify(meta), Date.now(), id);
+        }
+    }
+};
+const boost = async (ids) => {
+    for (const id of ids) {
+        const m = await db_1.q.get_mem.get(id);
+        if (m)
+            await db_1.q.upd_mem.run(m.content, m.tags, m.meta, Date.now(), id);
+        await db_1.q.upd_seen.run(id, m.last_seen_at, Math.min(1, m.salience * 1.1), Date.now());
+    }
+};
+const run_reflection = async () => {
+    console.error("[REFLECT] Starting reflection job...");
+    const min = cfg_1.env.reflect_min || 20;
+    const mems = await db_1.q.all_mem.all(100, 0);
+    console.error(`[REFLECT] Fetched ${mems.length} memories (min required: ${min})`);
+    if (mems.length < min) {
+        console.error("[REFLECT] Not enough memories, skipping");
+        return { created: 0, reason: "low" };
+    }
+    const cls = cluster(mems);
+    console.error(`[REFLECT] Clustered into ${cls.length} groups`);
+    let n = 0;
+    for (const c of cls) {
+        const txt = summ(c);
+        const s = sal(c);
+        const src = c.mem.map((m) => m.id);
+        const meta = {
+            type: "auto_reflect",
+            sources: src,
+            freq: c.n,
+            at: new Date().toISOString(),
+        };
+        console.error(`[REFLECT] Creating reflection: ${c.n} memories, salience=${s.toFixed(3)}, sector=${c.mem[0].primary_sector}`);
+        await (0, hsg_1.add_hsg_memory)(txt, (0, utils_1.j)(["reflect:auto"]), meta);
+        await mark(src);
+        await boost(src);
+        n++;
+    }
+    if (n > 0)
+        await (0, db_1.log_maint_op)("reflect", n);
+    console.error(`[REFLECT] Job complete: created ${n} reflections`);
+    return { created: n, clusters: cls.length };
+};
+exports.run_reflection = run_reflection;
+let timer = null;
+const start_reflection = () => {
+    if (!cfg_1.env.auto_reflect || timer)
+        return;
+    const int = (cfg_1.env.reflect_interval || 10) * 60000;
+    timer = setInterval(() => (0, exports.run_reflection)().catch((e) => console.error("[REFLECT]", e)), int);
+    console.error(`[REFLECT] Started: every ${cfg_1.env.reflect_interval || 10}m`);
+};
+exports.start_reflection = start_reflection;
+const stop_reflection = () => {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+};
+exports.stop_reflection = stop_reflection;

package/dist/memory/user_summary.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stop_user_summary_reflection = exports.start_user_summary_reflection = exports.auto_update_user_summaries = exports.update_user_summary = exports.gen_user_summary_async = void 0;
+const db_1 = require("../core/db");
+const cfg_1 = require("../core/cfg");
+const cos = (a, b) => {
+    let d = 0, ma = 0, mb = 0;
+    for (let i = 0; i < a.length; i++) {
+        d += a[i] * b[i];
+        ma += a[i] * a[i];
+        mb += b[i] * b[i];
+    }
+    return d / (Math.sqrt(ma) * Math.sqrt(mb));
+};
+const gen_user_summary = (mems) => {
+    if (!mems.length)
+        return "User profile initializing... (No memories recorded yet)";
+    const recent = mems.slice(0, 10);
+    const projects = new Set();
+    const languages = new Set();
+    const files = new Set();
+    let events = 0;
+    let saves = 0;
+    for (const m of mems) {
+        if (m.meta) {
+            try {
+                const meta = typeof m.meta === 'string' ? JSON.parse(m.meta) : m.meta;
+                if (meta.ide_project_name)
+                    projects.add(meta.ide_project_name);
+                if (meta.language)
+                    languages.add(meta.language);
+                if (meta.ide_file_path)
+                    files.add(meta.ide_file_path.split(/[\\/]/).pop());
+                if (meta.ide_event_type === 'save')
+                    saves++;
+            }
+            catch (e) { /* ignore */ }
+        }
+        events++;
+    }
+    const project_str = projects.size > 0 ? Array.from(projects).join(", ") : "Unknown Project";
+    const lang_str = languages.size > 0 ? Array.from(languages).join(", ") : "General";
+    const recent_files = Array.from(files).slice(0, 3).join(", ");
+    const last_active = mems[0].created_at ? new Date(mems[0].created_at).toLocaleString() : "Recently";
+    return `Active in ${project_str} using ${lang_str}. Focused on ${recent_files || "various files"}. (${mems.length} memories, ${saves} saves). Last active: ${last_active}.`;
+};
+const gen_user_summary_async = async (user_id) => {
+    const mems = await db_1.q.all_mem_by_user.all(user_id, 100, 0);
+    return gen_user_summary(mems);
+};
+exports.gen_user_summary_async = gen_user_summary_async;
+const update_user_summary = async (user_id) => {
+    try {
+        const summary = await (0, exports.gen_user_summary_async)(user_id);
+        const now = Date.now();
+        const existing = await db_1.q.get_user.get(user_id);
+        if (!existing) {
+            await db_1.q.ins_user.run(user_id, summary, 0, now, now);
+        }
+        else {
+            await db_1.q.upd_user_summary.run(user_id, summary, now);
+        }
+    }
+    catch (e) {
+        console.error(`[USER_SUMMARY] Fatal error for ${user_id}:`, e);
+    }
+};
+exports.update_user_summary = update_user_summary;
+const auto_update_user_summaries = async () => {
+    const all_mems = await db_1.q.all_mem.all(10000, 0);
+    const user_ids = new Set(all_mems.map((m) => m.user_id).filter(Boolean));
+    let updated = 0;
+    for (const uid of user_ids) {
+        try {
+            await (0, exports.update_user_summary)(uid);
+            updated++;
+        }
+        catch (e) {
+            console.error(`[USER_SUMMARY] Failed for ${uid}:`, e);
+        }
+    }
+    return { updated };
+};
+exports.auto_update_user_summaries = auto_update_user_summaries;
+let timer = null;
+const start_user_summary_reflection = () => {
+    if (timer)
+        return;
+    const int = (cfg_1.env.user_summary_interval || 30) * 60000;
+    timer = setInterval(() => (0, exports.auto_update_user_summaries)().catch((e) => console.error("[USER_SUMMARY]", e)), int);
+};
+exports.start_user_summary_reflection = start_user_summary_reflection;
+const stop_user_summary_reflection = () => {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+};
+exports.stop_user_summary_reflection = stop_user_summary_reflection;

package/dist/migrate.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const migrate_1 = require("./core/migrate");
+(0, migrate_1.run_migrations)().then(() => {
+    process.exit(0);
+}).catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/ops/compress.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCompressionEngine = exports.compressionEngine = void 0;
+const crypto_1 = require("crypto");
+class MemoryCompressionEngine {
+    stats = {
+        total: 0,
+        ogTok: 0,
+        compTok: 0,
+        saved: 0,
+        avgRatio: 0,
+        latency: 0,
+        algos: {},
+        updated: Date.now(),
+    };
+    cache = new Map();
+    MAX = 500;
+    MS = 0.05;
+    tok(t) {
+        if (!t)
+            return 0;
+        const w = t.split(/\s+/).length;
+        const c = t.length;
+        return Math.ceil(c / 4 + w / 2);
+    }
+    sem(t) {
+        if (!t || t.length < 50)
+            return t;
+        let c = t;
+        const s = c.split(/[.!?]+\s+/);
+        const u = s.filter((x, i, a) => {
+            if (i === 0)
+                return true;
+            const n = x.toLowerCase().trim();
+            const p = a[i - 1].toLowerCase().trim();
+            return n !== p;
+        });
+        c = u.join(". ").trim();
+        const f = [
+            /\b(just|really|very|quite|rather|somewhat|somehow)\b/gi,
+            /\b(actually|basically|essentially|literally)\b/gi,
+            /\b(I think that|I believe that|It seems that|It appears that)\b/gi,
+            /\b(in order to)\b/gi,
+        ];
+        for (const p of f)
+            c = c.replace(p, "");
+        c = c.replace(/\s+/g, " ").trim();
+        const r = [
+            [/\bat this point in time\b/gi, "now"],
+            [/\bdue to the fact that\b/gi, "because"],
+            [/\bin the event that\b/gi, "if"],
+            [/\bfor the purpose of\b/gi, "to"],
+            [/\bin the near future\b/gi, "soon"],
+            [/\ba number of\b/gi, "several"],
+            [/\bprior to\b/gi, "before"],
+            [/\bsubsequent to\b/gi, "after"],
+        ];
+        for (const [p, x] of r)
+            c = c.replace(p, x);
+        return c;
+    }
+    syn(t) {
+        if (!t || t.length < 30)
+            return t;
+        let c = t;
+        const ct = [
+            [/\bdo not\b/gi, "don't"],
+            [/\bcannot\b/gi, "can't"],
+            [/\bwill not\b/gi, "won't"],
+            [/\bshould not\b/gi, "shouldn't"],
+            [/\bwould not\b/gi, "wouldn't"],
+            [/\bit is\b/gi, "it's"],
+            [/\bthat is\b/gi, "that's"],
+            [/\bwhat is\b/gi, "what's"],
+            [/\bwho is\b/gi, "who's"],
+            [/\bthere is\b/gi, "there's"],
+            [/\bhas been\b/gi, "been"],
+            [/\bhave been\b/gi, "been"],
+        ];
+        for (const [p, x] of ct)
+            c = c.replace(p, x);
+        c = c.replace(/\b(the|a|an)\s+(\w+),\s+(the|a|an)\s+/gi, "$2, ");
+        c = c.replace(/\s*{\s*/g, "{").replace(/\s*}\s*/g, "}");
+        c = c.replace(/\s*\(\s*/g, "(").replace(/\s*\)\s*/g, ")");
+        c = c.replace(/\s*;\s*/g, ";");
+        return c;
+    }
+    agg(t) {
+        if (!t)
+            return t;
+        let c = this.sem(t);
+        c = this.syn(c);
+        c = c.replace(/[*_~`#]/g, "");
+        c = c.replace(/https?:\/\/(www\.)?([^\/\s]+)(\/[^\s]*)?/gi, "$2");
+        const a = [
+            [/\bJavaScript\b/gi, "JS"],
+            [/\bTypeScript\b/gi, "TS"],
+            [/\bPython\b/gi, "Py"],
+            [/\bapplication\b/gi, "app"],
+            [/\bfunction\b/gi, "fn"],
+            [/\bparameter\b/gi, "param"],
+            [/\bargument\b/gi, "arg"],
+            [/\breturn\b/gi, "ret"],
+            [/\bvariable\b/gi, "var"],
+            [/\bconstant\b/gi, "const"],
+            [/\bdatabase\b/gi, "db"],
+            [/\brepository\b/gi, "repo"],
+            [/\benvironment\b/gi, "env"],
+            [/\bconfiguration\b/gi, "config"],
+            [/\bdocumentation\b/gi, "docs"],
+        ];
+        for (const [p, x] of a)
+            c = c.replace(p, x);
+        c = c.replace(/\n{3,}/g, "\n\n");
+        c = c
+            .split("\n")
+            .map((l) => l.trim())
+            .join("\n");
+        return c.trim();
+    }
+    compress(t, a = "semantic") {
+        if (!t) {
+            return {
+                og: t,
+                comp: t,
+                metrics: this.empty(a),
+                hash: this.hash(t),
+            };
+        }
+        const k = `${a}:${this.hash(t)}`;
+        if (this.cache.has(k))
+            return this.cache.get(k);
+        const ot = this.tok(t);
+        let c;
+        switch (a) {
+            case "semantic":
+                c = this.sem(t);
+                break;
+            case "syntactic":
+                c = this.syn(t);
+                break;
+            case "aggressive":
+                c = this.agg(t);
+                break;
+            default:
+                c = t;
+        }
+        const ct = this.tok(c);
+        const sv = ot - ct;
+        const r = ct / ot;
+        const p = (sv / ot) * 100;
+        const l = sv * this.MS;
+        const m = {
+            ogTok: ot,
+            compTok: ct,
+            ratio: r,
+            saved: sv,
+            pct: p,
+            latency: l,
+            algo: a,
+            ts: Date.now(),
+        };
+        const res = {
+            og: t,
+            comp: c,
+            metrics: m,
+            hash: this.hash(t),
+        };
+        this.up(m);
+        this.store(k, res);
+        return res;
+    }
+    batch(ts, a = "semantic") {
+        return ts.map((t) => this.compress(t, a));
+    }
+    auto(t) {
+        if (!t || t.length < 50)
+            return this.compress(t, "semantic");
+        const code = /\b(function|const|let|var|def|class|import|export)\b/.test(t);
+        const urls = /https?:\/\//.test(t);
+        const verb = t.split(/\s+/).length > 100;
+        let a;
+        if (code || urls)
+            a = "aggressive";
+        else if (verb)
+            a = "semantic";
+        else
+            a = "syntactic";
+        return this.compress(t, a);
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    analyze(t) {
+        const r = {};
+        for (const a of ["semantic", "syntactic", "aggressive"]) {
+            const x = this.compress(t, a);
+            r[a] = x.metrics;
+        }
+        return r;
+    }
+    reset() {
+        this.stats = {
+            total: 0,
+            ogTok: 0,
+            compTok: 0,
+            saved: 0,
+            avgRatio: 0,
+            latency: 0,
+            algos: {},
+            updated: Date.now(),
+        };
+    }
+    clear() {
+        this.cache.clear();
+    }
+    empty(a) {
+        return {
+            ogTok: 0,
+            compTok: 0,
+            ratio: 1,
+            saved: 0,
+            pct: 0,
+            latency: 0,
+            algo: a,
+            ts: Date.now(),
+        };
+    }
+    hash(t) {
+        return (0, crypto_1.createHash)("md5").update(t).digest("hex").substring(0, 16);
+    }
+    up(m) {
+        this.stats.total++;
+        this.stats.ogTok += m.ogTok;
+        this.stats.compTok += m.compTok;
+        this.stats.saved += m.saved;
+        this.stats.latency += m.latency;
+        if (this.stats.ogTok > 0)
+            this.stats.avgRatio = this.stats.compTok / this.stats.ogTok;
+        if (!this.stats.algos[m.algo])
+            this.stats.algos[m.algo] = 0;
+        this.stats.algos[m.algo]++;
+        this.stats.updated = Date.now();
+    }
+    store(k, r) {
+        if (this.cache.size >= this.MAX) {
+            const f = this.cache.keys().next().value;
+            if (f)
+                this.cache.delete(f);
+        }
+        this.cache.set(k, r);
+    }
+}
+exports.MemoryCompressionEngine = MemoryCompressionEngine;
+exports.compressionEngine = new MemoryCompressionEngine();

package/dist/ops/dynamics.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apply_decay = exports.linkW = exports.SECTOR_INDEX_MAPPING_FOR_MATRIX_LOOKUP = exports.SECTORAL_INTERDEPENDENCE_MATRIX_FOR_COGNITIVE_RESONANCE = exports.TAU_ENERGY_THRESHOLD_FOR_RETRIEVAL = exports.LAMBDA_TWO_SLOW_DECAY_RATE = exports.LAMBDA_ONE_FAST_DECAY_RATE = exports.ETA_REINFORCEMENT_FACTOR_FOR_TRACE_LEARNING = exports.THETA_CONSOLIDATION_COEFFICIENT_FOR_LONG_TERM = exports.GAMMA_ATTENUATION_CONSTANT_FOR_GRAPH_DISTANCE = exports.BETA_LEARNING_RATE_FOR_EMOTIONAL_FREQUENCY = exports.ALPHA_LEARNING_RATE_FOR_RECALL_REINFORCEMENT = void 0;
+exports.calculateDynamicSalienceWithTimeDecay = calculateDynamicSalienceWithTimeDecay;
+exports.calculateDualPhaseDecayMemoryRetention = calculateDualPhaseDecayMemoryRetention;
+exports.calculateAssociativeWaypointLinkWeight = calculateAssociativeWaypointLinkWeight;
+exports.calculateSpreadingActivationEnergyForNode = calculateSpreadingActivationEnergyForNode;
+exports.applyRetrievalTraceReinforcementToMemory = applyRetrievalTraceReinforcementToMemory;
+exports.propagateAssociativeReinforcementToLinkedNodes = propagateAssociativeReinforcementToLinkedNodes;
+exports.calculateCrossSectorResonanceScore = calculateCrossSectorResonanceScore;
+exports.determineEnergyBasedRetrievalThreshold = determineEnergyBasedRetrievalThreshold;
+exports.applyDualPhaseDecayToAllMemories = applyDualPhaseDecayToAllMemories;
+exports.buildAssociativeWaypointGraphFromMemories = buildAssociativeWaypointGraphFromMemories;
+exports.performSpreadingActivationRetrieval = performSpreadingActivationRetrieval;
+exports.retrieveMemoriesWithEnergyThresholding = retrieveMemoriesWithEnergyThresholding;
+const db_1 = require("../core/db");
+const utils_1 = require("../utils");
+const embed_1 = require("../memory/embed");
+exports.ALPHA_LEARNING_RATE_FOR_RECALL_REINFORCEMENT = 0.15;
+exports.BETA_LEARNING_RATE_FOR_EMOTIONAL_FREQUENCY = 0.2;
+exports.GAMMA_ATTENUATION_CONSTANT_FOR_GRAPH_DISTANCE = 0.35;
+exports.THETA_CONSOLIDATION_COEFFICIENT_FOR_LONG_TERM = 0.4;
+exports.ETA_REINFORCEMENT_FACTOR_FOR_TRACE_LEARNING = 0.18;
+exports.LAMBDA_ONE_FAST_DECAY_RATE = 0.015;
+exports.LAMBDA_TWO_SLOW_DECAY_RATE = 0.002;
+exports.TAU_ENERGY_THRESHOLD_FOR_RETRIEVAL = 0.4;
+exports.SECTORAL_INTERDEPENDENCE_MATRIX_FOR_COGNITIVE_RESONANCE = [
+    [1.0, 0.7, 0.3, 0.6, 0.6],
+    [0.7, 1.0, 0.4, 0.7, 0.8],
+    [0.3, 0.4, 1.0, 0.5, 0.2],
+    [0.6, 0.7, 0.5, 1.0, 0.8],
+    [0.6, 0.8, 0.2, 0.8, 1.0],
+];
+exports.SECTOR_INDEX_MAPPING_FOR_MATRIX_LOOKUP = {
+    episodic: 0,
+    semantic: 1,
+    procedural: 2,
+    emotional: 3,
+    reflective: 4,
+};
+const sig = (x) => 1 / (1 + Math.exp(-x));
+const linkW = (sem, emo, α = 0.7, β = 0.3) => sig(α * sem + β * emo);
+exports.linkW = linkW;
+async function calculateDynamicSalienceWithTimeDecay(i, λ, r, e, t) {
+    const d = i * Math.exp(-λ * t);
+    const rc = exports.ALPHA_LEARNING_RATE_FOR_RECALL_REINFORCEMENT * r;
+    const ef = exports.BETA_LEARNING_RATE_FOR_EMOTIONAL_FREQUENCY * e;
+    return Math.max(0, Math.min(1, d + rc + ef));
+}
+async function calculateDualPhaseDecayMemoryRetention(t) {
+    const f = Math.exp(-exports.LAMBDA_ONE_FAST_DECAY_RATE * t);
+    const s = exports.THETA_CONSOLIDATION_COEFFICIENT_FOR_LONG_TERM *
+        Math.exp(-exports.LAMBDA_TWO_SLOW_DECAY_RATE * t);
+    return Math.max(0, Math.min(1, f + s));
+}
+async function calculateAssociativeWaypointLinkWeight(sv, tv, tg) {
+    const sim = (0, embed_1.cosineSimilarity)(sv, tv);
+    const td = tg / 86400000;
+    return Math.max(0, sim / (1 + td));
+}
+async function calculateSpreadingActivationEnergyForNode(nid, an, gr) {
+    const nd = gr.get(nid);
+    if (!nd)
+        return 0;
+    let tot = 0;
+    for (const e of nd.connected_waypoint_edges) {
+        const na = an.get(e.target_node_id) || 0;
+        const att = Math.exp(-exports.GAMMA_ATTENUATION_CONSTANT_FOR_GRAPH_DISTANCE * 1);
+        tot += e.link_weight_value * na * att;
+    }
+    return tot;
+}
+async function applyRetrievalTraceReinforcementToMemory(mid, sal) {
+    return Math.min(1, sal + exports.ETA_REINFORCEMENT_FACTOR_FOR_TRACE_LEARNING * (1 - sal));
+}
+async function propagateAssociativeReinforcementToLinkedNodes(sid, ssal, wps) {
+    const ups = [];
+    for (const wp of wps) {
+        const ld = (await (0, db_1.get_async)("select salience from memories where id=?", [wp.target_id]));
+        if (ld) {
+            const pr = exports.ETA_REINFORCEMENT_FACTOR_FOR_TRACE_LEARNING * wp.weight * ssal;
+            ups.push({
+                node_id: wp.target_id,
+                new_salience: Math.min(1, ld.salience + pr),
+            });
+        }
+    }
+    return ups;
+}
+async function calculateCrossSectorResonanceScore(ms, qs, bs) {
+    const si = exports.SECTOR_INDEX_MAPPING_FOR_MATRIX_LOOKUP[ms] ?? 1;
+    const ti = exports.SECTOR_INDEX_MAPPING_FOR_MATRIX_LOOKUP[qs] ?? 1;
+    return bs * exports.SECTORAL_INTERDEPENDENCE_MATRIX_FOR_COGNITIVE_RESONANCE[si][ti];
+}
+async function determineEnergyBasedRetrievalThreshold(act, tau) {
+    const nrm = Math.max(0.1, act);
+    return Math.max(0.1, Math.min(0.9, tau * (1 + Math.log(nrm + 1))));
+}
+async function applyDualPhaseDecayToAllMemories() {
+    const mems = await (0, db_1.all_async)("select id,salience,decay_lambda,last_seen_at,updated_at,created_at from memories");
+    const ts = (0, utils_1.now)();
+    const ops = mems.map(async (m) => {
+        const tms = Math.max(0, ts - (m.last_seen_at || m.updated_at));
+        const td = tms / 86400000;
+        const rt = await calculateDualPhaseDecayMemoryRetention(td);
+        const nsal = m.salience * rt;
+        await (0, db_1.run_async)(`update ${db_1.memories_table} set salience=?,updated_at=? where id=?`, [Math.max(0, nsal), ts, m.id]);
+    });
+    await Promise.all(ops);
+    console.log(`[DECAY] Applied to ${mems.length} memories`);
+}
+async function buildAssociativeWaypointGraphFromMemories() {
+    const gr = new Map();
+    const wps = (await (0, db_1.all_async)("select src_id,dst_id,weight,created_at from waypoints"));
+    const ids = new Set();
+    for (const wp of wps) {
+        ids.add(wp.src_id);
+        ids.add(wp.dst_id);
+    }
+    for (const id of ids)
+        gr.set(id, {
+            node_memory_id: id,
+            activation_energy_level: 0,
+            connected_waypoint_edges: [],
+        });
+    for (const wp of wps) {
+        const sn = gr.get(wp.src_id);
+        if (sn) {
+            const tg = Math.abs((0, utils_1.now)() - wp.created_at);
+            sn.connected_waypoint_edges.push({
+                target_node_id: wp.dst_id,
+                link_weight_value: wp.weight,
+                time_gap_delta_t: tg,
+            });
+        }
+    }
+    return gr;
+}
+async function performSpreadingActivationRetrieval(init, max) {
+    const gr = await buildAssociativeWaypointGraphFromMemories();
+    const act = new Map();
+    for (const id of init)
+        act.set(id, 1.0);
+    for (let i = 0; i < max; i++) {
+        const ups = new Map();
+        for (const [nid, ca] of act) {
+            const nd = gr.get(nid);
+            if (!nd)
+                continue;
+            for (const e of nd.connected_waypoint_edges) {
+                const pe = await calculateSpreadingActivationEnergyForNode(e.target_node_id, act, gr);
+                const ex = ups.get(e.target_node_id) || 0;
+                ups.set(e.target_node_id, ex + pe);
+            }
+        }
+        for (const [uid, nav] of ups) {
+            const cv = act.get(uid) || 0;
+            act.set(uid, Math.max(cv, nav));
+        }
+    }
+    return act;
+}
+async function retrieveMemoriesWithEnergyThresholding(qv, qs, me) {
+    const mems = (await (0, db_1.all_async)("select id,content,primary_sector,salience,mean_vec from memories where salience>0.01"));
+    const sc = new Map();
+    for (const m of mems) {
+        if (!m.mean_vec)
+            continue;
+        const buf = Buffer.isBuffer(m.mean_vec)
+            ? m.mean_vec
+            : Buffer.from(m.mean_vec);
+        const ev = [];
+        for (let i = 0; i < buf.length; i += 4)
+            ev.push(buf.readFloatLE(i));
+        const bs = (0, embed_1.cosineSimilarity)(qv, ev);
+        const cs = await calculateCrossSectorResonanceScore(m.primary_sector, qs, bs);
+        sc.set(m.id, cs * m.salience);
+    }
+    const sp = await performSpreadingActivationRetrieval(Array.from(sc.keys()).slice(0, 5), 3);
+    const cmb = new Map();
+    for (const m of mems)
+        cmb.set(m.id, (sc.get(m.id) || 0) + (sp.get(m.id) || 0) * 0.3);
+    const te = Array.from(cmb.values()).reduce((s, v) => s + v, 0);
+    const thr = await determineEnergyBasedRetrievalThreshold(te, me);
+    return mems
+        .filter((m) => (cmb.get(m.id) || 0) > thr)
+        .map((m) => ({ ...m, activation_energy: cmb.get(m.id) }));
+}
+exports.apply_decay = applyDualPhaseDecayToAllMemories;