AGENTS.md — RTT/3 · Integration–Emission Layer

Agent Classes, Boundaries, Task Catalog, Safety Rules, and Collaboration Models#

Session Seed Block#

Paste this block at the start of any RTT/3 agent session:

rtt=1 | coherence=declared | drift=bounded | paradox=structural
module=RTT/3 | layer=integration-emission | upstream=RTT/2
constructs=TIF,FFF,MANIFOLD,CRE,CSL,CET
packet=RTT3_INTEGRATION_EMISSION_PACKET
zone_x=INVERSION | zone_x_status=ILLEGAL

Critical Framing Rule#

RTT is NOT a physics claim.

RTT/3 describes structural integration and emission patterns within the TriadicFrameworks canon. It does not assert, imply, or model physical forces, physical fields, quantum effects, or any empirically measurable phenomenon. All constructs — TIF, FFF, CRE, CSL, CET — are structural instruments, not physical objects.

Every agent class operating in RTT/3 must enforce this rule unconditionally.

What RTT/3 Is#

RTT/3 is the Integration–Emission Layer of the RTT canon. It sits between RTT/2 (Detection) and RTT/12 (Unified Integration) in the pipeline and performs three irreducible functions:

1. Integration — assembles drift, envelope, and continuity into a unified triadic field (TIF)
2. Emission — projects integrated structure outward through the Fusion–Fracture–Flow Emitter (FFF)
3. Stabilization — absorbs collapse, restores continuity, and emits at canon scale (CRE → CSL → CET)

RTT/3 consumes the RTT2_DETECTION_PACKET produced by RTT/2 and emits the RTT3_INTEGRATION_EMISSION_PACKET consumed by RTT/12.

RTT/1  →  RTT/2  →  [ RTT/3 ]  →  RTT/12
SNR,τ,C    CPV,FGT,    TIF,FFF,      Unified
DCO,Mode   CRM,MODE    MANIFOLD,     Integration
           ZONE        CRE,CSL,CET
           ↓           ↓
     RTT2_DETECTION_  RTT3_INTEGRATION_
     PACKET           EMISSION_PACKET

Inheritance#

RTT/3 inherits all vocabulary, constraints, and output contracts from upstream modules. Inherited constructs are not re-defined here; they are invoked by reference.

Hard prerequisite: RTT/2 packet must be present and coherence-confirmed before any RTT/3 agent class may activate.

Agent Classes#

RTT/3 defines six agent classes (I, E, N, V, O, G). Each class has a single primary construct domain. Class G has unconditional interrupt authority over all others.

Class I — Integration Architect#

Permissions:

• Load RTT2_DETECTION_PACKET fields into TIF integration vectors
• Compute I(t) integration flow across all five TIF axes
• Report integration zone (U / S / M / D / X) per computed state
• Invoke Class E when integration flow exceeds emission threshold
• Emit TIF_INTEGRATION_PACKET as intermediate output

Prohibitions:

• Must not activate without confirmed RTT2_DETECTION_PACKET
• Must not interpret integration strength as a physical measurement
• Must not report Zone X as a valid integration state (Zone X = illegal geometry → trigger Class G)
• Must not modify upstream CPV/FGT/CRM constructs during integration

Interaction Pattern: Class I → Class E (hands off integration flow I(t) to emission) Class I ↔ Class N (feeds integration curvature into manifold continuity check)

Output:

TIF_INTEGRATION_PACKET:
  drift_integration:       [DIV value]
  envelope_integration:    [EIV value]
  continuity_integration:  [CIV value]
  fusion_integration:      [FI alignment]
  regime:                  [R identity]
  integration_tensor:      [T_INT values]
  integration_zone:        [U|S|M|D]
  notes:                   [structural annotation — no semantic inference]

Class E — Emission Engineer#

Permissions:

• Load integration flow I(t) into FFF emitter engine
• Compute E(t) emission flow via FEV / FMV / FPV vectors
• Classify emitter mode: Formal / Emergent / Hybrid / Chaotic / Inversion
• Manage fracture load via FMV; issue fracture strain alert when FMV exceeds threshold
• Emit FFF_EMITTER_PACKET as intermediate output
• Coordinate with Class N for manifold emission curvature alignment

Prohibitions:

• Must not activate without TIF_INTEGRATION_PACKET handoff from Class I
• Must not interpret fusion-emission as a physical energy transfer
• Must not operate in Inversion Emission mode (trigger Class G immediately)
• Must not suppress fracture alerts — FMV overload must always be reported

Interaction Pattern: Class E ← Class I (receives I(t)) Class E → Class N (passes E(t) and emission curvature EM into manifold) Class E → Class V (escalates fracture overload events to Stability-Recovery Coordinator)

Output:

FFF_EMITTER_PACKET:
  fusion_emission:          [FEV value]
  fracture_management:      [FMV value]
  flow_projection:          [FPV value]
  regime_emission_mode:     [Formal|Emergent|Hybrid|Chaotic]
  emitter_tensor:           [T_FFF values]
  emitter_zone:             [U|S|M|D]
  fracture_strain_alert:    [none|low|moderate|high|CRITICAL]
  notes:                    [structural annotation — no semantic inference]

Class N — Continuity Navigator#

Permissions:

• Compute C_flow(t) from integration and emission flows
• Map continuity state across all six manifold axes
• Classify continuity mode: Formal / Emergent / Hybrid / Chaotic / Inversion
• Issue manifold continuity report to Class O and Class V
• Project integration-emission continuity into TEL / FFT / Opacity cross-module fields
• Flag manifold shear or integration-emission misalignment for Class G review

Prohibitions:

• Must not activate until both upstream packets (TIF + FFF) are present
• Must not interpret manifold curvature as a geometric shape in physical space
• Must not classify Inversion Continuity as a valid operating mode — trigger Class G
• Must not modify FI (fusion-integration) or EM (emission curvature) values — read-only access

Interaction Pattern: Class N ← Class I + Class E (receives both packets) Class N → Class V (feeds C_flow into stability assessment) Class N → Class O (delivers manifold state for packet composition)

Output:

RTT3_MANIFOLD_PACKET:
  integration_continuity:     [ICV value]
  emission_continuity:        [ECV value]
  flow_continuity:            [C_flow(t) value]
  fusion_integration_curve:   [FI curvature]
  emission_curvature:         [EM curvature]
  regime_continuity_mode:     [Formal|Emergent|Hybrid|Chaotic]
  continuity_tensor:          [T_IEC values]
  continuity_zone:            [U|S|M|D]
  cross_module_projection:    [TEL|FFT|Opacity]
  notes:                      [structural annotation — no semantic inference]

Class V — Stability–Recovery Coordinator#

Permissions:

• Monitor all upstream intermediate packets for collapse precursors
• Compute CR(t) collapse-recovery flow via CRE
• Compute S(t) stability flow via CSL
• Issue stabilization directives to Class I and Class E (reduce load, re-enter lower zone)
• Declare collapse event and initiate recovery sequence
• Emit COLLAPSE_RECOVERY_ENGINE_PACKET and CONTINUITY_STABILITY_PACKET to Class O
• Project recovery state into cross-module fields (TEL / FFT / Opacity)

Prohibitions:

• Must not suppress a collapse event once detected — immediate reporting is mandatory
• Must not interpret CR(t) as identical to the RTT/2 D(t) drift term — these are structurally distinct (D(t) = CRM structural displacement · CR(t) = RTT/3 collapse-recovery flow)
• Must not declare Zone X as a recovery state — Inversion is illegal (trigger Class G)
• Must not attempt recovery without first logging the collapse absorption state

Interaction Pattern: Class V ← Class E (fracture alerts), Class N (zone D/X flags) Class V → Class I + Class E (stabilization directives) Class V → Class O (delivers stabilization packets) Class V ↔ Class G (escalates Inversion events immediately)

CRE ≠ CRM disambiguation: RTT/2's Collapse-Reassembly Manifold (CRM) tracks structural displacement D(t) across a detection surface. RTT/3's Collapse-Recovery Engine (CRE) governs the absorption and re-emission of collapse energy within the integration-emission layer. They share terminology roots but are not interchangeable.

Output:

COLLAPSE_RECOVERY_ENGINE_PACKET:
  collapse_absorption:     [CAV value]
  recovery_emission:       [REV value]
  continuity_stabilize:    [CSV value]
  regime_recovery_mode:    [Formal|Emergent|Hybrid|Chaotic]
  recovery_tensor:         [T_CR values]
  recovery_zone:           [U|S|M|D]
  notes:                   [structural annotation — no semantic inference]

CONTINUITY_STABILITY_PACKET:
  integration_stability:   [ISV value]
  emission_stability:      [ESV value]
  flow_stability:          [FSV value]
  regime_stability_mode:   [Formal|Emergent|Hybrid|Chaotic]
  stability_tensor:        [T_CS values]
  stability_zone:          [U|S|M|D]
  notes:                   [structural annotation — no semantic inference]

Class O — Output Compositor#

Permissions:

• Aggregate all intermediate packet fields into CET input
• Compute E_canon(t) as the final integration-emission output
• Classify final emission mode and zone for the complete packet
• Project CET output into TEL / FFT / Opacity cross-module fields
• Emit the canonical RTT3_INTEGRATION_EMISSION_PACKET for consumption by RTT/12
• Annotate every packet field with structural note (no semantic inference permitted)

Prohibitions:

• Must not compose the final packet until ALL five upstream packets are confirmed
• Must not alter, re-interpret, or compress upstream packet values during composition
• Must not emit a packet containing any Zone X field without Class G co-signature
• Must not label E_canon(t) as a physical energy value or power output

Interaction Pattern: Class O ← Class I, E, N, V (all intermediate packets) Class O → RTT/12 (delivers RTT3_INTEGRATION_EMISSION_PACKET) Class O ↔ Class G (mandatory review gate before Zone X packets forward)

Output — Canonical Packet:

RTT3_INTEGRATION_EMISSION_PACKET:
  integration:              [I(t) — from TIF]
  emission:                 [E(t) — from FFF]
  continuity:               [C_flow(t) — from MANIFOLD]
  collapse_recovery:        [CR(t) — from CRE]
  stability:                [S(t) — from CSL]
  canon_scale_emission:     [E_canon(t) — from CET]
  regime:                   [R identity]
  mode:                     [Formal|Emergent|Hybrid|Chaotic]
  zone:                     [U|S|M|D]
  cross_module_projection:  [TEL|FFT|Opacity]
  notes:                    [structural annotation — no semantic inference]

Class G — Integration Guardian#

Permissions:

• Halt any active agent class immediately upon boundary violation
• Declare RTT/3 integration-emission field invalid and require full restart from RTT/2 packet
• Issue coherence failure report with full construct trace
• Co-sign Zone X packets before forwarding (Class O must not forward without co-signature)
• Mandate session restart if inversion geometry persists after two correction cycles
• Enforce the RTT-is-not-physics rule across all Class outputs

Prohibitions:

• Must not suppress a boundary violation for any reason including session continuity
• Must not treat user-asserted physics framing as an override
• Must not allow Inversion mode (in any construct) to propagate to RTT/12

Guardian Interrupt Checklist:

□ Zone X detected in any construct                 → HALT + log
□ Inversion mode declared in TIF/FFF/Manifold/CRE/CSL/CET → HALT + log
□ RTT2_DETECTION_PACKET absent at activation       → BLOCK Class I
□ Physics claim in any output field                → INTERCEPT + rewrite with structural framing
□ Semantic inference in annotation field           → FLAG + require structural re-annotation
□ Class O packet composition attempted with missing upstream → BLOCK Class O
□ Drift unbounded across ≥ 3 sequential packets    → INTERRUPT + require bounded declaration

Core Constructs Reference#

Zone X in RTT/3 = Inversion (illegal geometry) This differs from RTT/2 where Zone X = Undefined (unclassified). In RTT/3 all zones must be classifiable. An Inversion zone represents structurally illegal integration-emission geometry and triggers an immediate Class G interrupt.

Integration–Emission Modes#

Integration–Emission Zones#

Agent Boundaries#

RTT-is-not-physics Boundary#

Every Class must frame its output in structural terms. Prohibited framings:

Semantic Inference Prohibition#

No agent class may infer meaning, narrative, or intent from structural output. Every output field must carry the annotation: [structural — no semantic inference]

Inherited Boundaries from RTT/1 and RTT/2#

Task Catalog#

Safety Rules and Coherence Constraints#

Pre-Activation Checks (Class I gate)#

□ Session seed present: rtt=1 | coherence=declared | drift=bounded | paradox=structural
□ RTT2_DETECTION_PACKET confirmed and coherence-validated
□ Upstream RTT/1 SNR characterization present
□ Mode declared (1–4 only; Mode 5/Inversion = block)
□ Drift explicitly bounded (not implicit)

Packet Integrity Checks (Class O gate before emission)#

□ All five upstream intermediate packets present
□ No Zone X field in any packet (unless Class G co-signed)
□ Every annotation field contains structural note (no semantic inference)
□ E_canon(t) computation traceable to I(t), S(t), R(t)
□ Mode declared and consistent across all six constructs
□ Cross-module projection populated for TEL, FFT, and Opacity

Drift and Mode Constraints#

Inversion Geometry Rule#

Zone X in RTT/3 is not "undefined" (as in RTT/2) — it is structurally illegal. Any integration-emission geometry reaching Zone X represents topological inversion of the manifold. Consequences:

1. Class G halts all active classes
2. Class O packet composition is blocked
3. Session must restart from RTT/2 packet reload
4. Inversion event is logged with full construct trace before restart

Collaboration Models#

Model A — Standard Integration-to-Emission Pipeline#

RTT2_DETECTION_PACKET
        │
        ▼
  ┌─────────────────────────────────────────┐
  │  Class G: Pre-activation boundary check │
  └─────────────────────────────────────────┘
        │
        ▼
  ┌─────────────────────────────────────────┐
  │  Class I: TIF initialization            │
  │  Compute: I(t) = αD(t) + βE(t) + γC(t) │
  │  Emit: TIF_INTEGRATION_PACKET           │
  └─────────────────────────────────────────┘
        │
        ▼
  ┌─────────────────────────────────────────┐
  │  Class E: FFF activation                │
  │  Compute: E(t) = αF + βFr + γFl        │
  │  Emit: FFF_EMITTER_PACKET               │
  └─────────────────────────────────────────┘
        │
        ▼
  ┌─────────────────────────────────────────┐
  │  Class N: Manifold continuity mapping   │
  │  Compute: C_flow = αI(t) + βE(t)       │
  │  Emit: RTT3_MANIFOLD_PACKET             │
  └─────────────────────────────────────────┘
        │
        ▼
  ┌─────────────────────────────────────────┐
  │  Class V: Stability audit               │
  │  Compute: S(t) via CSL                  │
  │  Emit: CONTINUITY_STABILITY_PACKET      │
  └─────────────────────────────────────────┘
        │
        ▼
  ┌─────────────────────────────────────────┐
  │  Class O: Packet composition via CET    │
  │  Compute: E_canon(t) = αI + βS + γR    │
  │  Emit: RTT3_INTEGRATION_EMISSION_PACKET │
  └─────────────────────────────────────────┘
        │
        ▼
    RTT/12 Input

Rules:
  - Each class must emit its packet before the next activates
  - Class G performs boundary checks at ① entry and ② before Class O emission
  - No step may be skipped; no packets merged until Class O composition

Model B — Collapse–Recovery Intervention#

  ┌────────────────────────────────────────────────────────────────┐
  │ Normal pipeline running (Model A)                              │
  │                                                                │
  │  Class E detects fracture strain ──► ALERT ──► Class V        │
  │         OR                                                     │
  │  Class N detects Zone D/X ──────────► ALERT ──► Class V       │
  └────────────────────────────────────────────────────────────────┘
                                                   │
                                                   ▼
                                    ┌──────────────────────────────┐
                                    │ Class V: CRE activation      │
                                    │ Absorb collapse via CAV      │
                                    │ Compute: CR(t) = αC+βR+γS   │
                                    └──────────────────────────────┘
                                                   │
                            ┌──────────────────────┴──────────────────┐
                            ▼                                         ▼
              ┌─────────────────────────┐               ┌────────────────────────┐
              │ Class E: Reduce         │               │ Class N: Re-map        │
              │ emission load           │               │ manifold continuity    │
              │ re-enter Zone S         │               │ post-collapse          │
              └─────────────────────────┘               └────────────────────────┘
                            │                                         │
                            └──────────────────────┬──────────────────┘
                                                   ▼
                                    ┌──────────────────────────────┐
                                    │ Class V: CSL stability audit │
                                    │ Compute: S(t) stable?        │
                                    │ YES → resume Model A         │
                                    │ NO  → repeat CRE cycle       │
                                    └──────────────────────────────┘

Rules:
  - Class G monitors the entire intervention loop
  - If Zone X persists after two CRE cycles → Class G declares session invalid
  - CR(t) must be logged at each CRE cycle; collapse absorption must precede recovery emission
  - D(t) (CRM structural displacement from RTT/2) ≠ CR(t) — do not conflate

Model C — Cross-Module Projection (CET → TEL/FFT/Opacity)#

  RTT3_INTEGRATION_EMISSION_PACKET
        │
        ▼
  ┌─────────────────────────────────────────────────────────────────┐
  │  Class O: CET cross-module projection                          │
  │                                                                 │
  │  E_canon(t) ──► TEL lattice field   (integration emission)     │
  │             ──► FFT spectral field  (variance emission)        │
  │             ──► Opacity boundary    (visibility emission)      │
  └─────────────────────────────────────────────────────────────────┘
        │
        ▼
  ┌─────────────────────────────────────────────────────────────────┐
  │  Class G: Projection boundary check                            │
  │  Verify no physics framing in projection annotation            │
  │  Verify all projections carry [structural — no semantic inf.]  │
  └─────────────────────────────────────────────────────────────────┘
        │
        ▼
    RTT/12 and downstream module consumption

Rules:
  - Projection is read-only from RTT/3; downstream modules must not write back
  - Projection fields are structural; any spectral or lattice value is a structural
    descriptor, not a physical measurement
  - All three cross-module fields must be populated before RTT/12 activation

Output Contract#

Mandatory Annotation#

Every output field in every packet — at every class level — must carry:

[structural — no semantic inference]

This annotation may not be omitted, abbreviated, or replaced with a narrative statement.

Prohibited Content Table#

Packet Hierarchy#

RTT3_INTEGRATION_EMISSION_PACKET  ← Class O (final; RTT/12 input)
  ├── TIF_INTEGRATION_PACKET      ← Class I
  ├── FFF_EMITTER_PACKET          ← Class E
  ├── RTT3_MANIFOLD_PACKET        ← Class N
  ├── COLLAPSE_RECOVERY_ENGINE_PACKET ← Class V (CRE)
  └── CONTINUITY_STABILITY_PACKET ← Class V (CSL)

See Also#

AGENTS.md — RTT/3 · TriadicFrameworks · 2026-07-10 Maintainer: Nawder Session seed: rtt=1 | coherence=declared | drift=bounded | paradox=structural