context-probe 0.1.0

package/dist/src/core/architecture-scoring-evidence.d.ts

@@ -0,0 +1,30 @@
+import type { ArchitectureScoringContext, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+import type { toEvidence } from "./response.js";
+type EvidenceEntry = ReturnType<typeof toEvidence>;
+export interface ArchitectureEvidenceBundle {
+    direction: EvidenceEntry[];
+    purity: EvidenceEntry[];
+    protocol: EvidenceEntry[];
+    contractBaselineSource: EvidenceEntry[];
+    contractBaselineInput: EvidenceEntry[];
+    scenario: EvidenceEntry[];
+    scenarioSource: EvidenceEntry[];
+    topology: EvidenceEntry[];
+    operations: EvidenceEntry[];
+    telemetrySource: EvidenceEntry[];
+    telemetryNormalization: EvidenceEntry[];
+    patternRuntimeNormalization: EvidenceEntry[];
+    telemetryExport: EvidenceEntry[];
+    deliverySource: EvidenceEntry[];
+    deliveryNormalization: EvidenceEntry[];
+    complexitySource: EvidenceEntry[];
+    deliveryExport: EvidenceEntry[];
+    complexityExport: EvidenceEntry[];
+    complexity: EvidenceEntry[];
+    evolution: EvidenceEntry[];
+    deliveryInput: EvidenceEntry[];
+    telemetryInput: EvidenceEntry[];
+}
+export declare function buildArchitectureEvidence(options: ComputeArchitectureScoresOptions, context: ArchitectureScoringContext): ArchitectureEvidenceBundle;
+export declare function collectArchitectureEvidence(evidence: ArchitectureEvidenceBundle): EvidenceEntry[];
+export {};

package/dist/src/core/architecture-scoring-evidence.js

@@ -0,0 +1,76 @@
+import { buildComplexityEvidence, buildComplexityExportEvidence, buildDeliveryExportEvidence, buildDeliveryNormalizationEvidence, buildDirectionEvidence, buildEvolutionEvidence, buildOperationsEvidence, buildPatternRuntimeNormalizationEvidence, buildProtocolEvidence, buildPurityEvidence, buildScenarioEvidence, buildTelemetryExportEvidence, buildTelemetryNormalizationEvidence, buildTopologyEvidence, } from "./architecture-scoring-evidence-findings.js";
+import { buildComplexitySourceEvidence, buildContractBaselineInputEvidence, buildContractBaselineSourceEvidence, buildDeliveryInputEvidence, buildDeliverySourceEvidence, buildScenarioSourceEvidence, buildTelemetryInputEvidence, buildTelemetrySourceEvidence, } from "./architecture-scoring-evidence-inputs.js";
+export function buildArchitectureEvidence(options, context) {
+    const direction = buildDirectionEvidence(context);
+    const purity = buildPurityEvidence(context);
+    const protocol = buildProtocolEvidence(context);
+    const contractBaselineSource = buildContractBaselineSourceEvidence(options);
+    const contractBaselineInput = buildContractBaselineInputEvidence(options);
+    const scenario = buildScenarioEvidence(context);
+    const scenarioSource = buildScenarioSourceEvidence(options);
+    const topology = buildTopologyEvidence(context);
+    const operations = buildOperationsEvidence(context);
+    const telemetrySource = buildTelemetrySourceEvidence(options);
+    const telemetryNormalization = buildTelemetryNormalizationEvidence(context);
+    const patternRuntimeNormalization = buildPatternRuntimeNormalizationEvidence(context);
+    const telemetryExport = buildTelemetryExportEvidence(context);
+    const deliverySource = buildDeliverySourceEvidence(options);
+    const deliveryNormalization = buildDeliveryNormalizationEvidence(context);
+    const complexitySource = buildComplexitySourceEvidence(options);
+    const deliveryExport = buildDeliveryExportEvidence(context);
+    const complexityExport = buildComplexityExportEvidence(context);
+    const complexity = buildComplexityEvidence(context);
+    const evolution = buildEvolutionEvidence(context);
+    const deliveryInput = buildDeliveryInputEvidence(options, context);
+    const telemetryInput = buildTelemetryInputEvidence(options, context);
+    return {
+        direction,
+        purity,
+        protocol,
+        contractBaselineSource,
+        contractBaselineInput,
+        scenario,
+        scenarioSource,
+        topology,
+        operations,
+        telemetrySource,
+        telemetryNormalization,
+        patternRuntimeNormalization,
+        telemetryExport,
+        deliverySource,
+        deliveryNormalization,
+        complexitySource,
+        deliveryExport,
+        complexityExport,
+        complexity,
+        evolution,
+        deliveryInput,
+        telemetryInput,
+    };
+}
+export function collectArchitectureEvidence(evidence) {
+    return [
+        ...evidence.scenarioSource,
+        ...evidence.scenario,
+        ...evidence.direction,
+        ...evidence.purity,
+        ...evidence.contractBaselineInput,
+        ...evidence.protocol,
+        ...evidence.contractBaselineSource,
+        ...evidence.topology,
+        ...evidence.telemetrySource,
+        ...evidence.telemetryInput,
+        ...evidence.telemetryExport,
+        ...evidence.telemetryNormalization,
+        ...evidence.patternRuntimeNormalization,
+        ...evidence.operations,
+        ...evidence.deliverySource,
+        ...evidence.deliveryInput,
+        ...evidence.deliveryExport,
+        ...evidence.deliveryNormalization,
+        ...evidence.complexitySource,
+        ...evidence.complexityExport,
+        ...evidence.complexity,
+        ...evidence.evolution,
+    ];
+}

package/dist/src/core/architecture-scoring-evolution-inputs.d.ts

@@ -0,0 +1,10 @@
+import type { ArchitecturePolicy, ComputeArchitectureScoresOptions, DeliveryNormalizationResult, EvolutionEfficiencyScore, EvolutionLocalityScore } from "./architecture-scoring-types.js";
+import { normalizeHistory } from "./history.js";
+export interface ArchitectureEvolutionInputResults {
+    architectureCommits: Awaited<ReturnType<typeof normalizeHistory>>;
+    architectureHistoryDiagnostics: string[];
+    evolutionLocalityScore: EvolutionLocalityScore;
+    evolutionEfficiencyScore: EvolutionEfficiencyScore;
+    localityValue: number;
+}
+export declare function resolveArchitectureEvolutionInputs(options: ComputeArchitectureScoresOptions, policy: ArchitecturePolicy, deliveryNormalizationResult?: DeliveryNormalizationResult): Promise<ArchitectureEvolutionInputResults>;

package/dist/src/core/architecture-scoring-evolution-inputs.js

@@ -0,0 +1,56 @@
+import { scoreArchitectureEvolutionEfficiency, scoreArchitectureEvolutionLocality, } from "../analyzers/architecture-evolution.js";
+import { evaluateFormula } from "./formula.js";
+import { normalizeHistory } from "./history.js";
+function collectArchitectureHistoryGlobs(options) {
+    if (options.boundaryMap && options.boundaryMap.boundaries.length > 0) {
+        return options.boundaryMap.boundaries.flatMap((entry) => entry.pathGlobs);
+    }
+    return options.constraints.layers.flatMap((entry) => entry.globs);
+}
+export async function resolveArchitectureEvolutionInputs(options, policy, deliveryNormalizationResult) {
+    let architectureCommits = [];
+    let architectureHistoryDiagnostics = [];
+    try {
+        architectureCommits = await normalizeHistory(options.repoPath, options.policyConfig, options.profileName, {
+            includePathGlobs: collectArchitectureHistoryGlobs(options),
+        });
+    }
+    catch (error) {
+        architectureHistoryDiagnostics = [
+            error instanceof Error
+                ? `Skipped architecture history analysis: ${error.message}`
+                : "Skipped architecture history analysis",
+        ];
+    }
+    const evolutionLocalityScore = scoreArchitectureEvolutionLocality({
+        commits: architectureCommits,
+        constraints: options.constraints,
+        ...(options.boundaryMap ? { boundaryMap: options.boundaryMap } : {}),
+    });
+    const localityValue = policy.metrics.AELS
+        ? evaluateFormula(policy.metrics.AELS.formula, {
+            CrossBoundaryCoChange: evolutionLocalityScore.CrossBoundaryCoChange,
+            WeightedPropagationCost: evolutionLocalityScore.WeightedPropagationCost,
+            WeightedClusteringCost: evolutionLocalityScore.WeightedClusteringCost,
+        })
+        : 0.4 * (1 - evolutionLocalityScore.CrossBoundaryCoChange) +
+            0.3 * (1 - evolutionLocalityScore.WeightedPropagationCost) +
+            0.3 * (1 - evolutionLocalityScore.WeightedClusteringCost);
+    const evolutionEfficiencyScore = scoreArchitectureEvolutionEfficiency({
+        ...(options.deliveryObservations
+            ? { deliveryObservations: options.deliveryObservations }
+            : deliveryNormalizationResult
+                ? { deliveryObservations: deliveryNormalizationResult.deliveryObservations }
+                : {}),
+        locality: localityValue,
+        localityConfidence: evolutionLocalityScore.confidence,
+        localityUnknowns: evolutionLocalityScore.unknowns,
+    });
+    return {
+        architectureCommits,
+        architectureHistoryDiagnostics,
+        evolutionLocalityScore,
+        evolutionEfficiencyScore,
+        localityValue,
+    };
+}

package/dist/src/core/architecture-scoring-inputs-complexity.d.ts

@@ -0,0 +1,7 @@
+import type { ComplexityExportIngestResult, ComplexityScore, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+import type { CodebaseAnalysis } from "./contracts.js";
+export interface ArchitectureScoringComplexityResults {
+    complexityExportIngestResult?: ComplexityExportIngestResult;
+    complexityScore: ComplexityScore;
+}
+export declare function resolveArchitectureScoringComplexityInputs(options: ComputeArchitectureScoresOptions, codebase: CodebaseAnalysis): ArchitectureScoringComplexityResults;

package/dist/src/core/architecture-scoring-inputs-complexity.js

@@ -0,0 +1,24 @@
+import { ingestComplexityExportBundle } from "../analyzers/architecture-cti-ingest.js";
+import { scoreComplexityTax } from "../analyzers/cti.js";
+export function resolveArchitectureScoringComplexityInputs(options, codebase) {
+    const complexityExportBundle = options.complexityExport ?? options.complexitySource?.data;
+    const complexityExportIngestResult = complexityExportBundle
+        ? ingestComplexityExportBundle({
+            bundle: complexityExportBundle,
+            ...(options.constraints.complexity ? { existing: options.constraints.complexity } : {}),
+        })
+        : undefined;
+    const complexityScore = scoreComplexityTax({
+        codebase,
+        constraints: complexityExportIngestResult
+            ? {
+                ...options.constraints,
+                complexity: complexityExportIngestResult.complexity,
+            }
+            : options.constraints,
+    });
+    return {
+        complexityScore,
+        ...(complexityExportIngestResult ? { complexityExportIngestResult } : {}),
+    };
+}

package/dist/src/core/architecture-scoring-inputs-observability.d.ts

@@ -0,0 +1,11 @@
+import type { ComputeArchitectureScoresOptions, DeliveryExportIngestResult, DeliveryNormalizationResult, OperationsScore, PatternRuntimeNormalizationResult, TelemetryExportIngestResult, TelemetryNormalizationResult } from "./architecture-scoring-types.js";
+export interface ArchitectureScoringObservabilityResults {
+    telemetryExportIngestResult?: TelemetryExportIngestResult;
+    patternRuntimeNormalizationResult?: PatternRuntimeNormalizationResult;
+    telemetryNormalizationResult?: TelemetryNormalizationResult;
+    operationsScore: OperationsScore;
+    deliveryExportIngestResult?: DeliveryExportIngestResult;
+    deliveryNormalizationResult?: DeliveryNormalizationResult;
+    usablePatternRuntimeRaw: boolean;
+}
+export declare function resolveArchitectureScoringObservabilityInputs(options: ComputeArchitectureScoresOptions, topologyValue: number): ArchitectureScoringObservabilityResults;

package/dist/src/core/architecture-scoring-inputs-observability.js

@@ -0,0 +1,84 @@
+import { normalizeDeliveryObservations } from "../analyzers/architecture-delivery-normalization.js";
+import { buildDefaultDeliveryNormalizationProfile } from "../analyzers/architecture-delivery-normalization-spec.js";
+import { ingestDeliveryExportBundle, ingestTelemetryExportBundle, } from "../analyzers/architecture-observation-ingest.js";
+import { scoreOperationalAdequacy } from "../analyzers/architecture-operations.js";
+import { normalizePatternRuntimeObservations } from "../analyzers/architecture-pattern-runtime-normalization.js";
+import { normalizeTelemetryObservations } from "../analyzers/architecture-telemetry-normalization.js";
+export function resolveArchitectureScoringObservabilityInputs(options, topologyValue) {
+    const telemetryExportBundle = options.telemetryExport ?? options.telemetrySource?.data;
+    const telemetryExportIngestResult = telemetryExportBundle
+        ? ingestTelemetryExportBundle(telemetryExportBundle)
+        : undefined;
+    const usableTelemetryRaw = Boolean(options.telemetryRawObservations && options.telemetryNormalizationProfile);
+    const usablePatternRuntimeRaw = Boolean(options.patternRuntimeRawObservations && options.patternRuntimeNormalizationProfile);
+    const patternRuntimeNormalizationResult = options.patternRuntimeObservations
+        ? undefined
+        : options.patternRuntimeRawObservations || options.patternRuntimeNormalizationProfile
+            ? normalizePatternRuntimeObservations({
+                ...(options.patternRuntimeRawObservations ? { raw: options.patternRuntimeRawObservations } : {}),
+                ...(options.patternRuntimeNormalizationProfile
+                    ? { profile: options.patternRuntimeNormalizationProfile }
+                    : {}),
+            })
+            : undefined;
+    const telemetryRawInput = options.telemetryObservations
+        ? undefined
+        : usableTelemetryRaw
+            ? options.telemetryRawObservations
+            : telemetryExportBundle
+                ? telemetryExportIngestResult?.telemetryRawObservations
+                : options.telemetryRawObservations;
+    const patternRuntimeInput = options.patternRuntimeObservations ??
+        (usablePatternRuntimeRaw ? patternRuntimeNormalizationResult?.patternRuntimeObservations : undefined) ??
+        telemetryExportIngestResult?.patternRuntimeObservations;
+    const telemetryNormalizationResult = options.telemetryObservations
+        ? undefined
+        : telemetryRawInput || options.telemetryNormalizationProfile
+            ? normalizeTelemetryObservations({
+                ...(telemetryRawInput ? { raw: telemetryRawInput } : {}),
+                ...(options.telemetryNormalizationProfile ? { profile: options.telemetryNormalizationProfile } : {}),
+            })
+            : undefined;
+    const operationsScore = scoreOperationalAdequacy({
+        ...(options.telemetryObservations
+            ? { telemetry: options.telemetryObservations }
+            : telemetryNormalizationResult
+                ? { telemetry: telemetryNormalizationResult.telemetry }
+                : {}),
+        ...(patternRuntimeInput ? { patternRuntime: patternRuntimeInput } : {}),
+        topologyIsolationBridge: topologyValue,
+    });
+    const deliveryExportBundle = options.deliveryExport ?? options.deliverySource?.data;
+    const deliveryExportIngestResult = deliveryExportBundle
+        ? ingestDeliveryExportBundle(deliveryExportBundle)
+        : undefined;
+    const usableDeliveryRaw = Boolean(options.deliveryRawObservations && options.deliveryNormalizationProfile);
+    const deliveryNormalizationProfile = options.deliveryNormalizationProfile ??
+        (deliveryExportBundle && !options.deliveryObservations && !usableDeliveryRaw
+            ? buildDefaultDeliveryNormalizationProfile()
+            : undefined);
+    const deliveryRawInput = options.deliveryObservations
+        ? undefined
+        : usableDeliveryRaw
+            ? options.deliveryRawObservations
+            : deliveryExportBundle
+                ? deliveryExportIngestResult?.deliveryRawObservations
+                : options.deliveryRawObservations;
+    const deliveryNormalizationResult = options.deliveryObservations
+        ? undefined
+        : deliveryRawInput || deliveryNormalizationProfile
+            ? normalizeDeliveryObservations({
+                ...(deliveryRawInput ? { raw: deliveryRawInput } : {}),
+                ...(deliveryNormalizationProfile ? { profile: deliveryNormalizationProfile } : {}),
+            })
+            : undefined;
+    return {
+        operationsScore,
+        ...(telemetryExportIngestResult ? { telemetryExportIngestResult } : {}),
+        ...(patternRuntimeNormalizationResult ? { patternRuntimeNormalizationResult } : {}),
+        ...(telemetryNormalizationResult ? { telemetryNormalizationResult } : {}),
+        ...(deliveryExportIngestResult ? { deliveryExportIngestResult } : {}),
+        ...(deliveryNormalizationResult ? { deliveryNormalizationResult } : {}),
+        usablePatternRuntimeRaw,
+    };
+}

package/dist/src/core/architecture-scoring-inputs-static.d.ts

@@ -0,0 +1,13 @@
+import type { ArchitecturePolicy, ArchitectureViolations, ComputeArchitectureScoresOptions, DirectionScore, ProtocolScore, PurityScore, ScenarioScore, TopologyScore } from "./architecture-scoring-types.js";
+import type { ArchitectureScenarioQualitySummary, CodebaseAnalysis } from "./contracts.js";
+export interface ArchitectureScoringStaticResults {
+    directionScore: DirectionScore;
+    purityScore: PurityScore;
+    protocolScore: ProtocolScore;
+    scenarioScore: ScenarioScore;
+    scenarioQuality?: ArchitectureScenarioQualitySummary;
+    topologyScore: TopologyScore;
+    topologyValue: number;
+    violations: ArchitectureViolations;
+}
+export declare function resolveArchitectureScoringStaticInputs(options: ComputeArchitectureScoresOptions, policy: ArchitecturePolicy, codebase: CodebaseAnalysis): Promise<ArchitectureScoringStaticResults>;

package/dist/src/core/architecture-scoring-inputs-static.js

@@ -0,0 +1,48 @@
+import { detectDirectionViolations, scoreDependencyDirection } from "../analyzers/architecture.js";
+import { scoreInterfaceProtocolStability } from "../analyzers/architecture-contracts.js";
+import { scoreBoundaryPurity } from "../analyzers/architecture-purity.js";
+import { scoreQualityScenarioFit } from "../analyzers/architecture-scenarios.js";
+import { scoreTopologyIsolation } from "../analyzers/architecture-topology.js";
+import { summarizeArchitectureScenarioQuality } from "./architecture-scenario-quality.js";
+import { evaluateFormula } from "./formula.js";
+export async function resolveArchitectureScoringStaticInputs(options, policy, codebase) {
+    const directionScore = scoreDependencyDirection(codebase, options.constraints);
+    const purityScore = scoreBoundaryPurity(codebase, options.constraints);
+    const resolvedContractBaseline = options.contractBaseline ?? options.contractBaselineSource?.data;
+    const protocolScore = await scoreInterfaceProtocolStability({
+        root: options.repoPath,
+        codebase,
+        constraints: options.constraints,
+        ...(resolvedContractBaseline ? { baseline: resolvedContractBaseline } : {}),
+    });
+    const scenarioObservationsInput = options.scenarioObservations ?? options.scenarioObservationSource?.data;
+    const scenarioScore = scoreQualityScenarioFit({
+        ...(options.scenarioCatalog ? { catalog: options.scenarioCatalog } : {}),
+        ...(scenarioObservationsInput ? { observations: scenarioObservationsInput } : {}),
+    });
+    const scenarioQuality = summarizeArchitectureScenarioQuality({
+        ...(options.scenarioCatalog ? { catalog: options.scenarioCatalog } : {}),
+        ...(scenarioObservationsInput ? { observations: scenarioObservationsInput } : {}),
+    });
+    const topologyScore = scoreTopologyIsolation({
+        ...(options.topologyModel ? { topology: options.topologyModel } : {}),
+        ...(options.runtimeObservations ? { observations: options.runtimeObservations } : {}),
+    });
+    const topologyValue = policy.metrics.TIS
+        ? evaluateFormula(policy.metrics.TIS.formula, {
+            FI: topologyScore.FI,
+            RC: topologyScore.RC,
+            SDR: topologyScore.SDR,
+        })
+        : 0.4 * topologyScore.FI + 0.3 * topologyScore.RC + 0.3 * (1 - topologyScore.SDR);
+    return {
+        directionScore,
+        purityScore,
+        protocolScore,
+        scenarioScore,
+        ...(scenarioQuality ? { scenarioQuality } : {}),
+        topologyScore,
+        topologyValue,
+        violations: detectDirectionViolations(codebase, options.constraints),
+    };
+}

package/dist/src/core/architecture-scoring-inputs.d.ts

@@ -0,0 +1,9 @@
+import { parseCodebase } from "../analyzers/code.js";
+import { type ArchitectureScoringComplexityResults } from "./architecture-scoring-inputs-complexity.js";
+import { type ArchitectureScoringObservabilityResults } from "./architecture-scoring-inputs-observability.js";
+import { type ArchitectureScoringStaticResults } from "./architecture-scoring-inputs-static.js";
+import type { ArchitecturePolicy, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+export type ArchitectureScoringInputResults = {
+    codebase: Awaited<ReturnType<typeof parseCodebase>>;
+} & ArchitectureScoringStaticResults & ArchitectureScoringObservabilityResults & ArchitectureScoringComplexityResults;
+export declare function resolveArchitectureScoringInputs(options: ComputeArchitectureScoresOptions, policy: ArchitecturePolicy): Promise<ArchitectureScoringInputResults>;

package/dist/src/core/architecture-scoring-inputs.js

@@ -0,0 +1,16 @@
+import { parseCodebase } from "../analyzers/code.js";
+import { resolveArchitectureScoringComplexityInputs, } from "./architecture-scoring-inputs-complexity.js";
+import { resolveArchitectureScoringObservabilityInputs, } from "./architecture-scoring-inputs-observability.js";
+import { resolveArchitectureScoringStaticInputs, } from "./architecture-scoring-inputs-static.js";
+export async function resolveArchitectureScoringInputs(options, policy) {
+    const codebase = await parseCodebase(options.repoPath);
+    const staticResults = await resolveArchitectureScoringStaticInputs(options, policy, codebase);
+    const observabilityResults = resolveArchitectureScoringObservabilityInputs(options, staticResults.topologyValue);
+    const complexityResults = resolveArchitectureScoringComplexityInputs(options, codebase);
+    return {
+        codebase,
+        ...staticResults,
+        ...observabilityResults,
+        ...complexityResults,
+    };
+}

package/dist/src/core/architecture-scoring-metric-shared.d.ts

@@ -0,0 +1,11 @@
+import type { ArchitectureEvidenceBundle } from "./architecture-scoring-evidence.js";
+import type { ArchitecturePolicy, ArchitectureScoringContext, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+export interface ArchitectureMetricBuilderArgs {
+    options: ComputeArchitectureScoresOptions;
+    policy: ArchitecturePolicy;
+    context: ArchitectureScoringContext;
+    evidence: ArchitectureEvidenceBundle;
+}
+export declare function evidenceRefs(...groups: Array<Array<{
+    evidenceId: string;
+}>>): string[];

package/dist/src/core/architecture-scoring-metric-shared.js

@@ -0,0 +1,3 @@
+export function evidenceRefs(...groups) {
+    return groups.flatMap((group) => group.map((entry) => entry.evidenceId));
+}

package/dist/src/core/architecture-scoring-metrics-composite.d.ts

@@ -0,0 +1,3 @@
+import type { ArchitectureMetricBuilderArgs } from "./architecture-scoring-metric-shared.js";
+import type { MetricScore } from "./contracts.js";
+export declare function buildCompositeArchitectureMetricScores(args: ArchitectureMetricBuilderArgs, scores: MetricScore[]): MetricScore[];

package/dist/src/core/architecture-scoring-metrics-composite.js

@@ -0,0 +1,56 @@
+import { evaluateFormula } from "./formula.js";
+import { confidenceFromSignals } from "./response.js";
+import { toMetricScore, weightedAverage } from "./scoring-shared.js";
+export function buildCompositeArchitectureMetricScores(args, scores) {
+    const { options, policy } = args;
+    if (!policy.metrics.APSI) {
+        return [];
+    }
+    const scoreMap = new Map(scores.map((score) => [score.metricId, score]));
+    const qsfMetric = scoreMap.get("QSF");
+    const ddsMetric = scoreMap.get("DDS");
+    const bpsMetric = scoreMap.get("BPS");
+    const ipsMetric = scoreMap.get("IPS");
+    const tisMetric = scoreMap.get("TIS");
+    const oasMetric = scoreMap.get("OAS");
+    const eesMetric = scoreMap.get("EES");
+    const ctiMetric = scoreMap.get("CTI");
+    const PCS = weightedAverage([
+        { value: ddsMetric?.value, weight: 0.4 },
+        { value: bpsMetric?.value, weight: 0.35 },
+        { value: ipsMetric?.value, weight: 0.25 },
+    ], 0.5);
+    const OAS = oasMetric?.value ?? tisMetric?.value ?? 0.5;
+    const apsiComponents = {
+        QSF: qsfMetric?.value ?? 0.5,
+        PCS,
+        OAS,
+        EES: eesMetric?.value ?? 0.5,
+        CTI: ctiMetric?.value ?? 0.5,
+    };
+    const apsiUnknowns = [];
+    if (!qsfMetric) {
+        apsiUnknowns.push("QSF was not computed, so APSI is using the neutral fallback value 0.5.");
+    }
+    if (!ddsMetric || !bpsMetric || !ipsMetric) {
+        apsiUnknowns.push("Some of DDS/BPS/IPS were not computed, so PCS is only a partial proxy.");
+    }
+    if (!oasMetric && tisMetric) {
+        apsiUnknowns.push("OAS is being approximated through the TIS proxy.");
+    }
+    if (!oasMetric && !tisMetric) {
+        apsiUnknowns.push("Neither OAS nor TIS was computed, so APSI is using the neutral fallback value 0.5.");
+    }
+    if (!eesMetric) {
+        apsiUnknowns.push("EES was not computed, so APSI is using the neutral fallback value 0.5.");
+    }
+    if (!ctiMetric) {
+        apsiUnknowns.push("CTI was not computed, so APSI is using the neutral fallback value 0.5.");
+    }
+    if (options.profileName !== "default") {
+        apsiUnknowns.push(`APSI is using the comparison weights from the ${options.profileName} policy profile.`);
+    }
+    return [
+        toMetricScore("APSI", evaluateFormula(policy.metrics.APSI.formula, apsiComponents), apsiComponents, Array.from(new Set([qsfMetric, ddsMetric, bpsMetric, ipsMetric, oasMetric, tisMetric, eesMetric, ctiMetric].flatMap((metric) => metric?.evidenceRefs ?? []))), confidenceFromSignals([qsfMetric, ddsMetric, bpsMetric, ipsMetric, oasMetric, tisMetric, eesMetric, ctiMetric].flatMap((metric) => metric ? [metric.confidence] : [])), Array.from(new Set(apsiUnknowns))),
+    ];
+}

package/dist/src/core/architecture-scoring-metrics-core.d.ts

@@ -0,0 +1,3 @@
+import { type ArchitectureMetricBuilderArgs } from "./architecture-scoring-metric-shared.js";
+import type { MetricScore } from "./contracts.js";
+export declare function buildCoreArchitectureMetricScores(args: ArchitectureMetricBuilderArgs): MetricScore[];

package/dist/src/core/architecture-scoring-metrics-core.js

@@ -0,0 +1,81 @@
+import { evidenceRefs } from "./architecture-scoring-metric-shared.js";
+import { evaluateFormula } from "./formula.js";
+import { confidenceFromSignals } from "./response.js";
+import { toMetricScore } from "./scoring-shared.js";
+export function buildCoreArchitectureMetricScores(args) {
+    const { options, policy, context, evidence } = args;
+    const scores = [];
+    if (policy.metrics.QSF) {
+        const qsfUnknowns = [
+            ...context.scenarioScore.unknowns,
+            ...(options.scenarioObservationSource?.unknowns ?? []),
+            ...(options.scenarioObservations && options.scenarioObservationSourceRequested
+                ? ["Scenario observations were provided explicitly, so the scenario observation source was not used."]
+                : []),
+        ];
+        scores.push(toMetricScore("QSF", evaluateFormula(policy.metrics.QSF.formula, {
+            QSF: context.scenarioScore.QSF,
+        }), {
+            scenario_count: context.scenarioScore.scenarioCount,
+            weighted_coverage: context.scenarioScore.weightedCoverage,
+            average_normalized_score: context.scenarioScore.averageNormalizedScore,
+            QSF: context.scenarioScore.QSF,
+        }, evidenceRefs(evidence.scenarioSource, evidence.scenario), confidenceFromSignals(options.scenarioObservationSource
+            ? [context.scenarioScore.confidence, options.scenarioObservationSource.confidence]
+            : [context.scenarioScore.confidence]), Array.from(new Set(qsfUnknowns))));
+    }
+    if (policy.metrics.DDS) {
+        scores.push(toMetricScore("DDS", evaluateFormula(policy.metrics.DDS.formula, {
+            IDR: context.directionScore.IDR,
+            LRC: context.directionScore.LRC,
+            APM: context.directionScore.APM,
+        }), {
+            IDR: context.directionScore.IDR,
+            LRC: context.directionScore.LRC,
+            APM: context.directionScore.APM,
+        }, evidenceRefs(evidence.direction), context.directionScore.applicableEdges > 0 ? 0.9 : 0.55, context.directionScore.applicableEdges > 0
+            ? []
+            : ["There are too few dependencies that can be classified into layers."]));
+    }
+    if (policy.metrics.BPS) {
+        scores.push(toMetricScore("BPS", evaluateFormula(policy.metrics.BPS.formula, {
+            ALR: context.purityScore.ALR,
+            FCC: context.purityScore.FCC,
+            SICR: context.purityScore.SICR,
+        }), {
+            ALR: context.purityScore.ALR,
+            FCC: context.purityScore.FCC,
+            SICR: context.purityScore.SICR,
+        }, evidenceRefs(evidence.purity), context.purityScore.confidence, context.purityScore.unknowns));
+    }
+    if (policy.metrics.IPS) {
+        const ipsUnknowns = Array.from(new Set([
+            ...(options.contractBaselineSource?.unknowns ?? []),
+            ...context.protocolScore.unknowns,
+            ...(options.contractBaseline && options.contractBaselineSourceRequested
+                ? ["A contract baseline was provided explicitly, so the contract baseline source was not used."]
+                : []),
+        ]));
+        scores.push(toMetricScore("IPS", evaluateFormula(policy.metrics.IPS.formula, {
+            CBC: context.protocolScore.CBC,
+            BCR: context.protocolScore.BCR,
+            SLA: context.protocolScore.SLA,
+        }), {
+            CBC: context.protocolScore.CBC,
+            BCR: context.protocolScore.BCR,
+            SLA: context.protocolScore.SLA,
+        }, evidenceRefs(evidence.contractBaselineInput, evidence.contractBaselineSource, evidence.protocol), context.protocolScore.confidence, ipsUnknowns));
+    }
+    if (policy.metrics.TIS) {
+        scores.push(toMetricScore("TIS", evaluateFormula(policy.metrics.TIS.formula, {
+            FI: context.topologyScore.FI,
+            RC: context.topologyScore.RC,
+            SDR: context.topologyScore.SDR,
+        }), {
+            FI: context.topologyScore.FI,
+            RC: context.topologyScore.RC,
+            SDR: context.topologyScore.SDR,
+        }, evidenceRefs(evidence.topology), context.topologyScore.confidence, context.topologyScore.unknowns));
+    }
+    return scores;
+}

package/dist/src/core/architecture-scoring-metrics-evolution.d.ts

@@ -0,0 +1,3 @@
+import { type ArchitectureMetricBuilderArgs } from "./architecture-scoring-metric-shared.js";
+import type { MetricScore } from "./contracts.js";
+export declare function buildEvolutionArchitectureMetricScores(args: ArchitectureMetricBuilderArgs): MetricScore[];

package/dist/src/core/architecture-scoring-metrics-evolution.js

@@ -0,0 +1,74 @@
+import { evidenceRefs } from "./architecture-scoring-metric-shared.js";
+import { evaluateFormula } from "./formula.js";
+import { confidenceFromSignals } from "./response.js";
+import { toMetricScore } from "./scoring-shared.js";
+export function buildEvolutionArchitectureMetricScores(args) {
+    const { options, policy, context, evidence } = args;
+    const scores = [];
+    if (policy.metrics.CTI) {
+        scores.push(toMetricScore("CTI", evaluateFormula(policy.metrics.CTI.formula, context.complexityScore.components), context.complexityScore.components, evidenceRefs(evidence.complexitySource, evidence.complexityExport, evidence.complexity), confidenceFromSignals(context.complexityExportIngestResult
+            ? options.complexitySource
+                ? [
+                    context.complexityScore.confidence,
+                    context.complexityExportIngestResult.confidence,
+                    options.complexitySource.confidence,
+                ]
+                : [context.complexityScore.confidence, context.complexityExportIngestResult.confidence]
+            : [context.complexityScore.confidence]), Array.from(new Set([
+            ...(options.complexitySource?.unknowns ?? []),
+            ...(context.complexityExportIngestResult?.unknowns ?? []),
+            ...context.complexityScore.unknowns,
+            ...(options.complexityExport && options.complexitySourceRequested
+                ? ["A complexity export was provided explicitly, so the complexity source was not used."]
+                : []),
+        ]))));
+    }
+    if (policy.metrics.AELS) {
+        scores.push(toMetricScore("AELS", context.localityValue, {
+            CrossBoundaryCoChange: context.evolutionLocalityScore.CrossBoundaryCoChange,
+            WeightedPropagationCost: context.evolutionLocalityScore.WeightedPropagationCost,
+            WeightedClusteringCost: context.evolutionLocalityScore.WeightedClusteringCost,
+        }, evidenceRefs(evidence.evolution), context.evolutionLocalityScore.confidence, context.evolutionLocalityScore.unknowns));
+    }
+    if (policy.metrics.EES) {
+        const eesUnknowns = [
+            ...(options.deliverySource?.unknowns ?? []),
+            ...(context.deliveryExportIngestResult?.unknowns ?? []),
+            ...(context.deliveryNormalizationResult?.unknowns ?? []),
+            ...context.evolutionEfficiencyScore.unknowns,
+            ...(options.deliveryObservations &&
+                (options.deliveryRawObservations ||
+                    options.deliveryNormalizationProfile ||
+                    options.deliveryExport ||
+                    options.deliverySourceRequested)
+                ? ["Delivery observations were provided explicitly, so raw/export/source delivery inputs were not used."]
+                : []),
+            ...(options.deliveryRawObservations && options.deliveryExport
+                ? ["Raw delivery observations were provided explicitly, so the delivery export was not used."]
+                : []),
+            ...(options.deliverySourceRequested &&
+                (options.deliveryObservations ||
+                    (options.deliveryRawObservations && options.deliveryNormalizationProfile) ||
+                    options.deliveryExport)
+                ? ["A higher-priority delivery input was present, so the delivery source was not used."]
+                : []),
+        ];
+        scores.push(toMetricScore("EES", evaluateFormula(policy.metrics.EES.formula, {
+            Delivery: context.evolutionEfficiencyScore.Delivery,
+            Locality: context.evolutionEfficiencyScore.Locality,
+        }), {
+            Delivery: context.evolutionEfficiencyScore.Delivery,
+            Locality: context.evolutionEfficiencyScore.Locality,
+        }, evidenceRefs(evidence.deliverySource, evidence.deliveryInput, evidence.deliveryExport, evidence.deliveryNormalization, evidence.evolution), confidenceFromSignals([
+            context.evolutionEfficiencyScore.confidence,
+            ...(context.deliveryNormalizationResult
+                ? [context.deliveryNormalizationResult.confidence]
+                : options.deliverySource
+                    ? [options.deliverySource.confidence, context.deliveryExportIngestResult?.confidence ?? 0.8]
+                    : context.deliveryExportIngestResult
+                        ? [context.deliveryExportIngestResult.confidence]
+                        : [0.85]),
+        ]), Array.from(new Set(eesUnknowns))));
+    }
+    return scores;
+}