cogmem 3.6.2

package/dist/routing/EvidenceBudgetManager.js

@@ -0,0 +1,55 @@
+import { ToolEvidenceNormalizer } from './ToolEvidenceNormalizer.js';
+import { ToolEvidencePack } from './ToolEvidencePack.js';
+const DEFAULT_CONFIG = {
+    maxTotalTokens: 1200,
+    maxFactsPerPack: 40,
+    maxNeuronSummaries: 10,
+    compressionStrategy: 'salience_sort',
+};
+export class EvidenceBudgetManager {
+    config;
+    evidencePack = new ToolEvidencePack();
+    normalizer = new ToolEvidenceNormalizer();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    absorb(input) {
+        const item = this.normalizer.normalize(input);
+        item.facts = item.facts.slice(0, this.config.maxFactsPerPack);
+        item.neurons = item.neurons.slice(0, this.config.maxNeuronSummaries);
+        this.evidencePack.add(item);
+        if (this.state().isOverBudget)
+            this.compress();
+        return item;
+    }
+    state() {
+        const usedTokens = this.evidencePack.totalTokens();
+        return {
+            usedTokens,
+            remainingTokens: Math.max(0, this.config.maxTotalTokens - usedTokens),
+            isOverBudget: usedTokens > this.config.maxTotalTokens,
+        };
+    }
+    pack() {
+        return this.evidencePack;
+    }
+    compress() {
+        if (!this.state().isOverBudget)
+            return;
+        this.evidencePack.items.sort((a, b) => b.relevanceScore - a.relevanceScore || a.addedAt - b.addedAt);
+        while (this.state().isOverBudget && this.evidencePack.items.length > 0) {
+            const last = this.evidencePack.items[this.evidencePack.items.length - 1];
+            if (this.config.compressionStrategy === 'drop_tail' || last.facts.length + last.events.length + last.neurons.length <= 1) {
+                this.evidencePack.items.pop();
+                continue;
+            }
+            if (last.facts.length > 0)
+                last.facts.pop();
+            else if (last.events.length > 0)
+                last.events.pop();
+            else if (last.neurons.length > 0)
+                last.neurons.pop();
+            last.estimatedTokens = Math.max(20, Math.floor(last.estimatedTokens * 0.75));
+        }
+    }
+}

package/dist/routing/ExecutionLoop.d.ts

@@ -0,0 +1,79 @@
+import type { BrainRecallResult } from '../types/BrainRecallResult.js';
+import { RecallSufficiencyGate } from '../recall/RecallSufficiencyGate.js';
+import { type ConfidenceGateResult } from './ConfidenceGate.js';
+import type { TaskPlan, TaskStepType } from './TaskPlan.js';
+import type { AutonomyContext, ChatSessionLike } from '../types/ExtensionPoints.js';
+import { type BrainToolDispatcherLike, type ToolCallRecord } from './IterativeLLMClarifier.js';
+import type { ToolUsePolicy } from './ToolUsePolicy.js';
+import type { EvidenceBudgetConfig } from './EvidenceBudgetManager.js';
+import type { BoardEventBus } from '../boards/BoardEventBus.js';
+export type RecallFunction = (query: string, options?: {
+    projectId?: string;
+    entityHint?: string;
+    limit?: number;
+    topicPath?: string;
+    enablePersistentGainEdges?: boolean;
+    enableDeepWriteEdges?: boolean;
+}) => BrainRecallResult | Promise<BrainRecallResult>;
+export type LLMClarifyFunction = (prompt: string, evidence: BrainRecallResult) => Promise<string>;
+export interface StepExecutionRecord {
+    stepId: string;
+    stepType: TaskStepType;
+    executed: boolean;
+    skippedReason?: 'cpu_sufficient' | 'no_llm_callback' | 'condition_not_met';
+    recallResult?: BrainRecallResult;
+    confidenceResult?: ConfidenceGateResult;
+    llmResponse?: string;
+    durationMs: number;
+    /** Tool calls made by IterativeLLMClarifier during this step (v1.1+). */
+    toolCallLog?: ToolCallRecord[];
+    /** Number of LLM iterations used in this step (v1.1+). */
+    iterationsUsed?: number;
+}
+export type { ToolCallRecord };
+export interface ExecutionResult {
+    planId: string;
+    query: string;
+    steps: StepExecutionRecord[];
+    finalRecallResult?: BrainRecallResult;
+    finalConfidence?: ConfidenceGateResult;
+    llmCallCount: number;
+    totalDurationMs: number;
+    verdict: 'cpu_resolved' | 'llm_assisted' | 'incomplete';
+}
+export declare class ExecutionLoop {
+    private recallFn;
+    private options?;
+    constructor(recallFn: RecallFunction, options?: {
+        onLLMClarify?: LLMClarifyFunction;
+        confidenceThreshold?: number;
+        defaultLimit?: number;
+        /** Pre-loaded persona block injected at the top of every LLM prompt. */
+        personaBlock?: string;
+        /** Active chat session whose history is injected after the persona block. */
+        session?: ChatSessionLike;
+        /**
+         * v1.1: Enable iterative ReAct loop. When > 0, uses IterativeLLMClarifier
+         * instead of a single LLM call. Defaults to 0 (disabled, v1.0 behavior).
+         */
+        maxLLMIterations?: number;
+        /**
+         * v1.1: Brain tool dispatcher required when maxLLMIterations > 0.
+         */
+        toolDispatcher?: BrainToolDispatcherLike;
+        /** v1.2: Optional CPU policy for iterative tool calls. */
+        toolUsePolicy?: ToolUsePolicy;
+        /** v1.2: Optional evidence budget config for iterative tool evidence. */
+        evidenceBudgetConfig?: Partial<EvidenceBudgetConfig>;
+        /** v1.2: Optional board event bus for reasoning trace events. */
+        boardEventBus?: BoardEventBus;
+        /** v1.3 reserved context; accepted and forwarded, but unused in v1.2.1. */
+        autonomyContext?: AutonomyContext;
+        recallGateDisabled?: boolean;
+        recallGate?: RecallSufficiencyGate;
+    } | undefined);
+    execute(plan: TaskPlan): Promise<ExecutionResult>;
+    private assertNever;
+    private collectRecallGateTurns;
+}
+//# sourceMappingURL=ExecutionLoop.d.ts.map

package/dist/routing/ExecutionLoop.js

@@ -0,0 +1,234 @@
+import { RecallSufficiencyGate } from '../recall/RecallSufficiencyGate.js';
+import { ConfidenceGate } from './ConfidenceGate.js';
+import { IterativeLLMClarifier, } from './IterativeLLMClarifier.js';
+import { buildCueDrivenSessionContext, selectCueDrivenSessionTurns } from './SessionContextSelector.js';
+export class ExecutionLoop {
+    recallFn;
+    options;
+    constructor(recallFn, options) {
+        this.recallFn = recallFn;
+        this.options = options;
+    }
+    async execute(plan) {
+        const startedAt = Date.now();
+        const steps = [];
+        let lastRecallResult;
+        let lastConfidenceResult;
+        let cpuSufficient = false;
+        let llmCallCount = 0;
+        let recallSufficiencyDecision;
+        for (const step of plan.steps) {
+            const stepStartedAt = Date.now();
+            const record = {
+                stepId: step.id,
+                stepType: step.type,
+                executed: false,
+                durationMs: 0
+            };
+            switch (step.type) {
+                case 'memory_recall': {
+                    const recallResult = await this.recallFn(step.inputs.query ?? plan.query, {
+                        projectId: step.inputs.projectId,
+                        entityHint: step.inputs.entityHint,
+                        topicPath: step.inputs.topicPath,
+                        limit: this.options?.defaultLimit ?? 8
+                    });
+                    lastRecallResult = recallResult;
+                    record.executed = true;
+                    record.recallResult = recallResult;
+                    break;
+                }
+                case 'graph_traverse': {
+                    const recallResult = await this.recallFn(step.inputs.query ?? plan.query, {
+                        projectId: step.inputs.projectId,
+                        entityHint: step.inputs.entityHint,
+                        topicPath: step.inputs.topicPath,
+                        limit: this.options?.defaultLimit ?? 8,
+                        enablePersistentGainEdges: true
+                    });
+                    lastRecallResult = recallResult;
+                    record.executed = true;
+                    record.recallResult = recallResult;
+                    break;
+                }
+                case 'fact_check': {
+                    const query = [step.inputs.subjectHint, step.inputs.predicateHint, step.inputs.query]
+                        .filter(Boolean)
+                        .join(' ');
+                    const recallResult = await this.recallFn(query, {
+                        projectId: step.inputs.projectId,
+                        entityHint: step.inputs.entityHint,
+                        topicPath: step.inputs.topicPath,
+                        limit: this.options?.defaultLimit ?? 8
+                    });
+                    lastRecallResult = recallResult;
+                    record.executed = true;
+                    record.recallResult = recallResult;
+                    break;
+                }
+                case 'confidence_check': {
+                    if (!lastRecallResult) {
+                        break;
+                    }
+                    const gate = new ConfidenceGate({
+                        threshold: this.options?.confidenceThreshold ?? 0.6
+                    });
+                    const confidenceResult = gate.evaluate(lastRecallResult, {
+                        entityHint: step.inputs.entityHint ?? plan.steps[0]?.inputs.entityHint
+                    });
+                    lastConfidenceResult = confidenceResult;
+                    if (confidenceResult.verdict === 'cpu_sufficient') {
+                        cpuSufficient = true;
+                    }
+                    record.executed = true;
+                    record.confidenceResult = confidenceResult;
+                    break;
+                }
+                case 'llm_clarify': {
+                    if (lastRecallResult && !this.options?.recallGateDisabled) {
+                        const gate = this.options?.recallGate ?? new RecallSufficiencyGate();
+                        recallSufficiencyDecision = gate.evaluate({
+                            query: plan.query,
+                            layer1Result: lastRecallResult,
+                            recentTurns: this.collectRecallGateTurns(plan.query, plan.steps[0]?.inputs.projectId),
+                            projectId: plan.steps[0]?.inputs.projectId
+                        });
+                        this.options?.boardEventBus?.emit({
+                            boardId: 'reasoning_trace',
+                            eventType: recallSufficiencyDecision.sufficient ? 'recall_gate.skip' : 'recall_gate.escalation',
+                            payload: {
+                                signals: recallSufficiencyDecision.signals,
+                                reason: recallSufficiencyDecision.reason,
+                                suggestedFollowupQueryCount: recallSufficiencyDecision.suggestedFollowupQueries.length
+                            },
+                            timestamp: Date.now(),
+                            workspaceId: plan.steps[0]?.inputs.projectId
+                        });
+                    }
+                    if (cpuSufficient && recallSufficiencyDecision?.sufficient !== false) {
+                        record.skippedReason = 'cpu_sufficient';
+                        break;
+                    }
+                    if (step.triggerCondition) {
+                        const dependencyRecord = steps.find((entry) => entry.stepId === step.triggerCondition?.dependsOnStepId);
+                        const score = dependencyRecord?.confidenceResult?.score;
+                        const conditionMet = typeof score === 'number'
+                            && step.triggerCondition.operator === 'lt'
+                            && score < step.triggerCondition.threshold;
+                        if (!conditionMet) {
+                            record.skippedReason = 'condition_not_met';
+                            break;
+                        }
+                    }
+                    if (!this.options?.onLLMClarify) {
+                        record.skippedReason = 'no_llm_callback';
+                        break;
+                    }
+                    const factsSummary = lastRecallResult?.compiledMemory.facts.map((fact) => ({
+                        factId: fact.factId,
+                        subject: fact.subject,
+                        predicateFamily: fact.predicateFamily,
+                        predicateValue: fact.predicateValue,
+                        object: fact.object,
+                        confidence: fact.confidence,
+                        status: fact.status,
+                        validFrom: fact.validFrom
+                    })) ?? [];
+                    // Build three-layer prompt: persona → history → query+evidence
+                    const promptParts = [];
+                    if (this.options?.personaBlock) {
+                        promptParts.push(this.options.personaBlock);
+                        promptParts.push('');
+                    }
+                    const history = buildCueDrivenSessionContext({
+                        session: this.options?.session,
+                        query: plan.query,
+                        projectId: step.inputs.projectId,
+                    });
+                    if (history) {
+                        promptParts.push('【对话历史】');
+                        promptParts.push(history);
+                        promptParts.push('');
+                    }
+                    promptParts.push(`【当前问题】\n${plan.query}`);
+                    if (factsSummary.length) {
+                        promptParts.push(`\n【记忆证据】\n${JSON.stringify(factsSummary, null, 2)}`);
+                    }
+                    else {
+                        promptParts.push('\n【记忆证据】\n（暂无相关编译记忆，请根据对话上下文和人格设定作答）');
+                    }
+                    const prompt = promptParts.join('\n');
+                    // v1.1: iterative ReAct path
+                    const maxIter = this.options?.maxLLMIterations ?? 0;
+                    if (maxIter > 0 && this.options?.toolDispatcher) {
+                        const clarifier = new IterativeLLMClarifier((p) => this.options.onLLMClarify(p, lastRecallResult), this.options.toolDispatcher, {
+                            maxIterations: maxIter,
+                            personaBlock: this.options?.personaBlock,
+                            session: this.options?.session,
+                            projectId: step.inputs.projectId,
+                            topicPath: step.inputs.topicPath,
+                            policy: this.options?.toolUsePolicy,
+                            budgetConfig: this.options?.evidenceBudgetConfig,
+                            boardEventBus: this.options?.boardEventBus,
+                            autonomyContext: this.options?.autonomyContext,
+                            seedFollowupQueries: recallSufficiencyDecision?.sufficient === false
+                                ? recallSufficiencyDecision.suggestedFollowupQueries
+                                : [],
+                        });
+                        const clarifierResult = await clarifier.clarify(plan.query, lastRecallResult);
+                        llmCallCount += clarifierResult.iterationsUsed;
+                        record.executed = true;
+                        record.llmResponse = clarifierResult.finalAnswer;
+                        record.toolCallLog = clarifierResult.toolCallLog;
+                        record.iterationsUsed = clarifierResult.iterationsUsed;
+                    }
+                    else {
+                        // v1.0 legacy single-call path
+                        const llmResponse = await this.options.onLLMClarify(prompt, lastRecallResult);
+                        llmCallCount += 1;
+                        record.executed = true;
+                        record.llmResponse = llmResponse;
+                    }
+                    break;
+                }
+                case 'answer_assemble': {
+                    record.executed = true;
+                    break;
+                }
+                default: {
+                    this.assertNever(step);
+                }
+            }
+            record.durationMs = Math.max(0, Date.now() - stepStartedAt);
+            steps.push(record);
+        }
+        const verdict = llmCallCount > 0
+            ? 'llm_assisted'
+            : lastConfidenceResult?.verdict === 'cpu_sufficient'
+                ? 'cpu_resolved'
+                : 'incomplete';
+        return {
+            planId: plan.planId,
+            query: plan.query,
+            steps,
+            finalRecallResult: lastRecallResult,
+            finalConfidence: lastConfidenceResult,
+            llmCallCount,
+            totalDurationMs: Math.max(0, Date.now() - startedAt),
+            verdict
+        };
+    }
+    assertNever(step) {
+        throw new Error(`Unsupported task step type: ${step.type}`);
+    }
+    collectRecallGateTurns(query, projectId) {
+        const session = this.options?.session;
+        if (!session)
+            return [];
+        return selectCueDrivenSessionTurns({ session, query, projectId, maxChars: 4000 }).map((turn) => ({
+            role: turn.role,
+            content: turn.content,
+            timestamp: turn.timestamp
+        }));
+    }
+}

package/dist/routing/IntentClassifier.d.ts

@@ -0,0 +1,15 @@
+import type { IntentType } from './TaskPlan.js';
+export declare class IntentClassifier {
+    classify(query: string, options?: {
+        projectId?: string;
+    }): {
+        intentType: IntentType;
+        entityHint?: string;
+        temporalHint?: string;
+        confidence: number;
+    };
+    private isCrossDomainQuery;
+    private extractTemporalHint;
+    private extractEntityHint;
+}
+//# sourceMappingURL=IntentClassifier.d.ts.map

package/dist/routing/IntentClassifier.js

@@ -0,0 +1,97 @@
+const TEMPORAL_RECALL_PATTERN = /last (?:week|month|day|time)|yesterday|ago|previously|before|earlier|上次|之前|上周|上个月/i;
+const CORRECTION_CHECK_PATTERN = /change.*mind|update|correct|fix|wrong|actually|no wait|wait no|改|纠正|更新/i;
+const CROSS_DOMAIN_PATTERN = /related|connected|associated|everything about|all.*about|有关|相关/i;
+const ENTITY_LOOKUP_PATTERN = /what is|who is|tell me about|what does.*do|describe|是什么|介绍/i;
+const FACTUAL_RECALL_PATTERN = /what.*problem|what.*issue|what.*wrong|how.*doing|status|有什么问题|状态/i;
+const CROSS_DOMAIN_TOPIC_GROUPS = {
+    connectivity: /\bbluetooth\b|\bwifi\b|\bnetwork\b|蓝牙|网络/i,
+    work: /\bproject\b|\bsdk\b|\bfeature\b|\btask\b|项目|功能/i,
+    hardware: /\bdevice\b|\bearphone\b|\bheadphone\b|\bphone\b|\blaptop\b|设备|耳机|手机|电脑/i,
+    aggregate: /\bthings\b|\beverything\b|\ball\b|\bdealing with\b|\bdealt with\b|所有|都有哪些/i
+};
+export class IntentClassifier {
+    classify(query, options = {}) {
+        const normalizedQuery = query.trim();
+        const entityHint = this.extractEntityHint(normalizedQuery);
+        const temporalHint = this.extractTemporalHint(normalizedQuery);
+        if (TEMPORAL_RECALL_PATTERN.test(normalizedQuery)) {
+            return {
+                intentType: 'temporal_recall',
+                entityHint,
+                temporalHint,
+                confidence: 0.95
+            };
+        }
+        if (CORRECTION_CHECK_PATTERN.test(normalizedQuery)) {
+            return {
+                intentType: 'correction_check',
+                entityHint,
+                confidence: 0.9
+            };
+        }
+        if (this.isCrossDomainQuery(normalizedQuery, options.projectId)) {
+            return {
+                intentType: 'cross_domain',
+                entityHint,
+                confidence: 0.8
+            };
+        }
+        if (ENTITY_LOOKUP_PATTERN.test(normalizedQuery)) {
+            return {
+                intentType: 'entity_lookup',
+                entityHint,
+                confidence: 0.85
+            };
+        }
+        if (FACTUAL_RECALL_PATTERN.test(normalizedQuery)) {
+            return {
+                intentType: 'factual_recall',
+                entityHint,
+                confidence: 0.82
+            };
+        }
+        return {
+            intentType: 'open_ended',
+            entityHint,
+            confidence: 0.5
+        };
+    }
+    isCrossDomainQuery(query, projectId) {
+        if (CROSS_DOMAIN_PATTERN.test(query)) {
+            return true;
+        }
+        const matchedGroups = Object.entries(CROSS_DOMAIN_TOPIC_GROUPS)
+            .filter(([, pattern]) => pattern.test(query))
+            .map(([group]) => group);
+        if (projectId && /\bproject\b|项目/i.test(query) && !matchedGroups.includes('work')) {
+            matchedGroups.push('work');
+        }
+        const distinctGroups = new Set(matchedGroups);
+        if (distinctGroups.size >= 2 && distinctGroups.has('aggregate')) {
+            return true;
+        }
+        return (distinctGroups.has('connectivity') &&
+            /\b(thing|things|stuff|history|dealing with|dealt with)\b|所有|都有哪些/i.test(query));
+    }
+    extractTemporalHint(query) {
+        const match = query.match(/last (?:week|month|day|time)|yesterday|\d+\s+(?:days?|weeks?|months?|years?)\s+ago|previously|before|earlier|上次|之前|上周|上个月/i);
+        return match?.[0];
+    }
+    extractEntityHint(query) {
+        const candidates = [];
+        const pushMatches = (pattern, groupIndex = 1) => {
+            for (const match of query.matchAll(pattern)) {
+                const value = match[groupIndex]?.trim();
+                const index = match.index ?? Number.MAX_SAFE_INTEGER;
+                if (value) {
+                    candidates.push({ index, value });
+                }
+            }
+        };
+        pushMatches(/["']([^"']+)["']/g);
+        pushMatches(/\b(?:my|our|the)\s+([A-Za-z0-9][A-Za-z0-9_-]*(?:\s+[A-Za-z0-9][A-Za-z0-9_-]*){0,3})/gi);
+        pushMatches(/\b([A-Z][A-Za-z0-9_-]*(?:\s+[A-Z][A-Za-z0-9_-]*)*)\b/g);
+        candidates.sort((left, right) => left.index - right.index);
+        return candidates[0]?.value;
+    }
+}

package/dist/routing/IntentPatternMatcher.d.ts

@@ -0,0 +1,12 @@
+import type { SystemIntent } from './SystemIntentClassifier.js';
+export declare const SYSTEM_INTENT_PRIORITY: readonly SystemIntent[];
+export declare const SYSTEM_INTENT_PATTERNS: Readonly<Record<SystemIntent, readonly RegExp[]>>;
+export interface IntentPatternMatch {
+    intent: SystemIntent;
+    pattern: RegExp;
+}
+export declare class IntentPatternMatcher {
+    readonly patterns: Readonly<Record<SystemIntent, readonly RegExp[]>>;
+    match(message: string): IntentPatternMatch | null;
+}
+//# sourceMappingURL=IntentPatternMatcher.d.ts.map