cogmem 3.6.2

package/dist/recall/VectorCandidateFilter.js

@@ -0,0 +1,78 @@
+import { isRecallableMemoryEvidence } from './RecallGovernance.js';
+export class VectorCandidateFilter {
+    rules;
+    constructor(rules = []) {
+        this.rules = rules;
+    }
+    filter(neuronIds, ctx) {
+        return this.rules.reduce((ids, rule) => rule.filter(ids, ctx), neuronIds);
+    }
+}
+class MemoryGraphVectorFilterRule {
+    memoryGraph;
+    constructor(memoryGraph) {
+        this.memoryGraph = memoryGraph;
+    }
+    neuron(id) {
+        return this.memoryGraph.getNeuron(id);
+    }
+}
+export class WorkspaceFilter extends MemoryGraphVectorFilterRule {
+    name = 'workspace';
+    filter(neuronIds, context) {
+        if (!context.projectId)
+            return neuronIds;
+        return neuronIds.filter((id) => this.neuron(id)?.metadata.projectId === context.projectId);
+    }
+}
+export class TopicFilter extends MemoryGraphVectorFilterRule {
+    name = 'topic';
+    filter(neuronIds, context) {
+        if (!context.topicPath)
+            return neuronIds;
+        const prefix = context.topicPath;
+        return neuronIds.filter((id) => {
+            const topicPath = this.neuron(id)?.metadata.topicPath;
+            if (!topicPath)
+                return false;
+            return topicPath === prefix || topicPath.startsWith(`${prefix}/`);
+        });
+    }
+}
+export class StaleFilter extends MemoryGraphVectorFilterRule {
+    name = 'stale';
+    filter(neuronIds, context) {
+        const maxStaleMs = context.maxStaleMs ?? 90 * 24 * 60 * 60 * 1000;
+        const cutoff = context.queryTime - maxStaleMs;
+        return neuronIds.filter((id) => (this.neuron(id)?.metadata.createdAt ?? 0) >= cutoff);
+    }
+}
+export class StatusFilter extends MemoryGraphVectorFilterRule {
+    name = 'status';
+    filter(neuronIds, _context) {
+        return neuronIds.filter((id) => {
+            const neuron = this.neuron(id);
+            return isRecallableMemoryEvidence(neuron);
+        });
+    }
+}
+export class CredibilityFilter extends MemoryGraphVectorFilterRule {
+    threshold;
+    name = 'credibility';
+    constructor(memoryGraph, threshold = 0.3) {
+        super(memoryGraph);
+        this.threshold = threshold;
+    }
+    filter(neuronIds, _context) {
+        return neuronIds.filter((id) => (this.neuron(id)?.metadata.confidence ?? 1) >= this.threshold);
+    }
+}
+export function createDefaultVectorCandidateFilter(memoryGraph) {
+    return new VectorCandidateFilter([
+        new WorkspaceFilter(memoryGraph),
+        new TopicFilter(memoryGraph),
+        new StaleFilter(memoryGraph),
+        new StatusFilter(memoryGraph),
+        new CredibilityFilter(memoryGraph),
+    ]);
+}

package/dist/retrieval/ConditionDslEvaluator.d.ts

@@ -0,0 +1,33 @@
+export interface ConditionEvaluationContext {
+    projectId?: string;
+    rawQuery?: string;
+    conditionHints?: string[];
+    entityHints?: string[];
+    environmentHints?: string[];
+    stateHints?: string[];
+    policyHints?: string[];
+}
+export declare class ConditionDslEvaluator {
+    private static readonly VALUE_ALIASES;
+    static evaluate(dsl: unknown, context: ConditionEvaluationContext): {
+        matched: boolean;
+        score: number;
+        reasons: string[];
+        executionReady: boolean;
+        normalizedContext: Record<string, string[]>;
+        policyActions: Array<{
+            policy: string;
+            action: 'allow' | 'deny' | 'prefer';
+        }>;
+    };
+    private static evaluateNode;
+    private static evaluateLeaf;
+    private static toCorpus;
+    private static normalizeValue;
+    private static matchesValue;
+    private static buildNormalizedContext;
+    private static buildPolicyActions;
+    private static rehydrateFromFlatClauses;
+    private static hasExplicitNegation;
+}
+//# sourceMappingURL=ConditionDslEvaluator.d.ts.map

package/dist/retrieval/ConditionDslEvaluator.js

@@ -0,0 +1,160 @@
+export class ConditionDslEvaluator {
+    static VALUE_ALIASES = {
+        production: ['prod', '生产', '生产环境'],
+        staging: ['stage', '预发', '预发环境'],
+        development: ['dev', '开发', '开发环境'],
+        approved: ['approval', '已批准', '审批', '审批通过'],
+        running: ['运行中'],
+        healthy: ['health', '健康'],
+        'circuit-breaker': ['circuit breaker'],
+        strict: ['严格']
+    };
+    static evaluate(dsl, context) {
+        if (!dsl || typeof dsl !== 'object') {
+            return {
+                matched: false,
+                score: 0,
+                reasons: [],
+                executionReady: false,
+                normalizedContext: this.buildNormalizedContext(context),
+                policyActions: []
+            };
+        }
+        const expr = dsl.expr;
+        const node = expr || this.rehydrateFromFlatClauses(dsl.clauses);
+        if (!node) {
+            return {
+                matched: false,
+                score: 0,
+                reasons: [],
+                executionReady: false,
+                normalizedContext: this.buildNormalizedContext(context),
+                policyActions: []
+            };
+        }
+        const result = this.evaluateNode(node, context);
+        const normalizedContext = this.buildNormalizedContext(context);
+        return {
+            matched: result.matched,
+            score: result.score,
+            reasons: result.reasons,
+            executionReady: result.matched && result.reasons.length > 0,
+            normalizedContext,
+            policyActions: this.buildPolicyActions(normalizedContext, result.matched)
+        };
+    }
+    static evaluateNode(node, context) {
+        if (node.kind === 'group') {
+            const childResults = node.clauses.map((clause) => this.evaluateNode(clause, context));
+            const matched = node.combinator === 'all'
+                ? childResults.every((item) => item.matched)
+                : childResults.some((item) => item.matched);
+            const normalizedScore = childResults.length > 0
+                ? childResults.reduce((sum, item) => sum + item.score, 0) / childResults.length
+                : 0;
+            return {
+                matched,
+                score: normalizedScore,
+                reasons: childResults.flatMap((item) => item.reasons)
+            };
+        }
+        return this.evaluateLeaf(node, context);
+    }
+    static evaluateLeaf(node, context) {
+        const value = this.normalizeValue(String(node.value || ''));
+        const operator = node.operator || 'eq';
+        const corpus = this.toCorpus(context);
+        const rawText = [context.rawQuery || '', ...(context.conditionHints || [])].join(' ').toLowerCase();
+        let positiveMatch = false;
+        if (node.kind === 'project_hint' && context.projectId) {
+            positiveMatch = this.matchesValue(context.projectId.toLowerCase(), value);
+        }
+        else if (node.kind === 'state') {
+            positiveMatch = (context.stateHints || []).some((hint) => this.matchesValue(hint, value));
+        }
+        else if (node.kind === 'policy_hint') {
+            positiveMatch = (context.policyHints || []).some((hint) => this.matchesValue(hint, value));
+        }
+        else if (node.kind === 'approval') {
+            positiveMatch = /(approved|approval|已批准|审批)/i.test(corpus);
+        }
+        else if (value) {
+            positiveMatch = this.matchesValue(corpus, value);
+        }
+        const explicitNegation = operator === 'neq' && this.hasExplicitNegation(rawText, value);
+        const matched = operator === 'neq'
+            ? (explicitNegation || !positiveMatch)
+            : positiveMatch;
+        return {
+            matched,
+            score: matched ? 1 : 0,
+            reasons: matched ? [`condition:${node.kind}:${operator}:${value}`] : []
+        };
+    }
+    static toCorpus(context) {
+        return [
+            context.projectId || '',
+            context.rawQuery || '',
+            ...(context.conditionHints || []),
+            ...(context.entityHints || []),
+            ...(context.environmentHints || []),
+            ...(context.stateHints || []),
+            ...(context.policyHints || [])
+        ]
+            .join(' ')
+            .toLowerCase();
+    }
+    static normalizeValue(value) {
+        const normalized = value.trim().toLowerCase();
+        for (const [canonical, aliases] of Object.entries(this.VALUE_ALIASES)) {
+            if (normalized === canonical || aliases.includes(normalized))
+                return canonical;
+        }
+        return normalized;
+    }
+    static matchesValue(haystack, value) {
+        const normalizedHaystack = haystack.toLowerCase();
+        const aliases = [value, ...(this.VALUE_ALIASES[value] || [])];
+        return aliases.some((alias) => normalizedHaystack.includes(alias.toLowerCase()));
+    }
+    static buildNormalizedContext(context) {
+        const normalizeList = (items) => Array.from(new Set((items || []).map((item) => this.normalizeValue(item)).filter(Boolean)));
+        return {
+            environment: normalizeList(context.environmentHints),
+            state: normalizeList(context.stateHints),
+            policy: normalizeList(context.policyHints),
+            entity: normalizeList(context.entityHints),
+            condition: normalizeList(context.conditionHints)
+        };
+    }
+    static buildPolicyActions(normalizedContext, matched) {
+        const actions = [];
+        for (const policy of normalizedContext.policy) {
+            if (policy === 'strict' || policy === 'circuit-breaker') {
+                actions.push({ policy, action: matched ? 'allow' : 'deny' });
+            }
+            else {
+                actions.push({ policy, action: matched ? 'prefer' : 'deny' });
+            }
+        }
+        return actions;
+    }
+    static rehydrateFromFlatClauses(rawClauses) {
+        if (!Array.isArray(rawClauses) || rawClauses.length === 0)
+            return null;
+        return {
+            kind: 'group',
+            combinator: 'all',
+            clauses: rawClauses.filter((item) => Boolean(item && typeof item === 'object'))
+        };
+    }
+    static hasExplicitNegation(rawText, value) {
+        if (!rawText || !value)
+            return false;
+        return (rawText.includes(`not ${value}`) ||
+            rawText.includes(`non-${value}`) ||
+            rawText.includes(`不是${value}`) ||
+            rawText.includes(`非${value}`) ||
+            rawText.includes(`不 ${value}`));
+    }
+}

package/dist/retrieval/EntityActivationIndex.d.ts

@@ -0,0 +1,14 @@
+import type { EntityStore } from '../store/EntityStore.js';
+import type { FactStore } from '../store/FactStore.js';
+export interface EntityActivationContext {
+    entityIds: string[];
+    factIds: string[];
+    neuronIds: string[];
+}
+export declare class EntityActivationIndex {
+    private entityStore;
+    private factStore;
+    constructor(entityStore: EntityStore, factStore: FactStore);
+    activate(entityIds: string[], predicateFamilies?: string[]): EntityActivationContext;
+}
+//# sourceMappingURL=EntityActivationIndex.d.ts.map

package/dist/retrieval/EntityActivationIndex.js

@@ -0,0 +1,19 @@
+export class EntityActivationIndex {
+    entityStore;
+    factStore;
+    constructor(entityStore, factStore) {
+        this.entityStore = entityStore;
+        this.factStore = factStore;
+    }
+    activate(entityIds, predicateFamilies) {
+        const facts = this.factStore.listFactsByEntityIds(entityIds, {
+            predicateFamilies,
+            limit: 60
+        });
+        return {
+            entityIds,
+            factIds: facts.map((fact) => fact.factId),
+            neuronIds: Array.from(new Set(facts.map((fact) => fact.neuronId)))
+        };
+    }
+}

package/dist/retrieval/EvidenceFusionPolicy.d.ts

@@ -0,0 +1,30 @@
+import { ContextFusionPath, FusionResolutionReason, type ContextPack } from '../types/index.js';
+import type { QueryTimePendingEntityResolutionHookOutput } from '../types/QueryTimePendingEntityResolution.js';
+export interface EvidenceFusionPolicyInput {
+    compiledFacts: ContextPack['compiledFacts'];
+    compiledEvidence: ContextPack['compiledEvidence'];
+    rawEvidence: ContextPack['rawEvidence'];
+    supportingEpisodes: ContextPack['supportingEpisodes'];
+    queryTimePendingEntityResolution?: QueryTimePendingEntityResolutionHookOutput;
+}
+export interface EvidenceFusionPolicyDecision {
+    fusionPath: ContextFusionPath;
+    chosenEvidence: Array<{
+        source: 'compiled' | 'raw';
+        evidenceId: string;
+    }>;
+    rejectedEvidence: Array<{
+        source: 'compiled' | 'raw';
+        evidenceId: string;
+        reason: string;
+    }>;
+    resolutionReason?: FusionResolutionReason;
+    conflictTrace: ContextPack['conflictTrace'];
+}
+export interface EvidenceFusionPolicy {
+    decide(input: EvidenceFusionPolicyInput): EvidenceFusionPolicyDecision;
+}
+export declare class DefaultEvidenceFusionPolicy implements EvidenceFusionPolicy {
+    decide(input: EvidenceFusionPolicyInput): EvidenceFusionPolicyDecision;
+}
+//# sourceMappingURL=EvidenceFusionPolicy.d.ts.map

package/dist/retrieval/EvidenceFusionPolicy.js

@@ -0,0 +1,112 @@
+import { ContextFusionPath, FusionResolutionReason } from '../types/index.js';
+import { classifyIssueFamilies } from '../lexicon/coreMemoryLexicon.js';
+export class DefaultEvidenceFusionPolicy {
+    decide(input) {
+        const hasCompiled = input.compiledEvidence.length > 0;
+        const hasRaw = input.rawEvidence.length > 0;
+        if (hasCompiled && !hasRaw) {
+            return {
+                fusionPath: ContextFusionPath.COMPILED_ONLY,
+                chosenEvidence: input.compiledEvidence.map((item) => ({ source: 'compiled', evidenceId: item.evidenceId })),
+                rejectedEvidence: [],
+                resolutionReason: FusionResolutionReason.COMPILED_WINS,
+                conflictTrace: []
+            };
+        }
+        if (!hasCompiled && hasRaw) {
+            return {
+                fusionPath: ContextFusionPath.RAW_ONLY,
+                chosenEvidence: input.rawEvidence.map((item) => ({ source: 'raw', evidenceId: item.neuronId })),
+                rejectedEvidence: [],
+                resolutionReason: FusionResolutionReason.RAW_WINS,
+                conflictTrace: []
+            };
+        }
+        if (!hasCompiled && !hasRaw) {
+            return {
+                fusionPath: ContextFusionPath.RAW_ONLY,
+                chosenEvidence: [],
+                rejectedEvidence: [],
+                conflictTrace: []
+            };
+        }
+        const conflictTrace = findFusionConflict(input.compiledFacts, input.supportingEpisodes);
+        if (conflictTrace.length > 0) {
+            const rejectedRawIds = new Set(conflictTrace.map((item) => item.conflictingRawContent));
+            return {
+                fusionPath: ContextFusionPath.CONFLICT_RESOLVED,
+                chosenEvidence: [
+                    ...input.compiledEvidence.map((item) => ({ source: 'compiled', evidenceId: item.evidenceId })),
+                    ...input.rawEvidence
+                        .filter((item) => !rejectedRawIds.has(item.content))
+                        .map((item) => ({ source: 'raw', evidenceId: item.neuronId }))
+                ],
+                rejectedEvidence: input.rawEvidence
+                    .filter((item) => rejectedRawIds.has(item.content))
+                    .map((item) => ({ source: 'raw', evidenceId: item.neuronId, reason: 'conflict_resolved' })),
+                resolutionReason: conflictTrace[0]?.resolutionReason,
+                conflictTrace
+            };
+        }
+        return {
+            fusionPath: ContextFusionPath.COMPILED_PLUS_RAW,
+            chosenEvidence: [
+                ...input.compiledEvidence.map((item) => ({ source: 'compiled', evidenceId: item.evidenceId })),
+                ...input.rawEvidence.map((item) => ({ source: 'raw', evidenceId: item.neuronId }))
+            ],
+            rejectedEvidence: [],
+            conflictTrace: []
+        };
+    }
+}
+function findFusionConflict(compiledFacts, supportingEpisodes) {
+    const targetFact = compiledFacts.find((fact) => ['has_issue', 'likes', 'dislikes'].includes(fact.predicateFamily));
+    if (!targetFact)
+        return [];
+    const compiledSignal = extractConflictSignal([targetFact.predicateValue, targetFact.object, targetFact.sourceText].filter(Boolean).join(' '));
+    if (!compiledSignal)
+        return [];
+    for (const episode of supportingEpisodes) {
+        if (episode.neuron.id === targetFact.neuronId)
+            continue;
+        const rawSignal = extractConflictSignal(episode.neuron.content);
+        if (!rawSignal)
+            continue;
+        if (rawSignal.domain !== compiledSignal.domain)
+            continue;
+        if (rawSignal.value === compiledSignal.value)
+            continue;
+        return [{
+                conflictingRawContent: episode.neuron.content,
+                conflictingCompiledFact: {
+                    factId: targetFact.factId,
+                    subject: targetFact.subject,
+                    predicateFamily: targetFact.predicateFamily,
+                    predicateValue: targetFact.predicateValue,
+                    object: targetFact.object,
+                    confidence: targetFact.confidence
+                },
+                resolutionReason: pickFusionResolutionReason(targetFact, episode.neuron)
+            }];
+    }
+    return [];
+}
+function extractConflictSignal(text) {
+    const issueFamilies = classifyIssueFamilies(text);
+    if (issueFamilies.length > 0)
+        return { domain: 'issue', value: issueFamilies[0] };
+    if (/(喜欢|i like)/i.test(text))
+        return { domain: 'preference', value: 'like' };
+    if (/(讨厌|不喜欢|i dislike)/i.test(text))
+        return { domain: 'preference', value: 'dislike' };
+    return null;
+}
+function pickFusionResolutionReason(fact, rawNeuron) {
+    if (fact.confidence >= 0.9)
+        return FusionResolutionReason.COMPILED_WINS;
+    if (rawNeuron.metadata.createdAt > fact.validFrom)
+        return FusionResolutionReason.RECENCY_WINS;
+    if (fact.confidence >= 0.8)
+        return FusionResolutionReason.TRUST_SCORE_HIGHER;
+    return FusionResolutionReason.RAW_WINS;
+}

package/dist/retrieval/EvidenceFusionRanker.d.ts

@@ -0,0 +1,13 @@
+export interface EvidenceSourceScore {
+    neuronId: string;
+    score: number;
+    source: string;
+    reason: string;
+}
+export declare class EvidenceFusionRanker {
+    rank(inputs: EvidenceSourceScore[], limit?: number): {
+        neuronIds: string[];
+        reasonsByNeuronId: Map<string, string[]>;
+    };
+}
+//# sourceMappingURL=EvidenceFusionRanker.d.ts.map

package/dist/retrieval/EvidenceFusionRanker.js

@@ -0,0 +1,17 @@
+export class EvidenceFusionRanker {
+    rank(inputs, limit = 120) {
+        const scoreByNeuron = new Map();
+        const reasonsByNeuronId = new Map();
+        for (const input of inputs) {
+            scoreByNeuron.set(input.neuronId, (scoreByNeuron.get(input.neuronId) || 0) + input.score);
+            const reasons = reasonsByNeuronId.get(input.neuronId) || [];
+            reasons.push(`${input.source}:${input.reason}`);
+            reasonsByNeuronId.set(input.neuronId, reasons);
+        }
+        const neuronIds = Array.from(scoreByNeuron.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, limit)
+            .map(([neuronId]) => neuronId);
+        return { neuronIds, reasonsByNeuronId };
+    }
+}

package/dist/retrieval/NarrativeRecallAssembler.d.ts

@@ -0,0 +1,32 @@
+export interface NarrativeRecallSummary {
+    headline: string;
+    path: string[];
+    whyMatched: string[];
+    runtimeSegments: Array<{
+        stage: string;
+        label: string;
+        count?: number;
+    }>;
+}
+export declare class NarrativeRecallAssembler {
+    assemble(input: {
+        query: string;
+        plannerReasons: string[];
+        pulseTrace: Array<{
+            stage: string;
+            candidateCount: number;
+            reason: string;
+        }>;
+        temporalLabels: string[];
+        branchIds: string[];
+        entityIds: string[];
+        denseJointCount?: number;
+        traversalPath?: string[];
+        traversalSegments?: Array<{
+            stage: string;
+            label: string;
+            count?: number;
+        }>;
+    }): NarrativeRecallSummary;
+}
+//# sourceMappingURL=NarrativeRecallAssembler.d.ts.map

package/dist/retrieval/NarrativeRecallAssembler.js

@@ -0,0 +1,27 @@
+export class NarrativeRecallAssembler {
+    assemble(input) {
+        const path = input.traversalPath && input.traversalPath.length > 0
+            ? input.traversalPath
+            : [
+                ...input.entityIds.slice(0, 3).map((id) => `entity:${id}`),
+                ...input.temporalLabels.slice(0, 3).map((label) => `time:${label}`),
+                ...input.branchIds.slice(0, 3).map((id) => `branch:${id}`)
+            ];
+        return {
+            headline: `universe navigation for: ${input.query}`,
+            path,
+            whyMatched: Array.from(new Set([
+                ...input.plannerReasons.slice(0, 4),
+                ...input.pulseTrace.slice(0, 4).map((item) => item.reason)
+            ])),
+            runtimeSegments: input.traversalSegments && input.traversalSegments.length > 0
+                ? input.traversalSegments
+                : [
+                    { stage: 'entity', label: input.entityIds[0] ? `entity:${input.entityIds[0]}` : 'entity:none', count: input.entityIds.length },
+                    { stage: 'temporal', label: input.temporalLabels[0] || 'temporal:none', count: input.temporalLabels.length },
+                    { stage: 'branch', label: input.branchIds[0] ? `branch:${input.branchIds[0]}` : 'branch:none', count: input.branchIds.length },
+                    { stage: 'dense', label: 'dense_joint_search', count: input.denseJointCount || 0 }
+                ]
+        };
+    }
+}

package/dist/retrieval/NativeQueryParser.d.ts

@@ -0,0 +1,23 @@
+import type { NativeQueryDirectives } from '../types/query-ir.js';
+export interface NativeQueryClause {
+    key: keyof NativeQueryDirectives;
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+}
+export interface NativeQueryParseResult {
+    directives?: NativeQueryDirectives;
+    clauses: NativeQueryClause[];
+    residualQuery: string;
+    parseMode: 'grammar';
+}
+export declare class NativeQueryParser {
+    private static readonly KEY_ALIASES;
+    parse(query: string): NativeQueryParseResult;
+    private buildResidualQuery;
+    private readIdentifier;
+    private readValue;
+    private skipWhitespace;
+}
+//# sourceMappingURL=NativeQueryParser.d.ts.map