labre-mcp 0.1.0

package/dist/work-on-evolution/pipeline/dual-verification-orchestrator.mjs

@@ -0,0 +1,288 @@
+// Dual-verification orchestrator for solution vs capability classification
+//
+// Accepts a component name and partial classification context, then runs a
+// multi-tier verification pipeline to determine whether the component is a
+// concrete SOLUTION (Kubernetes, Salesforce...) or an abstract CAPABILITY
+// (container orchestration, CRM...).
+//
+// Pipeline (ordered by cost, short-circuits when confident):
+//   Tier 1: Naming convention heuristics     (free, sub-ms)
+//           → If confidence >= 90%, return immediately
+//   Tier 2: LLM semantic classification      (moderate cost)
+//           → Invoked when naming confidence < 90% and llmCall available
+//   Tier 3: Web search evidence              (higher cost, highest accuracy)
+//           → Invoked when LLM does not resolve above threshold
+//   Tier 4: Reconciliation                   (combine all available signals)
+//
+// The result includes the verified classification plus the raw tier results
+// for traceability. It also carries the ComponentTypeDetection from the
+// existing solution-capability-router so downstream routing can use it
+// without re-computing.
+//
+// This module does NOT modify any existing strategy files or the capability
+// evaluation pipeline. It sits AFTER the classification gate and BEFORE
+// strategy dispatch — called by estimate-evolution.mjs as a replacement for
+// the direct detectComponentType() call when dual verification is desired.
+//
+// Usage:
+//   import { verifyClassification } from './dual-verification-orchestrator.mjs';
+//
+//   const result = await verifyClassification('Kubernetes', {
+//     description: 'Container platform for microservices',
+//     llmCall: myLlmCall,
+//   });
+//   // → { classification: 'solution', confidence: 0.98, verified: true, ... }
+import { detectComponentType, COMPONENT_TYPE, CONFIDENCE_THRESHOLD, } from '../../lib/component-detection.mjs';
+import { classifySolutionLLM } from '../routing/detect-solution.mjs';
+import { verifyViaWebSearch, combineWithPriorResult } from '../routing/web-search-verification.mjs';
+import { logDebug } from '../../lib/mcp-notifications.mjs';
+import { raceWithTimeout, buildSuccessSignal, buildTimeoutSignal, buildErrorSignal, buildSkippedSignal, } from './verification-signals.mjs';
+import { toIntermediateResult, reconcileTwoTiers, reconcileSignalPair, buildResult, } from './verification-reconciliation.mjs';
+// ─── Constants ────────────────────────────────────────────────────────────────
+const TOOL = 'dual-verification';
+/**
+ * Confidence thresholds for each tier transition.
+ *
+ * - NAMING_SKIP: If naming convention confidence >= this, skip LLM tier.
+ *   Reuses the CONFIDENCE_THRESHOLD from solution-capability-router (0.90).
+ * - LLM_SKIP: If combined naming+LLM confidence >= this, skip web search tier.
+ * - MIN_VERIFIED: Minimum confidence to consider the classification "verified".
+ */
+export const THRESHOLDS = {
+    NAMING_SKIP: CONFIDENCE_THRESHOLD, // 0.90
+    LLM_SKIP: 0.85,
+    MIN_VERIFIED: 0.70,
+};
+// ─── Type Definitions ────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} ClassificationContext
+ * @property {string}  [description]    - Business/usage context for the component
+ * @property {string}  [type]           - OWM DSL type hint (component, pipeline, anchor, etc.)
+ * @property {string}  [capability]     - Already-identified underlying capability (if any)
+ * @property {string}  [nature]         - Already-identified capability nature (if any)
+ * @property {function(string): Promise<string>} [llmCall]
+ *   LLM call function for Tier 2 fallback (from llm-call.mjs).
+ *   If not provided, the pipeline stops after Tier 1 naming convention.
+ * @property {function(string): Promise<string>} [webSearchCall]
+ *   Web search call function for Tier 3 evidence (from web-search-verification.mjs).
+ *   If not provided, the pipeline stops after Tier 2 LLM.
+ * @property {boolean} [skipLLM=false]  - Force-skip the LLM tier (e.g. for cost control)
+ * @property {boolean} [skipWebSearch=false] - Force-skip the web search tier
+ */
+/**
+ * @typedef {Object} VerifiedClassificationResult
+ * @property {'solution'|'capability'} classification - Verified component type
+ * @property {number}  confidence      - Final confidence score (0-1)
+ * @property {string}  method          - Detection method chain used:
+ *   'naming' | 'naming+llm' | 'naming+web-search' | 'naming+llm+web-search'
+ * @property {string}  reasoning       - Human-readable explanation of the final classification
+ * @property {boolean} isSolution      - Convenience flag: classification === 'solution'
+ * @property {boolean} verified        - true if at least two tiers agreed or a single tier had >= 90% confidence
+ * @property {string[]} tiersUsed      - Which tiers were actually invoked: ['naming'], ['naming', 'llm'], etc.
+ * @property {import('../routing/solution-capability-router.mjs').ComponentTypeDetection} routingDetection
+ *   - Full detection result from Tier 1 (solution-capability-router), preserved for downstream routing
+ * @property {{ useSolutionStrategies: boolean, useCapabilityStrategies: boolean, mode: string }} routingTargets
+ *   - Pre-computed routing targets based on the verified classification
+ * @property {Object}  [namingResult]  - Raw result from Tier 1 naming convention
+ * @property {Object}  [llmResult]     - Raw result from Tier 2 LLM (if invoked)
+ * @property {Object}  [webSearchResult] - Raw result from Tier 3 web search (if invoked)
+ */
+// ─── Core Orchestrator ──────────────────────────────────────────────────────
+/**
+ * Dual-verification orchestrator: classify a component as solution or capability
+ * using a multi-tier verification pipeline.
+ *
+ * The pipeline short-circuits at the earliest tier that produces a high-confidence
+ * result, minimizing cost. Each subsequent tier adds evidence to increase
+ * confidence or resolve ambiguity.
+ *
+ * Verification logic:
+ *   - Tier 1 alone at >= 90% confidence → verified = true (dictionary match)
+ *   - Tier 1 + Tier 2 agree → verified = true (boosted confidence)
+ *   - Tier 1 + Tier 2 disagree → Tier 3 invoked as tiebreaker (if available)
+ *   - Any final confidence >= MIN_VERIFIED (0.70) → verified = true
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {ClassificationContext} [context={}] - Partial classification context
+ * @returns {Promise<VerifiedClassificationResult>} Verified classification result
+ */
+// any: context bag (description, llmCall, webSearchCall, timeoutMs, etc.) — heterogeneous result shape
+export async function verifyClassification(componentName, context = {}) {
+    const name = (componentName || '').trim();
+    if (!name) {
+        return buildResult({
+            classification: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'error',
+            reasoning: 'Empty or invalid component name',
+            verified: false,
+            tiersUsed: [],
+            routingDetection: detectComponentType('', ''),
+        });
+    }
+    const description = context.description || '';
+    // ── Tier 1: Naming convention heuristics ─────────────────────────────────
+    logDebug(TOOL, `Tier 1 (naming) for "${name}"...`);
+    const namingResult = detectComponentType(name, description);
+    const tiersUsed = ['naming'];
+    logDebug(TOOL, `Tier 1 result: type=${namingResult.type}, confidence=${namingResult.confidence}, ` +
+        `method=${namingResult.method}, needsFallback=${namingResult.needsFallback}`);
+    // Short-circuit: high-confidence naming match → no further verification needed
+    if (namingResult.confidence >= THRESHOLDS.NAMING_SKIP) {
+        logDebug(TOOL, `Tier 1 sufficient (confidence=${namingResult.confidence} >= ${THRESHOLDS.NAMING_SKIP}) — skipping LLM/web`);
+        return buildResult({
+            classification: namingResult.type,
+            confidence: namingResult.confidence,
+            method: 'naming',
+            reasoning: namingResult.reason,
+            verified: true,
+            tiersUsed,
+            routingDetection: namingResult,
+            namingResult,
+        });
+    }
+    // ── Tier 2: LLM semantic classification ──────────────────────────────────
+    let llmResult = null;
+    let currentBest = toIntermediateResult(namingResult);
+    const canUseLLM = !context.skipLLM && typeof context.llmCall === 'function';
+    if (canUseLLM) {
+        logDebug(TOOL, `Tier 2 (LLM) for "${name}" (naming confidence=${namingResult.confidence} < ${THRESHOLDS.NAMING_SKIP})...`);
+        tiersUsed.push('llm');
+        try {
+            llmResult = await classifySolutionLLM(name, context.llmCall, {
+                context: description,
+            });
+            logDebug(TOOL, `Tier 2 result: ${llmResult.classification} (confidence=${llmResult.confidence})`);
+            // Reconcile naming + LLM
+            currentBest = reconcileTwoTiers(currentBest, {
+                classification: llmResult.classification,
+                confidence: llmResult.confidence,
+                method: 'llm',
+                reasoning: llmResult.reasoning,
+            });
+            logDebug(TOOL, `After reconciliation: ${currentBest.classification} (confidence=${currentBest.confidence})`);
+            // Short-circuit: if combined result is above LLM_SKIP threshold, stop
+            if (currentBest.confidence >= THRESHOLDS.LLM_SKIP) {
+                logDebug(TOOL, `Tier 1+2 sufficient (confidence=${currentBest.confidence} >= ${THRESHOLDS.LLM_SKIP}) — skipping web search`);
+                return buildResult({
+                    ...currentBest,
+                    method: 'naming+llm',
+                    verified: currentBest.confidence >= THRESHOLDS.MIN_VERIFIED,
+                    tiersUsed,
+                    routingDetection: namingResult,
+                    namingResult,
+                    llmResult,
+                });
+            }
+        }
+        catch (err) {
+            logDebug(TOOL, `Tier 2 (LLM) failed for "${name}": ${toErrorMessage(err)}`);
+            llmResult = { error: toErrorMessage(err) };
+        }
+    }
+    else {
+        logDebug(TOOL, `Tier 2 (LLM) skipped: ${context.skipLLM ? 'forced skip' : 'no llmCall provided'}`);
+    }
+    // ── Tier 3: Web search evidence ──────────────────────────────────────────
+    let webSearchResult = null;
+    const canUseWebSearch = !context.skipWebSearch &&
+        (typeof context.webSearchCall === 'function' || canUseLLM);
+    if (canUseWebSearch && currentBest.confidence < THRESHOLDS.LLM_SKIP) {
+        logDebug(TOOL, `Tier 3 (web search) for "${name}" (combined confidence=${currentBest.confidence} < ${THRESHOLDS.LLM_SKIP})...`);
+        tiersUsed.push('web-search');
+        try {
+            // any: web search options (Claude Agent SDK loose shape)
+            const webSearchOptions = {};
+            if (typeof context.webSearchCall === 'function') {
+                webSearchOptions.webSearchCall = context.webSearchCall;
+            }
+            if (description) {
+                webSearchOptions.context = description;
+            }
+            webSearchResult = await verifyViaWebSearch(name, webSearchOptions);
+            logDebug(TOOL, `Tier 3 result: ${webSearchResult.classification} (confidence=${webSearchResult.confidence})`);
+            // Combine web search with current best using the existing combiner
+            const combined = combineWithPriorResult(currentBest, webSearchResult);
+            currentBest = {
+                classification: combined.classification,
+                confidence: combined.confidence,
+                method: combined.method,
+                reasoning: combined.reasoning,
+            };
+            logDebug(TOOL, `After web search reconciliation: ${currentBest.classification} (confidence=${currentBest.confidence})`);
+        }
+        catch (err) {
+            logDebug(TOOL, `Tier 3 (web search) failed for "${name}": ${toErrorMessage(err)}`);
+            webSearchResult = { error: toErrorMessage(err) };
+        }
+    }
+    else {
+        logDebug(TOOL, `Tier 3 (web search) skipped: ${context.skipWebSearch ? 'forced skip' : currentBest.confidence >= THRESHOLDS.LLM_SKIP ? 'confidence sufficient' : 'no search backend'}`);
+    }
+    // ── Final result ─────────────────────────────────────────────────────────
+    const methodChain = tiersUsed.join('+');
+    return buildResult({
+        classification: currentBest.classification,
+        confidence: currentBest.confidence,
+        method: methodChain || currentBest.method,
+        reasoning: currentBest.reasoning,
+        verified: currentBest.confidence >= THRESHOLDS.MIN_VERIFIED,
+        tiersUsed,
+        routingDetection: namingResult,
+        namingResult,
+        llmResult,
+        webSearchResult,
+    });
+}
+// ─── Reconciliation Helpers ─────────────────────────────────────────────────
+// toIntermediateResult, reconcileTwoTiers, buildResult — imported from ./verification-reconciliation.mjs
+// ─── Concurrent Dual-Verification ───────────────────────────────────────────
+// Extracted to ./concurrent-verification.mjs for single-responsibility.
+// Re-exported here for backward compatibility.
+import { verifyConcurrent, verifyConcurrentFull, DEFAULT_SIGNAL_TIMEOUT_MS, } from './concurrent-verification.mjs';
+import { toErrorMessage } from '../../lib/errors.mjs';
+export { verifyConcurrent, verifyConcurrentFull };
+// ─── Convenience: classify without fallback ─────────────────────────────────
+/**
+ * Quick classification using only Tier 1 naming convention (no LLM, no web search).
+ *
+ * This is a thin wrapper around detectComponentType() that returns the same
+ * VerifiedClassificationResult shape for API consistency.
+ *
+ * Useful for hot paths where cost must be zero and the caller can tolerate
+ * lower confidence on unknown components.
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {string} [description] - Optional business context
+ * @returns {VerifiedClassificationResult}
+ */
+export function classifyNamingOnly(componentName, description = '') {
+    const name = (componentName || '').trim();
+    const namingResult = detectComponentType(name, description);
+    return buildResult({
+        classification: namingResult.type,
+        confidence: namingResult.confidence,
+        method: 'naming',
+        reasoning: namingResult.reason,
+        verified: namingResult.confidence >= THRESHOLDS.NAMING_SKIP,
+        tiersUsed: ['naming'],
+        routingDetection: namingResult,
+        namingResult,
+    });
+}
+// ─── Re-exports for consumer convenience ────────────────────────────────────
+export { COMPONENT_TYPE, CONFIDENCE_THRESHOLD };
+/**
+ * Exported for testing: signal builders and reconciliation.
+ * These are implementation details exposed to enable thorough unit testing.
+ */
+export const _internal = {
+    buildSuccessSignal,
+    buildTimeoutSignal,
+    buildErrorSignal,
+    buildSkippedSignal,
+    reconcileSignalPair,
+    raceWithTimeout,
+    DEFAULT_SIGNAL_TIMEOUT_MS,
+};
+//# sourceMappingURL=dual-verification-orchestrator.mjs.map

package/dist/work-on-evolution/pipeline/dual-verification-orchestrator.mjs.map

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

package/dist/work-on-evolution/pipeline/pipeline-capability-inference.d.mts

@@ -0,0 +1,45 @@
+/**
+ * @typedef {Object} PipelineCapabilityInferenceResult
+ * @property {string}  solutionName    - Original solution name input
+ * @property {string}  capability      - Inferred capability (nature-formatted, e.g. "Orchestrate containers")
+ * @property {string}  capabilityLabel - Clean label for OWM display (e.g. "Container Orchestration")
+ * @property {string}  nature          - Wardley component nature: activity | practice | knowledge | data
+ * @property {string}  wardleyType     - Component type: component | pipeline | anchor | market | ecosystem
+ * @property {number}  confidence      - Confidence in the inference (0–1)
+ * @property {string}  justification   - LLM reasoning for the inference
+ * @property {boolean} inferred        - Always true — marks this as an LLM inference result
+ */
+/**
+ * Convert a nature-formatted capability string into a clean display label
+ * suitable for OWM component names.
+ *
+ * Transformations by nature:
+ *   - activity: "Orchestrate containers" → "Container Orchestration"
+ *     (removes leading verb, nominalizes)
+ *   - practice: "how to manage IT services" → "IT Service Management"
+ *     (removes "how to", nominalizes)
+ *   - knowledge: "technical expertise in welding" → "Welding Expertise"
+ *   - data: kept as-is with title case
+ *
+ * Falls back to title-casing the raw capability if transformation fails.
+ *
+ * @param {string} capability - Nature-formatted capability string
+ * @param {string} nature     - Component nature (activity/practice/knowledge/data)
+ * @returns {string} Clean label for OWM display
+ */
+export declare function capabilityToLabel(capability: string, nature?: string): string;
+/**
+ * Infer the underlying capability from a solution name using the Tier 2 LLM.
+ *
+ * This is the core function for pipeline mode's first step: given a named
+ * solution (product, framework, methodology, standard), determine the generic
+ * capability it addresses.
+ *
+ * @param {string} solutionName - The solution name (e.g. "Kubernetes", "Scrum", "ISO 27001")
+ * @param {Object} options
+ * @param {string}   [options.description] - Additional context about the solution
+ * @param {function} options.llmCall       - LLM call function (from llm-call.mjs)
+ * @returns {Promise<PipelineCapabilityInferenceResult>}
+ */
+export declare function inferCapabilityFromSolution(solutionName: string, options?: any): Promise<any>;
+//# sourceMappingURL=pipeline-capability-inference.d.mts.map

package/dist/work-on-evolution/pipeline/pipeline-capability-inference.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-capability-inference.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/pipeline/pipeline-capability-inference.mts"],"names":[],"mappings":"AA2CA;;;;;;;;;;GAUG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CA+E7E;AAkBD;;;;;;;;;;;;GAYG;AAEH,wBAAsB,2BAA2B,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CA0CvG"}

package/dist/work-on-evolution/pipeline/pipeline-capability-inference.mjs

@@ -0,0 +1,206 @@
+// Pipeline capability inference — deduces the underlying capability from a solution name.
+//
+// When the pipeline enrichment mode (pipeline: true) receives a solution input
+// (e.g. "Kubernetes", "Scrum", "ISO 27001"), this module uses the Tier 2 LLM
+// (via the existing identifyCapability function) to determine the generic
+// capability that the solution addresses.
+//
+// The result is a structured intermediate object used by the pipeline orchestrator
+// to run the 3-evaluation sequence:
+//   1. Capability pivot (the inferred capability)
+//   2. Solution SotA (state-of-the-art solution in the same capability space)
+//   3. Solution legacy (an older/less-evolved solution)
+//
+// This module does NOT add latency to the default routing path — it is only
+// invoked when pipeline: true is explicitly requested.
+//
+// Usage:
+//   import { inferCapabilityFromSolution } from './pipeline-capability-inference.mjs';
+//
+//   const result = await inferCapabilityFromSolution('Kubernetes', {
+//     description: 'Container orchestration platform',
+//     llmCall,
+//   });
+//   // → {
+//   //   solutionName: 'Kubernetes',
+//   //   capability: 'Orchestrate containers',
+//   //   capabilityLabel: 'Container Orchestration',
+//   //   nature: 'activity',
+//   //   wardleyType: 'component',
+//   //   confidence: 0.92,
+//   //   justification: '...',
+//   // }
+import { identifyCapability } from '../../work-on-value-chain/identify-capability.mjs';
+import { logDebug } from '../../lib/mcp-notifications.mjs';
+// ─── Constants ────────────────────────────────────────────────────────────────
+const TOOL = 'pipelineCapabilityInference';
+// ─── Result Type ──────────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} PipelineCapabilityInferenceResult
+ * @property {string}  solutionName    - Original solution name input
+ * @property {string}  capability      - Inferred capability (nature-formatted, e.g. "Orchestrate containers")
+ * @property {string}  capabilityLabel - Clean label for OWM display (e.g. "Container Orchestration")
+ * @property {string}  nature          - Wardley component nature: activity | practice | knowledge | data
+ * @property {string}  wardleyType     - Component type: component | pipeline | anchor | market | ecosystem
+ * @property {number}  confidence      - Confidence in the inference (0–1)
+ * @property {string}  justification   - LLM reasoning for the inference
+ * @property {boolean} inferred        - Always true — marks this as an LLM inference result
+ */
+// ─── Capability Label Normalization ──────────────────────────────────────────
+/**
+ * Convert a nature-formatted capability string into a clean display label
+ * suitable for OWM component names.
+ *
+ * Transformations by nature:
+ *   - activity: "Orchestrate containers" → "Container Orchestration"
+ *     (removes leading verb, nominalizes)
+ *   - practice: "how to manage IT services" → "IT Service Management"
+ *     (removes "how to", nominalizes)
+ *   - knowledge: "technical expertise in welding" → "Welding Expertise"
+ *   - data: kept as-is with title case
+ *
+ * Falls back to title-casing the raw capability if transformation fails.
+ *
+ * @param {string} capability - Nature-formatted capability string
+ * @param {string} nature     - Component nature (activity/practice/knowledge/data)
+ * @returns {string} Clean label for OWM display
+ */
+export function capabilityToLabel(capability, nature) {
+    if (!capability)
+        return 'Capability';
+    const trimmed = capability.trim();
+    try {
+        switch (nature) {
+            case 'activity': {
+                // "Orchestrate containers" → "Container Orchestration"
+                // "Manage customer relationships" → "Customer Relationship Management"
+                // Remove leading infinitive verb, nominalize the rest
+                const verbMatch = trimmed.match(/^(manage|orchestrate|automate|process|handle|deliver|provide|build|create|monitor|analyze|store|compute|deploy|serve|route|transform|integrate|authenticate|authorize|brew|develop|test|maintain|secure|encrypt|optimize|schedule|balance|discover|log|cache|message|stream|search|index|render)\s+(.+)$/i);
+                if (verbMatch) {
+                    const verb = verbMatch[1].toLowerCase();
+                    const object = verbMatch[2].trim();
+                    // Nominalize: verb → noun form
+                    const nominalizations = {
+                        manage: 'Management', orchestrate: 'Orchestration',
+                        automate: 'Automation', process: 'Processing',
+                        handle: 'Handling', deliver: 'Delivery',
+                        provide: 'Provisioning', build: 'Building',
+                        create: 'Creation', monitor: 'Monitoring',
+                        analyze: 'Analytics', store: 'Storage',
+                        compute: 'Computing', deploy: 'Deployment',
+                        serve: 'Serving', route: 'Routing',
+                        transform: 'Transformation', integrate: 'Integration',
+                        authenticate: 'Authentication', authorize: 'Authorization',
+                        brew: 'Brewing', develop: 'Development',
+                        test: 'Testing', maintain: 'Maintenance',
+                        secure: 'Security', encrypt: 'Encryption',
+                        optimize: 'Optimization', schedule: 'Scheduling',
+                        balance: 'Balancing', discover: 'Discovery',
+                        log: 'Logging', cache: 'Caching',
+                        message: 'Messaging', stream: 'Streaming',
+                        search: 'Search', index: 'Indexing',
+                        render: 'Rendering',
+                    };
+                    const nounForm = nominalizations[verb] || (verb.charAt(0).toUpperCase() + verb.slice(1) + 'ing');
+                    // Title-case the object and append nominalization
+                    const objectTitled = titleCase(object);
+                    return `${objectTitled} ${nounForm}`;
+                }
+                // No verb detected — title case
+                return titleCase(trimmed);
+            }
+            case 'practice': {
+                // "how to manage IT services" → "IT Service Management"
+                const howToMatch = trimmed.match(/^how\s+to\s+(.+)$/i);
+                if (howToMatch) {
+                    // Recursively process as activity
+                    return capabilityToLabel(howToMatch[1], 'activity');
+                }
+                return titleCase(trimmed);
+            }
+            case 'knowledge': {
+                // "technical expertise in welding" → "Welding Expertise"
+                // "interpersonal skills for coaching" → "Coaching Skills"
+                const expertiseMatch = trimmed.match(/(?:technical\s+)?expertise\s+(?:in|for|on)\s+(.+)/i);
+                if (expertiseMatch) {
+                    return `${titleCase(expertiseMatch[1])} Expertise`;
+                }
+                const skillsMatch = trimmed.match(/(?:interpersonal\s+)?skills\s+(?:in|for|on)\s+(.+)/i);
+                if (skillsMatch) {
+                    return `${titleCase(skillsMatch[1])} Skills`;
+                }
+                return titleCase(trimmed);
+            }
+            case 'data':
+            default:
+                return titleCase(trimmed);
+        }
+    }
+    catch {
+        return titleCase(trimmed);
+    }
+}
+/**
+ * Title-case a string: capitalize first letter of each word.
+ * @param {string} str
+ * @returns {string}
+ */
+function titleCase(str) {
+    // Preserve existing capitalization for abbreviations (IT, CRM, API, etc.)
+    return str.replace(/\b\w+/g, (word) => {
+        // If already all-caps and length >= 2, keep it (likely an abbreviation)
+        if (word.length >= 2 && word === word.toUpperCase())
+            return word;
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    });
+}
+// ─── Main Inference Function ─────────────────────────────────────────────────
+/**
+ * Infer the underlying capability from a solution name using the Tier 2 LLM.
+ *
+ * This is the core function for pipeline mode's first step: given a named
+ * solution (product, framework, methodology, standard), determine the generic
+ * capability it addresses.
+ *
+ * @param {string} solutionName - The solution name (e.g. "Kubernetes", "Scrum", "ISO 27001")
+ * @param {Object} options
+ * @param {string}   [options.description] - Additional context about the solution
+ * @param {function} options.llmCall       - LLM call function (from llm-call.mjs)
+ * @returns {Promise<PipelineCapabilityInferenceResult>}
+ */
+// any: options bag (description, llmCall, ...) — result is { capability, nature, confidence, reasoning }
+export async function inferCapabilityFromSolution(solutionName, options = {}) {
+    const { description = '', llmCall } = options;
+    if (!solutionName || typeof solutionName !== 'string') {
+        throw new Error('inferCapabilityFromSolution: solutionName must be a non-empty string');
+    }
+    if (typeof llmCall !== 'function') {
+        throw new Error('inferCapabilityFromSolution: llmCall function is required');
+    }
+    const trimmedName = solutionName.trim();
+    logDebug(TOOL, `Inferring capability for solution "${trimmedName}"...`);
+    // Delegate to the existing identifyCapability module
+    // It already has the full LLM prompt and parsing logic
+    const component = {
+        name: trimmedName,
+        description: description || '',
+        context: description || '',
+    };
+    const capResult = await identifyCapability(component, llmCall);
+    logDebug(TOOL, `Inferred capability for "${trimmedName}": ` +
+        `"${capResult.capability}" (nature=${capResult.nature}, confidence=${capResult.confidence})`);
+    // Build the clean label for OWM display
+    const capabilityLabel = capabilityToLabel(capResult.capability, capResult.nature);
+    logDebug(TOOL, `Capability label for "${trimmedName}": "${capabilityLabel}"`);
+    return {
+        solutionName: trimmedName,
+        capability: capResult.capability,
+        capabilityLabel,
+        nature: capResult.nature || 'activity',
+        wardleyType: capResult.type || 'component',
+        confidence: capResult.confidence,
+        justification: capResult.justification || '',
+        inferred: true,
+    };
+}
+//# sourceMappingURL=pipeline-capability-inference.mjs.map

package/dist/work-on-evolution/pipeline/pipeline-capability-inference.mjs.map

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