labre-mcp 0.1.0

package/dist/work-on-evolution/routing/mode-router.mjs

@@ -0,0 +1,351 @@
+// Mode router: unified entry point for estimateEvolution requests
+//
+// Provides mode selection logic that:
+//   1. Accepts an explicit mode parameter ('oneshot' | 'guided')
+//   2. Auto-detects mode from input signals when mode is not specified
+//   3. Routes to the correct handler (one-shot or conversational guided)
+//   4. Returns responses through shared formatting
+//
+// Auto-detection heuristics:
+//   → guided: sessionState present (continuing a conversation)
+//   → oneshot: sufficient params for direct evaluation (name + certitude/ubiquity or pub data)
+//   → guided: minimal input (only name, or name + description without numeric params)
+//
+// Both modes share the same response formatter for consistent output.
+import { estimateEvolutionOneShot, estimateEvolutionConversational } from '../estimate-evolution.mjs';
+import { formatResponse } from '../../lib/response-formatter.mjs';
+// ─── Mode Constants ────────────────────────────────────────────────────────
+/** Supported execution modes */
+export const MODES = {
+    ONESHOT: 'oneshot',
+    GUIDED: 'guided',
+};
+/** Aliases mapped to canonical mode names */
+const MODE_ALIASES = {
+    oneshot: MODES.ONESHOT,
+    'one-shot': MODES.ONESHOT,
+    'one_shot': MODES.ONESHOT,
+    single: MODES.ONESHOT,
+    direct: MODES.ONESHOT,
+    guided: MODES.GUIDED,
+    conversational: MODES.GUIDED,
+    conversation: MODES.GUIDED,
+    interactive: MODES.GUIDED,
+    multiturn: MODES.GUIDED,
+    'multi-turn': MODES.GUIDED,
+    multi_turn: MODES.GUIDED,
+};
+// ─── Mode Detection ────────────────────────────────────────────────────────
+/**
+ * Determine whether the input has enough numeric parameters for a meaningful
+ * one-shot evaluation (beyond just the classification gate).
+ *
+ * @param {Object} input - Request input
+ * @returns {boolean} True if there are enough params for one-shot evaluation
+ */
+// any: input is the raw MCP arguments bag (validated downstream)
+function hasEvaluationParams(input) {
+    if (!input || typeof input !== 'object')
+        return false;
+    // S-curve params: certitude + ubiquity
+    const hasSCurveParams = input.certitude != null && input.ubiquity != null;
+    // Distribution-based params: phaseDistribution with at least one bin
+    const hasPhaseDistribution = input.phaseDistribution
+        && Array.isArray(input.phaseDistribution.bins)
+        && input.phaseDistribution.bins.length > 0;
+    // At least one complete param set for a strategy
+    return hasSCurveParams || hasPhaseDistribution;
+}
+/**
+ * Detect the execution mode from the input signals.
+ *
+ * Decision tree:
+ *   1. Explicit mode parameter → use it (resolved through aliases)
+ *   2. sessionState present → guided (continuing a conversation)
+ *   3. space explicitly provided → oneshot (user knows the classification)
+ *   4. Sufficient evaluation params → oneshot (enough data for strategies)
+ *   5. Otherwise → guided (need to gather more context)
+ *
+ * @param {Object} input - Raw request input
+ * @returns {{ mode: string, reason: string }} Detected mode and reason for the choice
+ */
+// any: input is the raw MCP arguments bag (mode/space/sessionState/eval params auto-detected)
+export function detectMode(input) {
+    if (!input || typeof input !== 'object') {
+        return { mode: MODES.GUIDED, reason: 'no valid input — defaulting to guided mode' };
+    }
+    // 1. Explicit mode parameter
+    if (input.mode != null && typeof input.mode === 'string') {
+        const normalized = input.mode.trim().toLowerCase();
+        const canonical = MODE_ALIASES[normalized];
+        if (canonical) {
+            return { mode: canonical, reason: `explicit mode parameter: "${input.mode}"` };
+        }
+        // 'default' or unrecognized → fall through to auto-detection
+        if (normalized !== 'default' && normalized !== 'auto') {
+            return { mode: MODES.GUIDED, reason: `unrecognized mode "${input.mode}" — defaulting to guided` };
+        }
+    }
+    // 2. Session state present → continuing a guided conversation
+    if (input.sessionState) {
+        return { mode: MODES.GUIDED, reason: 'sessionState present — continuing guided conversation' };
+    }
+    // 3. Explicit space → user pre-classified, likely one-shot
+    if (input.space != null) {
+        return { mode: MODES.ONESHOT, reason: 'space pre-classified — using one-shot mode' };
+    }
+    // 4. Sufficient evaluation parameters → one-shot
+    if (hasEvaluationParams(input)) {
+        return { mode: MODES.ONESHOT, reason: 'sufficient evaluation parameters for direct estimation' };
+    }
+    // 5. Default: guided mode (gather more context)
+    return { mode: MODES.GUIDED, reason: 'insufficient parameters — using guided mode to gather context' };
+}
+// ─── Shared Response Shape ─────────────────────────────────────────────────
+/**
+ * @typedef {Object} RoutedResponse
+ * @property {string}  mode             - 'oneshot' or 'guided'
+ * @property {string}  modeReason       - Why this mode was selected
+ * @property {Object}  classification   - Classification gate result
+ * @property {string[]|null} reQuestions - Re-questioning prompts for non-economic
+ * @property {Object|null}   evaluations - Strategy evaluation results
+ * @property {string}  message          - Human-readable summary
+ * @property {string}  formatted        - Markdown-formatted output (shared formatter)
+ * @property {string|null} sessionState - Session state for guided mode continuation
+ * @property {Object|null}  nextQuestion - Next question in guided mode
+ * @property {string|null}  phase        - Current phase in guided mode
+ * @property {Object|null}  routing      - Solution/capability routing metadata (type, confidence, method, evalMode)
+ */
+// ─── Unified Router ────────────────────────────────────────────────────────
+/**
+ * Route an estimateEvolution request to the appropriate mode handler
+ * and return a consistently shaped response.
+ *
+ * This is the single entry point for all estimateEvolution requests,
+ * whether from MCP tool calls, skill invocations, or direct API use.
+ *
+ * @param {Object} input - Request input with optional mode parameter
+ * @returns {Promise<RoutedResponse>} Unified response with mode, results, and formatting
+ */
+// any: input is raw MCP arguments bag
+export async function routeEstimateEvolution(input = {}) {
+    const { mode, reason } = detectMode(input);
+    if (mode === MODES.ONESHOT) {
+        return routeOneShot(input, reason);
+    }
+    return routeGuided(input, reason);
+}
+// ─── One-Shot Route ────────────────────────────────────────────────────────
+/**
+ * Route to one-shot mode: all parameters in a single call.
+ *
+ * @param {Object} input - Request input
+ * @param {string} modeReason - Why one-shot was selected
+ * @returns {Promise<RoutedResponse>}
+ */
+async function routeOneShot(input, modeReason) {
+    // Map input to one-shot API format
+    const oneShotInput = {
+        name: input.name,
+        description: input.description,
+        context: input.context,
+        space: input.space,
+        strategy: input.strategy || 'all',
+        ...(input.certitude != null && { certitude: input.certitude }),
+        ...(input.ubiquity != null && { ubiquity: input.ubiquity }),
+        ...(input.phaseDistribution != null && { phaseDistribution: input.phaseDistribution }),
+        ...(input.pipeline != null && { pipeline: Boolean(input.pipeline) }),
+    };
+    const result = await estimateEvolutionOneShot(oneShotInput);
+    // Format through shared formatter
+    const formatted = formatResponse(result, {
+        component: oneShotInput,
+        compact: input.compact || false,
+    });
+    // When pipeline mode is active, the result has a different shape with
+    // pipeline-specific fields (owmOutput, capabilityPivot, sotaSolution, etc.).
+    // Standard fields live under result.standardResult in that case.
+    const r = result; // any: result is a RoutedResponse | PipelineResponse union
+    const std = r.pipeline ? (r.standardResult || {}) : r;
+    const response = {
+        mode: MODES.ONESHOT,
+        modeReason,
+        classification: std.classification || r.classification,
+        reQuestions: std.reQuestions || r.reQuestions,
+        evaluations: std.evaluations || r.evaluations,
+        message: std.message || r.message,
+        formatted,
+        // One-shot mode has no session state or questions
+        sessionState: null,
+        nextQuestion: null,
+        phase: null,
+        // Pass through routing metadata (solution/capability detection + confidence)
+        routing: std.routing || r.routing || null,
+    };
+    // Pass through pipeline-specific fields when pipeline mode is active
+    if (r.pipeline) {
+        response.pipeline = true;
+        response.owmOutput = r.owmOutput;
+        response.owm = r.owm;
+        response.capabilityPivot = r.capabilityPivot;
+        response.sotaSolution = r.sotaSolution;
+        response.legacySolution = r.legacySolution;
+        response.discoveredSolutions = r.discoveredSolutions;
+        response.componentName = r.componentName;
+    }
+    return response;
+}
+// ─── Guided Route ──────────────────────────────────────────────────────────
+/**
+ * Route to guided (conversational) mode: progressive question-asking.
+ *
+ * @param {Object} input - Request input
+ * @param {string} modeReason - Why guided was selected
+ * @returns {Promise<RoutedResponse>}
+ */
+async function routeGuided(input, modeReason) {
+    // Build conversational input
+    const conversationalInput = {
+        sessionState: input.sessionState || null,
+        data: {},
+        forceEstimate: input.forceEstimate || false,
+        strategy: input.strategy,
+    };
+    // Map all available data into the conversational data payload
+    if (input.name)
+        conversationalInput.data.name = input.name;
+    if (input.description)
+        conversationalInput.data.description = input.description;
+    if (input.context)
+        conversationalInput.data.context = input.context;
+    if (input.space)
+        conversationalInput.data.space = input.space;
+    if (input.certitude != null)
+        conversationalInput.data.certitude = input.certitude;
+    if (input.ubiquity != null)
+        conversationalInput.data.ubiquity = input.ubiquity;
+    if (input.phaseDistribution != null)
+        conversationalInput.data.phaseDistribution = input.phaseDistribution;
+    if (input.sector)
+        conversationalInput.data.sector = input.sector;
+    if (input.maturitySignals)
+        conversationalInput.data.maturitySignals = input.maturitySignals;
+    if (input.marketDynamics)
+        conversationalInput.data.marketDynamics = input.marketDynamics;
+    if (input.adoptionPattern)
+        conversationalInput.data.adoptionPattern = input.adoptionPattern;
+    const result = await estimateEvolutionConversational(conversationalInput);
+    // Format through shared formatter for complete results;
+    // for intermediate turns, format inline
+    let formatted;
+    if (result.phase === 'complete') {
+        formatted = formatResponse(result, {
+            component: conversationalInput.data,
+            compact: input.compact || false,
+        });
+    }
+    else {
+        formatted = formatGuidedTurn(result);
+    }
+    return {
+        mode: MODES.GUIDED,
+        modeReason,
+        classification: result.classification,
+        reQuestions: result.reQuestions,
+        evaluations: result.evaluations,
+        message: result.message,
+        formatted,
+        sessionState: result.sessionState,
+        nextQuestion: result.nextQuestion || null,
+        phase: result.phase,
+        // Pass through routing metadata (solution/capability detection + confidence)
+        routing: result.routing || null, // any: routing is an optional extension field
+    };
+}
+// ─── Guided Turn Formatter ─────────────────────────────────────────────────
+/**
+ * Format an intermediate guided turn into markdown.
+ * Uses the shared response formatter's conventions for consistent styling.
+ *
+ * @param {Object} result - Result from estimateEvolutionConversational
+ * @returns {string} Markdown-formatted response
+ */
+// any: result is the conversational session output (loose shape)
+function formatGuidedTurn(result) {
+    const lines = [];
+    // Re-questioning for non-economic components
+    if (result.reQuestions && result.reQuestions.length > 0) {
+        const name = result.summary?.gathered?.name || 'the component';
+        lines.push(`## Evolution Estimation: ${name}`);
+        lines.push('');
+        lines.push(`**Classification:** ${result.classification?.space}`);
+        lines.push('');
+        lines.push('### ⚠️ Component Outside Economic Space');
+        lines.push('');
+        lines.push('Evolution evaluation is not applicable. Please consider:');
+        lines.push('');
+        for (let i = 0; i < result.reQuestions.length; i++) {
+            lines.push(`${i + 1}. ${result.reQuestions[i]}`);
+        }
+        lines.push('');
+        lines.push('💡 *Re-specify with economic context to proceed (e.g., "bottled oxygen" instead of "air").*');
+        return lines.join('\n');
+    }
+    // Intermediate turn: present next question with progress
+    const nextQ = result.nextQuestion;
+    if (!nextQ) {
+        return 'Session state is unclear. Provide more data or use `forceEstimate: true` to proceed.';
+    }
+    // Phase order depends on whether the component is on the solution or capability path
+    const isSolutionPath = result.summary?.componentType === 'solution' ||
+        result.summary?.gathered?.componentType === 'solution';
+    const phaseOrder = isSolutionPath
+        ? ['identity', 'classification', 'solution_context', 'ready']
+        : ['identity', 'classification', 'characteristics', 'market_signals', 'ready'];
+    const currentIdx = phaseOrder.indexOf(result.phase);
+    const totalPhases = phaseOrder.length - 1;
+    const phaseLabels = {
+        identity: 'Component Identity',
+        classification: 'Economic Classification',
+        characteristics: 'Maturity Characteristics',
+        market_signals: 'Market & Publication Signals',
+        solution_context: 'Solution Context (12-Property Evaluation)',
+    };
+    lines.push(`### Guided Estimation — Phase ${currentIdx + 1}/${totalPhases}: ${phaseLabels[result.phase] || result.phase}`);
+    lines.push('');
+    // Progress bar
+    const progressPct = Math.round((currentIdx / totalPhases) * 100);
+    const filled = Math.round(progressPct / 10);
+    lines.push(`Progress: [${'█'.repeat(filled)}${'░'.repeat(10 - filled)}] ${progressPct}%`);
+    lines.push('');
+    // Main question
+    lines.push(`**${nextQ.prompt}**`);
+    lines.push('');
+    // Hints
+    if (nextQ.hints && nextQ.hints.length > 0) {
+        for (const hint of nextQ.hints) {
+            if (hint.startsWith('✓') || hint === '') {
+                lines.push(`  ${hint}`);
+            }
+            else {
+                lines.push(`  - ${hint}`);
+            }
+        }
+        lines.push('');
+    }
+    // Gathered context
+    const summary = result.summary;
+    if (summary && Object.keys(summary.gathered).length > 0) {
+        lines.push('**Already gathered:**');
+        for (const [key, val] of Object.entries(summary.gathered)) {
+            if (key !== 'space' && key !== 'strategy') {
+                const display = typeof val === 'number' ? val.toFixed(2) : val;
+                lines.push(`  - ${key}: ${display}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push('*Tip: Provide all values at once for one-shot mode, or say "estimate now" to force estimation with available data.*');
+    return lines.join('\n');
+}
+//# sourceMappingURL=mode-router.mjs.map

package/dist/work-on-evolution/routing/mode-router.mjs.map

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

package/dist/work-on-evolution/routing/solution-capability-router.d.mts

@@ -0,0 +1,4 @@
+export { detectComponentType, normalizeName, isCommonWord, matchKnownSolution, matchKnownCapability, applyHeuristics, COMPONENT_TYPE, CONFIDENCE_THRESHOLD, } from '../../lib/component-detection.mjs';
+export { EVAL_MODES, getEvalMode, determineRoutingTargets, createSolutionStrategyInstance, dispatchSolutionStrategies, dispatchWithRouting, } from './solution-dispatch.mjs';
+export { WARDLEY_TYPE, WARDLEY_TYPE_PATTERNS, classifyWardleyType, } from './wardley-type-classification.mjs';
+//# sourceMappingURL=solution-capability-router.d.mts.map

package/dist/work-on-evolution/routing/solution-capability-router.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solution-capability-router.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/solution-capability-router.mts"],"names":[],"mappings":"AA6BA,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,cAAc,EACd,oBAAoB,GACrB,MAAM,mCAAmC,CAAC;AAU3C,OAAO,EACL,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,8BAA8B,EAC9B,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AAMjC,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,mCAAmC,CAAC"}

package/dist/work-on-evolution/routing/solution-capability-router.mjs

@@ -0,0 +1,36 @@
+// Solution vs Capability Router
+//
+// Core routing rule:
+//   NAMED components → SOLUTION path  (products, frameworks, methodologies, standards)
+//   GENERIC components → CAPABILITY path (abstract activities, practices, data, knowledge)
+//
+// "Named" means the component has a specific identity: a brand name, a proper
+// noun, a titled framework or methodology, or a recognized standard.
+// Examples: Kubernetes, ITIL, Scrum, ISO 27001, TOGAF, Six Sigma, React, SAP ERP
+//
+// "Generic" means the component describes an abstract capability that could be
+// fulfilled by multiple implementations or is not tied to a specific identity.
+// Examples: container orchestration, CRM, change management, data storage
+//
+// Detection strategy (ordered by priority):
+//   1. Naming convention heuristics with confidence score (fast, no LLM)
+//   2. When confidence < 90%, the caller should use LLM + web search fallback
+//      (implemented separately in the routing dispatch layer via
+//       dual-verification-orchestrator.mjs)
+//
+// Routing is exclusive by default (env: WARDLEY_EVAL_MODE=exclusive|parallel):
+//   - exclusive: routes to solution-strategies OR capability strategies, not both
+//   - parallel: routes to both, returns combined results
+//
+// The router does NOT modify existing strategy files or the capability pipeline.
+// It sits AFTER the classification gate and BEFORE strategy dispatch.
+// ─── Detection functions extracted to routing/component-detection.mjs ────────
+// Re-exported here for backward compatibility with existing consumers.
+export { detectComponentType, normalizeName, isCommonWord, matchKnownSolution, matchKnownCapability, applyHeuristics, COMPONENT_TYPE, CONFIDENCE_THRESHOLD, } from '../../lib/component-detection.mjs';
+// ─── Dispatch functions extracted to routing/solution-dispatch.mjs ───────────
+// Re-exported here for backward compatibility with existing consumers.
+export { EVAL_MODES, getEvalMode, determineRoutingTargets, createSolutionStrategyInstance, dispatchSolutionStrategies, dispatchWithRouting, } from './solution-dispatch.mjs';
+// ─── Wardley Type Classification extracted to routing/wardley-type-classification.mjs ─
+// Re-exported here for backward compatibility with existing consumers.
+export { WARDLEY_TYPE, WARDLEY_TYPE_PATTERNS, classifyWardleyType, } from './wardley-type-classification.mjs';
+//# sourceMappingURL=solution-capability-router.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solution-capability-router.mjs","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/solution-capability-router.mts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,EAAE;AACF,qBAAqB;AACrB,uFAAuF;AACvF,2FAA2F;AAC3F,EAAE;AACF,8EAA8E;AAC9E,qEAAqE;AACrE,iFAAiF;AACjF,EAAE;AACF,+EAA+E;AAC/E,+EAA+E;AAC/E,0EAA0E;AAC1E,EAAE;AACF,4CAA4C;AAC5C,yEAAyE;AACzE,8EAA8E;AAC9E,iEAAiE;AACjE,4CAA4C;AAC5C,EAAE;AACF,+EAA+E;AAC/E,kFAAkF;AAClF,yDAAyD;AACzD,EAAE;AACF,iFAAiF;AACjF,sEAAsE;AAEtE,gFAAgF;AAChF,uEAAuE;AACvE,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,cAAc,EACd,oBAAoB,GACrB,MAAM,mCAAmC,CAAC;AAQ3C,gFAAgF;AAChF,uEAAuE;AACvE,OAAO,EACL,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,8BAA8B,EAC9B,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AAIjC,yFAAyF;AACzF,uEAAuE;AACvE,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,mCAAmC,CAAC"}

package/dist/work-on-evolution/routing/solution-dispatch.d.mts

@@ -0,0 +1,91 @@
+import type { ComponentTypeDetection } from '../../types/routing.mjs';
+/** Routing modes */
+export declare const EVAL_MODES: {
+    EXCLUSIVE: string;
+    PARALLEL: string;
+};
+/**
+ * Get the current evaluation mode from environment variable.
+ *
+ * @returns {string} 'exclusive' or 'parallel'
+ */
+export declare function getEvalMode(): string;
+/**
+ * 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 declare function determineRoutingTargets(detection: ComponentTypeDetection | null): {
+    useSolutionStrategies: boolean;
+    useCapabilityStrategies: boolean;
+    mode: string;
+};
+/**
+ * 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}
+ */
+export declare function createSolutionStrategyInstance(StrategyCls: any, deps?: any): any;
+/**
+ * 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>>}
+ */
+export declare function dispatchSolutionStrategies(component: any, options?: any): Promise<Record<string, any>>;
+/**
+ * @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>}
+ */
+export declare function dispatchWithRouting(component: any, options?: any): Promise<any>;
+//# sourceMappingURL=solution-dispatch.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solution-dispatch.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/routing/solution-dispatch.mts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE,oBAAoB;AACpB,eAAO,MAAM,UAAU;;;CAGtB,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,WAAW,WAI1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,sBAAsB,GAAG,IAAI,GAAG;IAAE,qBAAqB,EAAE,OAAO,CAAC;IAAC,uBAAuB,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAyBpK;AAUD;;;;;;;;;;;GAWG;AAEH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,GAAG,EAAE,IAAI,GAAE,GAAQ,GAAG,GAAG,CAWpF;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAsB,0BAA0B,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CA+ChH;AAED;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAqDzF"}