cogmem 3.6.2

package/dist/engine/EntityResolutionEngine.d.ts

@@ -0,0 +1,45 @@
+import type { QueryIR } from '../types/query-ir.js';
+import type { EntityDisambiguationCandidate, EntityRecord, EntityStore } from '../store/EntityStore.js';
+export declare enum EntityInstanceDecisionSignal {
+    STRONG_NEW_SIGNAL = "strong_new_signal",
+    STRONG_UPDATE_SIGNAL = "strong_update_signal",
+    AMBIGUOUS = "ambiguous"
+}
+export declare enum PendingEntityFallbackStrategy {
+    ASSUME_NEW = "ASSUME_NEW",
+    ASSUME_LATEST = "ASSUME_LATEST",
+    STAY_PENDING = "STAY_PENDING"
+}
+export declare const STRONG_NEW_SIGNAL_PHRASES: readonly string[];
+export declare const STRONG_UPDATE_SIGNAL_PHRASES: readonly string[];
+export interface EntityInstanceResolutionDecision {
+    normalizedText: string;
+    signal: EntityInstanceDecisionSignal;
+    matchedSignal?: string;
+    fallback: PendingEntityFallbackStrategy;
+    shouldCreatePending: boolean;
+}
+export interface EntityResolutionResult {
+    resolved: EntityRecord[];
+    relatedEntityIds: string[];
+    candidateRefs: string[];
+    confidence: number;
+    disambiguation: Array<{
+        reference: string;
+        candidates: EntityDisambiguationCandidate[];
+    }>;
+}
+export declare class EntityResolutionEngine {
+    private entityStore;
+    constructor(entityStore: EntityStore);
+    resolve(input: {
+        query: string;
+        ir: QueryIR;
+        projectId?: string;
+    }): EntityResolutionResult;
+    private resolveBeforeTime;
+    private extractImplicitRefs;
+    private inferType;
+}
+export declare function decideEntityInstanceResolution(text: string): EntityInstanceResolutionDecision;
+//# sourceMappingURL=EntityResolutionEngine.d.ts.map

package/dist/engine/EntityResolutionEngine.js

@@ -0,0 +1,105 @@
+import { ENTITY_INSTANCE_SIGNAL_LEXICON, extractRelativeReferences, inferReferenceType, isStrongNewInstanceSignal, isStrongUpdateInstanceSignal, normalizeLexiconText } from '../lexicon/coreMemoryLexicon.js';
+export var EntityInstanceDecisionSignal;
+(function (EntityInstanceDecisionSignal) {
+    EntityInstanceDecisionSignal["STRONG_NEW_SIGNAL"] = "strong_new_signal";
+    EntityInstanceDecisionSignal["STRONG_UPDATE_SIGNAL"] = "strong_update_signal";
+    EntityInstanceDecisionSignal["AMBIGUOUS"] = "ambiguous";
+})(EntityInstanceDecisionSignal || (EntityInstanceDecisionSignal = {}));
+export var PendingEntityFallbackStrategy;
+(function (PendingEntityFallbackStrategy) {
+    PendingEntityFallbackStrategy["ASSUME_NEW"] = "ASSUME_NEW";
+    PendingEntityFallbackStrategy["ASSUME_LATEST"] = "ASSUME_LATEST";
+    PendingEntityFallbackStrategy["STAY_PENDING"] = "STAY_PENDING";
+})(PendingEntityFallbackStrategy || (PendingEntityFallbackStrategy = {}));
+export const STRONG_NEW_SIGNAL_PHRASES = ENTITY_INSTANCE_SIGNAL_LEXICON.strongNew;
+export const STRONG_UPDATE_SIGNAL_PHRASES = ENTITY_INSTANCE_SIGNAL_LEXICON.strongUpdate;
+export class EntityResolutionEngine {
+    entityStore;
+    constructor(entityStore) {
+        this.entityStore = entityStore;
+    }
+    resolve(input) {
+        const candidateRefs = Array.from(new Set([
+            ...input.ir.entities,
+            ...input.ir.mustMatch,
+            ...input.ir.shouldMatch,
+            ...input.ir.semantics.entityHints,
+            ...this.extractImplicitRefs(input.query)
+        ])).filter(Boolean);
+        const disambiguation = candidateRefs.map((ref) => ({
+            reference: ref,
+            candidates: this.entityStore.listReferenceCandidatesWithRelativeSupport(ref, this.inferType(ref, input.query), {
+                projectId: input.projectId,
+                beforeTime: this.resolveBeforeTime(input.ir)
+            })
+        }));
+        const resolved = disambiguation
+            .map((item) => item.candidates[0]?.entity)
+            .filter((entity) => Boolean(entity));
+        const relatedEntityIds = Array.from(new Set(resolved.flatMap((entity) => this.entityStore.listRelations(entity.entityId).map((relation) => relation.sourceEntityId === entity.entityId ? relation.targetEntityId : relation.sourceEntityId)))).filter((entityId) => !resolved.some((entity) => entity.entityId === entityId));
+        return {
+            resolved,
+            relatedEntityIds,
+            candidateRefs,
+            confidence: resolved.length > 0 ? Math.min(0.96, 0.58 + resolved.length * 0.12) : 0.22,
+            disambiguation: disambiguation.filter((item) => item.candidates.length > 0)
+        };
+    }
+    resolveBeforeTime(ir) {
+        if (ir.temporal.end)
+            return ir.temporal.end;
+        if (ir.temporal.relative === 'around_half_year_ago') {
+            return Date.now() - 150 * 24 * 60 * 60 * 1000;
+        }
+        if (ir.temporal.relative === 'past_six_months') {
+            return Date.now();
+        }
+        return undefined;
+    }
+    extractImplicitRefs(query) {
+        return extractRelativeReferences(normalizeLexiconText(query));
+    }
+    inferType(reference, query) {
+        return inferReferenceType(reference, query);
+    }
+}
+export function decideEntityInstanceResolution(text) {
+    const normalizedText = normalizeEntityInstanceText(text);
+    const strongNewMatch = STRONG_NEW_SIGNAL_PHRASES.find((phrase) => normalizedText.includes(phrase.toLowerCase()));
+    if (strongNewMatch) {
+        return {
+            normalizedText,
+            signal: EntityInstanceDecisionSignal.STRONG_NEW_SIGNAL,
+            matchedSignal: strongNewMatch,
+            fallback: PendingEntityFallbackStrategy.ASSUME_NEW,
+            shouldCreatePending: false
+        };
+    }
+    const strongUpdateMatch = STRONG_UPDATE_SIGNAL_PHRASES.find((phrase) => normalizedText.includes(phrase.toLowerCase()));
+    if (strongUpdateMatch) {
+        return {
+            normalizedText,
+            signal: EntityInstanceDecisionSignal.STRONG_UPDATE_SIGNAL,
+            matchedSignal: strongUpdateMatch,
+            fallback: PendingEntityFallbackStrategy.ASSUME_LATEST,
+            shouldCreatePending: false
+        };
+    }
+    return {
+        normalizedText,
+        signal: EntityInstanceDecisionSignal.AMBIGUOUS,
+        fallback: PendingEntityFallbackStrategy.STAY_PENDING,
+        shouldCreatePending: true
+    };
+}
+function normalizeEntityInstanceText(text) {
+    const normalized = normalizeLexiconText(text)
+        .toLowerCase()
+        .replace(/不对，?\s*/g, '')
+        .replace(/其实，?\s*/g, '')
+        .replace(/\s+/g, ' ');
+    if (isStrongNewInstanceSignal(normalized) || isStrongUpdateInstanceSignal(normalized)) {
+        return normalized;
+    }
+    return normalized;
+}

package/dist/engine/EpisodicSemanticDistiller.d.ts

@@ -0,0 +1,25 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+import type { IterativeLLMClarifier } from '../routing/IterativeLLMClarifier.js';
+export interface DistillationInput {
+    projectId: string;
+    episodicNeuronIds: string[];
+    topicPath?: string;
+}
+export interface DistillationResult {
+    semanticNeuronId: string;
+    principle: string;
+    sourceNeuronCount: number;
+    createdAt: number;
+}
+export declare class EpisodicSemanticDistiller {
+    private readonly memoryGraph;
+    private readonly clarifier;
+    private readonly maxEpisodicPerBatch;
+    private readonly minBatchSize;
+    constructor(memoryGraph: MemoryGraph, clarifier: IterativeLLMClarifier, options?: {
+        maxEpisodicPerBatch?: number;
+        minBatchSize?: number;
+    });
+    distill(input: DistillationInput): Promise<DistillationResult | null>;
+}
+//# sourceMappingURL=EpisodicSemanticDistiller.d.ts.map

package/dist/engine/EpisodicSemanticDistiller.js

@@ -0,0 +1,68 @@
+import { NeuronFactory } from '../core/Neuron.js';
+export class EpisodicSemanticDistiller {
+    memoryGraph;
+    clarifier;
+    maxEpisodicPerBatch;
+    minBatchSize;
+    constructor(memoryGraph, clarifier, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.clarifier = clarifier;
+        this.maxEpisodicPerBatch = options.maxEpisodicPerBatch ?? 50;
+        this.minBatchSize = options.minBatchSize ?? 5;
+    }
+    async distill(input) {
+        const sources = input.episodicNeuronIds
+            .map((id) => this.memoryGraph.getNeuron(id))
+            .filter((neuron) => Boolean(neuron))
+            .filter((neuron) => neuron.metadata.projectId === input.projectId)
+            .slice(0, this.maxEpisodicPerBatch);
+        if (sources.length < this.minBatchSize)
+            return null;
+        const prompt = [
+            'Distill these episodic memories into one durable semantic principle.',
+            'Return the principle as plain text only.',
+            `Project: ${input.projectId}`,
+            input.topicPath ? `Topic: ${input.topicPath}` : '',
+            JSON.stringify(sources.map((neuron) => ({ id: neuron.id, content: neuron.content.slice(0, 400) })))
+        ].filter(Boolean).join('\n');
+        const result = await this.clarifier.clarify(prompt, emptyRecallResult(prompt));
+        const principle = result.finalAnswer.trim() || 'Repeated episodes share a durable behavioral principle.';
+        const createdAt = Date.now();
+        const topicPath = input.topicPath || sources[0]?.metadata.topicPath || 'global';
+        const neuron = NeuronFactory.create(principle, this.memoryGraph.getLatestNeuronSelfHash(input.projectId) || 'genesis', { T: createdAt, S: [0, 0, 0], V: [] }, {
+            projectId: input.projectId,
+            topicPath,
+            type: 'semantic_consolidation',
+            createdAt,
+            updatedAt: createdAt,
+            status: 'active',
+            tags: ['consolidated', `topic:${topicPath}`, topicPath],
+            sourceType: 'llm_inference',
+            importanceLevel: 'important',
+            isPinned: true,
+            stability: 1,
+            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 {
+            semanticNeuronId: neuron.id,
+            principle,
+            sourceNeuronCount: sources.length,
+            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/EvolutionVerifier.d.ts

@@ -0,0 +1,39 @@
+import type { ProposalLedger } from '../meta/ProposalLedger.js';
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+import type { IAuditLedger } from '../types/ExtensionPoints.js';
+import type { ISkillMemoryStore } from '../types/ExtensionPoints.js';
+export interface EvolutionVerifierOptions {
+    minSamplesAfter?: number;
+    verifyDelayMs?: number;
+    minVerificationDelayMs?: number;
+    maxVerifyPerRun?: number;
+    memoryGraph?: MemoryGraph;
+}
+interface TagStats {
+    samples: number;
+    successRate: number;
+}
+type StatsCapableSkillStore = ISkillMemoryStore & {
+    getExecutionStatsForTags?: (tags: string[], options: {
+        before?: number;
+        after?: number;
+        projectId?: string;
+    }) => Record<string, TagStats>;
+};
+export declare class EvolutionVerifier {
+    private readonly skillMemoryStore;
+    private readonly proposalLedger;
+    private readonly auditLedger;
+    private readonly options;
+    constructor(skillMemoryStore: StatsCapableSkillStore, proposalLedger: ProposalLedger, auditLedger: IAuditLedger, options?: EvolutionVerifierOptions);
+    verify(projectId: string): Promise<number>;
+    verifyPending(projectId: string): Promise<{
+        verified: number;
+        skipped: number;
+    }>;
+    private verifyProposal;
+    private stats;
+    private writeRegressionObservation;
+}
+export {};
+//# sourceMappingURL=EvolutionVerifier.d.ts.map

package/dist/engine/EvolutionVerifier.js

@@ -0,0 +1,104 @@
+import { NeuronFactory } from '../core/Neuron.js';
+export class EvolutionVerifier {
+    skillMemoryStore;
+    proposalLedger;
+    auditLedger;
+    options;
+    constructor(skillMemoryStore, proposalLedger, auditLedger, options = {}) {
+        this.skillMemoryStore = skillMemoryStore;
+        this.proposalLedger = proposalLedger;
+        this.auditLedger = auditLedger;
+        this.options = options;
+    }
+    async verify(projectId) {
+        const result = await this.verifyPending(projectId);
+        return result.verified;
+    }
+    async verifyPending(projectId) {
+        const minSamplesAfter = this.options.minSamplesAfter ?? 10;
+        const verifyDelayMs = this.options.minVerificationDelayMs ?? this.options.verifyDelayMs ?? 24 * 60 * 60 * 1000;
+        const maxVerifyPerRun = this.options.maxVerifyPerRun ?? 10;
+        let verified = 0;
+        let skipped = 0;
+        for (const auditEntry of this.auditLedger.getPendingVerificationEntries(projectId)) {
+            if (verified >= maxVerifyPerRun)
+                break;
+            const proposal = this.proposalLedger.get(auditEntry.proposalId);
+            if (!proposal || proposal.status !== 'applied')
+                continue;
+            if (!proposal.predictedImpact || proposal.actualOutcomeVerifiedAt)
+                continue;
+            if ((proposal.appliedAt ?? proposal.proposedAt) + verifyDelayMs > Date.now()) {
+                skipped += 1;
+                continue;
+            }
+            const result = this.verifyProposal(proposal, projectId, minSamplesAfter);
+            this.proposalLedger.updateStatus(proposal.id, 'applied', {
+                actualOutcomeVerifiedAt: result.verifiedAt,
+                verificationResult: result
+            });
+            this.auditLedger.updateVerificationResult(proposal.id, result);
+            this.writeRegressionObservation(projectId, auditEntry.skillId, result);
+            verified += 1;
+        }
+        return { verified, skipped };
+    }
+    verifyProposal(proposal, projectId, minSamplesAfter) {
+        const tags = Array.from(new Set([
+            ...(proposal.predictedImpact?.improvedTags || []),
+            ...(proposal.predictedImpact?.potentialRegressionTags || [])
+        ]));
+        const beforeStats = this.stats(tags, { before: proposal.appliedAt ?? proposal.proposedAt, projectId });
+        const afterStats = this.stats(tags, { after: proposal.appliedAt ?? proposal.proposedAt, projectId });
+        const improvedTagsActual = collectRates(proposal.predictedImpact?.improvedTags || [], beforeStats, afterStats);
+        const regressionTagsActual = collectRates(proposal.predictedImpact?.potentialRegressionTags || [], beforeStats, afterStats);
+        const afterSamples = Object.values(afterStats).reduce((sum, stat) => sum + stat.samples, 0);
+        const regression = Object.values(regressionTagsActual).some((rate) => rate.before - rate.after > 0.1);
+        const improved = Object.values(improvedTagsActual).filter((rate) => rate.after > rate.before);
+        const verdict = afterSamples < minSamplesAfter
+            ? 'insufficient_data'
+            : regression
+                ? 'regressed'
+                : improved.length === Object.keys(improvedTagsActual).length
+                    ? 'confirmed'
+                    : 'partial';
+        return { verifiedAt: Date.now(), improvedTagsActual, regressionTagsActual, verdict };
+    }
+    stats(tags, options) {
+        if (typeof this.skillMemoryStore.getExecutionStatsForTags === 'function') {
+            return this.skillMemoryStore.getExecutionStatsForTags(tags, options);
+        }
+        const stats = {};
+        for (const tag of tags) {
+            const matching = this.skillMemoryStore.listAll().filter((neuron) => (neuron.metadata.skillMeta?.intentTags || []).includes(tag));
+            const samples = matching.reduce((sum, neuron) => sum + (neuron.metadata.skillMeta?.executionCount || 0), 0);
+            const successes = matching.reduce((sum, neuron) => sum + (neuron.metadata.skillMeta?.successCount || 0), 0);
+            stats[tag] = { samples, successRate: samples > 0 ? successes / samples : 0 };
+        }
+        return stats;
+    }
+    writeRegressionObservation(projectId, skillId, result) {
+        const memoryGraph = this.options.memoryGraph;
+        if (!memoryGraph)
+            return;
+        const content = `Evolution verification completed for ${skillId}: ${result.verdict}`;
+        const now = Date.now();
+        memoryGraph.addNeuron(NeuronFactory.create(content, memoryGraph.getLatestNeuronSelfHash(projectId) || 'genesis', { T: now, S: [0, 0, 0], V: [] }, {
+            projectId,
+            type: 'agent_observation',
+            createdAt: now,
+            updatedAt: now,
+            status: 'active',
+            tags: ['evolution_verification', result.verdict, skillId],
+            sourceType: 'verified_fact',
+            importanceLevel: 'important',
+            aaak_summary: content
+        }));
+    }
+}
+function collectRates(tags, before, after) {
+    const result = {};
+    for (const tag of tags)
+        result[tag] = { before: before[tag]?.successRate ?? 0, after: after[tag]?.successRate ?? 0 };
+    return result;
+}

package/dist/engine/FactCompiler.d.ts

@@ -0,0 +1,41 @@
+import type { Neuron } from '../types/index.js';
+import type { EntityStore } from '../store/EntityStore.js';
+import type { FactRecord, FactStore, EventRecord } from '../store/FactStore.js';
+import type { InteractionUnitRecord } from '../store/InteractionUnitStore.js';
+import type { SemanticCompilation } from './LocalSemanticCompiler.js';
+export interface FactCompilationResult {
+    facts: FactRecord[];
+    events: EventRecord[];
+    entityIds: string[];
+}
+export declare class FactCompiler {
+    private factStore;
+    private entityStore;
+    constructor(factStore: FactStore, entityStore: EntityStore);
+    compile(input: {
+        neuron: Neuron;
+        unit?: InteractionUnitRecord | null;
+        semanticCompilation?: SemanticCompilation;
+    }): FactCompilationResult;
+    private normalizeName;
+    private extractIssueMatches;
+    private normalizeIssueValue;
+    private buildIssueMetadata;
+    private buildContinuityMetadata;
+    private buildWriteTimeBindingMetadata;
+    private resolveContinuityProjectSurfaceName;
+    private extractIssuePhrase;
+    private inferIssueFamily;
+    private buildSelfCorrectionArtifact;
+    private isSelfCorrectionSurface;
+    private extractCorrectionSide;
+    private extractNegatedCorrectionSide;
+    private factMatchesCorrectionSide;
+    private extractPendingEntityReference;
+    private isRelativeProjectSurface;
+    private resolveImplicitEntity;
+    private resolveRelativeEntitySafely;
+    private isWeakRelativeReferenceSurface;
+    private pickSpecificRelativeReference;
+}
+//# sourceMappingURL=FactCompiler.d.ts.map