labre-mcp 0.1.0

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/classification/infer-capability-from-solution.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 '../capability/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=infer-capability-from-solution.mjs.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/classification/infer-capability-from-solution.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-capability-from-solution.mjs","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/classification/infer-capability-from-solution.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/classification/wardley-type-classification.d.mts

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

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/classification/wardley-type-classification.d.mts.map

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

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/classification/wardley-type-classification.mjs

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

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/classification/wardley-type-classification.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wardley-type-classification.mjs","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/classification/wardley-type-classification.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/concurrent-verification.d.mts

@@ -0,0 +1,81 @@
+/**
+ * Confidence thresholds for concurrent verification tiers.
+ * Mirrors the THRESHOLDS from the sequential orchestrator.
+ */
+export declare const THRESHOLDS: {
+    NAMING_SKIP: number;
+    LLM_SKIP: number;
+    MIN_VERIFIED: number;
+};
+/** Default timeout per verification signal (ms). Overridable via context. */
+export declare const DEFAULT_SIGNAL_TIMEOUT_MS = 15000;
+/**
+ * @typedef {Object} VerificationSignal
+ * @property {'solution'|'capability'|null} classification
+ * @property {number}    confidence
+ * @property {string}    method
+ * @property {string}    reasoning
+ * @property {'success'|'timeout'|'error'|'skipped'} status
+ * @property {number}    durationMs
+ * @property {Object}    [raw]
+ * @property {string}    [error]
+ */
+/**
+ * @typedef {Object} DualSignalPair
+ * @property {VerificationSignal}       llmSignal
+ * @property {VerificationSignal}       webSearchSignal
+ * @property {'solution'|'capability'}  classification
+ * @property {number}                   confidence
+ * @property {string}                   method
+ * @property {string}                   reasoning
+ * @property {boolean}                  verified
+ * @property {number}                   totalDurationMs
+ * @property {Object}                   [namingResult]
+ */
+/**
+ * Concurrent dual-verification orchestrator.
+ *
+ * Runs LLM verification and web search verification **in parallel** using
+ * `Promise.allSettled` with per-signal timeouts. This minimizes total latency
+ * compared to the sequential `verifyClassification` pipeline.
+ *
+ * Lifecycle:
+ *   1. (Optional) Tier 1 naming convention check — if confidence >= 90%, returns
+ *      immediately without invoking LLM or web search (cost optimization).
+ *   2. Launches LLM and web search concurrently (each with independent timeout).
+ *   3. Collects both signals (success / timeout / error / skipped).
+ *   4. Reconciles the pair into a single classification.
+ *   5. Returns structured DualSignalPair with both raw signals and reconciled result.
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {Object} [context={}]
+ * @param {string}   [context.description]
+ * @param {function} [context.llmCall]
+ * @param {function} [context.webSearchCall]
+ * @param {boolean}  [context.skipLLM=false]
+ * @param {boolean}  [context.skipWebSearch=false]
+ * @param {boolean}  [context.skipNamingPrecheck=false]
+ * @param {number}   [context.llmTimeoutMs]
+ * @param {number}   [context.webSearchTimeoutMs]
+ * @returns {Promise<DualSignalPair>}
+ */
+export declare function verifyConcurrent(componentName: string, context?: any): Promise<any>;
+/**
+ * Full concurrent verification with Tier 1 pre-check and routing target computation.
+ *
+ * This is the high-level integration point for estimate-evolution.mjs.
+ * It combines:
+ *   1. Tier 1 naming convention check (optional short-circuit)
+ *   2. Concurrent LLM + web search verification
+ *   3. Reconciliation of all available signals (naming + pair)
+ *   4. Routing target computation from the final classification
+ *
+ * Returns a VerifiedClassificationResult compatible with the existing
+ * `verifyClassification` contract, enriched with the DualSignalPair detail.
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {Object} [context={}]  - Same context shape as verifyConcurrent
+ * @returns {Promise<Object>}
+ */
+export declare function verifyConcurrentFull(componentName: string, context?: any): Promise<any>;
+//# sourceMappingURL=concurrent-verification.d.mts.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/concurrent-verification.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrent-verification.d.mts","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/concurrent-verification.mts"],"names":[],"mappings":"AAqCA;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;CAItB,CAAC;AAIF,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAIhD;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;GAWG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAuJ7F;AAID;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAwGjG"}