Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add AIR-X2 route selection framework

Yuechen Li6611f722122e
diff --git a/Aetheris.Kernel.Core.Tests/Air/AirRouteSelectorTests.cs b/Aetheris.Kernel.Core.Tests/Air/AirRouteSelectorTests.cs
new file mode 100644
index 00000000..5dc85568
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Air/AirRouteSelectorTests.cs
@@ -0,0 +1,132 @@
+using Aetheris.Kernel.Core.Air;
+
+namespace Aetheris.Kernel.Core.Tests.Air;
+
+public sealed class AirRouteSelectorTests
+{
+ [Fact]
+ public void AirRouteSelector_PrismaticSectionTransition_UsesDirectSelection()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForPrismaticSectionTransition());
+
+ Assert.True(decision.Succeeded);
+ Assert.Equal(AirRouteSelectionMode.Direct, decision.SelectionMode);
+ Assert.Equal(AirRouteKind.PrismaticSectionTransitionEmitter, decision.SelectedRouteKind);
+ Assert.Single(decision.Candidates, c => c.Status == AirRouteCandidateStatus.Admitted);
+ Assert.DoesNotContain(decision.Diagnostics, d => d.Code.Contains("judgment-utility", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(decision.Diagnostics, d => d.Code == "air-x2-no-production-route-replacement");
+ }
+
+ [Fact]
+ public void AirRouteSelector_ProfileExtrude_UsesDirectSelection()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForProfileExtrude());
+
+ Assert.True(decision.Succeeded);
+ Assert.Equal(AirRouteSelectionMode.Direct, decision.SelectionMode);
+ Assert.Equal(AirRouteKind.ProfileExtrudeEmitter, decision.SelectedRouteKind);
+ Assert.Single(decision.Candidates, c => c.Status == AirRouteCandidateStatus.Admitted);
+ Assert.DoesNotContain(decision.Diagnostics, d => d.Code.Contains("judgment-utility", StringComparison.OrdinalIgnoreCase));
+ Assert.Contains(decision.Diagnostics, d => d.Code == "air-x2-no-production-route-replacement");
+ }
+
+ [Fact]
+ public void AirRouteSelector_TopFaceLoopChamfer_UsesSwitchMatchSelection()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("top-face-loop-chamfer", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.UniformChamfer, "history-known top-face loop"));
+
+ Assert.True(decision.Succeeded);
+ Assert.Equal(AirRouteSelectionMode.SwitchMatch, decision.SelectionMode);
+ Assert.Equal(AirRouteKind.TopFaceLoopChamferPrismatic, decision.SelectedRouteKind);
+ Assert.Equal(AirSelectionClass.FaceBoundaryLoop, decision.Summary.SelectionClass);
+ Assert.Equal(AirRuleKind.UniformChamfer, decision.Summary.RuleKind);
+ Assert.Contains(decision.Diagnostics, d => d.Code == "air-x2-switch-match-selection");
+ Assert.Contains(decision.Guarantees, g => g == "Class B face-boundary loop");
+ Assert.Contains(decision.Guarantees, g => g == "not four independent single-edge chamfers");
+ Assert.DoesNotContain(decision.Guarantees, g => g.Contains("AirEdgeSweep", StringComparison.OrdinalIgnoreCase) || g.Contains("BrepBoundedChamfer", StringComparison.OrdinalIgnoreCase) || g.Contains("Boolean", StringComparison.OrdinalIgnoreCase) || g.Contains("graft", StringComparison.OrdinalIgnoreCase) || g.Contains("merge", StringComparison.OrdinalIgnoreCase));
+ }
+
+ [Fact]
+ public void AirRouteSelector_ArbitraryGraph_IsRejected()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("arbitrary-graph-chamfer", AirSelectionClass.ArbitraryGraph, AirRuleKind.UniformChamfer, "history-known arbitrary graph"));
+
+ Assert.False(decision.Succeeded);
+ Assert.Null(decision.SelectedRouteKind);
+ var candidate = Assert.Single(decision.Candidates);
+ Assert.Equal(AirRouteCandidateStatus.Rejected, candidate.Status);
+ Assert.Equal(AirRouteRejectionReason.ArbitraryGraphUnsupported, candidate.ReasonCode);
+ Assert.Contains(decision.Diagnostics, d => d.Code == "air-x2-arbitrary-graph-rejected");
+ }
+
+ [Fact]
+ public void AirRouteSelector_LoopFillet_IsDeferred()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("loop-fillet", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.ConstantRadiusFillet, "history-known face loop"));
+
+ Assert.False(decision.Succeeded);
+ Assert.Equal(AirSelectionClass.FaceBoundaryLoop, decision.Summary.SelectionClass);
+ Assert.Equal(AirRuleKind.ConstantRadiusFillet, decision.Summary.RuleKind);
+ var candidate = Assert.Single(decision.Candidates);
+ Assert.Equal(AirRouteCandidateStatus.Deferred, candidate.Status);
+ Assert.Equal(AirRouteRejectionReason.LoopFilletDeferredUntilSingleEdgeEvidence, candidate.ReasonCode);
+ Assert.Contains("single-edge", candidate.Reason);
+ Assert.Null(decision.SelectedRouteKind);
+ }
+
+ [Fact]
+ public void AirRouteSelector_NonUniformRule_IsRejectedOrDeferred()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("non-uniform-loop-rule", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.Unsupported, "history-known top-face loop"));
+
+ Assert.False(decision.Succeeded);
+ Assert.Null(decision.SelectedRouteKind);
+ var candidate = Assert.Single(decision.Candidates);
+ Assert.Contains(candidate.Status, new[] { AirRouteCandidateStatus.Rejected, AirRouteCandidateStatus.Deferred });
+ Assert.Equal(AirRouteRejectionReason.NonUniformRuleUnsupported, candidate.ReasonCode);
+ Assert.Contains(decision.Diagnostics, d => d.Code == "air-x2-non-uniform-rule-rejected");
+ }
+
+ [Fact]
+ public void AirRouteSelection_IsDeterministic()
+ {
+ AssertStable(AirRouteSelector.Decide(AirRouteSelector.ForPrismaticSectionTransition()), AirRouteSelector.Decide(AirRouteSelector.ForPrismaticSectionTransition()));
+ AssertStable(AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("top-face-loop-chamfer", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.UniformChamfer, "history-known top-face loop")), AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("top-face-loop-chamfer", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.UniformChamfer, "history-known top-face loop")));
+ }
+
+ [Fact]
+ public void AirRouteSelector_JudgmentUtility_IsRepresentedButDeferred()
+ {
+ var direct = AirRouteSelector.Decide(AirRouteSelector.ForProfileExtrude());
+ var contested = AirRouteSelector.Decide(AirRouteSelector.ForJudgmentUtilityProbe());
+
+ Assert.NotEqual(AirRouteSelectionMode.JudgmentUtility, direct.SelectionMode);
+ Assert.Equal(AirRouteSelectionMode.JudgmentUtility, contested.SelectionMode);
+ Assert.False(contested.Succeeded);
+ Assert.Contains(contested.Diagnostics, d => d.Code == "air-x2-judgment-utility-deferred");
+ }
+
+ [Fact]
+ public void AirRouteDecision_TopFaceLoopChamfer_CanInvokeExistingAirWrapper()
+ {
+ var decision = AirRouteSelector.Decide(AirRouteSelector.ForEdgeFinish("top-face-loop-chamfer", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.UniformChamfer, "history-known top-face loop"));
+ var wrapper = AirTopFaceLoopChamferWrapper.LowerCanonicalTopFaceLoopChamfer();
+
+ Assert.True(decision.Succeeded);
+ Assert.Equal(AirRouteKind.TopFaceLoopChamferPrismatic, decision.SelectedRouteKind);
+ Assert.True(wrapper.Succeeded);
+ Assert.Equal(decision.SelectedRouteKind, wrapper.RouteKind);
+ Assert.Equal("AIR-X2", decision.Provenance.Milestone);
+ Assert.Contains(decision.Diagnostics, d => d.Code == "air-x2-no-production-route-replacement");
+ }
+
+ private static void AssertStable(AirRouteDecision a, AirRouteDecision b)
+ {
+ Assert.Equal(a.SelectedRouteKind, b.SelectedRouteKind);
+ Assert.Equal(a.SelectionMode, b.SelectionMode);
+ Assert.Equal(a.Candidates.Select(c => c.Status), b.Candidates.Select(c => c.Status));
+ Assert.Equal(a.Candidates.Select(c => c.ReasonCode), b.Candidates.Select(c => c.ReasonCode));
+ Assert.Equal(a.Diagnostics.Select(d => d.Code), b.Diagnostics.Select(d => d.Code));
+ Assert.Equal(a.Guarantees, b.Guarantees);
+ }
+}
diff --git a/Aetheris.Kernel.Core/Air/AirRouteSelection.cs b/Aetheris.Kernel.Core/Air/AirRouteSelection.cs
new file mode 100644
index 00000000..48ebb051
--- /dev/null
+++ b/Aetheris.Kernel.Core/Air/AirRouteSelection.cs
@@ -0,0 +1,129 @@
+namespace Aetheris.Kernel.Core.Air;
+
+internal enum AirRouteSelectionMode { Direct, SwitchMatch, JudgmentUtility, Unsupported }
+internal enum AirRouteCandidateStatus { Admitted, Rejected, Deferred, Unavailable, NotApplicable }
+
+internal static class AirRouteRejectionReason
+{
+ public const string None = "none";
+ public const string ArbitraryGraphUnsupported = "arbitrary-graph-unsupported";
+ public const string LoopFilletDeferredUntilSingleEdgeEvidence = "loop-fillet-deferred-until-single-edge-fillet-evidence";
+ public const string FilletX1Required = "fillet-x1-required";
+ public const string NonUniformRuleUnsupported = "non-uniform-rule-unsupported";
+ public const string JudgmentUtilityDeferred = "judgment-utility-deferred-until-air-x3-policy-work";
+ public const string UnsupportedRequest = "unsupported-air-route-selection-request";
+}
+
+internal sealed record AirRouteCandidate(
+ AirRouteKind RouteKind,
+ AirRouteCandidateStatus Status,
+ AirRouteSelectionMode SelectionMode,
+ double? Score,
+ string ReasonCode,
+ string Reason,
+ IReadOnlyList<AirDiagnostic> Diagnostics,
+ IReadOnlyList<string> Guarantees,
+ IReadOnlyList<string> KnownLosses);
+
+internal sealed record AirRouteAdmissibility(
+ AirRouteCandidateStatus Status,
+ string ReasonCode,
+ string Reason);
+
+internal sealed record AirRouteSelectionSummary(
+ AirRouteSelectionMode SelectionMode,
+ AirSelectionClass SelectionClass,
+ AirRuleKind RuleKind,
+ string ConstructionHistoryKind,
+ IReadOnlyList<AirDiagnostic> Diagnostics);
+
+internal sealed record AirRouteSelectionRequest(
+ string RequestName,
+ AirNodeKind NodeKind,
+ AirSelectionClass SelectionClass = AirSelectionClass.None,
+ AirRuleKind RuleKind = AirRuleKind.None,
+ string ConstructionHistoryKind = "unspecified");
+
+internal sealed record AirRouteDecision(
+ string RequestName,
+ AirNodeKind NodeKind,
+ AirRouteSelectionMode SelectionMode,
+ AirRouteKind? SelectedRouteKind,
+ bool Succeeded,
+ string Recommendation,
+ IReadOnlyList<AirRouteCandidate> Candidates,
+ IReadOnlyList<AirDiagnostic> Diagnostics,
+ IReadOnlyList<string> Guarantees,
+ AirProvenance Provenance,
+ AirRouteSelectionSummary Summary);
+
+internal static class AirRouteSelector
+{
+ public static AirRouteSelectionRequest ForPrismaticSectionTransition(string requestName = "canonical-prismatic-section-transition") =>
+ new(requestName, AirNodeKind.PrismaticSectionTransition, ConstructionHistoryKind: "generated/constructive");
+
+ public static AirRouteSelectionRequest ForProfileExtrude(string requestName = "canonical-profile-extrude") =>
+ new(requestName, AirNodeKind.ProfileExtrude, ConstructionHistoryKind: "generated/constructive");
+
+ public static AirRouteSelectionRequest ForEdgeFinish(string requestName, AirSelectionClass selectionClass, AirRuleKind ruleKind, string constructionHistoryKind) =>
+ new(requestName, AirNodeKind.TopFaceLoopChamfer, selectionClass, ruleKind, constructionHistoryKind);
+
+ public static AirRouteSelectionRequest ForJudgmentUtilityProbe(string requestName = "contested-history-known-chamfer") =>
+ new(requestName, AirNodeKind.Unsupported, AirSelectionClass.SingleEdge, AirRuleKind.UniformChamfer, "history-known/contested");
+
+ public static AirRouteDecision Decide(AirRouteSelectionRequest request) => request.NodeKind switch
+ {
+ AirNodeKind.PrismaticSectionTransition when request.SelectionClass == AirSelectionClass.None => Direct(request, AirRouteKind.PrismaticSectionTransitionEmitter, "air-x2-prismatic-section-transition-direct-route"),
+ AirNodeKind.ProfileExtrude when request.SelectionClass == AirSelectionClass.None => Direct(request, AirRouteKind.ProfileExtrudeEmitter, "air-x2-profile-extrude-direct-route"),
+ _ when request.RequestName == "contested-history-known-chamfer" => JudgmentDeferred(request),
+ _ => SwitchMatch(request),
+ };
+
+ // Direct selection is for already-canonical Constructive AIR nodes: no scoring, no route competition.
+ private static AirRouteDecision Direct(AirRouteSelectionRequest request, AirRouteKind route, string routeDiagnostic)
+ {
+ var diagnostics = StableDiagnostics("air-x2-direct-selection", routeDiagnostic, "air-x2-no-judgment-engine-required", "air-x2-no-production-route-replacement");
+ var guarantees = StableStrings("explicit direct route", "deterministic route decision", "no production route replacement");
+ var candidate = new AirRouteCandidate(route, AirRouteCandidateStatus.Admitted, AirRouteSelectionMode.Direct, null, AirRouteRejectionReason.None, "already-canonical Constructive AIR node names the route", diagnostics, guarantees, []);
+ return Decision(request, AirRouteSelectionMode.Direct, route, true, "air-x2-direct-route-admitted", [candidate], diagnostics, guarantees);
+ }
+
+ // Switch/match selection is for closed structural classifications: deterministic and deliberately unscored.
+ private static AirRouteDecision SwitchMatch(AirRouteSelectionRequest request)
+ {
+ var codes = new List<string> { "air-x2-switch-match-selection", "air-x2-selection-class-classified", "air-x2-rule-kind-classified", "air-x2-no-production-route-replacement" };
+ AirRouteKind route = AirRouteKind.Unsupported;
+ var status = AirRouteCandidateStatus.Deferred;
+ var reason = AirRouteRejectionReason.UnsupportedRequest;
+ var text = "request is outside AIR-X2 route-selection scope";
+ var guarantees = new List<string> { "deterministic switch/match classification", "no production route replacement" };
+
+ if (request.SelectionClass == AirSelectionClass.FaceBoundaryLoop && request.RuleKind == AirRuleKind.UniformChamfer && request.ConstructionHistoryKind.Contains("top-face", StringComparison.OrdinalIgnoreCase))
+ {
+ route = AirRouteKind.TopFaceLoopChamferPrismatic; status = AirRouteCandidateStatus.Admitted; reason = AirRouteRejectionReason.None; text = "history-known top-face loop uniform chamfer admits the prismatic wrapper";
+ codes.Add("air-x2-face-boundary-loop-uniform-chamfer-admitted"); guarantees.Add("Class B face-boundary loop"); guarantees.Add("not four independent single-edge chamfers");
+ }
+ else if (request.SelectionClass == AirSelectionClass.ArbitraryGraph && request.RuleKind == AirRuleKind.UniformChamfer) { status = AirRouteCandidateStatus.Rejected; reason = AirRouteRejectionReason.ArbitraryGraphUnsupported; text = "arbitrary graph edge finishes are unsupported in AIR-X2"; codes.Add("air-x2-arbitrary-graph-rejected"); }
+ else if (request.SelectionClass == AirSelectionClass.FaceBoundaryLoop && request.RuleKind == AirRuleKind.ConstantRadiusFillet) { reason = AirRouteRejectionReason.LoopFilletDeferredUntilSingleEdgeEvidence; text = "loop fillet is deferred until single-edge fillet and corner evidence exist"; codes.Add("air-x2-fillet-deferred"); }
+ else if (request.SelectionClass == AirSelectionClass.SingleEdge && request.RuleKind == AirRuleKind.ConstantRadiusFillet) { reason = AirRouteRejectionReason.FilletX1Required; text = "single-edge fillet requires FILLET-X1 evidence before AIR route admission"; codes.Add("air-x2-fillet-deferred"); }
+ else if (request.SelectionClass == AirSelectionClass.FaceBoundaryLoop && request.RuleKind == AirRuleKind.Unsupported) { status = AirRouteCandidateStatus.Rejected; reason = AirRouteRejectionReason.NonUniformRuleUnsupported; text = "non-uniform or mixed loop rules are unsupported in AIR-X2"; codes.Add("air-x2-non-uniform-rule-rejected"); }
+
+ var diagnostics = StableDiagnostics(codes.ToArray());
+ var candidate = new AirRouteCandidate(route, status, AirRouteSelectionMode.SwitchMatch, null, reason, text, diagnostics, guarantees.Order(StringComparer.Ordinal).ToArray(), []);
+ return Decision(request, status == AirRouteCandidateStatus.Admitted ? AirRouteSelectionMode.SwitchMatch : AirRouteSelectionMode.Unsupported, status == AirRouteCandidateStatus.Admitted ? route : null, status == AirRouteCandidateStatus.Admitted, status == AirRouteCandidateStatus.Admitted ? "air-x2-switch-match-route-admitted" : reason, [candidate], diagnostics, candidate.Guarantees);
+ }
+
+ // JudgmentUtility is reserved for competing admissible routes with policy tradeoffs; AIR-X2 represents it but defers wiring.
+ private static AirRouteDecision JudgmentDeferred(AirRouteSelectionRequest request)
+ {
+ var diagnostics = StableDiagnostics("air-x2-judgment-utility-deferred", "air-x2-judgment-engine-not-required-for-direct-or-switch-selection", "air-x2-no-production-route-replacement");
+ var candidate = new AirRouteCandidate(AirRouteKind.Unsupported, AirRouteCandidateStatus.Deferred, AirRouteSelectionMode.JudgmentUtility, null, AirRouteRejectionReason.JudgmentUtilityDeferred, "JudgmentUtility route policy is deferred to AIR-X3 because AIR-X2 direct and switch/match cases do not need scored tradeoffs.", diagnostics, ["no production route replacement"], []);
+ return Decision(request, AirRouteSelectionMode.JudgmentUtility, null, false, AirRouteRejectionReason.JudgmentUtilityDeferred, [candidate], diagnostics, candidate.Guarantees);
+ }
+
+ private static AirRouteDecision Decision(AirRouteSelectionRequest request, AirRouteSelectionMode mode, AirRouteKind? selected, bool succeeded, string recommendation, IReadOnlyList<AirRouteCandidate> candidates, IReadOnlyList<AirDiagnostic> diagnostics, IReadOnlyList<string> guarantees) =>
+ new(request.RequestName, request.NodeKind, mode, selected, succeeded, recommendation, candidates, diagnostics, guarantees, new AirProvenance("AIR-X2", "AIR route selector", request.RequestName, request.RequestName, selected?.ToString() ?? "none", request.SelectionClass, request.RuleKind, request.ConstructionHistoryKind, false, ["Route decision only; no production route replacement."]), new AirRouteSelectionSummary(mode, request.SelectionClass, request.RuleKind, request.ConstructionHistoryKind, diagnostics));
+
+ private static IReadOnlyList<AirDiagnostic> StableDiagnostics(params string[] codes) => codes.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).Select(c => new AirDiagnostic(c, AirDiagnosticSeverity.Info, c)).ToArray();
+ private static IReadOnlyList<string> StableStrings(params string[] values) => values.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray();
+}
diff --git a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
index bfecc17b..613b7d61 100644
--- a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
+++ b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
@@ -740,3 +740,7 @@ Reasoning:
## AIR-X1 status note
AIR-X1 adds a minimal internal AIR envelope and thin wrappers for the existing profile extrusion, prismatic section transition, and top-face loop chamfer constructive lanes. The wrappers validate provenance, diagnostics, route identity, topology summaries, and Class B loop metadata without introducing BRepPlan, route selection, production route replacement, CIR mirror changes, or STEP/BRep/Boolean behavior changes. See `docs/air-x1-minimal-air-wrappers-for-proven-lanes.md`.
+
+## AIR-X2 status note
+
+AIR-X2 adds an internal route-selection/admissibility layer ahead of AIR-X1 wrappers. It preserves the AIR-A0 authority split: Firmament remains source intent, AIR remains constructive MIR, BRep remains topology authority, CIR remains a mirror side-channel, and STEP remains serialization. AIR-X2 does not implement BRepPlan and does not replace production routes.
diff --git a/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md b/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md
index a072125b..152f30a1 100644
--- a/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md
+++ b/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md
@@ -71,3 +71,7 @@ Focused AIR tests were added for profile extrusion provenance, prismatic split-p
## 11. Recommended next milestone
AIR-X2 should introduce route-selection/admissibility metadata only after more wrappers need bounded strategy choice. AIR-X3 should introduce a BRepPlan for prismatic section transition if the next goal is to separate constructive planning from direct emitter invocation. AIR-X1 evidence suggests BRepPlan for the prismatic section stack is the narrower next technical step.
+
+## AIR-X2 route-selection note
+
+AIR-X2 now records deterministic route decisions for the AIR-X1 wrapper lanes. Profile extrusion and prismatic section transition use direct selection; top-face loop chamfer uses switch/match classification. These decisions are internal/test-visible and do not replace production routes.
diff --git a/docs/air-x2-route-selection-and-admissibility.md b/docs/air-x2-route-selection-and-admissibility.md
new file mode 100644
index 00000000..ce29de42
--- /dev/null
+++ b/docs/air-x2-route-selection-and-admissibility.md
@@ -0,0 +1,66 @@
+# AIR-X2 Route Selection and Admissibility
+
+## Purpose and scope
+
+AIR-X2 adds a minimal internal route-selection and admissibility layer for AIR. Its purpose is to make route choice explicit, deterministic, inspectable, and testable while leaving production behavior unchanged.
+
+AIR-X2 is not a production route replacement, not a geometry milestone, not BRepPlan, and not a full JudgmentEngine integration.
+
+## Relationship to AIR-A0 and AIR-X1
+
+AIR-A0 defines Aetheris as a compiler for BRep: Firmament is source intent, AIR is constructive geometry MIR, BRep is explicit topology authority, CIR is an admitted evaluation side-channel, and STEP is serialization rather than construction truth.
+
+AIR-X1 introduced thin AIR wrappers around proven lanes. AIR-X2 adds route decisions in front of those wrappers for test/lab inspection only.
+
+## Route-selection modes
+
+- `Direct`: used when an already-canonical Constructive AIR node implies exactly one route. There is no scoring and no candidate competition.
+- `SwitchMatch`: used when route choice is a closed, finite, deterministic structural classification. There is no utility scoring.
+- `JudgmentUtility`: reserved for competing admissible routes where policy tradeoffs require scored diagnostics and explicit rejection reasons.
+- `Unsupported`: used when AIR-X2 has no admissible route.
+
+## Choosing the mode
+
+Use direct selection for constructive nodes such as profile extrusion and prismatic section transition. Use switch/match selection for finite edge-finish classifications such as face-boundary-loop uniform chamfer versus arbitrary graph. Use JudgmentUtility only when multiple plausible routes compete.
+
+JudgmentEngine should not be used for deterministic enum dispatch because it would obscure simple structural decisions behind unnecessary scoring. Conversely, switch/match must not replace utility policy when route tradeoffs genuinely compete, because fallback-free scored diagnostics are needed in that case.
+
+## AIR-X2 model
+
+The model records candidates, statuses, decisions, diagnostics, guarantees, known losses, and provenance. A successful decision has exactly one selected route. Rejected, deferred, unavailable, and not-applicable candidates retain stable reason codes. Silent fallback is forbidden.
+
+## Implemented direct-selection examples
+
+- `AirPrismaticSectionTransition` selects `PrismaticSectionTransitionEmitter`.
+- `AirProfileExtrude` selects `ProfileExtrudeEmitter` without introducing a Core-to-Firmament dependency cycle.
+
+## Implemented switch/match examples
+
+- `FaceBoundaryLoop + UniformChamfer + history-known top-face loop` admits `TopFaceLoopChamferPrismatic`.
+- `ArbitraryGraph + UniformChamfer` is rejected as `arbitrary-graph-unsupported`.
+- `FaceBoundaryLoop + ConstantRadiusFillet` is deferred until single-edge fillet/corner evidence exists.
+- `FaceBoundaryLoop + non-uniform/mixed rule` is rejected as `non-uniform-rule-unsupported`.
+
+## JudgmentUtility status
+
+AIR-X2 represents `JudgmentUtility` but defers wiring it to AIR-X3 policy work. The current direct and switch/match requests do not need scored route competition, so no production JudgmentEngine integration is forced.
+
+## Relationship to production routes
+
+There is no production route replacement and no default CLI behavior change. AIR-X2 decisions are internal and test-visible for now.
+
+## Relationship to BRepPlan
+
+BRepPlan is not implemented in AIR-X2. Future route decisions can select a Constructive AIR to BRepPlan path.
+
+## Relationship to CIR
+
+AIR-X2 does not change CIR mirror behavior. Future utility decisions may consider mirror availability as a scoring or capability input.
+
+## Tests run
+
+Focused AIR route-selection tests were added under `Aetheris.Kernel.Core.Tests`. The milestone validation commands are recorded in the implementation PR summary.
+
+## Recommended next milestone
+
+Recommended next milestone: AIR-X3 JudgmentUtility integration for one contested edge-finish route. AIR-X2 found direct and switch/match selection clean enough that the remaining new evidence is in scored competing-route policy rather than another deterministic selector.
diff --git a/docs/edge-a3-edge-finish-selection-taxonomy.md b/docs/edge-a3-edge-finish-selection-taxonomy.md
index 87d2c541..00dac57c 100644
--- a/docs/edge-a3-edge-finish-selection-taxonomy.md
+++ b/docs/edge-a3-edge-finish-selection-taxonomy.md
@@ -361,3 +361,7 @@ AIR-A0 maps these selection classes into Feature AIR: Class A as `AirEdgeSelecti
## AIR-X1 Class B metadata note
AIR-X1 records the top-face outer-loop chamfer proof as internal AIR metadata with node kind `TopFaceLoopChamfer`, route `TopFaceLoopChamferPrismatic`, selection class `FaceBoundaryLoop`, and rule kind `UniformChamfer`. This note is descriptive metadata around the existing prismatic loop route only; it does not introduce route selection, JudgmentEngine policy, production replacement, or new chamfer/fillet geometry.
+
+## AIR-X2 evidence note
+
+AIR-X2 provides route-selection evidence for Class B face-boundary-loop uniform chamfer by admitting the `TopFaceLoopChamferPrismatic` AIR-X1 wrapper through switch/match classification. It also records stable rejection for arbitrary-graph uniform chamfer as unsupported in AIR-X2.
diff --git a/docs/edge-fillet-a0-selection-taxonomy-architecture-audit.md b/docs/edge-fillet-a0-selection-taxonomy-architecture-audit.md
index 2ec6ee01..df49f917 100644
--- a/docs/edge-fillet-a0-selection-taxonomy-architecture-audit.md
+++ b/docs/edge-fillet-a0-selection-taxonomy-architecture-audit.md
@@ -279,3 +279,7 @@ This milestone explicitly does not include:
## AIR-A0 route-selection note
AIR-A0 places future fillet support behind AIR route selection: constant-radius Class A evidence should lower through the highest construction-aware route available, then a future `AirFillet`/`AirEdgeSweep` local route only when no-history support is explicitly admitted, with legacy bounded BRep fillet behavior preserved as the current authoritative fallback. See `docs/air-a0-aetheris-v2-compiler-ir-constitution.md`.
+
+## AIR-X2 route-policy note
+
+AIR-X2 keeps face-boundary-loop constant-radius fillet deferred. The route selector requires Class A single-edge fillet and corner evidence before a loop fillet route can be admitted, and no fillet geometry behavior changes in AIR-X2.
diff --git a/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md b/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md
index cfa4b7ba..e19a2203 100644
--- a/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md
+++ b/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md
@@ -214,3 +214,7 @@ AIR-A0 classifies this corpus as evidence for a future `AirTopFaceLoopChamfer` F
## AIR-X1 wrapper note
AIR-X1 adds an internal `TopFaceLoopChamfer` AIR wrapper around the existing `PrismaticTopFaceLoopChamferPrototype` lane. The wrapper preserves the EDGE-LOOP-X2 Class B face-boundary-loop metadata, uniform chamfer rule, split-preserving topology summary, STEP smoke summary, and route-exclusion guarantees; it does not replace production routing or change chamfer geometry.
+
+## AIR-X2 route-selection note
+
+AIR-X2 can select the top-face loop chamfer wrapper through deterministic switch/match policy for `FaceBoundaryLoop + UniformChamfer + history-known top-face loop`. This is route-decision evidence only; it does not change the corpus writer or production geometry routes.