labre-mcp 0.1.0

package/dist/work-on-evolution/routing/solution-dispatch.mjs

@@ -0,0 +1,230 @@
+// Solution Strategy Dispatch & Routing
+//
+// Extracted from solution-capability-router.mjs for single-responsibility.
+//
+// Contains:
+//   - EVAL_MODES constant
+//   - getEvalMode() — reads routing mode from env
+//   - determineRoutingTargets() — exclusive vs parallel routing decision
+//   - createSolutionStrategyInstance() — DI wrapper for solution strategies
+//   - dispatchSolutionStrategies() — run all/specific solution strategies
+//   - dispatchWithRouting() — full routing + dispatch pipeline
+import { loadSolutionStrategies } from '../strategies/solution/registry.mjs';
+import { assembleSolutionResult } from '../strategies/solution/assemble-result.mjs';
+import { logDebug } from '../../lib/mcp-notifications.mjs';
+import { COMPONENT_TYPE, detectComponentType, } from '../../lib/component-detection.mjs';
+import { toErrorMessage } from '../../lib/errors.mjs';
+/** Routing modes */
+export const EVAL_MODES = {
+    EXCLUSIVE: 'exclusive',
+    PARALLEL: 'parallel',
+};
+// ─── Routing Mode ─────────────────────────────────────────────────────────────
+/**
+ * Get the current evaluation mode from environment variable.
+ *
+ * @returns {string} 'exclusive' or 'parallel'
+ */
+export function getEvalMode() {
+    const mode = (process.env.WARDLEY_EVAL_MODE || 'exclusive').toLowerCase().trim();
+    if (mode === 'parallel')
+        return EVAL_MODES.PARALLEL;
+    return EVAL_MODES.EXCLUSIVE;
+}
+/**
+ * Determine routing targets based on component detection and eval mode.
+ *
+ * Enforces the core routing rule:
+ *   NAMED → solution-strategies (12 Wardley property evaluation)
+ *   GENERIC → capability strategies (6 capability strategies including CPC)
+ *
+ * In exclusive mode (default):
+ *   - solution detected → route to solution-strategies ONLY
+ *   - capability detected → route to capability strategies ONLY
+ *
+ * In parallel mode:
+ *   - always route to BOTH strategy sets
+ *
+ * @param {ComponentTypeDetection} detection - Result from detectComponentType()
+ *   or from the dual-verification orchestrator (routingDetection field)
+ * @returns {{ useSolutionStrategies: boolean, useCapabilityStrategies: boolean, mode: string }}
+ */
+export function determineRoutingTargets(detection) {
+    const mode = getEvalMode();
+    if (mode === EVAL_MODES.PARALLEL) {
+        return {
+            useSolutionStrategies: true,
+            useCapabilityStrategies: true,
+            mode: EVAL_MODES.PARALLEL,
+        };
+    }
+    // Exclusive mode (default)
+    if (detection?.type === COMPONENT_TYPE.SOLUTION) {
+        return {
+            useSolutionStrategies: true,
+            useCapabilityStrategies: false,
+            mode: EVAL_MODES.EXCLUSIVE,
+        };
+    }
+    return {
+        useSolutionStrategies: false,
+        useCapabilityStrategies: true,
+        mode: EVAL_MODES.EXCLUSIVE,
+    };
+}
+// ─── Solution Strategy Dispatch ──────────────────────────────────────────────
+//
+// The dispatch layer sits between the routing decision and the strategy
+// execution. When the router determines a component is a solution, these
+// functions instantiate and run solution strategies from the solution-strategies
+// registry. Results conform to the same EvolutionResult contract used by
+// capability strategies, so consumers treat both uniformly.
+/**
+ * Create a solution strategy instance with LLM dependencies injected.
+ *
+ * Solution strategies (like properties-strategy) require an llmCall.
+ * This mirrors createStrategyInstance() in estimate-evolution.mjs.
+ *
+ * @param {typeof import('../strategies/solution/solution-base-strategy.mjs').SolutionBaseStrategy} StrategyCls
+ * @param {Object} deps
+ * @param {function} [deps.llmCall] - LLM call function
+ * @param {string}   [deps.mode]   - 'auto' or 'conversational'
+ * @returns {import('../strategies/solution/solution-base-strategy.mjs').SolutionBaseStrategy}
+ */
+// any: StrategyCls is a constructor and deps is a DI bag with diverse shapes
+export function createSolutionStrategyInstance(StrategyCls, deps = {}) {
+    // All solution strategies currently use LLM for evaluation
+    if (deps.llmCall) {
+        return new StrategyCls({
+            llmCall: deps.llmCall,
+            ...(deps.mode && { mode: deps.mode }),
+        });
+    }
+    // Try default constructor as fallback (may throw if llmCall required)
+    return new StrategyCls();
+}
+/**
+ * Run all (or a specific) solution strategies on a component.
+ *
+ * This is the solution-side equivalent of the capability strategy loop
+ * in estimateEvolutionOneShot().
+ *
+ * @param {Object} component - Component to evaluate (tagged as solution)
+ * @param {Object} options
+ * @param {function} options.llmCall - LLM call function
+ * @param {string}   [options.strategy='all'] - Specific strategy method or 'all'
+ * @param {string}   [options.mode='auto']    - 'auto' or 'conversational'
+ * @returns {Promise<Object<string, import('../strategies/solution/solution-base-strategy.mjs').SolutionEvolutionResult>>}
+ */
+// any: options is a heterogeneous bag (llmCall, strategy, mode, etc.)
+export async function dispatchSolutionStrategies(component, options = {}) {
+    const { llmCall, strategy = 'all', mode = 'auto' } = options;
+    const evaluations = {};
+    // Tag the component for solution strategies
+    const solutionComponent = { ...component, isSolution: true };
+    if (strategy === 'all') {
+        const strategies = await loadSolutionStrategies();
+        const strategyNames = [...strategies.keys()];
+        logDebug('solution-dispatch', `Running ${strategyNames.length} solution strategy(ies) for "${component.name}": ${strategyNames.join(', ')}`);
+        for (const [method, StrategyCls] of strategies) {
+            try {
+                logDebug('solution-dispatch', `Running solution strategy "${method}" on "${component.name}"...`);
+                const instance = createSolutionStrategyInstance(StrategyCls, { llmCall, mode });
+                const rawResult = await Promise.resolve(instance.evaluate(solutionComponent));
+                // Enrich with structured metadata (phase distribution, stage, confidence metadata)
+                evaluations[method] = assembleSolutionResult(rawResult, { mode });
+                logDebug('solution-dispatch', `Solution "${method}": evolution=${rawResult.evolution}, confidence=${rawResult.confidence}`);
+            }
+            catch (err) {
+                evaluations[method] = { error: toErrorMessage(err) };
+                logDebug('solution-dispatch', `Solution "${method}" failed: ${toErrorMessage(err)}`);
+            }
+        }
+    }
+    else {
+        // Run specific solution strategy
+        try {
+            const { getSolutionStrategy } = await import('../strategies/solution/registry.mjs');
+            const StrategyCls = await getSolutionStrategy(strategy);
+            logDebug('solution-dispatch', `Running solution strategy "${strategy}" on "${component.name}"...`);
+            const instance = createSolutionStrategyInstance(StrategyCls, { llmCall, mode });
+            const rawResult = await Promise.resolve(instance.evaluate(solutionComponent));
+            // Enrich with structured metadata
+            evaluations[strategy] = assembleSolutionResult(rawResult, { mode });
+            logDebug('solution-dispatch', `Solution "${strategy}": evolution=${rawResult.evolution}, confidence=${rawResult.confidence}`);
+        }
+        catch (err) {
+            evaluations[strategy] = { error: toErrorMessage(err) };
+            logDebug('solution-dispatch', `Solution "${strategy}" failed: ${toErrorMessage(err)}`);
+        }
+    }
+    return evaluations;
+}
+/**
+ * @typedef {Object} RoutedEvaluationResult
+ * @property {Object}  evaluations           - Merged evaluations from all dispatched strategies
+ * @property {Object}  [solutionEvaluations] - Solution-only evaluations (present when solution strategies ran)
+ * @property {Object}  [capabilityEvaluations] - Capability-only evaluations (present when capability strategies ran)
+ * @property {ComponentTypeDetection} detection - The detection result
+ * @property {{ useSolutionStrategies: boolean, useCapabilityStrategies: boolean, mode: string }} targets - Routing targets
+ */
+/**
+ * Full routing + dispatch pipeline.
+ *
+ * Detects component type, determines routing targets, dispatches to the
+ * appropriate strategy set(s), and returns merged evaluations.
+ *
+ * For capability strategies, the caller provides a callback that runs
+ * the existing capability evaluation pipeline. For solution strategies,
+ * this function dispatches directly.
+ *
+ * @param {Object} component - Component with at least { name }
+ * @param {Object} options
+ * @param {function} [options.llmCall]  - LLM call function (for detection fallback + solution strategies)
+ * @param {function} [options.runCapabilityStrategies] - Callback: (component, strategy) => Promise<evaluations>
+ * @param {string}   [options.strategy='all']  - Strategy name or 'all'
+ * @param {string}   [options.mode='auto']     - 'auto' or 'conversational'
+ * @param {string}   [options.description]     - Component description for detection
+ * @returns {Promise<RoutedEvaluationResult>}
+ */
+// any: options is a heterogeneous bag and the response includes legacy fields (detection, mode, …)
+export async function dispatchWithRouting(component, options = {}) {
+    const { llmCall, runCapabilityStrategies: capabilityCallback, strategy = 'all', mode = 'auto', description = '', } = options;
+    // Step 1: Detect component type. `description` is a label-like signal
+    // suitable for classification; `context` (business environment) is not used
+    // here to avoid contaminating the detection heuristics with unrelated prose.
+    const detection = detectComponentType(component.name, description || component.description || component.name || '');
+    // Step 2: Determine routing targets
+    const targets = determineRoutingTargets(detection);
+    logDebug('solution-dispatch', `Routing "${component.name}": type=${detection.type}, confidence=${detection.confidence}, ` +
+        `mode=${targets.mode} -> solution=${targets.useSolutionStrategies}, capability=${targets.useCapabilityStrategies}`);
+    let capabilityEvaluations = {};
+    let solutionEvaluations = {};
+    // Step 3a: Run capability strategies if routed
+    if (targets.useCapabilityStrategies && typeof capabilityCallback === 'function') {
+        capabilityEvaluations = await capabilityCallback(component, strategy);
+    }
+    // Step 3b: Run solution strategies if routed
+    if (targets.useSolutionStrategies) {
+        solutionEvaluations = await dispatchSolutionStrategies(component, {
+            llmCall,
+            strategy: strategy === 'all' ? 'all' : strategy,
+            mode,
+        });
+    }
+    // Step 4: Merge evaluations (solution results get a 'solution:' prefix to avoid key collisions)
+    const evaluations = { ...capabilityEvaluations };
+    for (const [method, result] of Object.entries(solutionEvaluations)) {
+        // Only prefix if there would be a key collision
+        const key = evaluations[method] ? `solution:${method}` : method;
+        evaluations[key] = result;
+    }
+    return {
+        evaluations,
+        solutionEvaluations,
+        capabilityEvaluations,
+        detection,
+        targets,
+    };
+}
+//# sourceMappingURL=solution-dispatch.mjs.map

package/dist/work-on-evolution/routing/solution-dispatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"solution-dispatch.mjs","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/solution-dispatch.mts"],"names":[],"mappings":"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"}

package/dist/work-on-evolution/routing/wardley-type-classification.d.mts

@@ -0,0 +1,37 @@
+/** @typedef {'activity'|'practice'|'data'|'knowledge'} WardleyComponentType */
+/** Wardley component type constants */
+export declare const WARDLEY_TYPE: {
+    ACTIVITY: string;
+    PRACTICE: string;
+    DATA: string;
+    KNOWLEDGE: string;
+};
+/**
+ * Heuristic patterns for Wardley component type classification.
+ * Applied when the type isn't already known from dictionary lookup.
+ */
+export declare const WARDLEY_TYPE_PATTERNS: {
+    activity: RegExp[];
+    practice: RegExp[];
+    data: RegExp[];
+    knowledge: RegExp[];
+};
+/**
+ * Classify a Wardley component into one of the 4 types:
+ * activity, practice, data, or knowledge.
+ *
+ * Uses a layered approach:
+ *   1. If the component was matched in KNOWN_CAPABILITIES and has a `nature` field, use it directly
+ *   2. If the component was matched in KNOWN_SOLUTIONS, infer from category
+ *   3. Apply heuristic patterns on the component name and description
+ *   4. Default to 'activity' (most common in Wardley Maps)
+ *
+ * @param {string} name - Component name
+ * @param {Object} [options]
+ * @param {string} [options.description] - Component description for contextual inference
+ * @param {string} [options.nature] - Pre-existing nature from detection (e.g. from KNOWN_CAPABILITIES)
+ * @param {string} [options.category] - Category from KNOWN_SOLUTIONS
+ * @returns {{ wardleyType: WardleyComponentType, confidence: number, reason: string }}
+ */
+export declare function classifyWardleyType(name: string, options?: any): any;
+//# sourceMappingURL=wardley-type-classification.d.mts.map

package/dist/work-on-evolution/routing/wardley-type-classification.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wardley-type-classification.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/wardley-type-classification.mts"],"names":[],"mappings":"AAaA,+EAA+E;AAE/E,uCAAuC;AACvC,eAAO,MAAM,YAAY;;;;;CAKxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;CAuCjC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CA8ExE"}

package/dist/work-on-evolution/routing/wardley-type-classification.mjs

@@ -0,0 +1,154 @@
+// Wardley Component Type Classification
+//
+// Wardley Maps distinguish 4 types of components along the value chain:
+//   - Activity:   things you DO (manage, process, deliver, store, compute...)
+//   - Practice:   HOW you do things (methodologies, standards, frameworks, approaches)
+//   - Data:       information, metrics, records, signals, datasets
+//   - Knowledge:  expertise, skills, understanding, models, algorithms
+//
+// This classification is informative metadata only -- it does NOT change routing
+// or evaluation logic. It enriches the output for Wardley Map construction.
+import { KNOWN_CAPABILITIES } from '../../lib/known-dictionaries.mjs';
+/** @typedef {'activity'|'practice'|'data'|'knowledge'} WardleyComponentType */
+/** Wardley component type constants */
+export const WARDLEY_TYPE = {
+    ACTIVITY: 'activity',
+    PRACTICE: 'practice',
+    DATA: 'data',
+    KNOWLEDGE: 'knowledge',
+};
+/**
+ * Heuristic patterns for Wardley component type classification.
+ * Applied when the type isn't already known from dictionary lookup.
+ */
+export const WARDLEY_TYPE_PATTERNS = {
+    activity: [
+        // Starts with activity verb
+        /^(manage|orchestrate|process|deliver|store|compute|deploy|build|create|monitor|serve|route|host|run|handle|track|schedule|encrypt|collect|aggregate|index|backup|restore|notify|moderate|operate|execute|provision|scale|configure|maintain|administer|integrate|automate|authenticate|authorize|balance|cache|search|stream|replicate)\b/i,
+        // Gerund + noun (activity phrasing): "load balancing", "event streaming"
+        /^\w+ing\s+\w+/i,
+        // "management" suffix
+        /\bmanagement$/i,
+        // Common activity suffixes
+        /\b(processing|delivery|storage|hosting|computing|deployment|provisioning|scheduling|orchestration|brokering|streaming|balancing|routing|caching|archiving)\b$/i,
+    ],
+    practice: [
+        // "how to" prefix
+        /^how\s+to\b/i,
+        // Known practice patterns
+        /\b(methodology|framework|standard|best.?practice|process\s+model|approach|discipline|principle|pattern|governance|compliance|certification)\b/i,
+        // -ops family (DevOps, MLOps, etc.)
+        /ops$/i,
+        // "as code" patterns (infrastructure as code, etc.)
+        /\bas\s+(code|a\s+service)$/i,
+        // Continuous * (CI/CD family)
+        /^continuous\s+/i,
+        // Agile / Lean / Six Sigma type names
+        /\b(agile|lean|six\s+sigma|kaizen|kanban|scrum|xp|tdd|bdd|ddd|sre|itil|cobit|togaf|safe|prince2)\b/i,
+    ],
+    data: [
+        // Explicit data words
+        /\b(data|dataset|database|record|metric|signal|log|index|catalog|registry|inventory|report|dashboard|feed|telemetry|trace|event\s+data|time.?series|metadata)\b/i,
+        // Information / intelligence terms
+        /\b(information|intelligence|insight|analytics\s+data|sensor\s+data)\b/i,
+    ],
+    knowledge: [
+        // Expertise / skills / know-how
+        /\b(expertise|skill|know-?how|knowledge|competence|proficiency|understanding|literacy|fluency)\b/i,
+        // ML / AI models and algorithms
+        /\b(model|algorithm|neural\s+network|machine\s+learning|deep\s+learning|natural\s+language|computer\s+vision|artificial\s+intelligence|generative\s+ai)\b/i,
+        // Research / science domains
+        /\b(research|science|theory|taxonomy|ontology|heuristic)\b/i,
+    ],
+};
+/**
+ * Classify a Wardley component into one of the 4 types:
+ * activity, practice, data, or knowledge.
+ *
+ * Uses a layered approach:
+ *   1. If the component was matched in KNOWN_CAPABILITIES and has a `nature` field, use it directly
+ *   2. If the component was matched in KNOWN_SOLUTIONS, infer from category
+ *   3. Apply heuristic patterns on the component name and description
+ *   4. Default to 'activity' (most common in Wardley Maps)
+ *
+ * @param {string} name - Component name
+ * @param {Object} [options]
+ * @param {string} [options.description] - Component description for contextual inference
+ * @param {string} [options.nature] - Pre-existing nature from detection (e.g. from KNOWN_CAPABILITIES)
+ * @param {string} [options.category] - Category from KNOWN_SOLUTIONS
+ * @returns {{ wardleyType: WardleyComponentType, confidence: number, reason: string }}
+ */
+// any: options accept loose ad-hoc fields (nature, category) and return is heterogeneous
+export function classifyWardleyType(name, options = {}) {
+    const trimmed = (name || '').trim();
+    // Layer 1: Use pre-existing nature from dictionary lookup
+    if (options.nature) {
+        const validTypes = new Set(Object.values(WARDLEY_TYPE));
+        if (validTypes.has(options.nature)) {
+            return {
+                wardleyType: options.nature,
+                confidence: 0.95,
+                reason: `dictionary match (nature: ${options.nature})`,
+            };
+        }
+    }
+    // Layer 2: Check KNOWN_CAPABILITIES directly for nature
+    const normalized = trimmed.toLowerCase().replace(/\s+/g, ' ');
+    const capMatch = KNOWN_CAPABILITIES.get(normalized);
+    if (capMatch?.nature) {
+        return {
+            wardleyType: capMatch.nature,
+            confidence: 0.95,
+            reason: `known capability "${capMatch.canonical}" (nature: ${capMatch.nature})`,
+        };
+    }
+    // Layer 3: Infer from solution category (most solutions enable activities)
+    if (options.category) {
+        const cat = options.category.toLowerCase();
+        if (/\b(data|database|analytics|warehouse|lake)\b/.test(cat)) {
+            return { wardleyType: WARDLEY_TYPE.DATA, confidence: 0.70, reason: `solution category "${options.category}" suggests data` };
+        }
+        if (/\b(framework|methodology|standard|practice)\b/.test(cat)) {
+            return { wardleyType: WARDLEY_TYPE.PRACTICE, confidence: 0.70, reason: `solution category "${options.category}" suggests practice` };
+        }
+        if (/\b(ai|ml|model|algorithm|language)\b/.test(cat)) {
+            return { wardleyType: WARDLEY_TYPE.KNOWLEDGE, confidence: 0.70, reason: `solution category "${options.category}" suggests knowledge` };
+        }
+        // Most solution categories (CRM, ERP, platform, etc.) map to activity
+        return { wardleyType: WARDLEY_TYPE.ACTIVITY, confidence: 0.60, reason: `solution category "${options.category}" defaults to activity` };
+    }
+    // Layer 4: Pattern-based heuristic on name + description
+    const textToCheck = `${trimmed} ${options.description || ''}`.trim();
+    const scores = { activity: 0, practice: 0, data: 0, knowledge: 0 };
+    for (const [type, patterns] of Object.entries(WARDLEY_TYPE_PATTERNS)) {
+        for (const pattern of patterns) {
+            if (pattern.test(textToCheck)) {
+                scores[type] += 1;
+            }
+        }
+    }
+    const maxScore = Math.max(...Object.values(scores));
+    if (maxScore > 0) {
+        // invariant: maxScore > 0 ⇒ at least one entry has that score
+        const bestEntry = Object.entries(scores).find(([, s]) => s === maxScore);
+        if (!bestEntry)
+            throw new Error('wardley-type-classification: maxScore > 0 but no matching entry');
+        const bestType = bestEntry[0];
+        // Confidence: higher when one type clearly dominates
+        const totalMatches = Object.values(scores).reduce((a, b) => a + b, 0);
+        const dominance = maxScore / totalMatches;
+        const confidence = Math.round(Math.min(0.90, 0.50 + dominance * 0.40) * 100) / 100;
+        return {
+            wardleyType: bestType,
+            confidence,
+            reason: `pattern match (${maxScore} indicator(s) for ${bestType})`,
+        };
+    }
+    // Layer 5: Default to activity (most common component type in Wardley Maps)
+    return {
+        wardleyType: WARDLEY_TYPE.ACTIVITY,
+        confidence: 0.40,
+        reason: 'default classification (no strong signals detected)',
+    };
+}
+//# sourceMappingURL=wardley-type-classification.mjs.map

package/dist/work-on-evolution/routing/wardley-type-classification.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wardley-type-classification.mjs","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/wardley-type-classification.mts"],"names":[],"mappings":"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"}

package/dist/work-on-evolution/routing/web-search-verification.d.mts

@@ -0,0 +1,94 @@
+import type { WebSearchVerificationResult } from '../../types/routing.mjs';
+/**
+ * @typedef {Object} WebSearchEvidence
+ * @property {string} type         - Evidence type: 'product-page' | 'wikipedia' | 'vendor-association' | 'pricing' | 'repository' | 'concept-article' | 'multi-implementation' | 'generic'
+ * @property {string} description  - Human-readable description of the evidence
+ * @property {string} [source]     - Source URL or domain
+ * @property {'solution'|'capability'} supports - Which classification this evidence supports
+ */
+/**
+ * @typedef {Object} WebSearchReference
+ * @property {string} title  - Page/article title
+ * @property {string} [url]  - Source URL
+ * @property {string} [snippet] - Relevant snippet or excerpt
+ */
+/**
+ * @typedef {Object} WebSearchVerificationResult
+ * @property {'solution'|'capability'} classification - Component classification
+ * @property {number}  confidence   - Confidence score (0–1)
+ * @property {string}  method       - Always 'web-search'
+ * @property {string}  reasoning    - Human-readable explanation
+ * @property {boolean} isSolution   - Convenience flag
+ * @property {WebSearchEvidence[]}  evidence   - Structured evidence items
+ * @property {WebSearchReference[]} references - Source references found
+ */
+/**
+ * Prompt template for web search-based verification.
+ *
+ * The LLM is instructed to:
+ *   1. Search the web for information about the component
+ *   2. Analyze results for product/solution vs capability evidence
+ *   3. Return structured classification with references
+ */
+/**
+ * Parse the web search verification response from the LLM.
+ *
+ * Extracts classification, confidence, reasoning, evidence, and references
+ * from the structured response format. Falls back to keyword-based extraction
+ * if the response doesn't match the expected format.
+ *
+ * @param {string} text - Raw LLM response text
+ * @param {string} name - Component name (for fallback messages)
+ * @returns {WebSearchVerificationResult}
+ */
+export declare function parseWebSearchResponse(text: string, name: string): import("../../types/routing.mjs").ComponentTypeDetection;
+/**
+ * Create a web search call function backed by the Claude Agent SDK.
+ *
+ * Uses `query()` with WebSearch and WebFetch tools enabled so the LLM can
+ * perform real web searches to gather evidence about a component.
+ *
+ * @param {Object} [config={}]
+ * @param {string} [config.model='claude-sonnet-4-6'] - Model to use
+ * @param {number} [config.maxBudgetUsd=0.08]         - Budget limit per call
+ * @param {number} [config.maxTurns=3]                 - Max tool-use turns (search + analyze)
+ * @returns {function(string, Object?): Promise<string>}
+ */
+export declare function createWebSearchCall(config?: any): (prompt: string) => Promise<string>;
+/**
+ * Verify whether a component is a known product/solution or an abstract
+ * capability using web search evidence.
+ *
+ * This function is designed as the fallback tier in the detection pipeline:
+ *   Tier 1: Naming convention heuristics (fast, no cost)
+ *   Tier 2: LLM semantic classification (moderate cost)
+ *   Tier 3: Web search verification (higher cost, higher accuracy) ← this
+ *
+ * @param {string} name - Component name to verify
+ * @param {Object} [options={}]
+ * @param {function(string): Promise<string>} [options.webSearchCall]
+ *   Custom web search function. If not provided, creates one via
+ *   createWebSearchCall(). Accepts a prompt and returns raw text response.
+ * @param {string} [options.context] - Additional context about the component
+ * @returns {Promise<WebSearchVerificationResult>}
+ */
+export declare function verifyViaWebSearch(name: string, options?: {
+    description?: string;
+    context?: string;
+    webSearchCall?: any;
+    timeoutMs?: number;
+}): Promise<WebSearchVerificationResult>;
+/**
+ * Combine web search verification with a prior naming/LLM classification.
+ *
+ * Used by the detection pipeline to merge evidence from multiple tiers.
+ * When web search agrees with the prior result, confidence is boosted.
+ * When they disagree, the web search result takes priority (it has
+ * stronger evidence) but confidence is reduced.
+ *
+ * @param {Object} priorResult   - Result from naming or LLM tier
+ * @param {WebSearchVerificationResult} webResult - Web search result
+ * @returns {WebSearchVerificationResult} Combined result
+ */
+export declare function combineWithPriorResult(priorResult: any, webResult: WebSearchVerificationResult): any;
+//# sourceMappingURL=web-search-verification.d.mts.map

package/dist/work-on-evolution/routing/web-search-verification.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-search-verification.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/web-search-verification.mts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,2BAA2B,EAAyC,MAAM,yBAAyB,CAAC;AA4BlH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;GASG;AAIH;;;;;;;GAOG;AAKH;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,4DAmChE;AAmLD;;;;;;;;;;;GAWG;AAEH,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,GAAQ,IAOd,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAAC,CAqDrE;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAgD9L;AAID;;;;;;;;;;;GAWG;AAEH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,GAAG,EAAE,SAAS,EAAE,2BAA2B,GAAG,GAAG,CAmCpG"}