labre-mcp 0.1.0

package/dist/work-on-value-chain/write/component/verification-reconciliation.mjs

@@ -0,0 +1,182 @@
+// Reconciliation logic for dual-verification pipeline
+//
+// Extracted from dual-verification-orchestrator.mjs to enforce
+// single-responsibility: this module handles converting tier results
+// to intermediate format and reconciling multiple verification signals
+// into a single classification decision.
+import { COMPONENT_TYPE } from '../../../lib/component-detection.mjs';
+import { determineRoutingTargets } from '../../../work-on-evolution/write/routing/solution-dispatch.mjs';
+/**
+ * Convert a ComponentTypeDetection (from naming conventions or LLM) into an
+ * intermediate result object for reconciliation.
+ *
+ * @param {import('../../lib/component-detection.mjs').ComponentTypeDetection} detection
+ * @returns {{ classification: string, confidence: number, method: string, reasoning: string }}
+ */
+// any: returns a heterogeneous intermediate shape (legacy fields plus routing)
+export function toIntermediateResult(detection) {
+    return {
+        classification: detection.type,
+        confidence: detection.confidence,
+        method: detection.method,
+        reasoning: detection.reason || '',
+    };
+}
+/**
+ * Reconcile two tier results using agreement/disagreement logic.
+ *
+ * When both tiers agree on classification:
+ *   → Boost confidence: average of both + 0.10 agreement bonus (capped at 0.98)
+ *
+ * When tiers disagree:
+ *   → Trust the tier with higher confidence, but apply a 0.10 disagreement penalty
+ *   → Minimum confidence floor of 0.45
+ *
+ * This mirrors the combineWithPriorResult logic in web-search-verification.mjs
+ * and the naming+llm reconciliation in detect-solution.mjs.
+ *
+ * @param {{ classification: string, confidence: number, method: string, reasoning: string }} tierA
+ * @param {{ classification: string, confidence: number, method: string, reasoning: string }} tierB
+ * @returns {{ classification: string, confidence: number, method: string, reasoning: string }}
+ */
+// any: tierA/tierB shapes are heterogeneous detection-or-signal payloads
+export function reconcileTwoTiers(tierA, tierB) {
+    if (tierA.classification === tierB.classification) {
+        // Agreement: boost confidence
+        const boosted = Math.round(Math.min(0.98, (tierA.confidence + tierB.confidence) / 2 + 0.10) * 100) / 100;
+        return {
+            classification: tierA.classification,
+            confidence: boosted,
+            method: `${tierA.method}+${tierB.method}`,
+            reasoning: `${tierB.reasoning} (agrees with ${tierA.method}: ${tierA.reasoning})`,
+        };
+    }
+    // Disagreement: trust higher-confidence tier with penalty
+    const winner = tierA.confidence >= tierB.confidence ? tierA : tierB;
+    const loser = tierA.confidence >= tierB.confidence ? tierB : tierA;
+    const penalized = Math.round(Math.max(0.45, winner.confidence - 0.10) * 100) / 100;
+    return {
+        classification: winner.classification,
+        confidence: penalized,
+        method: `${tierA.method}+${tierB.method}`,
+        reasoning: `${winner.method} overrides ${loser.method}: ${winner.reasoning} (${loser.method} said: ${loser.classification})`,
+    };
+}
+/**
+ * Reconcile a pair of verification signals into a single classification.
+ *
+ * Resolution rules (ordered by priority):
+ *   1. Both successful and agree → boost confidence (average + 0.10 bonus, capped at 0.98)
+ *   2. Both successful but disagree → trust higher confidence, apply 0.10 penalty (floor 0.45)
+ *   3. Only one successful → use its result directly
+ *   4. Neither successful → default to capability with 0 confidence
+ *
+ * @param {import('./dual-verification-orchestrator.mjs').VerificationSignal} llmSignal
+ * @param {import('./dual-verification-orchestrator.mjs').VerificationSignal} webSearchSignal
+ * @returns {{ classification: string, confidence: number, method: string, reasoning: string }}
+ */
+// any: caller guarantees both signals are non-null after early-return guards above
+export function reconcileSignalPair(llmSignal, webSearchSignal) {
+    const llmOk = llmSignal.status === 'success' && llmSignal.classification != null;
+    const webOk = webSearchSignal.status === 'success' && webSearchSignal.classification != null;
+    // Case 4: Neither succeeded
+    if (!llmOk && !webOk) {
+        const reasons = [];
+        if (llmSignal.status !== 'skipped')
+            reasons.push(`LLM: ${llmSignal.reasoning}`);
+        if (webSearchSignal.status !== 'skipped')
+            reasons.push(`Web: ${webSearchSignal.reasoning}`);
+        return {
+            classification: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'none',
+            reasoning: reasons.length > 0
+                ? `Both verifications failed: ${reasons.join('; ')}`
+                : 'Both verifications were skipped',
+        };
+    }
+    // Case 3a: Only LLM succeeded
+    if (llmOk && !webOk) {
+        return {
+            classification: llmSignal.classification,
+            confidence: llmSignal.confidence,
+            method: 'llm',
+            reasoning: `${llmSignal.reasoning} (web search ${webSearchSignal.status})`,
+        };
+    }
+    // Case 3b: Only web search succeeded
+    if (!llmOk && webOk) {
+        return {
+            classification: webSearchSignal.classification,
+            confidence: webSearchSignal.confidence,
+            method: 'web-search',
+            reasoning: `${webSearchSignal.reasoning} (LLM ${llmSignal.status})`,
+        };
+    }
+    // Case 1 & 2: Both succeeded
+    if (llmSignal.classification === webSearchSignal.classification) {
+        // Case 1: Agreement — boost confidence
+        const boosted = Math.round(Math.min(0.98, (llmSignal.confidence + webSearchSignal.confidence) / 2 + 0.10) * 100) / 100;
+        return {
+            classification: llmSignal.classification,
+            confidence: boosted,
+            method: 'llm+web-search',
+            reasoning: `${webSearchSignal.reasoning} (LLM agrees: ${llmSignal.reasoning})`,
+        };
+    }
+    // Case 2: Disagreement — trust higher confidence with penalty
+    const winner = llmSignal.confidence >= webSearchSignal.confidence ? llmSignal : webSearchSignal;
+    const loser = llmSignal.confidence >= webSearchSignal.confidence ? webSearchSignal : llmSignal;
+    const penalized = Math.round(Math.max(0.45, winner.confidence - 0.10) * 100) / 100;
+    return {
+        classification: winner.classification,
+        confidence: penalized,
+        method: 'llm+web-search',
+        reasoning: `${winner.method} overrides ${loser.method}: ${winner.reasoning} (${loser.method} said: ${loser.classification})`,
+    };
+}
+// ─── Result Builder ─────────────────────────────────────────────────────────
+/**
+ * Build a VerifiedClassificationResult with routing targets pre-computed.
+ *
+ * @param {Object} params
+ * @param {string} params.classification - 'solution' or 'capability'
+ * @param {number} params.confidence - Confidence score (0–1)
+ * @param {string} params.method - Method chain
+ * @param {string} params.reasoning - Human-readable explanation
+ * @param {boolean} [params.verified] - Whether the result meets verification threshold
+ * @param {string[]} [params.tiersUsed] - Which tiers contributed
+ * @param {Object} params.routingDetection - Original detection for routing
+ * @param {Object} [params.namingResult] - Tier 1 naming result
+ * @param {Object} [params.llmResult] - Tier 2 LLM result
+ * @param {Object} [params.webSearchResult] - Tier 3 web search result
+ * @returns {import('./dual-verification-orchestrator.mjs').VerifiedClassificationResult}
+ */
+// any: result params bag varies (legacy fields, signal merges)
+export function buildResult(params) {
+    const { classification, confidence, method, reasoning, verified, tiersUsed, routingDetection, namingResult, llmResult, webSearchResult, } = params;
+    const isSolution = classification === COMPONENT_TYPE.SOLUTION;
+    // Pre-compute routing targets using the verified classification
+    // Override the naming detection type with the verified classification
+    const overriddenDetection = {
+        ...routingDetection,
+        type: classification,
+        confidence,
+    };
+    const routingTargets = determineRoutingTargets(overriddenDetection);
+    return {
+        classification,
+        confidence,
+        method,
+        reasoning,
+        isSolution,
+        verified: verified || false,
+        tiersUsed: tiersUsed || [],
+        routingDetection,
+        routingTargets,
+        ...(namingResult !== undefined && { namingResult }),
+        ...(llmResult !== undefined && { llmResult }),
+        ...(webSearchResult !== undefined && { webSearchResult }),
+    };
+}
+//# sourceMappingURL=verification-reconciliation.mjs.map

package/dist/work-on-value-chain/write/component/verification-reconciliation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-reconciliation.mjs","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/verification-reconciliation.mts"],"names":[],"mappings":"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"}

package/dist/work-on-value-chain/write/component/verification-signals.d.mts

@@ -0,0 +1,62 @@
+import type { VerificationSignal } from '../../../types/pipeline.mjs';
+/**
+ * Verification signal builders and timeout racing utility.
+ *
+ * These functions construct standardised VerificationSignal objects used by the
+ * dual-verification orchestrator to represent the outcome of each verification
+ * backend (LLM, web-search).
+ *
+ * @module pipeline/verification-signals
+ */
+/**
+ * Race a promise against a timeout.  Resolves (never rejects) with a descriptor
+ * indicating whether the promise settled or timed out.
+ *
+ * @param {Promise} promise    - The promise to race
+ * @param {number}  timeoutMs  - Timeout in milliseconds
+ * @param {string}  label      - Human-readable label (for debugging)
+ * @returns {Promise<{ value: any, timedOut: boolean, error?: Error }>}
+ */
+export declare function raceWithTimeout(promise: Promise<any>, timeoutMs: number, label: string): Promise<any>;
+/**
+ * Build a VerificationSignal from a successful verification result.
+ *
+ * @param {Object} result     - Raw result from the verification backend
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} durationMs - Duration in milliseconds
+ * @returns {VerificationSignal}
+ */
+export declare function buildSuccessSignal(result: {
+    classification?: string | null;
+    confidence?: number;
+    reasoning?: string;
+    isSolution?: boolean;
+    [key: string]: unknown;
+}, method: string, durationMs: number): VerificationSignal;
+/**
+ * Build a VerificationSignal for a timeout.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} timeoutMs  - The timeout that was exceeded
+ * @param {number} durationMs - Actual elapsed time
+ * @returns {VerificationSignal}
+ */
+export declare function buildTimeoutSignal(method: string, timeoutMs: number, durationMs: number): VerificationSignal;
+/**
+ * Build a VerificationSignal for an error.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {Error}  err        - The error that occurred
+ * @param {number} durationMs - Duration before failure
+ * @returns {VerificationSignal}
+ */
+export declare function buildErrorSignal(method: string, err: unknown, durationMs: number): VerificationSignal;
+/**
+ * Build a VerificationSignal for a skipped verification.
+ *
+ * @param {string} method - Signal method: 'llm' or 'web-search'
+ * @param {string} reason - Why the signal was skipped
+ * @returns {VerificationSignal}
+ */
+export declare function buildSkippedSignal(method: string, reason: string): VerificationSignal;
+//# sourceMappingURL=verification-signals.d.mts.map

package/dist/work-on-value-chain/write/component/verification-signals.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-signals.d.mts","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/verification-signals.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAGtE;;;;;;;;GAQG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA2BrG;AAID;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAU5N;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAU5G;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAUrG;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,kBAAkB,CASrF"}

package/dist/work-on-value-chain/write/component/verification-signals.mjs

@@ -0,0 +1,123 @@
+import { toErrorMessage } from '../../../lib/errors.mjs';
+/**
+ * Verification signal builders and timeout racing utility.
+ *
+ * These functions construct standardised VerificationSignal objects used by the
+ * dual-verification orchestrator to represent the outcome of each verification
+ * backend (LLM, web-search).
+ *
+ * @module pipeline/verification-signals
+ */
+// ─── raceWithTimeout ───────────────────────────────────────────────────────────
+/**
+ * Race a promise against a timeout.  Resolves (never rejects) with a descriptor
+ * indicating whether the promise settled or timed out.
+ *
+ * @param {Promise} promise    - The promise to race
+ * @param {number}  timeoutMs  - Timeout in milliseconds
+ * @param {string}  label      - Human-readable label (for debugging)
+ * @returns {Promise<{ value: any, timedOut: boolean, error?: Error }>}
+ */
+export function raceWithTimeout(promise, timeoutMs, label) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                resolve({ value: null, timedOut: true });
+            }
+        }, timeoutMs);
+        promise
+            .then((value) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve({ value, timedOut: false });
+            }
+        })
+            .catch((err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                // Re-throw wrapped so Promise.allSettled captures it
+                resolve({ value: null, timedOut: false, error: err });
+            }
+        });
+    });
+}
+// ─── Signal builders ───────────────────────────────────────────────────────────
+/**
+ * Build a VerificationSignal from a successful verification result.
+ *
+ * @param {Object} result     - Raw result from the verification backend
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} durationMs - Duration in milliseconds
+ * @returns {VerificationSignal}
+ */
+export function buildSuccessSignal(result, method, durationMs) {
+    return {
+        classification: result.classification || null,
+        confidence: typeof result.confidence === 'number' ? result.confidence : 0,
+        method,
+        reasoning: result.reasoning || '',
+        status: 'success',
+        durationMs,
+        raw: result,
+    };
+}
+/**
+ * Build a VerificationSignal for a timeout.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {number} timeoutMs  - The timeout that was exceeded
+ * @param {number} durationMs - Actual elapsed time
+ * @returns {VerificationSignal}
+ */
+export function buildTimeoutSignal(method, timeoutMs, durationMs) {
+    return {
+        classification: null,
+        confidence: 0,
+        method,
+        reasoning: `${method} verification timed out after ${timeoutMs}ms`,
+        status: 'timeout',
+        durationMs,
+        error: `Timeout after ${timeoutMs}ms`,
+    };
+}
+/**
+ * Build a VerificationSignal for an error.
+ *
+ * @param {string} method     - Signal method: 'llm' or 'web-search'
+ * @param {Error}  err        - The error that occurred
+ * @param {number} durationMs - Duration before failure
+ * @returns {VerificationSignal}
+ */
+export function buildErrorSignal(method, err, durationMs) {
+    return {
+        classification: null,
+        confidence: 0,
+        method,
+        reasoning: `${method} verification failed: ${toErrorMessage(err)}`,
+        status: 'error',
+        durationMs,
+        error: toErrorMessage(err),
+    };
+}
+/**
+ * Build a VerificationSignal for a skipped verification.
+ *
+ * @param {string} method - Signal method: 'llm' or 'web-search'
+ * @param {string} reason - Why the signal was skipped
+ * @returns {VerificationSignal}
+ */
+export function buildSkippedSignal(method, reason) {
+    return {
+        classification: null,
+        confidence: 0,
+        method,
+        reasoning: reason,
+        status: 'skipped',
+        durationMs: 0,
+    };
+}
+//# sourceMappingURL=verification-signals.mjs.map

package/dist/work-on-value-chain/write/component/verification-signals.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-signals.mjs","sourceRoot":"","sources":["../../../../src/work-on-value-chain/write/component/verification-signals.mts"],"names":[],"mappings":"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"}

package/dist/work-on-value-chain/write/component/wardley-type-classification.d.mts

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

package/dist/work-on-value-chain/write/component/wardley-type-classification.d.mts.map

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

package/dist/work-on-value-chain/write/component/wardley-type-classification.mjs

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

package/dist/work-on-value-chain/write/component/wardley-type-classification.mjs.map

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