Skip to content

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.cs
index 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 AirChamferFeatureRecognitionParityLab
IncludeStepSmoke: 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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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.md
index 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 note
EDGE-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.md
new file mode 100644
index 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.md
index 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.