cogmem 3.6.2

package/dist/routing/MessageRouter.js

@@ -0,0 +1,58 @@
+export class MessageRouter {
+    classifier;
+    managers;
+    formatter;
+    constructor(classifier, managers, formatter) {
+        this.classifier = classifier;
+        this.managers = managers;
+        this.formatter = formatter;
+    }
+    async route(message) {
+        const startedAt = Date.now();
+        const classification = this.classifier.classify(message);
+        if (classification.intent === 'reasoning_required') {
+            return {
+                path: 'slow',
+                intent: 'reasoning_required',
+                reply: '',
+                latencyMs: Date.now() - startedAt
+            };
+        }
+        const data = await this.managers.dispatch(classification.intent, this.buildParams(classification.intent, message, classification.matchedPattern));
+        return {
+            path: 'fast',
+            intent: classification.intent,
+            reply: data === null ? '（该功能暂不可用）' : this.formatter.format(classification.intent, data),
+            latencyMs: Date.now() - startedAt
+        };
+    }
+    buildParams(intent, message, matchedPattern) {
+        switch (intent) {
+            case 'system_query.memory_search':
+                return { q: message.trim() };
+            case 'system_query.memory_recent':
+                return { limit: 10 };
+            case 'system_query.trace':
+                return { limit: 5 };
+            case 'system_command.approve':
+            case 'system_command.reject':
+            case 'system_command.cancel_task': {
+                const extractedId = this.extractIdentifier(message, matchedPattern);
+                return extractedId ? { id: extractedId } : undefined;
+            }
+            default:
+                return undefined;
+        }
+    }
+    extractIdentifier(message, matchedPattern) {
+        const confirmationMatch = matchedPattern?.match(/^confirmation:(?:approve|reject):(.+)$/);
+        if (confirmationMatch?.[1]) {
+            return confirmationMatch[1];
+        }
+        const idMatch = message.match(/\b([A-Za-z0-9][A-Za-z0-9_-]{2,})\b/g);
+        if (!idMatch || idMatch.length === 0) {
+            return undefined;
+        }
+        return idMatch[idMatch.length - 1];
+    }
+}

package/dist/routing/SessionContextSelector.d.ts

@@ -0,0 +1,12 @@
+import type { ChatSessionLike } from '../types/ExtensionPoints.js';
+export interface SessionContextSelectionInput {
+    session?: ChatSessionLike;
+    query: string;
+    projectId?: string;
+    maxChars?: number;
+}
+type SessionTurn = ReturnType<ChatSessionLike['getRecentTurns']>[number];
+export declare function selectCueDrivenSessionTurns(input: SessionContextSelectionInput): SessionTurn[];
+export declare function buildCueDrivenSessionContext(input: SessionContextSelectionInput): string;
+export {};
+//# sourceMappingURL=SessionContextSelector.d.ts.map

package/dist/routing/SessionContextSelector.js

@@ -0,0 +1,86 @@
+const DEFAULT_MAX_CHARS = 4000;
+export function selectCueDrivenSessionTurns(input) {
+    const session = input.session;
+    if (!session)
+        return [];
+    const maxChars = Math.max(1, input.maxChars ?? DEFAULT_MAX_CHARS);
+    const hostSelectedTurns = session.getRelevantTurns?.({
+        query: input.query,
+        projectId: input.projectId,
+        maxChars,
+    });
+    const rawTurns = hostSelectedTurns ?? session.getRecentTurns();
+    const scored = rawTurns
+        .map((turn, index) => ({
+        turn,
+        index,
+        score: turnRelevanceScore(input.query, turn.content),
+    }))
+        .filter((item) => item.turn.content.trim().length > 0);
+    const candidates = hostSelectedTurns
+        ? [...scored].sort((a, b) => b.score - a.score || b.turn.timestamp - a.turn.timestamp || b.index - a.index)
+        : scored
+            .filter((item) => item.score > 0)
+            .sort((a, b) => b.score - a.score || b.turn.timestamp - a.turn.timestamp || b.index - a.index);
+    const fallback = [...scored].sort((a, b) => b.turn.timestamp - a.turn.timestamp || b.index - a.index);
+    const selectedFrom = candidates.length > 0 ? candidates : fallback;
+    const selected = [];
+    let usedChars = 0;
+    for (const item of selectedFrom) {
+        const cost = formatSessionTurn(item.turn).length + 1;
+        if (selected.length > 0 && usedChars + cost > maxChars)
+            continue;
+        selected.push(item);
+        usedChars += cost;
+        if (usedChars >= maxChars)
+            break;
+    }
+    return selected
+        .sort((a, b) => a.turn.timestamp - b.turn.timestamp || a.index - b.index)
+        .map((item) => item.turn);
+}
+export function buildCueDrivenSessionContext(input) {
+    return selectCueDrivenSessionTurns(input)
+        .map(formatSessionTurn)
+        .join('\n');
+}
+function formatSessionTurn(turn) {
+    const role = turn.role === 'user' ? 'User' : 'Agent';
+    return `${role}: ${turn.content.trim()}`;
+}
+function turnRelevanceScore(query, content) {
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0)
+        return 0;
+    const normalizedContent = content.toLowerCase();
+    const lexicalHits = queryTokens.filter((token) => normalizedContent.includes(token)).length;
+    return lexicalHits / queryTokens.length + trigramJaccard(query, content);
+}
+function tokenize(text) {
+    return Array.from(new Set(text
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}_\-\u4e00-\u9fa5\s]/gu, ' ')
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2)));
+}
+function trigrams(text) {
+    const normalized = text.toLowerCase().replace(/\s+/g, ' ').trim();
+    if (normalized.length < 3)
+        return new Set(normalized ? [normalized] : []);
+    const grams = new Set();
+    for (let i = 0; i <= normalized.length - 3; i++)
+        grams.add(normalized.slice(i, i + 3));
+    return grams;
+}
+function trigramJaccard(a, b) {
+    const left = trigrams(a);
+    const right = trigrams(b);
+    if (left.size === 0 && right.size === 0)
+        return 1;
+    let intersection = 0;
+    for (const item of left)
+        if (right.has(item))
+            intersection += 1;
+    return intersection / (left.size + right.size - intersection);
+}

package/dist/routing/SystemIntentClassifier.d.ts

@@ -0,0 +1,15 @@
+import { ConfirmationPhraseMatcher } from './ConfirmationPhraseMatcher.js';
+import { IntentPatternMatcher } from './IntentPatternMatcher.js';
+export type SystemIntent = 'system_query.tasks' | 'system_query.approvals' | 'system_query.contradictions' | 'system_query.capabilities' | 'system_query.environment' | 'system_query.self_manifest' | 'system_query.models' | 'system_query.file_assets' | 'system_query.memory_recent' | 'system_query.memory_search' | 'system_query.important_memories' | 'system_query.context' | 'system_query.trace' | 'system_command.approve' | 'system_command.reject' | 'system_command.resume' | 'system_command.cancel_task' | 'system_command.mark_important' | 'system_command.mark_permanent' | 'system_command.unmark_important' | 'system_confirmation.yes_no' | 'reasoning_required';
+export interface IntentClassificationResult {
+    intent: SystemIntent;
+    confidence: number;
+    matchedPattern?: string;
+}
+export declare class SystemIntentClassifier {
+    private readonly patternMatcher;
+    private readonly confirmationPhraseMatcher;
+    constructor(patternMatcher?: IntentPatternMatcher, confirmationPhraseMatcher?: ConfirmationPhraseMatcher);
+    classify(message: string): IntentClassificationResult;
+}
+//# sourceMappingURL=SystemIntentClassifier.d.ts.map

package/dist/routing/SystemIntentClassifier.js

@@ -0,0 +1,50 @@
+import { ConfirmationPhraseMatcher } from './ConfirmationPhraseMatcher.js';
+import { IntentPatternMatcher } from './IntentPatternMatcher.js';
+export class SystemIntentClassifier {
+    patternMatcher;
+    confirmationPhraseMatcher;
+    constructor(patternMatcher = new IntentPatternMatcher(), confirmationPhraseMatcher = new ConfirmationPhraseMatcher()) {
+        this.patternMatcher = patternMatcher;
+        this.confirmationPhraseMatcher = confirmationPhraseMatcher;
+    }
+    classify(message) {
+        const normalizedMessage = message.trim();
+        if (!normalizedMessage) {
+            return { intent: 'reasoning_required', confidence: 1.0 };
+        }
+        const match = this.patternMatcher.match(normalizedMessage);
+        if (match) {
+            const confirmation = this.confirmationPhraseMatcher.matchConfirmation(normalizedMessage);
+            if (confirmation && (match.intent === 'system_command.approve' || match.intent === 'system_command.reject')) {
+                return {
+                    intent: match.intent,
+                    confidence: 1.0,
+                    matchedPattern: confirmation.subject
+                        ? `confirmation:${confirmation.action}:${confirmation.subject}`
+                        : `confirmation:${confirmation.action}`
+                };
+            }
+            return {
+                intent: match.intent,
+                confidence: 1.0,
+                matchedPattern: match.pattern.source
+            };
+        }
+        const confirmation = this.confirmationPhraseMatcher.matchConfirmation(normalizedMessage);
+        if (confirmation?.action === 'approve') {
+            return {
+                intent: 'system_command.approve',
+                confidence: 1.0,
+                matchedPattern: confirmation.subject ? `confirmation:approve:${confirmation.subject}` : 'confirmation:approve'
+            };
+        }
+        if (confirmation?.action === 'reject') {
+            return {
+                intent: 'system_command.reject',
+                confidence: 1.0,
+                matchedPattern: confirmation.subject ? `confirmation:reject:${confirmation.subject}` : 'confirmation:reject'
+            };
+        }
+        return { intent: 'reasoning_required', confidence: 1.0 };
+    }
+}

package/dist/routing/TaskPlan.d.ts

@@ -0,0 +1,31 @@
+export type IntentType = 'factual_recall' | 'temporal_recall' | 'entity_lookup' | 'cross_domain' | 'correction_check' | 'open_ended';
+export type TaskStepType = 'memory_recall' | 'fact_check' | 'graph_traverse' | 'confidence_check' | 'perception_call' | 'llm_clarify' | 'answer_assemble';
+export interface TaskStep {
+    id: string;
+    type: TaskStepType;
+    label: string;
+    inputs: {
+        query?: string;
+        entityHint?: string;
+        projectId?: string;
+        subjectHint?: string;
+        predicateHint?: string;
+        capabilityId?: string;
+        capabilityInput?: Record<string, unknown>;
+    };
+    triggerCondition?: {
+        dependsOnStepId: string;
+        metric: 'confidence_score';
+        operator: 'lt';
+        threshold: number;
+    };
+    mayCallLLM: boolean;
+}
+export interface TaskPlan {
+    planId: string;
+    intentType: IntentType;
+    query: string;
+    steps: TaskStep[];
+    estimatedLLMCalls: number;
+}
+//# sourceMappingURL=TaskPlan.d.ts.map

package/dist/routing/TaskPlan.js

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

package/dist/routing/TaskRouter.d.ts

@@ -0,0 +1,13 @@
+import { IntentClassifier } from './IntentClassifier.js';
+import type { TaskPlan } from './TaskPlan.js';
+export declare class TaskRouter {
+    private classifier;
+    constructor(classifier?: IntentClassifier);
+    plan(query: string, options?: {
+        projectId?: string;
+        confidenceThreshold?: number;
+    }): TaskPlan;
+    private createStep;
+    private createClarifyStep;
+}
+//# sourceMappingURL=TaskRouter.d.ts.map

package/dist/routing/TaskRouter.js

@@ -0,0 +1,111 @@
+import { randomUUID } from 'crypto';
+import { IntentClassifier } from './IntentClassifier.js';
+export class TaskRouter {
+    classifier;
+    constructor(classifier = new IntentClassifier()) {
+        this.classifier = classifier;
+    }
+    plan(query, options = {}) {
+        const classification = this.classifier.classify(query, { projectId: options.projectId });
+        const threshold = options.confidenceThreshold ?? 0.6;
+        const steps = [];
+        steps.push(this.createStep('step_1', 'memory_recall', 'Recall memory evidence for the query', {
+            query,
+            entityHint: classification.entityHint,
+            projectId: options.projectId
+        }), this.createStep('step_2', 'confidence_check', 'Evaluate confidence of the recall evidence', {
+            query,
+            entityHint: classification.entityHint,
+            projectId: options.projectId
+        }));
+        switch (classification.intentType) {
+            case 'factual_recall':
+            case 'entity_lookup':
+                steps.push(this.createClarifyStep('step_3', 'Clarify low-confidence recall with LLM', 'step_2', threshold, {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }));
+                break;
+            case 'temporal_recall':
+                steps.push(this.createStep('step_3', 'fact_check', 'Check temporal facts for the hinted entity', {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId,
+                    subjectHint: classification.entityHint,
+                    predicateHint: 'any'
+                }), this.createClarifyStep('step_4', 'Clarify low-confidence temporal evidence with LLM', 'step_3', threshold, {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }));
+                break;
+            case 'cross_domain':
+                steps.push(this.createStep('step_3', 'graph_traverse', 'Traverse connected memory graph for related domains', {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }), this.createStep('step_4', 'confidence_check', 'Evaluate confidence of graph traversal evidence', {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }), this.createClarifyStep('step_5', 'Clarify low-confidence graph evidence with LLM', 'step_4', threshold, {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }));
+                break;
+            case 'correction_check':
+                steps.push(this.createStep('step_3', 'fact_check', 'Check whether the prior fact was superseded', {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId,
+                    subjectHint: classification.entityHint,
+                    predicateHint: 'superseded'
+                }), this.createClarifyStep('step_4', 'Clarify low-confidence correction evidence with LLM', 'step_2', threshold, {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }));
+                break;
+            case 'open_ended':
+                steps.push(this.createClarifyStep('step_3', 'Clarify open-ended request with LLM', 'step_2', threshold, {
+                    query,
+                    entityHint: classification.entityHint,
+                    projectId: options.projectId
+                }));
+                break;
+        }
+        return {
+            planId: randomUUID(),
+            intentType: classification.intentType,
+            query,
+            steps,
+            estimatedLLMCalls: steps.filter((step) => step.type === 'llm_clarify').length
+        };
+    }
+    createStep(id, type, label, inputs) {
+        return {
+            id,
+            type,
+            label,
+            inputs,
+            mayCallLLM: false
+        };
+    }
+    createClarifyStep(id, label, dependsOnStepId, threshold, inputs) {
+        return {
+            id,
+            type: 'llm_clarify',
+            label,
+            inputs,
+            triggerCondition: {
+                dependsOnStepId,
+                metric: 'confidence_score',
+                operator: 'lt',
+                threshold
+            },
+            mayCallLLM: true
+        };
+    }
+}

package/dist/routing/ToolCallParser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ToolCallParser.ts
+ * Parses LLM output to extract BrainToolCall JSON objects or detect final answers.
+ * Phase 46 — v1.1 ReAct
+ */
+import type { BrainToolCall } from './LLMToolSchema.js';
+/**
+ * Parse the LLM output and return a BrainToolCall if the response is a
+ * tool invocation, or `null` if it is a final natural-language answer.
+ */
+export declare function parse(llmOutput: string): BrainToolCall | null;
+/**
+ * Returns true when the LLM output is a final answer (no tool call detected).
+ */
+export declare function isFinalAnswer(llmOutput: string): boolean;
+//# sourceMappingURL=ToolCallParser.d.ts.map

package/dist/routing/ToolCallParser.js

@@ -0,0 +1,123 @@
+/**
+ * ToolCallParser.ts
+ * Parses LLM output to extract BrainToolCall JSON objects or detect final answers.
+ * Phase 46 — v1.1 ReAct
+ */
+import { getRequiredParams } from './LLMToolSchema.js';
+const ALLOWED_ACTIONS = new Set([
+    'brain_recall',
+    'get_neuron_context',
+    'expand_entity',
+    'find_file_assets',
+    'get_file_context',
+]);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Attempts to extract the first JSON object from an arbitrary string.
+ * The LLM may prefix its call with explanatory text, e.g.:
+ *   "I need more details.\n{\"action\":\"brain_recall\",...}"
+ *
+ * Strategy: scan for the first '{' that starts a valid JSON object.
+ */
+function extractFirstJsonObject(text) {
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '{') {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                const candidate = text.slice(start, i + 1);
+                try {
+                    const parsed = JSON.parse(candidate);
+                    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    // not valid JSON, continue scanning
+                    depth = 0;
+                    start = -1;
+                }
+            }
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Parse the LLM output and return a BrainToolCall if the response is a
+ * tool invocation, or `null` if it is a final natural-language answer.
+ */
+export function parse(llmOutput) {
+    if (!llmOutput || typeof llmOutput !== 'string')
+        return null;
+    const trimmed = llmOutput.trim();
+    if (trimmed.startsWith('[')) {
+        try {
+            if (Array.isArray(JSON.parse(trimmed)))
+                return null;
+        }
+        catch {
+            // Fall through to object extraction for malformed text with later JSON.
+        }
+    }
+    const obj = extractFirstJsonObject(llmOutput);
+    if (obj === null)
+        return null;
+    const action = obj['action'];
+    if (typeof action !== 'string')
+        return null;
+    if (!ALLOWED_ACTIONS.has(action))
+        return null;
+    const toolName = action;
+    // Validate required parameters
+    const required = getRequiredParams(toolName);
+    for (const param of required) {
+        if (obj[param] === undefined || obj[param] === null || obj[param] === '') {
+            return null; // missing required field → treat as final answer
+        }
+    }
+    // Build the typed BrainToolCall
+    const call = { action: toolName };
+    if (typeof obj['query'] === 'string')
+        call.query = obj['query'];
+    if (typeof obj['entity_hint'] === 'string')
+        call.entity_hint = obj['entity_hint'];
+    if (typeof obj['limit'] === 'number')
+        call.limit = obj['limit'];
+    if (typeof obj['neuron_id'] === 'string')
+        call.neuron_id = obj['neuron_id'];
+    if (typeof obj['entity_name'] === 'string')
+        call.entity_name = obj['entity_name'];
+    if (typeof obj['entity_type'] === 'string')
+        call.entity_type = obj['entity_type'];
+    if (typeof obj['extension'] === 'string')
+        call.extension = obj['extension'];
+    if (typeof obj['mime_type'] === 'string')
+        call.mime_type = obj['mime_type'];
+    if (typeof obj['asset_id'] === 'string')
+        call.asset_id = obj['asset_id'];
+    if (typeof obj['chunk_index'] === 'number')
+        call.chunk_index = obj['chunk_index'];
+    if (typeof obj['radius'] === 'number')
+        call.radius = obj['radius'];
+    if (typeof obj['reason'] === 'string')
+        call.reason = obj['reason'];
+    return call;
+}
+/**
+ * Returns true when the LLM output is a final answer (no tool call detected).
+ */
+export function isFinalAnswer(llmOutput) {
+    return parse(llmOutput) === null;
+}

package/dist/routing/ToolEvidenceNormalizer.d.ts

@@ -0,0 +1,13 @@
+import type { BrainToolCall, BrainToolResult } from './LLMToolSchema.js';
+import { type ToolEvidenceItem } from './ToolEvidencePack.js';
+export interface ToolEvidenceNormalizeInput {
+    toolResult: BrainToolResult;
+    call: BrainToolCall;
+    sanitizedResult: unknown;
+    projectId?: string;
+    injectionRiskDetected?: boolean;
+}
+export declare class ToolEvidenceNormalizer {
+    normalize(input: ToolEvidenceNormalizeInput): ToolEvidenceItem;
+}
+//# sourceMappingURL=ToolEvidenceNormalizer.d.ts.map

package/dist/routing/ToolEvidenceNormalizer.js

@@ -0,0 +1,96 @@
+import { estimateTokens } from './ToolEvidencePack.js';
+export class ToolEvidenceNormalizer {
+    normalize(input) {
+        const payload = objectPayload(input.sanitizedResult);
+        const facts = factArray(payload.facts);
+        const events = eventArray(payload.events);
+        const neurons = neuronSummaries(payload);
+        const entityIds = entityIdsFor(input.call, payload, facts);
+        const beliefs = beliefArray(payload.beliefs);
+        const query = input.call.query ?? input.call.neuron_id ?? input.call.entity_name ?? '';
+        const relevanceScore = computeRelevance(query, facts, events, neurons, beliefs);
+        return {
+            toolCallId: input.toolResult.callId,
+            toolName: input.toolResult.toolName,
+            query,
+            facts,
+            events,
+            neurons,
+            entityIds,
+            beliefs,
+            relevanceScore,
+            estimatedTokens: estimateTokens(JSON.stringify({ facts, events, neurons, entityIds, beliefs })),
+            addedAt: Date.now(),
+            projectId: input.projectId,
+            sanitized: true,
+            injectionRiskDetected: input.injectionRiskDetected ?? false,
+        };
+    }
+}
+function objectPayload(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function factArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function eventArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function beliefArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function neuronSummaries(payload) {
+    const summaries = [];
+    const neuron = objectPayload(payload.neuron);
+    if (typeof neuron.neuronId === 'string') {
+        summaries.push({
+            neuronId: neuron.neuronId,
+            contentPreview: String(neuron.content ?? '').slice(0, 500),
+            tags: Array.isArray(neuron.tags) ? neuron.tags.filter((tag) => typeof tag === 'string') : [],
+            type: typeof neuron.type === 'string' ? neuron.type : 'unknown',
+            createdAt: typeof neuron.createdAt === 'number' ? neuron.createdAt : undefined,
+            projectId: typeof neuron.projectId === 'string' ? neuron.projectId : undefined,
+        });
+    }
+    const neighbors = Array.isArray(payload.neighbors) ? payload.neighbors : [];
+    for (const raw of neighbors) {
+        const n = objectPayload(raw);
+        if (typeof n.neuronId !== 'string')
+            continue;
+        summaries.push({
+            neuronId: n.neuronId,
+            contentPreview: String(n.content ?? '').slice(0, 300),
+            tags: Array.isArray(n.tags) ? n.tags.filter((tag) => typeof tag === 'string') : [],
+            type: typeof n.type === 'string' ? n.type : 'unknown',
+            projectId: typeof n.projectId === 'string' ? n.projectId : undefined,
+        });
+    }
+    return summaries;
+}
+function entityIdsFor(call, payload, facts) {
+    const ids = new Set();
+    if (typeof payload.entityId === 'string')
+        ids.add(payload.entityId);
+    if (call.entity_name && typeof payload.entityId === 'string')
+        ids.add(payload.entityId);
+    for (const fact of facts) {
+        if (fact.entityId)
+            ids.add(fact.entityId);
+    }
+    return Array.from(ids);
+}
+function computeRelevance(query, facts, events, neurons, beliefs) {
+    const q = query.toLowerCase();
+    if (!q)
+        return 0.5;
+    const haystacks = [
+        ...facts.map((f) => `${f.subject} ${f.predicateFamily} ${f.predicateValue ?? ''} ${f.object ?? ''}`),
+        ...events.map((e) => `${e.eventType} ${e.actor ?? ''} ${e.target ?? ''}`),
+        ...neurons.map((n) => n.contentPreview),
+        ...beliefs.map((b) => `${b.subject} ${b.predicate} ${b.objectValue.raw}`),
+    ];
+    if (haystacks.length === 0)
+        return 0.1;
+    const hits = haystacks.filter((text) => text.toLowerCase().includes(q)).length;
+    return Math.max(0.2, Math.min(1, hits / haystacks.length + 0.4));
+}

package/dist/routing/ToolEvidencePack.d.ts

@@ -0,0 +1,36 @@
+import type { BeliefRecord } from '../types/index.js';
+import type { EventRecord, FactRecord } from '../store/FactStore.js';
+import type { BrainToolName } from './LLMToolSchema.js';
+export interface NeuronEvidenceSummary {
+    neuronId: string;
+    contentPreview: string;
+    tags: string[];
+    type: string;
+    createdAt?: number;
+    projectId?: string;
+}
+export interface ToolEvidenceItem {
+    toolCallId: string;
+    toolName: BrainToolName;
+    query: string;
+    facts: FactRecord[];
+    events: EventRecord[];
+    neurons: NeuronEvidenceSummary[];
+    entityIds: string[];
+    beliefs: BeliefRecord[];
+    relevanceScore: number;
+    estimatedTokens: number;
+    addedAt: number;
+    projectId?: string;
+    sanitized: boolean;
+    injectionRiskDetected: boolean;
+}
+export declare class ToolEvidencePack {
+    readonly items: ToolEvidenceItem[];
+    add(item: ToolEvidenceItem): void;
+    deduplicate(): void;
+    totalTokens(): number;
+    toPromptSummary(limit: number): string;
+}
+export declare function estimateTokens(text: string): number;
+//# sourceMappingURL=ToolEvidencePack.d.ts.map