cogmem 3.6.2

package/dist/engine/GraphCommunityEngine.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+export interface GraphCommunityEngineOptions {
+    maxIterations?: number;
+    minCommunitySize?: number;
+    excludeArchived?: boolean;
+    incrementalWindowMs?: number;
+}
+export declare class GraphCommunityEngine {
+    private readonly memoryGraph;
+    private readonly options;
+    constructor(memoryGraph: MemoryGraph, options?: GraphCommunityEngineOptions);
+    run(projectId: string): Promise<{
+        communitiesDetected: number;
+        neuronsUpdated: number;
+    }>;
+    getCommunityMembers(communityId: string): string[];
+    private neighborIds;
+    private mergeSmallCommunities;
+}
+//# sourceMappingURL=GraphCommunityEngine.d.ts.map

package/dist/engine/GraphCommunityEngine.js

@@ -0,0 +1,91 @@
+export class GraphCommunityEngine {
+    memoryGraph;
+    options;
+    constructor(memoryGraph, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.options = options;
+    }
+    async run(projectId) {
+        const maxIterations = this.options.maxIterations ?? 20;
+        const minCommunitySize = this.options.minCommunitySize ?? 3;
+        const allProjectNeurons = this.memoryGraph.getAllNeurons()
+            .filter((neuron) => neuron.metadata.projectId === projectId)
+            .filter((neuron) => this.options.excludeArchived === false || neuron.metadata.status !== 'archived');
+        const incrementalWindowMs = this.options.incrementalWindowMs ?? 48 * 60 * 60 * 1000;
+        const changedIds = incrementalWindowMs === 0
+            ? new Set(allProjectNeurons.map((neuron) => neuron.id))
+            : new Set(allProjectNeurons
+                .filter((neuron) => (neuron.metadata.updatedAt || neuron.metadata.createdAt || 0) > Date.now() - incrementalWindowMs)
+                .map((neuron) => neuron.id));
+        const touchedIds = new Set(changedIds);
+        const allById = new Map(allProjectNeurons.map((neuron) => [neuron.id, neuron]));
+        for (const neuron of allProjectNeurons) {
+            if (changedIds.has(neuron.id)) {
+                for (const id of this.neighborIds(neuron, allById))
+                    touchedIds.add(id);
+            }
+            else if (this.neighborIds(neuron, allById).some((id) => changedIds.has(id))) {
+                touchedIds.add(neuron.id);
+            }
+        }
+        const neurons = allProjectNeurons.filter((neuron) => touchedIds.has(neuron.id));
+        const byId = new Map(neurons.map((neuron) => [neuron.id, neuron]));
+        const neighbors = new Map(neurons.map((neuron) => [neuron.id, this.neighborIds(neuron, byId)]));
+        const labels = new Map(neurons.map((neuron) => [neuron.id, neuron.id]));
+        for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+            let changed = false;
+            for (const neuron of neurons) {
+                const next = mostFrequent((neighbors.get(neuron.id) || []).map((id) => labels.get(id) || id));
+                if (next && labels.get(neuron.id) !== next) {
+                    labels.set(neuron.id, next);
+                    changed = true;
+                }
+            }
+            if (!changed)
+                break;
+        }
+        this.mergeSmallCommunities(labels, neighbors, minCommunitySize);
+        let neuronsUpdated = 0;
+        for (const [neuronId, communityId] of labels) {
+            if (byId.get(neuronId)?.metadata.communityId === communityId)
+                continue;
+            this.memoryGraph.updateNeuronMetadata(neuronId, { communityId });
+            neuronsUpdated += 1;
+        }
+        return { communitiesDetected: new Set(labels.values()).size, neuronsUpdated };
+    }
+    getCommunityMembers(communityId) {
+        return this.memoryGraph.getAllNeurons()
+            .filter((neuron) => neuron.metadata.communityId === communityId)
+            .map((neuron) => neuron.id);
+    }
+    neighborIds(neuron, byId) {
+        const out = neuron.synapses.map((synapse) => synapse.targetId).filter((id) => byId.has(id));
+        const incoming = Array.from(byId.values())
+            .filter((other) => other.synapses.some((synapse) => synapse.targetId === neuron.id))
+            .map((other) => other.id);
+        return Array.from(new Set([...out, ...incoming]));
+    }
+    mergeSmallCommunities(labels, neighbors, minSize) {
+        const sizes = countLabels(labels);
+        for (const [neuronId, label] of labels) {
+            if ((sizes.get(label) || 0) >= minSize)
+                continue;
+            const replacement = mostFrequent((neighbors.get(neuronId) || []).map((id) => labels.get(id) || id));
+            if (replacement)
+                labels.set(neuronId, replacement);
+        }
+    }
+}
+function mostFrequent(values) {
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) || 0) + 1);
+    return Array.from(counts.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0];
+}
+function countLabels(labels) {
+    const counts = new Map();
+    for (const label of labels.values())
+        counts.set(label, (counts.get(label) || 0) + 1);
+    return counts;
+}

package/dist/engine/ImportanceSignalDetector.d.ts

@@ -0,0 +1,11 @@
+import type { MemoryImportanceLevel } from '../types/index.js';
+export declare const PERMANENT_SIGNALS: readonly RegExp[];
+export declare const IMPORTANT_SIGNALS: readonly RegExp[];
+export declare class ImportanceSignalDetector {
+    private readonly permanentSignals;
+    private readonly importantSignals;
+    constructor(permanentSignals?: readonly RegExp[], importantSignals?: readonly RegExp[]);
+    detect(content: string): MemoryImportanceLevel;
+    static detect(content: string): MemoryImportanceLevel;
+}
+//# sourceMappingURL=ImportanceSignalDetector.d.ts.map

package/dist/engine/ImportanceSignalDetector.js

@@ -0,0 +1,51 @@
+export const PERMANENT_SIGNALS = [
+    /永远(记住|不能忘|不要忘|不能违反)/,
+    /永久(记住|保留)/,
+    /绝对不能/,
+    /核心约束/,
+    /never forget/i,
+    /remember permanently/i,
+    /core constraint/i
+];
+export const IMPORTANT_SIGNALS = [
+    /这(件事|条|个)?.*(很|非常|相当)?重要/,
+    /请记住/,
+    /不要忘记/,
+    /别忘记/,
+    /关键(需求|约束|配置|决定|事实)/,
+    /this is important/i,
+    /please remember/i,
+    /must remember/i,
+    /don't forget/i,
+    /key requirement/i
+];
+const NON_MEMORY_CONTEXT_SIGNALS = [
+    /^(日志|代码注释|工具输出|引用文本|报错|错误日志)/,
+    /^(log|code comment|tool output|quoted text|error log)/i
+];
+export class ImportanceSignalDetector {
+    permanentSignals;
+    importantSignals;
+    constructor(permanentSignals = PERMANENT_SIGNALS, importantSignals = IMPORTANT_SIGNALS) {
+        this.permanentSignals = permanentSignals;
+        this.importantSignals = importantSignals;
+        if (this.permanentSignals.length === 0 || this.importantSignals.length === 0) {
+            throw new Error('Importance signal rules must not be empty.');
+        }
+    }
+    detect(content) {
+        const text = content.trim();
+        if (!text)
+            return 'normal';
+        if (NON_MEMORY_CONTEXT_SIGNALS.some((pattern) => pattern.test(text)))
+            return 'normal';
+        if (this.permanentSignals.some((pattern) => pattern.test(text)))
+            return 'permanent';
+        if (this.importantSignals.some((pattern) => pattern.test(text)))
+            return 'important';
+        return 'normal';
+    }
+    static detect(content) {
+        return new ImportanceSignalDetector().detect(content);
+    }
+}

package/dist/engine/IngestionEngine.d.ts

@@ -0,0 +1,44 @@
+import type { Neuron, IngestInput } from '../types/index.js';
+import { Embedder } from '../store/Embedder.js';
+interface IngestRuntimeOptions {
+    prevNeuronSelfHash?: string | null;
+}
+export declare class IngestionEngine {
+    private readonly vectorDimension;
+    private embedder;
+    private projectId?;
+    private vectorSearchFn?;
+    private getNeuronFn?;
+    private activateNeuronFn?;
+    constructor(embedder: Embedder, projectId?: string, vectorDimension?: number);
+    /** 设置去重所需的依赖 */
+    setDedupDeps(vectorSearchFn: (vector: number[], k: number) => Array<{
+        id: string;
+        score: number;
+    }>, getNeuronFn: (id: string) => Neuron | null, activateNeuronFn: (id: string) => void): void;
+    /** 摄取输入并创建神经元（含双重去重） */
+    ingest(input: IngestInput, options?: IngestRuntimeOptions): Promise<{
+        neuron: Neuron;
+        isDuplicate: boolean;
+        activatedId?: string;
+    }>;
+    /** 双重去重检查 */
+    private checkDuplicate;
+    /** 同步摄取（用于事务） */
+    ingestSync(input: IngestInput, options?: IngestRuntimeOptions): Neuron;
+    /** 批量摄取 */
+    ingestBatch(inputs: IngestInput[]): Promise<Array<{
+        neuron: Neuron;
+        isDuplicate: boolean;
+    }>>;
+    /** 计算空间坐标 */
+    private calculateSpatialCoordinates;
+    /** 获取文件类型代码 */
+    private getFileTypeCode;
+    /** 计算重要性权重 */
+    private calculateImportance;
+    setProjectId(id: string): void;
+    getProjectId(): string | undefined;
+}
+export {};
+//# sourceMappingURL=IngestionEngine.d.ts.map

package/dist/engine/IngestionEngine.js

@@ -0,0 +1,182 @@
+// @ts-nocheck
+// ============================================
+// 摄取引擎 - 日志/对话 → 神经元（含双重去重）
+// ============================================
+import { NeuronFactory } from '../core/Neuron.js';
+import { HashUtils } from '../utils/hash.js';
+import { aaakGenerator } from '../utils/AAAKGenerator.js';
+import { IMPORTANCE_STABILITY_MAP } from '../core/ImportanceLevels.js';
+import { ImportanceSignalDetector } from './ImportanceSignalDetector.js';
+import { config } from '../utils/Config.js';
+export class IngestionEngine {
+    vectorDimension;
+    embedder;
+    projectId;
+    vectorSearchFn;
+    getNeuronFn;
+    activateNeuronFn;
+    constructor(embedder, projectId, vectorDimension = config.vector.dimension) {
+        this.vectorDimension = vectorDimension;
+        this.embedder = embedder;
+        this.projectId = projectId;
+    }
+    /** 设置去重所需的依赖 */
+    setDedupDeps(vectorSearchFn, getNeuronFn, activateNeuronFn) {
+        this.vectorSearchFn = vectorSearchFn;
+        this.getNeuronFn = getNeuronFn;
+        this.activateNeuronFn = activateNeuronFn;
+    }
+    /** 摄取输入并创建神经元（含双重去重） */
+    async ingest(input, options = {}) {
+        const createdAt = input.createdAt ?? Date.now();
+        const updatedAt = input.updatedAt ?? createdAt;
+        // 1. 计算语义向量
+        const V = await this.embedder.embed(input.content);
+        // 2. 双重去重检查
+        const dedupResult = await this.checkDuplicate(input.content, V, input.projectId);
+        if (dedupResult.isDuplicate && dedupResult.existingNeuronId) {
+            // 高度雷同：激活旧神经元，不创建新的
+            this.activateNeuronFn?.(dedupResult.existingNeuronId);
+            const existingNeuron = this.getNeuronFn?.(dedupResult.existingNeuronId);
+            if (existingNeuron) {
+                return { neuron: existingNeuron, isDuplicate: true, activatedId: dedupResult.existingNeuronId };
+            }
+        }
+        // 3. 计算坐标
+        const coordinates = {
+            T: createdAt,
+            S: this.calculateSpatialCoordinates(input.filePath),
+            V
+        };
+        // 4. 计算 self_hash（内容 + 时间戳 + 随机数防碰撞）
+        const nonce = Math.random().toString(36).substring(2, 10);
+        const selfHash = HashUtils.computeSelfHash(input.content, coordinates.T, coordinates.S);
+        // 5. 计算 prev_hash
+        const prevHash = HashUtils.computePrevHash(options.prevNeuronSelfHash || null);
+        // 6. 创建元数据
+        const detectedImportance = input.importanceLevel || ImportanceSignalDetector.detect(input.content);
+        const isPinned = input.isPinned ?? detectedImportance !== 'normal';
+        const metadata = {
+            projectId: input.projectId || this.projectId,
+            topicPath: input.topicPath,
+            filePath: input.filePath,
+            type: input.type,
+            createdAt,
+            updatedAt,
+            tags: input.tags,
+            confidence: 1.0,
+            sourceType: input.sourceType || 'user_input',
+            sourceEventId: input.sourceEventId,
+            sourceRefs: input.sourceRefs,
+            stability: IMPORTANCE_STABILITY_MAP[detectedImportance],
+            repetitions: 0,
+            importanceLevel: detectedImportance,
+            isPinned
+        };
+        // 7. 创建神经元
+        const neuron = NeuronFactory.create(input.content, prevHash, { ...coordinates }, metadata);
+        neuron.self_hash = selfHash;
+        // 8. 生成 AAAK 摘要
+        const importance = this.calculateImportance(input.content);
+        neuron.metadata.aaak_summary = await aaakGenerator.generateSummary(input.content, input.type, importance);
+        return { neuron, isDuplicate: false };
+    }
+    /** 双重去重检查 */
+    async checkDuplicate(content, vector, projectId) {
+        const SIMILARITY_THRESHOLD = 0.98;
+        // 检查 1: self_hash 验证（基于内容的快速检查）
+        const contentHash = HashUtils.sha256(content);
+        // 这里可以维护一个内存中的 contentHash → neuronId 映射进行快速查找
+        // 检查 2: 向量相似度拦截
+        if (this.vectorSearchFn && this.getNeuronFn) {
+            const candidates = this.vectorSearchFn(vector, 10);
+            for (const { id, score } of candidates) {
+                if (score >= SIMILARITY_THRESHOLD) {
+                    const existing = this.getNeuronFn(id);
+                    if (existing && (!projectId || existing.metadata.projectId === projectId)) {
+                        return { isDuplicate: true, existingNeuronId: id, similarity: score };
+                    }
+                }
+            }
+        }
+        return { isDuplicate: false };
+    }
+    /** 同步摄取（用于事务） */
+    ingestSync(input, options = {}) {
+        const T = input.createdAt ?? Date.now();
+        const updatedAt = input.updatedAt ?? T;
+        const S = this.calculateSpatialCoordinates(input.filePath);
+        const hash = HashUtils.sha256(input.content);
+        const V = [];
+        for (let i = 0; i < this.vectorDimension; i++) {
+            V.push((hash.charCodeAt(i % hash.length) - 48) / 48 * 2 - 1);
+        }
+        const prevHash = HashUtils.computePrevHash(options.prevNeuronSelfHash || null);
+        const detectedImportance = input.importanceLevel || ImportanceSignalDetector.detect(input.content);
+        const isPinned = input.isPinned ?? detectedImportance !== 'normal';
+        const metadata = {
+            projectId: input.projectId || this.projectId,
+            topicPath: input.topicPath,
+            filePath: input.filePath,
+            type: input.type,
+            createdAt: T,
+            updatedAt,
+            tags: input.tags,
+            confidence: 1.0,
+            sourceType: input.sourceType || 'user_input',
+            sourceEventId: input.sourceEventId,
+            sourceRefs: input.sourceRefs,
+            stability: IMPORTANCE_STABILITY_MAP[detectedImportance],
+            repetitions: 0,
+            importanceLevel: detectedImportance,
+            isPinned
+        };
+        const importance = this.calculateImportance(input.content);
+        const neuron = NeuronFactory.create(input.content, prevHash, { T, S, V }, metadata);
+        neuron.metadata.aaak_summary = aaakGenerator.generateSummarySync(input.content, input.type, importance);
+        return neuron;
+    }
+    /** 批量摄取 */
+    async ingestBatch(inputs) {
+        const results = [];
+        for (const input of inputs) {
+            const result = await this.ingest(input);
+            results.push(result);
+        }
+        return results;
+    }
+    /** 计算空间坐标 */
+    calculateSpatialCoordinates(filePath) {
+        if (!filePath)
+            return [0, 0, 0];
+        const depth = filePath.split('/').length;
+        const nameHash = HashUtils.sha256(filePath);
+        const x = depth % 100;
+        const y = parseInt(nameHash.substring(0, 8), 16) % 100;
+        const z = this.getFileTypeCode(filePath);
+        return [x, y, z];
+    }
+    /** 获取文件类型代码 */
+    getFileTypeCode(filePath) {
+        const ext = filePath.split('.').pop()?.toLowerCase() || '';
+        const codes = {
+            'ts': 1, 'js': 2, 'json': 3, 'md': 4, 'txt': 5, 'py': 6, 'rb': 7, 'go': 8, 'rs': 9
+        };
+        return codes[ext] || 0;
+    }
+    /** 计算重要性权重 */
+    calculateImportance(content) {
+        const len = content.length;
+        if (len < 50)
+            return 1;
+        if (len < 100)
+            return 2;
+        if (len < 200)
+            return 3;
+        if (len < 500)
+            return 4;
+        return 5;
+    }
+    setProjectId(id) { this.projectId = id; }
+    getProjectId() { return this.projectId; }
+}

package/dist/engine/InteractionBinder.d.ts

@@ -0,0 +1,16 @@
+import type { Neuron } from '../types/index.js';
+import type { InteractionUnitRecord, InteractionUnitStore } from '../store/InteractionUnitStore.js';
+export interface BindingResult {
+    bound: boolean;
+    pendingRegistered: boolean;
+    unit?: InteractionUnitRecord | null;
+    reason: string;
+}
+export declare class InteractionBinder {
+    private store;
+    constructor(store: InteractionUnitStore);
+    process(neuron: Neuron): BindingResult;
+    private detectPendingType;
+    private detectBindIntent;
+}
+//# sourceMappingURL=InteractionBinder.d.ts.map

package/dist/engine/InteractionBinder.js

@@ -0,0 +1,87 @@
+import { detectPendingBindingPromptType, INTERACTION_EVENT_PREFIX, matchBindingReplyIntent } from '../lexicon/coreMemoryLexicon.js';
+export class InteractionBinder {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    process(neuron) {
+        const text = neuron.content.trim();
+        const bindIntent = this.detectBindIntent(text);
+        if (bindIntent) {
+            const pending = this.store.getLatestPending(bindIntent.types, 10 * 60 * 1000, neuron.metadata.createdAt);
+            if (!pending) {
+                return {
+                    bound: false,
+                    pendingRegistered: false,
+                    reason: 'no_pending_interaction_found'
+                };
+            }
+            const semanticText = `${bindIntent.semanticPrefix}: ${pending.referenceText}`;
+            const unit = this.store.resolvePendingWithReply({
+                pendingId: pending.pendingId,
+                replyNeuronId: neuron.id,
+                semanticText,
+                resolvedAt: neuron.metadata.createdAt
+            });
+            return {
+                bound: true,
+                pendingRegistered: false,
+                unit,
+                reason: 'reply_bound_to_pending_interaction'
+            };
+        }
+        const pendingType = this.detectPendingType(text);
+        if (pendingType) {
+            const unit = this.store.createUnit({
+                type: pendingType === 'action' ? 'proposal' : 'question',
+                messageNeuronIds: [neuron.id],
+                semanticText: text,
+                status: 'pending',
+                createdAt: neuron.metadata.createdAt
+            });
+            this.store.registerPending({
+                bindingType: pendingType,
+                unitId: unit.unitId,
+                referenceText: text,
+                createdAt: neuron.metadata.createdAt
+            });
+            return {
+                bound: false,
+                pendingRegistered: true,
+                unit,
+                reason: 'registered_pending_interaction'
+            };
+        }
+        const unit = this.store.createUnit({
+            type: text.endsWith('?') ? 'question' : 'statement',
+            messageNeuronIds: [neuron.id],
+            semanticText: text,
+            status: 'resolved',
+            createdAt: neuron.metadata.createdAt
+        });
+        return {
+            bound: false,
+            pendingRegistered: false,
+            unit,
+            reason: 'standalone_interaction'
+        };
+    }
+    detectPendingType(text) {
+        return detectPendingBindingPromptType(text);
+    }
+    detectBindIntent(text) {
+        const intent = matchBindingReplyIntent(text);
+        if (!intent)
+            return null;
+        if (intent.kind === 'approved') {
+            return { types: ['action', 'question'], semanticPrefix: INTERACTION_EVENT_PREFIX.approved };
+        }
+        if (intent.kind === 'rejected') {
+            return { types: ['action', 'question'], semanticPrefix: INTERACTION_EVENT_PREFIX.rejected };
+        }
+        return {
+            types: ['entity'],
+            semanticPrefix: `${INTERACTION_EVENT_PREFIX.entitySelection} ${intent.reference || text.trim()}`
+        };
+    }
+}

package/dist/engine/LocalSemanticCompiler.d.ts

@@ -0,0 +1,40 @@
+import type { NeuronType } from '../types/index.js';
+import type { QueryIR, QuerySemanticHints } from '../types/query-ir.js';
+export interface SemanticEntityCandidate {
+    text: string;
+    type?: string;
+    confidence: number;
+}
+export interface SemanticTopicLink {
+    topic: string;
+    confidence: number;
+}
+export interface SemanticCompilation {
+    runId: string;
+    sourceType: 'memory' | 'query';
+    entities: SemanticEntityCandidate[];
+    topics: SemanticTopicLink[];
+    temporalHints: Array<QueryIR['temporal']['relative']>;
+    conditionHints: string[];
+    issueHints: string[];
+    ownershipSignals: string[];
+    relativeReferences: string[];
+    projectLinks: string[];
+    tags: string[];
+    confidence: number;
+}
+export declare class LocalSemanticCompiler {
+    compileMemory(input: {
+        text: string;
+        projectId?: string;
+        type: NeuronType;
+        createdAt: number;
+    }): SemanticCompilation;
+    compileQuery(input: {
+        text: string;
+        projectId?: string;
+    }): SemanticCompilation;
+    mergeIntoSemantics(base: QuerySemanticHints, compilation: SemanticCompilation): QuerySemanticHints;
+    private compile;
+}
+//# sourceMappingURL=LocalSemanticCompiler.d.ts.map

package/dist/engine/LocalSemanticCompiler.js

@@ -0,0 +1,111 @@
+import { randomUUID } from 'crypto';
+import { classifyIssueFamilies, extractConditionHints, extractDeviceCandidate, extractIssueHints, extractOwnershipSignals, extractProjectCandidate, extractProjectLinks, extractRelativeReferences, extractTemporalHints, inferEntityTypeFromText, isOwnershipSignal, normalizeLexiconText } from '../lexicon/coreMemoryLexicon.js';
+export class LocalSemanticCompiler {
+    compileMemory(input) {
+        return this.compile('memory', input.text);
+    }
+    compileQuery(input) {
+        return this.compile('query', input.text);
+    }
+    mergeIntoSemantics(base, compilation) {
+        return {
+            ...base,
+            entityHints: Array.from(new Set([...base.entityHints, ...compilation.entities.map((entity) => entity.text)])),
+            conditionHints: Array.from(new Set([...base.conditionHints, ...compilation.conditionHints])),
+            valueHints: Array.from(new Set([...base.valueHints, ...compilation.topics.map((topic) => topic.topic)]))
+        };
+    }
+    compile(sourceType, text) {
+        const normalized = normalizeLexiconText(text);
+        const lowered = normalized.toLowerCase();
+        const entities = [];
+        const topics = [];
+        const temporalHints = [];
+        const conditionHints = [];
+        const issueHints = [];
+        const ownershipSignals = [];
+        const relativeReferences = [];
+        const projectLinks = [];
+        const tags = new Set();
+        const pushEntity = (value, type, confidence) => {
+            if (!value)
+                return;
+            const textValue = value.trim();
+            if (!textValue)
+                return;
+            if (entities.some((entity) => entity.text === textValue && entity.type === type))
+                return;
+            entities.push({ text: textValue, type, confidence });
+        };
+        const primaryEntityCandidate = extractDeviceCandidate(normalized) || extractProjectCandidate(normalized);
+        const primaryEntityType = primaryEntityCandidate ? inferEntityTypeFromText(primaryEntityCandidate) : undefined;
+        if (primaryEntityCandidate && primaryEntityType) {
+            pushEntity(primaryEntityCandidate, primaryEntityType, 0.94);
+            tags.add(primaryEntityType);
+        }
+        for (const pattern of extractOwnershipSignals(normalized)) {
+            ownershipSignals.push(pattern.trim());
+            tags.add('ownership');
+        }
+        for (const match of extractProjectLinks(normalized)) {
+            pushEntity(match, 'project', 0.9);
+            tags.add('project');
+            projectLinks.push(match.trim());
+        }
+        const ownershipProjectIssuePattern = isOwnershipSignal(lowered)
+            && classifyIssueFamilies(lowered).length > 0
+            && Boolean(extractProjectCandidate(normalized) || primaryEntityType === 'device');
+        if (ownershipProjectIssuePattern) {
+            tags.add('compound_memory');
+            topics.push({ topic: 'compound_memory', confidence: 0.82 });
+        }
+        const apiMatch = normalized.match(/https?:\/\/[^\s,，。]+/i)?.[0];
+        if (apiMatch) {
+            topics.push({ topic: 'api', confidence: 0.82 });
+            tags.add('endpoint');
+        }
+        const issueFamilies = classifyIssueFamilies(normalized);
+        if (issueFamilies.length > 0) {
+            topics.push({ topic: 'issue', confidence: 0.84 });
+            tags.add('issue');
+            const issueMatches = extractIssueHints(normalized);
+            for (const issue of issueMatches)
+                issueHints.push(issue.trim());
+            for (const family of issueFamilies) {
+                topics.push({ topic: family, confidence: 0.78 });
+            }
+        }
+        temporalHints.push(...extractTemporalHints(normalized));
+        for (const match of extractConditionHints(normalized)) {
+            conditionHints.push(match.trim());
+            tags.add('conditional');
+        }
+        const relativeRefs = extractRelativeReferences(normalized);
+        if (relativeRefs.length > 0) {
+            tags.add('relative_reference');
+            for (const ref of relativeRefs)
+                relativeReferences.push(ref.trim());
+        }
+        const confidence = Math.min(0.98, 0.45
+            + Math.min(entities.length, 3) * 0.14
+            + Math.min(topics.length, 3) * 0.08
+            + Math.min(temporalHints.length, 2) * 0.08
+            + Math.min(conditionHints.length, 2) * 0.06
+            + Math.min(issueHints.length, 2) * 0.05
+            + Math.min(ownershipSignals.length, 1) * 0.05);
+        return {
+            runId: `sem-${randomUUID()}`,
+            sourceType,
+            entities,
+            topics: Array.from(new Map(topics.map((topic) => [topic.topic, topic])).values()),
+            temporalHints: Array.from(new Set(temporalHints)),
+            conditionHints: Array.from(new Set(conditionHints)),
+            issueHints: Array.from(new Set(issueHints)),
+            ownershipSignals: Array.from(new Set(ownershipSignals)),
+            relativeReferences: Array.from(new Set(relativeReferences)),
+            projectLinks: Array.from(new Set(projectLinks)),
+            tags: Array.from(tags),
+            confidence
+        };
+    }
+}

package/dist/engine/MemoryConsolidationEngine.d.ts

@@ -0,0 +1,11 @@
+import type { ConsolidationTrigger } from './ConsolidationTrigger.js';
+import type { EpisodicSemanticDistiller } from './EpisodicSemanticDistiller.js';
+export declare class MemoryConsolidationEngine {
+    private readonly trigger;
+    private readonly distiller;
+    constructor(trigger: ConsolidationTrigger, distiller: EpisodicSemanticDistiller);
+    run(projectId: string): Promise<{
+        semanticNeuronsCreated: number;
+    }>;
+}
+//# sourceMappingURL=MemoryConsolidationEngine.d.ts.map