cogmem 3.6.2

package/dist/core/Reflection.js

@@ -0,0 +1,183 @@
+// ============================================
+// 反思模块 - 突触权重更新 + 短期转长期记忆 + SM-2 遗忘曲线
+// ============================================
+import { SynapseUtils } from './Synapse.js';
+import { logger } from '../utils/Logger.js';
+export class Reflection {
+    memoryGraph;
+    activationLog = new Map();
+    coOccurrenceMap = new Map();
+    constructor(memoryGraph) {
+        this.memoryGraph = memoryGraph;
+    }
+    /** 每日权重更新 */
+    async dailyWeightUpdate() {
+        logger.info('Running daily weight update...');
+        const coOccurrences = await this.findCoOccurrences();
+        for (const [pair, count] of coOccurrences) {
+            const [sourceId, targetId] = pair;
+            const synapse = this.getSynapse(sourceId, targetId);
+            if (synapse) {
+                const strengthened = SynapseUtils.strengthen(synapse, count * 0.1);
+                this.updateSynapse(sourceId, strengthened);
+            }
+        }
+        // SM-2 遗忘曲线
+        await this.applySM2Forgetting();
+        this.coOccurrenceMap.clear();
+        logger.info('Daily weight update completed');
+    }
+    /** 动态触发：频繁激活 → 短期转长期 + 增加 stability */
+    onNeuronActivated(neuronId) {
+        const now = Date.now();
+        const activations = this.activationLog.get(neuronId) || [];
+        activations.push(now);
+        const recent = activations.filter(t => now - t < 3600000);
+        this.activationLog.set(neuronId, recent);
+        const neuron = this.memoryGraph.getNeuron(neuronId);
+        if (neuron) {
+            // 更新激活计数
+            const newCount = (neuron.metadata.activationCount || 0) + 1;
+            // SM-2: 增加 stability（稳定性），上限 2.5
+            const newStability = Math.min(2.5, (neuron.metadata.stability || 1.0) + 0.1);
+            const newRepetitions = (neuron.metadata.repetitions || 0) + 1;
+            neuron.metadata.lastActivated = now;
+            neuron.metadata.activationCount = newCount;
+            neuron.metadata.stability = newStability;
+            neuron.metadata.repetitions = newRepetitions;
+            this.memoryGraph.updateNeuronMetadata(neuronId, neuron.metadata);
+        }
+        if (recent.length >= 5) {
+            this.boostSynapses(neuronId);
+            if (neuron)
+                this.detectAndCreateOverrides(neuron);
+        }
+        this.recordCoOccurrence(neuronId);
+    }
+    /** SM-2 遗忘曲线: CurrentWeight = BaseWeight * exp(-elapsedTime_in_days / stability) */
+    async applySM2Forgetting() {
+        const allNeurons = this.memoryGraph.getAllNeurons();
+        const now = Date.now();
+        for (const neuron of allNeurons) {
+            const lastActivated = neuron.metadata.lastActivated || neuron.metadata.createdAt;
+            const stability = neuron.metadata.stability || 1.0;
+            const elapsedDays = (now - lastActivated) / (1000 * 60 * 60 * 24);
+            for (const synapse of neuron.synapses) {
+                // SM-2 公式
+                const decayFactor = Math.exp(-elapsedDays / stability);
+                const newWeight = synapse.weight * decayFactor;
+                this.memoryGraph.addSynapse(neuron.id, { ...synapse, weight: Math.max(0, newWeight) });
+            }
+        }
+        logger.info(`SM-2 forgetting applied to ${allNeurons.length} neurons`);
+    }
+    /** 检测并创建 Overrides 突触 */
+    detectAndCreateOverrides(newNeuron, vectorSearchFn) {
+        const conflicting = this.findConflictingNeurons(newNeuron, vectorSearchFn);
+        for (const oldNeuron of conflicting) {
+            const timeDiffDays = (newNeuron.metadata.createdAt - oldNeuron.metadata.createdAt) / (1000 * 60 * 60 * 24);
+            const dynamicWeight = Math.min(0.5 + Math.abs(timeDiffDays) * 0.05, 1.0);
+            this.memoryGraph.addSynapse(newNeuron.id, {
+                targetId: oldNeuron.id,
+                type: 'Overrides',
+                weight: dynamicWeight
+            });
+            logger.debug(`Created override: ${newNeuron.id} → ${oldNeuron.id}`);
+        }
+    }
+    /** 查找冲突的旧记忆（向量检索 + 极性碰撞） */
+    findConflictingNeurons(newNeuron, vectorSearchFn) {
+        const conflicting = [];
+        const SIMILARITY_THRESHOLD = 0.85;
+        const TIME_WINDOW_DAYS = 30;
+        const now = Date.now();
+        const windowStart = now - TIME_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+        // 向量检索优先
+        if (vectorSearchFn && newNeuron.coordinates.V.length > 0) {
+            const candidates = vectorSearchFn(newNeuron.coordinates.V, 50);
+            for (const { id, score } of candidates) {
+                if (score < SIMILARITY_THRESHOLD)
+                    continue;
+                const old = this.memoryGraph.getNeuron(id);
+                if (!old || old.id === newNeuron.id)
+                    continue;
+                if (old.metadata.createdAt < windowStart)
+                    continue;
+                if (old.metadata.type !== newNeuron.metadata.type)
+                    continue;
+                if (this.checkPolarityCollision(newNeuron, old)) {
+                    conflicting.push(old);
+                }
+            }
+        }
+        return conflicting;
+    }
+    /** 极性碰撞检测 */
+    checkPolarityCollision(a, b) {
+        const pos = ['是', '会', '能', '正确', 'yes', 'true', '确认'];
+        const neg = ['不是', '不会', '不能', '错误', 'no', 'false', '否认', '取消'];
+        const aLower = a.content.toLowerCase();
+        const bLower = b.content.toLowerCase();
+        const aHasPos = pos.some(k => aLower.includes(k));
+        const aHasNeg = neg.some(k => aLower.includes(k));
+        const bHasPos = pos.some(k => bLower.includes(k));
+        const bHasNeg = neg.some(k => bLower.includes(k));
+        return (aHasPos && bHasNeg) || (aHasNeg && bHasPos);
+    }
+    // --- 原有方法保留 ---
+    async findCoOccurrences() {
+        const coOccurrences = new Map();
+        for (const [neuronId, relatedIds] of this.coOccurrenceMap) {
+            for (const relatedId of relatedIds.keys()) {
+                const pair = [neuronId, relatedId].sort().join('-');
+                coOccurrences.set(pair, (coOccurrences.get(pair) || 0) + 1);
+            }
+        }
+        return coOccurrences;
+    }
+    recordCoOccurrence(neuronId) {
+        if (!this.coOccurrenceMap.has(neuronId)) {
+            this.coOccurrenceMap.set(neuronId, new Map());
+        }
+        const related = this.coOccurrenceMap.get(neuronId);
+        const synapses = this.memoryGraph.getSynapses(neuronId);
+        for (const synapse of synapses) {
+            related.set(synapse.targetId, (related.get(synapse.targetId) || 0) + 1);
+        }
+    }
+    boostSynapses(neuronId) {
+        const synapses = this.memoryGraph.getSynapses(neuronId);
+        for (const synapse of synapses) {
+            this.updateSynapse(neuronId, SynapseUtils.strengthen(synapse, 0.2));
+        }
+    }
+    getSynapse(sourceId, targetId) {
+        return this.memoryGraph.getSynapses(sourceId).find(s => s.targetId === targetId) || null;
+    }
+    updateSynapse(sourceId, synapse) {
+        this.memoryGraph.addSynapse(sourceId, synapse);
+    }
+    async createAnchor(neuronIds, projectId) {
+        return this.memoryGraph.createAnchor(neuronIds, projectId);
+    }
+    getActivationStats() {
+        let total = 0;
+        const top = [];
+        for (const [id, acts] of this.activationLog) {
+            total += acts.length;
+            top.push({ id, count: acts.length });
+        }
+        top.sort((a, b) => b.count - a.count);
+        return { totalActivations: total, activeNeurons: this.activationLog.size, topActivated: top.slice(0, 10) };
+    }
+    cleanupOldActivations(maxAge = 86400000) {
+        const now = Date.now();
+        for (const [id, acts] of this.activationLog) {
+            const recent = acts.filter(t => now - t < maxAge);
+            if (recent.length === 0)
+                this.activationLog.delete(id);
+            else
+                this.activationLog.set(id, recent);
+        }
+    }
+}

package/dist/core/ResonanceCore.d.ts

@@ -0,0 +1,26 @@
+import type { Neuron, TemporalOperator, SpatialOperator } from '../types/index.js';
+interface IReasoningChainStore {
+    areNeuronsInSameChain(n1: string, n2: string): boolean;
+}
+export declare class ResonanceCore {
+    private static chainStore;
+    static setChainStore(store: IReasoningChainStore): void;
+    /** 能量传导（含推理链强化 + 置信度乘数） */
+    static propagateEnergy(anchorNeuron: Neuron, getNeuron: (id: string) => Neuron | null, maxHops?: number): Promise<Map<string, number>>;
+    /** 获取衰减系数（推理链强化） */
+    private static getDecayFactor;
+    /** 突触类型衰减系数 */
+    private static getSynapseDecay;
+    private static calculateDecayedEnergy;
+    /** 应用能量排序（含置信度） */
+    static applyEnergyRanking(candidates: Neuron[], energyMap: Map<string, number>, temporalOp?: TemporalOperator, spatialOp?: SpatialOperator): Array<{
+        neuron: Neuron;
+        energy: number;
+    }>;
+    private static calculateTemporalEnergy;
+    private static calculateSpatialEnergy;
+    static calculateTotalEnergy(energyMap: Map<string, number>): number;
+    static calculateResonanceDepth(energyMap: Map<string, number>): number;
+}
+export {};
+//# sourceMappingURL=ResonanceCore.d.ts.map

package/dist/core/ResonanceCore.js

@@ -0,0 +1,115 @@
+// ============================================
+// 共振核心 - 能量传导算法（含推理链强化 + 置信度乘数）
+// ============================================
+import { config } from '../utils/Config.js';
+export class ResonanceCore {
+    static chainStore = null;
+    static setChainStore(store) {
+        this.chainStore = store;
+    }
+    /** 能量传导（含推理链强化 + 置信度乘数） */
+    static async propagateEnergy(anchorNeuron, getNeuron, maxHops = 5) {
+        const energyMap = new Map();
+        const queue = [
+            { neuronId: anchorNeuron.id, energy: config.energy.initialEnergy, hops: 0 }
+        ];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const { neuronId, energy, hops } = queue.shift();
+            if (visited.has(neuronId) || hops > maxHops)
+                continue;
+            visited.add(neuronId);
+            const neuron = getNeuron(neuronId);
+            if (!neuron || neuron.metadata.status === 'suspect')
+                continue;
+            if (neuron.metadata.status === 'cold' || neuron.metadata.status === 'archived')
+                continue;
+            // 置信度乘数
+            const confidence = neuron.metadata.confidence ?? 1.0;
+            const decayedEnergy = this.calculateDecayedEnergy(energy, hops) * confidence;
+            const existing = energyMap.get(neuronId) || 0;
+            energyMap.set(neuronId, Math.max(existing, decayedEnergy));
+            for (const synapse of neuron.synapses) {
+                // 推理链强化：同一链内 Sequence 突触衰减系数提升至 0.85
+                const decayFactor = this.getDecayFactor(synapse, neuronId);
+                const nextEnergy = decayedEnergy * synapse.weight * decayFactor;
+                queue.push({ neuronId: synapse.targetId, energy: nextEnergy, hops: hops + 1 });
+            }
+        }
+        return energyMap;
+    }
+    /** 获取衰减系数（推理链强化） */
+    static getDecayFactor(synapse, sourceId) {
+        if (synapse.type === 'Sequence' && this.chainStore) {
+            if (this.chainStore.areNeuronsInSameChain(sourceId, synapse.targetId)) {
+                return 0.85; // 同一推理链，强化
+            }
+        }
+        return this.getSynapseDecay(synapse.type);
+    }
+    /** 突触类型衰减系数 */
+    static getSynapseDecay(type) {
+        const DECAY = {
+            'Caused_by': 0.9,
+            'Sequence': 0.6,
+            'Similar': 0.75,
+            'Referenced': 0.8,
+            'Overrides': 0.95,
+            'Default': 0.8
+        };
+        return DECAY[type] || DECAY.Default;
+    }
+    static calculateDecayedEnergy(initialEnergy, hops) {
+        return initialEnergy * Math.pow(0.8, hops);
+    }
+    /** 应用能量排序（含置信度） */
+    static applyEnergyRanking(candidates, energyMap, temporalOp, spatialOp) {
+        const overriddenIds = new Set();
+        for (const neuron of candidates) {
+            const overrides = neuron.synapses.filter(s => s.type === 'Overrides');
+            for (const override of overrides) {
+                overriddenIds.add(override.targetId);
+            }
+        }
+        const filtered = candidates.filter(n => !overriddenIds.has(n.id));
+        return filtered.map(neuron => {
+            let energy = energyMap.get(neuron.id) || 50;
+            // 置信度加成
+            const confidence = neuron.metadata.confidence ?? 1.0;
+            energy *= confidence;
+            if (temporalOp)
+                energy += this.calculateTemporalEnergy(neuron, temporalOp);
+            if (spatialOp)
+                energy += this.calculateSpatialEnergy(neuron, spatialOp);
+            return { neuron, energy };
+        }).sort((a, b) => b.energy - a.energy);
+    }
+    static calculateTemporalEnergy(neuron, op) {
+        const ts = neuron.coordinates.T;
+        if (op.type === 'range' && op.start && op.end) {
+            return (ts >= op.start && ts <= op.end) ? 50 : Math.max(-30, 50 - Math.min(Math.abs(ts - op.start), Math.abs(ts - op.end)) / 30 * 50);
+        }
+        if (op.type === 'dynamic' && op.threshold) {
+            return ts >= op.threshold ? 50 : Math.max(-30, 50 - (op.threshold - ts) / 30 * 50);
+        }
+        return 0;
+    }
+    static calculateSpatialEnergy(neuron, op) {
+        const [x, y] = neuron.coordinates.S;
+        if (op.type === 'point' && op.center) {
+            const dist = Math.sqrt(Math.pow(x - op.center[0], 2) + Math.pow(y - op.center[1], 2));
+            return dist <= (op.radius || 10) ? 40 : Math.max(-20, 40 - dist * 2);
+        }
+        if (op.type === 'gravity' && op.center) {
+            const dist = Math.sqrt(Math.pow(x - op.center[0], 2) + Math.pow(y - op.center[1], 2));
+            return Math.max(0, 40 * (op.weight || 0.1) / (1 + dist / 100));
+        }
+        return 0;
+    }
+    static calculateTotalEnergy(energyMap) {
+        return Array.from(energyMap.values()).reduce((sum, e) => sum + e, 0);
+    }
+    static calculateResonanceDepth(energyMap) {
+        return Array.from(energyMap.values()).filter(e => e > 0).length;
+    }
+}

package/dist/core/Synapse.d.ts

@@ -0,0 +1,10 @@
+import type { Synapse, SynapseType } from '../types/index.js';
+export declare class SynapseUtils {
+    static readonly DECAY_FACTORS: Record<SynapseType, number>;
+    static getDecayFactor(type: SynapseType): number;
+    static create(targetId: string, type: SynapseType, weight?: number): Synapse;
+    static calculateDecay(initialEnergy: number, synapseType: SynapseType, hops: number): number;
+    static strengthen(synapse: Synapse, amount?: number): Synapse;
+    static weaken(synapse: Synapse, amount?: number): Synapse;
+}
+//# sourceMappingURL=Synapse.d.ts.map

package/dist/core/Synapse.js

@@ -0,0 +1,27 @@
+// ============================================
+// 突触工具 - 神经元连接管理
+// ============================================
+export class SynapseUtils {
+    static DECAY_FACTORS = {
+        Caused_by: 0.9,
+        Sequence: 0.6,
+        Similar: 0.75,
+        Referenced: 0.8,
+        Overrides: 0.95
+    };
+    static getDecayFactor(type) {
+        return this.DECAY_FACTORS[type] || 0.8;
+    }
+    static create(targetId, type, weight = 1.0) {
+        return { targetId, type, weight: Math.min(1.0, Math.max(0.0, weight)) };
+    }
+    static calculateDecay(initialEnergy, synapseType, hops) {
+        return initialEnergy * Math.pow(this.getDecayFactor(synapseType), hops);
+    }
+    static strengthen(synapse, amount = 0.1) {
+        return { ...synapse, weight: Math.min(1.0, synapse.weight + amount) };
+    }
+    static weaken(synapse, amount = 0.05) {
+        return { ...synapse, weight: Math.max(0.0, synapse.weight - amount) };
+    }
+}

package/dist/core/TwoStagePulseRanker.d.ts

@@ -0,0 +1,16 @@
+import type { Neuron, QueryResult } from '../types/index.js';
+import type { QueryIR } from '../types/query-ir.js';
+import type { IVectorStore } from '../store/IVectorStore.js';
+export declare class TwoStagePulseRanker {
+    private vectorStore;
+    private topK;
+    constructor(vectorStore: IVectorStore, topK?: number);
+    query(queryVector: number[], getNeuron: (id: string) => Neuron | null, ir: QueryIR): Promise<QueryResult>;
+    private convertTemporalConstraint;
+    private convertSpatialConstraint;
+    private resolveRelativeTime;
+    private applyHardConstraints;
+    setTopK(k: number): void;
+    getTopK(): number;
+}
+//# sourceMappingURL=TwoStagePulseRanker.d.ts.map

package/dist/core/TwoStagePulseRanker.js

@@ -0,0 +1,120 @@
+// ============================================
+// 二级脉冲 - 高性能检索（QueryIR 驱动）
+// ============================================
+import { config } from '../utils/Config.js';
+import { ResonanceCore } from './ResonanceCore.js';
+export class TwoStagePulseRanker {
+    vectorStore;
+    topK;
+    constructor(vectorStore, topK = config.vector.topK) {
+        this.vectorStore = vectorStore;
+        this.topK = topK;
+    }
+    async query(queryVector, getNeuron, ir) {
+        const startTime = Date.now();
+        const semanticCandidates = await this.vectorStore.search(queryVector, this.topK);
+        const candidates = [];
+        for (const { id } of semanticCandidates) {
+            const neuron = getNeuron(id);
+            if (neuron)
+                candidates.push(neuron);
+        }
+        const hardFiltered = this.applyHardConstraints(candidates, ir);
+        const energyMap = new Map();
+        for (const { id, score } of semanticCandidates) {
+            if (hardFiltered.some(n => n.id === id)) {
+                energyMap.set(id, score * config.energy.initialEnergy);
+            }
+        }
+        const temporalOp = this.convertTemporalConstraint(ir.temporal);
+        const spatialOp = this.convertSpatialConstraint(ir.spatial);
+        const ranked = ResonanceCore.applyEnergyRanking(hardFiltered, energyMap, temporalOp, spatialOp);
+        const sortedNeurons = ranked.sort((a, b) => b.energy - a.energy).map(r => r.neuron);
+        return {
+            neurons: sortedNeurons,
+            totalEnergy: ResonanceCore.calculateTotalEnergy(energyMap),
+            resonanceDepth: ResonanceCore.calculateResonanceDepth(energyMap),
+            queryTime: Date.now() - startTime
+        };
+    }
+    convertTemporalConstraint(constraint) {
+        if (constraint.start || constraint.end) {
+            return { type: 'range', start: constraint.start, end: constraint.end };
+        }
+        if (constraint.relative) {
+            const range = this.resolveRelativeTime(constraint.relative);
+            return { type: 'range', start: range.start, end: range.end };
+        }
+        return { type: 'range' };
+    }
+    convertSpatialConstraint(constraint) {
+        if (constraint.projectId) {
+            return { type: 'point', center: [0, 0], radius: 100 };
+        }
+        return { type: 'point', center: [0, 0], radius: 100 };
+    }
+    resolveRelativeTime(relative) {
+        const now = Date.now();
+        const day = 86400000;
+        const today = new Date().setHours(0, 0, 0, 0);
+        switch (relative) {
+            case 'today': return { start: today, end: now };
+            case 'yesterday': return { start: today - day, end: today };
+            case 'this_week': return { start: today - (new Date(today).getDay() * day), end: now };
+            case 'last_week': return { start: today - ((new Date(today).getDay() + 7) * day), end: today };
+            case 'this_month': return { start: new Date(new Date().getFullYear(), new Date().getMonth(), 1).getTime(), end: now };
+            case 'last_month': return { start: new Date(new Date().getFullYear(), new Date().getMonth() - 1, 1).getTime(), end: new Date(new Date().getFullYear(), new Date().getMonth(), 0).getTime() };
+            case 'this_year': return { start: new Date(new Date().getFullYear(), 0, 1).getTime(), end: now };
+            case 'last_year': return {
+                start: new Date(new Date().getFullYear() - 1, 0, 1).getTime(),
+                end: new Date(new Date().getFullYear(), 0, 1).getTime()
+            };
+            case 'past_six_months': return {
+                start: new Date(new Date().getFullYear(), new Date().getMonth() - 6, new Date().getDate()).getTime(),
+                end: now
+            };
+            case 'past_year': return {
+                start: new Date(new Date().getFullYear() - 1, new Date().getMonth(), new Date().getDate()).getTime(),
+                end: now
+            };
+            case 'around_half_year_ago': {
+                const center = new Date(new Date().getFullYear(), new Date().getMonth() - 6, new Date().getDate()).getTime();
+                return { start: center - 30 * day, end: center + 30 * day };
+            }
+            default: return { start: 0, end: now };
+        }
+    }
+    applyHardConstraints(neurons, ir) {
+        let filtered = neurons;
+        if (ir.temporal.start || ir.temporal.end) {
+            const start = ir.temporal.start || 0;
+            const end = ir.temporal.end || Date.now();
+            filtered = filtered.filter(n => {
+                const ts = n.coordinates.T;
+                return ts >= start && ts <= end;
+            });
+        }
+        else if (ir.temporal.relative) {
+            const range = this.resolveRelativeTime(ir.temporal.relative);
+            filtered = filtered.filter(n => {
+                const ts = n.coordinates.T;
+                return ts >= range.start && ts <= range.end;
+            });
+        }
+        if (ir.spatial.projectId) {
+            filtered = filtered.filter(n => n.metadata.projectId === ir.spatial.projectId);
+        }
+        if (ir.spatial.fileType) {
+            filtered = filtered.filter(n => {
+                const ext = n.metadata.filePath?.split('.').pop()?.toLowerCase();
+                return ext === ir.spatial.fileType?.toLowerCase();
+            });
+        }
+        for (const kw of ir.mustMatch) {
+            filtered = filtered.filter(n => n.content.toLowerCase().includes(kw.toLowerCase()));
+        }
+        return filtered;
+    }
+    setTopK(k) { this.topK = k; }
+    getTopK() { return this.topK; }
+}

package/dist/dream/DreamScheduler.d.ts

@@ -0,0 +1,47 @@
+import type { DreamCuratorWorker } from '../engine/DreamCuratorWorker.js';
+import type { EpisodeStore } from '../episode/EpisodeStore.js';
+export type DreamTickMode = 'auto' | 'micro' | 'normal' | 'deep';
+export type SelectedDreamMode = 'none' | 'micro' | 'normal' | 'deep';
+export interface DreamTickOptions {
+    projectId?: string;
+    mode?: DreamTickMode;
+    maxEpisodes?: number;
+    now?: number;
+    softSealGraceMs?: number;
+    leaseMs?: number;
+    maxAttempts?: number;
+    maintenanceReason?: 'daily' | 'upgrade_repair';
+}
+export interface DreamTickResult {
+    runId: string;
+    projectId?: string;
+    requestedMode: DreamTickMode;
+    selectedMode: SelectedDreamMode;
+    selectedModes: {
+        micro: number;
+        normal: number;
+        deep: number;
+    };
+    skipped: boolean;
+    reason: string;
+    processedEpisodeCount: number;
+    failedEpisodeCount: number;
+    candidateCount: number;
+    episodeIds: string[];
+    candidateIds: string[];
+    durationMs: number;
+    failedEpisodes: Array<{
+        episodeId: string;
+        error: string;
+        failureCategory: string;
+        retryAfter?: number;
+    }>;
+}
+export declare class DreamScheduler {
+    private readonly episodeStore;
+    private readonly curator;
+    constructor(episodeStore: EpisodeStore, curator: DreamCuratorWorker);
+    tick(options?: DreamTickOptions): Promise<DreamTickResult>;
+    private recordRun;
+}
+//# sourceMappingURL=DreamScheduler.d.ts.map