context-probe 0.1.0

package/dist/src/core/review-items.js

@@ -0,0 +1,116 @@
+import { classifyReviewItemKind, sortReviewItems } from "./measurement-metadata.js";
+function isGlossaryTerm(entity) {
+    return "termId" in entity;
+}
+function getEntityId(entity) {
+    if ("termId" in entity) {
+        return entity.termId;
+    }
+    if ("ruleId" in entity) {
+        return entity.ruleId;
+    }
+    return entity.invariantId;
+}
+function getEntitySummary(entity) {
+    if (isGlossaryTerm(entity)) {
+        return entity.canonicalTerm;
+    }
+    return entity.statement;
+}
+function getReviewItemsFromEntities(entities, evidenceRefs) {
+    const reviewItems = [];
+    entities.forEach((entity, index) => {
+        const targetEntityId = getEntityId(entity);
+        const summary = getEntitySummary(entity);
+        if (entity.confidence < 0.75) {
+            reviewItems.push({
+                reviewItemId: `RV-LOW-${index + 1}`,
+                reason: "low_confidence",
+                kind: "low_confidence",
+                summary: `${summary} has low confidence`,
+                confidence: entity.confidence,
+                evidenceRefs,
+                targetEntityId,
+            });
+        }
+        entity.unknowns.forEach((unknown, unknownIndex) => {
+            reviewItems.push({
+                reviewItemId: `RV-UNK-${index + 1}-${unknownIndex + 1}`,
+                reason: "unknown",
+                kind: classifyReviewItemKind(unknown, "unknown"),
+                summary: unknown,
+                confidence: entity.confidence,
+                evidenceRefs,
+                targetEntityId,
+            });
+        });
+        if (isGlossaryTerm(entity) && entity.collision) {
+            reviewItems.push({
+                reviewItemId: `RV-COLL-${index + 1}`,
+                reason: "collision",
+                kind: "collision",
+                summary: `${entity.canonicalTerm} may have a collision`,
+                confidence: entity.confidence,
+                evidenceRefs,
+                targetEntityId,
+            });
+        }
+    });
+    return reviewItems;
+}
+export function listReviewItems(response) {
+    const reviewItems = [];
+    const evidenceRefs = response.evidence.map((entry) => entry.evidenceId);
+    response.unknowns.forEach((unknown, index) => {
+        reviewItems.push({
+            reviewItemId: `RV-RSP-${index + 1}`,
+            reason: "unknown",
+            kind: classifyReviewItemKind(unknown, "unknown"),
+            summary: unknown,
+            confidence: response.confidence,
+            evidenceRefs,
+        });
+    });
+    if (typeof response.result !== "object" || response.result === null) {
+        return reviewItems;
+    }
+    const result = response.result;
+    if (Array.isArray(result.terms)) {
+        reviewItems.push(...getReviewItemsFromEntities(result.terms, evidenceRefs));
+    }
+    if (Array.isArray(result.rules)) {
+        reviewItems.push(...getReviewItemsFromEntities(result.rules, evidenceRefs));
+    }
+    if (Array.isArray(result.invariants)) {
+        reviewItems.push(...getReviewItemsFromEntities(result.invariants, evidenceRefs));
+    }
+    if (Array.isArray(result.metrics)) {
+        for (const [index, metric] of result.metrics.entries()) {
+            if (metric.confidence < 0.75) {
+                reviewItems.push({
+                    reviewItemId: `RV-METRIC-${index + 1}`,
+                    reason: "low_confidence",
+                    kind: "low_confidence",
+                    summary: `${metric.metricId} has low confidence`,
+                    confidence: metric.confidence,
+                    evidenceRefs,
+                });
+            }
+        }
+    }
+    if (Array.isArray(result.localityWatchlist)) {
+        for (const [index, item] of result.localityWatchlist.entries()) {
+            reviewItems.push({
+                reviewItemId: `RV-HOTSPOT-${index + 1}`,
+                reason: "history_hotspot",
+                kind: "history_hotspot",
+                summary: `Recurring cross-boundary hotspot ${item.boundaries.join(" <-> ")} appears in ${item.count} commits${item.sampleCommitHashes && item.sampleCommitHashes.length > 0
+                    ? ` (${item.sampleCommitHashes.join(", ")})`
+                    : ""}.`,
+                confidence: response.confidence,
+                evidenceRefs,
+            });
+        }
+    }
+    return sortReviewItems(reviewItems);
+}

package/dist/src/core/review-resolutions.d.ts

@@ -0,0 +1,3 @@
+import type { ReviewItem, ReviewResolution, ReviewResolutionLog } from "./contracts.js";
+export declare function resolveReviewItems(reviewItems: ReviewItem[], resolutions: ReviewResolution[]): ReviewResolutionLog;
+export declare function applyReviewOverrides<T extends object>(items: T[], log: ReviewResolutionLog | undefined, idKey: keyof T): T[];

package/dist/src/core/review-resolutions.js

@@ -0,0 +1,43 @@
+export function resolveReviewItems(reviewItems, resolutions) {
+    const resolvedItems = reviewItems.map((reviewItem) => ({
+        ...reviewItem,
+        resolution: resolutions.find((resolution) => resolution.reviewItemId === reviewItem.reviewItemId) ?? null,
+    }));
+    const overrides = resolvedItems.flatMap((reviewItem) => {
+        const patch = reviewItem.resolution?.decision?.patch;
+        if (!reviewItem.targetEntityId || !patch || Object.keys(patch).length === 0) {
+            return [];
+        }
+        return [
+            {
+                targetEntityId: reviewItem.targetEntityId,
+                patch,
+                reason: reviewItem.reason,
+            },
+        ];
+    });
+    return {
+        reviewItems: resolvedItems,
+        overrides,
+    };
+}
+export function applyReviewOverrides(items, log, idKey) {
+    if (!log) {
+        return items;
+    }
+    const overrideMap = new Map(log.overrides.map((override) => [override.targetEntityId, override.patch]));
+    return items.map((item) => {
+        const id = item[idKey];
+        if (typeof id !== "string") {
+            return item;
+        }
+        const patch = overrideMap.get(id);
+        if (!patch) {
+            return item;
+        }
+        return {
+            ...item,
+            ...patch,
+        };
+    });
+}

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

@@ -0,0 +1,2 @@
+export { listReviewItems } from "./review-items.js";
+export { applyReviewOverrides, resolveReviewItems } from "./review-resolutions.js";

package/dist/src/core/review.js

@@ -0,0 +1,2 @@
+export { listReviewItems } from "./review-items.js";
+export { applyReviewOverrides, resolveReviewItems } from "./review-resolutions.js";

package/dist/src/core/scaffold-aggregation.d.ts

@@ -0,0 +1,13 @@
+import type { ArchitectureLayerCandidate, DomainContextCandidate, Evidence } from "./contracts.js";
+export declare function mergeEvidence(candidates: Array<{
+    evidence: Evidence[];
+}>): Evidence[];
+export declare function mergeUnknowns(candidates: Array<{
+    unknowns: string[];
+}>, extras?: string[]): string[];
+export declare function averageConfidence(contextCandidates: Array<{
+    candidate: DomainContextCandidate;
+}>, aggregateCandidates: Array<{
+    confidence: number;
+}>, extraSignals: number[]): number;
+export declare function averageLayerConfidence(layers: ArchitectureLayerCandidate[]): number;

package/dist/src/core/scaffold-aggregation.js

@@ -0,0 +1,18 @@
+import { unique } from "./scaffold-naming.js";
+export function mergeEvidence(candidates) {
+    return candidates.flatMap((candidate) => candidate.evidence).slice(0, 12);
+}
+export function mergeUnknowns(candidates, extras = []) {
+    return unique([...extras, ...candidates.flatMap((candidate) => candidate.unknowns)]);
+}
+export function averageConfidence(contextCandidates, aggregateCandidates, extraSignals) {
+    const signals = [
+        ...contextCandidates.map((entry) => entry.candidate.confidence),
+        ...aggregateCandidates.map((candidate) => candidate.confidence),
+        ...extraSignals,
+    ];
+    return signals.reduce((sum, signal) => sum + signal, 0) / Math.max(1, signals.length);
+}
+export function averageLayerConfidence(layers) {
+    return layers.reduce((sum, layer) => sum + layer.confidence, 0) / Math.max(1, layers.length);
+}

package/dist/src/core/scaffold-architecture-balances.d.ts

@@ -0,0 +1,3 @@
+import type { CodebaseAnalysis } from "./contracts.js";
+import type { SourceGroup } from "./scaffold-shared.js";
+export declare function buildArchitectureLayerBalances(codebase: CodebaseAnalysis, groups: SourceGroup[]): Map<string, number>;

package/dist/src/core/scaffold-architecture-balances.js

@@ -0,0 +1,25 @@
+export function buildArchitectureLayerBalances(codebase, groups) {
+    const fileToGroup = new Map();
+    for (const group of groups) {
+        for (const filePath of group.files) {
+            fileToGroup.set(filePath, group.key);
+        }
+    }
+    const balances = new Map();
+    for (const group of groups) {
+        balances.set(group.key, 0);
+    }
+    for (const dependency of codebase.dependencies) {
+        if (dependency.targetKind !== "file") {
+            continue;
+        }
+        const sourceGroup = fileToGroup.get(dependency.source);
+        const targetGroup = fileToGroup.get(dependency.target);
+        if (!sourceGroup || !targetGroup || sourceGroup === targetGroup) {
+            continue;
+        }
+        balances.set(sourceGroup, (balances.get(sourceGroup) ?? 0) + 1);
+        balances.set(targetGroup, (balances.get(targetGroup) ?? 0) - 1);
+    }
+    return balances;
+}

package/dist/src/core/scaffold-architecture-drafts-builders.d.ts

@@ -0,0 +1,19 @@
+import type { ArchitectureBoundaryMap, ArchitectureConstraints, ArchitectureScenarioCatalog, ArchitectureScenarioObservationTemplate, ArchitectureTopologyModel, CodebaseAnalysis } from "./contracts.js";
+export declare function buildArchitectureScaffoldDrafts(codebase: CodebaseAnalysis, constraints: ArchitectureConstraints): {
+    scenarioObservationsTemplate: {
+        value: ArchitectureScenarioObservationTemplate;
+        yaml: string;
+    };
+    scenarioCatalog: {
+        value: ArchitectureScenarioCatalog;
+        yaml: string;
+    };
+    topologyModel: {
+        value: ArchitectureTopologyModel;
+        yaml: string;
+    };
+    boundaryMap: {
+        value: ArchitectureBoundaryMap;
+        yaml: string;
+    };
+};

package/dist/src/core/scaffold-architecture-drafts-builders.js

@@ -0,0 +1,114 @@
+import YAML from "yaml";
+import { matchGlobs } from "./io.js";
+import { buildScenarioProfile, inferTopologyNodeKind, normalizeNodeId, } from "./scaffold-architecture-drafts-profiles.js";
+function buildScenarioCatalog(constraints) {
+    return {
+        version: constraints.version,
+        scenarios: constraints.layers.map((layer, index) => {
+            const profile = buildScenarioProfile(layer);
+            return {
+                scenarioId: `SC-${String(index + 1).padStart(3, "0")}`,
+                name: profile.name,
+                qualityAttribute: profile.qualityAttribute,
+                stimulus: profile.stimulus,
+                environment: "Docs-first repository with scaffolded architecture constraints.",
+                response: profile.response,
+                responseMeasure: {
+                    metric: profile.metric,
+                    unit: "ratio",
+                },
+                direction: "higher_is_better",
+                priority: index + 1,
+                target: 0.8,
+                worstAcceptable: 0.5,
+            };
+        }),
+    };
+}
+function buildScenarioObservationsTemplate(catalog) {
+    return {
+        version: catalog.version,
+        scenarios: catalog.scenarios.map((scenario) => ({
+            scenarioId: scenario.scenarioId,
+            ...(scenario.name ? { name: scenario.name } : {}),
+            ...(scenario.qualityAttribute ? { qualityAttribute: scenario.qualityAttribute } : {}),
+            priority: scenario.priority,
+            measurementStatus: "needs_measurement",
+            note: `Populate an observed value for ${scenario.qualityAttribute ?? scenario.name ?? scenario.scenarioId} from benchmark or incident review before scoring.`,
+        })),
+    };
+}
+function classifyLayer(path, constraints) {
+    return constraints.layers.find((layer) => matchGlobs(path, layer.globs));
+}
+function buildTopologyModel(codebase, constraints) {
+    const nodes = constraints.layers.map((layer) => ({
+        nodeId: normalizeNodeId(layer.name),
+        kind: inferTopologyNodeKind(layer),
+        isolationBoundary: layer.name,
+    }));
+    const edges = new Map();
+    for (const dependency of codebase.dependencies) {
+        if (dependency.targetKind !== "file") {
+            continue;
+        }
+        const sourceLayer = classifyLayer(dependency.source, constraints);
+        const targetLayer = classifyLayer(dependency.target, constraints);
+        if (!sourceLayer || !targetLayer || sourceLayer.name === targetLayer.name) {
+            continue;
+        }
+        const edgeKey = `${sourceLayer.name} -> ${targetLayer.name}`;
+        if (!edges.has(edgeKey)) {
+            edges.set(edgeKey, {
+                source: normalizeNodeId(sourceLayer.name),
+                target: normalizeNodeId(targetLayer.name),
+                kind: "sync_call",
+            });
+        }
+    }
+    const fallbackEdges = edges.size > 0
+        ? Array.from(edges.values())
+        : nodes.slice(1).map((node, index) => ({
+            source: nodes[index]?.nodeId ?? node.nodeId,
+            target: node.nodeId,
+            kind: "sync_call",
+        }));
+    return {
+        version: constraints.version,
+        nodes,
+        edges: fallbackEdges,
+    };
+}
+function buildBoundaryMap(constraints) {
+    return {
+        version: constraints.version,
+        boundaries: constraints.layers.map((layer) => ({
+            name: layer.name,
+            pathGlobs: layer.globs,
+        })),
+    };
+}
+export function buildArchitectureScaffoldDrafts(codebase, constraints) {
+    const scenarioCatalog = buildScenarioCatalog(constraints);
+    const scenarioObservationsTemplate = buildScenarioObservationsTemplate(scenarioCatalog);
+    const topologyModel = buildTopologyModel(codebase, constraints);
+    const boundaryMap = buildBoundaryMap(constraints);
+    return {
+        scenarioObservationsTemplate: {
+            value: scenarioObservationsTemplate,
+            yaml: YAML.stringify(scenarioObservationsTemplate),
+        },
+        scenarioCatalog: {
+            value: scenarioCatalog,
+            yaml: YAML.stringify(scenarioCatalog),
+        },
+        topologyModel: {
+            value: topologyModel,
+            yaml: YAML.stringify(topologyModel),
+        },
+        boundaryMap: {
+            value: boundaryMap,
+            yaml: YAML.stringify(boundaryMap),
+        },
+    };
+}

package/dist/src/core/scaffold-architecture-drafts-profiles.d.ts

@@ -0,0 +1,11 @@
+import type { LayerDefinition } from "./contracts.js";
+export interface ScenarioDraftProfile {
+    name: string;
+    qualityAttribute: string;
+    metric: string;
+    stimulus: string;
+    response: string;
+}
+export declare function normalizeNodeId(name: string): string;
+export declare function buildScenarioProfile(layer: LayerDefinition): ScenarioDraftProfile;
+export declare function inferTopologyNodeKind(layer: LayerDefinition): "service" | "datastore" | "queue" | "cache" | "gateway" | "worker" | "unknown";

package/dist/src/core/scaffold-architecture-drafts-profiles.js

@@ -0,0 +1,183 @@
+export function normalizeNodeId(name) {
+    return name
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^a-zA-Z0-9]+/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toLowerCase();
+}
+function humanizeLayerName(name) {
+    const stripped = name.replace(/\d+$/u, "");
+    const words = stripped
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .split(/\s+/u)
+        .filter((segment) => segment.length > 0);
+    if (words.length === 0) {
+        return name;
+    }
+    const lowercaseWords = new Set(["and", "or", "of", "the", "to", "for", "in", "on", "with"]);
+    return words
+        .map((word, index) => {
+        const normalized = word.toLowerCase();
+        if (index > 0 && lowercaseWords.has(normalized)) {
+            return normalized;
+        }
+        if (/^[A-Z0-9]{2,}$/u.test(word)) {
+            return word;
+        }
+        return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`;
+    })
+        .join(" ");
+}
+function includesAny(normalizedName, markers) {
+    return markers.some((marker) => normalizedName.includes(marker));
+}
+export function buildScenarioProfile(layer) {
+    const normalized = normalizeNodeId(layer.name);
+    const displayName = humanizeLayerName(layer.name);
+    const stimulus = `A change request primarily affects the ${displayName} layer.`;
+    if (includesAny(normalized, ["domain", "core", "kernel", "model", "foundation"])) {
+        return {
+            name: "Domain cohesion",
+            qualityAttribute: "Domain cohesion",
+            metric: "cohesion",
+            stimulus,
+            response: `The change preserves ${displayName} cohesion and avoids unnecessary cross-layer spread.`,
+        };
+    }
+    if (includesAny(normalized, ["contract", "contracts", "schema", "schemas", "dto", "dtos", "api"])) {
+        return {
+            name: "Contract stability",
+            qualityAttribute: "Contract stability",
+            metric: "stability",
+            stimulus,
+            response: `The change preserves ${displayName} contract boundaries and avoids interface churn.`,
+        };
+    }
+    if (includesAny(normalized, ["ingest", "extract", "import", "load", "parser", "parse", "sync", "crawl"])) {
+        return {
+            name: "Ingestion coverage",
+            qualityAttribute: "Ingestion coverage",
+            metric: "coverage",
+            stimulus,
+            response: `The change keeps ${displayName} ingestion work localized and avoids spreading parsing concerns.`,
+        };
+    }
+    if (includesAny(normalized, ["runtime", "infra", "infrastructure", "platform", "persistence"])) {
+        return {
+            name: "Runtime containment",
+            qualityAttribute: "Runtime containment",
+            metric: "containment",
+            stimulus,
+            response: `The change stays contained within ${displayName} and avoids pulling runtime concerns inward.`,
+        };
+    }
+    if (includesAny(normalized, ["workspace", "project", "bootstrap", "config", "env", "setup"])) {
+        return {
+            name: "Workspace bootstrap readiness",
+            qualityAttribute: "Workspace bootstrap readiness",
+            metric: "readiness",
+            stimulus,
+            response: `The change preserves ${displayName} readiness and keeps setup concerns isolated.`,
+        };
+    }
+    if (includesAny(normalized, ["evaluation", "quality", "benchmark", "review", "telemetry", "metric", "score", "eval"])) {
+        return {
+            name: "Evaluation fidelity",
+            qualityAttribute: "Evaluation fidelity",
+            metric: "fidelity",
+            stimulus,
+            response: `The change preserves ${displayName} fidelity and keeps measurement logic explicit.`,
+        };
+    }
+    if (includesAny(normalized, ["test", "tests", "verify", "validation"])) {
+        return {
+            name: "Validation coverage",
+            qualityAttribute: "Validation coverage",
+            metric: "coverage",
+            stimulus,
+            response: `The change preserves ${displayName} coverage and keeps validation concerns isolated.`,
+        };
+    }
+    if (includesAny(normalized, ["shared", "common", "util", "utils", "types"])) {
+        return {
+            name: "Shared surface stability",
+            qualityAttribute: "Shared surface stability",
+            metric: "stability",
+            stimulus,
+            response: `The change preserves ${displayName} surface stability and avoids leaking shared abstractions.`,
+        };
+    }
+    if (includesAny(normalized, ["data", "store", "storage", "db", "database", "cache", "queue"])) {
+        return {
+            name: "Data locality",
+            qualityAttribute: "Data locality",
+            metric: "locality",
+            stimulus,
+            response: `The change keeps ${displayName} data work localized and avoids data-path spillover.`,
+        };
+    }
+    if (includesAny(normalized, ["tool", "tools", "tooling", "script", "scripts"])) {
+        return {
+            name: "Tooling fit",
+            qualityAttribute: "Tooling fit",
+            metric: "fit",
+            stimulus,
+            response: `The change keeps ${displayName} tooling aligned with operational needs.`,
+        };
+    }
+    if (includesAny(normalized, ["application", "app", "usecase", "usecases", "service", "services", "orchestration"])) {
+        return {
+            name: "Application flow locality",
+            qualityAttribute: "Application flow locality",
+            metric: "locality",
+            stimulus,
+            response: `The change keeps ${displayName} flow localized and avoids unnecessary cross-layer spread.`,
+        };
+    }
+    if (includesAny(normalized, [
+        "adapter",
+        "adapters",
+        "delivery",
+        "presentation",
+        "interface",
+        "interfaces",
+        "ui",
+        "server",
+        "mcp",
+    ])) {
+        return {
+            name: "Boundary adaptation",
+            qualityAttribute: "Boundary adaptation",
+            metric: "adaptation",
+            stimulus,
+            response: `The change keeps ${displayName} boundary work explicit and avoids hidden coupling.`,
+        };
+    }
+    return {
+        name: `${displayName} locality`,
+        qualityAttribute: "Architecture locality",
+        metric: "locality",
+        stimulus,
+        response: `The change remains localized to the ${displayName} layer and avoids unnecessary cross-layer spread.`,
+    };
+}
+export function inferTopologyNodeKind(layer) {
+    const normalized = normalizeNodeId(layer.name);
+    if (/(data|store|storage|db|database|persistence|cache|queue)/u.test(normalized)) {
+        return "datastore";
+    }
+    if (/(worker|job|script|test|eval|quality)/u.test(normalized)) {
+        return "worker";
+    }
+    if (/(api|ui|presentation|delivery|adapter|adapters|extract|extractors|server|mcp)/u.test(normalized)) {
+        return "gateway";
+    }
+    if (/(contract|domain|core|kernel|foundation|model|usecase|usecases|service|services|application|runtime|project|workspace|bootstrap|infra|infrastructure|platform)/u.test(normalized)) {
+        return "service";
+    }
+    return "unknown";
+}

package/dist/src/core/scaffold-architecture-drafts.d.ts

@@ -0,0 +1,12 @@
+import type { ArchitectureBoundaryMap, ArchitectureConstraints, ArchitectureScenarioCatalog, ArchitectureScenarioObservationTemplate, ArchitectureTopologyModel, CodebaseAnalysis } from "./contracts.js";
+export interface ArchitectureScaffoldDraft<T> {
+    value: T;
+    yaml: string;
+}
+export interface ArchitectureScaffoldDrafts {
+    scenarioObservationsTemplate: ArchitectureScaffoldDraft<ArchitectureScenarioObservationTemplate>;
+    scenarioCatalog: ArchitectureScaffoldDraft<ArchitectureScenarioCatalog>;
+    topologyModel: ArchitectureScaffoldDraft<ArchitectureTopologyModel>;
+    boundaryMap: ArchitectureScaffoldDraft<ArchitectureBoundaryMap>;
+}
+export declare function buildArchitectureScaffoldDrafts(codebase: CodebaseAnalysis, constraints: ArchitectureConstraints): ArchitectureScaffoldDrafts;

package/dist/src/core/scaffold-architecture-drafts.js

@@ -0,0 +1,4 @@
+import { buildArchitectureScaffoldDrafts as buildArchitectureScaffoldDraftsImpl } from "./scaffold-architecture-drafts-builders.js";
+export function buildArchitectureScaffoldDrafts(codebase, constraints) {
+    return buildArchitectureScaffoldDraftsImpl(codebase, constraints);
+}

package/dist/src/core/scaffold-architecture-layer-candidates.d.ts

@@ -0,0 +1,3 @@
+import type { ArchitectureLayerCandidate } from "./contracts.js";
+import { type SourceGroup } from "./scaffold-shared.js";
+export declare function buildLayerCandidate(group: SourceGroup, balance: number): ArchitectureLayerCandidate;

package/dist/src/core/scaffold-architecture-layer-candidates.js

@@ -0,0 +1,32 @@
+import { clampConfidence, toEvidence } from "./response.js";
+import { inferGroupDisplayName, LAYER_PRIORITY_HINTS, normalizeName } from "./scaffold-shared.js";
+export function buildLayerCandidate(group, balance) {
+    const name = inferGroupDisplayName(group);
+    const globs = group.pathGlobs;
+    const hintKey = normalizeName(group.segment ?? name).replace(/\s+/gu, "_");
+    const confidence = clampConfidence(0.58 + (LAYER_PRIORITY_HINTS.has(hintKey) ? 0.18 : 0) + (group.files.length >= 2 ? 0.08 : 0));
+    const groupScope = group.heuristicSplit && (group.origins?.length ?? 0) > 1
+        ? `${group.origins?.length ?? 0} source buckets`
+        : group.basePath || ".";
+    return {
+        definition: {
+            name,
+            rank: 0,
+            globs,
+        },
+        confidence,
+        evidence: [
+            toEvidence(`${name} was inferred from ${group.files.length} source file(s) under ${groupScope}.`, {
+                group: group.basePath || ".",
+                ...(group.origins && group.origins.length > 0 ? { origins: group.origins } : {}),
+                outgoingMinusIncomingDependencies: balance,
+                globs,
+            }, undefined, confidence),
+        ],
+        unknowns: group.heuristicSplit
+            ? ["This layer was split from a broad infrastructure bucket by heuristic and should be reviewed."]
+            : group.segment
+                ? []
+                : ["Root-level source files were grouped into a single layer by heuristic."],
+    };
+}

package/dist/src/core/scaffold-architecture-layers.d.ts

@@ -0,0 +1,3 @@
+import type { ArchitectureConstraints, ArchitectureLayerCandidate } from "./contracts.js";
+import type { SourceGroup } from "./scaffold-shared.js";
+export declare function buildArchitectureScaffoldLayers(orderedGroups: SourceGroup[], constraints: ArchitectureConstraints, balances: Map<string, number>): ArchitectureLayerCandidate[];

package/dist/src/core/scaffold-architecture-layers.js

@@ -0,0 +1,15 @@
+import { buildLayerCandidate } from "./scaffold-architecture-layer-candidates.js";
+export function buildArchitectureScaffoldLayers(orderedGroups, constraints, balances) {
+    return orderedGroups.map((group, index) => {
+        const candidate = buildLayerCandidate(group, balances.get(group.key) ?? 0);
+        return {
+            ...candidate,
+            definition: {
+                ...candidate.definition,
+                name: constraints.layers[index]?.name ?? candidate.definition.name,
+                rank: index,
+                globs: constraints.layers[index]?.globs ?? candidate.definition.globs,
+            },
+        };
+    });
+}

package/dist/src/core/scaffold-architecture-orchestration.d.ts

@@ -0,0 +1,5 @@
+import type { ArchitectureConstraintsScaffoldResult } from "./contracts.js";
+import { type ScaffoldComputation } from "./scaffold-shared.js";
+export declare function scaffoldArchitectureConstraints(options: {
+    repoRoot: string;
+}): Promise<ScaffoldComputation<ArchitectureConstraintsScaffoldResult>>;