labre-mcp 0.1.0

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/anchor/estimate-anchor-evolution.mjs

@@ -0,0 +1,156 @@
+// Estimate the evolution position of an anchor (user need / stakeholder)
+// in a Wardley Map using the consumption culture lens.
+//
+// Unlike components evaluated by technical maturity, anchors are assessed
+// through two perception dimensions mapped to the 4 evolution phases:
+//   1. User perception (how end-users perceive the offering)
+//   2. Industry perception (how the market/industry views it)
+//
+// The MCP tool wrapper lives in src/mcp/estimate-anchor-evolution.tool.mts.
+import { evolutionToStage } from '#lib/response-formatter.mjs';
+import { parseKeyValueBlock } from '#lib/prompts/parsers.mjs';
+import { getPrompt } from '#lib/prompts/registry.mjs';
+import { tryDegradeAmbient, getCurrentCollector } from '#lib/degradation/index.mjs';
+// ─── Anchor Perception Model ───────────────────────────────────────────────
+const PHASE_MIDPOINTS = { 1: 0.09, 2: 0.29, 3: 0.55, 4: 0.85 };
+const USER_PERCEPTION = {
+    1: 'Différent / déroutant / excitant / surprenant',
+    2: 'Avant-garde / émergente',
+    3: 'Commun / Déçu de ne pas l\'utiliser / Déçu qu\'il ne soit pas disponible',
+    4: 'Standard / Attendu',
+};
+const INDUSTRY_PERCEPTION = {
+    1: 'Avantage concurrentiel / Imprévisible / Inconnu',
+    2: 'Avantage concurrentiel / ROI / Cas d\'exemple',
+    3: 'Avantage par l\'implémentation / fonctionnalités',
+    4: 'Coût d\'entrée / Partie indéniable des affaires / Répandu',
+};
+// Prompt text lives in prompts/anchor-evolution.md. Resolved via getPrompt('anchor-evolution').
+// ─── Response Parsing ──────────────────────────────────────────────────────
+export function parseAnchorResponse(text) {
+    const raw = parseKeyValueBlock(text, ['phase', 'justification', 'confidence']);
+    // Original regex captured only the first digit (/^phase=(\d)/), preserve by taking the first char.
+    const phaseRaw = raw.phase?.[0];
+    if (!phaseRaw || !/\d/.test(phaseRaw)) {
+        throw new Error(`estimateAnchorEvolution: could not parse LLM response: ${text.slice(0, 200)}`);
+    }
+    const phase = parseInt(phaseRaw, 10);
+    if (phase < 1 || phase > 4) {
+        throw new Error(`estimateAnchorEvolution: phase out of range (user=${phase})`);
+    }
+    return {
+        phase,
+        justification: raw.justification ?? '',
+        confidence: raw.confidence !== undefined ? parseFloat(raw.confidence) : 0.5,
+    };
+}
+// ─── Core Evaluation ───────────────────────────────────────────────────────
+// any: args is the raw MCP arguments bag; llmCall is a closure with diverse signatures
+export async function estimateAnchorEvolution(args, llmCall) {
+    const { name, context } = args;
+    let phase, justification, source, confidence;
+    if (args.phase != null) {
+        phase = args.phase;
+        justification = 'Provided by user';
+        source = 'user';
+        confidence = 1.0;
+    }
+    else {
+        const p = getPrompt('anchor-evolution');
+        const built = p.build({ anchor: name, context });
+        // Wrap the LLM call: a failure flips the ambient MCP envelope's
+        // degraded flag and falls back to phase 2 (Custom-built) at low
+        // confidence rather than throwing.
+        const response = await tryDegradeAmbient('llm:anchor-evolution', () => llmCall(built.user, undefined, { systemPrompt: built.system }), '');
+        if (response) {
+            const parsed = p.parse(response);
+            phase = parsed.phase;
+            justification = parsed.justification;
+            source = 'llm';
+            confidence = parsed.confidence;
+        }
+        else {
+            // tryDegradeAmbient returned the empty fallback — record the
+            // recovery decision and use a safe neutral default.
+            phase = 2;
+            justification = 'LLM call failed — defaulting to phase 2 (Custom-built)';
+            source = 'fallback';
+            confidence = 0.2;
+            const collector = getCurrentCollector();
+            if (collector) {
+                collector.record({
+                    source: 'llm:anchor-evolution',
+                    reason: 'LLM returned empty response — using phase 2 fallback',
+                    severity: 'warning',
+                    recoverable: true,
+                });
+            }
+        }
+    }
+    const evolution = PHASE_MIDPOINTS[phase];
+    const stage = evolutionToStage(evolution);
+    return {
+        evolution: parseFloat(evolution.toFixed(3)),
+        confidence,
+        method: 'anchor-perception',
+        name,
+        context,
+        perception: {
+            phase,
+            userDescriptor: USER_PERCEPTION[phase],
+            industryDescriptor: INDUSTRY_PERCEPTION[phase],
+            justification,
+            source,
+        },
+        stage: { name: stage.name, rangeMin: stage.rangeMin, rangeMax: stage.rangeMax },
+    };
+}
+// ─── Core BaseStrategy wrapper class ────────────────────────────────────────
+//
+// Wraps the `estimateAnchorEvolution` function in the core BaseStrategy
+// contract. The function above stays exported for the MCP tool wrapper
+// (`src/mcp/estimate-anchor-evolution.tool.mts`) and the legacy dispatcher.
+// methodId follows the framework convention: this is a write operation
+// against the anchor subdomain, using the consumption-culture phase model.
+import { BaseStrategy as CoreBaseStrategy, } from '#core/ast/base-strategy.mjs';
+import { getStrategyLLM } from '#lib/llm/registry.mjs';
+const NEW_METHOD_ID_ANCHOR = 'wardley:map:climate:position-anchor-in-evolution:culture-phase';
+export class EstimateAnchorEvolutionStrategy extends CoreBaseStrategy {
+    // any: llmCall closure shape is provider-dependent
+    _llmCall;
+    constructor(options = {}) {
+        super();
+        this._llmCall = options.llmCall ?? null;
+    }
+    static get method() {
+        return NEW_METHOD_ID_ANCHOR;
+    }
+    async evaluate(input, _context) {
+        // any: legacy registry id 'anchor-evolution' is not in the StrategyId enum yet.
+        const llmCall = this._llmCall ?? await getStrategyLLM('anchor-evolution');
+        const result = await estimateAnchorEvolution(input, llmCall);
+        const capturedAt = new Date().toISOString();
+        return {
+            signals: [
+                { name: 'name', value: input.name, source: 'user-input', capturedAt },
+                ...(input.context
+                    ? [{ name: 'context', value: input.context, source: 'user-input', capturedAt }]
+                    : []),
+                ...(input.phase != null
+                    ? [{ name: 'phase', value: input.phase, source: 'user-input', capturedAt }]
+                    : []),
+            ],
+            reasoning: [],
+            insights: result.perception?.justification
+                ? [{
+                        text: result.perception.justification,
+                        by: NEW_METHOD_ID_ANCHOR,
+                        type: 'other',
+                        confidence: result.confidence,
+                    }]
+                : [],
+            result,
+        };
+    }
+}
+//# sourceMappingURL=estimate-anchor-evolution.mjs.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/anchor/estimate-anchor-evolution.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate-anchor-evolution.mjs","sourceRoot":"","sources":["../../../../../../../../src/frameworks/wardley/evolution/_legacy/write/strategies/anchor/estimate-anchor-evolution.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/capacity/base-strategy.d.mts

@@ -0,0 +1,72 @@
+import type { EvolutionResult, ComponentInput } from '#types/evolution.mjs';
+import type { EvaluationInput } from '#schemas/inputs.schema.mjs';
+export type { EvolutionResult, ComponentInput };
+/**
+ * @typedef {Object} EvolutionResult
+ * @property {number} evolution  - Evolution position (0–1 competitive, outside = extra-competitive)
+ * @property {number} confidence - Confidence score (0–1)
+ * @property {string} method     - Strategy identifier string
+ * @property {array} trace    - trace of reasoning steps, strategy-specific format (optional)
+ */
+/**
+ * @typedef {Object} ComponentInput
+ * @property {string}  name        - Component name
+ * @property {number}  [certitude] - Certitude score (0–1)
+ * @property {number}  [ubiquity]  - Ubiquity score (0–1)
+ * @property {number}  [wonder]    - Wonder publication proportion
+ * @property {number}  [build]     - Build publication proportion
+ * @property {number}  [operate]   - Operate publication proportion
+ * @property {number}  [usage]     - Usage publication proportion
+ * @property {string}  [description] - Free-text component description
+ * @property {string|Date} [date]    - Optional date for context (e.g. when component is to observe)
+ * @property {string}  [capability] - Underlying capability (activity/practice/knowledge/data) identified by orchestrator
+ * @property {string}  [nature]    - Capability nature: activity|practice|knowledge|data|none
+ * @property {Object}  [metadata]  - Additional strategy-specific data
+ */
+/**
+ * Abstract base class for evolution evaluation strategies.
+ *
+ * Subclasses MUST override:
+ *   - evaluate(component) → EvolutionResult
+ *   - static get method() → string
+ *
+ * The base class enforces the EvolutionResult contract at runtime via
+ * validateResult(), which strategies can call or which is checked by
+ * the evaluation orchestrator.
+ */
+export declare class BaseStrategy {
+    /**
+     * Strategy identifier. Must be overridden by each subclass.
+     * @returns {string}
+     */
+    static get method(): string;
+    /**
+     * Disabled flag. Return falsy to enable (default), or `{ reason: string }`
+     * to disable. The registry filters disabled strategies out of
+     * loadStrategies()/getStrategy()/listStrategies() and exposes them via
+     * listDisabled()/isDisabled(). To disable a strategy, override this getter
+     * in the subclass — no other code changes needed.
+     *
+     * @returns {false | { reason: string }}
+     */
+    static get disabled(): boolean | {
+        reason: string;
+    };
+    /**
+     * Evaluate a component and return its evolution position.
+     * Must be overridden by every strategy.
+     *
+     * @param {ComponentInput} component
+     * @returns {EvolutionResult}
+     */
+    evaluate(component: EvaluationInput): EvolutionResult | Promise<EvolutionResult>;
+    /**
+     * Validate that a result conforms to the EvolutionResult interface.
+     * Throws on invalid shape — call from evaluate() or from the orchestrator.
+     *
+     * @param {*} result
+     * @returns {EvolutionResult} the validated result (pass-through)
+     */
+    static validateResult(result: unknown): EvolutionResult;
+}
+//# sourceMappingURL=base-strategy.d.mts.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/capacity/base-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.d.mts","sourceRoot":"","sources":["../../../../../../../../src/frameworks/wardley/evolution/_legacy/write/strategies/capacity/base-strategy.mts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC;AAEhD;;;;;;GAMG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IAEvB;;;OAGG;IACH,MAAM,KAAK,MAAM,IAAI,MAAM,CAE1B;IAED;;;;;;;;OAQG;IACH,MAAM,KAAK,QAAQ,IAAI,OAAO,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAkB;IAErE;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,eAAe,GAAG,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAIhF;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,eAAe;CAsBxD"}

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/capacity/base-strategy.mjs

@@ -0,0 +1,98 @@
+// Base strategy interface for Wardley Map evolution evaluation
+//
+// Every evaluation strategy must extend BaseStrategy and implement evaluate().
+// Adding a new strategy requires only creating one file — no existing code changes.
+//
+// EvolutionResult shape:
+//   {
+//     evolution:  number,  // Evolution value, typically 0–1 (competitive) or outside (extra-competitive)
+//     confidence: number,  // Confidence score 0–1
+//     method:     string   // Strategy identifier (e.g. 's-curve', 'pub-distribution')
+//   }
+/**
+ * @typedef {Object} EvolutionResult
+ * @property {number} evolution  - Evolution position (0–1 competitive, outside = extra-competitive)
+ * @property {number} confidence - Confidence score (0–1)
+ * @property {string} method     - Strategy identifier string
+ * @property {array} trace    - trace of reasoning steps, strategy-specific format (optional)
+ */
+/**
+ * @typedef {Object} ComponentInput
+ * @property {string}  name        - Component name
+ * @property {number}  [certitude] - Certitude score (0–1)
+ * @property {number}  [ubiquity]  - Ubiquity score (0–1)
+ * @property {number}  [wonder]    - Wonder publication proportion
+ * @property {number}  [build]     - Build publication proportion
+ * @property {number}  [operate]   - Operate publication proportion
+ * @property {number}  [usage]     - Usage publication proportion
+ * @property {string}  [description] - Free-text component description
+ * @property {string|Date} [date]    - Optional date for context (e.g. when component is to observe)
+ * @property {string}  [capability] - Underlying capability (activity/practice/knowledge/data) identified by orchestrator
+ * @property {string}  [nature]    - Capability nature: activity|practice|knowledge|data|none
+ * @property {Object}  [metadata]  - Additional strategy-specific data
+ */
+/**
+ * Abstract base class for evolution evaluation strategies.
+ *
+ * Subclasses MUST override:
+ *   - evaluate(component) → EvolutionResult
+ *   - static get method() → string
+ *
+ * The base class enforces the EvolutionResult contract at runtime via
+ * validateResult(), which strategies can call or which is checked by
+ * the evaluation orchestrator.
+ */
+export class BaseStrategy {
+    /**
+     * Strategy identifier. Must be overridden by each subclass.
+     * @returns {string}
+     */
+    static get method() {
+        throw new Error('BaseStrategy.method must be overridden by subclass');
+    }
+    /**
+     * Disabled flag. Return falsy to enable (default), or `{ reason: string }`
+     * to disable. The registry filters disabled strategies out of
+     * loadStrategies()/getStrategy()/listStrategies() and exposes them via
+     * listDisabled()/isDisabled(). To disable a strategy, override this getter
+     * in the subclass — no other code changes needed.
+     *
+     * @returns {false | { reason: string }}
+     */
+    static get disabled() { return false; }
+    /**
+     * Evaluate a component and return its evolution position.
+     * Must be overridden by every strategy.
+     *
+     * @param {ComponentInput} component
+     * @returns {EvolutionResult}
+     */
+    evaluate(component) {
+        throw new Error(`${this.constructor.name}.evaluate() must be implemented`);
+    }
+    /**
+     * Validate that a result conforms to the EvolutionResult interface.
+     * Throws on invalid shape — call from evaluate() or from the orchestrator.
+     *
+     * @param {*} result
+     * @returns {EvolutionResult} the validated result (pass-through)
+     */
+    static validateResult(result) {
+        if (result === null || typeof result !== 'object') {
+            throw new TypeError('EvolutionResult must be a non-null object');
+        }
+        const { evolution, confidence, method, trace } = result;
+        if (typeof evolution !== 'number' || Number.isNaN(evolution)) {
+            throw new TypeError(`EvolutionResult.evolution must be a number, got ${evolution}`);
+        }
+        if (typeof confidence !== 'number' || Number.isNaN(confidence) ||
+            confidence < 0 || confidence > 1) {
+            throw new TypeError(`EvolutionResult.confidence must be a number in [0, 1], got ${confidence}`);
+        }
+        if (typeof method !== 'string' || method.length === 0) {
+            throw new TypeError(`EvolutionResult.method must be a non-empty string, got ${method}`);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=base-strategy.mjs.map

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/capacity/base-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.mjs","sourceRoot":"","sources":["../../../../../../../../src/frameworks/wardley/evolution/_legacy/write/strategies/capacity/base-strategy.mts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,EAAE;AACF,+EAA+E;AAC/E,oFAAoF;AACpF,EAAE;AACF,yBAAyB;AACzB,MAAM;AACN,0GAA0G;AAC1G,mDAAmD;AACnD,uFAAuF;AACvF,MAAM;AAMN;;;;;;GAMG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,OAAO,YAAY;IAEvB;;;OAGG;IACH,MAAM,KAAK,MAAM;QACf,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IACxE,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,KAAK,QAAQ,KAAmC,OAAO,KAAK,CAAC,CAAC,CAAC;IAErE;;;;;;OAMG;IACH,QAAQ,CAAC,SAA0B;QACjC,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,iCAAiC,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CAAC,MAAe;QACnC,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAClD,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAC;QACnE,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAkC,CAAC;QAEpF,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,SAAS,CAAC,mDAAmD,SAAS,EAAE,CAAC,CAAC;QACtF,CAAC;QACD,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC;YAC1D,UAAU,GAAG,CAAC,IAAI,UAAU,GAAG,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,SAAS,CACjB,8DAA8D,UAAU,EAAE,CAC3E,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,SAAS,CAAC,0DAA0D,MAAM,EAAE,CAAC,CAAC;QAC1F,CAAC;QAED,OAAO,MAAyB,CAAC;IACnC,CAAC;CACF"}

package/dist/frameworks/wardley/evolution/_legacy/write/strategies/capacity/cpc-evolution-strategy.d.mts

@@ -0,0 +1,324 @@
+import { BaseStrategy } from './base-strategy.mjs';
+import type { ComponentInput, EvolutionResult } from '#types/evolution.mjs';
+import type { PatentData } from '#types/patent.mjs';
+/**
+ * Parse the cpc-evolution sot-extraction response.
+ *
+ * Expected format (single line): NAME | DESCRIPTION | EVOLUTION
+ * Returns null when the line is missing or malformed. Caps name/description
+ * lengths at the values the prompt requests (30 / 40 chars). Does NOT clamp
+ * the evolution value — that floor/ceiling is a strategy-level policy applied
+ * by the call-site after this parser returns.
+ */
+export declare function parseCpcSotExtraction(response: string): {
+    name: string;
+    description: string;
+    evolution: number | null;
+} | null;
+/**
+ * Default weights for certitude indicators (must sum to 1.0 when all enabled).
+ * Keys match patent-indicators.mjs function names.
+ * @type {Record<string, { weight: number, enabled: boolean }>}
+ */
+declare const DEFAULT_CERTITUDE_INDICATORS: {
+    convergenceHHI: {
+        weight: number;
+        enabled: boolean;
+    };
+    stabiliteTaxonomique: {
+        weight: number;
+        enabled: boolean;
+    };
+    densiteCitation: {
+        weight: number;
+        enabled: boolean;
+    };
+    retrecissementClaims: {
+        weight: number;
+        enabled: boolean;
+    };
+};
+/**
+ * Default weights for ubiquity indicators (must sum to 1.0 when all enabled).
+ * Keys match patent-indicators.mjs function names.
+ * @type {Record<string, { weight: number, enabled: boolean }>}
+ */
+declare const DEFAULT_UBIQUITY_INDICATORS: {
+    diversiteAssignees: {
+        weight: number;
+        enabled: boolean;
+    };
+    couvertureGeo: {
+        weight: number;
+        enabled: boolean;
+    };
+    diffusionSectorielle: {
+        weight: number;
+        enabled: boolean;
+    };
+    ratioExpires: {
+        weight: number;
+        enabled: boolean;
+    };
+};
+/**
+ * Renormalize weights for enabled indicators so they sum to 1.0.
+ * Disabled indicators are excluded from the sum.
+ *
+ * @param {Record<string, { weight: number, enabled: boolean }>} indicators
+ * @returns {Record<string, number>} Map of indicator name → renormalized weight (enabled only)
+ */
+declare function renormalizeWeights(indicators: any): any;
+/**
+ * Data quality score based on patent count thresholds.
+ * Degrades gracefully with insufficient data.
+ *
+ * @param {number} patentCount - Number of patents found
+ * @returns {number} Data quality score in [0.2, 0.9]
+ */
+declare function computeDataQuality(patentCount: number): number;
+/**
+ * Model confidence based on how well the (certitude, ubiquity) point
+ * fits within the S-curve band.
+ *
+ * @param {Object} scurveResult - Result from computeEvolution()
+ * @returns {number} Model confidence score in [0.3, 0.95]
+ */
+declare function computeModelConfidence(scurveResult: any): number;
+/**
+ * Combined confidence = dataQuality * 0.5 + modelConfidence * 0.5, bounded [0.1, 0.95].
+ *
+ * @param {number} dataQuality - Patent data quality score
+ * @param {number} modelConfidence - S-curve model fit confidence
+ * @returns {number} Bounded confidence score
+ */
+declare function computeConfidence(dataQuality: number, modelConfidence: number): number;
+/**
+ * Aggregate individual indicator values into a single axis score
+ * using renormalized weights.
+ *
+ * @param {Record<string, number>} indicatorValues - Computed indicator values (0-1 each)
+ * @param {Record<string, number>} weights - Renormalized weights (enabled indicators only)
+ * @returns {number} Weighted aggregate score in [0, 1]
+ */
+declare function aggregateAxis(indicatorValues: any, weights: Record<string, number>): number;
+/**
+ * CPC Evolution Strategy: uses patent CPC data to estimate component evolution.
+ *
+ * Extends BaseStrategy for auto-discovery by the plugin system.
+ * Delegates scoring entirely to computeEvolution(certitude, ubiquity) from s-curve.mjs.
+ * Exposes certitude/ubiquity on result for Phase B enrichment.
+ *
+ * @example
+ *   const strategy = new CpcEvolutionStrategy({ llmCall, patentSource });
+ *   const result = await strategy.evaluate({ name: 'Kubernetes', capability: 'container orchestration' });
+ *   // result.evolution, result.confidence, result.certitude, result.ubiquity
+ */
+export declare class CpcEvolutionStrategy extends BaseStrategy {
+    /**
+     * @param {Object} [options]
+     * @param {function(string): Promise<string>} [options.llmCall]
+     *   Async LLM call for CPC mapper (falls back to hardcoded mappings if absent).
+     * @param {import('#lib/patent/patent-data-source.mjs').PatentDataSource} [options.patentSource]
+     *   Patent data source (defaults to BigQueryPatentSource from env vars).
+     * @param {import('../../patent/cpc-mapper.mjs').CpcMapper} [options.cpcMapper]
+     *   CPC code mapper (defaults to LLM-assisted + hardcoded fallback).
+     * @param {Object} [options.config]
+     *   Configuration overrides.
+     * @param {Record<string, { weight?: number, enabled?: boolean }>} [options.config.certitudeIndicators]
+     *   Override certitude indicator weights/toggles.
+     * @param {Record<string, { weight?: number, enabled?: boolean }>} [options.config.ubiquityIndicators]
+     *   Override ubiquity indicator weights/toggles.
+     */
+    _llmCall: any;
+    _patentSource: any;
+    _cpcMapper: any;
+    _certitudeIndicators: any;
+    _ubiquityIndicators: any;
+    constructor(options?: any);
+    /** @returns {string} Strategy identifier for registry. */
+    static get method(): string;
+    /**
+     * Evaluate a component's evolution using patent CPC data.
+     *
+     * Pipeline:
+     *   1. Map component capability to CPC codes
+     *   2. Fetch patent data via PatentDataSource
+     *   3. Compute 8 indicators (pure functions)
+     *   4. Aggregate into (certitude, ubiquity)
+     *   5. Delegate to computeEvolution(c, u)
+     *   6. Build confidence from data quality + model fit
+     *
+     * **GUARANTEE: Always returns a valid EvolutionResult — never throws, never
+     * returns null.** When data is missing, unavailable, or any internal error
+     * occurs, the strategy degrades gracefully to a low-confidence result with
+     * neutral (0.5, 0.5) defaults. Phase B enrichment in estimate-evolution.mjs
+     * uses the confidence score to weight this strategy's contribution alongside
+     * other strategies, so low confidence naturally reduces its influence on the
+     * final evolution estimate without requiring abstention.
+     *
+     * Degradation tiers:
+     *   - No CPC codes found → neutral indicators (0.5), confidence ≈ 0.25
+     *   - No patents found   → neutral indicators (0.5), confidence ≈ 0.25
+     *   - <10 patents        → real indicators, confidence 0.25–0.45
+     *   - 10–100 patents     → real indicators, confidence 0.45–0.65
+     *   - >100 patents       → real indicators, confidence 0.55–0.95
+     *   - Unexpected error    → fallback result, confidence = 0.1 (minimum)
+     *
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @returns {Promise<import('./base-strategy.mjs').EvolutionResult & { certitude: number, ubiquity: number }>}
+     */
+    evaluate(component: ComponentInput): Promise<EvolutionResult>;
+    /**
+     * Internal evaluation pipeline — separated from evaluate() so the top-level
+     * safety net can catch any unexpected error without duplicating fallback logic.
+     *
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @returns {Promise<import('./base-strategy.mjs').EvolutionResult & { certitude: number, ubiquity: number }>}
+     * @private
+     */
+    _evaluateInternal(component: any): Promise<any>;
+    /**
+     * Build a minimal valid fallback result when the pipeline fails unexpectedly.
+     *
+     * Uses neutral (0.5, 0.5) inputs to computeEvolution so the evolution score
+     * is still derived from the calibrated S-curve model (no custom scoring bypass).
+     * Confidence is set to the minimum (0.1) so Phase B enrichment weighting
+     * naturally deprioritizes this result.
+     *
+     * @param {Error} err - The error that triggered the fallback
+     * @returns {import('./base-strategy.mjs').EvolutionResult & { certitude: number, ubiquity: number }}
+     * @private
+     */
+    _buildFallbackResult(err: unknown): any;
+    /**
+     * Enable or disable an individual indicator at runtime.
+     * Weights are automatically renormalized on next evaluate() call.
+     *
+     * @param {'certitude'|'ubiquity'} axis - Which axis the indicator belongs to
+     * @param {string} key - Indicator key (e.g. 'convergenceHHI', 'diversiteAssignees')
+     * @param {boolean} enabled - Whether to enable or disable the indicator
+     * @throws {Error} If the indicator key is not found on the given axis
+     */
+    setIndicatorEnabled(axis: string, key: string, enabled: boolean): void;
+    /**
+     * Bulk-update indicator enabled/disabled flags.
+     * Accepts a map of indicator key → boolean for each axis.
+     * Keys not present in the map are left unchanged.
+     *
+     * @param {Object} toggles
+     * @param {Record<string, boolean>} [toggles.certitude] - Certitude indicator toggles
+     * @param {Record<string, boolean>} [toggles.ubiquity] - Ubiquity indicator toggles
+     */
+    setIndicatorsEnabled(toggles?: any): void;
+    /**
+     * Get the current indicator configuration for both axes.
+     * Includes raw weights, enabled status, and renormalized weights.
+     *
+     * @returns {{
+     *   certitude: Array<{key: string, weight: number, enabled: boolean, weightNormalized: number}>,
+     *   ubiquity: Array<{key: string, weight: number, enabled: boolean, weightNormalized: number}>,
+     * }}
+     */
+    getIndicatorConfig(): {
+        certitude: {
+            key: string;
+            weight: any;
+            enabled: any;
+            weightNormalized: any;
+        }[];
+        ubiquity: {
+            key: string;
+            weight: any;
+            enabled: any;
+            weightNormalized: any;
+        }[];
+    };
+    /**
+     * Get only the renormalized weights for currently enabled indicators.
+     * Useful for inspecting what weights will be used in the next evaluate() call.
+     *
+     * @returns {{
+     *   certitude: Record<string, number>,
+     *   ubiquity: Record<string, number>,
+     * }}
+     */
+    getActiveWeights(): {
+        certitude: any;
+        ubiquity: any;
+    };
+    /**
+     * Reset indicator configuration to defaults (all enabled, original weights).
+     */
+    resetIndicatorConfig(): void;
+    /**
+     * Generate a .wm pipeline insight showing the evaluated component
+     * within its underlying capability pipeline.
+     *
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @param {number} evolution - Computed evolution score
+     * @param {Array<{code: string, title: string}>} cpcTitles - CPC codes with titles
+     * @returns {Promise<string>} .wm format snippet
+     * @private
+     */
+    _generatePipelineInsight(component: any, evolution: number, cpcTitles: any): Promise<any>;
+    /**
+     * Derive a clean capability name from CPC titles or component data.
+     * @private
+     */
+    _deriveCapabilityName(component: any, cpcTitles: any): string;
+    /**
+     * Ask the LLM for a concrete state-of-the-art example in the CPC domain.
+     * @private
+     */
+    _getStateOfArtExample(component: any, evolution: number, cpcTitles: any): Promise<any>;
+    /**
+     * Resolve CPC codes from component capability via CPC mapper.
+     * Uses progressive discovery (LLM + taxonomy cache) when available.
+     * Falls back to empty array if no mapper available (confidence will be low).
+     *
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @returns {Promise<string[]>} Array of CPC codes (variable length)
+     */
+    _resolveCpcCodes(component: any): Promise<any>;
+    /**
+     * Fetch patent data from the configured data source.
+     * Returns a minimal stub if no data source is available.
+     *
+     * @param {string[]} cpcCodes
+     * @returns {Promise<Object>} Patent data object
+     */
+    _fetchPatentData(cpcCodes: string[]): Promise<any>;
+    /**
+     * Compute all 8 indicators using pure functions from patent-indicators.mjs.
+     * Uses computeAllIndicators() which takes raw patentData and returns both axes.
+     * Returns values split into certitude and ubiquity axes for aggregation.
+     *
+     * @param {Object} patentData - Raw patent data from data source
+     * @param {string[]} cpcCodes - CPC codes used for the query
+     * @returns {Promise<{ certitude: Record<string, number>, ubiquity: Record<string, number> }>}
+     */
+    _computeIndicators(patentData: PatentData, cpcCodes: string[]): Promise<any>;
+}
+/**
+ * Merge user indicator config overrides with defaults.
+ * Preserves default weights/enabled unless explicitly overridden.
+ *
+ * @param {Record<string, { weight: number, enabled: boolean }>} defaults
+ * @param {Record<string, { weight?: number, enabled?: boolean }>} [overrides]
+ * @returns {Record<string, { weight: number, enabled: boolean }>}
+ */
+declare function mergeIndicatorConfig(defaults: any, overrides: any): any;
+export { DEFAULT_CERTITUDE_INDICATORS, DEFAULT_UBIQUITY_INDICATORS, renormalizeWeights, computeDataQuality, computeModelConfidence, computeConfidence, aggregateAxis, mergeIndicatorConfig, };
+import { BaseStrategy as CoreBaseStrategy, type StrategyResult } from '#core/ast/base-strategy.mjs';
+import type { RequestContext } from '#core/context/request-context.mjs';
+import type { LLMCall } from '#types/llm.mjs';
+export declare class CpcEvolutionStrategyCore extends CoreBaseStrategy<ComponentInput, EvolutionResult> {
+    private readonly _llmCall;
+    constructor(options?: {
+        llmCall?: LLMCall;
+    });
+    static get method(): string;
+    evaluate(component: ComponentInput, _context: RequestContext): Promise<StrategyResult<EvolutionResult>>;
+}
+//# sourceMappingURL=cpc-evolution-strategy.d.mts.map