cogmem 3.6.2

package/dist/retrieval/UniverseNavigator.d.ts

@@ -0,0 +1,43 @@
+import type { QueryCompiler } from './QueryCompiler.js';
+import type { RetrievalPlanner } from './RetrievalPlanner.js';
+import type { TemporalBranchSearch } from './TemporalBranchSearch.js';
+import type { PulseRetrievalEngine } from './PulseRetrievalEngine.js';
+import type { NarrativeRecallAssembler } from './NarrativeRecallAssembler.js';
+import type { UniverseTraversalExecutor } from './UniverseTraversalExecutor.js';
+export interface UniverseNavigationResult {
+    compiledQuery: ReturnType<QueryCompiler['compile']>;
+    branchSearch: ReturnType<TemporalBranchSearch['search']>;
+    pulse: ReturnType<PulseRetrievalEngine['run']>;
+    narrative: ReturnType<NarrativeRecallAssembler['assemble']>;
+    runtime: {
+        path: string[];
+        segments: Array<{
+            stage: string;
+            label: string;
+            count?: number;
+        }>;
+    };
+}
+export declare class UniverseNavigator {
+    private queryCompiler;
+    private retrievalPlanner;
+    private temporalBranchSearch;
+    private pulseRetrievalEngine;
+    private narrativeRecallAssembler;
+    private traversalExecutor;
+    constructor(queryCompiler: QueryCompiler, retrievalPlanner: RetrievalPlanner, temporalBranchSearch: TemporalBranchSearch, pulseRetrievalEngine: PulseRetrievalEngine, narrativeRecallAssembler: NarrativeRecallAssembler, traversalExecutor: UniverseTraversalExecutor);
+    navigate(input: {
+        query: string;
+        projectId?: string;
+        startTime?: number;
+        endTime?: number;
+        topologyIds: string[];
+        branchIds: string[];
+        temporalBucketIds: string[];
+        temporalNeuronIds: string[];
+        graphIds: string[];
+        cognitiveGraphIds: string[];
+        entityNeuronIds: string[];
+    }): UniverseNavigationResult;
+}
+//# sourceMappingURL=UniverseNavigator.d.ts.map

package/dist/retrieval/UniverseNavigator.js

@@ -0,0 +1,75 @@
+export class UniverseNavigator {
+    queryCompiler;
+    retrievalPlanner;
+    temporalBranchSearch;
+    pulseRetrievalEngine;
+    narrativeRecallAssembler;
+    traversalExecutor;
+    constructor(queryCompiler, retrievalPlanner, temporalBranchSearch, pulseRetrievalEngine, narrativeRecallAssembler, traversalExecutor) {
+        this.queryCompiler = queryCompiler;
+        this.retrievalPlanner = retrievalPlanner;
+        this.temporalBranchSearch = temporalBranchSearch;
+        this.pulseRetrievalEngine = pulseRetrievalEngine;
+        this.narrativeRecallAssembler = narrativeRecallAssembler;
+        this.traversalExecutor = traversalExecutor;
+    }
+    navigate(input) {
+        const compiledQuery = this.queryCompiler.compile(input.query, input.projectId);
+        const plan = this.retrievalPlanner.plan(compiledQuery.ir);
+        const startTime = input.startTime ?? compiledQuery.ir.temporal.start;
+        const endTime = input.endTime ?? compiledQuery.ir.temporal.end;
+        const branchSearch = this.temporalBranchSearch.search({
+            projectId: input.projectId,
+            startTime,
+            endTime,
+            temporalBucketIds: input.temporalBucketIds,
+            entityNeuronIds: input.entityNeuronIds,
+            terms: Array.from(new Set([
+                ...compiledQuery.ir.entities,
+                ...compiledQuery.ir.semantics.entityHints,
+                ...compiledQuery.ir.mustMatch,
+                ...compiledQuery.ir.shouldMatch
+            ]))
+        });
+        const pulse = this.pulseRetrievalEngine.run({
+            plan,
+            ir: compiledQuery.ir,
+            entityIds: compiledQuery.entityResolution.resolved.map((entity) => entity.entityId),
+            topologyIds: Array.from(new Set([...input.topologyIds, ...branchSearch.neuronIds, ...branchSearch.denseJointNeuronIds])),
+            branchIds: Array.from(new Set([...input.branchIds, ...branchSearch.neuronIds])),
+            temporalBucketIds: Array.from(new Set([...input.temporalBucketIds, ...branchSearch.temporalTraversal.bucketIds])),
+            temporalNeuronIds: Array.from(new Set([...input.temporalNeuronIds, ...branchSearch.temporalTraversal.neuronIds])),
+            graphIds: input.graphIds,
+            cognitiveGraphIds: input.cognitiveGraphIds,
+            entityNeuronIds: Array.from(new Set([...input.entityNeuronIds, ...branchSearch.denseJointNeuronIds]))
+        });
+        const traversal = this.traversalExecutor.execute({
+            temporalSegments: branchSearch.temporalTraversal.segments,
+            branchIds: branchSearch.branchIds,
+            taskIds: branchSearch.taskIds,
+            clusterIds: branchSearch.clusterIds,
+            denseJointCount: branchSearch.denseJointNeuronIds.length
+        });
+        const narrative = this.narrativeRecallAssembler.assemble({
+            query: input.query,
+            plannerReasons: plan.diagnostics.reasons,
+            pulseTrace: pulse.trace,
+            temporalLabels: branchSearch.temporalTraversal.labels,
+            branchIds: branchSearch.branchIds,
+            entityIds: compiledQuery.entityResolution.resolved.map((entity) => entity.entityId),
+            denseJointCount: branchSearch.denseJointNeuronIds.length,
+            traversalPath: traversal.path,
+            traversalSegments: traversal.segments
+        });
+        return {
+            compiledQuery,
+            branchSearch,
+            pulse,
+            narrative,
+            runtime: {
+                path: traversal.path,
+                segments: traversal.segments
+            }
+        };
+    }
+}

package/dist/retrieval/UniverseTraversalExecutor.d.ts

@@ -0,0 +1,21 @@
+import type { TemporalTraversalSegment } from './TemporalBranchSearch.js';
+export interface UniverseTraversalSegment {
+    stage: 'temporal' | 'day' | 'adjacent_days' | 'project_branch' | 'task_branch' | 'event_cluster' | 'dense';
+    key: string;
+    label: string;
+    count?: number;
+}
+export interface UniverseTraversalExecution {
+    path: string[];
+    segments: UniverseTraversalSegment[];
+}
+export declare class UniverseTraversalExecutor {
+    execute(input: {
+        temporalSegments: TemporalTraversalSegment[];
+        branchIds: string[];
+        taskIds: string[];
+        clusterIds: string[];
+        denseJointCount: number;
+    }): UniverseTraversalExecution;
+}
+//# sourceMappingURL=UniverseTraversalExecutor.d.ts.map

package/dist/retrieval/UniverseTraversalExecutor.js

@@ -0,0 +1,77 @@
+export class UniverseTraversalExecutor {
+    execute(input) {
+        const temporalSegments = input.temporalSegments
+            .slice()
+            .sort((a, b) => a.bucketStart - b.bucketStart);
+        const segments = [];
+        segments.push({
+            stage: 'temporal',
+            key: 'temporal-root',
+            label: temporalSegments[0]?.label || 'temporal:none',
+            count: temporalSegments.length
+        });
+        const firstTemporal = temporalSegments[0];
+        if (firstTemporal) {
+            segments.push({
+                stage: 'day',
+                key: firstTemporal.bucketId,
+                label: firstTemporal.label,
+                count: firstTemporal.neuronIds.length
+            });
+        }
+        for (const segment of temporalSegments.slice(1, 4)) {
+            segments.push({
+                stage: 'adjacent_days',
+                key: segment.bucketId,
+                label: segment.label,
+                count: segment.neuronIds.length
+            });
+        }
+        const preferredBranches = Array.from(new Set([
+            ...temporalSegments.flatMap((segment) => segment.branchIds),
+            ...input.branchIds
+        ]));
+        const preferredTasks = Array.from(new Set([
+            ...temporalSegments.flatMap((segment) => segment.taskIds),
+            ...input.taskIds
+        ]));
+        const preferredClusters = Array.from(new Set([
+            ...temporalSegments.flatMap((segment) => segment.clusterIds),
+            ...input.clusterIds
+        ]));
+        for (const branchId of preferredBranches.slice(0, 3)) {
+            segments.push({
+                stage: 'project_branch',
+                key: branchId,
+                label: `branch:${branchId}`,
+                count: 1
+            });
+        }
+        for (const taskId of preferredTasks.slice(0, 3)) {
+            segments.push({
+                stage: 'task_branch',
+                key: taskId,
+                label: `task:${taskId}`,
+                count: 1
+            });
+        }
+        for (const clusterId of preferredClusters.slice(0, 3)) {
+            segments.push({
+                stage: 'event_cluster',
+                key: clusterId,
+                label: `cluster:${clusterId}`,
+                count: 1
+            });
+        }
+        segments.push({
+            stage: 'dense',
+            key: 'dense_joint',
+            label: 'dense_joint_search',
+            count: input.denseJointCount
+        });
+        return {
+            path: segments.map((segment) => `${segment.stage}:${segment.label}`),
+            segments
+        };
+    }
+}

package/dist/routing/AnswerEvidenceTrace.d.ts

@@ -0,0 +1,18 @@
+export interface EvidenceRef {
+    source: 'initial_recall' | 'brain_recall' | 'get_neuron_context' | 'expand_entity' | 'find_file_assets' | 'get_file_context' | 'find_skills';
+    toolCallId?: string;
+    iterationIndex: number;
+    factIds?: string[];
+    neuronIds?: string[];
+    entityIds?: string[];
+}
+export interface AnswerEvidenceTrace {
+    finalAnswer: string;
+    evidenceRefs: EvidenceRef[];
+    iterationCount: number;
+    toolCallIds: string[];
+    stoppedByPolicy: boolean;
+    stoppedByMaxIter: boolean;
+    totalTokensUsed: number;
+}
+//# sourceMappingURL=AnswerEvidenceTrace.d.ts.map

package/dist/routing/AnswerEvidenceTrace.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/BrainToolDispatcher.d.ts

@@ -0,0 +1,37 @@
+/**
+ * BrainToolDispatcher.ts
+ * Routes BrainToolCall to the correct tool implementation.
+ * Phase 48 — v1.1
+ */
+import type { FactStore } from '../store/FactStore.js';
+import type { EntityStore } from '../store/EntityStore.js';
+import type { BeliefStore } from '../belief/BeliefStore.js';
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+import type { GraphEdgeStoreLike } from '../types/ExtensionPoints.js';
+import type { FileAssetStore, FileChunkStore } from '../assets/index.js';
+import type { ISkillDiscovery } from '../types/ExtensionPoints.js';
+import type { BrainToolCall, BrainToolResult } from './LLMToolSchema.js';
+import type { RecallFunction } from './ExecutionLoop.js';
+import type { BrainToolDispatcherLike, BrainToolDispatchContext } from './IterativeLLMClarifier.js';
+export interface BrainToolDispatcherDeps {
+    recallFn: RecallFunction;
+    memoryGraph: MemoryGraph;
+    factStore: FactStore;
+    entityStore: EntityStore;
+    beliefStore: BeliefStore;
+    graphEdgeStore?: GraphEdgeStoreLike;
+    fileAssetStore?: FileAssetStore;
+    fileChunkStore?: FileChunkStore;
+    skillDiscoveryEngine?: ISkillDiscovery;
+}
+export declare class BrainToolDispatcher implements BrainToolDispatcherLike {
+    private readonly deps;
+    private readonly secondaryRecall;
+    private readonly neuronContext;
+    private readonly entityExpand;
+    private readonly skillDiscovery?;
+    constructor(deps: BrainToolDispatcherDeps);
+    dispatch(call: BrainToolCall, context?: BrainToolDispatchContext): Promise<BrainToolResult>;
+    private error;
+}
+//# sourceMappingURL=BrainToolDispatcher.d.ts.map

package/dist/routing/BrainToolDispatcher.js

@@ -0,0 +1,163 @@
+/**
+ * BrainToolDispatcher.ts
+ * Routes BrainToolCall to the correct tool implementation.
+ * Phase 48 — v1.1
+ */
+import { SecondaryRecallTool } from './tools/SecondaryRecallTool.js';
+import { NeuronContextTool } from './tools/NeuronContextTool.js';
+import { EntityExpandTool } from './tools/EntityExpandTool.js';
+import { SkillDiscoveryTool } from './tools/SkillDiscoveryTool.js';
+/** Unique monotonic counter for call IDs (per process lifetime) */
+let callSeq = 0;
+function nextCallId() {
+    return `tool-call-${Date.now()}-${++callSeq}`;
+}
+export class BrainToolDispatcher {
+    deps;
+    secondaryRecall;
+    neuronContext;
+    entityExpand;
+    skillDiscovery;
+    constructor(deps) {
+        this.deps = deps;
+        this.secondaryRecall = new SecondaryRecallTool(deps.recallFn);
+        this.neuronContext = new NeuronContextTool(deps.memoryGraph, deps.graphEdgeStore);
+        this.entityExpand = new EntityExpandTool(deps.factStore, deps.entityStore, deps.beliefStore);
+        this.skillDiscovery = deps.skillDiscoveryEngine ? new SkillDiscoveryTool(deps.skillDiscoveryEngine) : undefined;
+    }
+    async dispatch(call, context = {}) {
+        const callId = nextCallId();
+        const startedAt = Date.now();
+        try {
+            switch (call.action) {
+                case 'brain_recall': {
+                    if (!call.query) {
+                        return this.error(call.action, callId, 'brain_recall requires a query parameter', startedAt);
+                    }
+                    const output = await this.secondaryRecall.execute({
+                        query: call.query,
+                        entityHint: call.entity_hint,
+                        limit: call.limit,
+                        projectId: context.projectId,
+                        topicPath: context.topicPath,
+                    });
+                    return {
+                        toolName: call.action,
+                        callId,
+                        success: true,
+                        result: output,
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    };
+                }
+                case 'get_neuron_context': {
+                    if (!call.neuron_id) {
+                        return this.error(call.action, callId, 'get_neuron_context requires a neuron_id parameter', startedAt);
+                    }
+                    const output = this.neuronContext.execute(call.neuron_id, context.projectId);
+                    if (!output) {
+                        return this.error(call.action, callId, `Neuron not found: ${call.neuron_id}`, startedAt);
+                    }
+                    return {
+                        toolName: call.action,
+                        callId,
+                        success: true,
+                        result: output,
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    };
+                }
+                case 'expand_entity': {
+                    if (!call.entity_name) {
+                        return this.error(call.action, callId, 'expand_entity requires an entity_name parameter', startedAt);
+                    }
+                    const output = this.entityExpand.execute(call.entity_name, call.entity_type, context.projectId);
+                    if (!output) {
+                        return this.error(call.action, callId, `Entity not found: ${call.entity_name}`, startedAt);
+                    }
+                    return {
+                        toolName: call.action,
+                        callId,
+                        success: true,
+                        result: output,
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    };
+                }
+                case 'find_file_assets': {
+                    if (!this.deps.fileAssetStore) {
+                        return this.error(call.action, callId, 'find_file_assets is not available in this runtime', startedAt);
+                    }
+                    if (!call.query) {
+                        return this.error(call.action, callId, 'find_file_assets requires a query parameter', startedAt);
+                    }
+                    const output = this.deps.fileAssetStore.listByQuery({
+                        query: call.query,
+                        projectId: context.projectId,
+                        extension: call.extension,
+                        mimeType: call.mime_type,
+                        limit: call.limit
+                    });
+                    return {
+                        toolName: call.action,
+                        callId,
+                        success: true,
+                        result: { assets: output },
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    };
+                }
+                case 'get_file_context': {
+                    if (!this.deps.fileChunkStore) {
+                        return this.error(call.action, callId, 'get_file_context is not available in this runtime', startedAt);
+                    }
+                    if (!call.asset_id || typeof call.chunk_index !== 'number') {
+                        return this.error(call.action, callId, 'get_file_context requires asset_id and chunk_index parameters', startedAt);
+                    }
+                    const evidence = this.deps.fileChunkStore.listContext(call.asset_id, call.chunk_index, call.radius ?? 1);
+                    return {
+                        toolName: call.action,
+                        callId,
+                        success: true,
+                        result: { fileEvidence: this.deps.fileChunkStore.groupEvidenceByAsset(evidence) },
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    };
+                }
+                case 'find_skills': {
+                    if (!this.skillDiscovery) {
+                        return this.error(call.action, callId, 'find_skills is not available in this runtime', startedAt);
+                    }
+                    if (!call.query) {
+                        return this.error(call.action, callId, 'find_skills requires a query parameter', startedAt);
+                    }
+                    const output = this.skillDiscovery.execute({
+                        query: call.query,
+                        limit: call.limit,
+                        projectId: context.projectId
+                    });
+                    return {
+                        toolName: call.action,
+                        callId,
+                        success: true,
+                        result: output,
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    };
+                }
+                default: {
+                    const unknownAction = call.action;
+                    return this.error(
+                    // Cast to handle unknown actions gracefully
+                    'brain_recall', callId, `Unknown tool action: ${unknownAction}`, startedAt);
+                }
+            }
+        }
+        catch (err) {
+            return this.error(call.action, callId, err instanceof Error ? err.message : String(err), startedAt);
+        }
+    }
+    error(toolName, callId, message, startedAt) {
+        return {
+            toolName,
+            callId,
+            success: false,
+            errorMessage: message,
+            durationMs: Math.max(0, Date.now() - startedAt),
+        };
+    }
+}

package/dist/routing/ConfidenceGate.d.ts

@@ -0,0 +1,26 @@
+import type { BrainRecallResult } from '../types/BrainRecallResult.js';
+export interface ConfidenceGateResult {
+    score: number;
+    verdict: 'cpu_sufficient' | 'needs_llm';
+    reason: string;
+    signals: {
+        hasCompiledFacts: boolean;
+        highConfidenceFact: boolean;
+        exactEntityMatch: boolean;
+        graphEdgeTraversed: boolean;
+        timeRangeClear: boolean;
+        multipleCorroborating: boolean;
+    };
+}
+export declare class ConfidenceGate {
+    private readonly threshold;
+    constructor(options?: {
+        threshold?: number;
+    });
+    evaluate(recallResult: BrainRecallResult, options?: {
+        queryText?: string;
+        entityHint?: string;
+    }): ConfidenceGateResult;
+    private matchesEntityHint;
+}
+//# sourceMappingURL=ConfidenceGate.d.ts.map

package/dist/routing/ConfidenceGate.js

@@ -0,0 +1,40 @@
+export class ConfidenceGate {
+    threshold;
+    constructor(options = {}) {
+        this.threshold = options.threshold ?? 0.75;
+    }
+    evaluate(recallResult, options = {}) {
+        const facts = recallResult.compiledMemory.facts;
+        const normalizedEntityHint = options.entityHint?.trim().toLowerCase();
+        const signals = {
+            hasCompiledFacts: facts.length > 0,
+            highConfidenceFact: facts.some((fact) => fact.confidence >= 0.85),
+            exactEntityMatch: normalizedEntityHint
+                ? facts.some((fact) => this.matchesEntityHint(fact.subject, fact.object, normalizedEntityHint))
+                : false,
+            graphEdgeTraversed: recallResult.strategy.primaryLevel === 'compiled_memory' &&
+                facts.length > 0 &&
+                recallResult.rawEvidence.length > facts.length,
+            timeRangeClear: facts.some((fact) => typeof fact.validFrom === 'number' && fact.validFrom > 0),
+            multipleCorroborating: facts.length >= 2
+        };
+        const score = Math.min(1, (signals.hasCompiledFacts ? 0.3 : 0) +
+            (signals.highConfidenceFact ? 0.2 : 0) +
+            (signals.exactEntityMatch ? 0.2 : 0) +
+            (signals.graphEdgeTraversed ? 0.15 : 0) +
+            (signals.timeRangeClear ? 0.1 : 0) +
+            (signals.multipleCorroborating ? 0.05 : 0));
+        const triggeredSignals = Object.entries(signals)
+            .filter(([, active]) => active)
+            .map(([name]) => name);
+        return {
+            score,
+            verdict: score >= this.threshold ? 'cpu_sufficient' : 'needs_llm',
+            reason: triggeredSignals.length > 0 ? triggeredSignals.join(', ') : 'none',
+            signals
+        };
+    }
+    matchesEntityHint(subject, object, entityHint) {
+        return subject.toLowerCase().includes(entityHint) || object?.toLowerCase().includes(entityHint) === true;
+    }
+}

package/dist/routing/ConfirmationPhraseMatcher.d.ts

@@ -0,0 +1,9 @@
+export interface ConfirmationMatchResult {
+    action: 'approve' | 'reject';
+    subject?: string;
+}
+export declare class ConfirmationPhraseMatcher {
+    matchConfirmation(message: string): ConfirmationMatchResult | null;
+    private extractSubject;
+}
+//# sourceMappingURL=ConfirmationPhraseMatcher.d.ts.map

package/dist/routing/ConfirmationPhraseMatcher.js

@@ -0,0 +1,43 @@
+const APPROVE_SUBJECT_PATTERNS = [
+    /^(?:确认|批准|同意|允许|执行)\s*(?:部署|发布|运行|执行|启动)?\s*[:：]?\s*(.+?)\s*$/i,
+    /^(?:approve|confirm|authorize)\s+(?:the\s+)?(?:deploy(?:ment)?|release|run|execution)?\s*[: ]\s*(.+?)\s*$/i,
+    /^(?:yes|go\s+ahead|proceed)\s+(?:with\s+)?(.+?)\s*$/i
+];
+const REJECT_SUBJECT_PATTERNS = [
+    /^(?:取消|拒绝|停止|终止|撤销|不要)\s*(?:部署|发布|运行|执行|任务)?\s*[:：]?\s*(.+?)\s*$/i,
+    /^(?:reject|deny|cancel|abort|decline|stop)\s+(?:the\s+)?(?:deployment|release|run|execution|task)?\s*[: ]\s*(.+?)\s*$/i,
+    /^(?:no|don'?t)\s+(?:do|run|deploy|execute)?\s*(.+?)\s*$/i
+];
+const SUBJECT_STRIP_PATTERN = /^(?:that|it|the|这个|那个|本次|这次|该)\s+|[\s，。,.:：;；!?！]+$/g;
+const BARE_CONFIRMATION_PATTERN = /^(?:是|对|好|嗯|确认|没错|正确|否|不是|不|错|取消|放弃|yes|no|y|n)[\s。，！!?.]*$/i;
+export class ConfirmationPhraseMatcher {
+    matchConfirmation(message) {
+        const normalizedMessage = message.trim();
+        if (!normalizedMessage) {
+            return null;
+        }
+        if (BARE_CONFIRMATION_PATTERN.test(normalizedMessage)) {
+            return null;
+        }
+        const approveSubject = this.extractSubject(normalizedMessage, APPROVE_SUBJECT_PATTERNS);
+        if (approveSubject !== null) {
+            return approveSubject ? { action: 'approve', subject: approveSubject } : { action: 'approve' };
+        }
+        const rejectSubject = this.extractSubject(normalizedMessage, REJECT_SUBJECT_PATTERNS);
+        if (rejectSubject !== null) {
+            return rejectSubject ? { action: 'reject', subject: rejectSubject } : { action: 'reject' };
+        }
+        return null;
+    }
+    extractSubject(message, patterns) {
+        for (const pattern of patterns) {
+            const match = message.match(pattern);
+            if (!match) {
+                continue;
+            }
+            const subject = match[1]?.replace(SUBJECT_STRIP_PATTERN, '').trim();
+            return subject || '';
+        }
+        return null;
+    }
+}

package/dist/routing/DirectReplyFormatter.d.ts

@@ -0,0 +1,5 @@
+import type { SystemIntent } from './SystemIntentClassifier.js';
+export declare class DirectReplyFormatter {
+    format(intent: SystemIntent, data: unknown): string;
+}
+//# sourceMappingURL=DirectReplyFormatter.d.ts.map

package/dist/routing/DirectReplyFormatter.js

@@ -0,0 +1,55 @@
+import { formatApprovalsReply } from './templates/approvals_template.js';
+import { formatCapabilitiesReply } from './templates/ability_template.js';
+import { formatContradictionsReply } from './templates/contradictions_template.js';
+import { formatContextReply } from './templates/context_template.js';
+import { formatImportanceReply } from './templates/importance_template.js';
+import { formatMemoryReply } from './templates/memory_template.js';
+import { formatTasksReply } from './templates/tasks_template.js';
+import { formatTraceReply } from './templates/trace_template.js';
+import { formatEnvironmentReply, formatFileAssetsReply, formatModelsReply, formatSelfManifestReply } from './templates/self_manifest_template.js';
+export class DirectReplyFormatter {
+    format(intent, data) {
+        if (data === null || data === undefined) {
+            return '（暂无数据）';
+        }
+        switch (intent) {
+            case 'system_query.tasks':
+            case 'system_command.resume':
+            case 'system_command.cancel_task':
+                return formatTasksReply(data);
+            case 'system_query.approvals':
+            case 'system_command.approve':
+            case 'system_command.reject':
+            case 'system_confirmation.yes_no':
+                return formatApprovalsReply(data);
+            case 'system_query.contradictions':
+                return formatContradictionsReply(data);
+            case 'system_query.capabilities':
+                return formatCapabilitiesReply(data);
+            case 'system_query.environment':
+                return formatEnvironmentReply(data);
+            case 'system_query.models':
+                return formatModelsReply(data);
+            case 'system_query.file_assets':
+                return formatFileAssetsReply(data);
+            case 'system_query.self_manifest':
+                return formatSelfManifestReply(data);
+            case 'system_query.memory_recent':
+            case 'system_query.memory_search':
+                return formatMemoryReply(data);
+            case 'system_query.important_memories':
+            case 'system_command.mark_important':
+            case 'system_command.mark_permanent':
+            case 'system_command.unmark_important':
+                return formatImportanceReply(data);
+            case 'system_query.context':
+                return formatContextReply(data);
+            case 'system_query.trace':
+                return formatTraceReply(data);
+            case 'reasoning_required':
+                return '（暂无数据）';
+            default:
+                return '（暂无数据）';
+        }
+    }
+}

package/dist/routing/EvidenceBudgetManager.d.ts

@@ -0,0 +1,30 @@
+import type { BrainToolCall, BrainToolResult } from './LLMToolSchema.js';
+import { ToolEvidencePack, type ToolEvidenceItem } from './ToolEvidencePack.js';
+export interface EvidenceBudgetConfig {
+    maxTotalTokens: number;
+    maxFactsPerPack: number;
+    maxNeuronSummaries: number;
+    compressionStrategy: 'drop_tail' | 'salience_sort' | 'summary';
+}
+export interface EvidenceBudgetState {
+    usedTokens: number;
+    remainingTokens: number;
+    isOverBudget: boolean;
+}
+export declare class EvidenceBudgetManager {
+    private readonly config;
+    private readonly evidencePack;
+    private readonly normalizer;
+    constructor(config?: Partial<EvidenceBudgetConfig>);
+    absorb(input: {
+        toolResult: BrainToolResult;
+        call: BrainToolCall;
+        sanitizedResult: unknown;
+        projectId?: string;
+        injectionRiskDetected?: boolean;
+    }): ToolEvidenceItem;
+    state(): EvidenceBudgetState;
+    pack(): ToolEvidencePack;
+    compress(): void;
+}
+//# sourceMappingURL=EvidenceBudgetManager.d.ts.map