labre-mcp 0.1.0

package/dist/work-on-evolution/strategies/capacity/s-curve-strategy.mjs

@@ -0,0 +1,44 @@
+// S-curve strategy: wraps the existing dual generalized sigmoid model
+// (certitude, ubiquity) → evolution via geometric projection onto the center curve
+//
+// This is the primary deterministic/analytical strategy.
+// Requires: certitude, ubiquity inputs on the component.
+import { BaseStrategy } from './base-strategy.mjs';
+import { computeEvolution } from '../../s-curve/s-curve.mjs';
+export class SCurveStrategy extends BaseStrategy {
+    static get method() {
+        return 's-curve';
+    }
+    /**
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @returns {import('./base-strategy.mjs').EvolutionResult}
+     */
+    evaluate(component) {
+        const { certitude, ubiquity } = component;
+        if (certitude == null || ubiquity == null) {
+            throw new Error('SCurveStrategy requires certitude and ubiquity inputs');
+        }
+        const result = computeEvolution(certitude, ubiquity);
+        // Confidence: constant inside band, logarithmic decay outside.
+        // Discontinuous gap at boundary signals clearly that the point left the valid zone.
+        // Distance is Euclidean to the center sigmoid (not vertical to band edge).
+        let confidence;
+        if (result.zone === 'competitive') {
+            confidence = 0.9;
+        }
+        else {
+            // Outside band: logarithmic decay from 0.90 (continuous), using Euclidean distance to center sigmoid
+            const k = 2.0;
+            const scale = 0.2;
+            confidence = Math.max(0.05, 0.9 / (1 + k * Math.log(1 + result.distToCenter / scale)));
+        }
+        confidence = Math.round(confidence * 1000) / 1000;
+        const validated = BaseStrategy.validateResult({
+            evolution: result.evolution,
+            confidence,
+            method: SCurveStrategy.method,
+        });
+        return validated;
+    }
+}
+//# sourceMappingURL=s-curve-strategy.mjs.map

package/dist/work-on-evolution/strategies/capacity/s-curve-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"s-curve-strategy.mjs","sourceRoot":"","sources":["../../../../src/work-on-evolution/strategies/capacity/s-curve-strategy.mts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,mFAAmF;AACnF,EAAE;AACF,yDAAyD;AACzD,yDAAyD;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,OAAO,cAAe,SAAQ,YAAY;IAE9C,MAAM,KAAK,MAAM;QACf,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,SAAyB;QAChC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC;QAE1C,IAAI,SAAS,IAAI,IAAI,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAErD,+DAA+D;QAC/D,oFAAoF;QACpF,2EAA2E;QAC3E,IAAI,UAAU,CAAC;QACf,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YAClC,UAAU,GAAG,GAAG,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,qGAAqG;YACrG,MAAM,CAAC,GAAG,GAAG,CAAC;YACd,MAAM,KAAK,GAAG,GAAG,CAAC;YAClB,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACzF,CAAC;QACD,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QAElD,MAAM,SAAS,GAAG,YAAY,CAAC,cAAc,CAAC;YAC5C,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,UAAU;YACV,MAAM,EAAE,cAAc,CAAC,MAAM;SAC9B,CAAC,CAAC;QAEH,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

package/dist/work-on-evolution/strategies/capacity/timeline-benchmark-strategy.d.mts

@@ -0,0 +1,52 @@
+import { BaseStrategy } from './base-strategy.mjs';
+import type { ComponentInput, EvolutionResult } from '../../../types/evolution.mjs';
+import type { ParsedHistoryIteration } from '../../../schemas/parsed-llm.schema.mjs';
+interface TimelineMilestone {
+    name: string;
+    date: number;
+    evolution: number;
+    confidence: number;
+}
+/**
+ * Parse a single history iteration response from the LLM.
+ * @param {string} text
+ * @returns {{ name: string, date: number }}
+ */
+export declare function parseHistoryIterationResponse(text: string): ParsedHistoryIteration;
+/**
+ * Format the accumulated history into a text section for the next prompt.
+ * @param {Array<{ name: string, date: number, evolution: number, confidence: number }>} history
+ * @returns {string}
+ */
+export declare function formatHistorySection(history: TimelineMilestone[]): string;
+/**
+ * Generate adaptive pacing guidance so the LLM spaces milestones to reach the present.
+ * @param {Array<{ date: number }>} history
+ * @param {number} iteration - current iteration index (0-based)
+ * @param {number} maxIterations
+ * @returns {string}
+ */
+export declare function formatPacingGuidance(history: TimelineMilestone[], iteration: number, maxIterations: number): string;
+/**
+ * Compute confidence from the richness, internal consistency, and LLM-direct confidence of the timeline.
+ * @param {Array<{ name: string, date: number, evolution: number, confidence: number }>} history
+ * @returns {number} confidence in [0.2, 0.95]
+ */
+export declare function computeTimelineConfidence(history: TimelineMilestone[]): number;
+export declare class TimelineBenchmarkStrategy extends BaseStrategy {
+    _llmCall: any;
+    constructor({ llmCall }?: {
+        llmCall?: any;
+    });
+    static get method(): string;
+    static get disabled(): {
+        reason: string;
+    };
+    /**
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @returns {Promise<import('./base-strategy.mjs').EvolutionResult>}
+     */
+    evaluate(component: ComponentInput): Promise<EvolutionResult>;
+}
+export {};
+//# sourceMappingURL=timeline-benchmark-strategy.d.mts.map

package/dist/work-on-evolution/strategies/capacity/timeline-benchmark-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-benchmark-strategy.d.mts","sourceRoot":"","sources":["../../../../src/work-on-evolution/strategies/capacity/timeline-benchmark-strategy.mts"],"names":[],"mappings":"AAYA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAErF,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAaD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAelF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,MAAM,CASzE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAgBnH;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,MAAM,CAgC9E;AAED,qBAAa,yBAA0B,SAAQ,YAAY;IAEzD,QAAQ,EAAE,GAAG,CAAC;gBAEF,EAAE,OAAO,EAAE,GAAE;QAAE,OAAO,CAAC,EAAE,GAAG,CAAA;KAAO;IAK/C,MAAM,KAAK,MAAM,WAEhB;IAED,MAAM,KAAK,QAAQ;;MAIlB;IAED;;;OAGG;IACG,QAAQ,CAAC,SAAS,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;CA6GpE"}

package/dist/work-on-evolution/strategies/capacity/timeline-benchmark-strategy.mjs

@@ -0,0 +1,226 @@
+// Timeline benchmark strategy: evolution estimation based on historical
+// capability analysis and iterative timeline reconstruction.
+//
+// Phase 1: Capability Identification — looks behind technical labels to
+//          identify the true underlying capability or need
+//          (delegated to src/tools/identify-capability.mjs)
+// Phase 2: Recursive Historical Timeline — iteratively builds a chronological
+//          timeline of solutions/manifestations until the current year,
+//          each milestone evaluated by LLMDirectStrategy with date context
+//
+// Requires llmCall injection (shared with LLMDirectStrategy internally).
+import { BaseStrategy } from './base-strategy.mjs';
+import { identifyCapability } from '../../../work-on-value-chain/identify-capability.mjs';
+import { LLMDirectStrategy } from './llm-direct-strategy.mjs';
+import { parseKeyValueBlock } from '../../../lib/prompts/parsers.mjs';
+import { getPrompt } from '../../../lib/prompts/registry.mjs';
+const CURRENT_YEAR = new Date().getFullYear();
+const MAX_HISTORY_ITERATIONS = 15;
+// Prompt text lives in prompts/timeline-benchmark.md. Resolved via getPrompt().
+// The {{current_year}} placeholder replaces the former ${CURRENT_YEAR} template
+// literal (same resolved value — CURRENT_YEAR is passed in via build()).
+/**
+ * Parse a single history iteration response from the LLM.
+ * @param {string} text
+ * @returns {{ name: string, date: number }}
+ */
+export function parseHistoryIterationResponse(text) {
+    const raw = parseKeyValueBlock(text, ['milestone_name', 'milestone_date'], { separator: 'any', anchored: false });
+    // Extract leading integer from milestone_date to preserve original /(\d+)/ behavior
+    // (tolerates trailing commentary like "1969 (moon landing)")
+    const dateDigits = raw.milestone_date?.match(/\d+/)?.[0];
+    if (raw.milestone_name === undefined || !dateDigits) {
+        throw new Error(`TimelineBenchmarkStrategy: could not parse history iteration: ${text.slice(0, 200)}`);
+    }
+    return {
+        name: raw.milestone_name,
+        date: parseInt(dateDigits, 10),
+    };
+}
+/**
+ * Format the accumulated history into a text section for the next prompt.
+ * @param {Array<{ name: string, date: number, evolution: number, confidence: number }>} history
+ * @returns {string}
+ */
+export function formatHistorySection(history) {
+    if (history.length === 0) {
+        return 'History so far: (none — identify the GENESIS-ERA origin: the EARLIEST known form of this capability, when it was first conceived or rudimentarily practiced. This should be in the Genesis stage of evolution: novel, poorly understood, rare.)';
+    }
+    const lines = history.map((h) => `- ${h.name} (${h.date}): evolution=${h.evolution}`);
+    const last = history[history.length - 1];
+    return `History so far (chronological):\n${lines.join('\n')}\n\nContinue from after ${last.name} (${last.date}).`;
+}
+/**
+ * Generate adaptive pacing guidance so the LLM spaces milestones to reach the present.
+ * @param {Array<{ date: number }>} history
+ * @param {number} iteration - current iteration index (0-based)
+ * @param {number} maxIterations
+ * @returns {string}
+ */
+export function formatPacingGuidance(history, iteration, maxIterations) {
+    const remaining = maxIterations - iteration - 1;
+    const lastDate = history.length > 0 ? history[history.length - 1].date : null;
+    const yearsToGo = lastDate != null ? CURRENT_YEAR - lastDate : null;
+    if (remaining <= 1) {
+        return `FINAL ITERATION: This must be the current or most recent manifestation of this capability in ${CURRENT_YEAR}.`;
+    }
+    if (remaining <= 3) {
+        return `IMPORTANT: Only ${remaining} iterations remain to reach ${CURRENT_YEAR}. ${yearsToGo != null ? `You still need to cover ~${yearsToGo} years. ` : ''}Your next milestone should jump significantly forward in time.`;
+    }
+    if (lastDate != null && yearsToGo != null && yearsToGo > 0) {
+        const avgGap = Math.ceil(yearsToGo / remaining);
+        return `PACING: ${remaining} iterations remaining to reach ${CURRENT_YEAR}. Last milestone was in ${lastDate} (~${yearsToGo} years to go). Aim for roughly ${avgGap}-year gaps between milestones.`;
+    }
+    return '';
+}
+/**
+ * Compute confidence from the richness, internal consistency, and LLM-direct confidence of the timeline.
+ * @param {Array<{ name: string, date: number, evolution: number, confidence: number }>} history
+ * @returns {number} confidence in [0.2, 0.95]
+ */
+export function computeTimelineConfidence(history) {
+    if (history.length === 0)
+        return 0.2;
+    // Factor 1: iteration richness (more milestones = more grounded)
+    const iterationFactor = Math.min(history.length / MAX_HISTORY_ITERATIONS, 1);
+    // Factor 2: monotonicity of evolution values
+    let monotonicSteps = 0;
+    for (let i = 1; i < history.length; i++) {
+        if (history[i].evolution >= history[i - 1].evolution) {
+            monotonicSteps++;
+        }
+    }
+    const monotonicityFactor = history.length > 1
+        ? monotonicSteps / (history.length - 1)
+        : 1;
+    // Factor 3: average confidence from LLM-direct evaluations
+    const avgLlmConfidence = history.reduce((s, h) => s + h.confidence, 0) / history.length;
+    // Factor 4: temporal coverage — did the timeline reach the present?
+    const firstDate = history[0].date;
+    const lastDate = history[history.length - 1].date;
+    const totalSpan = CURRENT_YEAR - firstDate;
+    const coveredSpan = lastDate - firstDate;
+    const coverageFactor = totalSpan > 0 ? Math.min(coveredSpan / totalSpan, 1) : 0;
+    return Math.round(Math.max(0.2, Math.min(0.95, iterationFactor * 0.15 + monotonicityFactor * 0.20 + avgLlmConfidence * 0.40 + coverageFactor * 0.20 + 0.05)) * 1000) / 1000;
+}
+export class TimelineBenchmarkStrategy extends BaseStrategy {
+    // any: LLM closure injected via DI — diverse backend signatures
+    _llmCall;
+    constructor({ llmCall } = {}) {
+        super();
+        this._llmCall = llmCall || null;
+    }
+    static get method() {
+        return 'timeline-benchmark';
+    }
+    static get disabled() {
+        return {
+            reason: 'High LLM latency (>30 min/run) — disabled pending optimization',
+        };
+    }
+    /**
+     * @param {import('./base-strategy.mjs').ComponentInput} component
+     * @returns {Promise<import('./base-strategy.mjs').EvolutionResult>}
+     */
+    async evaluate(component) {
+        if (!this._llmCall) {
+            throw new Error('TimelineBenchmarkStrategy requires an llmCall function');
+        }
+        // ── Phase 1: Capability Identification (skip if pre-identified by orchestrator)
+        const capability = component.capability
+            ? { capability: component.capability, nature: component.nature || 'none' }
+            : await identifyCapability(component, this._llmCall);
+        // ── Phase 2: Recursive Historical Timeline Loop ─────────────────
+        const llmDirect = new LLMDirectStrategy({ llmCall: this._llmCall });
+        const history = []; // Array<{ name, date, evolution, confidence, certitude, ubiquity }>
+        for (let i = 0; i < MAX_HISTORY_ITERATIONS; i++) {
+            const historySection = formatHistorySection(history);
+            const pacingGuidance = formatPacingGuidance(history, i, MAX_HISTORY_ITERATIONS);
+            const tb = getPrompt('timeline-benchmark');
+            const iterationPrompt = tb.build({
+                capability: capability.capability,
+                component: component.name || '',
+                description: component.description ?? '',
+                context: component.context ?? '',
+                current_year: String(CURRENT_YEAR),
+                history_section: historySection,
+                pacing_guidance: pacingGuidance,
+            });
+            let milestone;
+            try {
+                const response = await this._llmCall(iterationPrompt);
+                milestone = tb.parse(response);
+            }
+            catch (err) {
+                // If LLM fails mid-loop and we have at least one result, use it
+                if (history.length > 0)
+                    break;
+                throw err;
+            }
+            // Evaluate evolution of the capability (not the milestone name) at the milestone date
+            let evoResult;
+            try {
+                evoResult = await llmDirect.evaluate({
+                    kind: 'capability',
+                    name: milestone.name,
+                    capability: capability.capability,
+                    nature: capability.nature,
+                    description: component.description,
+                    context: component.context,
+                    date: milestone.date,
+                });
+            }
+            catch (err) {
+                if (history.length > 0)
+                    break;
+                throw err;
+            }
+            history.push({
+                name: milestone.name,
+                date: milestone.date,
+                evolution: evoResult.evolution,
+                confidence: evoResult.confidence,
+            });
+            // Termination: reached current year
+            if (milestone.date >= CURRENT_YEAR) {
+                break;
+            }
+        }
+        // ── Fallback: force present-day evaluation if loop didn't reach current year
+        if (history.length > 0 && history[history.length - 1].date < CURRENT_YEAR) {
+            try {
+                const presentResult = await llmDirect.evaluate({
+                    kind: 'capability',
+                    name: component.name || capability.capability,
+                    capability: capability.capability,
+                    nature: capability.nature,
+                    description: component.description,
+                    context: component.context,
+                    date: CURRENT_YEAR,
+                });
+                history.push({
+                    name: `${component.name || capability.capability} (${CURRENT_YEAR})`,
+                    date: CURRENT_YEAR,
+                    evolution: presentResult.evolution,
+                    confidence: presentResult.confidence,
+                    _fallback: true,
+                });
+            }
+            catch {
+                // If fallback fails, proceed with accumulated history
+            }
+        }
+        // ── Compute final result ────────────────────────────────────────
+        const lastMilestone = history[history.length - 1];
+        const evolution = Math.round(Math.max(0, Math.min(1, lastMilestone.evolution)) * 1000) / 1000;
+        const confidence = computeTimelineConfidence(history);
+        const result = {
+            evolution,
+            confidence,
+            method: TimelineBenchmarkStrategy.method,
+            trace: history,
+        };
+        return BaseStrategy.validateResult(result);
+    }
+}
+//# sourceMappingURL=timeline-benchmark-strategy.mjs.map

package/dist/work-on-evolution/strategies/capacity/timeline-benchmark-strategy.mjs.map

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

package/dist/work-on-evolution/strategies/solution/aggregate-properties.d.mts

@@ -0,0 +1,197 @@
+/**
+ * Map discrete phase (1–4) to continuous evolution midpoint on the Wardley axis.
+ * @type {Readonly<Record<number, number>>}
+ */
+declare const PHASE_TO_EVOLUTION: Record<number, number>;
+export { PHASE_TO_EVOLUTION };
+/** Standard property count in the Wardley evolution reference model. */
+export declare const STANDARD_PROPERTY_COUNT = 12;
+/** Default weight per property (equal weighting). */
+export declare const DEFAULT_WEIGHT: number;
+/** Maximum confidence when all properties are evaluated with full coverage. */
+export declare const MAX_BASE_CONFIDENCE = 0.85;
+/** Minimum confidence floor (even with very poor coverage). */
+export declare const MIN_CONFIDENCE = 0.1;
+/** Maximum overall confidence cap (prevent over-confidence). */
+export declare const MAX_CONFIDENCE = 0.95;
+/**
+ * @typedef {Object} PropertyWeightConfig
+ * @property {number}  weight   - Base weight for this property
+ * @property {boolean} enabled  - Whether the property participates in aggregation
+ */
+/**
+ * Renormalize weights for enabled properties so they sum to 1.0.
+ * Disabled properties are excluded entirely from the aggregation.
+ *
+ * This is the solution-strategies equivalent of the patent indicator
+ * toggle pattern in cpc-evolution-strategy.mjs.
+ *
+ * @param {Record<string, PropertyWeightConfig>} weightConfig
+ *   Map of property identifier → { weight, enabled }.
+ *   Identifiers can be property names or IDs.
+ * @returns {Record<string, number>}
+ *   Map of enabled property identifier → renormalized weight.
+ *   Empty map if all properties are disabled.
+ *
+ * @example
+ *   const config = {
+ *     market:               { weight: 1/12, enabled: true },
+ *     knowledge_management: { weight: 1/12, enabled: true },
+ *     efficiency:           { weight: 1/12, enabled: false },
+ *     // ...
+ *   };
+ *   const weights = renormalizeWeights(config);
+ *   // efficiency excluded, others get proportionally higher weights summing to 1.0
+ */
+export declare function renormalizeWeights(weightConfig: any): any;
+/**
+ * Build a weight configuration map from an array of property evaluations,
+ * optionally applying a disabled list and custom weight overrides.
+ *
+ * @param {Array<{ property: string, phase: number, weight?: number }>} properties
+ *   Array of per-property evaluations.
+ * @param {Object} [options={}]
+ * @param {string[]}  [options.disabled=[]]      - Property names/IDs to disable
+ * @param {Record<string, number>} [options.customWeights={}] - Custom weight overrides by property name/ID
+ * @returns {Record<string, PropertyWeightConfig>}
+ */
+export declare function buildWeightConfig(properties: any, options?: any): any;
+/**
+ * @typedef {Object} AggregationResult
+ * @property {number}  evolution   - Weighted average evolution position (0–1)
+ * @property {number}  confidence  - Aggregation confidence score (0–1)
+ * @property {Record<string, number>} weightMap
+ *   Final normalized weights used (after toggling/renormalization)
+ * @property {AggregationMetadata} metadata
+ *   Detailed metadata about the aggregation computation
+ */
+/**
+ * @typedef {Object} AggregationMetadata
+ * @property {number}  totalProperties     - Total input properties
+ * @property {number}  enabledProperties   - Properties participating in aggregation
+ * @property {number}  disabledProperties  - Properties excluded from aggregation
+ * @property {number}  validProperties     - Properties with valid phases (1–4)
+ * @property {number}  coverage            - Ratio of valid/enabled to total standard (0–1)
+ * @property {string}  aggregationMethod   - Method identifier: 'weighted_average'
+ * @property {number}  phaseAgreement      - Inter-property phase consistency (0–1)
+ * @property {{ 1: number, 2: number, 3: number, 4: number }} phaseDistribution
+ *   Count of properties at each phase
+ * @property {number}  meanPhase           - Mean phase across evaluated properties
+ * @property {number}  weightedPhase       - Weighted mean phase
+ * @property {boolean} renormalized        - Whether weight renormalization was applied
+ */
+/**
+ * Aggregate per-property phase evaluations into a single evolution placement.
+ *
+ * This is the primary aggregation function for solution evaluation. It takes
+ * an array of per-property phase scores and computes:
+ *   1. Weighted average of phase midpoints → overall evolution value
+ *   2. Coverage-based confidence score
+ *   3. Detailed aggregation metadata
+ *
+ * Default behavior: equal weights (1/N), all properties enabled.
+ *
+ * Advanced behavior (CPC indicator toggle pattern):
+ *   - Disable specific properties via `options.disabled`
+ *   - Override weights via `options.customWeights`
+ *   - Remaining weights are renormalized to sum to 1.0
+ *
+ * @param {Array<{ property: string, phase: number, weight?: number, id?: string }>} properties
+ *   Array of per-property evaluations. Each must have:
+ *     - property: Property name (e.g. "Market")
+ *     - phase: Evaluated phase (1–4)
+ *     - weight: Optional custom weight (default: 1/N)
+ *     - id: Optional canonical property ID
+ *
+ * @param {Object} [options={}]
+ * @param {string[]}  [options.disabled=[]]
+ *   Property names/IDs to exclude from aggregation. Weights are renormalized.
+ * @param {Record<string, number>} [options.customWeights={}]
+ *   Override weights by property name/ID. Applied before renormalization.
+ * @param {number}  [options.totalExpected=12]
+ *   Total expected properties (for coverage calculation). Default: 12.
+ *
+ * @returns {AggregationResult}
+ *   The aggregated evolution result with confidence and metadata.
+ *
+ * @throws {Error} If properties array is empty or all properties are disabled.
+ *
+ * @example
+ *   // Basic: all 12 properties with equal weights
+ *   const result = aggregatePropertyScores([
+ *     { property: 'Market', phase: 3 },
+ *     { property: 'Knowledge management', phase: 3 },
+ *     // ... 10 more
+ *   ]);
+ *   // → { evolution: 0.55, confidence: 0.85, ... }
+ *
+ * @example
+ *   // With toggling: disable two properties
+ *   const result = aggregatePropertyScores(allProperties, {
+ *     disabled: ['efficiency', 'decision_driver'],
+ *   });
+ *   // Remaining 10 properties have renormalized weights summing to 1.0
+ *
+ * @example
+ *   // With custom weights: emphasize market properties
+ *   const result = aggregatePropertyScores(allProperties, {
+ *     customWeights: { market: 0.2, market_perception: 0.15 },
+ *   });
+ */
+export declare function aggregatePropertyScores(properties: Array<{
+    property?: string;
+    phase: number;
+    weight?: number;
+    reason?: string;
+    confidence?: number | null;
+    id?: string;
+}>, options?: {
+    mode?: string;
+    method?: string;
+    weightConfig?: Record<string, number>;
+    totalExpected?: number;
+    disabled?: string[];
+    customWeights?: Record<string, number>;
+}): any;
+/**
+ * Compute phase agreement metric using normalized entropy.
+ *
+ * 0 = all properties at the same phase (maximum agreement)
+ * 1 = perfectly uniform distribution across all 4 phases (minimum agreement)
+ *
+ * RETURNS: inverted (1 = max agreement, 0 = uniform distribution)
+ *
+ * @param {{ 1: number, 2: number, 3: number, 4: number }} distribution
+ * @param {number} total - Total count of evaluated properties
+ * @returns {number} Phase agreement score (0–1), where 1 = perfect agreement
+ */
+export declare function computePhaseAgreement(distribution: Record<number, number>, total: number): number;
+/**
+ * Aggregate an array of PropertyScore instances (from solution-evolution-result.mjs).
+ *
+ * This is a convenience wrapper around aggregatePropertyScores that accepts
+ * PropertyScore instances directly, using their toPropertyEvaluation() method
+ * for the aggregation input.
+ *
+ * @param {Array<import('./solution-evolution-result.mjs').PropertyScore>} scores
+ *   Array of PropertyScore instances.
+ * @param {Object} [options={}] - Same options as aggregatePropertyScores.
+ * @returns {AggregationResult}
+ */
+export declare function aggregatePropertyScoreInstances(scores: any[], options?: any): any;
+/**
+ * Simple equal-weight aggregation without toggling.
+ * Backward-compatible with the original SolutionBaseStrategy.aggregateProperties().
+ *
+ * @param {Array<{ property: string, phase: number, weight?: number }>} properties
+ * @returns {{ evolution: number, confidence: number }}
+ */
+export declare function simpleAggregate(properties: Array<{
+    property?: string;
+    phase: number;
+    weight?: number;
+}>): {
+    evolution: number;
+    confidence: number;
+};
+//# sourceMappingURL=aggregate-properties.d.mts.map

package/dist/work-on-evolution/strategies/solution/aggregate-properties.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-properties.d.mts","sourceRoot":"","sources":["../../../../src/work-on-evolution/strategies/solution/aggregate-properties.mts"],"names":[],"mappings":"AAyCA;;;GAGG;AACH,QAAA,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAK7C,CAAC;AAEH,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAI9B,wEAAwE;AACxE,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,qDAAqD;AACrD,eAAO,MAAM,cAAc,QAA8B,CAAC;AAE1D,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,+DAA+D;AAC/D,eAAO,MAAM,cAAc,MAAO,CAAC;AAEnC,gEAAgE;AAChE,eAAO,MAAM,cAAc,OAAO,CAAC;AAMnC;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,GAAG,GAAG,GAAG,CAiBzD;AAED;;;;;;;;;;GAUG;AAEH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CA8BzE;AAID;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,KAAK,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAO,GAAG,GAAG,CAmH7V;AA8BD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAejG;AAID;;;;;;;;;;;GAWG;AAEH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,OAAO,GAAE,GAAQ,GAAG,GAAG,CAWrF;AAID;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,KAAK,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAMnJ"}