context-probe 0.1.0

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

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

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

@@ -0,0 +1,68 @@
+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 buildRuntimeArchitectureMetricScores(args) {
+    const { options, policy, context, evidence } = args;
+    const scores = [];
+    if (policy.metrics.OAS) {
+        const oasUnknowns = [
+            ...(options.telemetrySource?.unknowns ?? []),
+            ...(context.telemetryNormalizationResult?.unknowns ?? []),
+            ...(context.telemetryExportIngestResult?.unknowns ?? []),
+            ...(context.patternRuntimeNormalizationResult?.unknowns ?? []),
+            ...context.operationsScore.unknowns,
+            ...(options.telemetryObservations &&
+                (options.telemetryRawObservations ||
+                    options.telemetryNormalizationProfile ||
+                    options.telemetryExport ||
+                    options.telemetrySourceRequested)
+                ? ["Telemetry observations were provided explicitly, so raw/export/source telemetry inputs were not used."]
+                : []),
+            ...(options.telemetryRawObservations && options.telemetryExport
+                ? ["Raw telemetry observations were provided explicitly, so the telemetry export was not used."]
+                : []),
+            ...(options.telemetrySourceRequested &&
+                (options.telemetryObservations ||
+                    (options.telemetryRawObservations && options.telemetryNormalizationProfile) ||
+                    options.telemetryExport)
+                ? ["A higher-priority telemetry input was present, so the telemetry source was not used."]
+                : []),
+            ...(options.patternRuntimeObservations && context.telemetryExportIngestResult?.patternRuntimeObservations
+                ? [
+                    "Pattern runtime observations were provided explicitly, so pattern runtime data inside the telemetry export was not used.",
+                ]
+                : []),
+            ...(options.patternRuntimeObservations &&
+                options.patternRuntimeRawRequested &&
+                options.patternRuntimeNormalizationProfileRequested
+                ? ["Pattern runtime observations were provided explicitly, so raw pattern runtime input was not used."]
+                : []),
+            ...(context.usablePatternRuntimeRaw && context.telemetryExportIngestResult?.patternRuntimeObservations
+                ? [
+                    "Raw pattern runtime input was provided explicitly, so pattern runtime data inside the telemetry export was not used.",
+                ]
+                : []),
+        ];
+        scores.push(toMetricScore("OAS", evaluateFormula(policy.metrics.OAS.formula, {
+            CommonOps: context.operationsScore.CommonOps,
+            PatternRuntime: context.operationsScore.PatternRuntime,
+        }), {
+            CommonOps: context.operationsScore.CommonOps,
+            PatternRuntime: context.operationsScore.PatternRuntime,
+            band_count: context.operationsScore.bandCount,
+            weighted_band_coverage: context.operationsScore.weightedBandCoverage,
+        }, evidenceRefs(evidence.telemetrySource, evidence.telemetryInput, evidence.telemetryExport, evidence.telemetryNormalization, evidence.patternRuntimeNormalization, evidence.operations), confidenceFromSignals([
+            context.operationsScore.confidence,
+            ...(context.patternRuntimeNormalizationResult ? [context.patternRuntimeNormalizationResult.confidence] : []),
+            ...(context.telemetryNormalizationResult
+                ? [context.telemetryNormalizationResult.confidence]
+                : options.telemetrySource
+                    ? [options.telemetrySource.confidence, context.telemetryExportIngestResult?.confidence ?? 0.8]
+                    : context.telemetryExportIngestResult
+                        ? [context.telemetryExportIngestResult.confidence]
+                        : [0.85]),
+        ]), Array.from(new Set(oasUnknowns))));
+    }
+    return scores;
+}

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

@@ -0,0 +1,4 @@
+import type { ArchitectureEvidenceBundle } from "./architecture-scoring-evidence.js";
+import type { ArchitecturePolicy, ArchitectureScoringContext, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+import type { MetricScore } from "./contracts.js";
+export declare function buildArchitectureMetricScores(options: ComputeArchitectureScoresOptions, policy: ArchitecturePolicy, context: ArchitectureScoringContext, evidence: ArchitectureEvidenceBundle): MetricScore[];

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

@@ -0,0 +1,14 @@
+import { buildCompositeArchitectureMetricScores } from "./architecture-scoring-metrics-composite.js";
+import { buildCoreArchitectureMetricScores } from "./architecture-scoring-metrics-core.js";
+import { buildEvolutionArchitectureMetricScores } from "./architecture-scoring-metrics-evolution.js";
+import { buildRuntimeArchitectureMetricScores } from "./architecture-scoring-metrics-runtime.js";
+export function buildArchitectureMetricScores(options, policy, context, evidence) {
+    const builderArgs = { options, policy, context, evidence };
+    const scores = [
+        ...buildCoreArchitectureMetricScores(builderArgs),
+        ...buildRuntimeArchitectureMetricScores(builderArgs),
+        ...buildEvolutionArchitectureMetricScores(builderArgs),
+    ];
+    scores.push(...buildCompositeArchitectureMetricScores(builderArgs, scores));
+    return scores;
+}

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

@@ -0,0 +1,94 @@
+import type { detectDirectionViolations, scoreDependencyDirection } from "../analyzers/architecture.js";
+import type { scoreInterfaceProtocolStability } from "../analyzers/architecture-contracts.js";
+import type { ingestComplexityExportBundle } from "../analyzers/architecture-cti-ingest.js";
+import type { normalizeDeliveryObservations } from "../analyzers/architecture-delivery-normalization.js";
+import type { scoreArchitectureEvolutionEfficiency, scoreArchitectureEvolutionLocality } from "../analyzers/architecture-evolution.js";
+import type { ingestDeliveryExportBundle, ingestTelemetryExportBundle } from "../analyzers/architecture-observation-ingest.js";
+import type { scoreOperationalAdequacy } from "../analyzers/architecture-operations.js";
+import type { normalizePatternRuntimeObservations } from "../analyzers/architecture-pattern-runtime-normalization.js";
+import type { scoreBoundaryPurity } from "../analyzers/architecture-purity.js";
+import type { scoreQualityScenarioFit } from "../analyzers/architecture-scenarios.js";
+import type { ResolvedCanonicalSource } from "../analyzers/architecture-source-loader.js";
+import type { normalizeTelemetryObservations } from "../analyzers/architecture-telemetry-normalization.js";
+import type { scoreTopologyIsolation } from "../analyzers/architecture-topology.js";
+import type { scoreComplexityTax } from "../analyzers/cti.js";
+import type { ArchitectureBoundaryMap, ArchitectureComplexityExportBundle, ArchitectureConstraints, ArchitectureContractBaseline, ArchitectureDeliveryExportBundle, ArchitectureDeliveryNormalizationProfile, ArchitectureDeliveryObservationSet, ArchitectureDeliveryRawObservationSet, ArchitecturePatternRuntimeNormalizationProfile, ArchitecturePatternRuntimeObservationSet, ArchitecturePatternRuntimeRawObservationSet, ArchitectureScenarioCatalog, ArchitectureScenarioQualitySummary, ArchitectureTelemetryExportBundle, ArchitectureTelemetryNormalizationProfile, ArchitectureTelemetryObservationSet, ArchitectureTelemetryRawObservationSet, ArchitectureTopologyModel, CochangeCommit, LocalityWatchlistItem, PolicyConfig, ProvenanceRef, ScenarioObservationSet, TopologyRuntimeObservationSet } from "./contracts.js";
+import type { getDomainPolicy } from "./policy.js";
+export interface ComputeArchitectureScoresOptions {
+    repoPath: string;
+    constraints: ArchitectureConstraints;
+    policyConfig: PolicyConfig;
+    profileName: string;
+    scenarioCatalog?: ArchitectureScenarioCatalog;
+    scenarioObservations?: ScenarioObservationSet;
+    scenarioObservationSource?: ResolvedCanonicalSource<ScenarioObservationSet>;
+    scenarioObservationSourceRequested?: boolean;
+    topologyModel?: ArchitectureTopologyModel;
+    boundaryMap?: ArchitectureBoundaryMap;
+    contractBaseline?: ArchitectureContractBaseline;
+    contractBaselineSource?: ResolvedCanonicalSource<ArchitectureContractBaseline>;
+    contractBaselineSourceRequested?: boolean;
+    runtimeObservations?: TopologyRuntimeObservationSet;
+    deliveryObservations?: ArchitectureDeliveryObservationSet;
+    deliveryRawObservations?: ArchitectureDeliveryRawObservationSet;
+    deliveryExport?: ArchitectureDeliveryExportBundle;
+    deliverySource?: ResolvedCanonicalSource<ArchitectureDeliveryExportBundle>;
+    deliverySourceRequested?: boolean;
+    deliveryNormalizationProfile?: ArchitectureDeliveryNormalizationProfile;
+    telemetryObservations?: ArchitectureTelemetryObservationSet;
+    telemetryRawObservations?: ArchitectureTelemetryRawObservationSet;
+    telemetryExport?: ArchitectureTelemetryExportBundle;
+    telemetrySource?: ResolvedCanonicalSource<ArchitectureTelemetryExportBundle>;
+    telemetrySourceRequested?: boolean;
+    telemetryNormalizationProfile?: ArchitectureTelemetryNormalizationProfile;
+    patternRuntimeObservations?: ArchitecturePatternRuntimeObservationSet;
+    patternRuntimeRawObservations?: ArchitecturePatternRuntimeRawObservationSet;
+    patternRuntimeRawRequested?: boolean;
+    patternRuntimeNormalizationProfile?: ArchitecturePatternRuntimeNormalizationProfile;
+    patternRuntimeNormalizationProfileRequested?: boolean;
+    complexityExport?: ArchitectureComplexityExportBundle;
+    complexitySource?: ResolvedCanonicalSource<ArchitectureComplexityExportBundle>;
+    complexitySourceRequested?: boolean;
+    additionalProvenance?: ProvenanceRef[];
+}
+export type ArchitecturePolicy = ReturnType<typeof getDomainPolicy>;
+export type DirectionScore = ReturnType<typeof scoreDependencyDirection>;
+export type ArchitectureViolations = ReturnType<typeof detectDirectionViolations>;
+export type PurityScore = ReturnType<typeof scoreBoundaryPurity>;
+export type ProtocolScore = Awaited<ReturnType<typeof scoreInterfaceProtocolStability>>;
+export type ScenarioScore = ReturnType<typeof scoreQualityScenarioFit>;
+export type TopologyScore = ReturnType<typeof scoreTopologyIsolation>;
+export type TelemetryExportIngestResult = ReturnType<typeof ingestTelemetryExportBundle>;
+export type PatternRuntimeNormalizationResult = ReturnType<typeof normalizePatternRuntimeObservations>;
+export type TelemetryNormalizationResult = ReturnType<typeof normalizeTelemetryObservations>;
+export type OperationsScore = ReturnType<typeof scoreOperationalAdequacy>;
+export type DeliveryExportIngestResult = ReturnType<typeof ingestDeliveryExportBundle>;
+export type DeliveryNormalizationResult = ReturnType<typeof normalizeDeliveryObservations>;
+export type ComplexityExportIngestResult = ReturnType<typeof ingestComplexityExportBundle>;
+export type ComplexityScore = ReturnType<typeof scoreComplexityTax>;
+export type EvolutionLocalityScore = ReturnType<typeof scoreArchitectureEvolutionLocality>;
+export type EvolutionEfficiencyScore = ReturnType<typeof scoreArchitectureEvolutionEfficiency>;
+export interface ArchitectureScoringContext {
+    directionScore: DirectionScore;
+    purityScore: PurityScore;
+    protocolScore: ProtocolScore;
+    scenarioScore: ScenarioScore;
+    topologyScore: TopologyScore;
+    telemetryExportIngestResult?: TelemetryExportIngestResult;
+    patternRuntimeNormalizationResult?: PatternRuntimeNormalizationResult;
+    telemetryNormalizationResult?: TelemetryNormalizationResult;
+    operationsScore: OperationsScore;
+    deliveryExportIngestResult?: DeliveryExportIngestResult;
+    deliveryNormalizationResult?: DeliveryNormalizationResult;
+    complexityExportIngestResult?: ComplexityExportIngestResult;
+    complexityScore: ComplexityScore;
+    architectureCommits: CochangeCommit[];
+    architectureHistoryDiagnostics: string[];
+    evolutionLocalityScore: EvolutionLocalityScore;
+    evolutionEfficiencyScore: EvolutionEfficiencyScore;
+    localityValue: number;
+    localityWatchlist: LocalityWatchlistItem[];
+    scenarioQuality?: ArchitectureScenarioQualitySummary;
+    violations: ArchitectureViolations;
+    usablePatternRuntimeRaw: boolean;
+}

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

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

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

@@ -0,0 +1,9 @@
+import type { ArchitectureScoringContext, ArchitectureViolations, ComputeArchitectureScoresOptions } from "./architecture-scoring-types.js";
+import type { CommandResponse, MetricScore } from "./contracts.js";
+export declare function computeArchitectureScores(options: ComputeArchitectureScoresOptions): Promise<CommandResponse<{
+    domainId: "architecture_design";
+    metrics: MetricScore[];
+    violations: ArchitectureViolations;
+    scenarioQuality?: ArchitectureScoringContext["scenarioQuality"];
+    localityWatchlist?: ArchitectureScoringContext["localityWatchlist"];
+}>>;

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

@@ -0,0 +1,82 @@
+import { buildArchitectureEvidence, collectArchitectureEvidence } from "./architecture-scoring-evidence.js";
+import { resolveArchitectureEvolutionInputs } from "./architecture-scoring-evolution-inputs.js";
+import { resolveArchitectureScoringInputs } from "./architecture-scoring-inputs.js";
+import { buildArchitectureMetricScores } from "./architecture-scoring-metrics.js";
+import { getDomainPolicy } from "./policy.js";
+import { confidenceFromSignals, createResponse, toProvenance } from "./response.js";
+export async function computeArchitectureScores(options) {
+    const startedAt = Date.now();
+    const analysisStartedAt = Date.now();
+    const { repoPath, policyConfig, profileName } = options;
+    const policy = getDomainPolicy(policyConfig, profileName, "architecture_design");
+    const inputResults = await resolveArchitectureScoringInputs(options, policy);
+    const historyStartedAt = Date.now();
+    const evolutionResults = await resolveArchitectureEvolutionInputs(options, policy, inputResults.deliveryNormalizationResult);
+    const historyMs = Date.now() - historyStartedAt;
+    const context = {
+        directionScore: inputResults.directionScore,
+        purityScore: inputResults.purityScore,
+        protocolScore: inputResults.protocolScore,
+        scenarioScore: inputResults.scenarioScore,
+        topologyScore: inputResults.topologyScore,
+        ...(inputResults.telemetryExportIngestResult
+            ? { telemetryExportIngestResult: inputResults.telemetryExportIngestResult }
+            : {}),
+        ...(inputResults.patternRuntimeNormalizationResult
+            ? { patternRuntimeNormalizationResult: inputResults.patternRuntimeNormalizationResult }
+            : {}),
+        ...(inputResults.telemetryNormalizationResult
+            ? { telemetryNormalizationResult: inputResults.telemetryNormalizationResult }
+            : {}),
+        operationsScore: inputResults.operationsScore,
+        ...(inputResults.deliveryExportIngestResult
+            ? { deliveryExportIngestResult: inputResults.deliveryExportIngestResult }
+            : {}),
+        ...(inputResults.deliveryNormalizationResult
+            ? { deliveryNormalizationResult: inputResults.deliveryNormalizationResult }
+            : {}),
+        ...(inputResults.complexityExportIngestResult
+            ? { complexityExportIngestResult: inputResults.complexityExportIngestResult }
+            : {}),
+        complexityScore: inputResults.complexityScore,
+        architectureCommits: evolutionResults.architectureCommits,
+        architectureHistoryDiagnostics: evolutionResults.architectureHistoryDiagnostics,
+        evolutionLocalityScore: evolutionResults.evolutionLocalityScore,
+        evolutionEfficiencyScore: evolutionResults.evolutionEfficiencyScore,
+        localityValue: evolutionResults.localityValue,
+        localityWatchlist: evolutionResults.evolutionLocalityScore.watchlist,
+        ...(inputResults.scenarioQuality ? { scenarioQuality: inputResults.scenarioQuality } : {}),
+        violations: inputResults.violations,
+        usablePatternRuntimeRaw: inputResults.usablePatternRuntimeRaw,
+    };
+    const architectureEvidence = buildArchitectureEvidence(options, context);
+    const scores = buildArchitectureMetricScores(options, policy, context, architectureEvidence);
+    const evidence = collectArchitectureEvidence(architectureEvidence);
+    return createResponse({
+        domainId: "architecture_design",
+        metrics: scores,
+        violations: inputResults.violations,
+        ...(context.scenarioQuality ? { scenarioQuality: context.scenarioQuality } : {}),
+        ...(context.localityWatchlist.length > 0 ? { localityWatchlist: context.localityWatchlist } : {}),
+    }, {
+        status: evolutionResults.architectureHistoryDiagnostics.length > 0 ? "warning" : "ok",
+        evidence,
+        confidence: confidenceFromSignals(scores.map((score) => score.confidence)),
+        unknowns: Array.from(new Set(scores.flatMap((score) => score.unknowns))),
+        diagnostics: evolutionResults.architectureHistoryDiagnostics,
+        provenance: [
+            toProvenance(repoPath, "architecture_design"),
+            toProvenance(repoPath, `profile=${profileName}`),
+            ...(options.additionalProvenance ?? []),
+        ],
+        meta: {
+            runtime: {
+                totalMs: Date.now() - startedAt,
+                stages: {
+                    historyMs,
+                    analysisMs: Date.now() - analysisStartedAt - historyMs,
+                },
+            },
+        },
+    });
+}

package/dist/src/core/artifacts.d.ts

@@ -0,0 +1,3 @@
+import type { Artifact, Fragment } from "./contracts.js";
+export declare function registerArtifacts(root: string): Promise<Artifact[]>;
+export declare function normalizeDocuments(root: string): Promise<Fragment[]>;

package/dist/src/core/artifacts.js

@@ -0,0 +1,58 @@
+import { hashText, isDocumentFile, isSourceFile, listFiles, readText, relativePath } from "./io.js";
+function inferArtifactType(filePath) {
+    if (isDocumentFile(filePath)) {
+        return "document";
+    }
+    if (isSourceFile(filePath)) {
+        return "source_code";
+    }
+    if (filePath.endsWith(".json") || filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+        return "config";
+    }
+    return "unknown";
+}
+export async function registerArtifacts(root) {
+    const files = await listFiles(root);
+    const artifacts = [];
+    for (const filePath of files) {
+        const content = await readText(filePath);
+        artifacts.push({
+            artifactId: `ART-${hashText(`${filePath}:${content}`).slice(0, 8)}`,
+            type: inferArtifactType(filePath),
+            path: relativePath(root, filePath),
+            size: content.length,
+            hash: hashText(content),
+            collectedAt: new Date().toISOString(),
+        });
+    }
+    return artifacts;
+}
+export async function normalizeDocuments(root) {
+    const files = await listFiles(root);
+    const fragments = [];
+    for (const filePath of files.filter((filePath) => isDocumentFile(filePath) && !filePath.toLowerCase().endsWith(".ja.md"))) {
+        const content = await readText(filePath);
+        const relative = relativePath(root, filePath);
+        const paragraphs = content
+            .split(/\n\s*\n/g)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        let searchCursor = 0;
+        for (const paragraph of paragraphs) {
+            const startIndex = content.indexOf(paragraph, searchCursor);
+            const lineStart = content.slice(0, Math.max(0, startIndex)).split("\n").length;
+            const lineEnd = lineStart + paragraph.split("\n").length - 1;
+            searchCursor = startIndex + paragraph.length;
+            fragments.push({
+                fragmentId: `FRG-${hashText(`${relative}:${paragraph}`).slice(0, 10)}`,
+                artifactId: `ART-${hashText(`${relative}:${content}`).slice(0, 8)}`,
+                kind: paragraph.startsWith("#") ? "heading" : "paragraph",
+                text: paragraph,
+                path: relative,
+                lineStart,
+                lineEnd,
+            });
+        }
+    }
+    return fragments.sort((left, right) => left.path.localeCompare(right.path));
+}

package/dist/src/core/boundary-fitness-attraction.d.ts

@@ -0,0 +1,4 @@
+export declare function computeAttractionScore<T extends {
+    contexts: string[];
+    confidence: number;
+}>(signals: T[]): number;

package/dist/src/core/boundary-fitness-attraction.js

@@ -0,0 +1,11 @@
+import { clamp01 } from "./boundary-fitness-shared.js";
+import { localizationScore } from "./boundary-fitness-signals.js";
+export function computeAttractionScore(signals) {
+    if (signals.length === 0) {
+        return 0.45;
+    }
+    const weightedAttraction = signals.map((signal) => localizationScore(signal.contexts) * signal.confidence);
+    const attractionWeight = signals.map((signal) => signal.confidence);
+    return clamp01(weightedAttraction.reduce((sum, value) => sum + value, 0) /
+        Math.max(0.0001, attractionWeight.reduce((sum, value) => sum + value, 0)));
+}

package/dist/src/core/boundary-fitness-contexts.d.ts

@@ -0,0 +1,7 @@
+import type { DomainModel, Fragment, GlossaryTerm, TermTraceLink } from "./contracts.js";
+export declare function buildFragmentContextMentions(fragments: Fragment[], model: DomainModel): Map<string, string[]>;
+export declare function collectTermContexts(term: GlossaryTerm, link: TermTraceLink | undefined, fragmentContextMentions: Map<string, string[]>, model: DomainModel): string[];
+export declare function collectStatementContexts(statement: string, fragmentIds: string[], fragmentContextMentions: Map<string, string[]>, mappedTerms: Array<{
+    labels: string[];
+    contexts: string[];
+}>, model: DomainModel): string[];

package/dist/src/core/boundary-fitness-contexts.js

@@ -0,0 +1,80 @@
+import { scoreTextAgainstLabel } from "./domain-design-matching.js";
+import { matchGlobs } from "./io.js";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isAsciiLabel(value) {
+    return /^[A-Za-z0-9 _-]+$/.test(value);
+}
+function contextMentionPattern(name) {
+    if (isAsciiLabel(name)) {
+        return new RegExp(`(^|[^A-Za-z0-9_])${escapeRegExp(name)}([^A-Za-z0-9_]|$)`, "i");
+    }
+    return null;
+}
+function detectContextMentions(text, model) {
+    return model.contexts
+        .filter((context) => {
+        const pattern = contextMentionPattern(context.name);
+        if (pattern) {
+            return pattern.test(text);
+        }
+        return text.includes(context.name);
+    })
+        .map((context) => context.name);
+}
+function mapOccurrenceToContexts(occurrence, model) {
+    if (occurrence.kind !== "code") {
+        return [];
+    }
+    return model.contexts
+        .filter((context) => matchGlobs(occurrence.path, context.pathGlobs))
+        .map((context) => context.name);
+}
+function unique(values) {
+    return Array.from(new Set(values));
+}
+export function buildFragmentContextMentions(fragments, model) {
+    return new Map(fragments.map((fragment) => [fragment.fragmentId, unique(detectContextMentions(fragment.text, model))]));
+}
+export function collectTermContexts(term, link, fragmentContextMentions, model) {
+    const contexts = new Set();
+    for (const occurrence of link?.occurrences ?? []) {
+        for (const contextName of mapOccurrenceToContexts(occurrence, model)) {
+            contexts.add(contextName);
+        }
+        if (occurrence.kind === "document" && occurrence.fragmentId) {
+            for (const contextName of fragmentContextMentions.get(occurrence.fragmentId) ?? []) {
+                contexts.add(contextName);
+            }
+        }
+    }
+    for (const fragmentId of term.fragmentIds) {
+        for (const contextName of fragmentContextMentions.get(fragmentId) ?? []) {
+            contexts.add(contextName);
+        }
+    }
+    return Array.from(contexts);
+}
+export function collectStatementContexts(statement, fragmentIds, fragmentContextMentions, mappedTerms, model) {
+    const contexts = new Set();
+    for (const contextName of detectContextMentions(statement, model)) {
+        contexts.add(contextName);
+    }
+    for (const fragmentId of fragmentIds) {
+        for (const contextName of fragmentContextMentions.get(fragmentId) ?? []) {
+            contexts.add(contextName);
+        }
+    }
+    for (const term of mappedTerms) {
+        if (term.contexts.length === 0) {
+            continue;
+        }
+        if (term.labels.some((label) => scoreTextAgainstLabel(statement, label) > 0)) {
+            for (const contextName of term.contexts) {
+                contexts.add(contextName);
+            }
+        }
+    }
+    return Array.from(contexts);
+}

package/dist/src/core/boundary-fitness-core.d.ts

@@ -0,0 +1,28 @@
+import type { BoundaryLeakFinding, ContractUsageReport, DomainModel, Evidence, Fragment, GlossaryTerm, InvariantCandidate, ModelCodeLink, RuleCandidate, TermTraceLink } from "./contracts.js";
+import type { ProgressReporter } from "./progress.js";
+export interface BoundaryFitnessResult {
+    A: number;
+    R: number;
+    confidence: number;
+    evidence: Evidence[];
+    unknowns: string[];
+    diagnostics: string[];
+    details: {
+        localizedSignals: number;
+        ambiguousSignals: number;
+        explicitSeparationSignals: number;
+        mappedTerms: number;
+    };
+}
+export declare function computeBoundaryFitness(input: {
+    model: DomainModel;
+    fragments: Fragment[];
+    terms: GlossaryTerm[];
+    links: TermTraceLink[];
+    rules: RuleCandidate[];
+    invariants: InvariantCandidate[];
+    contractUsage: ContractUsageReport;
+    leakFindings: BoundaryLeakFinding[];
+    modelCodeLinks: ModelCodeLink[];
+    reportProgress?: ProgressReporter;
+}): BoundaryFitnessResult;

package/dist/src/core/boundary-fitness-core.js

@@ -0,0 +1,132 @@
+import { computeAttractionScore } from "./boundary-fitness-attraction.js";
+import { buildFragmentContextMentions, collectTermContexts } from "./boundary-fitness-contexts.js";
+import { buildBoundaryFitnessEvidence } from "./boundary-fitness-evidence.js";
+import { computeCodeBoundaryStrength, computeSeparationScore } from "./boundary-fitness-separation.js";
+import { average, clamp01, hasSeparationSignal, unique } from "./boundary-fitness-shared.js";
+import { buildAttractionSignals } from "./boundary-fitness-signals.js";
+export function computeBoundaryFitness(input) {
+    const computed = computeBoundaryFitnessComponents(input);
+    return {
+        A: computed.A,
+        R: computed.R,
+        confidence: computed.confidence,
+        evidence: computed.evidence,
+        unknowns: unique(computed.unknowns),
+        diagnostics: computed.diagnostics,
+        details: computed.details,
+    };
+}
+function computeBoundaryFitnessComponents(input) {
+    const unknowns = [];
+    const diagnostics = [];
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: mapping document fragments to domain contexts.",
+    });
+    const fragmentContextMentions = buildFragmentContextMentions(input.fragments, input.model);
+    const linkByTermId = new Map(input.links.map((link) => [link.termId, link]));
+    const termContextEntries = [];
+    let lastHeartbeatAt = Date.now();
+    for (const [index, term] of input.terms.entries()) {
+        const now = Date.now();
+        if (now - lastHeartbeatAt >= 5000) {
+            input.reportProgress?.({
+                phase: "docs",
+                message: `BFS: mapped ${index}/${input.terms.length} glossary term context(s).`,
+                elapsedMs: now - lastHeartbeatAt,
+            });
+            lastHeartbeatAt = now;
+        }
+        termContextEntries.push([
+            term.termId,
+            collectTermContexts(term, linkByTermId.get(term.termId), fragmentContextMentions, input.model),
+        ]);
+    }
+    const termContexts = new Map(termContextEntries);
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: building attraction signals from glossary, rules, and invariants.",
+    });
+    const attractionSignals = buildAttractionSignals({
+        terms: input.terms,
+        termContexts,
+        rules: input.rules,
+        invariants: input.invariants,
+        fragments: input.fragments,
+        fragmentContextMentions,
+        model: input.model,
+        ...(input.reportProgress ? { reportProgress: input.reportProgress } : {}),
+    });
+    const localizedSignals = attractionSignals.filter((signal) => signal.contexts.length === 1);
+    const ambiguousSignals = attractionSignals.filter((signal) => signal.contexts.length > 1);
+    const A = computeAttractionScore(attractionSignals);
+    if (attractionSignals.length === 0) {
+        unknowns.push("Terms, rules, and invariants tied to contexts are too weakly observed, so A(P) is provisional.");
+    }
+    const separationFragments = input.fragments.filter((fragment) => {
+        const mentions = fragmentContextMentions.get(fragment.fragmentId) ?? [];
+        return mentions.length >= 2 && hasSeparationSignal(fragment.text);
+    });
+    const explicitSeparationScore = separationFragments.length > 0 ? 1 : 0.5;
+    if (separationFragments.length === 0) {
+        unknowns.push("Explicit separation evidence such as ownership or security is limited, so part of R(P) is approximate.");
+    }
+    const modelCoverageScore = average(input.modelCodeLinks.map((link) => link.coverage), 0.55);
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: evaluating code-level separation and model coverage.",
+    });
+    const codeBoundaryStrength = computeCodeBoundaryStrength({
+        applicableReferences: input.contractUsage.applicableReferences,
+        adherence: input.contractUsage.adherence,
+        leakCount: input.leakFindings.length,
+        modelCoverageScore,
+    });
+    if (input.contractUsage.applicableReferences === 0) {
+        unknowns.push("There are too few cross-context references to derive strong code-level separation evidence.");
+    }
+    const R = computeSeparationScore({
+        attractionSignalCount: attractionSignals.length,
+        localizedSignalCount: localizedSignals.length,
+        explicitSeparationScore,
+        codeBoundaryStrength,
+        modelCoverageScore,
+    });
+    const confidenceSignals = [
+        attractionSignals.length > 0
+            ? average(attractionSignals.map((signal) => signal.confidence), 0.55)
+            : 0.5,
+        separationFragments.length > 0 ? 0.8 : 0.55,
+        input.model.contexts.length >= 2 ? 0.85 : 0.35,
+        input.contractUsage.applicableReferences > 0 ? 0.85 : 0.6,
+    ];
+    if (input.model.contexts.length < 2) {
+        unknowns.push("Fewer than two contexts were defined, so BFS should be interpreted carefully.");
+    }
+    if (input.modelCodeLinks.some((link) => link.coverage === 0)) {
+        diagnostics.push("Some contexts could not be linked to code, which lowers model coverage.");
+    }
+    input.reportProgress?.({
+        phase: "docs",
+        message: "BFS: building evidence and confidence summary.",
+    });
+    return {
+        A,
+        R,
+        confidence: clamp01(average(confidenceSignals, 0.55)),
+        evidence: buildBoundaryFitnessEvidence({
+            localizedSignals,
+            ambiguousSignals,
+            separationFragments,
+            fragmentContextMentions,
+        }),
+        unknowns,
+        diagnostics,
+        details: {
+            localizedSignals: localizedSignals.length,
+            ambiguousSignals: ambiguousSignals.length,
+            explicitSeparationSignals: separationFragments.length,
+            mappedTerms: Array.from(termContexts.values()).filter((contexts) => contexts.length > 0).length,
+        },
+    };
+}

package/dist/src/core/boundary-fitness-evidence.d.ts

@@ -0,0 +1,17 @@
+import type { Fragment } from "./contracts.js";
+import { toEvidence } from "./response.js";
+type AttractionSignal = {
+    summary: string;
+    contexts: string[];
+    confidence: number;
+    kind: string;
+    fragmentIds?: string[];
+    linkedEntities?: string[];
+};
+export declare function buildBoundaryFitnessEvidence(input: {
+    localizedSignals: AttractionSignal[];
+    ambiguousSignals: AttractionSignal[];
+    separationFragments: Fragment[];
+    fragmentContextMentions: Map<string, string[]>;
+}): ReturnType<typeof toEvidence>[];
+export {};