Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Advance parser-backed box trace to Constructive AIR

Yuechen Li63f33d06a7de
diff --git a/Aetheris.CLI.Tests/AirTraceCommandTests.cs b/Aetheris.CLI.Tests/AirTraceCommandTests.cs
index de76e4dc..650a6f02 100644
--- a/Aetheris.CLI.Tests/AirTraceCommandTests.cs
+++ b/Aetheris.CLI.Tests/AirTraceCommandTests.cs
@@ -107,20 +107,22 @@ public sealed class AirTraceCommandTests
[Fact]
- public void TraceParserBackedBoxFixture_ReachesFeatureAir_DefaultText()
+ public void TraceParserBackedBoxFixture_ReachesConstructiveAir_DefaultText()
{
var (exitCode, output, error) = Run("trace", "--fixture", PrimitiveFixture("valid/box.valid.firmfixture"));
Assert.Equal(0, exitCode); Assert.True(string.IsNullOrWhiteSpace(error));
Assert.False(output.TrimStart().StartsWith("{", StringComparison.Ordinal));
Assert.Contains("Fixture", output); Assert.Contains("Frontend", output);
Assert.Contains("Parser-backed: true", output); Assert.Contains("Parse succeeded: true", output);
- Assert.Contains("Expected stage: feature-air", output); Assert.Contains("Actual stage: feature-air", output);
+ Assert.Contains("Expected stage: constructive-air", output); Assert.Contains("Actual stage: constructive-air", output);
Assert.Contains("Feature AIR", output); Assert.Contains("Source op: box", output); Assert.Contains("Node: CreateBox", output);
+ Assert.Contains("Constructive AIR", output); Assert.Contains("Node: AirProfileExtrude", output); Assert.Contains("Canonical form: rectangle-profile-extrude", output);
+ Assert.Contains("Profile: Rectangle(width=10, depth=8)", output); Assert.Contains("Extrusion: height=6", output);
Assert.Contains("Expectation satisfied: true", output);
}
[Fact]
- public void TraceParserBackedBoxFixture_ReachesFeatureAir_Json()
+ public void TraceParserBackedBoxFixture_ReachesConstructiveAir_Json()
{
var (exitCode, output, _) = Run("trace", "--fixture", PrimitiveFixture("valid/box.valid.firmfixture"), "--json");
Assert.Equal(0, exitCode);
@@ -131,16 +133,18 @@ public sealed class AirTraceCommandTests
Assert.True(root.GetProperty("fixture").GetProperty("expectationSatisfied").GetBoolean());
Assert.True(root.GetProperty("frontend").GetProperty("parserBacked").GetBoolean());
Assert.True(root.GetProperty("frontend").GetProperty("parseSucceeded").GetBoolean());
- Assert.Equal("feature-air", root.GetProperty("frontend").GetProperty("frontendStageReached").GetString());
- Assert.Equal("feature-air", root.GetProperty("actualStageReached").GetString());
+ Assert.Equal("constructive-air", root.GetProperty("frontend").GetProperty("frontendStageReached").GetString());
+ Assert.Equal("constructive-air", root.GetProperty("actualStageReached").GetString());
Assert.Equal("box", root.GetProperty("featureAir").GetProperty("sourceOpKind").GetString());
Assert.Equal("CreateBox", root.GetProperty("featureAir").GetProperty("nodeKind").GetString());
- Assert.Contains("air-x9-firmament-parse-succeeded", output);
+ Assert.Equal("AirProfileExtrude", root.GetProperty("constructiveAir").GetProperty("nodeKind").GetString());
+ Assert.Equal("rectangle-profile-extrude", root.GetProperty("constructiveAir").GetProperty("canonicalForm").GetString());
+ Assert.Contains("air-x10-firmament-parse-succeeded", output);
}
[Fact]
- public void TraceParserBackedBoxFixture_DimensionsAreReported()
+ public void TraceParserBackedBoxFixture_DimensionsMappedToProfileExtrude()
{
var (exitCode, output, _) = Run("trace", "--fixture", PrimitiveFixture("valid/box.valid.firmfixture"), "--json");
Assert.Equal(0, exitCode);
@@ -149,7 +153,12 @@ public sealed class AirTraceCommandTests
Assert.Equal(10, dimensions.GetProperty("width").GetDouble());
Assert.Equal(8, dimensions.GetProperty("depth").GetDouble());
Assert.Equal(6, dimensions.GetProperty("height").GetDouble());
- Assert.Contains("air-x9-source-dimensions-extracted", output);
+ var constructive = doc.RootElement.GetProperty("constructiveAir");
+ Assert.Equal(10, constructive.GetProperty("width").GetDouble());
+ Assert.Equal(8, constructive.GetProperty("depth").GetDouble());
+ Assert.Equal(6, constructive.GetProperty("height").GetDouble());
+ Assert.Equal("Rectangle", constructive.GetProperty("profileKind").GetString());
+ Assert.Contains("air-x10-box-dimensions-extracted", output);
}
[Fact]
@@ -158,10 +167,12 @@ public sealed class AirTraceCommandTests
var (exitCode, output, _) = Run("trace", "--fixture", PrimitiveFixture("valid/box.valid.firmfixture"), "--json");
Assert.Equal(0, exitCode);
using var doc = JsonDocument.Parse(output); var root = doc.RootElement;
- Assert.Equal("feature-air", root.GetProperty("actualStageReached").GetString());
+ Assert.Equal("constructive-air", root.GetProperty("actualStageReached").GetString());
Assert.Equal("none", root.GetProperty("brepPlan").GetProperty("planKind").GetString());
Assert.Equal("not-requested", root.GetProperty("cirMirror").GetProperty("status").GetString());
- Assert.False(root.TryGetProperty("constructiveAir", out var constructive) && constructive.ValueKind != JsonValueKind.Null);
+ Assert.Equal("AirProfileExtrude", root.GetProperty("constructiveAir").GetProperty("nodeKind").GetString());
+ Assert.Contains("air-x10-brepplan-deferred", output);
+ Assert.Contains("air-x10-cir-mirror-deferred", output);
}
[Fact]
@@ -176,7 +187,7 @@ public sealed class AirTraceCommandTests
[Fact]
public void ParserBackedBoxExpectationFailure_ReturnsNonZeroWithReport()
{
- var source = File.ReadAllText(PrimitiveFixture("valid/box.valid.firmfixture")).Replace("// expected-stage: feature-air", "// expected-stage: cir-mirror", StringComparison.Ordinal);
+ var source = File.ReadAllText(PrimitiveFixture("valid/box.valid.firmfixture")).Replace("// expected-stage: constructive-air", "// expected-stage: cir-mirror", StringComparison.Ordinal);
var path = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N") + ".valid.firmfixture");
File.WriteAllText(path, source);
var (exitCode, output, error) = Run("trace", "--fixture", path, "--json");
@@ -184,8 +195,8 @@ public sealed class AirTraceCommandTests
using var doc = JsonDocument.Parse(output); var root = doc.RootElement;
Assert.False(root.GetProperty("fixture").GetProperty("expectationSatisfied").GetBoolean());
Assert.True(root.GetProperty("frontend").GetProperty("parseSucceeded").GetBoolean());
- Assert.Equal("feature-air", root.GetProperty("actualStageReached").GetString());
- Assert.Contains("air-x9-firmament-parse-succeeded", output);
+ Assert.Equal("constructive-air", root.GetProperty("actualStageReached").GetString());
+ Assert.Contains("air-x10-firmament-parse-succeeded", output);
}
[Fact]
diff --git a/Aetheris.CLI/AirTrace.cs b/Aetheris.CLI/AirTrace.cs
index 1c131c15..74067e6a 100644
--- a/Aetheris.CLI/AirTrace.cs
+++ b/Aetheris.CLI/AirTrace.cs
@@ -43,7 +43,7 @@ internal sealed record AirTraceReport(
internal sealed record AirTraceFixtureSummary(string Path, string Expectation, string CaseName, string? ExpectedStage, string ActualStageReached, string? ExpectedRoute, string? ExpectedReason, bool ExpectationSatisfied, bool ParserBacked, IReadOnlyList<string> Diagnostics);
internal sealed record AirTraceFrontendSummary(bool ParserBacked, string? ParserName, bool? ParseSucceeded, IReadOnlyList<string> ParseDiagnostics, string? FrontendStageReached, string? FrontendSummary);
internal sealed record AirTraceFeatureAirSummary(bool ParserBacked, string SourceOpKind, string NodeKind, AirTraceDimensionsSummary? Dimensions, string ConstructionIntent, string StageReached, IReadOnlyList<string> Diagnostics, IReadOnlyList<string> Guarantees);
-internal sealed record AirTraceConstructiveAirSummary(string NodeKind, string CanonicalForm, string StageReached, IReadOnlyList<string> Diagnostics);
+internal sealed record AirTraceConstructiveAirSummary(string NodeKind, string CanonicalForm, string SourceFeatureAirNodeKind, string ProfileKind, double Width, double Depth, double Height, string ExtrusionAxis, string ConstructionIntent, string RouteKind, string StageReached, IReadOnlyList<string> Diagnostics, IReadOnlyList<string> Guarantees);
internal sealed record AirTraceDimensionsSummary(double Width, double Depth, double Height);
internal sealed record AirTraceAirSummary(string Node, string Route, string SelectionClass, string Rule, string ConstructionHistory, string FeatureName, string FeatureId, string ProvenanceMilestone);
internal sealed record AirTraceRouteDecisionSummary(string Mode, string? SelectedRoute, bool Succeeded, string Recommendation, string SelectionClass, string Rule, IReadOnlyList<string> Diagnostics);
@@ -126,17 +126,17 @@ internal static class AirTraceReportBuilder
frontend.FeatureAir.Guarantees);
var constructiveAir = frontend.ConstructiveAir is null
? null
- : new AirTraceConstructiveAirSummary(frontend.ConstructiveAir.NodeKind, frontend.ConstructiveAir.CanonicalForm, frontend.ConstructiveAir.StageReached, frontend.ConstructiveAir.Diagnostics);
+ : new AirTraceConstructiveAirSummary(frontend.ConstructiveAir.NodeKind, frontend.ConstructiveAir.CanonicalForm, frontend.ConstructiveAir.SourceFeatureAirNodeKind, frontend.ConstructiveAir.ProfileKind, frontend.ConstructiveAir.Dimensions.Width, frontend.ConstructiveAir.Dimensions.Depth, frontend.ConstructiveAir.Dimensions.Height, frontend.ConstructiveAir.ExtrusionAxis, frontend.ConstructiveAir.ConstructionIntent, frontend.ConstructiveAir.RouteKind, frontend.ConstructiveAir.StageReached, frontend.ConstructiveAir.Diagnostics, frontend.ConstructiveAir.Guarantees);
- return new("AIR-X9", "trace", "lowering", "firmfixture", fixture.CaseName, expectationSatisfied, frontend.FrontendSummary,
- new(featureAir?.NodeKind ?? "FirmamentPrimitive", "none", "none", "none", "parser-backed-source-fixture", fixture.CaseName, fixture.CaseName, "AIR-X9"),
- new("none", null, false, "Constructive AIR and route selection are deferred for parser-backed box fixtures in AIR-X9.", "none", "none", []),
+ return new("AIR-X10", "trace", "lowering", "firmfixture", fixture.CaseName, expectationSatisfied, frontend.FrontendSummary,
+ new(constructiveAir?.NodeKind ?? featureAir?.NodeKind ?? "FirmamentPrimitive", constructiveAir?.RouteKind ?? "none", "none", "none", "parser-backed-source-fixture", fixture.CaseName, fixture.CaseName, "AIR-X10"),
+ new("none", null, false, "Route selection, BRepPlan, emission, STEP, and CIR are deferred for parser-backed box fixtures in AIR-X10.", "none", "none", []),
new("none", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "none", "none", null, []),
- new("none", false, "parser-backed fixture stops at truthful frontend boundary"),
+ new("none", false, "parser-backed fixture stops at Constructive AIR summary; BRepPlan, emission, STEP, and CIR are deferred"),
new(false, false, false, false, []),
new("not-requested", "none", "none", "FirmamentPrimitive", "none", "none", "none", [], [], [], []),
- [], ["Constructive AIR lowering not wired for parser-backed box fixture"], fxDiagnostics,
- ["real Firmament parser invoked", "parser-backed fixture reaches Feature AIR summary", "Constructive AIR deferred", "no production grammar expansion", "no production route replacement", "no new geometry"],
+ [], ["BRepPlan/emission/CIR deferred for parser-backed box fixture"], fxDiagnostics,
+ ["real Firmament parser invoked", "parser-backed fixture reaches Feature AIR summary", "parser-backed fixture reaches Constructive AIR summary", "ProfileExtrude wrapper not invoked", "no production grammar expansion", "no production route replacement", "no new geometry"],
["no production Firmament grammar expansion", "no production route replacement", "no production analyzer behavior change", "no STEP exporter/importer change", "no BRep topology behavior change", "no route-selection/JudgmentUtility behavior change", "no CIR evaluator/tape behavior change", "no Boolean behavior change", "no AirEdgeSweep behavior change", "no BrepBoundedChamfer/BrepBoundedFillet behavior change", "no chamfer/fillet/shell geometry change", "no new geometry"],
new(fixture.Path, fixture.Expectation, fixture.CaseName, fixture.ExpectedStage, actualStage, fixture.ExpectedRoute, fixture.ExpectedReason, expectationSatisfied, true, fxDiagnostics),
fixture.Path, fixture.Expectation, fixture.CaseName, fixture.ExpectedStage, actualStage, fixture.ExpectedRoute, fixture.ExpectedReason, expectationSatisfied, fxDiagnostics,
@@ -229,7 +229,7 @@ internal static class AirTraceTextRenderer
}
if (r.ConstructiveAir is not null)
{
- b.AppendLine("Constructive AIR"); b.AppendLine($" Node: {r.ConstructiveAir.NodeKind}"); b.AppendLine($" Canonical form: {r.ConstructiveAir.CanonicalForm}"); b.AppendLine($" Stage reached: {r.ConstructiveAir.StageReached}"); b.AppendLine();
+ b.AppendLine("Constructive AIR"); b.AppendLine($" Node: {r.ConstructiveAir.NodeKind}"); b.AppendLine($" Canonical form: {r.ConstructiveAir.CanonicalForm}"); b.AppendLine($" Profile: {r.ConstructiveAir.ProfileKind}(width={r.ConstructiveAir.Width:g}, depth={r.ConstructiveAir.Depth:g})"); b.AppendLine($" Extrusion: height={r.ConstructiveAir.Height:g}"); b.AppendLine($" Extrusion axis: {r.ConstructiveAir.ExtrusionAxis}"); b.AppendLine($" Intent: {r.ConstructiveAir.ConstructionIntent}"); b.AppendLine($" Route kind: {r.ConstructiveAir.RouteKind}"); b.AppendLine($" Stage reached: {r.ConstructiveAir.StageReached}"); b.AppendLine(" Diagnostics:"); foreach (var d in r.ConstructiveAir.Diagnostics) b.AppendLine($" - {d}"); b.AppendLine();
}
b.AppendLine("AIR"); b.AppendLine($" Node: {r.Air.Node}"); b.AppendLine($" Route: {r.Air.Route}"); b.AppendLine($" Selection class: {r.Air.SelectionClass}"); b.AppendLine($" Rule: {r.Air.Rule}"); b.AppendLine($" Construction history: {r.Air.ConstructionHistory}"); b.AppendLine();
b.AppendLine("Route decision"); b.AppendLine($" Mode: {r.RouteDecision.Mode}"); b.AppendLine($" Selected route: {r.RouteDecision.SelectedRoute}"); b.AppendLine($" Succeeded: {r.RouteDecision.Succeeded.ToString().ToLowerInvariant()}"); b.AppendLine();
diff --git a/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs b/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs
index b2a971a1..e60f75b7 100644
--- a/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentFrontendTraceProbe.cs
@@ -27,8 +27,15 @@ public sealed record FirmamentPrimitiveAirTraceSummary(
public sealed record FirmamentConstructiveAirTraceSummary(
string NodeKind,
string CanonicalForm,
+ string SourceFeatureAirNodeKind,
+ string ProfileKind,
+ FirmamentTraceDimensions Dimensions,
+ string ExtrusionAxis,
+ string ConstructionIntent,
+ string RouteKind,
string StageReached,
- IReadOnlyList<string> Diagnostics);
+ IReadOnlyList<string> Diagnostics,
+ IReadOnlyList<string> Guarantees);
public sealed record FirmamentTraceDimensions(double Width, double Depth, double Height);
@@ -47,21 +54,19 @@ public static class FirmamentFrontendTraceProbe
{
var dimensions = TryExtractBoxDimensions(boxOp) ?? TryExtractBoxDimensionsFromSource(sourceText);
var dimensionDiagnostics = dimensions is null
- ? new[] { "air-x9-box-dimensions-missing" }
- : new[] { "air-x9-source-dimensions-extracted" };
+ ? new[] { "air-x10-box-dimensions-missing" }
+ : new[] { "air-x10-box-dimensions-extracted", "air-x9-source-dimensions-extracted" };
var featureAirDiagnostics = new[]
{
- "air-x9-parser-backed-fixture-loaded",
- "air-x9-firmament-parser-invoked",
- "air-x9-firmament-parse-succeeded",
- "air-x9-firmament-box-op-recognized",
+ "air-x10-parser-backed-fixture-loaded",
+ "air-x10-firmament-parser-invoked",
+ "air-x10-firmament-parse-succeeded",
+ "air-x10-firmament-box-op-recognized",
+ "air-x10-feature-air-box-read",
+ "air-x10-no-production-grammar-change",
+ "air-x10-no-production-route-replacement",
"air-x9-feature-air-summary-created",
- "air-x9-feature-air-box-created",
- "air-x9-actual-stage-feature-air",
- "air-x9-box-constructive-air-lowering-not-wired",
- "air-x9-constructive-air-deferred",
- "air-x9-no-production-grammar-change",
- "air-x9-no-production-route-replacement"
+ "air-x9-feature-air-box-created"
}.Concat(dimensionDiagnostics).Order(StringComparer.Ordinal).ToArray();
var featureAir = new FirmamentPrimitiveAirTraceSummary(
@@ -69,26 +74,68 @@ public static class FirmamentFrontendTraceProbe
SourceOpKind: boxOp.OpName,
FeatureAirNodeKind: "CreateBox",
SourceDimensions: dimensions,
- ConstructionIntent: "box / rectangular prism",
+ ConstructionIntent: "Box",
StageReached: "feature-air",
Diagnostics: featureAirDiagnostics,
Guarantees:
[
"parser-backed Firmament source form",
- "Feature AIR summary only",
- "Constructive AIR deferred",
+ "Feature AIR CreateBox summary",
+ "Constructive AIR rectangle profile extrusion summary",
"no production grammar expansion",
"no production route replacement",
"no geometry emitted"
]);
+ var constructiveDiagnostics = dimensions is null
+ ? new[] { "air-x10-box-canonicalization-failed" }
+ : new[]
+ {
+ "air-x10-box-canonicalized-to-profile-extrude",
+ "air-x10-constructive-air-summary-created",
+ "air-x10-actual-stage-constructive-air",
+ "air-x10-profile-extrude-wrapper-not-invoked",
+ "air-x10-brepplan-deferred",
+ "air-x10-emission-deferred",
+ "air-x10-cir-mirror-deferred",
+ "air-x10-no-geometry-emission-required"
+ }.Order(StringComparer.Ordinal).ToArray();
+
+ var constructiveAir = dimensions is null
+ ? null
+ : new FirmamentConstructiveAirTraceSummary(
+ NodeKind: "AirProfileExtrude",
+ CanonicalForm: "rectangle-profile-extrude",
+ SourceFeatureAirNodeKind: "CreateBox",
+ ProfileKind: "Rectangle",
+ Dimensions: dimensions,
+ ExtrusionAxis: "Z",
+ ConstructionIntent: "Box",
+ RouteKind: "ProfileExtrude",
+ StageReached: "constructive-air",
+ Diagnostics: constructiveDiagnostics,
+ Guarantees:
+ [
+ "trace summary only",
+ "rectangle profile uses size[0] width and size[1] depth",
+ "extrusion uses size[2] height",
+ "profile extrusion wrapper not invoked",
+ "BRepPlan deferred",
+ "emission deferred",
+ "CIR mirror deferred"
+ ]);
+
+ var allDiagnostics = featureAirDiagnostics.Concat(constructiveDiagnostics).Order(StringComparer.Ordinal).ToArray();
return new(
"FirmamentTopLevelParser",
true,
- "feature-air",
- $"Parsed Firmament document with {opCount} op(s). Recognized box op and created Feature AIR CreateBox summary; Constructive AIR is deferred.",
- featureAirDiagnostics,
- featureAir);
+ dimensions is null ? "feature-air" : "constructive-air",
+ dimensions is null
+ ? $"Parsed Firmament document with {opCount} op(s). Recognized box op and created Feature AIR CreateBox summary; Constructive AIR canonicalization failed because dimensions were missing or invalid."
+ : $"Parsed Firmament document with {opCount} op(s). Recognized box op, created Feature AIR CreateBox summary, and canonicalized it to Constructive AIR AirProfileExtrude rectangle profile extrusion.",
+ allDiagnostics,
+ featureAir,
+ constructiveAir);
}
return new(
diff --git a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
index 49c64f36..3707cbd1 100644
--- a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
+++ b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
@@ -773,3 +773,7 @@ AIR-X8 anchors the Firmament fixture corpus to the real Firmament frontend for o
## AIR-X9 parser-backed frontend boundary note
AIR-X9 creates the first parser-backed Firmament-to-AIR boundary for the existing TOON-style primitive box fixture. The path is `Firmament source -> FirmamentTopLevelParser -> parsed box op -> Feature AIR CreateBox trace summary`. This validates the constitutional distinction between Firmament source and Feature AIR without expanding grammar, replacing production routes, or claiming Constructive AIR/BRepPlan/CIR stages that are not wired.
+
+## AIR-X10 parser-backed boundary note
+
+AIR-X10 creates the first parser-backed Feature AIR to Constructive AIR boundary: the existing Firmament `op: box` / `size[3]` fixture now traces from parsed source to Feature AIR `CreateBox` and then to a Constructive AIR `AirProfileExtrude` rectangle-profile-extrude summary. This is still a trace-only frontend-to-MIR proof; it does not change production grammar, route selection, BRepPlan, BRep, STEP, CIR, Boolean, or geometry behavior.
diff --git a/docs/air-x10-box-feature-air-to-constructive-air.md b/docs/air-x10-box-feature-air-to-constructive-air.md
new file mode 100644
index 00000000..41356c4e
--- /dev/null
+++ b/docs/air-x10-box-feature-air-to-constructive-air.md
@@ -0,0 +1,100 @@
+# AIR-X10 — Box Feature AIR to Constructive AIR/ProfileExtrude trace
+
+## Purpose and scope
+
+AIR-X10 advances the first parser-backed Firmament fixture from a Feature AIR-only trace summary to a Constructive AIR trace summary. It proves one parsed primitive source form can cross the frontend-to-constructive-MIR boundary without expanding Firmament grammar, replacing production routes, or requiring BRepPlan/BRep/STEP/CIR output.
+
+## Relationship to AIR-X9
+
+AIR-X9 proved that `fixtures/Firmament/Primitive/valid/box.valid.firmfixture` loads through `FirmFixtureLoader`, invokes `FirmamentTopLevelParser`, recognizes `op: box`, extracts `size[3]`, and reports Feature AIR `CreateBox`. AIR-X10 keeps that path and adds a narrow trace-only canonicalizer from that Feature AIR box summary to Constructive AIR `AirProfileExtrude`.
+
+## Existing Firmament syntax used
+
+AIR-X10 uses the existing TOON-style primitive syntax:
+
+```text
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 8
+ 6
+```
+
+No new syntax or grammar production is introduced.
+
+## Parser-backed fixture path
+
+```text
+fixtures/Firmament/Primitive/valid/box.valid.firmfixture
+```
+
+The fixture now expects `constructive-air`, `expected-feature-air: CreateBox`, and `expected-constructive-air: AirProfileExtrude`.
+
+## Frontend path
+
+```text
+box.valid.firmfixture
+ -> fixture metadata/source-body split
+ -> FirmamentTopLevelParser
+ -> parsed Firmament op: box
+ -> Feature AIR trace summary: CreateBox
+ -> Constructive AIR trace summary: AirProfileExtrude
+```
+
+## Dimension mapping
+
+The trace adapter maps the existing `size[3]` tuple deterministically:
+
+- `size[0]` -> width;
+- `size[1]` -> depth;
+- `size[2]` -> height.
+
+For the committed fixture this yields `width=10`, `depth=8`, and `height=6`. The rectangle profile uses width/depth. The extrusion uses height along the reported `Z` axis.
+
+## Constructive AIR summary fields
+
+The JSON/text trace surface reports:
+
+- node kind: `AirProfileExtrude`;
+- canonical form: `rectangle-profile-extrude`;
+- source Feature AIR node kind: `CreateBox`;
+- profile kind: `Rectangle`;
+- width/depth/height;
+- extrusion axis: `Z`;
+- construction intent: `Box`;
+- route kind: `ProfileExtrude` as a canonical route label only;
+- diagnostics and guarantees.
+
+## Stage reached and why
+
+The actual stage is `constructive-air` because the parsed box has all bounded data required to summarize a canonical rectangular profile extrusion. The adapter does not claim backend topology emission.
+
+## Profile wrapper/emitter status
+
+AIR-X10 does **not** invoke the existing profile extrusion wrapper or `LineArcProfileExtrudeEmitter`. It creates a Constructive AIR summary only. BRepPlan, emission, STEP smoke, and CIR mirror remain deferred with explicit diagnostics. A future milestone can invoke the wrapper if dependency direction and trace semantics remain clean.
+
+## What remains metadata-driven
+
+The AIR-X7 Chamfer fixture corpus remains metadata-driven and continues to exercise the existing AIR-X2/AIR-X6 trace paths. AIR-X10 does not migrate those fixtures to parser-backed Firmament syntax.
+
+## Non-goals
+
+- no grammar expansion;
+- no full Firmament-to-AIR migration;
+- no production route replacement;
+- no geometry changes;
+- no BRepPlan/CIR requirement;
+- no STEP exporter/importer changes;
+- no BRep topology changes;
+- no route-selection/JudgmentUtility behavior changes.
+
+## Tests run
+
+Implementation validation includes the focused CLI build/help/trace commands and filtered CLI, Firmament, Core, and FrictionLab test commands listed in the PR summary.
+
+## Recommended next milestone
+
+Recommended next milestone: **AIR-X11 — Box Constructive AIR to existing profile extrusion wrapper/emission trace**. AIR-X10 found the parser-backed source-to-Constructive-AIR bridge clean, while wrapper/emitter invocation remains deliberately deferred to avoid overstating BRepPlan, STEP, or CIR success.
diff --git a/docs/air-x6-aetheris-trace-lowering-report-cli.md b/docs/air-x6-aetheris-trace-lowering-report-cli.md
index 3cd9c5f9..99da507c 100644
--- a/docs/air-x6-aetheris-trace-lowering-report-cli.md
+++ b/docs/air-x6-aetheris-trace-lowering-report-cli.md
@@ -150,3 +150,7 @@ For `.firmfixture` inputs with `// parser-backed: true`, `aetheris trace --fixtu
## AIR-X9 Feature AIR section for parser-backed fixtures
For the parser-backed box fixture, `aetheris trace --fixture` now includes a `Feature AIR` text section and a `featureAir` JSON object. The section reports source op `box`, node `CreateBox`, dimensions when extracted, construction intent, deterministic diagnostics, and the truthful stage `feature-air`. Constructive AIR, BRepPlan, BRep/STEP, and CIR mirror sections remain unavailable/not-requested for this fixture unless a later milestone wires those boundaries.
+
+## AIR-X10 Constructive AIR fixture section
+
+For parser-backed Firmament primitive fixtures, `aetheris trace --fixture` can now include both `Feature AIR` and `Constructive AIR` sections. The AIR-X10 box fixture reports source op `box`, Feature AIR `CreateBox`, Constructive AIR `AirProfileExtrude`, canonical form `rectangle-profile-extrude`, rectangle width/depth, extrusion height, and truthful deferred BRepPlan/emission/STEP/CIR status.
diff --git a/docs/air-x7-firmament-fixture-trace-corpus.md b/docs/air-x7-firmament-fixture-trace-corpus.md
index 45ded893..ca1ddc47 100644
--- a/docs/air-x7-firmament-fixture-trace-corpus.md
+++ b/docs/air-x7-firmament-fixture-trace-corpus.md
@@ -109,3 +109,7 @@ The first parser-backed fixture is `fixtures/Firmament/Primitive/valid/box.valid
## AIR-X9 parser-backed primitive stage
The parser-backed primitive fixture `fixtures/Firmament/Primitive/valid/box.valid.firmfixture` now reaches `feature-air` through the real Firmament parser and a narrow trace summary adapter. The AIR-X7 Chamfer fixtures remain metadata-driven and continue to use their existing route-selection/lowering trace mappings.
+
+## AIR-X10 parser-backed fixture advancement
+
+The primitive parser-backed fixture `fixtures/Firmament/Primitive/valid/box.valid.firmfixture` now expects and reaches `constructive-air`. It remains parser-backed while the Chamfer corpus remains metadata-driven. The box trace reports Feature AIR `CreateBox`, Constructive AIR `AirProfileExtrude`, canonical form `rectangle-profile-extrude`, and deferred BRepPlan/emission/CIR status.
diff --git a/docs/air-x8-parser-backed-firmament-fixture.md b/docs/air-x8-parser-backed-firmament-fixture.md
index 33bde69e..bc669d7d 100644
--- a/docs/air-x8-parser-backed-firmament-fixture.md
+++ b/docs/air-x8-parser-backed-firmament-fixture.md
@@ -98,3 +98,7 @@ Recommended AIR-X9: **Firmament-to-AIR frontend boundary for parsed box primitiv
## AIR-X9 advancement
AIR-X9 advances the same parser-backed box fixture from `parsed` to `feature-air`. The syntax remains the existing TOON-style `op: box` with `size[3]`; the parser is still the real Firmament parser; and the new trace-only boundary creates a Feature AIR `CreateBox` summary with width/depth/height dimensions. Constructive AIR remains deferred and is not reported as reached.
+
+## AIR-X10 stage update
+
+The parser-backed box fixture no longer stops at `parsed` or `feature-air`: AIR-X10 traces it through Feature AIR `CreateBox` into Constructive AIR `AirProfileExtrude` as a rectangle-profile extrusion summary. The syntax remains the same existing TOON-style `op: box` / `size[3]` form.
diff --git a/docs/air-x9-firmament-to-air-box-boundary.md b/docs/air-x9-firmament-to-air-box-boundary.md
index f7634bc3..39ce3f76 100644
--- a/docs/air-x9-firmament-to-air-box-boundary.md
+++ b/docs/air-x9-firmament-to-air-box-boundary.md
@@ -84,3 +84,7 @@ The implementation was validated with the AIR-X9 parser-backed box trace command
## Recommended next milestone
Recommended next milestone: **AIR-X10 — Box Feature AIR to Constructive AIR/ProfileExtrude trace**. AIR-X9 found the Feature AIR boundary clean and dimension-bearing; the next narrow step is to decide whether a parser-backed box `CreateBox` can canonicalize to an `AirProfileExtrude` rectangle summary without creating dependency cycles or replacing production routes.
+
+## AIR-X10 advancement
+
+AIR-X10 advances the same parser-backed box fixture from `feature-air` to `constructive-air`. The trace now canonicalizes Feature AIR `CreateBox` to Constructive AIR `AirProfileExtrude` with canonical form `rectangle-profile-extrude`, using `size[0]` as width, `size[1]` as depth, and `size[2]` as height. The profile wrapper/emitter remains deferred, and BRepPlan/emission/STEP/CIR sections remain truthful non-success placeholders.
diff --git a/fixtures/Firmament/Primitive/valid/box.valid.firmfixture b/fixtures/Firmament/Primitive/valid/box.valid.firmfixture
index 08d814d2..d1c51f09 100644
--- a/fixtures/Firmament/Primitive/valid/box.valid.firmfixture
+++ b/fixtures/Firmament/Primitive/valid/box.valid.firmfixture
@@ -1,9 +1,10 @@
// case: box
// expected: valid
-// expected-stage: feature-air
+// expected-stage: constructive-air
// expected-feature-air: CreateBox
+// expected-constructive-air: AirProfileExtrude
// parser-backed: true
-// description: Minimal parser-backed Firmament primitive fixture reaching Feature AIR.
+// description: Minimal parser-backed Firmament primitive fixture reaching Constructive AIR.
firmament:
version: 1