Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add AirChamfer shadow route
Yuechen Li0b0a573a36ac
diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.cs b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.csindex 2345480a..c2ebcc49 100644--- a/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.cs+++ b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferFeatureRecognitionParityLab.cs@@ -50,7 +50,6 @@ public static class AirChamferFeatureRecognitionParityLab};var sourceBody = BrepPrimitives.CreateBox(10d, 8d, 6d).Value;- var sourceSummary = Summarize(sourceBody, stepSmokeSucceeded: true);diagnostics.Add("edge-x9-source-body-summary-captured");var request = new AirChamferRealBodyPrototypeRequest(@@ -71,13 +70,37 @@ public static class AirChamferFeatureRecognitionParityLabIncludeStepSmoke: true);var v2 = AirChamferRealBodyPrototype.Evaluate(request);+ return EvaluateCandidateEvidence(c.CaseName, sourceBody, v2, diagnostics);+ }++ public static AirChamferFeatureRecognitionParityRow EvaluateCandidateEvidence(+ string caseName,+ BrepBody sourceBody,+ AirChamferRealBodyPrototypeResult v2)+ => EvaluateCandidateEvidence(caseName, sourceBody, v2, new[]+ {+ "edge-x9-feature-recognition-lab-started",+ "edge-x9-legacy-authority-preserved",+ "edge-x9-no-production-route-replacement",+ "edge-x9-no-3d-boolean-used",+ "edge-x9-source-body-summary-captured"+ });++ private static AirChamferFeatureRecognitionParityRow EvaluateCandidateEvidence(+ string caseName,+ BrepBody sourceBody,+ AirChamferRealBodyPrototypeResult v2,+ IEnumerable<string> initialDiagnostics)+ {+ var diagnostics = new List<string>(initialDiagnostics);+ var sourceSummary = Summarize(sourceBody, stepSmokeSucceeded: true);diagnostics.Add("edge-x9-edge-v2-prototype-invoked");if (v2.Status is not AirChamferRealBodyPrototypeStatus.Succeeded || v2.CandidateBody is null || v2.TopologySummary is null){diagnostics.Add("edge-x9-recognition-contract-checked");diagnostics.Add($"edge-x9-first-divergence:prototype-status-{v2.Status}");- return new(c.CaseName, true, false, sourceSummary, null, 0, 0, 0, 0, 0, 0, false, false, $"prototype-status-{v2.Status}", "edge-x9-legacy-comparison-unavailable:controlled-case-not-comparable", 0, 0,+ return new(caseName, true, false, sourceSummary, null, 0, 0, 0, 0, 0, 0, false, false, $"prototype-status-{v2.Status}", "edge-x9-legacy-comparison-unavailable:controlled-case-not-comparable", 0, 0,"air-chamfer-candidate-keep-legacy-authority", diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray());}@@ -116,7 +139,7 @@ public static class AirChamferFeatureRecognitionParityLab}else diagnostics.Add("edge-x9-feature-recognition-parity-succeeded");- return new(c.CaseName, true, true, sourceSummary, candidateSummary, chamferFaceCount, trimmedAdjacentFaceCount, transitionEdgeCount,+ return new(caseName, true, true, sourceSummary, candidateSummary, chamferFaceCount, trimmedAdjacentFaceCount, transitionEdgeCount,chamferAdjacentFaceCount, transitionMin, transitionMax, originalEdgeAbsent, contractSatisfied, divergence, legacyStatus,RecognizedCandidateCount: contractSatisfied ? 1 : 0, AdmissibleCandidateCount: contractSatisfied ? 1 : 0,Recommendation: contractSatisfied ? "air-chamfer-candidate-ready-for-shadow-route-probe" : "air-chamfer-candidate-needs-adjacency-hardening",diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferShadowRoute.cs b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferShadowRoute.csnew file mode 100644index 00000000..95468c34--- /dev/null+++ b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferShadowRoute.cs@@ -0,0 +1,184 @@+using System.Numerics;+using Aetheris.Kernel.Core.Brep;++namespace Aetheris.Firmament.FrictionLab.CIRLab;++public enum AirChamferShadowCandidateStatus { Succeeded, Rejected, Deferred, Failed, FallbackLegacy }++public sealed record AirChamferShadowRouteRequest(+ string CaseName,+ BrepBody SourceBody,+ Vector3 TargetEdgeStart,+ Vector3 TargetEdgeEnd,+ Vector3? AdjacentFaceNormalA,+ Vector3? AdjacentFaceNormalB,+ double ChamferDistance,+ AirChamferFaceFamily FaceFamily,+ bool IsEdgeChain,+ bool IsCornerChain,+ bool LegacyDependency,+ AirChamferClassificationExpectation ClassificationExpectation,+ bool IsOrthogonalFacePair,+ double ReferenceEnvelope,+ bool IncludeStepSmoke = true);++public sealed record AirChamferShadowReport(+ bool LegacyAuthoritative,+ bool ProductionOutputChanged,+ bool ShadowCandidateProduced,+ AirChamferShadowCandidateStatus ShadowCandidateStatus,+ string AirChamferDecision,+ AirChamferRealBodyTopologySummary? TopologySummary,+ AirChamferClosedWitnessStepSummary? StepSmokeSummary,+ AirChamferFeatureRecognitionParityRow? FeatureRecognitionSummary,+ string? FirstDivergence,+ string Recommendation,+ BrepBody? ShadowCandidateBody,+ IReadOnlyList<string> Diagnostics);++public static class AirChamferShadowRoute+{+ public static readonly IReadOnlySet<string> AllowedRecommendations = new HashSet<string>(StringComparer.Ordinal)+ {+ "air-chamfer-shadow-ready-for-controlled-opt-in-route",+ "air-chamfer-shadow-needs-recognition-hardening",+ "air-chamfer-shadow-needs-body-prototype-hardening",+ "air-chamfer-shadow-rejected-invalid",+ "air-chamfer-shadow-deferred-unsupported",+ "air-chamfer-shadow-keep-legacy-authority"+ };++ public static AirChamferShadowReport Evaluate(AirChamferShadowRouteRequest request)+ {+ var diagnostics = new List<string>+ {+ "edge-v3-shadow-route-started",+ "edge-v3-shadow-route-internal-only",+ "edge-v3-legacy-authority-preserved",+ "edge-v3-production-output-unchanged",+ "edge-v3-no-production-route-replacement",+ "edge-v3-no-3d-boolean-used"+ };++ var prototypeRequest = new AirChamferRealBodyPrototypeRequest(+ request.CaseName,+ request.SourceBody,+ request.TargetEdgeStart,+ request.TargetEdgeEnd,+ request.AdjacentFaceNormalA,+ request.AdjacentFaceNormalB,+ request.ChamferDistance,+ request.FaceFamily,+ request.IsEdgeChain,+ request.IsCornerChain,+ request.LegacyDependency,+ request.ClassificationExpectation,+ request.IsOrthogonalFacePair,+ request.ReferenceEnvelope,+ request.IncludeStepSmoke);++ var prototype = AirChamferRealBodyPrototype.Evaluate(prototypeRequest);+ diagnostics.Add("edge-v3-air-chamfer-real-body-prototype-invoked");+ diagnostics.Add("edge-v3-judgment-engine-used");++ var status = ToShadowStatus(prototype.Status);+ if (prototype.Status is not AirChamferRealBodyPrototypeStatus.Succeeded || prototype.CandidateBody is null || prototype.TopologySummary is null)+ {+ var terminal = status is AirChamferShadowCandidateStatus.Deferred or AirChamferShadowCandidateStatus.FallbackLegacy+ ? "edge-v3-shadow-route-deferred"+ : "edge-v3-shadow-route-rejected";+ diagnostics.Add($"{terminal}:{prototype.Decision}");++ var terminalRecommendation = status switch+ {+ AirChamferShadowCandidateStatus.FallbackLegacy => "air-chamfer-shadow-keep-legacy-authority",+ AirChamferShadowCandidateStatus.Deferred => "air-chamfer-shadow-deferred-unsupported",+ AirChamferShadowCandidateStatus.Rejected => "air-chamfer-shadow-rejected-invalid",+ _ => "air-chamfer-shadow-needs-body-prototype-hardening"+ };++ return Report(+ candidateProduced: false,+ status,+ prototype.Decision,+ topology: null,+ step: null,+ recognition: null,+ firstDivergence: $"prototype-status-{prototype.Status}",+ terminalRecommendation,+ candidateBody: null,+ diagnostics);+ }++ diagnostics.Add("edge-v3-shadow-candidate-produced");+ if (prototype.StepSmoke?.Succeeded == true)+ diagnostics.Add("edge-v3-shadow-candidate-step-smoke-succeeded");++ var recognition = AirChamferFeatureRecognitionParityLab.EvaluateCandidateEvidence(request.CaseName, request.SourceBody, prototype);+ diagnostics.Add("edge-v3-shadow-feature-recognition-captured");++ var firstDivergence = recognition.FirstDivergence;+ string recommendation;+ if (recognition.RecognitionContractSatisfied)+ {+ diagnostics.Add("edge-v3-shadow-feature-recognition-parity-succeeded");+ recommendation = "air-chamfer-shadow-ready-for-controlled-opt-in-route";+ }+ else+ {+ diagnostics.Add($"edge-v3-shadow-feature-recognition-parity-mismatch:{firstDivergence ?? "unknown"}");+ recommendation = "air-chamfer-shadow-needs-recognition-hardening";+ }++ return Report(+ candidateProduced: true,+ status,+ prototype.Decision,+ prototype.TopologySummary,+ prototype.StepSmoke,+ recognition,+ firstDivergence,+ recommendation,+ prototype.CandidateBody,+ diagnostics);+ }++ private static AirChamferShadowReport Report(+ bool candidateProduced,+ AirChamferShadowCandidateStatus status,+ string decision,+ AirChamferRealBodyTopologySummary? topology,+ AirChamferClosedWitnessStepSummary? step,+ AirChamferFeatureRecognitionParityRow? recognition,+ string? firstDivergence,+ string recommendation,+ BrepBody? candidateBody,+ IEnumerable<string> diagnostics)+ {+ if (!AllowedRecommendations.Contains(recommendation))+ throw new InvalidOperationException($"Unexpected AirChamfer shadow recommendation '{recommendation}'.");++ return new AirChamferShadowReport(+ LegacyAuthoritative: true,+ ProductionOutputChanged: false,+ ShadowCandidateProduced: candidateProduced,+ status,+ decision,+ topology,+ step,+ recognition,+ firstDivergence,+ recommendation,+ candidateBody,+ diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray());+ }++ private static AirChamferShadowCandidateStatus ToShadowStatus(AirChamferRealBodyPrototypeStatus status) => status switch+ {+ AirChamferRealBodyPrototypeStatus.Succeeded => AirChamferShadowCandidateStatus.Succeeded,+ AirChamferRealBodyPrototypeStatus.Rejected => AirChamferShadowCandidateStatus.Rejected,+ AirChamferRealBodyPrototypeStatus.Deferred => AirChamferShadowCandidateStatus.Deferred,+ AirChamferRealBodyPrototypeStatus.FallbackLegacy => AirChamferShadowCandidateStatus.FallbackLegacy,+ _ => AirChamferShadowCandidateStatus.Failed+ };+}diff --git a/Aetheris.FrictionLab.Tests/CIRLab/AirChamferShadowRouteTests.cs b/Aetheris.FrictionLab.Tests/CIRLab/AirChamferShadowRouteTests.csnew file mode 100644index 00000000..e22df1a7--- /dev/null+++ b/Aetheris.FrictionLab.Tests/CIRLab/AirChamferShadowRouteTests.cs@@ -0,0 +1,118 @@+using System.Numerics;+using Aetheris.Firmament.FrictionLab.CIRLab;+using Aetheris.Kernel.Core.Brep;++namespace Aetheris.FrictionLab.Tests.CIRLab;++public sealed class AirChamferShadowRouteTests+{+ [Fact]+ public void Run_CanonicalControlledCase_DeterministicNonAuthoritativeCandidateReport()+ {+ var a = AirChamferShadowRoute.Evaluate(Request("canonical-shadow", 1d));+ var b = AirChamferShadowRoute.Evaluate(Request("canonical-shadow", 1d));++ Assert.Equal(System.Text.Json.JsonSerializer.Serialize(a with { ShadowCandidateBody = null }), System.Text.Json.JsonSerializer.Serialize(b with { ShadowCandidateBody = null }));+ AssertAccepted(a);+ }++ [Fact]+ public void Run_NonOrthogonalControlledCase_ProducesShadowCandidateWhenPrototypeSupportsIt()+ {+ var report = AirChamferShadowRoute.Evaluate(Request("safe-nonorthogonal-shadow", 1d, nonOrthogonal: true));+ AssertAccepted(report);+ }++ [Theory]+ [InlineData("invalid-distance", 0d, false, false, AirChamferFaceFamily.Planar, false, false, false, AirChamferShadowCandidateStatus.Rejected)]+ [InlineData("invalid-target-edge", 1d, true, false, AirChamferFaceFamily.Planar, false, false, false, AirChamferShadowCandidateStatus.Rejected)]+ [InlineData("missing-adjacent-face", 1d, false, true, AirChamferFaceFamily.Planar, false, false, false, AirChamferShadowCandidateStatus.Rejected)]+ [InlineData("non-planar-adjacent-marker", 1d, false, false, AirChamferFaceFamily.Cylindrical, false, false, false, AirChamferShadowCandidateStatus.Rejected)]+ [InlineData("edge-chain", 1d, false, false, AirChamferFaceFamily.Planar, true, false, false, AirChamferShadowCandidateStatus.Deferred)]+ [InlineData("corner-chain", 1d, false, false, AirChamferFaceFamily.Planar, false, true, false, AirChamferShadowCandidateStatus.Deferred)]+ [InlineData("legacy-triangle-dependent-fixture", 1d, false, false, AirChamferFaceFamily.Planar, false, false, true, AirChamferShadowCandidateStatus.FallbackLegacy)]+ public void Run_RejectedDeferredCases_DoNotProduceCandidateAndRemainNonAuthoritative(+ string caseName,+ double distance,+ bool invalidEdge,+ bool missingFace,+ AirChamferFaceFamily faceFamily,+ bool edgeChain,+ bool cornerChain,+ bool legacyDependent,+ AirChamferShadowCandidateStatus expectedStatus)+ {+ var a = AirChamferShadowRoute.Evaluate(Request(caseName, distance, invalidEdge, missingFace, faceFamily, edgeChain, cornerChain, legacyDependent));+ var b = AirChamferShadowRoute.Evaluate(Request(caseName, distance, invalidEdge, missingFace, faceFamily, edgeChain, cornerChain, legacyDependent));++ Assert.Equal(System.Text.Json.JsonSerializer.Serialize(a with { ShadowCandidateBody = null }), System.Text.Json.JsonSerializer.Serialize(b with { ShadowCandidateBody = null }));+ Assert.True(a.LegacyAuthoritative);+ Assert.False(a.ProductionOutputChanged);+ Assert.False(a.ShadowCandidateProduced);+ Assert.Null(a.ShadowCandidateBody);+ Assert.Null(a.TopologySummary);+ Assert.Equal(expectedStatus, a.ShadowCandidateStatus);+ Assert.NotNull(a.FirstDivergence);+ Assert.Contains(a.Recommendation, AirChamferShadowRoute.AllowedRecommendations);+ Assert.Contains("edge-v3-shadow-route-started", a.Diagnostics);+ Assert.Contains("edge-v3-shadow-route-internal-only", a.Diagnostics);+ Assert.Contains("edge-v3-legacy-authority-preserved", a.Diagnostics);+ Assert.Contains("edge-v3-production-output-unchanged", a.Diagnostics);+ Assert.Contains("edge-v3-no-production-route-replacement", a.Diagnostics);+ Assert.Contains("edge-v3-no-3d-boolean-used", a.Diagnostics);+ }++ private static void AssertAccepted(AirChamferShadowReport report)+ {+ Assert.True(report.LegacyAuthoritative);+ Assert.False(report.ProductionOutputChanged);+ Assert.True(report.ShadowCandidateProduced);+ Assert.Equal(AirChamferShadowCandidateStatus.Succeeded, report.ShadowCandidateStatus);+ Assert.NotNull(report.ShadowCandidateBody);+ Assert.NotNull(report.TopologySummary);+ Assert.NotNull(report.StepSmokeSummary);+ Assert.NotNull(report.FeatureRecognitionSummary);+ Assert.Null(report.FirstDivergence);+ Assert.Equal("air-chamfer-shadow-ready-for-controlled-opt-in-route", report.Recommendation);+ Assert.True(report.StepSmokeSummary!.Succeeded);+ Assert.True(report.FeatureRecognitionSummary!.RecognitionContractSatisfied);+ Assert.Equal(1, report.TopologySummary!.ChamferFaceCount);+ Assert.Equal(2, report.TopologySummary.TrimmedAdjacentFaceCount);+ Assert.Equal(2, report.TopologySummary.TransitionEdgeCount);+ Assert.True(report.TopologySummary.OriginalEdgeReplaced);+ Assert.Equal(0, report.FeatureRecognitionSummary.CandidateSummary!.CylindricalFaceCount);++ Assert.Contains("edge-v3-shadow-route-started", report.Diagnostics);+ Assert.Contains("edge-v3-shadow-route-internal-only", report.Diagnostics);+ Assert.Contains("edge-v3-legacy-authority-preserved", report.Diagnostics);+ Assert.Contains("edge-v3-production-output-unchanged", report.Diagnostics);+ Assert.Contains("edge-v3-air-chamfer-real-body-prototype-invoked", report.Diagnostics);+ Assert.Contains("edge-v3-judgment-engine-used", report.Diagnostics);+ Assert.Contains("edge-v3-shadow-candidate-produced", report.Diagnostics);+ Assert.Contains("edge-v3-shadow-candidate-step-smoke-succeeded", report.Diagnostics);+ Assert.Contains("edge-v3-shadow-feature-recognition-captured", report.Diagnostics);+ Assert.Contains("edge-v3-shadow-feature-recognition-parity-succeeded", report.Diagnostics);+ Assert.Contains("edge-v3-no-production-route-replacement", report.Diagnostics);+ Assert.Contains("edge-v3-no-3d-boolean-used", report.Diagnostics);+ }++ private static AirChamferShadowRouteRequest Request(+ string caseName,+ double distance,+ bool invalidEdge = false,+ bool missingFace = false,+ AirChamferFaceFamily faceFamily = AirChamferFaceFamily.Planar,+ bool edgeChain = false,+ bool cornerChain = false,+ bool legacyDependent = false,+ bool nonOrthogonal = false)+ {+ var body = BrepPrimitives.CreateBox(10d, 8d, 6d).Value;+ var edgeStart = new Vector3(5f, 4f, -3f);+ var edgeEnd = invalidEdge ? edgeStart : new Vector3(5f, 4f, 3f);+ Vector3? faceA = new(1f, 0f, 0f);+ Vector3? faceB = missingFace ? null : (nonOrthogonal ? Vector3.Normalize(new Vector3(1f, 1f, 0f)) : new Vector3(0f, 1f, 0f));+ var classification = edgeChain || cornerChain || legacyDependent ? AirChamferClassificationExpectation.Concave : AirChamferClassificationExpectation.Convex;+ return new(caseName, body, edgeStart, edgeEnd, faceA, faceB, distance, faceFamily, edgeChain, cornerChain, legacyDependent, classification, !nonOrthogonal, 10d);+ }+}diff --git a/docs/edge-v2-real-body-air-chamfer-prototype.md b/docs/edge-v2-real-body-air-chamfer-prototype.mdindex a7d35e53..b6b88b52 100644--- a/docs/edge-v2-real-body-air-chamfer-prototype.md+++ b/docs/edge-v2-real-body-air-chamfer-prototype.md@@ -68,3 +68,6 @@ Recommended next milestone: EDGE-X9 feature-recognition parity probe, or EDGE-V3## EDGE-X9 follow-on noteEDGE-X9 adds a lab-only feature-recognition parity probe (`AirChamferFeatureRecognitionParityLab`) for EDGE-V2 candidate-body readiness, including adjacency-contract checks and deterministic legacy-comparison boundary diagnostics, while preserving legacy authority and no production-route replacement.++## EDGE-V3 shadow-route wrapper note+EDGE-V3 wraps `AirChamferRealBodyPrototype` in `AirChamferShadowRoute`, a non-authoritative internal/test-only seam that invokes the EDGE-V2 candidate body path, captures topology/STEP/recognition evidence, and reports readiness while keeping legacy `BrepBoundedChamfer` authoritative and production output unchanged.diff --git a/docs/edge-v3-air-chamfer-shadow-route.md b/docs/edge-v3-air-chamfer-shadow-route.mdnew file mode 100644index 00000000..025e1c70--- /dev/null+++ b/docs/edge-v3-air-chamfer-shadow-route.md@@ -0,0 +1,154 @@+# EDGE-V3 — Non-authoritative AirChamfer shadow route++## Purpose and scope+EDGE-V3 introduces `AirChamferShadowRoute`, an internal/test-only shadow seam that runs the controlled AirChamfer candidate beside legacy chamfer authority for the exact bounded convex planar single-edge case. The route is diagnostic only: it can produce and inspect an AirChamfer candidate report, but it cannot replace or mutate the production `BrepBoundedChamfer` result.++The milestone answers whether AirChamfer can run as a deterministic shadow candidate behind a controlled seam while production output remains unchanged.++## References+- V2 architecture doctrine: `docs/aetheris-v2-sweep-first-architecture.md`+- Legacy topology / parallel lane doctrine: `docs/v2-a3-legacy-topology-contracts-and-parallel-emitter-lanes.md`+- AirEdgeSweep audit: `docs/edge-a0-air-edge-sweep-fillet-chamfer-audit.md`+- EDGE-X3 JudgmentEngine-backed convex planar AirChamfer policy lab+- EDGE-X4 convex planar AirChamfer topology-plan lab+- EDGE-X5 convex planar AirChamfer geometry-artifact lab+- EDGE-X6 convex planar AirChamfer closed-witness lab+- EDGE-V1 internal production-adjacent convex planar prototype+- EDGE-X7 controlled real-body integration probe+- EDGE-X8 controlled local topology graft lab+- EDGE-V2 `AirChamferRealBodyPrototype`+- EDGE-X9 `AirChamferFeatureRecognitionParityLab`++## Component and internal API shape+Component: `AirChamferShadowRoute` in the FrictionLab CIRLab namespace.++Request shape (`AirChamferShadowRouteRequest`):+- controlled source body,+- explicit target edge endpoints,+- explicit adjacent face normals,+- positive finite chamfer distance,+- face-family marker,+- edge-chain / corner-chain / legacy-dependency guards,+- deterministic convexity expectation,+- orthogonal/non-orthogonal marker,+- reference envelope,+- optional STEP smoke flag.++Result shape (`AirChamferShadowReport`):+- `LegacyAuthoritative` is always `true`,+- `ProductionOutputChanged` is always `false`,+- `ShadowCandidateProduced`,+- `ShadowCandidateStatus`,+- `AirChamferDecision`,+- `TopologySummary`,+- `StepSmokeSummary`,+- `FeatureRecognitionSummary`,+- `FirstDivergence`,+- finite deterministic `Recommendation`,+- optional `ShadowCandidateBody`,+- deterministic diagnostics.++The result model keeps the candidate body under `ShadowCandidateBody` and separately marks legacy authority and unchanged production output, making accidental authoritative treatment explicit and testable.++## Supported controlled scope+Accepted shadow candidates are limited to:+- controlled/simple body,+- one explicitly selected convex planar edge,+- two explicitly resolved adjacent planar faces,+- positive finite chamfer distance,+- deterministic convex classification,+- no edge chain,+- no corner chain,+- no legacy-dependent topology flag,+- no unsupported face family.++A safe non-orthogonal controlled planar face pair is also covered because EDGE-V2 and EDGE-X9 support it cleanly.++## Pipeline reuse+`AirChamferShadowRoute` invokes `AirChamferRealBodyPrototype` directly, preserving the EDGE-V2 controlled body/topology/STEP pipeline. It then reuses EDGE-X9 recognition parity logic through `AirChamferFeatureRecognitionParityLab.EvaluateCandidateEvidence(...)` so recognition-summary, first-divergence, and readiness semantics are not duplicated.++The AirChamfer path continues to rely on the EDGE-X3 JudgmentEngine-backed policy chain, and the shadow report emits `edge-v3-judgment-engine-used` after prototype invocation.++## Diagnostics contract+EDGE-V3 emits deterministic diagnostics including:+- `edge-v3-shadow-route-started`+- `edge-v3-shadow-route-internal-only`+- `edge-v3-legacy-authority-preserved`+- `edge-v3-production-output-unchanged`+- `edge-v3-air-chamfer-real-body-prototype-invoked`+- `edge-v3-judgment-engine-used`+- `edge-v3-shadow-candidate-produced`+- `edge-v3-shadow-candidate-step-smoke-succeeded`+- `edge-v3-shadow-feature-recognition-captured`+- `edge-v3-shadow-feature-recognition-parity-succeeded`+- `edge-v3-shadow-feature-recognition-parity-mismatch:<payload>`+- `edge-v3-shadow-route-rejected:<reason>`+- `edge-v3-shadow-route-deferred:<reason>`+- `edge-v3-no-production-route-replacement`+- `edge-v3-no-3d-boolean-used`++## Recommendations+Finite recommendations are constrained to:+- `air-chamfer-shadow-ready-for-controlled-opt-in-route`+- `air-chamfer-shadow-needs-recognition-hardening`+- `air-chamfer-shadow-needs-body-prototype-hardening`+- `air-chamfer-shadow-rejected-invalid`+- `air-chamfer-shadow-deferred-unsupported`+- `air-chamfer-shadow-keep-legacy-authority`++## Accepted, deferred, and rejected cases+Accepted:+- canonical controlled convex planar single-edge,+- safe non-orthogonal controlled convex planar single-edge.++Rejected/deferred with no shadow candidate body:+- invalid distance,+- invalid target edge,+- missing adjacent face,+- non-planar adjacent marker,+- edge chain,+- corner chain,+- legacy-dependent triangle/chamfer fixture.++All rejected/deferred cases preserve `LegacyAuthoritative=true` and `ProductionOutputChanged=false`.++## STEP and feature-recognition findings+For accepted controlled cases, the shadow candidate is produced, STEP smoke succeeds, and feature recognition parity is captured. The current accepted cases satisfy the recognition contract: one chamfer face, two trimmed adjacent faces, two transition edges, no cylindrical faces, and original sharp-edge replacement.++When recognition parity fails in a future fixture, EDGE-V3 reports `FirstDivergence` and recommends `air-chamfer-shadow-needs-recognition-hardening` without changing production output.++## Legacy authority relationship+Legacy `BrepBoundedChamfer` remains production-authoritative. EDGE-V3 does not replace production chamfer routing and does not alter normal Firmament chamfer execution. The shadow route is internal/test-only and exists to produce readiness evidence beside legacy behavior.++## Explicit unchanged-production statement+Production output is unchanged by construction and by test assertions: `ProductionOutputChanged=false` on every report, including accepted, rejected, deferred, and legacy-dependent fixtures.++## No-3D-Boolean guarantee+The shadow path emits `edge-v3-no-3d-boolean-used` and does not invoke 3D Boolean for the AirChamfer candidate path. Boolean core behavior is unchanged.++## Tests run+EDGE-V3 adds focused FrictionLab tests for deterministic accepted, rejected, deferred, and legacy-dependent shadow route cases. The intended validation set is:+- `dotnet test Aetheris.FrictionLab.Tests/Aetheris.FrictionLab.Tests.csproj -c Release -f net10.0 --filter "AirChamferShadow|AirChamferFeatureRecognition|AirChamferControlledBody|AirChamferTopologyGraft|AirChamferClosedWitness|AirChamferGeometryArtifact|AirChamferTopologyPlan|AirChamferJudgment|AirChamferPolicy|AirChamferPatch|EdgeSweep|Chamfer|Fillet|EdgeFinish|CIRLab"`+- `dotnet test Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj --filter "Chamfer|Fillet|Corner|TriangularPrism|FirmamentPrimitive|FirmamentStepExporter|LineArcProfileExtrude|SemanticRecovery|FrepMaterializer|Rematerialize"`+- `dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj --filter "Judgment|Chamfer|Fillet|Corner|TriangularPrism|BrepPrimitives|Step242|Primitive|Extrude|Boolean|SafeComposition"`++## Limitations+Still deferred:+- production route replacement,+- arbitrary model selection,+- normal Firmament chamfer execution replacement,+- multiple edges,+- corner patches,+- non-planar adjacent faces,+- cylindrical adjacent faces,+- fillets,+- variable distance,+- legacy triangle/chamfer topology,+- ambiguous convex/concave cases,+- triangle migration retry,+- sketch solver, clipping engine, NURBS, or freeform support.++No public API, STEP exporter/importer, Boolean core, production chamfer/fillet behavior, fillet geometry, chain/corner implementation, triangle migration, sketch solver, clipping engine, or NURBS/freeform support changed.++## Next recommended milestone+Because the canonical and safe non-orthogonal shadow route fixtures are expected to stay green, the next recommended milestone is EDGE-X10 controlled opt-in route fixture. If future shadow parity issues appear, run EDGE-X9.1 recognition/body hardening instead, scoped by the first-divergence payload.diff --git a/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md b/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.mdindex 5c4aa84f..db9f5af3 100644--- a/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md+++ b/docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md@@ -64,3 +64,6 @@ No production behavior change, no production replacement, no fillet work, no cha## 15) Recommended next milestone- If parity remains stable: EDGE-V3 non-authoritative shadow-route probe behind controlled seam.- If mismatch appears: EDGE-X9.1 adjacency/recognizer hardening with first-divergence driven scope.++## 16) EDGE-V3 consumer note+EDGE-V3 consumes the parity probe through `AirChamferFeatureRecognitionParityLab.EvaluateCandidateEvidence(...)` so the non-authoritative `AirChamferShadowRoute` can reuse EDGE-X9 recognition-summary and first-divergence logic after invoking `AirChamferRealBodyPrototype`, without replacing production chamfer behavior.