context-probe 0.1.0

package/dist/src/analyzers/architecture-delivery-normalization-core.d.ts

@@ -0,0 +1,6 @@
+import type { ArchitectureDeliveryNormalizationProfile, ArchitectureDeliveryRawObservationSet } from "../core/contracts.js";
+import type { NormalizedDeliveryResult } from "./architecture-delivery-normalization-shared.js";
+export declare function normalizeDeliveryObservationsCore(input: {
+    raw?: ArchitectureDeliveryRawObservationSet;
+    profile?: ArchitectureDeliveryNormalizationProfile;
+}): NormalizedDeliveryResult;

package/dist/src/analyzers/architecture-delivery-normalization-core.js

@@ -0,0 +1,83 @@
+import { buildDeliverySignalMappings } from "./architecture-delivery-normalization-spec.js";
+import { average, clamp01, normalizeObservedValue, uniqueUnknowns, } from "./architecture-observation-normalization-shared.js";
+export function normalizeDeliveryObservationsCore(input) {
+    const findings = [];
+    const unknowns = [];
+    const rawValues = input.raw?.values;
+    const profile = input.profile;
+    if (!rawValues) {
+        return buildEmptyDeliveryNormalizationResult("No delivery raw observations were provided, so raw normalization is unobserved.", 0.25, findings);
+    }
+    if (!profile) {
+        return buildEmptyDeliveryNormalizationResult("No delivery normalization profile was provided, so raw delivery cannot be scored.", 0.3, findings);
+    }
+    const normalizedScores = {};
+    let observedSignals = 0;
+    const mappings = buildDeliverySignalMappings({ rawValues, profile });
+    for (const mapping of mappings) {
+        if (!mapping.rule) {
+            unknowns.push(`A normalization rule for ${mapping.component} is missing.`);
+            findings.push({
+                kind: "missing_normalization_rule",
+                component: mapping.component,
+                scoreComponent: mapping.scoreComponent,
+                confidence: 0.58,
+                note: `There is no rule to normalize ${mapping.component}.`,
+            });
+            continue;
+        }
+        if (mapping.observed === undefined) {
+            unknowns.push(`The raw ${mapping.component} signal is missing.`);
+            findings.push({
+                kind: "missing_raw_signal",
+                component: mapping.component,
+                scoreComponent: mapping.scoreComponent,
+                confidence: 0.62,
+                note: `The raw ${mapping.component} signal is missing.`,
+            });
+            continue;
+        }
+        const normalized = normalizeObservedValue({
+            direction: mapping.rule.direction,
+            observed: mapping.observed,
+            target: mapping.rule.target,
+            worstAcceptable: mapping.rule.worstAcceptable,
+        });
+        const storedScore = mapping.invertForStorage ? 1 - normalized : normalized;
+        normalizedScores[mapping.scoreComponent] = storedScore;
+        observedSignals += 1;
+        findings.push({
+            kind: "normalized_signal",
+            component: mapping.component,
+            scoreComponent: mapping.scoreComponent,
+            observed: mapping.observed,
+            normalized: storedScore,
+            confidence: 0.86,
+            note: `${mapping.component} was normalized from raw delivery input to ${storedScore.toFixed(3)}.`,
+        });
+    }
+    return {
+        deliveryObservations: {
+            version: "1.0",
+            scores: normalizedScores,
+        },
+        confidence: clamp01(average([
+            Object.keys(rawValues).length > 0 ? 0.82 : 0.25,
+            Object.keys(profile.signals).length > 0 ? 0.84 : 0.35,
+            observedSignals / mappings.length,
+        ], 0.35)),
+        unknowns: uniqueUnknowns(unknowns),
+        findings,
+    };
+}
+function buildEmptyDeliveryNormalizationResult(unknown, confidence, findings) {
+    return {
+        deliveryObservations: {
+            version: "1.0",
+            scores: {},
+        },
+        confidence,
+        unknowns: [unknown],
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-delivery-normalization-shared.d.ts

@@ -0,0 +1,16 @@
+import type { ArchitectureDeliveryObservationSet } from "../core/contracts.js";
+export interface DeliveryNormalizationFinding {
+    kind: "normalized_signal" | "missing_raw_signal" | "missing_normalization_rule";
+    confidence: number;
+    note: string;
+    component: "LeadTime" | "DeployFrequency" | "RecoveryTime" | "ChangeFailRate" | "ReworkRate";
+    scoreComponent: "LeadTimeScore" | "DeployFreqScore" | "RecoveryScore" | "ChangeFailScore" | "ReworkScore";
+    observed?: number;
+    normalized?: number;
+}
+export interface NormalizedDeliveryResult {
+    deliveryObservations: ArchitectureDeliveryObservationSet;
+    confidence: number;
+    unknowns: string[];
+    findings: DeliveryNormalizationFinding[];
+}

package/dist/src/analyzers/architecture-delivery-normalization-shared.js

@@ -0,0 +1 @@
+export {};

package/dist/src/analyzers/architecture-delivery-normalization-spec.d.ts

@@ -0,0 +1,13 @@
+import type { ArchitectureDeliveryNormalizationProfile, ArchitectureDeliveryRawObservationSet } from "../core/contracts.js";
+export declare function buildDefaultDeliveryNormalizationProfile(): ArchitectureDeliveryNormalizationProfile;
+export interface DeliverySignalMapping {
+    component: "LeadTime" | "DeployFrequency" | "RecoveryTime" | "ChangeFailRate" | "ReworkRate";
+    scoreComponent: "LeadTimeScore" | "DeployFreqScore" | "RecoveryScore" | "ChangeFailScore" | "ReworkScore";
+    observed: number | undefined;
+    rule: ArchitectureDeliveryNormalizationProfile["signals"][keyof ArchitectureDeliveryNormalizationProfile["signals"]] | undefined;
+    invertForStorage: boolean;
+}
+export declare function buildDeliverySignalMappings(input: {
+    rawValues: ArchitectureDeliveryRawObservationSet["values"];
+    profile: ArchitectureDeliveryNormalizationProfile;
+}): DeliverySignalMapping[];

package/dist/src/analyzers/architecture-delivery-normalization-spec.js

@@ -0,0 +1,52 @@
+export function buildDefaultDeliveryNormalizationProfile() {
+    return {
+        version: "1.0",
+        signals: {
+            LeadTime: { direction: "lower_is_better", target: 2, worstAcceptable: 14 },
+            DeployFrequency: { direction: "higher_is_better", target: 20, worstAcceptable: 2 },
+            RecoveryTime: { direction: "lower_is_better", target: 1, worstAcceptable: 8 },
+            ChangeFailRate: { direction: "lower_is_better", target: 0.05, worstAcceptable: 0.4 },
+            ReworkRate: { direction: "lower_is_better", target: 0.04, worstAcceptable: 0.35 },
+        },
+    };
+}
+export function buildDeliverySignalMappings(input) {
+    const { rawValues, profile } = input;
+    return [
+        {
+            component: "LeadTime",
+            scoreComponent: "LeadTimeScore",
+            observed: rawValues.LeadTime,
+            rule: profile.signals.LeadTime,
+            invertForStorage: false,
+        },
+        {
+            component: "DeployFrequency",
+            scoreComponent: "DeployFreqScore",
+            observed: rawValues.DeployFrequency,
+            rule: profile.signals.DeployFrequency,
+            invertForStorage: false,
+        },
+        {
+            component: "RecoveryTime",
+            scoreComponent: "RecoveryScore",
+            observed: rawValues.RecoveryTime,
+            rule: profile.signals.RecoveryTime,
+            invertForStorage: false,
+        },
+        {
+            component: "ChangeFailRate",
+            scoreComponent: "ChangeFailScore",
+            observed: rawValues.ChangeFailRate,
+            rule: profile.signals.ChangeFailRate,
+            invertForStorage: true,
+        },
+        {
+            component: "ReworkRate",
+            scoreComponent: "ReworkScore",
+            observed: rawValues.ReworkRate,
+            rule: profile.signals.ReworkRate,
+            invertForStorage: true,
+        },
+    ];
+}

package/dist/src/analyzers/architecture-delivery-normalization.d.ts

@@ -0,0 +1,6 @@
+import type { ArchitectureDeliveryNormalizationProfile, ArchitectureDeliveryRawObservationSet } from "../core/contracts.js";
+export type { DeliveryNormalizationFinding, NormalizedDeliveryResult, } from "./architecture-delivery-normalization-shared.js";
+export declare function normalizeDeliveryObservations(input: {
+    raw?: ArchitectureDeliveryRawObservationSet;
+    profile?: ArchitectureDeliveryNormalizationProfile;
+}): import("./architecture-delivery-normalization-shared.js").NormalizedDeliveryResult;

package/dist/src/analyzers/architecture-delivery-normalization.js

@@ -0,0 +1,4 @@
+import { normalizeDeliveryObservationsCore } from "./architecture-delivery-normalization-core.js";
+export function normalizeDeliveryObservations(input) {
+    return normalizeDeliveryObservationsCore(input);
+}

package/dist/src/analyzers/architecture-evolution-efficiency.d.ts

@@ -0,0 +1,8 @@
+import type { ArchitectureDeliveryObservationSet } from "../core/contracts.js";
+import { type ArchitectureEvolutionEfficiencyScore } from "./architecture-evolution-shared.js";
+export declare function scoreArchitectureEvolutionEfficiency(options: {
+    deliveryObservations?: ArchitectureDeliveryObservationSet;
+    locality: number;
+    localityUnknowns?: string[];
+    localityConfidence: number;
+}): ArchitectureEvolutionEfficiencyScore;

package/dist/src/analyzers/architecture-evolution-efficiency.js

@@ -0,0 +1,76 @@
+import { average, clamp01, uniqueUnknowns, } from "./architecture-evolution-shared.js";
+export function scoreArchitectureEvolutionEfficiency(options) {
+    const findings = [];
+    const unknowns = [...(options.localityUnknowns ?? [])];
+    const scores = options.deliveryObservations?.scores;
+    const weightedComponents = [
+        {
+            component: "LeadTimeScore",
+            weight: 0.25,
+            value: scores?.LeadTimeScore,
+            note: "Applying lead time score to delivery efficiency.",
+        },
+        {
+            component: "DeployFreqScore",
+            weight: 0.2,
+            value: scores?.DeployFreqScore,
+            note: "Applying deployment frequency score to delivery efficiency.",
+        },
+        {
+            component: "RecoveryScore",
+            weight: 0.2,
+            value: scores?.RecoveryScore,
+            note: "Applying recovery score to delivery efficiency.",
+        },
+        {
+            component: "ChangeFailScore",
+            weight: 0.2,
+            value: scores?.ChangeFailScore,
+            invert: true,
+            note: "Applying the inverted change-fail score to delivery efficiency.",
+        },
+        {
+            component: "ReworkScore",
+            weight: 0.15,
+            value: scores?.ReworkScore,
+            invert: true,
+            note: "Applying the inverted deployment-rework score to delivery efficiency.",
+        },
+    ];
+    let observedWeight = 0;
+    let weightedSum = 0;
+    for (const entry of weightedComponents) {
+        if (entry.value === undefined) {
+            unknowns.push(`${entry.component} is missing, so Delivery is only a partial approximation.`);
+            findings.push({
+                kind: "missing_delivery_observation",
+                component: entry.component,
+                confidence: 0.45,
+                note: `${entry.component} was not provided.`,
+            });
+            continue;
+        }
+        const normalized = clamp01(entry.invert ? 1 - entry.value : entry.value);
+        observedWeight += entry.weight;
+        weightedSum += entry.weight * normalized;
+        if (normalized < 0.5) {
+            findings.push({
+                kind: "weak_delivery_score",
+                component: entry.component,
+                confidence: 0.76,
+                note: `${entry.note} (normalized=${normalized.toFixed(3)})`,
+            });
+        }
+    }
+    const Delivery = observedWeight > 0 ? weightedSum / observedWeight : 0.5;
+    if (!scores) {
+        unknowns.push("No delivery observations were provided, so Delivery is using the neutral value 0.5.");
+    }
+    return {
+        Delivery,
+        Locality: options.locality,
+        confidence: clamp01(average([observedWeight > 0 ? 0.82 * observedWeight + 0.35 * (1 - observedWeight) : 0.3, options.localityConfidence], 0.4)),
+        unknowns: uniqueUnknowns(unknowns),
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-evolution-locality.d.ts

@@ -0,0 +1,7 @@
+import type { ArchitectureBoundaryMap, ArchitectureConstraints, CochangeCommit } from "../core/contracts.js";
+import { type ArchitectureEvolutionLocalityScore } from "./architecture-evolution-shared.js";
+export declare function scoreArchitectureEvolutionLocality(options: {
+    commits: CochangeCommit[];
+    constraints: ArchitectureConstraints;
+    boundaryMap?: ArchitectureBoundaryMap;
+}): ArchitectureEvolutionLocalityScore;

package/dist/src/analyzers/architecture-evolution-locality.js

@@ -0,0 +1,129 @@
+import { architectureBoundaries, average, clamp01, classifyBoundary, pairKey, uniqueUnknowns, } from "./architecture-evolution-shared.js";
+export function scoreArchitectureEvolutionLocality(options) {
+    const boundaries = architectureBoundaries(options.constraints, options.boundaryMap);
+    const findings = [];
+    const unknowns = [];
+    if (boundaries.length < 2) {
+        return {
+            CrossBoundaryCoChange: 0.5,
+            WeightedPropagationCost: 0.5,
+            WeightedClusteringCost: 0.5,
+            confidence: 0.25,
+            unknowns: ["There are too few architecture boundaries, so AELS is close to unobserved."],
+            findings,
+            watchlist: [],
+        };
+    }
+    if (!options.boundaryMap) {
+        unknowns.push("No boundary map was provided, so AELS is using constraint layers as a boundary proxy.");
+    }
+    const relevant = options.commits
+        .map((commit) => {
+        const touchedBoundaries = new Set(commit.files
+            .map((filePath) => classifyBoundary(filePath, boundaries))
+            .filter((value) => Boolean(value)));
+        return {
+            ...commit,
+            touchedBoundaries,
+        };
+    })
+        .filter((entry) => entry.touchedBoundaries.size > 0);
+    if (relevant.length === 0) {
+        return {
+            CrossBoundaryCoChange: 0.5,
+            WeightedPropagationCost: 0.5,
+            WeightedClusteringCost: 0.5,
+            confidence: 0.3,
+            unknowns: uniqueUnknowns([
+                ...unknowns,
+                "No history could be mapped to architecture boundaries, so AELS is close to unobserved.",
+            ]),
+            findings,
+            watchlist: [],
+        };
+    }
+    const totalBoundaries = Math.max(1, boundaries.length);
+    const crossBoundaryCommits = relevant.filter((entry) => entry.touchedBoundaries.size > 1);
+    const CrossBoundaryCoChange = crossBoundaryCommits.length / relevant.length;
+    const propagationCosts = relevant.map((entry) => totalBoundaries <= 1 ? 0 : (entry.touchedBoundaries.size - 1) / Math.max(1, totalBoundaries - 1));
+    const WeightedPropagationCost = clamp01(average(propagationCosts, 0));
+    const pairCounts = new Map();
+    const involvedBoundaries = new Set();
+    for (const commit of crossBoundaryCommits) {
+        const boundaryNames = Array.from(commit.touchedBoundaries).sort();
+        for (const boundary of boundaryNames) {
+            involvedBoundaries.add(boundary);
+        }
+        for (let index = 0; index < boundaryNames.length; index += 1) {
+            for (let next = index + 1; next < boundaryNames.length; next += 1) {
+                const leftBoundary = boundaryNames[index];
+                const rightBoundary = boundaryNames[next];
+                if (!leftBoundary || !rightBoundary) {
+                    continue;
+                }
+                const key = pairKey(leftBoundary, rightBoundary);
+                pairCounts.set(key, (pairCounts.get(key) ?? 0) + 1);
+            }
+        }
+        findings.push({
+            kind: "cross_boundary_cochange",
+            commitHash: commit.hash,
+            confidence: 0.82,
+            note: `Commit ${commit.hash.slice(0, 7)} changed multiple boundaries at once: ${boundaryNames.join(", ")}`,
+        });
+    }
+    const maxPossiblePairs = Math.max(1, (totalBoundaries * (totalBoundaries - 1)) / 2);
+    const pairSpread = pairCounts.size / maxPossiblePairs;
+    const pairTouchDensity = Array.from(pairCounts.values()).reduce((sum, value) => sum + value, 0) /
+        Math.max(1, relevant.length * maxPossiblePairs);
+    const boundarySpread = involvedBoundaries.size / totalBoundaries;
+    const WeightedClusteringCost = crossBoundaryCommits.length === 0 ? 0 : clamp01(0.75 * pairTouchDensity + 0.15 * pairSpread + 0.1 * boundarySpread);
+    if (relevant.length < 3) {
+        unknowns.push("History is still thin for architecture-locality evaluation, so AELS is provisional.");
+    }
+    if (crossBoundaryCommits.length === 0) {
+        unknowns.push("No cross-boundary co-change was observed, so WPC/WCC evidence is limited.");
+    }
+    if (WeightedPropagationCost > 0.5) {
+        findings.push({
+            kind: "high_propagation_cost",
+            confidence: 0.76,
+            note: `WeightedPropagationCost is high at ${WeightedPropagationCost.toFixed(3)}, so changes are likely to spread.`,
+        });
+    }
+    if (WeightedClusteringCost > 0.5) {
+        findings.push({
+            kind: "high_clustering_cost",
+            confidence: 0.74,
+            note: `WeightedClusteringCost is high at ${WeightedClusteringCost.toFixed(3)}, so change coupling is spread across boundaries.`,
+        });
+    }
+    const watchlist = Array.from(pairCounts.entries())
+        .map(([key, count]) => {
+        const boundaries = key.split("::");
+        const sampleCommitHashes = crossBoundaryCommits
+            .filter((commit) => boundaries.every((boundary) => commit.touchedBoundaries.has(boundary)))
+            .slice(0, 3)
+            .map((commit) => commit.hash.slice(0, 7));
+        return {
+            boundaries,
+            count,
+            sampleCommitHashes,
+        };
+    })
+        .sort((left, right) => right.count - left.count || left.boundaries.join("::").localeCompare(right.boundaries.join("::")))
+        .slice(0, 5);
+    return {
+        CrossBoundaryCoChange,
+        WeightedPropagationCost,
+        WeightedClusteringCost,
+        confidence: clamp01(average([
+            options.boundaryMap ? 0.86 : 0.68,
+            relevant.length >= 3 ? 0.84 : relevant.length > 0 ? 0.58 : 0.3,
+            crossBoundaryCommits.length > 0 ? 0.82 : 0.62,
+        ], 0.45)),
+        unknowns: uniqueUnknowns(unknowns),
+        findings,
+        watchlist,
+    };
+}

package/dist/src/analyzers/architecture-evolution-shared.d.ts

@@ -0,0 +1,33 @@
+import type { ArchitectureBoundaryMap, ArchitectureConstraints, ArchitectureDeliveryObservationSet, LocalityWatchlistItem } from "../core/contracts.js";
+export interface ArchitectureEvolutionFinding {
+    kind: "cross_boundary_cochange" | "high_propagation_cost" | "high_clustering_cost" | "missing_delivery_observation" | "weak_delivery_score";
+    confidence: number;
+    note: string;
+    commitHash?: string;
+    component?: keyof ArchitectureDeliveryObservationSet["scores"];
+}
+export interface ArchitectureEvolutionLocalityScore {
+    CrossBoundaryCoChange: number;
+    WeightedPropagationCost: number;
+    WeightedClusteringCost: number;
+    confidence: number;
+    unknowns: string[];
+    findings: ArchitectureEvolutionFinding[];
+    watchlist: LocalityWatchlistItem[];
+}
+export interface ArchitectureEvolutionEfficiencyScore {
+    Delivery: number;
+    Locality: number;
+    confidence: number;
+    unknowns: string[];
+    findings: ArchitectureEvolutionFinding[];
+}
+export declare function clamp01(value: number): number;
+export declare function average(values: number[], fallback: number): number;
+export declare function uniqueUnknowns(entries: string[]): string[];
+export declare function architectureBoundaries(constraints: ArchitectureConstraints, boundaryMap?: ArchitectureBoundaryMap): import("../core/contracts.js").ArchitectureBoundaryDefinition[];
+export declare function classifyBoundary(filePath: string, boundaries: Array<{
+    name: string;
+    pathGlobs: string[];
+}>): string | undefined;
+export declare function pairKey(left: string, right: string): string;

package/dist/src/analyzers/architecture-evolution-shared.js

@@ -0,0 +1,29 @@
+import { matchGlobs, toPosixPath } from "../core/io.js";
+export function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function average(values, fallback) {
+    if (values.length === 0) {
+        return fallback;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+export function uniqueUnknowns(entries) {
+    return Array.from(new Set(entries));
+}
+export function architectureBoundaries(constraints, boundaryMap) {
+    if (boundaryMap && boundaryMap.boundaries.length > 0) {
+        return boundaryMap.boundaries;
+    }
+    return constraints.layers.map((layer) => ({
+        name: layer.name,
+        pathGlobs: layer.globs,
+    }));
+}
+export function classifyBoundary(filePath, boundaries) {
+    const normalized = toPosixPath(filePath);
+    return boundaries.find((boundary) => matchGlobs(normalized, boundary.pathGlobs))?.name;
+}
+export function pairKey(left, right) {
+    return [left, right].sort().join("::");
+}

package/dist/src/analyzers/architecture-evolution.d.ts

@@ -0,0 +1,3 @@
+export { scoreArchitectureEvolutionEfficiency } from "./architecture-evolution-efficiency.js";
+export { scoreArchitectureEvolutionLocality } from "./architecture-evolution-locality.js";
+export type { ArchitectureEvolutionEfficiencyScore, ArchitectureEvolutionFinding, ArchitectureEvolutionLocalityScore, } from "./architecture-evolution-shared.js";

package/dist/src/analyzers/architecture-evolution.js

@@ -0,0 +1,2 @@
+export { scoreArchitectureEvolutionEfficiency } from "./architecture-evolution-efficiency.js";
+export { scoreArchitectureEvolutionLocality } from "./architecture-evolution-locality.js";

package/dist/src/analyzers/architecture-observation-ingest-delivery.d.ts

@@ -0,0 +1,9 @@
+import type { ArchitectureDeliveryExportBundle, ArchitectureDeliveryRawObservationSet } from "../core/contracts.js";
+import { type ObservationIngestFinding } from "./architecture-observation-ingest-shared.js";
+export interface IngestedDeliveryExport {
+    deliveryRawObservations: ArchitectureDeliveryRawObservationSet;
+    confidence: number;
+    unknowns: string[];
+    findings: ObservationIngestFinding[];
+}
+export declare function ingestDeliveryExportBundle(bundle: ArchitectureDeliveryExportBundle): IngestedDeliveryExport;

package/dist/src/analyzers/architecture-observation-ingest-delivery.js

@@ -0,0 +1,62 @@
+import { average, clamp01, unique } from "./architecture-observation-ingest-shared.js";
+export function ingestDeliveryExportBundle(bundle) {
+    const findings = [];
+    const unknowns = [];
+    const confidenceSignals = [];
+    const measurements = bundle.measurements;
+    const mappings = [
+        { component: "leadTime", scoreComponent: "LeadTime", observed: measurements.leadTime },
+        {
+            component: "deployFrequency",
+            scoreComponent: "DeployFrequency",
+            observed: measurements.deployFrequency,
+        },
+        { component: "recoveryTime", scoreComponent: "RecoveryTime", observed: measurements.recoveryTime },
+        {
+            component: "changeFailRate",
+            scoreComponent: "ChangeFailRate",
+            observed: measurements.changeFailRate,
+        },
+        { component: "reworkRate", scoreComponent: "ReworkRate", observed: measurements.reworkRate },
+    ];
+    for (const mapping of mappings) {
+        if (mapping.observed === undefined) {
+            unknowns.push(`The delivery export is missing ${mapping.component}.`);
+            findings.push({
+                kind: "delivery_export_missing_signal",
+                confidence: 0.62,
+                note: `The delivery export is missing ${mapping.component}.`,
+                component: mapping.component,
+                ...(bundle.sourceSystem ? { sourceSystem: bundle.sourceSystem } : {}),
+            });
+            confidenceSignals.push(0.55);
+            continue;
+        }
+        findings.push({
+            kind: "delivery_export_signal_mapped",
+            confidence: 0.84,
+            note: `Imported ${mapping.component} from the delivery export into raw delivery input.`,
+            component: mapping.component,
+            observed: mapping.observed,
+            ...(bundle.sourceSystem ? { sourceSystem: bundle.sourceSystem } : {}),
+        });
+        confidenceSignals.push(0.84);
+    }
+    return {
+        deliveryRawObservations: {
+            version: bundle.version,
+            values: {
+                ...(measurements.leadTime !== undefined ? { LeadTime: measurements.leadTime } : {}),
+                ...(measurements.deployFrequency !== undefined ? { DeployFrequency: measurements.deployFrequency } : {}),
+                ...(measurements.recoveryTime !== undefined ? { RecoveryTime: measurements.recoveryTime } : {}),
+                ...(measurements.changeFailRate !== undefined ? { ChangeFailRate: measurements.changeFailRate } : {}),
+                ...(measurements.reworkRate !== undefined ? { ReworkRate: measurements.reworkRate } : {}),
+            },
+            ...(bundle.sourceSystem ? { source: bundle.sourceSystem } : {}),
+            ...(bundle.note ? { note: bundle.note } : {}),
+        },
+        confidence: clamp01(average(confidenceSignals, 0.6)),
+        unknowns: unique(unknowns),
+        findings,
+    };
+}

package/dist/src/analyzers/architecture-observation-ingest-shared.d.ts

@@ -0,0 +1,13 @@
+export interface ObservationIngestFinding {
+    kind: "telemetry_export_band_mapped" | "telemetry_export_missing_signal" | "telemetry_export_pattern_runtime_embedded" | "delivery_export_signal_mapped" | "delivery_export_missing_signal";
+    confidence: number;
+    note: string;
+    sourceSystem?: string;
+    bandId?: string;
+    component?: string;
+    observed?: number;
+    window?: string;
+}
+export declare function clamp01(value: number): number;
+export declare function average(values: number[], fallback: number): number;
+export declare function unique(values: string[]): string[];

package/dist/src/analyzers/architecture-observation-ingest-shared.js

@@ -0,0 +1,12 @@
+export function clamp01(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+export function average(values, fallback) {
+    if (values.length === 0) {
+        return fallback;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+export function unique(values) {
+    return Array.from(new Set(values));
+}

package/dist/src/analyzers/architecture-observation-ingest-telemetry.d.ts

@@ -0,0 +1,10 @@
+import type { ArchitecturePatternRuntimeObservationSet, ArchitectureTelemetryExportBundle, ArchitectureTelemetryRawObservationSet } from "../core/contracts.js";
+import { type ObservationIngestFinding } from "./architecture-observation-ingest-shared.js";
+export interface IngestedTelemetryExport {
+    telemetryRawObservations: ArchitectureTelemetryRawObservationSet;
+    patternRuntimeObservations?: ArchitecturePatternRuntimeObservationSet;
+    confidence: number;
+    unknowns: string[];
+    findings: ObservationIngestFinding[];
+}
+export declare function ingestTelemetryExportBundle(bundle: ArchitectureTelemetryExportBundle): IngestedTelemetryExport;