labre-mcp 0.1.0

package/dist/work-on-evolution/write/strategies/anchor/estimate-anchor-evolution.mjs

@@ -0,0 +1,125 @@
+// 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)
+//
+// Exposes an MCP tool (estimateAnchorEvolution) for direct invocation.
+import { z } from 'zod';
+import { EstimateAnchorEvolutionInputSchema } from '../../../../schemas/estimate-anchor-evolution.schema.mjs';
+import { getStrategyLLM } from '../../../../lib/llm/registry.mjs';
+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 },
+    };
+}
+// ─── MCP Tool Definition ───────────────────────────────────────────────────
+export const ESTIMATE_ANCHOR_EVOLUTION_TOOL = {
+    name: 'estimateAnchorEvolution',
+    description: 'Estimate the evolution position of an anchor (user need / stakeholder) in a Wardley Map. ' +
+        'Unlike components evaluated by technical maturity, anchors are evaluated through ' +
+        'the consumption culture lens (user perception + industry perception). ' +
+        'The LLM determines a single evolution phase (1–4, Genesis → Commodity). ' +
+        'A phase can be provided directly to skip LLM assessment.',
+    inputSchema: z.toJSONSchema(EstimateAnchorEvolutionInputSchema, { io: 'input' }),
+};
+export async function handleEstimateAnchorEvolution(args) {
+    const input = EstimateAnchorEvolutionInputSchema.parse(args);
+    return estimateAnchorEvolution(input, getStrategyLLM('anchor-evolution'));
+}
+//# sourceMappingURL=estimate-anchor-evolution.mjs.map

package/dist/work-on-evolution/write/strategies/anchor/estimate-anchor-evolution.mjs.map

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

package/dist/work-on-evolution/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/work-on-evolution/write/strategies/capacity/base-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.d.mts","sourceRoot":"","sources":["../../../../../src/work-on-evolution/write/strategies/capacity/base-strategy.mts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACvF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAC7E,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/work-on-evolution/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/work-on-evolution/write/strategies/capacity/base-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-strategy.mjs","sourceRoot":"","sources":["../../../../../src/work-on-evolution/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/work-on-evolution/write/strategies/capacity/cpc-evolution-strategy.d.mts

@@ -0,0 +1,313 @@
+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, };
+//# sourceMappingURL=cpc-evolution-strategy.d.mts.map

package/dist/work-on-evolution/write/strategies/capacity/cpc-evolution-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpc-evolution-strategy.d.mts","sourceRoot":"","sources":["../../../../../src/work-on-evolution/write/strategies/capacity/cpc-evolution-strategy.mts"],"names":[],"mappings":"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"}