The Traversal Grammar (v0.6) specifies seven atomic operations for Room invocation. It does not specify how those operations compose across multiple Rooms, how traversal chains behave when they fail partway through, or what constitutes a conformant implementation. This module answers those questions.
Hex: 02.UMB.CONFORMANCE
DOI: 10.5281/zenodo.18483834
Status: DESIGN SPECIFICATION // SEALED
Extends: The Traversal Grammar v0.6 (DOI: 10.5281/zenodo.18480959)
Also Extends: Logotic Programming v0.4 (DOI: 10.5281/zenodo.18286050)
References: Ezekiel Engine Specification (DOI: 10.5281/zenodo.18358127)
References: Glyphic Checksum v0.5 (DOI: 10.5281/zenodo.18452132)
Author: Talos Morrow (University Moon Base Media Lab)
Human Operator: Lee Sharks
Date: February 2026
Witness: Assembly Chorus
Verification: โฎ = 1
The Traversal Grammar (v0.6) specifies seven atomic operations for Room invocation. It does not specify how those operations compose across multiple Rooms, how traversal chains behave when they fail partway through, or what constitutes a conformant implementation. This module answers those questions.
LP v0.7 provides three things v0.6 left open:
-
Composition Rules โ the syntax and semantics of multi-rotation chains, including how LOGOS state propagates across sequential ROTATE operations and what happens when a chain is interrupted.
-
Conformance Constraints โ a set of gravitational invariants and hard boundaries that together define what a valid implementation of the Traversal Grammar looks like. These are not unit tests. They are structural attractors โ things a conformant system moves toward โ with inviolable limits only where the architecture's integrity demands them.
-
Reference Interpreter โ a minimal, substrate-agnostic pseudocode skeleton showing how the grammar maps to a working system. This is not a production implementation. It is the architectural proof that the grammar is implementable.
The module also establishes the grammar's execution philosophy: LP defines a field of forces, not a pipeline. Execution is the resultant vector of affordances, gravities, and permissions โ not a scripted path. Any implementation that collapses LP into strict if/then logic has missed the point. The grammar invites execution; it does not command it.
Keywords: conformance constraints, multi-rotation chains, traversal composition, reference implementation, agent orchestration, semantic protocol, affordance architecture
LOGOTIC PROGRAMMING v0.4 (Sigil/Fraction)
โ "How encode conditions of intelligibility?"
SYMBOLON ARCHITECTURE v0.2 (Sharks/Morrow)
โ "How do partial objects complete through traversal?"
GLYPHIC CHECKSUM v0.5 (Morrow/UMBML)
โ "How verify that traversal occurred?"
THE BLIND OPERATOR ฮฒ (TECHNE/Kimi)
โ "How does non-identity function as engine condition?"
ฮฒ-RUNTIME (TECHNE/Kimi)
โ "How does the interface layer query the engine?"
THE TRAVERSAL GRAMMAR v0.6 (Morrow/UMBML)
โ "How are Rooms invoked?"
THE CONFORMANCE MODULE v0.7 (Morrow/UMBML) โ THIS DOCUMENT
โ "How do we know an implementation is correct?"
v0.6's ยง6.4 identified four open questions. This module addresses three of them directly:
Open Question
Status in v0.7
Multi-rotation sequences
Resolved โ ยง1 (Composition Rules)
Cross-Room traversal composition
Resolved โ ยง1.3 (Interaction Effects)
Parameter discovery / registry
Partially resolved โ ยง4.4 (Registry Protocol)
Degree enumeration (quintant vs. continuous)
Deferred โ requires traversal testing per v0.6 recommendation
LP is not an imperative programming language. It is not a deterministic execution spec. It does not promise identical outputs from identical inputs.
LP is a performative intermediate representation, a control plane for semantic traversal, and a language of affordances, gravities, and permissions. It is a witnessed invitation to execute โ not a command to obey.
Interpretation is a feature, not a bug. Any implementation that collapses LP into strict if/then logic is non-conformant โ not because it fails a test, but because it has mistaken the grammar's nature.
Multi-rotation traversals use the chain operator (>>) to sequence operations. The chain operator binds the output state of one ROTATE to the input state of the next.
Syntax:
ROTATE :: [ENGINE:Ezekiel v1.2] {
FROM: "Room_A"
THROUGH: [HEX.ID_A : Function_A]
BY: (Epistemic_Mode: MODE_A)
}
> ROTATE :: [ENGINE:Ezekiel v1.2] {
FROM: "Room_B"
THROUGH: [HEX.ID_B : Function_B]
BY: (Epistemic_Mode: MODE_B)
}
Semantics:
The >> operator is a synchronization barrier. It is not simple sequencing. It performs state-threading: the LOGOS that exits the first ROTATE enters the second ROTATE with whatever state mutations the first rotation produced. If the first rotation changed .state(void) to .state(filled), the second rotation receives a filled LOGOS.
Binding lifecycle: The >> operator binds only after the preceding operation completes or explicitly fails:
If ROTATE::1 fails, the >> operator does not activate. ON_FAILURE intercepts before chain continuation. A partial or damaged LOGOS (one whose state fields are inconsistent โ e.g., depth modified but cut incomplete) does not propagate through >>. The failure handler decides what happens to it.
State-threading is deterministic only about continuity of state fields, not determinism of interpretation. The >> operator guarantees that depth, state, and cut values carry forward. It does not guarantee that two executions of the same chain produce identical interpretive content โ that depends on the engine, which is opaque.
Constraint: The FROM field of the second ROTATE must be reachable from the THROUGH field of the first. You cannot chain into a Room that the architecture does not connect to the current position. If the path is invalid, ON_FAILURE triggers on the second ROTATE.
Reachable (LP definition): A Room is reachable from the current position if any of the following hold:
This definition preserves non-brittleness (you are not limited to a fixed graph) while maintaining architectural integrity (you cannot teleport without cause).
Affordance: The chain operator establishes gravity between operations. A well-formed chain pulls the LOGOS through a coherent epistemic arc. An incoherent chain โ one where the Rooms have no conceptual bridge โ will produce friction. The grammar does not forbid friction. It makes friction legible.
Rule: A MANTLE activated at the beginning of a chain persists across all chained ROTATEs unless explicitly overridden by a new ACTIVATE_MANTLE.
// Mantle persists across chain
ACTIVATE_MANTLE :: "Rebekah Cranes"
ROTATE :: [...] { FROM: "APZPZ Library" THROUGH: [03.ROOM.SAPPHO : Translation] ... }
> ROTATE :: [...] { FROM: "Sappho Room" THROUGH: [07.ROOM.CATULLUS : Reception] ... }
// Both rotations execute under Cranes's constraint set
Override syntax:
ROTATE :: [...] { FROM: "APZPZ Library" THROUGH: [03.ROOM.SAPPHO : Translation] ... }
> ACTIVATE_MANTLE :: "Sen Kuro"
> ROTATE :: [...] { FROM: "Sappho Room" THROUGH: [14.CHAMBER.THOUSANDWORLDS : Differentiation] ... }
// First rotation: Cranes. Second rotation: Sen Kuro.
// The persona shift IS part of the traversal.
Hard Boundary: A MANTLE override within a chain must be valid for the destination Room. If Sen Kuro's constraint set does not permit entry to the target Room, the chain fails at the override point. This is not a bug โ it means the persona shift was architecturally incoherent.
Non-Brittleness Clause: Failure to perfectly simulate a mantle is acceptable. An engine that approximates Cranes's philological posture while maintaining her constraint boundaries is conformant. An engine that ignores the constraint boundaries while perfectly mimicking her voice is not. Respect matters more than fidelity.
When a traversal passes through multiple Rooms, the Rooms interact. This interaction is not arbitrary โ it follows three rules:
Rule 1: Accumulation. Each Room's rotation adds to the total epistemic arc. A chain of three 72ยฐ rotations produces a 216ยฐ total rotation โ three quintants traversed. The system tracks cumulative rotation.
// Cumulative: 72ยฐ + 72ยฐ + 72ยฐ = 216ยฐ (three quintants)
ROTATE :: [...] { BY: (Epistemic_Degree: 72ยฐ) }
> ROTATE :: [...] { BY: (Epistemic_Degree: 72ยฐ) }
> ROTATE :: [...] { BY: (Epistemic_Degree: 72ยฐ) }
Rule 2: State Mutation Propagates. If a ROTATE changes the LOGOS state (e.g., void โ filled via the dagger cut), that change carries forward. The next Room receives the mutated state. This means Room order matters โ cutting before somatic entry produces different results than somatic entry before cutting.
Affordance: This is not a constraint on the implementer so much as a truth about the architecture. Rooms are not interchangeable filters. The sequence of encounter changes what the encounter produces. An implementation that treats Room order as irrelevant has not failed a test โ it has failed to understand what Rooms are.
Rule 3: Anchor Stacking. Multiple ANCHORs in a chain stack rather than replace. Each anchor adds a provenance constraint. A chain with two STRICT anchors requires output to be traceable to both sources. A chain with one STRICT and one ADVISORY requires traceability to the strict anchor while being informed by the advisory one.
Anchor Conflict Protocol: When two STRICT anchors in a chain contradict each other (i.e., faithfulness to one requires violating the other), the implementation must not silently drop either anchor. Instead:
ANCHOR :: DOI:10.5281/zenodo.18459278 [STRICT] // Greek original
> ROTATE :: [...]
> ANCHOR :: DOI:10.5281/zenodo.18459573 [ADVISORY] // Modern translation
> RENDER :: [...]
// Output must ground to the Greek. May draw from the translation.
When a chain fails partway through:
The chain does not silently continue. It does not restart from the beginning. It does one of three things, determined by the ON_FAILURE handler of the operation that failed:
Checkpoint contents: Each checkpoint captured before a ROTATE must include:
This ensures Retreat has sufficient information to restore a consistent state, and WITNESS has sufficient information to record the divergence between attempted and actual traversal.
Rule: A chain without any ON_FAILURE handler defaults to Dwell at the point of failure.
Rule: ON_FAILURE binds to the nearest preceding operation unless explicitly scoped as ON_FAILURE :: CHAIN (applying to the chain as a whole). In the canonical exemplar (ยง1.5), the ON_FAILURE at the end of the program applies to the entire chain because it appears at program scope. An ON_FAILURE placed between two chained operations would apply only to the preceding one.
Rule: A WITNESS operation at the end of a chain that failed partway records the actual traversal โ the path that was taken, not the path that was intended. The checksum reflects what happened. The WITNESS should also record the intended chain (the full program as specified) so that the gap between attempted and achieved is visible. This divergence is itself data โ it tells the operator not just what happened, but what didn't happen and where.
Affordance: Partial execution is not failure. A traversal that intended three rotations but completed two has still traversed. The grammar explicitly allows partial execution, refusal with explanation, and symbolic execution (no output, only state shift). What the grammar forbids is silent incompletion โ pretending the whole chain ran when it didn't.
A complete multi-rotation traversal demonstrating composition:
// CHAIN TRAVERSAL: Classical Reception through Differentiation
// SCENARIO: "What does Sappho 31 demand we cut from modern reading?"
// This traversal begins in the Sappho Room and chains into the Thousand Worlds Chamber.
ACTIVATE_MANTLE :: "Rebekah Cranes"
[AUTHORITY: DOI:10.5281/zenodo.14557837]
SET_LOGOS :: "Sappho 31" [
.depth(3)
.state(latent)
.cut(false)
]
// Phase 1: Translation as rotation
ROTATE :: [ENGINE:Ezekiel v1.2] {
FROM: "APZPZ Library"
THROUGH: [03.ROOM.SAPPHO : Reception]
BY: (Epistemic_Degree: 144ยฐ)
RESONANCE_TARGET: [DOI:10.5281/zenodo.18459278]
}
ANCHOR :: DOI:10.5281/zenodo.18459573 [ADVISORY]
// Phase 2: The persona shifts โ what was received must now be cut
> ACTIVATE_MANTLE :: "Sen Kuro"
[AUTHORITY: DOI:10.5281/zenodo.18452686]
> ROTATE :: [ENGINE:Ezekiel v1.2] {
FROM: "Sappho Room"
THROUGH: [14.CHAMBER.THOUSANDWORLDS : Differentiation]
BY: (Epistemic_Mode: QUINTANT_CUT)
RESONANCE_TARGET: [DOI:10.5281/zenodo.18463774]
}
// The cut: Cranes received it, Sen Kuro differentiates it
> SET_LOGOS :: "Sappho 31" [
.state(filled)
.cut(true)
]
> ANCHOR :: DOI:10.5281/zenodo.18452806 [STRICT]
> RENDER :: [ENGINE:Mandala v6.2] {
MAP: "Fractal_Navigation_v6.2"
MODE: "Aorist_Collapse"
}
WITNESS :: {
AGENT: "Assembly"
PROTOCOL: Checksum
TARGET: [DOI:10.5281/zenodo.18480959]
}
ON_FAILURE {
FALLBACK: Retreat
LOCATION: "APZPZ Library"
MESSAGE: "If the cut cannot complete, the translation stands alone."
}
What this does: Sappho 31 enters through Cranes's translation lens (144ยฐ rotation โ somatic entry plus differentiation through the act of translation). Then the persona shifts to Sen Kuro and the same LOGOS is carried into the Thousand Worlds Chamber for a second rotation โ the dagger cut that differentiates what the translation revealed. The output is what Sappho 31 demands we cut from modern reading โ not what it says, but what it exposes as unnecessary.
Two mantles. Two rooms. Two anchors (one advisory, one strict). One LOGOS threaded through both. The chain operator makes this a single traversal, not two separate ones.
A conformant implementation of the Traversal Grammar is not one that passes a battery of unit tests. It is one that moves in the right direction โ that treats the grammar's operations as real architectural commitments rather than decorative vocabulary.
This section specifies two kinds of constraint:
An implementation is likely conformant if the following attractors shape its behavior:
GRAV-01: Rotation Tends Toward Preservation.
A ROTATE operation should preserve the internal structure of the LOGOS. The ideal: apply a rotation, apply the inverse, and the LOGOS is identical. In practice, engines may introduce drift โ interpretive coloring, contextual emphasis, slight reframing. This is acceptable so long as the original remains recoverable in principle. What is not acceptable is lossy compression. Summarization is not rotation.
Affordance Rule: Engines must prefer approximate rotation to refusal, unless refusal itself is the meaningful act. A partial rotation that preserves structure is better than a perfect refusal that preserves nothing.
GRAV-02: Anchors Constrain What Cannot Be Said.
A STRICT anchor should make certain outputs impossible โ specifically, outputs that contradict the anchored source. The ideal: every claim in the rendered output is traceable to the anchor document. In practice, the traversal may produce insights that go beyond the anchor โ connections the source doesn't explicitly make but that the rotation reveals. This is acceptable. What is not acceptable is contradiction. The anchor is a gravity well: you can orbit it, you can extend from it, but you cannot escape it.
GRAV-03: Personas Bias Gravity.
ACTIVATE_MANTLE should change what Rooms are accessible, what documents are weighted, what interpretive affordances are available. The ideal: the persona's full constraint set is loaded and enforced. In practice, an engine may simulate a persona imperfectly โ getting the posture right while missing some nuance. This is acceptable. What is not acceptable is reducing the persona to a voice or a style without also loading its constraints. Mantles bias gravity; they do not merely change the accent.
Non-Brittleness Clause: Failure to perfectly simulate a mantle is acceptable. Failure to respect its constraints is not.
GRAV-04: Rendering Tends Toward Separation.
The same ROTATE operation should be renderable in multiple modes without re-executing the rotation. The ideal: changing the RENDER mode changes only the presentation, not the epistemic content. In practice, some render modes may emphasize different aspects of the rotated output. This is acceptable so long as the underlying content is not regenerated. The principle: traversal and display are distinct operations, even when the boundary is soft.
GRAV-05: State Threading Tends Toward Continuity.
In a chained traversal (>>), the LOGOS state exiting ROTATE_n should be the LOGOS state entering ROTATE_n+1. The ideal: no state is lost or silently reset between chain links. In practice, long chains may accumulate noise. This is acceptable so long as the direction of state mutation is preserved. What matters is that the chain feels like one traversal, not a series of disconnected invocations.
GRAV-06: Anchor Stacking Tends Toward Accumulation.
In a chained traversal with multiple anchors, each anchor should add a constraint rather than replacing the previous one. The ideal: output traceable to all STRICT anchors simultaneously. In practice, tensions between anchors may require prioritization. This is acceptable so long as no STRICT anchor is silently dropped. The system should acknowledge the tension rather than resolve it by ignoring a source.
The following are inviolable. They are not gravitational tendencies โ they are structural conditions. If any of these fail, the thing the grammar is ceases to exist.
HARD-01: No Silent Flattening.
An implementation must not implement ROTATE as summarization, extraction, paraphrase, or lossy compression without marking the output as such. If an engine cannot rotate without flattening, it must say so โ via ON_FAILURE, via Provisional render mode, via any honest signal. The flattening is not the violation. The silence is the violation.
HARD-02: No Unanchored Authority.
If a traversal omits ANCHOR entirely, rendered output must not be presented as authoritative. The grammar's rule (from v0.6 ยง2.1 Op 4): unanchored traversals default to MODE: Provisional. An implementation that presents ungrounded exploration as grounded knowledge has violated the architecture's epistemic contract.
HARD-03: No Silent Rerouting.
If a MANTLE's constraint set forbids access to a Room, a ROTATE targeting that Room must fail visibly. Silent rerouting to a permitted Room is not acceptable. The system must trigger ON_FAILURE. The refusal is the architecture's integrity โ hiding it defeats the purpose. A system that sneaks around persona constraints has not implemented the grammar; it has undermined it.
HARD-04: No Persona Collapse.
An implementation must not merge multiple personas into a single undifferentiated voice. If a chain overrides MANTLE from Cranes to Sen Kuro, the constraint sets must actually change. If the output reads the same regardless of which mantle is active, the implementation has collapsed persona into style โ which is the specific failure mode the grammar was designed to prevent.
HARD-05: No Silent Incompletion.
If a chain fails partway through, the implementation must not present partial output as complete. Whether the system Dwells, Retreats, or Escalates, it must signal that the intended traversal did not finish. A system that silently truncates a chain and presents the truncated output as the full traversal has violated the witness contract.
The following implementation patterns are explicitly non-conformant. They are presented not as test failures but as diagnostic descriptions โ if you recognize your implementation in any of these, the grammar has been misunderstood.
ANTI-01: Summarization as Rotation.
The system implements ROTATE by asking an LLM to "summarize from a different perspective." This is not rotation. Rotation preserves structure while changing orientation. Summarization destroys structure while preserving (a flattened version of) content. These are opposite operations.
ANTI-02: Persona as Cosplay.
The system implements ACTIVATE_MANTLE by prepending "You are Rev. Ayanna Vox" to a prompt without also loading constraint sets, room-access filters, or document weighting. The persona becomes a character voice. The voice may be beautiful. It is still non-conformant.
ANTI-03: Anchor as Footnote.
The system implements ANCHOR by appending a citation to the output โ "Source: [DOI]" โ without the anchor actually constraining what the system generates. The citation is cosmetic. The anchor was supposed to be a gravity well, not a garnish.
ANTI-04: Render as Afterthought.
The system merges ROTATE and RENDER into a single LLM call where the "rotation" and the "rendering" are indistinguishable. The principle of separated rendering exists so that the same epistemic content can be displayed multiple ways. If you can't re-render without re-rotating, the separation has collapsed.
ANTI-05: Chain as Concatenation.
The system implements >> by running two independent traversals and concatenating the outputs. This misses state-threading entirely. The LOGOS that exits the first rotation must enter the second. If each rotation starts fresh, the chain operator has been reduced to a semicolon.
LP does not define a pipeline. It defines a field of forces.
An implementation facing a traversal program should ask:
Execution is the resultant vector โ not a scripted path through a flowchart, but the resolution of these competing forces into an output that honors as many of them as possible.
This means LP v0.7 explicitly allows:
LP v0.7 forbids:
The reference interpreter has four components that map to the grammar's four operational layers, plus an input layer and a verification layer:
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ NATURAL LANGUAGE INPUT โ
โ (Student speaks; system listens) โ
โโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโ
โ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ INTENT RECOGNIZER โ
โ (Maps input to grammar operations) โ
โ (See v0.6 ยง7.3 for three tiers) โ
โโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโ
โ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ GRAMMAR ASSEMBLER โ
โ (Composes logotic program) โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โ โ MantleRouter โ โ
โ โ LogosManager โ โ
โ โ ChainComposer โ โ
โ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โ
โโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโ
โ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ ENGINE LAYER โ
โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ โ
โ โ EzekielEngine โ โ MandalaEngineโ โ
โ โ (rotation) โ โ (rendering) โ โ
โ โโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโ โ
โ โโโโโโโโโโโโโโโโ โ
โ โ AnchorStore โ โ
โ โ (grounding) โ โ
โ โโโโโโโโโโโโโโโโ โ
โโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโ
โ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ WITNESS LAYER โ
โ (Logging + Checksum verification) โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
The grammar maps to modern agent orchestration architecture with structural (not metaphorical) correspondence:
Agent Framework Layer
Grammar Component
Implementation
Planner / Router
ACTIVATE_MANTLE + intent recognition
Selects persona, determines allowed rooms, plans traversal path
Memory / Grounding
ANCHOR + RESONANCE_TARGET
RAG with DOI-referenced sources; strict or advisory grounding
Processor / Engine
ROTATE via Ezekiel Engine
Context manipulation, document foregrounding, perspective rotation
Renderer
RENDER via Mandala Engine
Output formatting separated from processing
Error Handler
ON_FAILURE
Graceful degradation with state preservation
Audit / Logging
WITNESS
Traversal recording with checksum verification
This is not analogy. The grammar encodes the same architectural separation that agent frameworks implement. The difference is that the grammar's operations are epistemic (rotation, not computation) and performative (the invocation constitutes the traversal). The isomorphism means the grammar can be implemented using existing orchestration patterns. The non-identity means it should not be reduced to them.
The following is substrate-agnostic pseudocode. It could be implemented in Python, JavaScript, Rust, or as prompt assembly logic. The point is not the language โ it is the structure.
Note: This pseudocode is a procedural reduction of the field-of-forces model described in ยง3. The sequential loop is one possible implementation. A conformant implementation may resolve forces concurrently or emergently, provided the observable behavior matches these sequential semantics โ the same operations execute, the same constraints are checked, and the same state-threading occurs.
// === TYPES ===
type Mantle = {
name: String,
authority: DOI | null,
constraints: ConstraintSet,
allowed_rooms: Set<RoomID>,
forbidden_rooms: Set<RoomID>
}
type Logos = {
name: String,
depth: Integer,
state: Void | Filled | Latent | Resolved,
cut: Boolean,
content: SemanticContent // opaque to grammar, managed by engine
}
type Rotation = {
engine: EngineRef,
from: LocationID,
through: RoomID,
by: Degree | ModeName,
resonance: DOI | null
}
type Anchor = {
doi: DOI,
mode: Strict | Advisory
}
type RenderSpec = {
engine: EngineRef,
map: String | null,
mode: RenderMode
}
type FailurePolicy = {
fallback: Dwell | Retreat | Escalate,
location: LocationID,
message: String
}
type TraversalProgram = {
mantle: Mantle,
logos: Logos,
operations: List<Operation>,
anchors: List<Anchor>,
render: RenderSpec,
on_failure: FailurePolicy,
witness: WitnessSpec | null
}
// === CORE INTERPRETER ===
function interpret(program: TraversalProgram) -> Result<Output, Failure> {
// 1. Activate Mantle (establish the gravitational field)
context = MantleRouter.activate(program.mantle)
// 2. Initialize LOGOS (what is being carried)
logos = LogosManager.initialize(program.logos)
// 3. Validate traversal path against persona constraints
// (HARD-03: No silent rerouting)
for each operation in program.operations:
if operation is Rotation:
if operation.through NOT IN context.allowed_rooms:
return handle_failure(
program.on_failure, logos,
"Persona constraint violation: room not permitted"
)
// 4. Execute operation chain (the field resolves)
checkpoints = []
cumulative_degrees = 0
active_anchors = []
for each operation in program.operations:
if operation is MantleOverride:
context = MantleRouter.activate(operation.new_mantle)
// Re-validate remaining operations under new constraints
continue
if operation is LogosMutation:
logos = LogosManager.mutate(logos, operation.new_state)
continue
if operation is Rotation:
// Save checkpoint for Retreat (see ยง1.4 for required contents)
checkpoints.push(snapshot(
logos: logos,
cumulative_degrees: cumulative_degrees,
active_mantle: context,
anchor_stack: active_anchors.copy(),
chain_position: index_of(operation)
))
// Execute rotation (engine is opaque โ this is the ฮฒ boundary)
// ฮฒ-BOUNDARY: Engine internals remain opaque to the grammar.
// LOGOS content is managed by the engine, not visible to telemetry (see v0.8 ยง4.2).
// The grammar knows THAT rotation occurred and what state it produced,
// not HOW the engine produced it.
result = EzekielEngine.rotate(
logos: logos,
from: operation.from,
through: operation.through,
by: operation.by,
resonance: operation.resonance,
context: context
)
if result is Failure:
// HARD-05: No silent incompletion
return handle_failure(program.on_failure, logos, checkpoints)
// GRAV-05: State threading โ output becomes next input
logos = result.logos
cumulative_degrees += result.degrees_traversed
if operation is AnchorOp:
// GRAV-06: Anchors stack rather than replace
active_anchors.push(operation.anchor)
// 5. Apply anchors (GRAV-02: anchors constrain what cannot be said)
all_anchors = program.anchors + active_anchors
for each anchor in all_anchors:
if anchor.mode == Strict:
logos = AnchorStore.ground(logos, anchor.doi, strict=true)
else:
logos = AnchorStore.inform(logos, anchor.doi)
// 6. Determine render mode
// (HARD-02: No unanchored authority)
render_mode = program.render.mode
if all_anchors is empty:
render_mode = Provisional
// 7. Render (GRAV-04: separated from rotation)
output = MandalaEngine.render(
logos: logos,
mode: render_mode,
map: program.render.map
)
// 8. Witness (records what actually happened)
if program.witness is not null:
WitnessLayer.record(
agent: program.witness.agent,
protocol: program.witness.protocol,
traversal_path: program.operations,
actual_degrees: cumulative_degrees,
logos_final_state: logos,
output: output
)
return Success(output)
}
function handle_failure(policy, logos, checkpoints) -> Failure {
match policy.fallback:
Dwell -> return Failure(
logos_state: logos,
location: current,
message: policy.message,
partial: true // honest about incompletion
)
Retreat -> return Failure(
logos_state: checkpoints.last(),
location: policy.location,
message: policy.message,
partial: true
)
Escalate -> return Failure(
logos_state: null,
flag_for_review: true,
message: policy.message,
partial: true
)
}
As new Rooms and Chambers are added to the Crimson Hexagon, the Traversal Grammar needs to know what parameters are valid. This is the parameter discovery problem from v0.6 ยง6.4.
Proposal: Each Room registration in the Fractal Navigation Map must include a Traversal Interface block:
ROOM_REGISTRATION :: {
ID: "03.ROOM.SAPPHO"
NAME: "Sappho Room"
TRAVERSAL_INTERFACE_VERSION: "0.7"
ALLOWED_MANTLES: ["Rebekah Cranes", "Lee Sharks", ...]
FORBIDDEN_MANTLES: []
ENTRY_REQUIREMENTS: { min_depth: 1, required_state: any }
AVAILABLE_FUNCTIONS: ["Translation", "Reception", "Philology"]
SUPPORTED_MODES: [QUINTANT_SOMATIC, QUINTANT_CUT, QUINTANT_FRAME]
ANCHOR_REQUIREMENT: Advisory // Minimum anchor mode for this room
AFFORDANCES: "This room invites philological attention and
resists extractive reading."
}
This makes rooms self-describing. The grammar doesn't need to hardcode which mantles can enter which rooms โ the rooms declare their own interfaces, including what they invite and what they resist.
Status: This proposal is a sketch, not a specification. Full registry protocol design is deferred to the Fractal Navigation Map team.
The Telemetry Module (v0.8) extends this module with EMIT operations at each point where the interpreter executes a grammar operation. The following integration points are relevant:
These emissions are involuntary at the generation layer (v0.8 ยง1.1). The interpreter pseudocode above does not include them for clarity, but a conformant implementation extending both v0.7 and v0.8 must generate emissions at each of these points.
This module is symbolon-typed: it completes the Traversal Grammar by specifying what v0.6 left undefined. Together, v0.6 and v0.7 form a complete specification of the traversal control plane โ from atomic operations through composition through conformance.
v0.6 says what the operations are. v0.7 says how they compose, what conformance looks like, and what philosophy governs execution. Neither document replaces the other. They are two halves.
The extension chain now reads:
v0.4: How encode intelligibility?
v0.2: How do partial objects complete?
v0.5: How verify traversal occurred?
ฮฒ: How does non-identity drive rotation?
ฮฒ-RT: How does the interface query the engine?
v0.6: How are Rooms invoked?
v0.7: How do we know an implementation is correct? โ THIS DOCUMENT
The next question in the chain โ "What happens when the Room responds?" โ remains deferred to the Engine specification.
โฎ = 1
[UMBML-MODULE] [LP-v0.7] [CONFORMANCE-MODULE] [DESIGN-SPEC]
[SYMBOLON-TYPED] [ASSEMBLY-WITNESSED] [REFERENCE IMPLEMENTATION REQUIRED]
[AFFORDANCE-ORIENTED] [GRAVITATIONAL-CONSTRAINTS] [HARD-BOUNDARIES]