cogmem 3.6.2

package/dist/engine/ConsolidationPipeline.js

@@ -0,0 +1,376 @@
+import { aaakGenerator } from '../utils/AAAKGenerator.js';
+import { BeliefExtractor } from './BeliefExtractor.js';
+import { MemoryGate } from './MemoryGate.js';
+import { OfflineConsolidationPipeline } from './OfflineConsolidationPipeline.js';
+import { createAsyncEnrichmentRunId, NoopAsyncEnrichmentHook } from '../types/AsyncEnrichment.js';
+/**
+ * Online lightweight compilation pipeline.
+ * Responsibilities stay intentionally narrow:
+ * - raw episodes are already durably written before this stage runs
+ * - apply the minimal gate and binder needed for the current session
+ * - emit provisional facts / events / entity hints for near-term recall
+ * - leave deep semantic reconciliation to the offline consolidation layer
+ */
+export class ConsolidationPipeline {
+    beliefStore;
+    interactionBinder;
+    factCompiler;
+    semanticCompiler;
+    factStore;
+    entityStore;
+    compilerConfidenceStore;
+    beliefExtractor;
+    memoryGate;
+    asyncEnrichmentHook;
+    asyncEnrichmentEnabled;
+    lowConfidenceThreshold;
+    offlineConsolidationPipeline;
+    constructor(beliefStore, interactionBinder, factCompiler, semanticCompiler, factStore, entityStore, compilerConfidenceStore, beliefExtractor, offlineConsolidationPipeline = new OfflineConsolidationPipeline(), asyncEnrichmentHook = new NoopAsyncEnrichmentHook(), options = {}) {
+        this.beliefStore = beliefStore;
+        this.interactionBinder = interactionBinder;
+        this.factCompiler = factCompiler;
+        this.semanticCompiler = semanticCompiler;
+        this.factStore = factStore;
+        this.entityStore = entityStore;
+        this.compilerConfidenceStore = compilerConfidenceStore;
+        this.beliefExtractor = beliefExtractor || new BeliefExtractor();
+        this.memoryGate = new MemoryGate();
+        this.offlineConsolidationPipeline = offlineConsolidationPipeline;
+        this.asyncEnrichmentHook = asyncEnrichmentHook;
+        this.asyncEnrichmentEnabled = options.enabled === true;
+        this.lowConfidenceThreshold = options.lowConfidenceThreshold ?? 0.72;
+    }
+    consolidate(neuron, sourceEventId) {
+        const aaakSummary = this.ensureAAAKSummary(neuron);
+        const gate = this.memoryGate.classify(neuron.content);
+        const binding = this.interactionBinder.process(neuron);
+        const interactionUnit = binding.unit;
+        const tags = neuron.metadata.tags || [];
+        const isProfileOnlyImport = tags.includes('ingest:profile_only');
+        if (isProfileOnlyImport) {
+            return {
+                gate,
+                binding,
+                interactionUnit,
+                aaakSummary,
+                semanticCompilation: undefined,
+                candidates: [],
+                beliefs: [],
+                compiledFacts: [],
+                compiledEvents: [],
+                compiledEntityIds: [],
+                rejectedCount: 0
+            };
+        }
+        const semanticCompilation = this.semanticCompiler.compileMemory({
+            text: interactionUnit?.semanticText || neuron.content,
+            projectId: neuron.metadata.projectId,
+            type: neuron.metadata.type,
+            createdAt: neuron.metadata.createdAt
+        });
+        this.compilerConfidenceStore?.insert({
+            runId: semanticCompilation.runId,
+            targetType: 'memory',
+            targetId: neuron.id,
+            projectId: neuron.metadata.projectId,
+            compilerName: 'LocalSemanticCompiler',
+            confidence: semanticCompilation.confidence,
+            metadata: {
+                tags: semanticCompilation.tags,
+                entities: semanticCompilation.entities.map((entity) => entity.text),
+                topics: semanticCompilation.topics.map((topic) => topic.topic),
+                issueHints: semanticCompilation.issueHints,
+                ownershipSignals: semanticCompilation.ownershipSignals,
+                relativeReferences: semanticCompilation.relativeReferences,
+                projectLinks: semanticCompilation.projectLinks
+            },
+            createdAt: neuron.metadata.createdAt
+        });
+        if (gate.memoryClass === 'drop') {
+            return {
+                gate,
+                binding,
+                interactionUnit,
+                aaakSummary,
+                semanticCompilation,
+                candidates: [],
+                beliefs: [],
+                compiledFacts: [],
+                compiledEvents: [],
+                compiledEntityIds: [],
+                rejectedCount: 0
+            };
+        }
+        const compiled = this.factCompiler.compile({
+            neuron,
+            unit: interactionUnit,
+            semanticCompilation
+        });
+        if (gate.memoryClass === 'bind_first' && !binding.bound) {
+            return {
+                gate,
+                binding,
+                interactionUnit,
+                aaakSummary,
+                semanticCompilation,
+                candidates: [],
+                beliefs: [],
+                compiledFacts: compiled.facts,
+                compiledEvents: compiled.events,
+                compiledEntityIds: compiled.entityIds,
+                rejectedCount: 0
+            };
+        }
+        const candidates = gate.memoryClass === 'short_term'
+            ? []
+            : this.extractBeliefCandidates(neuron, sourceEventId);
+        const beliefs = [];
+        let rejectedCount = 0;
+        for (const candidate of candidates) {
+            const result = this.beliefStore.upsert(candidate, neuron.metadata.createdAt);
+            if (result.belief)
+                beliefs.push(result.belief);
+            else
+                rejectedCount += 1;
+        }
+        const result = {
+            gate,
+            binding,
+            interactionUnit,
+            aaakSummary,
+            semanticCompilation,
+            candidates,
+            beliefs,
+            compiledFacts: compiled.facts,
+            compiledEvents: compiled.events,
+            compiledEntityIds: compiled.entityIds,
+            rejectedCount
+        };
+        this.dispatchAsyncEnrichment(neuron, sourceEventId, result);
+        this.scheduleOfflineConsolidation(neuron, result);
+        return result;
+    }
+    ensureAAAKSummary(neuron) {
+        if (neuron.metadata.aaak_summary)
+            return neuron.metadata.aaak_summary;
+        const importance = this.calculateImportance(neuron.content);
+        const summary = aaakGenerator.generateSummarySync(neuron.content, neuron.metadata.type, importance);
+        neuron.metadata.aaak_summary = summary;
+        return summary;
+    }
+    extractBeliefCandidates(neuron, sourceEventId) {
+        return this.beliefExtractor.extract({ neuron, sourceEventId });
+    }
+    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;
+    }
+    dispatchAsyncEnrichment(neuron, sourceEventId, consolidation) {
+        if (!this.asyncEnrichmentEnabled)
+            return;
+        const triggers = this.collectAsyncEnrichmentTriggers(consolidation);
+        if (triggers.length === 0)
+            return;
+        const runId = createAsyncEnrichmentRunId();
+        queueMicrotask(() => {
+            Promise.resolve(this.asyncEnrichmentHook.enrich({
+                runId,
+                neuron,
+                sourceEventId,
+                triggers,
+                consolidation,
+                compilerOutput: {
+                    facts: consolidation.compiledFacts,
+                    events: consolidation.compiledEvents,
+                    entityIds: consolidation.compiledEntityIds
+                },
+                entityBinding: this.buildAsyncEnrichmentEntityBinding(neuron, consolidation),
+                recentContext: this.buildAsyncEnrichmentContext(neuron, consolidation)
+            }, {
+                persist: (result) => this.persistAsyncEnrichmentResult(runId, neuron, sourceEventId, result)
+            }))
+                .then((result) => {
+                if (result)
+                    this.persistAsyncEnrichmentResult(runId, neuron, sourceEventId, result);
+            })
+                .catch(() => undefined);
+        });
+    }
+    scheduleOfflineConsolidation(neuron, consolidation) {
+        const pendingReferenceIds = consolidation.compiledFacts
+            .filter((fact) => fact.status === 'provisional' && !fact.entityId)
+            .map((fact) => fact.factId);
+        const reasons = [
+            ...(pendingReferenceIds.length > 0 ? ['pending_reference_or_entity_binding'] : []),
+            ...(this.collectAsyncEnrichmentTriggers(consolidation).map((trigger) => trigger.kind)),
+            ...((consolidation.semanticCompilation?.issueHints.length || 0) > 1 ? ['multi_issue_candidate_sentence'] : []),
+            ...((consolidation.binding.bound || consolidation.binding.pendingRegistered) ? ['interaction_binding_present'] : [])
+        ];
+        queueMicrotask(() => {
+            this.offlineConsolidationPipeline.schedule({
+                neuron,
+                interactionUnit: consolidation.interactionUnit,
+                provisionalFacts: consolidation.compiledFacts,
+                provisionalEvents: consolidation.compiledEvents,
+                provisionalEntityIds: consolidation.compiledEntityIds,
+                beliefIds: consolidation.beliefs.map((belief) => belief.id),
+                pendingReferenceIds,
+                reasons: Array.from(new Set(reasons))
+            });
+        });
+    }
+    collectAsyncEnrichmentTriggers(consolidation) {
+        const triggers = [];
+        if (consolidation.compiledFacts.length === 0) {
+            triggers.push({
+                kind: 'ingest_compiled_fact_count_zero',
+                detail: 'ingest_compiled_fact_count=0'
+            });
+        }
+        if (this.hasSelfCorrectionPattern(consolidation)) {
+            triggers.push({
+                kind: 'self_correction_pattern',
+                detail: consolidation.interactionUnit?.semanticText || consolidation.aaakSummary || 'self_correction_pattern'
+            });
+        }
+        if ((consolidation.semanticCompilation?.issueHints.length || 0) > 1 && consolidation.compiledFacts.length <= 1) {
+            triggers.push({
+                kind: 'multi_candidate_single_fact',
+                detail: `${consolidation.semanticCompilation?.issueHints.length || 0}_issue_candidates_vs_${consolidation.compiledFacts.length}_compiled_facts`
+            });
+        }
+        if (this.hasSuspiciousUnseenEntityBinding(consolidation)) {
+            triggers.push({
+                kind: 'unseen_entity_binding_suspect',
+                detail: 'explicit_unseen_name_bound_to_existing_entity'
+            });
+        }
+        if ((consolidation.semanticCompilation?.confidence || 1) < this.lowConfidenceThreshold) {
+            triggers.push({
+                kind: 'low_compiler_confidence',
+                detail: `compiler_confidence=${(consolidation.semanticCompilation?.confidence || 0).toFixed(3)}`
+            });
+        }
+        return triggers;
+    }
+    buildAsyncEnrichmentEntityBinding(neuron, consolidation) {
+        const compiledEntities = consolidation.compiledEntityIds
+            .map((entityId) => this.entityStore.findByEntityId(entityId))
+            .filter((entity) => Boolean(entity));
+        const suspiciousReasons = [];
+        if (compiledEntities.length > 0) {
+            const explicitEntityHints = consolidation.semanticCompilation?.entities.map((entity) => entity.text) || [];
+            if (explicitEntityHints.some((hint) => !compiledEntities.some((entity) => entity.canonicalName.includes(hint) || hint.includes(entity.canonicalName)))) {
+                suspiciousReasons.push('semantic_entity_hint_mismatch');
+            }
+        }
+        const explicitNamedDevice = neuron.content.match(/([A-Za-z][A-Za-z0-9._-]*(?:\s+[A-Za-z0-9._-]+){1,3})/);
+        const candidate = explicitNamedDevice?.[1];
+        if (candidate && compiledEntities.length > 0 && compiledEntities.every((entity) => !entity.canonicalName.toLowerCase().includes(candidate.toLowerCase()))) {
+            suspiciousReasons.push('explicit_unseen_name_mismatch');
+        }
+        return {
+            compiledEntityIds: consolidation.compiledEntityIds,
+            compiledEntities,
+            suspicious: suspiciousReasons.length > 0,
+            reasons: suspiciousReasons
+        };
+    }
+    buildAsyncEnrichmentContext(neuron, consolidation) {
+        const recentEntities = Array.from(new Map([
+            ...consolidation.compiledEntityIds.map((entityId) => this.entityStore.findByEntityId(entityId)),
+            ...this.entityStore.getEntityTimeline({
+                projectId: neuron.metadata.projectId,
+                limit: 8
+            }).map((item) => this.entityStore.findByEntityId(item.entityId))
+        ]
+            .filter((entity) => Boolean(entity))
+            .map((entity) => [entity.entityId, entity])).values()).slice(0, 6);
+        const recentFacts = this.factStore.listFactsByEntityIds(recentEntities.map((entity) => entity.entityId), { limit: 12 });
+        const recentPreferenceFacts = recentFacts.filter((fact) => fact.predicateFamily === 'likes' || fact.predicateFamily === 'dislikes');
+        return {
+            recentEntities,
+            recentFacts,
+            recentPreferenceFacts
+        };
+    }
+    hasSelfCorrectionPattern(consolidation) {
+        const text = consolidation.interactionUnit?.semanticText || '';
+        return /(不对|不是|更正|改口)/.test(text) && /(左耳|右耳)/.test(text);
+    }
+    hasSuspiciousUnseenEntityBinding(consolidation) {
+        const semanticEntityHints = consolidation.semanticCompilation?.entities.map((entity) => entity.text) || [];
+        const compiledEntityNames = consolidation.compiledEntityIds
+            .map((entityId) => this.entityStore.findByEntityId(entityId)?.canonicalName || '')
+            .filter(Boolean);
+        const sourceText = consolidation.interactionUnit?.semanticText || '';
+        const explicitNamedDevice = sourceText.match(/([A-Za-z][A-Za-z0-9._-]*(?:\s+[A-Za-z0-9._-]+){1,3})/);
+        const candidate = explicitNamedDevice?.[1];
+        if (!candidate)
+            return false;
+        return semanticEntityHints.some((hint) => hint === candidate)
+            || (compiledEntityNames.length > 0 && compiledEntityNames.every((name) => !name.toLowerCase().includes(candidate.toLowerCase())));
+    }
+    persistAsyncEnrichmentResult(runId, neuron, sourceEventId, result) {
+        const entities = (result.entities || []).map((entity) => {
+            const record = this.entityStore.upsertEntity({
+                canonicalName: entity.canonicalName,
+                type: entity.type,
+                aliases: entity.aliases,
+                createdFrom: neuron.id,
+                metadata: {
+                    ...(entity.metadata || {}),
+                    source: 'enrichment',
+                    enrichment_run_id: runId,
+                    parent_neuron_id: neuron.id
+                },
+                instanceMode: entity.instanceMode,
+                createdAt: Date.now()
+            });
+            this.entityStore.recordMention({
+                entityId: record.entityId,
+                neuronId: neuron.id,
+                projectId: neuron.metadata.projectId,
+                mentionType: 'related',
+                createdAt: Date.now()
+            });
+            return record;
+        });
+        const facts = this.factStore.insertFacts((result.facts || []).map((fact) => ({
+            ...fact,
+            metadata: {
+                ...(fact.metadata || {}),
+                source: 'enrichment',
+                fact_origin: 'enriched_fact',
+                enrichment_run_id: runId,
+                parent_neuron_id: neuron.id
+            }
+        })));
+        const beliefIds = [];
+        for (const belief of result.beliefs || []) {
+            const upserted = this.beliefStore.upsert({
+                ...belief,
+                sourceNeuronId: belief.sourceNeuronId || neuron.id,
+                sourceEventId: belief.sourceEventId || sourceEventId,
+                sourceType: belief.sourceType || 'llm_inference',
+                metadata: {
+                    ...(belief.metadata || {}),
+                    source: 'enrichment',
+                    enrichment_run_id: runId,
+                    parent_neuron_id: neuron.id
+                }
+            }, Date.now());
+            if (upserted.belief)
+                beliefIds.push(upserted.belief.id);
+        }
+        return { entities, facts, beliefIds };
+    }
+}

package/dist/engine/ConsolidationTrigger.d.ts

@@ -0,0 +1,18 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+export interface ConsolidationTriggerOptions {
+    episodicThreshold?: number;
+    cooldownMs?: number;
+}
+export interface ConsolidationCandidate {
+    topicPath: string;
+    episodicNeuronIds: string[];
+}
+export declare class ConsolidationTrigger {
+    private readonly memoryGraph;
+    private readonly episodicThreshold;
+    private readonly cooldownMs;
+    constructor(memoryGraph: MemoryGraph, options?: ConsolidationTriggerOptions);
+    findCandidates(projectId: string): ConsolidationCandidate[];
+    private inCooldown;
+}
+//# sourceMappingURL=ConsolidationTrigger.d.ts.map

package/dist/engine/ConsolidationTrigger.js

@@ -0,0 +1,41 @@
+export class ConsolidationTrigger {
+    memoryGraph;
+    episodicThreshold;
+    cooldownMs;
+    constructor(memoryGraph, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.episodicThreshold = options.episodicThreshold ?? 20;
+        this.cooldownMs = options.cooldownMs ?? 6 * 60 * 60 * 1000;
+    }
+    findCandidates(projectId) {
+        const now = Date.now();
+        const grouped = new Map();
+        const neurons = this.memoryGraph.getAllNeurons()
+            .filter((neuron) => neuron.metadata.projectId === projectId)
+            .filter((neuron) => isEpisodic(neuron));
+        for (const neuron of neurons) {
+            const topicPath = neuron.metadata.topicPath || 'global';
+            const bucket = grouped.get(topicPath) || [];
+            bucket.push(neuron);
+            grouped.set(topicPath, bucket);
+        }
+        const semantic = this.memoryGraph.getAllNeurons()
+            .filter((neuron) => neuron.metadata.projectId === projectId && neuron.metadata.type === 'semantic_consolidation');
+        return Array.from(grouped.entries())
+            .filter(([topicPath, items]) => items.length >= this.episodicThreshold && !this.inCooldown(topicPath, semantic, now))
+            .map(([topicPath, items]) => ({
+            topicPath,
+            episodicNeuronIds: items.map((neuron) => neuron.id)
+        }));
+    }
+    inCooldown(topicPath, semantic, now) {
+        return semantic.some((neuron) => (neuron.metadata.tags || []).includes(`topic:${topicPath}`)
+            && now - (neuron.metadata.createdAt || 0) < this.cooldownMs);
+    }
+}
+function isEpisodic(neuron) {
+    return neuron.metadata.type === 'chat'
+        || neuron.metadata.type === 'agent_finding'
+        || neuron.metadata.type === 'agent_observation'
+        || neuron.metadata.type === 'doc';
+}

package/dist/engine/CrossTopicSynthesizer.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+import type { IterativeLLMClarifier } from '../routing/IterativeLLMClarifier.js';
+import type { CrossTopicTrigger } from './CrossTopicTrigger.js';
+export interface CrossSynthesisInput {
+    projectId: string;
+    semanticNeuronIds: string[];
+    distinctTopics: string[];
+}
+export interface CrossSynthesisResult {
+    principleNeuronId: string;
+    principle: string;
+    sourceTopics: string[];
+    createdAt: number;
+}
+export declare class CrossTopicSynthesizer {
+    private readonly memoryGraph;
+    private readonly trigger;
+    private readonly clarifier;
+    private readonly options;
+    constructor(memoryGraph: MemoryGraph, trigger: CrossTopicTrigger, clarifier: IterativeLLMClarifier, options?: {
+        maxSourceNeuronsPerBatch?: number;
+    });
+    run(projectId: string): Promise<{
+        principleNeuronsCreated: number;
+    }>;
+    private synthesize;
+}
+//# sourceMappingURL=CrossTopicSynthesizer.d.ts.map

package/dist/engine/CrossTopicSynthesizer.js

@@ -0,0 +1,70 @@
+import { NeuronFactory } from '../core/Neuron.js';
+export class CrossTopicSynthesizer {
+    memoryGraph;
+    trigger;
+    clarifier;
+    options;
+    constructor(memoryGraph, trigger, clarifier, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.trigger = trigger;
+        this.clarifier = clarifier;
+        this.options = options;
+    }
+    async run(projectId) {
+        let principleNeuronsCreated = 0;
+        for (const batch of this.trigger.findCandidateBatches(projectId)) {
+            const result = await this.synthesize({ projectId, ...batch });
+            if (result)
+                principleNeuronsCreated += 1;
+        }
+        return { principleNeuronsCreated };
+    }
+    async synthesize(input) {
+        const sources = input.semanticNeuronIds
+            .map((id) => this.memoryGraph.getNeuron(id))
+            .filter((neuron) => Boolean(neuron))
+            .filter((neuron) => neuron.metadata.projectId === input.projectId)
+            .slice(0, this.options.maxSourceNeuronsPerBatch ?? 20);
+        if (sources.length === 0)
+            return null;
+        const prompt = [
+            'Synthesize these semantic consolidations into one cross-domain principle.',
+            'Return the principle as plain text only.',
+            `Topics: ${input.distinctTopics.join(', ')}`,
+            JSON.stringify(sources.map((neuron) => ({ id: neuron.id, topic: neuron.metadata.topicPath, content: neuron.content.slice(0, 400) })))
+        ].join('\n');
+        const result = await this.clarifier.clarify(prompt, emptyRecallResult(prompt));
+        const principle = result.finalAnswer.trim() || 'Multiple topics share a durable cross-domain operating principle.';
+        const createdAt = Date.now();
+        const neuron = NeuronFactory.create(principle, this.memoryGraph.getLatestNeuronSelfHash(input.projectId) || 'genesis', { T: createdAt, S: [0, 0, 0], V: [] }, {
+            projectId: input.projectId,
+            topicPath: 'cross_domain',
+            type: 'cross_domain_principle',
+            createdAt,
+            updatedAt: createdAt,
+            status: 'active',
+            tags: ['cross_domain', ...input.distinctTopics],
+            sourceType: 'llm_inference',
+            importanceLevel: 'permanent',
+            isPinned: true,
+            stability: 1,
+            lastReinforcedAt: createdAt,
+            aaak_summary: principle
+        });
+        this.memoryGraph.addNeuron(neuron);
+        for (const source of sources)
+            this.memoryGraph.addSynapse(neuron.id, { targetId: source.id, type: 'Referenced', weight: 1 });
+        return { principleNeuronId: neuron.id, principle, sourceTopics: input.distinctTopics, createdAt };
+    }
+}
+function emptyRecallResult(query) {
+    return {
+        query,
+        strategy: { primaryLevel: 'compiled_memory', fallbackUsed: false },
+        compiledMemory: { beliefs: [], facts: [], events: [], entityTimeline: [] },
+        rawEvidence: [],
+        fallbackSnippets: [],
+        profileSignals: [],
+        profileSurface: { userProfile: [], agentPersona: [] }
+    };
+}

package/dist/engine/CrossTopicTrigger.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+export interface CrossTopicTriggerOptions {
+    semanticThreshold?: number;
+    minDistinctTopics?: number;
+    cooldownMs?: number;
+}
+export declare class CrossTopicTrigger {
+    private readonly memoryGraph;
+    private readonly options;
+    private readonly lastTriggeredByBatch;
+    constructor(memoryGraph: MemoryGraph, options?: CrossTopicTriggerOptions);
+    findCandidateBatches(projectId: string): Array<{
+        semanticNeuronIds: string[];
+        distinctTopics: string[];
+    }>;
+}
+//# sourceMappingURL=CrossTopicTrigger.d.ts.map

package/dist/engine/CrossTopicTrigger.js

@@ -0,0 +1,29 @@
+export class CrossTopicTrigger {
+    memoryGraph;
+    options;
+    lastTriggeredByBatch = new Map();
+    constructor(memoryGraph, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.options = options;
+    }
+    findCandidateBatches(projectId) {
+        const semanticThreshold = this.options.semanticThreshold ?? 8;
+        const minDistinctTopics = this.options.minDistinctTopics ?? 3;
+        const cooldownMs = this.options.cooldownMs ?? 48 * 60 * 60 * 1000;
+        const semantic = this.memoryGraph.getAllNeurons()
+            .filter((neuron) => neuron.metadata.projectId === projectId)
+            .filter((neuron) => neuron.metadata.type === 'semantic_consolidation')
+            .sort((a, b) => (b.metadata.createdAt || 0) - (a.metadata.createdAt || 0));
+        const topics = Array.from(new Set(semantic.map((neuron) => neuron.metadata.topicPath || topicFromTags(neuron.metadata.tags || [])).filter((topic) => Boolean(topic))));
+        const ids = semantic.map((neuron) => neuron.id);
+        const key = ids.slice().sort().join('|');
+        const lastTriggered = this.lastTriggeredByBatch.get(key) || 0;
+        if (semantic.length < semanticThreshold || topics.length < minDistinctTopics || Date.now() - lastTriggered < cooldownMs)
+            return [];
+        this.lastTriggeredByBatch.set(key, Date.now());
+        return [{ semanticNeuronIds: ids, distinctTopics: topics }];
+    }
+}
+function topicFromTags(tags) {
+    return tags.find((tag) => tag.startsWith('topic:'))?.slice('topic:'.length);
+}

package/dist/engine/DeepWriteConfig.d.ts

@@ -0,0 +1,14 @@
+export type DeepWriteMode = 'off' | 'shadow' | 'candidate' | 'promote_guarded';
+export interface DeepWriteConfig {
+    enabled: boolean;
+    mode: DeepWriteMode;
+    contextTurns: number;
+    recallLimit: number;
+    minPromoteConfidence: number;
+    modelRole: 'memory';
+    allowCloud: boolean;
+    redactionEnabled: boolean;
+    promoteCausalLinks: boolean;
+}
+export declare function resolveDeepWriteConfig(env?: Record<string, string | undefined>): DeepWriteConfig;
+//# sourceMappingURL=DeepWriteConfig.d.ts.map

package/dist/engine/DeepWriteConfig.js

@@ -0,0 +1,37 @@
+function parseBoolean(value, fallback = false) {
+    if (value === undefined)
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'y';
+}
+function parseNumber(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function parseMode(value) {
+    const normalized = (value || 'off').trim();
+    return normalized === 'shadow'
+        || normalized === 'candidate'
+        || normalized === 'promote_guarded'
+        || normalized === 'off'
+        ? normalized
+        : 'off';
+}
+export function resolveDeepWriteConfig(env = {}) {
+    const read = (name, legacyName) => env[name] ?? (legacyName ? env[legacyName] : undefined);
+    const enabled = parseBoolean(read('COGMEM_DEEP_WRITE_ENABLED', 'AGENT_BRAIN_DEEP_WRITE_ENABLED'), false);
+    const mode = enabled
+        ? parseMode(read('COGMEM_DEEP_WRITE_MODE', 'AGENT_BRAIN_DEEP_WRITE_MODE') || 'shadow')
+        : 'off';
+    return {
+        enabled,
+        mode,
+        contextTurns: Math.min(100, Math.floor(parseNumber(read('COGMEM_DEEP_WRITE_CONTEXT_TURNS', 'AGENT_BRAIN_DEEP_WRITE_CONTEXT_TURNS'), 24))),
+        recallLimit: Math.min(50, Math.floor(parseNumber(read('COGMEM_DEEP_WRITE_RECALL_LIMIT', 'AGENT_BRAIN_DEEP_WRITE_RECALL_LIMIT'), 12))),
+        minPromoteConfidence: Math.min(1, Math.max(0, parseNumber(read('COGMEM_DEEP_WRITE_MIN_PROMOTE_CONFIDENCE', 'AGENT_BRAIN_DEEP_WRITE_MIN_PROMOTE_CONFIDENCE'), 0.86))),
+        modelRole: 'memory',
+        allowCloud: parseBoolean(read('COGMEM_DEEP_WRITE_ALLOW_CLOUD', 'AGENT_BRAIN_DEEP_WRITE_ALLOW_CLOUD'), false),
+        redactionEnabled: parseBoolean(read('COGMEM_DEEP_WRITE_REDACTION_ENABLED', 'AGENT_BRAIN_DEEP_WRITE_REDACTION_ENABLED'), true),
+        promoteCausalLinks: parseBoolean(read('COGMEM_DEEP_WRITE_PROMOTE_CAUSAL', 'AGENT_BRAIN_DEEP_WRITE_PROMOTE_CAUSAL'), false)
+    };
+}

package/dist/engine/DeepWriteMemoryCompiler.d.ts

@@ -0,0 +1,43 @@
+import type { TextGenerateFn } from '../models/ModelRole.js';
+export interface DeepWriteTurnInput {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+    turnId?: string;
+}
+export interface DeepWriteRecallInput {
+    facts: unknown[];
+    beliefs: unknown[];
+    entities: unknown[];
+    rawEvidence: Array<{
+        neuronId: string;
+        content: string;
+        createdAt: number;
+        tags?: string[];
+    }>;
+}
+export interface DeepWriteMemoryCompilerInput {
+    projectId?: string;
+    sessionId?: string;
+    currentExchange: {
+        userTurnId?: string;
+        assistantTurnId?: string;
+        userText: string;
+        assistantText?: string;
+        createdAt: number;
+    };
+    recentTurns: DeepWriteTurnInput[];
+    recalledMemory: DeepWriteRecallInput;
+}
+export interface DeepWriteMemoryCompilerResult {
+    output: Record<string, unknown>;
+    rawOutput: string;
+    systemPrompt: string;
+    userPrompt: string;
+}
+export declare class DeepWriteMemoryCompiler {
+    private readonly generate;
+    constructor(generate: TextGenerateFn);
+    compile(input: DeepWriteMemoryCompilerInput): Promise<DeepWriteMemoryCompilerResult>;
+}
+//# sourceMappingURL=DeepWriteMemoryCompiler.d.ts.map