labre-mcp 0.1.0

package/dist/work-on-evolution/pipeline/signal-combiner.d.mts

@@ -0,0 +1,131 @@
+import type { VerificationSignal, CombinedSignalResult } from '../../types/pipeline.mjs';
+/** Component type constants (mirroring solution-capability-router) */
+export declare const COMPONENT_TYPE: {
+    SOLUTION: string;
+    CAPABILITY: string;
+};
+/**
+ * Confidence adjustment parameters.
+ *
+ * These are tuned to match the existing reconciliation logic in
+ * dual-verification-orchestrator.mjs and web-search-verification.mjs,
+ * ensuring consistent behavior across the codebase.
+ */
+export declare const COMBINATION_PARAMS: {
+    /** Bonus added when both signals agree (on top of their average) */
+    AGREEMENT_BONUS: number;
+    /** Maximum confidence after combination (prevents over-confidence) */
+    MAX_CONFIDENCE: number;
+    /** Penalty applied when signals disagree (subtracted from winner) */
+    DISAGREEMENT_PENALTY: number;
+    /** Minimum confidence floor after disagreement penalty */
+    DISAGREEMENT_FLOOR: number;
+    /** Weight given to LLM signal when both are present (web search gets 1 - this) */
+    LLM_WEIGHT: number;
+    /** Weight given to web search signal when both are present */
+    WEB_SEARCH_WEIGHT: number;
+    /** Minimum confidence for a signal to be considered "usable" */
+    MIN_SIGNAL_CONFIDENCE: number;
+    /** Confidence degradation factor when a signal is missing/failed */
+    MISSING_SIGNAL_DEGRADATION: number;
+};
+/**
+ * Signal status values.
+ * Matches the VerificationSignal status enum from dual-verification-orchestrator.
+ */
+export declare const SIGNAL_STATUS: {
+    SUCCESS: string;
+    TIMEOUT: string;
+    ERROR: string;
+    SKIPPED: string;
+};
+/**
+ * @typedef {Object} ClassificationSignal
+ * @property {'solution'|'capability'|null} classification - Classified component type (null if failed)
+ * @property {number}    confidence  - Confidence score (0-1), 0 if failed/unavailable
+ * @property {string}    method      - Signal source identifier: 'llm', 'web-search', 'naming', etc.
+ * @property {string}    [reasoning] - Human-readable explanation
+ * @property {'success'|'timeout'|'error'|'skipped'} [status] - Signal outcome
+ * @property {number}    [durationMs] - Wall-clock time for this signal
+ * @property {Object}    [raw]       - Raw result from the verification backend
+ * @property {string}    [error]     - Error message (when status is 'error' or 'timeout')
+ */
+/**
+ * @typedef {Object} CombinedClassificationResult
+ * @property {'solution'|'capability'} classification - Final combined classification
+ * @property {number}    confidence   - Combined confidence score (0-1)
+ * @property {string}    method       - Method chain describing which signals contributed
+ * @property {string}    reasoning    - Combined human-readable reasoning
+ * @property {'agreement'|'disagreement'|'single-signal'|'no-signal'} mergeCase
+ *   Which of the three merge cases was applied
+ * @property {boolean}   verified     - true if confidence >= MIN_VERIFIED threshold
+ * @property {boolean}   isSolution   - Convenience flag: classification === 'solution'
+ * @property {Object}    [signals]    - Both input signals preserved for traceability
+ * @property {ClassificationSignal} [signals.llm]       - LLM signal as received
+ * @property {ClassificationSignal} [signals.webSearch]  - Web search signal as received
+ */
+/**
+ * Check if a signal is usable (successful with a valid classification).
+ *
+ * A signal is usable when:
+ *   - status is 'success' (or status field is absent, for backward compat)
+ *   - classification is a non-null string ('solution' or 'capability')
+ *   - confidence is a positive number above the minimum threshold
+ *
+ * @param {ClassificationSignal} signal - Signal to check
+ * @returns {boolean} true if the signal provides a usable classification
+ */
+export declare function isSignalUsable(signal: VerificationSignal | null | undefined): boolean;
+/**
+ * Combine LLM classification signal and web search signal into a single
+ * solution-or-capability determination.
+ *
+ * Merge cases (handled in order):
+ *
+ *   **Case 1: Agreement** (both usable, same classification)
+ *     Confidence = avg(llm, webSearch) + AGREEMENT_BONUS (capped at MAX_CONFIDENCE)
+ *     → High confidence because independent signals corroborate each other
+ *
+ *   **Case 2: Disagreement** (both usable, different classification)
+ *     Winner = signal with higher confidence
+ *     Confidence = max(weightedLlm, weightedWeb) - DISAGREEMENT_PENALTY (floor at DISAGREEMENT_FLOOR)
+ *     → Lower confidence because the signals contradict; fallback to the stronger signal
+ *     → When confidences are close (within 0.10), additional penalty applied
+ *
+ *   **Case 3: Partial/missing** (one or both signals not usable)
+ *     - One signal usable → use it, apply MISSING_SIGNAL_DEGRADATION factor
+ *     - Neither usable → default to capability with confidence 0
+ *
+ * @param {ClassificationSignal} llmSignal - LLM classification signal
+ * @param {ClassificationSignal} webSearchSignal - Web search classification signal
+ * @param {Object} [options={}]
+ * @param {number} [options.agreementBonus=0.10]       - Override agreement bonus
+ * @param {number} [options.disagreementPenalty=0.10]   - Override disagreement penalty
+ * @param {number} [options.maxConfidence=0.98]         - Override max confidence cap
+ * @param {number} [options.disagreementFloor=0.45]     - Override minimum after disagreement
+ * @param {number} [options.llmWeight=0.45]             - Override LLM weight in disagreement
+ * @param {number} [options.webSearchWeight=0.55]       - Override web search weight in disagreement
+ * @param {number} [options.minVerified=0.70]           - Min confidence for verified flag
+ * @returns {CombinedClassificationResult} Combined classification with confidence
+ */
+export declare function combineSignals(llmSignal: VerificationSignal | null, webSearchSignal: VerificationSignal | null, options?: any): CombinedSignalResult;
+/**
+ * Combine three signals: naming convention + LLM + web search.
+ *
+ * This is the full integration point for estimate-evolution.mjs when all
+ * three detection tiers have run. The naming signal carries the Tier 1
+ * result from solution-capability-router.mjs.
+ *
+ * Algorithm:
+ *   1. First combine LLM + web search using combineSignals()
+ *   2. Then reconcile the combined result with the naming signal
+ *      using a two-stage combination that preserves agreement/disagreement logic
+ *
+ * @param {ClassificationSignal} namingSignal     - Naming convention signal (Tier 1)
+ * @param {ClassificationSignal} llmSignal        - LLM classification signal (Tier 2)
+ * @param {ClassificationSignal} webSearchSignal  - Web search signal (Tier 3)
+ * @param {Object} [options={}]                   - Same options as combineSignals
+ * @returns {CombinedClassificationResult} Combined classification from all three signals
+ */
+export declare function combineAllSignals(namingSignal: VerificationSignal | null, llmSignal: VerificationSignal | null, webSearchSignal: VerificationSignal | null, options?: any): CombinedSignalResult;
+//# sourceMappingURL=signal-combiner.d.mts.map

package/dist/work-on-evolution/pipeline/signal-combiner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-combiner.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/pipeline/signal-combiner.mts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAMzF,sEAAsE;AACtE,eAAO,MAAM,cAAc;;;CAG1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oEAAoE;;IAEpE,sEAAsE;;IAEtE,qEAAqE;;IAErE,0DAA0D;;IAE1D,kFAAkF;;IAElF,8DAA8D;;IAE9D,gEAAgE;;IAEhE,oEAAoE;;CAErE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;CAKzB,CAAC;AAIF;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;GAaG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAgBrF;AAoCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,cAAc,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,EAAE,eAAe,EAAE,kBAAkB,GAAG,IAAI,EAAE,OAAO,GAAE,GAAQ,GAAG,oBAAoB,CAuIxJ;AAID;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI,EAAE,SAAS,EAAE,kBAAkB,GAAG,IAAI,EAAE,eAAe,EAAE,kBAAkB,GAAG,IAAI,EAAE,OAAO,GAAE,GAAQ,GAAG,oBAAoB,CA2EpM"}

package/dist/work-on-evolution/pipeline/signal-combiner.mjs

@@ -0,0 +1,435 @@
+// Signal Combiner for Solution vs Capability Classification
+//
+// Combines LLM classification signal and web search signal into a single
+// solution-or-capability determination with a combined confidence score.
+//
+// Three merge cases:
+//   1. Agreement     — Both signals classify the same type → boost confidence
+//   2. Disagreement  — Signals disagree → weighted fallback to higher-confidence signal
+//   3. Partial/missing — One or both signals are absent/failed → graceful degradation
+//
+// This module is the single source of truth for signal combination logic
+// used by the routing layer (dual-verification-orchestrator, estimate-evolution).
+//
+// It does NOT modify any existing strategy files or the capability pipeline.
+// It sits within the verification pipeline, consuming verification signal
+// outputs and producing a reconciled classification.
+import { logDebug } from '../../lib/mcp-notifications.mjs';
+// ─── Constants ───────────────────────────────────────────────────────────────
+const TOOL = 'signal-combiner';
+/** Component type constants (mirroring solution-capability-router) */
+export const COMPONENT_TYPE = {
+    SOLUTION: 'solution',
+    CAPABILITY: 'capability',
+};
+/**
+ * Confidence adjustment parameters.
+ *
+ * These are tuned to match the existing reconciliation logic in
+ * dual-verification-orchestrator.mjs and web-search-verification.mjs,
+ * ensuring consistent behavior across the codebase.
+ */
+export const COMBINATION_PARAMS = {
+    /** Bonus added when both signals agree (on top of their average) */
+    AGREEMENT_BONUS: 0.10,
+    /** Maximum confidence after combination (prevents over-confidence) */
+    MAX_CONFIDENCE: 0.98,
+    /** Penalty applied when signals disagree (subtracted from winner) */
+    DISAGREEMENT_PENALTY: 0.10,
+    /** Minimum confidence floor after disagreement penalty */
+    DISAGREEMENT_FLOOR: 0.45,
+    /** Weight given to LLM signal when both are present (web search gets 1 - this) */
+    LLM_WEIGHT: 0.45,
+    /** Weight given to web search signal when both are present */
+    WEB_SEARCH_WEIGHT: 0.55,
+    /** Minimum confidence for a signal to be considered "usable" */
+    MIN_SIGNAL_CONFIDENCE: 0.10,
+    /** Confidence degradation factor when a signal is missing/failed */
+    MISSING_SIGNAL_DEGRADATION: 0.85,
+};
+/**
+ * Signal status values.
+ * Matches the VerificationSignal status enum from dual-verification-orchestrator.
+ */
+export const SIGNAL_STATUS = {
+    SUCCESS: 'success',
+    TIMEOUT: 'timeout',
+    ERROR: 'error',
+    SKIPPED: 'skipped',
+};
+// ─── Type Definitions ────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} ClassificationSignal
+ * @property {'solution'|'capability'|null} classification - Classified component type (null if failed)
+ * @property {number}    confidence  - Confidence score (0-1), 0 if failed/unavailable
+ * @property {string}    method      - Signal source identifier: 'llm', 'web-search', 'naming', etc.
+ * @property {string}    [reasoning] - Human-readable explanation
+ * @property {'success'|'timeout'|'error'|'skipped'} [status] - Signal outcome
+ * @property {number}    [durationMs] - Wall-clock time for this signal
+ * @property {Object}    [raw]       - Raw result from the verification backend
+ * @property {string}    [error]     - Error message (when status is 'error' or 'timeout')
+ */
+/**
+ * @typedef {Object} CombinedClassificationResult
+ * @property {'solution'|'capability'} classification - Final combined classification
+ * @property {number}    confidence   - Combined confidence score (0-1)
+ * @property {string}    method       - Method chain describing which signals contributed
+ * @property {string}    reasoning    - Combined human-readable reasoning
+ * @property {'agreement'|'disagreement'|'single-signal'|'no-signal'} mergeCase
+ *   Which of the three merge cases was applied
+ * @property {boolean}   verified     - true if confidence >= MIN_VERIFIED threshold
+ * @property {boolean}   isSolution   - Convenience flag: classification === 'solution'
+ * @property {Object}    [signals]    - Both input signals preserved for traceability
+ * @property {ClassificationSignal} [signals.llm]       - LLM signal as received
+ * @property {ClassificationSignal} [signals.webSearch]  - Web search signal as received
+ */
+// ─── Signal Validation ───────────────────────────────────────────────────────
+/**
+ * Check if a signal is usable (successful with a valid classification).
+ *
+ * A signal is usable when:
+ *   - status is 'success' (or status field is absent, for backward compat)
+ *   - classification is a non-null string ('solution' or 'capability')
+ *   - confidence is a positive number above the minimum threshold
+ *
+ * @param {ClassificationSignal} signal - Signal to check
+ * @returns {boolean} true if the signal provides a usable classification
+ */
+export function isSignalUsable(signal) {
+    if (!signal)
+        return false;
+    // Status check: success or absent status field (backward compatibility)
+    const statusOk = !signal.status || signal.status === SIGNAL_STATUS.SUCCESS;
+    // Classification must be a valid type
+    const classOk = signal.classification === COMPONENT_TYPE.SOLUTION ||
+        signal.classification === COMPONENT_TYPE.CAPABILITY;
+    // Confidence must be a positive number
+    const confOk = typeof signal.confidence === 'number' &&
+        !Number.isNaN(signal.confidence) &&
+        signal.confidence >= COMBINATION_PARAMS.MIN_SIGNAL_CONFIDENCE;
+    return statusOk && classOk && confOk;
+}
+/**
+ * Normalize a signal input to a consistent shape.
+ * Handles null/undefined signals and provides sensible defaults.
+ *
+ * @param {ClassificationSignal|null|undefined} signal - Raw signal input
+ * @param {string} defaultMethod - Method label to use if not provided
+ * @returns {ClassificationSignal} Normalized signal (never null)
+ */
+function normalizeSignal(signal, defaultMethod = 'unknown') {
+    if (!signal) {
+        return {
+            classification: null,
+            confidence: 0,
+            method: defaultMethod,
+            reasoning: `No ${defaultMethod} signal provided`,
+            status: SIGNAL_STATUS.SKIPPED,
+        };
+    }
+    return {
+        classification: signal.classification || null,
+        confidence: typeof signal.confidence === 'number' && !Number.isNaN(signal.confidence)
+            ? signal.confidence : 0,
+        method: signal.method || defaultMethod,
+        reasoning: signal.reasoning || '',
+        status: signal.status || (signal.classification ? SIGNAL_STATUS.SUCCESS : SIGNAL_STATUS.SKIPPED),
+        ...(signal.durationMs !== undefined && { durationMs: signal.durationMs }),
+        ...(signal.raw !== undefined && { raw: signal.raw }),
+        ...(signal.error !== undefined && { error: signal.error }),
+    };
+}
+// ─── Core Combination Function ───────────────────────────────────────────────
+/**
+ * Combine LLM classification signal and web search signal into a single
+ * solution-or-capability determination.
+ *
+ * Merge cases (handled in order):
+ *
+ *   **Case 1: Agreement** (both usable, same classification)
+ *     Confidence = avg(llm, webSearch) + AGREEMENT_BONUS (capped at MAX_CONFIDENCE)
+ *     → High confidence because independent signals corroborate each other
+ *
+ *   **Case 2: Disagreement** (both usable, different classification)
+ *     Winner = signal with higher confidence
+ *     Confidence = max(weightedLlm, weightedWeb) - DISAGREEMENT_PENALTY (floor at DISAGREEMENT_FLOOR)
+ *     → Lower confidence because the signals contradict; fallback to the stronger signal
+ *     → When confidences are close (within 0.10), additional penalty applied
+ *
+ *   **Case 3: Partial/missing** (one or both signals not usable)
+ *     - One signal usable → use it, apply MISSING_SIGNAL_DEGRADATION factor
+ *     - Neither usable → default to capability with confidence 0
+ *
+ * @param {ClassificationSignal} llmSignal - LLM classification signal
+ * @param {ClassificationSignal} webSearchSignal - Web search classification signal
+ * @param {Object} [options={}]
+ * @param {number} [options.agreementBonus=0.10]       - Override agreement bonus
+ * @param {number} [options.disagreementPenalty=0.10]   - Override disagreement penalty
+ * @param {number} [options.maxConfidence=0.98]         - Override max confidence cap
+ * @param {number} [options.disagreementFloor=0.45]     - Override minimum after disagreement
+ * @param {number} [options.llmWeight=0.45]             - Override LLM weight in disagreement
+ * @param {number} [options.webSearchWeight=0.55]       - Override web search weight in disagreement
+ * @param {number} [options.minVerified=0.70]           - Min confidence for verified flag
+ * @returns {CombinedClassificationResult} Combined classification with confidence
+ */
+// any: options bag carries many tunable knobs (weights, floors, bonuses, ...)
+export function combineSignals(llmSignal, webSearchSignal, options = {}) {
+    const params = {
+        agreementBonus: options.agreementBonus ?? COMBINATION_PARAMS.AGREEMENT_BONUS,
+        disagreementPenalty: options.disagreementPenalty ?? COMBINATION_PARAMS.DISAGREEMENT_PENALTY,
+        maxConfidence: options.maxConfidence ?? COMBINATION_PARAMS.MAX_CONFIDENCE,
+        disagreementFloor: options.disagreementFloor ?? COMBINATION_PARAMS.DISAGREEMENT_FLOOR,
+        llmWeight: options.llmWeight ?? COMBINATION_PARAMS.LLM_WEIGHT,
+        webSearchWeight: options.webSearchWeight ?? COMBINATION_PARAMS.WEB_SEARCH_WEIGHT,
+        minVerified: options.minVerified ?? 0.70,
+    };
+    // Normalize inputs
+    const llm = normalizeSignal(llmSignal, 'llm');
+    const web = normalizeSignal(webSearchSignal, 'web-search');
+    const llmUsable = isSignalUsable(llm);
+    const webUsable = isSignalUsable(web);
+    logDebug(TOOL, `Combining: LLM=${llm.classification}(${llm.confidence}, ${llm.status}), ` +
+        `Web=${web.classification}(${web.confidence}, ${web.status}) → ` +
+        `usable: llm=${llmUsable}, web=${webUsable}`);
+    // ── Case 3: Partial / Missing ───────────────────────────────────────────
+    if (!llmUsable && !webUsable) {
+        // Neither signal is usable → default to capability with zero confidence
+        logDebug(TOOL, 'Case: no-signal — defaulting to capability');
+        return buildCombinedResult({
+            classification: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'none',
+            reasoning: buildNoSignalReasoning(llm, web),
+            mergeCase: 'no-signal',
+            minVerified: params.minVerified,
+            llm,
+            web,
+        });
+    }
+    if (!llmUsable || !webUsable) {
+        // Only one signal is usable → use it with degradation factor
+        const usable = llmUsable ? llm : web;
+        const missing = llmUsable ? web : llm;
+        const degradedConfidence = roundConfidence(usable.confidence * COMBINATION_PARAMS.MISSING_SIGNAL_DEGRADATION);
+        logDebug(TOOL, `Case: single-signal (${usable.method}) → ` +
+            `${usable.classification} conf=${degradedConfidence} (degraded from ${usable.confidence})`);
+        return buildCombinedResult({
+            classification: usable.classification,
+            confidence: degradedConfidence,
+            method: usable.method,
+            reasoning: `${usable.reasoning} (${missing.method} ${missing.status || 'unavailable'})`,
+            mergeCase: 'single-signal',
+            minVerified: params.minVerified,
+            llm,
+            web,
+        });
+    }
+    // ── Both signals are usable ──────────────────────────────────────────────
+    // ── Case 1: Agreement ─────────────────────────────────────────────────────
+    if (llm.classification === web.classification) {
+        const boosted = roundConfidence(Math.min(params.maxConfidence, (llm.confidence + web.confidence) / 2 + params.agreementBonus));
+        logDebug(TOOL, `Case: agreement (${llm.classification}) → boosted conf=${boosted} ` +
+            `(from avg=${((llm.confidence + web.confidence) / 2).toFixed(3)} + bonus=${params.agreementBonus})`);
+        return buildCombinedResult({
+            classification: llm.classification,
+            confidence: boosted,
+            method: 'llm+web-search',
+            reasoning: buildAgreementReasoning(llm, web),
+            mergeCase: 'agreement',
+            minVerified: params.minVerified,
+            llm,
+            web,
+        });
+    }
+    // ── Case 2: Disagreement ──────────────────────────────────────────────────
+    //
+    // When LLM and web search disagree, we apply weighted scoring to determine
+    // the winner, then apply a confidence penalty for the conflict.
+    //
+    // Weighting: web search gets slightly more weight (0.55 vs 0.45) because
+    // it's based on real-world evidence (product pages, Wikipedia, GitHub repos)
+    // rather than parametric knowledge that may be stale.
+    const llmWeighted = llm.confidence * params.llmWeight;
+    const webWeighted = web.confidence * params.webSearchWeight;
+    const winner = llmWeighted >= webWeighted ? llm : web;
+    const loser = llmWeighted >= webWeighted ? web : llm;
+    // Base penalty
+    let penalty = params.disagreementPenalty;
+    // Extra penalty when confidences are close (within 0.10) — higher ambiguity
+    const confGap = Math.abs(llm.confidence - web.confidence);
+    if (confGap < 0.10) {
+        penalty += 0.05;
+    }
+    const penalizedConfidence = roundConfidence(Math.max(params.disagreementFloor, winner.confidence - penalty));
+    logDebug(TOOL, `Case: disagreement — LLM=${llm.classification}(${llm.confidence}), ` +
+        `Web=${web.classification}(${web.confidence}) → ` +
+        `winner=${winner.method}(weighted: llm=${llmWeighted.toFixed(3)}, web=${webWeighted.toFixed(3)}), ` +
+        `conf=${penalizedConfidence} (penalty=${penalty})`);
+    return buildCombinedResult({
+        classification: winner.classification,
+        confidence: penalizedConfidence,
+        method: 'llm+web-search',
+        reasoning: buildDisagreementReasoning(winner, loser, confGap),
+        mergeCase: 'disagreement',
+        minVerified: params.minVerified,
+        llm,
+        web,
+    });
+}
+// ─── Three-way Combination (with Naming Signal) ─────────────────────────────
+/**
+ * Combine three signals: naming convention + LLM + web search.
+ *
+ * This is the full integration point for estimate-evolution.mjs when all
+ * three detection tiers have run. The naming signal carries the Tier 1
+ * result from solution-capability-router.mjs.
+ *
+ * Algorithm:
+ *   1. First combine LLM + web search using combineSignals()
+ *   2. Then reconcile the combined result with the naming signal
+ *      using a two-stage combination that preserves agreement/disagreement logic
+ *
+ * @param {ClassificationSignal} namingSignal     - Naming convention signal (Tier 1)
+ * @param {ClassificationSignal} llmSignal        - LLM classification signal (Tier 2)
+ * @param {ClassificationSignal} webSearchSignal  - Web search signal (Tier 3)
+ * @param {Object} [options={}]                   - Same options as combineSignals
+ * @returns {CombinedClassificationResult} Combined classification from all three signals
+ */
+// any: options bag carries many tunable knobs (weights, floors, bonuses, ...)
+export function combineAllSignals(namingSignal, llmSignal, webSearchSignal, options = {}) {
+    const params = {
+        agreementBonus: options.agreementBonus ?? COMBINATION_PARAMS.AGREEMENT_BONUS,
+        maxConfidence: options.maxConfidence ?? COMBINATION_PARAMS.MAX_CONFIDENCE,
+        disagreementPenalty: options.disagreementPenalty ?? COMBINATION_PARAMS.DISAGREEMENT_PENALTY,
+        disagreementFloor: options.disagreementFloor ?? COMBINATION_PARAMS.DISAGREEMENT_FLOOR,
+        minVerified: options.minVerified ?? 0.70,
+    };
+    // Step 1: Combine LLM + web search
+    const dualResult = combineSignals(llmSignal, webSearchSignal, options);
+    // Step 2: Normalize naming signal
+    const naming = normalizeSignal(namingSignal, 'naming');
+    const namingUsable = isSignalUsable(naming);
+    if (!namingUsable) {
+        // No usable naming signal — return the dual result directly
+        return dualResult;
+    }
+    if (dualResult.mergeCase === 'no-signal') {
+        // Dual verification produced nothing — return naming with degradation
+        const degradedConfidence = roundConfidence(naming.confidence * COMBINATION_PARAMS.MISSING_SIGNAL_DEGRADATION);
+        return buildCombinedResult({
+            classification: naming.classification,
+            confidence: degradedConfidence,
+            method: 'naming',
+            reasoning: `${naming.reasoning} (dual verification unavailable)`,
+            mergeCase: 'single-signal',
+            minVerified: params.minVerified,
+            llm: normalizeSignal(llmSignal, 'llm'),
+            web: normalizeSignal(webSearchSignal, 'web-search'),
+        });
+    }
+    // Step 3: Reconcile naming with the dual result
+    if (naming.classification === dualResult.classification) {
+        // Triple agreement (or naming agrees with dual winner) → strong boost
+        const boosted = roundConfidence(Math.min(params.maxConfidence, (naming.confidence + dualResult.confidence) / 2 + params.agreementBonus));
+        return buildCombinedResult({
+            classification: dualResult.classification,
+            confidence: boosted,
+            method: `naming+${dualResult.method}`,
+            reasoning: `${dualResult.reasoning} (naming agrees: ${naming.reasoning})`,
+            mergeCase: dualResult.mergeCase === 'agreement' ? 'agreement' : dualResult.mergeCase,
+            minVerified: params.minVerified,
+            llm: normalizeSignal(llmSignal, 'llm'),
+            web: normalizeSignal(webSearchSignal, 'web-search'),
+        });
+    }
+    // Naming disagrees with dual result → trust dual (it's multi-signal) but penalize
+    const penalized = roundConfidence(Math.max(params.disagreementFloor, dualResult.confidence - params.disagreementPenalty));
+    return buildCombinedResult({
+        classification: dualResult.classification,
+        confidence: penalized,
+        method: `naming+${dualResult.method}`,
+        reasoning: `Dual verification (${dualResult.method}) overrides naming: ${dualResult.reasoning} (naming said: ${naming.classification})`,
+        mergeCase: 'disagreement',
+        minVerified: params.minVerified,
+        llm: normalizeSignal(llmSignal, 'llm'),
+        web: normalizeSignal(webSearchSignal, 'web-search'),
+    });
+}
+// ─── Reasoning Builders ──────────────────────────────────────────────────────
+/**
+ * Build reasoning string for the no-signal case.
+ * @param {ClassificationSignal} llm
+ * @param {ClassificationSignal} web
+ * @returns {string}
+ */
+function buildNoSignalReasoning(llm, web) {
+    const parts = [];
+    if (llm.status && llm.status !== SIGNAL_STATUS.SKIPPED) {
+        parts.push(`LLM: ${llm.reasoning || llm.status}`);
+    }
+    if (web.status && web.status !== SIGNAL_STATUS.SKIPPED) {
+        parts.push(`Web search: ${web.reasoning || web.status}`);
+    }
+    if (parts.length === 0) {
+        return 'Both verification signals were skipped or unavailable';
+    }
+    return `Both verification signals failed: ${parts.join('; ')}`;
+}
+/**
+ * Build reasoning string for the agreement case.
+ * @param {ClassificationSignal} llm
+ * @param {ClassificationSignal} web
+ * @returns {string}
+ */
+function buildAgreementReasoning(llm, web) {
+    const primary = web.confidence >= llm.confidence ? web : llm;
+    const secondary = web.confidence >= llm.confidence ? llm : web;
+    return `${primary.reasoning || primary.method} (${secondary.method} agrees: ${secondary.reasoning || secondary.classification})`;
+}
+/**
+ * Build reasoning string for the disagreement case.
+ * @param {ClassificationSignal} winner
+ * @param {ClassificationSignal} loser
+ * @param {number} confGap
+ * @returns {string}
+ */
+function buildDisagreementReasoning(winner, loser, confGap) {
+    const ambiguityNote = confGap < 0.10
+        ? ' — signals are close in confidence, classification is ambiguous'
+        : '';
+    return `${winner.method} overrides ${loser.method}: ${winner.reasoning || winner.classification} ` +
+        `(${loser.method} said: ${loser.classification}${loser.reasoning ? `, ${loser.reasoning}` : ''})${ambiguityNote}`;
+}
+// ─── Result Builder ──────────────────────────────────────────────────────────
+/**
+ * Build a CombinedClassificationResult.
+ *
+ * @param {Object} params
+ * @returns {CombinedClassificationResult}
+ */
+function buildCombinedResult(params) {
+    const { classification, confidence, method, reasoning, mergeCase, minVerified, llm, web } = params;
+    return {
+        classification,
+        confidence,
+        method,
+        reasoning,
+        mergeCase,
+        verified: confidence >= minVerified,
+        isSolution: classification === COMPONENT_TYPE.SOLUTION,
+        signals: {
+            llm: llm || null,
+            webSearch: web || null,
+        },
+    };
+}
+// ─── Utility ─────────────────────────────────────────────────────────────────
+/**
+ * Round a confidence value to 2 decimal places.
+ * @param {number} value
+ * @returns {number}
+ */
+function roundConfidence(value) {
+    return Math.round(value * 100) / 100;
+}
+//# sourceMappingURL=signal-combiner.mjs.map

package/dist/work-on-evolution/pipeline/signal-combiner.mjs.map

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

package/dist/work-on-evolution/pipeline/verification-reconciliation.d.mts

@@ -0,0 +1,60 @@
+import type { CombinedSignalResult } from '../../types/pipeline.mjs';
+import type { ComponentTypeDetection } from '../../types/routing.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 }}
+ */
+export declare function toIntermediateResult(detection: ComponentTypeDetection): any;
+/**
+ * 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 }}
+ */
+export declare function reconcileTwoTiers(tierA: any, tierB: any): any;
+/**
+ * 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 }}
+ */
+export declare function reconcileSignalPair(llmSignal: any, webSearchSignal: any): CombinedSignalResult;
+/**
+ * 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}
+ */
+export declare function buildResult(params: any): any;
+//# sourceMappingURL=verification-reconciliation.d.mts.map

package/dist/work-on-evolution/pipeline/verification-reconciliation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification-reconciliation.d.mts","sourceRoot":"","sources":["../../../src/work-on-evolution/pipeline/verification-reconciliation.mts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAsB,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE;;;;;;GAMG;AAEH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,sBAAsB,GAAG,GAAG,CAO3E;AAED;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,GAAG,CA6B7D;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,GAAG,EAAE,eAAe,EAAE,GAAG,GAAG,oBAAoB,CAoE9F;AAID;;;;;;;;;;;;;;;GAeG;AAEH,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAuC5C"}