labre-mcp 0.1.0

package/dist/work-on-evolution/write/estimate-evolution.mjs

@@ -0,0 +1,654 @@
+// One-shot evolution estimation entry point
+//
+// Accepts all required parameters (name, description, space) in a single call
+// and returns a complete evolution estimation result.
+//
+// Pipeline: validate → classify (or use provided space) → evaluate → format
+//
+// This module provides a high-level API on top of the MCP tool handler,
+// adding explicit one-shot mode support with a `space` parameter that
+// allows callers to pre-classify components and bypass the classification gate.
+import { buildReQuestions } from './routing/classification-gate.mjs';
+import { loadStrategies, getStrategy, listStrategies } from './strategies/capacity/registry.mjs';
+import { ConversationSession } from '../../session/conversation-session.mjs';
+import { getStrategyLLM, getStrategyLogprobLLM } from '../../lib/llm/registry.mjs';
+import { identifyCapability } from '../../work-on-value-chain/write/component/identify-capability.mjs';
+import { logDebug, logInfo } from '../../lib/mcp-notifications.mjs';
+import { createMessageResolverFromArgs } from '../../lib/progress-messages.mjs';
+import { detectComponentType, COMPONENT_TYPE, CONFIDENCE_THRESHOLD, } from '../../lib/component-detection.mjs';
+import { determineRoutingTargets, dispatchSolutionStrategies, } from './routing/solution-dispatch.mjs';
+import { classifyWardleyType } from '../../work-on-value-chain/write/component/wardley-type-classification.mjs';
+import { verifyClassification } from '../../work-on-value-chain/write/component/dual-verification-orchestrator.mjs';
+import { runEnrichedPipeline } from './pipeline/pipeline-enriched.mjs';
+import { validateOneShotInput, resolveClassification } from './lib/evolution-input-validation.mjs';
+import { toErrorMessage } from '../../lib/errors.mjs';
+/**
+ * @typedef {Object} OneShotResult
+ * @property {'oneshot'}  mode          - Always 'oneshot' for this entry point
+ * @property {import('./routing/classification-gate.mjs').ClassificationResult} classification
+ * @property {string[]|null} reQuestions - Re-questioning prompts if non-economic
+ * @property {Object<string, import('./strategies/capacity/base-strategy.mjs').EvolutionResult>|null} evaluations
+ * @property {Object}    [routing]      - Solution/capability routing metadata
+ * @property {{ type: string, confidence: number, reason: string }} [wardleyType] - Wardley component type (activity/practice/data/knowledge) — informative metadata only
+ * @property {string}    message        - Human-readable summary
+ */
+// ─── One-Shot Evaluation ────────────────────────────────────────────────────
+/**
+ * Estimate evolution of a Wardley Map component in one-shot mode.
+ *
+ * Accepts all parameters in a single call and returns a complete result.
+ * The pipeline:
+ *   1. Validate input
+ *   2. Classify (or use provided space)
+ *   3. If non-economic: return re-questioning prompts
+ *   4. If economic: evaluate with selected strategy(ies)
+ *   5. Format and return the result
+ *
+ * @param {OneShotInput} rawInput - All parameters for the estimation
+ * @returns {Promise<OneShotResult>} Complete estimation result
+ */
+// any: rawInput is the raw MCP arguments bag (validated downstream); result is RoutedResponse
+export async function estimateEvolutionOneShot(rawInput) {
+    // Step 1: Validate input
+    const validated = validateOneShotInput(rawInput);
+    const { name, description, space, strategy, pipeline, ...componentData } = validated;
+    // ── Localized message resolver (pilot: estimateEvolution) ──────────
+    const { msg, lang } = createMessageResolverFromArgs({ name, description, context: description });
+    const TOOL = 'estimateEvolution';
+    // Info-level: tool start (localized)
+    logInfo(TOOL, msg('tool.start', { tool: TOOL, component: name }));
+    const t0 = Date.now();
+    logDebug(TOOL, `Input validated: component="${name}", strategy="${strategy}"${space ? `, space="${space}"` : ''} [lang=${lang}]`);
+    // Step 2: Classify
+    const classification = resolveClassification(name, description ?? '', space);
+    logDebug(TOOL, msg('step.classification', { component: name, space: classification.space }));
+    // Step 3: Non-economic → re-questioning
+    if (classification.requiresReQuestion) {
+        const reQuestions = buildReQuestions(classification, name);
+        const duration = Date.now() - t0;
+        logInfo(TOOL, msg('tool.end', { tool: TOOL, component: name, duration }));
+        return {
+            mode: 'oneshot',
+            classification,
+            reQuestions,
+            evaluations: null,
+            message: `Component "${name}" classified as ${classification.space}. ` +
+                `Evolution evaluation is not applicable — please review the re-questioning prompts.`,
+        };
+    }
+    // Step 4: Build component input for strategies.
+    // `context` and `description` have distinct semantics — never fall back from
+    // one to the other. Caller supplies each slot independently; missing context
+    // is a signal for strategies to warn, not something to paper over here.
+    // any: ComponentInput superset including pipeline-specific fields
+    const component = {
+        name,
+        ...(description ? { description } : {}),
+        ...componentData,
+    };
+    // Step 4b: Identify underlying capability for LLM strategies
+    try {
+        const capResult = await identifyCapability(component, getStrategyLLM('identify-capability'));
+        component.capability = capResult.capability;
+        component.nature = capResult.nature;
+        logDebug(TOOL, `Identified capability for "${name}": ${capResult.capability} (${capResult.nature})`);
+    }
+    catch {
+        // LLM not available — skip capability identification (analytical strategies don't need it)
+    }
+    // Step 4c: Route component to solution or capability strategies
+    //   Tier 1: Fast naming convention detection
+    const detection = detectComponentType(name, description);
+    let routingTargets = determineRoutingTargets(detection);
+    let verifiedDetection = null;
+    logDebug(TOOL, `Routing "${name}": type=${detection.type}, confidence=${detection.confidence}, ` +
+        `needsFallback=${detection.needsFallback}, evalMode=${routingTargets.mode}`);
+    // Fallback: when naming convention confidence < 90%, delegate to the
+    // dual-verification orchestrator (LLM + web search) for higher accuracy.
+    // Forwards the component name plus any partial classification context
+    // accumulated so far (description, capability, nature).
+    if (detection.needsFallback) {
+        logDebug(TOOL, `Naming confidence ${detection.confidence} < 0.90 for "${name}" — triggering dual-verification fallback`);
+        try {
+            const partialContext = {
+                description,
+                llmCall: getStrategyLLM('dual-verification'),
+                ...(component.capability && { capability: component.capability }),
+                ...(component.nature && { nature: component.nature }),
+            };
+            verifiedDetection = await verifyClassification(name, partialContext);
+            // Use verified result for routing (overrides naming-only detection)
+            routingTargets = verifiedDetection.routingTargets;
+            logDebug(TOOL, `Dual-verification result for "${name}": type=${verifiedDetection.classification}, ` +
+                `confidence=${verifiedDetection.confidence}, method=${verifiedDetection.method}, ` +
+                `verified=${verifiedDetection.verified}, tiers=${verifiedDetection.tiersUsed.join('+')}`);
+        }
+        catch (err) {
+            // Fallback failed — continue with the naming-only detection
+            logDebug(TOOL, `Dual-verification fallback failed for "${name}": ${toErrorMessage(err)} — using naming-only routing`);
+        }
+    }
+    logDebug(TOOL, `Final routing "${name}": solution=${routingTargets.useSolutionStrategies}, ` +
+        `capability=${routingTargets.useCapabilityStrategies}`);
+    // Pose the canonical `kind` discriminant on the component as soon as routing
+    // is settled. Downstream enrichment (pipeline-enriched) reads this rather
+    // than the result-side usedSolutionStrategies flag.
+    const effectiveType = verifiedDetection ? verifiedDetection.classification : detection.type;
+    component.kind = effectiveType === COMPONENT_TYPE.SOLUTION ? 'solution' : 'capability';
+    // Step 5: Evaluate with selected strategy(ies) — dispatched via routing
+    const evaluations = {};
+    // Step 5a: Run capability strategies (existing pipeline) if routed
+    if (routingTargets.useCapabilityStrategies) {
+        logDebug(TOOL, `Dispatching "${name}" to capability strategies`);
+        if (strategy === 'all') {
+            const strategies = await loadStrategies();
+            const strategyNames = [...strategies.keys()];
+            logDebug(TOOL, `Loaded ${strategyNames.length} capability strategies for "${name}": ${strategyNames.join(', ')}`);
+            // Phase A: Run all non-s-curve strategies in parallel via the shared
+            // helper. Phase B (enrichment) and Phase C (s-curve) stay sequential
+            // below because they depend on phase A outputs.
+            const phaseA = [...strategies].filter(([m]) => m !== 'write:capacity:s-curve');
+            for (const [method] of phaseA) {
+                logDebug(TOOL, msg('step.strategy', { strategy: method, component: name }));
+            }
+            const phaseAOutcomes = await evaluateStrategiesInParallel(phaseA, component);
+            for (const { method, result, error } of phaseAOutcomes) {
+                if (error == null) {
+                    evaluations[method] = result;
+                    logDebug(TOOL, msg('step.strategy.result', { strategy: method, evolution: result.evolution, confidence: result.confidence }));
+                }
+                else {
+                    evaluations[method] = { error };
+                    logDebug(TOOL, msg('step.strategy.error', { strategy: method, error }));
+                }
+            }
+            // Phase B: If certitude/ubiquity not on the component, derive from LLM strategies
+            // any: ComponentInput enriched with derived fields from LLM signals
+            const enrichedComponent = { ...component };
+            if (enrichedComponent.certitude == null || enrichedComponent.ubiquity == null) {
+                const llmResults = // any: evaluations values are EvolutionResult | {error} | extended LLM results
+                 Object.values(evaluations).filter(e => !e.error && e.certitude != null && e.ubiquity != null);
+                if (llmResults.length > 0) {
+                    // Average certitude/ubiquity from all LLM strategies that provided them
+                    enrichedComponent.certitude = Math.round(llmResults.reduce((s, r) => s + r.certitude, 0) / llmResults.length * 1000) / 1000;
+                    enrichedComponent.ubiquity = Math.round(llmResults.reduce((s, r) => s + r.ubiquity, 0) / llmResults.length * 1000) / 1000;
+                    logDebug(TOOL, `Enriched "${name}" from ${llmResults.length} LLM result(s): certitude=${enrichedComponent.certitude}, ubiquity=${enrichedComponent.ubiquity}`);
+                }
+            }
+            // Phase C: Run s-curve with enriched component
+            const scurveCls = strategies.get('write:capacity:s-curve');
+            if (scurveCls) {
+                try {
+                    logDebug(TOOL, msg('step.strategy', { strategy: 'write:capacity:s-curve', component: name }));
+                    const instance = createStrategyInstance(scurveCls);
+                    const result = await Promise.resolve(instance.evaluate(enrichedComponent));
+                    evaluations['write:capacity:s-curve'] = result;
+                    logDebug(TOOL, msg('step.strategy.result', { strategy: 'write:capacity:s-curve', evolution: result.evolution, confidence: result.confidence }));
+                }
+                catch (err) {
+                    evaluations['write:capacity:s-curve'] = { error: toErrorMessage(err) };
+                    logDebug(TOOL, msg('step.strategy.error', { strategy: 'write:capacity:s-curve', error: toErrorMessage(err) }));
+                }
+            }
+        }
+        else {
+            try {
+                logDebug(TOOL, msg('step.strategy', { strategy, component: name }));
+                const StrategyCls = await getStrategy(strategy);
+                const instance = createStrategyInstance(StrategyCls);
+                const result = await Promise.resolve(instance.evaluate(component));
+                evaluations[strategy] = result;
+                logDebug(TOOL, msg('step.strategy.result', { strategy, evolution: result.evolution, confidence: result.confidence }));
+            }
+            catch (err) {
+                evaluations[strategy] = { error: toErrorMessage(err) };
+                logDebug(TOOL, msg('step.strategy.error', { strategy, error: toErrorMessage(err) }));
+            }
+        }
+    }
+    // Step 5b: Run solution strategies if routed
+    if (routingTargets.useSolutionStrategies) {
+        logDebug(TOOL, `Dispatching "${name}" to solution strategies`);
+        try {
+            const solutionEvals = await dispatchSolutionStrategies(component, {
+                llmCall: getStrategyLLM('properties-strategy'),
+                strategy: strategy === 'all' ? 'all' : strategy,
+                mode: 'auto',
+            });
+            // Merge solution evaluations (prefix to avoid key collisions)
+            for (const [method, result] of Object.entries(solutionEvals)) {
+                const key = evaluations[method] ? `solution:${method}` : method;
+                evaluations[key] = result;
+            }
+        }
+        catch (err) {
+            evaluations['solution-dispatch-error'] = { error: toErrorMessage(err) };
+            logDebug(TOOL, `Solution strategy dispatch failed: ${toErrorMessage(err)}`);
+        }
+    }
+    // Step 6: Format result
+    const successCount = // any: evaluations values are EvolutionResult | {error} | extended LLM results
+     Object.values(evaluations).filter(e => !e.error).length;
+    const errorCount = // any: evaluations values are EvolutionResult | {error} | extended LLM results
+     Object.values(evaluations).filter(e => e.error).length;
+    const duration = Date.now() - t0;
+    logDebug(TOOL, `Results for "${name}": ${successCount} succeeded, ${errorCount} failed out of ${Object.keys(evaluations).length} strategies`);
+    // Info-level: tool end (localized)
+    logInfo(TOOL, msg('tool.end', { tool: TOOL, component: name, duration }));
+    // Build routing metadata — use verified detection if available, else naming-only
+    // effectiveType already computed above when we posed component.kind
+    const effectiveConfidence = verifiedDetection ? verifiedDetection.confidence : detection.confidence;
+    const effectiveMethod = verifiedDetection ? verifiedDetection.method : detection.method;
+    // Classify Wardley component type (activity/practice/data/knowledge) — informative metadata only
+    const wardleyTypeResult = classifyWardleyType(name, {
+        description,
+        nature: detection.nature,
+        category: detection.category,
+    });
+    logDebug(TOOL, `Wardley type for "${name}": ${wardleyTypeResult.wardleyType} (confidence=${wardleyTypeResult.confidence}, ${wardleyTypeResult.reason})`);
+    let message = `Component "${name}" classified as ${classification.space}`;
+    if (effectiveType === COMPONENT_TYPE.SOLUTION) {
+        message += ` (detected as solution, confidence=${effectiveConfidence})`;
+    }
+    message += `. Evaluated with ${successCount} strategy(ies)`;
+    if (errorCount > 0) {
+        message += ` (${errorCount} strategy(ies) returned errors)`;
+    }
+    message += '.';
+    // any: RoutedResponse-like shape with optional pipeline extension fields
+    const standardResult = {
+        mode: 'oneshot',
+        classification,
+        reQuestions: null,
+        evaluations,
+        routing: {
+            type: effectiveType,
+            confidence: effectiveConfidence,
+            method: effectiveMethod,
+            evalMode: routingTargets.mode,
+            usedSolutionStrategies: routingTargets.useSolutionStrategies,
+            usedCapabilityStrategies: routingTargets.useCapabilityStrategies,
+            ...(verifiedDetection && {
+                verified: verifiedDetection.verified,
+                tiersUsed: verifiedDetection.tiersUsed,
+            }),
+        },
+        wardleyType: {
+            type: wardleyTypeResult.wardleyType,
+            confidence: wardleyTypeResult.confidence,
+            reason: wardleyTypeResult.reason,
+        },
+        message,
+    };
+    // ── Pipeline enrichment: when pipeline=true, orchestrate the 3-step evaluation
+    if (pipeline) {
+        logDebug(TOOL, `Pipeline mode enabled for "${name}" — running enriched pipeline`);
+        // Provide a capability evaluation function that re-uses estimateEvolutionOneShot
+        // but forces capability path (no pipeline recursion)
+        const evaluateCapabilityFn = (capInput) => // any: capability-only input variant
+         estimateEvolutionOneShot({ ...capInput, pipeline: false });
+        const pipelineResult = await runEnrichedPipeline(standardResult, component, {
+            evaluateCapabilityFn,
+            llmCall: getStrategyLLM('pipeline-enrichment'),
+        });
+        logDebug(TOOL, `Pipeline complete for "${name}": capability evolution=${pipelineResult.capabilityPivot?.evolution}`);
+        return pipelineResult;
+    }
+    return standardResult;
+}
+/**
+ * Create a strategy instance with LLM dependencies injected.
+ *
+ * - s-curve: analytical only, no LLM
+ * - publication-analysis: enriched with LLM for deep research
+ * - timeline-benchmark: enriched with LLM for historical reasoning
+ * - llm-direct: requires LLM call
+ * - logprob-distribution: uses OpenCode/kimi for real logprobs
+ *
+ * @param {typeof BaseStrategy} StrategyCls
+ * @returns {BaseStrategy}
+ */
+// any: StrategyCls is a constructor (BaseStrategy subclass); instance shape varies
+function createStrategyInstance(StrategyCls) {
+    const method = StrategyCls.method;
+    // s-curve: purely analytical
+    if (method === 'write:capacity:s-curve') {
+        return new StrategyCls();
+    }
+    // Enriched analytical strategies: inject LLM for deeper analysis
+    if (method === 'write:capacity:publication-analysis' || method === 'write:capacity:timeline-benchmark') {
+        return new StrategyCls({ llmCall: getStrategyLLM(method) });
+    }
+    // LLM-required strategies: inject Agent SDK llmCall
+    if (method === 'write:capacity:llm-direct') {
+        return new StrategyCls({ llmCall: getStrategyLLM('llm-direct') });
+    }
+    // CPC evolution strategy: inject LLM for CPC mapper (patent source uses env vars)
+    if (method === 'write:capacity:cpc-evolution') {
+        return new StrategyCls({ llmCall: getStrategyLLM('cpc-evolution') });
+    }
+    // Logprob strategy: inject OpenCode/kimi logprob call
+    if (method === 'write:capacity:logprob-distribution') {
+        return new StrategyCls({ llmLogprobCall: getStrategyLogprobLLM('logprob-distribution') });
+    }
+    // Unknown strategy type — try default constructor
+    return new StrategyCls();
+}
+/**
+ * Evaluate a set of strategy entries against a component in parallel.
+ *
+ * Each strategy is independent (no cross-strategy state), so they run
+ * concurrently via `Promise.allSettled`. Input order is preserved in the
+ * output array, which lets callers zip the result back with their own
+ * per-strategy logging/i18n context.
+ *
+ * The degradation collector uses AsyncLocalStorage (see src/lib/degradation/
+ * context.mts) so each async branch inherits the caller's ambient context —
+ * per-strategy events do not bleed between concurrent frames.
+ *
+ * A strategy that throws produces `{ error }` for that slot; the other
+ * strategies are unaffected.
+ */
+// any: StrategyCtor is a constructor type with shifting `new (...args: any[])` signatures
+export async function evaluateStrategiesInParallel(entries, component) {
+    const settled = await Promise.allSettled(entries.map(async ([method, StrategyCls]) => {
+        const instance = createStrategyInstance(StrategyCls);
+        const result = await Promise.resolve(instance.evaluate(component));
+        return { method, result };
+    }));
+    return settled.map((r, i) => {
+        const [method] = entries[i];
+        if (r.status === 'fulfilled')
+            return { method, result: r.value.result };
+        return { method, result: null, error: toErrorMessage(r.reason) };
+    });
+}
+// ─── Conversational Mode ────────────────────────────────────────────────────
+/**
+ * @typedef {Object} ConversationalResult
+ * @property {'conversational'} mode
+ * @property {string} phase - Current conversation phase
+ * @property {import('../session/conversation-session.mjs').QuestionSet | null} nextQuestion
+ * @property {import('./routing/classification-gate.mjs').ClassificationResult | null} classification
+ * @property {string[] | null} reQuestions
+ * @property {Object<string, import('./strategies/capacity/base-strategy.mjs').EvolutionResult> | null} evaluations
+ * @property {Object} summary - Gathered/missing data summary
+ * @property {string} sessionState - Serialized session for persistence
+ * @property {string} message
+ */
+/**
+ * Start or continue a conversational evolution estimation session.
+ *
+ * This function handles multi-turn interaction:
+ *   - First call (no sessionState): creates a new session, returns first question
+ *   - Subsequent calls (with sessionState): updates session with new data, returns next question or result
+ *   - When enough context is gathered: runs evaluation and returns final result
+ *
+ * @param {Object} input - Exchange data
+ * @param {string} [input.sessionState] - Serialized session from previous exchange (null for first call)
+ * @param {Object} [input.data] - New data gathered in this exchange (key-value pairs)
+ * @param {boolean} [input.forceEstimate] - Force estimation with available data
+ * @param {string} [input.strategy] - Strategy to use (default: 'all')
+ * @returns {Promise<ConversationalResult>}
+ */
+// any: conversational input is the raw MCP arguments bag; result is a guided-turn shape
+export async function estimateEvolutionConversational(input = {}) {
+    const { sessionState, data = {}, forceEstimate = false, strategy } = input;
+    const TOOL = 'estimateEvolution';
+    // Create or restore session
+    let session;
+    if (sessionState) {
+        try {
+            session = ConversationSession.deserialize(sessionState);
+            logDebug(TOOL, `Session restored (phase: ${session.phase})`);
+        }
+        catch {
+            session = new ConversationSession();
+            logDebug(TOOL, 'Session deserialization failed — new session created');
+        }
+    }
+    else {
+        session = new ConversationSession();
+        logDebug(TOOL, 'New conversational session created');
+    }
+    // Apply strategy preference if provided
+    if (strategy) {
+        session.update({ strategy });
+        logDebug(TOOL, `Strategy preference set: "${strategy}"`);
+    }
+    // Update session with new data
+    if (data && Object.keys(data).length > 0) {
+        session.update(data);
+        logDebug(TOOL, `Session updated with ${Object.keys(data).length} field(s): ${Object.keys(data).join(', ')}`);
+    }
+    // Force estimation if requested
+    if (forceEstimate && !session.isReadyForEstimation()) {
+        session.forceReady();
+        logDebug(TOOL, 'Force estimation requested — session marked as ready');
+    }
+    // Check for non-economic classification (triggers re-questioning)
+    if (session.isReadyForEstimation() && session.isNonEconomic()) {
+        const classification = session.getClassification();
+        const reQuestions = session.getReQuestions();
+        // invariant: isNonEconomic() ⇒ classification was set
+        if (!classification) {
+            throw new Error('estimateEvolutionConversational: isNonEconomic() but no classification');
+        }
+        logDebug(TOOL, `Component "${session.state.name}" classified as ${classification.space} — re-questioning`);
+        return {
+            mode: 'conversational',
+            phase: 'complete',
+            nextQuestion: null,
+            classification,
+            reQuestions,
+            evaluations: null,
+            summary: session.getSummary(),
+            sessionState: session.serialize(),
+            message: `Component "${session.state.name}" classified as ${classification.space}. ` +
+                `Evolution evaluation is not applicable — the component is outside the economic space. ` +
+                `Please review the re-questioning prompts to reframe the component.`,
+        };
+    }
+    // If ready for estimation, run the strategies with routing
+    if (session.isReadyForEstimation()) {
+        const classification = session.getClassification();
+        const component = session.buildComponentInput();
+        const selectedStrategy = session.state.strategy || 'all';
+        const evaluations = {};
+        logDebug(TOOL, `Conversational estimation ready for "${session.state.name}", strategy="${selectedStrategy}"`);
+        // Route component to solution or capability strategies.
+        //
+        // The conversation session already detected the component type during the
+        // classification phase (stored in session.state.componentType). We reuse
+        // that detection here instead of re-running detectComponentType() — this
+        // ensures routing is consistent with the conversation branching the user
+        // experienced (solution_context vs characteristics/market_signals path).
+        //
+        // When the session detection confidence is below the 90% threshold,
+        // we still trigger the dual-verification fallback for higher accuracy.
+        let convDetection;
+        const sessionDetection = session.getComponentTypeDetection();
+        if (sessionDetection.type && (sessionDetection.confidence ?? 0) >= CONFIDENCE_THRESHOLD) {
+            // Session already has high-confidence detection — reuse it directly
+            convDetection = {
+                type: sessionDetection.type,
+                confidence: sessionDetection.confidence,
+                method: sessionDetection.method,
+                needsFallback: false,
+            };
+            logDebug(TOOL, `Reusing session detection for "${session.state.name}": type=${convDetection.type}, ` +
+                `confidence=${convDetection.confidence}, method=${convDetection.method} (no fallback needed)`);
+        }
+        else {
+            // Re-detect (session had low confidence or no detection)
+            convDetection = detectComponentType(session.state.name ?? '', session.state.description || '');
+            logDebug(TOOL, `Conversational routing "${session.state.name}": type=${convDetection.type}, ` +
+                `confidence=${convDetection.confidence}, needsFallback=${convDetection.needsFallback}`);
+        }
+        // any: convDetection has 'type' string from runtime, ComponentTypeDetection accepts string union via [key: string]
+        let convRoutingTargets = determineRoutingTargets(convDetection);
+        let convVerifiedDetection = null;
+        logDebug(TOOL, `Routing targets "${session.state.name}": ` +
+            `solution=${convRoutingTargets.useSolutionStrategies}, ` +
+            `capability=${convRoutingTargets.useCapabilityStrategies}, mode=${convRoutingTargets.mode}`);
+        // Fallback: when naming convention confidence < 90%, delegate to the
+        // dual-verification orchestrator (LLM + web search) for higher accuracy.
+        // Forwards component name plus partial classification context from session.
+        if (convDetection.needsFallback) {
+            logDebug(TOOL, `Naming confidence ${convDetection.confidence} < 0.90 for "${session.state.name}" — ` +
+                `triggering dual-verification fallback (conversational)`);
+            try {
+                const convPartialContext = {
+                    description: session.state.description || '',
+                    llmCall: getStrategyLLM('dual-verification'),
+                    ...(component.capability ? { capability: component.capability } : {}),
+                    ...(component.nature ? { nature: component.nature } : {}),
+                };
+                convVerifiedDetection = await verifyClassification(session.state.name ?? '', convPartialContext);
+                // Use verified result for routing (overrides naming-only detection)
+                convRoutingTargets = convVerifiedDetection.routingTargets;
+                logDebug(TOOL, `Dual-verification result for "${session.state.name}": type=${convVerifiedDetection.classification}, ` +
+                    `confidence=${convVerifiedDetection.confidence}, method=${convVerifiedDetection.method}, ` +
+                    `verified=${convVerifiedDetection.verified}, tiers=${convVerifiedDetection.tiersUsed.join('+')}`);
+            }
+            catch (err) {
+                logDebug(TOOL, `Dual-verification fallback failed for "${session.state.name}": ${toErrorMessage(err)} — ` +
+                    `using naming-only routing`);
+            }
+        }
+        logDebug(TOOL, `Final conversational routing "${session.state.name}": ` +
+            `solution=${convRoutingTargets.useSolutionStrategies}, capability=${convRoutingTargets.useCapabilityStrategies}`);
+        // Run capability strategies if routed
+        if (convRoutingTargets.useCapabilityStrategies) {
+            if (selectedStrategy === 'all') {
+                const strategies = await loadStrategies();
+                const strategyEntries = [...strategies];
+                const strategyNames = strategyEntries.map(([m]) => m);
+                logDebug(TOOL, `Running ${strategyNames.length} capability strategies: ${strategyNames.join(', ')}`);
+                for (const method of strategyNames) {
+                    logDebug(TOOL, `Running strategy "${method}" on "${session.state.name}"...`);
+                }
+                const outcomes = await evaluateStrategiesInParallel(strategyEntries, component);
+                for (const { method, result, error } of outcomes) {
+                    if (error == null) {
+                        evaluations[method] = result;
+                        logDebug(TOOL, `Strategy "${method}": evolution=${result.evolution}, confidence=${result.confidence}`);
+                    }
+                    else {
+                        evaluations[method] = { error };
+                        logDebug(TOOL, `Strategy "${method}" failed: ${error}`);
+                    }
+                }
+            }
+            else {
+                try {
+                    logDebug(TOOL, `Running single strategy "${selectedStrategy}" on "${session.state.name}"...`);
+                    const StrategyCls = await getStrategy(selectedStrategy);
+                    const instance = createStrategyInstance(StrategyCls);
+                    const result = await Promise.resolve(instance.evaluate(component));
+                    evaluations[selectedStrategy] = result;
+                    logDebug(TOOL, `Strategy "${selectedStrategy}": evolution=${result.evolution}, confidence=${result.confidence}`);
+                }
+                catch (err) {
+                    evaluations[selectedStrategy] = { error: toErrorMessage(err) };
+                    logDebug(TOOL, `Strategy "${selectedStrategy}" failed: ${toErrorMessage(err)}`);
+                }
+            }
+        }
+        // Run solution strategies if routed
+        if (convRoutingTargets.useSolutionStrategies) {
+            logDebug(TOOL, `Dispatching "${session.state.name}" to solution strategies (conversational)`);
+            try {
+                const solutionEvals = await dispatchSolutionStrategies(component, {
+                    llmCall: getStrategyLLM('properties-strategy'),
+                    strategy: selectedStrategy === 'all' ? 'all' : selectedStrategy,
+                    mode: 'conversational',
+                });
+                for (const [method, result] of Object.entries(solutionEvals)) {
+                    const key = evaluations[method] ? `solution:${method}` : method;
+                    evaluations[key] = result;
+                }
+            }
+            catch (err) {
+                evaluations['solution-dispatch-error'] = { error: toErrorMessage(err) };
+                logDebug(TOOL, `Solution strategy dispatch failed: ${toErrorMessage(err)}`);
+            }
+        }
+        const successCount = // any: evaluations values are EvolutionResult | {error} | extended LLM results
+         Object.values(evaluations).filter(e => !e.error).length;
+        const errorCount = // any: evaluations values are EvolutionResult | {error} | extended LLM results
+         Object.values(evaluations).filter(e => e.error).length;
+        const summary = session.getSummary();
+        logDebug(TOOL, `Conversational results for "${session.state.name}": ${successCount} succeeded, ${errorCount} failed, ${summary.exchangeCount} exchange(s)`);
+        // Build routing metadata — use verified detection if available
+        const convEffectiveType = convVerifiedDetection ? convVerifiedDetection.classification : convDetection.type;
+        const convEffectiveConfidence = convVerifiedDetection ? convVerifiedDetection.confidence : convDetection.confidence;
+        const convEffectiveMethod = convVerifiedDetection ? convVerifiedDetection.method : convDetection.method;
+        let message = `Component "${session.state.name}" — conversational estimation complete after ${summary.exchangeCount} exchange(s)`;
+        if (convEffectiveType === COMPONENT_TYPE.SOLUTION) {
+            message += ` (detected as solution, confidence=${convEffectiveConfidence})`;
+        }
+        message += `. Evaluated with ${successCount} strategy(ies)`;
+        if (errorCount > 0) {
+            message += ` (${errorCount} returned errors)`;
+        }
+        message += '.';
+        // Classify Wardley component type (activity/practice/data/knowledge) — informative metadata
+        const convWardleyType = classifyWardleyType(session.state.name ?? '', {
+            description: session.state.description || '',
+            nature: convDetection.nature,
+            category: convDetection.category,
+        });
+        logDebug(TOOL, `Wardley type for "${session.state.name}": ${convWardleyType.wardleyType} (${convWardleyType.reason})`);
+        return {
+            mode: 'conversational',
+            phase: 'complete',
+            nextQuestion: null,
+            classification,
+            reQuestions: null,
+            evaluations,
+            routing: {
+                type: convEffectiveType,
+                confidence: convEffectiveConfidence,
+                method: convEffectiveMethod,
+                evalMode: convRoutingTargets.mode,
+                usedSolutionStrategies: convRoutingTargets.useSolutionStrategies,
+                usedCapabilityStrategies: convRoutingTargets.useCapabilityStrategies,
+                ...(convVerifiedDetection && {
+                    verified: convVerifiedDetection.verified,
+                    tiersUsed: convVerifiedDetection.tiersUsed,
+                }),
+            },
+            wardleyType: {
+                type: convWardleyType.wardleyType,
+                confidence: convWardleyType.confidence,
+                reason: convWardleyType.reason,
+            },
+            summary,
+            sessionState: session.serialize(),
+            message,
+        };
+    }
+    // Not ready yet — return the next question
+    const nextQuestion = session.nextQuestion();
+    const summary = session.getSummary();
+    logDebug(TOOL, `Conversational phase "${session.phase}": ${summary.missing.length} field(s) still missing, gathered=${summary.gathered.length}`);
+    return {
+        mode: 'conversational',
+        phase: session.phase,
+        nextQuestion,
+        classification: session.getClassification(),
+        reQuestions: null,
+        evaluations: null,
+        summary,
+        sessionState: session.serialize(),
+        message: `Gathering information for evolution estimation (phase: ${session.phase}). ` +
+            `${summary.missing.length} field(s) still available to gather. ` +
+            `You can provide more data or use forceEstimate to proceed with what's available.`,
+    };
+}
+// ─── Re-export ConversationSession for external use ─────────────────────────
+export { ConversationSession };
+// ─── Convenience: list available strategies ──────────────────────────────────
+export { listStrategies };
+//# sourceMappingURL=estimate-evolution.mjs.map