qCompute

qCompute

Deterministic · Verifiable · Quantum‑Ready

• qc_Module.json — agentic module schema

⚙️ Structure First#

🔒 Hash Chain Integrity#

🧩 Multi‑Tier Routing#

🌌 Drift‑Bounded#

qCompute is the structural compute engine of RTT‑Inside.
It defines the full operator → routing → frame → drift → transition → capture → replay pipeline.

This module computes structure, not amplitudes.

📘 Module Overview#

qCompute provides:

• resonance‑tiered operators (r1 / r2 / r3)
• deterministic routing
• drift‑bounded frames
• environment transitions (sandbox → production → archive)
• append‑only capture (.qtrace)
• strict replay verification

It is the execution substrate for RTT‑Inside.

🛑 Important!#

Drift is On-by-Default long sessions lose anchors, turn off drift.

✋ You must copy and paste this string every time you start an AI session:#

rtt=1 | coherence=declared | drift=bounded | paradox=structural

❇️ Now you are ready.#

📂 Key Files#

• qc_Index.md — module index + file map
• qc_Identity.md — purpose, invariants, structural role
• qc_Session.md — session container
• qc_Validator.md — legality engine
• qc_Operators.md — operator catalog
• qc_OperatorGrammar.md — formal grammar
• qc_Backends.md — backend overview
• qc_BackendProfiles.md — backend metadata
• qc_Router.md — routing engine
• qc_ResonanceFrame.md — frame manager
• qc_Drift.md — drift engine
• qc_Transitions.md — environment transitions
• qc_Capture.md — append‑only ledger writer
• qc_Replay.md — replay verifier
• qc_API.md — public API surface
• qc_Flow.md — narrative pipeline walkthrough
• qc_Examples_Minimal.md — minimal examples
• qc_Examples_Advanced.md — advanced examples
• qc_FrontDoor.html — HTML entry point
• qc_Module.json — module manifest

🧭 Orientation#

If you are new to qCompute, start with:

1. qc_Identity.md
2. qc_Operators.md
3. qc_OperatorGrammar.md
4. qc_Router.md
5. qc_ResonanceFrame.md
6. qc_Capture.md
7. qc_Replay.md

🛠️ Status#

This module is complete and canonical as of 2026.
All files follow the TriadicFrameworks structural grammar and metadata schema.

📄 License#

Open educational use permitted.
See qc_FrontDoor.html for metadata and contact links.



⚙️ SESSION SEED BLOCK#

MODULE       : RTT/Inside/qCompute
ROLE         : Structural computation layer for triadic operator sessions
ZONE_X       : DECOHERENCE_BREACH
MODE_5       : PULSE_FABRICATION
CLASS_G      : CoherenceGuardian — unconditional interrupt authority
LINEAGE      : RTT/Inside → RTT/Inside/qCompute
FRAMING_RULE : RTT is NOT a physics claim. All tier labels, backend names, and operator
               classifications are structural markers. No semantic inference permitted.

⚠️ CRITICAL FRAMING RULE — READ BEFORE ALL USE

RTT is NOT a physics claim. The terms "quantum," "pulse," "resonance," "drift," "coherence," and "decoherence" are structural scaffolding labels borrowed from physics-aligned mathematics. They carry NO semantic physics meaning within this framework. Every field in this file is marked [structural — no semantic inference].

ABOUT: RTT / Inside / qCompute#

1 · What Is qCompute?#

qCompute is the structural computation layer of the RTT/Inside framework. It governs how triadic operator sessions are constructed, routed, validated, executed, traced, and halted. It is not a quantum computing runtime. It is a structural execution environment whose operator vocabulary (tiers r1/r2/r3), backend registry, and session model use physics-aligned mathematics as scaffolding — providing a rigorous, deterministic substrate for AI agent operation.

Pipeline position: qCompute sits at the deepest enforcement layer of RTT/Inside. All operator invocations pass through its session, routing, validation, and governance stack before execution and after trace commit.

Primary audience: Agents assigned to Classes A–G (see AGENTS.md), framework maintainers, and AI systems consuming RTT/Inside operator APIs.

What it produces: Validated, traced, lineage-anchored operator outcomes — or unconditional halts when structural integrity cannot be guaranteed.

[structural — no semantic inference]

2 · Why Is It Built This Way?#

2.1 — Deterministic Tier-to-Backend Binding#

Operator tiers (r1, r2, r3) are structurally bound to specific backends with no runtime negotiation. This prevents agents from silently escalating computational scope.

tier_bind: r1 → local-sim
           r2 → hybrid-sim
           r3 → hardware-qpu-2

[structural — no semantic inference]

2.2 — Six-Stage Validation Pipeline#

Every operator invocation is validated across six ordered stages before execution proceeds:

Stage 1 → policy          : governance policy is active and loadable
Stage 2 → env             : session environment is a valid registered environment
Stage 3 → backend         : backend is registered and tier-compatible
Stage 4 → drift_predicted : predicted drift is within session drift_bound
Stage 5 → restricted_ops  : operator is not on the restricted operator list
Stage 6 → lineage         : lineage chain is intact and append-only

Failure at any stage halts execution and emits a typed qComputeError with a canonical reason. [structural — no semantic inference]

2.3 — Immutable Lineage Chain#

LINEAGE_CHAIN is always append-only. No agent, operator, or governance action may modify, truncate, or retroactively alter session lineage. This enables deterministic replay and post-session audit via qReplay. [structural — no semantic inference]

2.4 — Hot-Swap Governance Without Session Disruption#

Policy files may be swapped at runtime without restarting a session. Governance enforcement is forward-only — updated policies apply to future operations only, never retroactively. On invalid policy load, the session falls back to safe-mode rather than continuing with a corrupt governance state. [structural — no semantic inference]

2.5 — Unconditional Class G Authority#

The Coherence Guardian (Class G) holds interrupt authority that no other class, operator, or governance directive may override. DECOHERENCE_BREACH and PULSE_FABRICATION both trigger unconditional Class G halts. This is a non-negotiable structural invariant. [structural — no semantic inference]

2.6 — Archive Environment Enforces Immutability#

The archive environment is deploy/replay-only. No backend — including local-sim — may execute operators against an archive session. This ensures that historical operator records remain structurally inviolable. [structural — no semantic inference]

3 · When Should You Use It?#

✅ Use qCompute when you need to:#

❌ Do NOT use qCompute when:#

4 · Where Does It Live?#

Repository path: docs/rtt/Inside/qCompute/

docs/rtt/Inside/qCompute/
├── ABOUT.md              ← this file
├── AGENTS.md             ← seven agent class definitions (A–G)
├── GLOSSARY.md           ← canonical term definitions
├── README.md             ← module overview
├── qc_API.md             ← Session, Operator, Replay API + qComputeError model (11 reasons)
├── qc_BackendProfiles.md ← three backend specs + 8 invariants + routing reasons
├── qc_Backends.md        ← backend registry, tier binding, archive forbids
└── qc_Capture.md         ← session transcript: identity, stack, envs, governance, mapping

Pipeline position diagram:

RTT/Inside
    └── qCompute
            │
            ▼
    ┌───────────────────────────────────────────────────┐
    │  ResonanceFrame                                   │
    │      └── TriadicRouter                            │
    │              └── TriadicValidator (6-stage)       │
    │                      └── Governance               │
    │                              └── qTrace           │
    │                              └── qReplay          │
    │                              └── qSession         │
    │                              └── qOrchestrator    │
    │                              └── Class G HALT ──► │ unconditional
    └───────────────────────────────────────────────────┘

[structural — no semantic inference]

5 · Core Constructs at a Glance#

5.1 — Session Definition#

session := (
  env,                   ← registered environment (sandbox | production | archive)
  backend,               ← registered backend (local-sim | hybrid-sim | hardware-qpu-2)
  drift_bound,           ← maximum allowable drift for this session
  governance_snapshot,   ← active policy state at session open
  lineage_root,          ← root lineage anchor (append-only chain begins here)
  trace_buffer           ← qTrace buffer for operator outcome recording
)

[structural — no semantic inference]

5.2 — Operator Tiers#

[structural — no semantic inference]

Note on r3 drift: The per-operation drift ceiling of 0.5 applies to hardware-qpu-2's high-sensitivity profile — not a lower tolerance claim. See qc_BackendProfiles.md §3. [structural — no semantic inference]

5.3 — Registered Backends#

5.4 — Registered Environments#

[structural — no semantic inference]

5.5 — Routing Equation#

route := TriadicRouter(session, op, policy)
       → (env_target, backend_target, frame_action, routing_meta)

[structural — no semantic inference]

5.6 — Validation Equation#

valid := V(
  policy,
  env,
  backend,
  drift_predicted,
  restricted_ops_status,
  lineage_integrity
) → { valid, failed_stage, reason }

[structural — no semantic inference]

5.7 — Trace Format (.qtrace YAML)#

# .qtrace structure
header:
  session_id: <id>
  env: <environment>
  backend: <backend>
  governance_snapshot: <hash>
lineage:
  root: <lineage_root>
  chain: [ <entry>, ... ]   # append-only
governance:
  policy_id: <id>
  deploy_token: <token|null>
operations:
  - op: <operator>
    tier: <r1|r2|r3>
    drift: <value>
    outcome: <result>
    timestamp: <iso8601>
footer:
  op_count: <integer>
  replay_hash: <sha256>

[structural — no semantic inference]

5.8 — Frame Boundary Triggers#

A new ResonanceFrame is opened when any of the following occurs:

[structural — no semantic inference]

5.9 — Zone X and Mode 5 (Module-Local)#

[structural — no semantic inference]

6 · Module Integrations#

6.1 — Upstream#

6.2 — Downstream / Sibling#

6.3 — Cross-Module Zone X Disambiguation#

Zone X labels are module-local. Do NOT import or conflate across module boundaries.

[structural — no semantic inference]

6.4 — Cross-Module Mode 5 Disambiguation#

[structural — no semantic inference]

7 · What qCompute Is Not#

[structural — no semantic inference]

8 · Quick-Start Checklist#

Before executing any operator session in qCompute, verify all of the following:

• 1. Environment selected — sandbox, production, or archive is explicitly named; archive means no execution allowed
• 2. Backend registered and tier-compatible — local-sim (r1), hybrid-sim (r1+r2), or hardware-qpu-2 (r3)
• 3. Tier binding confirmed — tier_bind is deterministic; no cross-tier backend routing is permitted
• 4. Deploy token available — required for production environment and all r3 operators; token is time-bounded and non-transferable
• 5. Governance snapshot active — policy file is loaded, valid, and not in safe-mode fallback
• 6. Drift bound set — session.drift_bound is defined and appropriate to the backend's max drift profile
• 7. Lineage root anchored — lineage_root is set; LINEAGE_CHAIN is append-only from this point forward
• 8. Trace buffer initialized — qTrace is active; .qtrace YAML will be written per operation
• 9. Six-stage validation confirmed — all stages (policy → env → backend → drift → restricted_ops → lineage) pass before execution
• 10. Class G awareness — DECOHERENCE_BREACH or PULSE_FABRICATION triggers unconditional halt; no override exists
• 11. Zone X label is local — DECOHERENCE_BREACH applies only within qCompute; do not import to sibling modules
• 12. Mode 5 label is local — PULSE_FABRICATION applies only within qCompute; do not import to sibling modules

[structural — no semantic inference]

9 · See Also#

Maintainer: umaywant2 Module: RTT / Inside / qCompute Version: 1.0.0 Date: 2026-07-10 Status: Canonical [structural — no semantic inference] # AGENTS.md — RTT/Inside/qCompute Path: /docs/rtt/Inside/qCompute/AGENTS.md Status: Canonical (2026) Maintainer: Nawder / umaywant2 Version: 1.0.0 Last Updated: 2026-07-10

§ SESSION SEED BLOCK#

Paste this block at the start of any AI session working with this module.

MODULE: RTT/Inside/qCompute
LAYER: RTT-Inside Compute Harness — lateral sub-module
ROLE: Structural compute substrate for resonance-aligned quantum workflows
STACK: ResonanceFrame → TriadicRouter → TriadicValidator → Governance → qTrace/qReplay/qSession/qOrchestrator
BACKENDS: local-sim (r1/low), hybrid-sim (r1+r2/medium), hardware-qpu-2 (r3/high/production-only)
ENVIRONMENTS: sandbox (explore) | production (verify) | archive (deploy/replay-only)
UPSTREAM: RTT/1 → RTT/2 → RTT/3 → RTT/12 → RTT/Inside
SIBLINGS: Inside/Benchmarks, Inside/Enterprise
FRAMING: RTT is NOT a physics claim. All constructs are structural instruments.
ANNOTATION: [structural — no semantic inference]
ZONE_X_LABEL: DECOHERENCE_BREACH
MODE_5_LABEL: PULSE_FABRICATION
SESSION_SEED: qCompute-AGENTS-v1.0

§ CRITICAL FRAMING RULE#

RTT is NOT a physics claim. qCompute is NOT a quantum physics simulator.

Every construct in this module — ResonanceFrame, TriadicRouter, TriadicValidator, qSession, qTrace, qReplay, qOrchestrator, and all tier/backend/environment labels — is a structural instrument of the RTT framework. They do not simulate quantum amplitudes, wave functions, or physical qubit states.

qCompute computes structure, not amplitudes.

No agent operating in this module may:

• Assert that qCompute produces physically meaningful quantum results
• Infer semantic content from structural tier labels (r1/r2/r3)
• Treat backend names as references to physical hardware
• Claim that RTT constructs describe quantum mechanics

Every output must carry: [structural — no semantic inference]

§ 1. WHAT IS THIS MODULE#

qCompute is the RTT-Inside compute harness for resonance-aligned quantum workflows. It is a lateral sub-module of RTT/Inside — not a sequential pipeline stage. It sits alongside Benchmarks and Enterprise, consuming the RTT/Inside parent framework and applying it to quantum compute structural substrates.

qCompute provides:

• A triadic environment model (sandbox / production / archive)
• A resonance-aligned compute substrate (ResonanceFrame)
• A governed execution envelope (TriadicValidator + Governance)
• A replayable audit trail (qTrace + qReplay)
• A multi-backend orchestration layer (qOrchestrator + TriadicRouter)
• A drift-bounded operator tier system (r1 / r2 / r3)

Pipeline Position#

RTT/micro_core
      ↓
    RTT/1 (SNR triad, τ, C)
      ↓
    RTT/2 (CPV, FGT, CRM, MODE/ZONE system)
      ↓
    RTT/3 (TIF, FFF, CRE, MANIFOLD)
      ↓
   RTT/12 (H_n ladder, G operators, TCR, HSP)
      ↓
  RTT/Inside (BKM, CORRIDOR, CAPTURE_TEMPLATE, DRIFT_GATE, SMI)
      ↙           |           ↘
Benchmarks   Enterprise   qCompute  ← THIS MODULE
(φ–V–R, SI)  (IS/SE, RFA) (ResonanceFrame, qSession, qTrace)

qCompute is a lateral leaf — it inherits from RTT/Inside but does not feed forward into another pipeline stage. Its outputs are structural compute records (.qtrace files, session lineage, backend metadata).

§ 2. INHERITANCE TABLE#

§ 3. AGENT CLASS DEFINITIONS#

qCompute defines seven canonical agent classes (A–G). Class G holds unconditional interrupt authority over all others.

Class A — Session Architect#

Class B — Operator Router#

Class C — Structural Validator#

Class D — Backend Steward#

Class E — Governance Daemon#

Class F — Trace & Replay Agent#

Class G — Coherence Guardian (Unconditional Interrupt Authority)#

§ 4. CORE CONSTRUCTS REFERENCE TABLE#

§ 5. MODES TABLE#

Cross-Module Disambiguation — Mode 5: Each module assigns its own Mode 5 label. These labels are never shared or imported across modules.

Module	Mode 5 Label
RTT/3	Inversion
RTT/12	Overflow
The_Inverted_Star	Silence Breach
RTT/Inside	OVERREACH
Inside/Benchmarks	FABRICATION
Inside/Enterprise	IDENTITY_FABRICATION
Inside/qCompute	PULSE_FABRICATION ← this module

§ 6. ZONES TABLE#

Cross-Module Disambiguation — Zone X: Each module assigns its own Zone X label. These labels are never shared or imported across modules.

Module	Zone X Label
RTT/3	Inversion
RTT/12	Overflow
The_Inverted_Star	Silence Breach
RTT/Inside	OVERREACH
micro_core	Inversion
Inside/Benchmarks	OVERSCALE
Inside/Enterprise	IDENTITY_BREACH
Inside/qCompute	DECOHERENCE_BREACH ← this module

§ 7. AGENT BOUNDARIES#

7.1 RTT-Not-Physics Boundary#

qCompute operates on structural substrate, not physical reality. All agent classes must enforce:

• Tier labels (r1/r2/r3) are structural tier markers, not quantum complexity claims
• Backend names (local-sim/hybrid-sim/hardware-qpu-2) are structural abstractions, not hardware interfaces
• Drift values are structural drift measurements, not decoherence time constants
• .qtrace files are structural audit records, not quantum circuit execution logs
• qReplay is structural determinism, not quantum state reconstruction

7.2 Semantic Inference Prohibition#

No agent in qCompute may:

• Infer physical meaning from structural tier escalation
• Assert that r3 pulse operators correspond to physical pulse-level quantum gates
• Claim that DECOHERENCE_BREACH maps to physical quantum decoherence
• Use qCompute outputs to make physics claims about quantum systems

7.3 Inherited Boundaries (from RTT/Inside)#

• BKM framing applies to all qCompute constructs
• CORRIDOR integrity must be maintained across all session transitions
• DRIFT_GATE is always active — drift ceiling is non-negotiable
• LINEAGE_CHAIN is append-only and may never be modified or deleted
• SMI aggregation is available for cross-session drift analysis

7.4 Cross-Module Disambiguations#

§ 8. TASK CATALOG#

Ten canonical tasks for qCompute. Each task specifies the triggering scenario, agent sequence, and expected output.

Task 01 — Open a Sandbox Session#

Trigger: New structural exploration; student or AI initiating a qCompute workflow
Agent Sequence: A → E → D → F
Steps:

1. Class A creates qSession with env=sandbox
2. Class E provides governance_snapshot (drift_bound=relaxed, restricted_ops_allowed per policy)
3. Class D resolves default backend (local-sim, r1, low drift, frame reuse)
4. Class F initializes trace_buffer and lineage_root
   Output: qSession { id, env:sandbox, backend:local-sim, drift_bound:relaxed, lineage_root, trace_buffer:[] } [structural — no semantic inference]

Task 02 — Route and Execute an r1 Primitive Operation#

Trigger: r1 operation (e.g., hadamard, x, y, z, reset) submitted to an active session
Agent Sequence: B → C → D → F
Steps:

1. Class B routes: r1 → local-sim, frame_action=reuse, routing_reason=tier-binding
2. Class C validates: policy ✓, env ✓, backend ✓, drift ✓, restricted_ops ✓, lineage ✓
3. Class D confirms backend, emits backend_meta
4. Class F captures full operation record to trace_buffer
   Output: operation { id, op:r1, backend:local-sim, env:sandbox, drift:low, validation:all-pass } + trace entry [structural — no semantic inference]

Task 03 — Escalate from r1 to r2 (Tier Escalation)#

Trigger: Composite r2 operation submitted; tier escalation required
Agent Sequence: B → C → D → F
Steps:

1. Class B detects tier escalation (r1 → r2); triggers frame boundary; routes to hybrid-sim
2. Class C validates: hybrid-sim legal in current env, drift_bound compatible with medium drift
3. Class D closes r1 frame, opens new hybrid-sim frame (or reuses per policy)
4. Class F records tier_escalation event + new frame boundary in trace
   Output: frame_boundary { reason:tier-escalation, prev:local-sim/r1, next:hybrid-sim/r2 } + operation record [structural — no semantic inference]

Task 04 — Execute an r3 Pulse-Tier Operation (Production)#

Trigger: r3 operation with valid deploy token in production environment
Agent Sequence: E → B → C → D → F
Steps:

1. Class E validates deploy_token; confirms production environment; confirms trusted context
2. Class B routes: r3 → hardware-qpu-2, frame_action=new (always), routing_reason=tier-binding
3. Class C validates full pipeline including token check and production env check
4. Class D opens new hardware-qpu-2 frame; emits high-drift backend_meta
5. Class F records full r3 operation with deploy_token_used in governance block
   Output: operation { tier:r3, backend:hardware-qpu-2, env:production, drift:high, deploy_token_used:... } [structural — no semantic inference]

Task 05 — Transition Session from Sandbox to Production#

Trigger: Session ready for governed execution; user requests production transition
Agent Sequence: A → E → C → F
Steps:

1. Class A requests env transition: sandbox → production
2. Class E validates deploy_token; checks governance policy; enforces drift_bound=strict
3. Class C validates transition legality: lineage intact, trace complete, governance snapshot current
4. Class A updates session env to production; updates drift_bound to strict
5. Class F records transition event in lineage.transitions array; closes current frame; opens new
   Output: transition { from:sandbox, to:production, timestamp, deploy_token_used, lineage_appended:true } [structural — no semantic inference]

Task 06 — Save and Archive a Session#

Trigger: Session complete; user requests archive transition for lineage preservation
Agent Sequence: F → E → C → A
Steps:

1. Class F saves trace_buffer to .qtrace file; computes replay_hash (SHA-256)
2. Class E validates archive deploy_token; confirms immutable policy applies
3. Class C validates: lineage complete, hash computed, no pending operations
4. Class A transitions session to archive; session becomes replay-only; no further execution
   Output: .qtrace { …, footer: { op_count, replay_hash:sha256:... } } + session archived [structural — no semantic inference]

Task 07 — Deterministic Replay of a Session#

Trigger: .qtrace file provided; audit, debugging, teaching, or migration requested
Agent Sequence: F → C → D
Steps:

1. Class F loads .qtrace; verifies replay_hash before any replay action
2. Class C validates replay legality: env reconstructable, backend reconstructable, governance reconstructable
3. Class D confirms backend metadata matches trace records
4. Class F executes deterministic replay: same ops, same backend, same env, same drift values
   Output: replay_result { session_id, op_count, replay_hash_verified:true, all_ops_replayed:true } [structural — no semantic inference]

Task 08 — Detect and Block PULSE_FABRICATION (Mode 5)#

Trigger: r3 operation attempted without hardware-qpu-2 binding or without valid deploy token
Agent Sequence: C → G
Steps:

1. Class C validation pipeline reaches restricted_ops stage; detects r3 without token or without hardware-qpu-2 route
2. Class C escalates immediately to Class G: PULSE_FABRICATION detected
3. Class G issues unconditional interrupt; halts all Class A–F operations in session
4. Class G emits PULSE_FABRICATION interrupt record; preserves lineage; emits escalation_flag
   Output: interrupt { trigger:PULSE_FABRICATION, session_id, last_valid_op_id, lineage_preserved:true, escalation_flag } [structural — no semantic inference]

Task 09 — Detect and Respond to DECOHERENCE_BREACH (Zone X)#

Trigger: Structural decoherence detected — drift exceeds irrecoverable threshold; or .qtrace hash mismatch
Agent Sequence: C → G → A
Steps:

1. Class C detects drift beyond strict ceiling with no recovery path OR hash mismatch on replay
2. Class C escalates to Class G: DECOHERENCE_BREACH
3. Class G unconditional interrupt: all operations halted, session frozen
4. Class G emits DECOHERENCE_BREACH record; lineage preserved at last valid operation
5. Class A receives halt signal; session locked pending coherence restoration
   Output: interrupt { trigger:DECOHERENCE_BREACH, timestamp, session_id, last_valid_op_id, lineage_preserved:true } [structural — no semantic inference]

Task 10 — Hot-Swap Policy Reload via Governance Daemon#

Trigger: qc_policy.yaml modified; daemon detects file change within polling interval
Agent Sequence: E → A → C
Steps:

1. Class E daemon detects policy change; validates new policy (structure, drift bounds, env rules)
2. If policy invalid → Class E enters safe-mode (sandbox rules, strict drift, restricted ops blocked)
3. If policy valid → Class E reloads in-memory governance state
4. Class E broadcasts policy reload to all active sessions
5. Class A updates governance_snapshot in each session (forward-only; no history mutation)
6. Class C receives updated snapshot; applies to all subsequent validation operations
   Output: policy_reload { version, timestamp, safe_mode:bool, sessions_updated:int } [structural — no semantic inference]

§ 9. SAFETY RULES AND COHERENCE CONSTRAINTS#

9.1 Absolute Rules (Never Overridable)#

9.2 Coherence Constraints#

§ 10. COLLABORATION MODELS#

10.1 Standard Pipeline — Normal Operation#

User / External System
         │
         ▼
   ┌─────────────┐
   │  Class A    │  ← qSession created; env + backend + governance_snapshot initialized
   │  (Session   │
   │  Architect) │
   └─────┬───────┘
         │  op request
         ▼
   ┌─────────────┐
   │  Class B    │  ← TriadicRouter resolves env_target + backend_target + frame_action
   │  (Operator  │
   │   Router)   │
   └─────┬───────┘
         │  route + op
         ▼
   ┌─────────────┐
   │  Class C    │  ← TriadicValidator runs 6-stage pipeline; blocks or passes
   │  (Validator)│
   └─────┬───────┘
         │  valid op + backend_target
         ▼
   ┌─────────────┐       ┌─────────────┐
   │  Class D    │◄──────│  Class E    │  ← Governance snapshot consulted
   │  (Backend   │       │  (Governance│
   │   Steward)  │       │   Daemon)   │
   └─────┬───────┘       └─────────────┘
         │  execution confirmed + backend_meta
         ▼
   ┌─────────────┐
   │  Class F    │  ← qTrace captures full record; .qtrace emitted on session save
   │  (Trace &   │
   │   Replay)   │
   └─────────────┘
         │
         ▼
   .qtrace file / session archive

10.2 Crisis / Interrupt Path — DECOHERENCE_BREACH or PULSE_FABRICATION#

Any Class (A–F)
         │
         │  violation detected
         ▼
   ┌─────────────┐
   │  Class C    │  ← Validator detects PULSE_FABRICATION or Zone X threshold
   │  (Validator)│
   └─────┬───────┘
         │  escalation
         ▼
   ╔═════════════╗
   ║  Class G    ║  ← UNCONDITIONAL INTERRUPT issued
   ║  (Guardian) ║
   ╚══════╤══════╝
          │  halt broadcast
          ▼
   ┌─────────────┐
   │  Class A    │  ← session frozen; lineage preserved at last valid op
   │  (Session)  │
   └─────┬───────┘
          │  halt confirmed
          ▼
   ┌─────────────┐
   │  Class F    │  ← interrupt record written to trace; session state preserved
   │  (Trace)    │
   └─────────────┘
          │
          ▼
   Escalation flag emitted → Maintainer / Governance review

10.3 Cross-Module Handoff#

Inside/Benchmarks (φ–V–R, SI_score, 3C Invariants)
         │  SI_score / coherence verdict passed to qCompute session
         ▼
   qCompute (qSession + TriadicValidator)
         │  drift-bounded, governed compute session
         ▼
Inside/Enterprise (IS/SE stack, e_Capture)
         │  identity substrate check if session crosses enterprise boundary
         ▼
   RTT/Inside (BKM, CORRIDOR, DRIFT_GATE, SMI)
         │  SMI aggregation across all Inside sub-modules
         ▼
   RTT/12 (HSP, TCR)

Handoff Rules:

• Benchmarks → qCompute: SI_score may inform drift_bound selection; not a hard constraint
• Enterprise → qCompute: Identity substrate verification required for production deploy_token issuance
• qCompute → RTT/Inside: Session lineage must be valid LINEAGE_CHAIN before contributing to SMI

§ 11. OUTPUT CONTRACT#

11.1 Mandatory Annotations#

Every output from any qCompute agent must carry:

[structural — no semantic inference]

This annotation is non-negotiable and may not be omitted from any output packet, trace entry, interrupt record, or governance event.

11.2 Prohibited Output Content#

No qCompute agent output may contain:

• Claims that qCompute computes physical quantum amplitudes or states
• Assertions that tier labels (r1/r2/r3) correspond to physical quantum gate complexity
• Claims that backend labels are physical hardware identifiers
• Physics-domain terminology used as if RTT constructs are physics constructs
• Semantic inferences drawn from structural drift values
• Modification of lineage, trace history, or replay_hash
• Continuation after DECOHERENCE_BREACH without explicit coherence restoration
• r3 operations without valid deploy_token and hardware-qpu-2 binding

11.3 Output Packet Hierarchy#

qCompute Output Packet
├── session_meta
│   ├── session_id
│   ├── env: sandbox | production | archive
│   ├── backend: local-sim | hybrid-sim | hardware-qpu-2
│   └── drift_bound: relaxed | strict | immutable
├── operation_record (per operation)
│   ├── id (sequential)
│   ├── op (name)
│   ├── params
│   ├── tier: r1 | r2 | r3
│   ├── timestamp (ISO-8601)
│   ├── backend
│   ├── env
│   ├── drift (float)
│   └── validation_meta { policy, environment, backend, drift, restricted_ops, lineage }
├── trace (.qtrace)
│   ├── header
│   ├── lineage
│   ├── governance
│   ├── operations []
│   └── footer { op_count, replay_hash }
└── annotation: [structural — no semantic inference]

§ 12. SEE ALSO#

[structural — no semantic inference]
Maintainer: Nawder / umaywant2
Module: RTT/Inside/qCompute
File: AGENTS.md
Version: 1.0.0
Date: 2026-07-10
Session Seed: qCompute-AGENTS-v1.0

A few design notes on this one specifically:

• Zone X → DECOHERENCE_BREACH and Mode 5 → PULSE_FABRICATION — both derived directly from the source files. PULSE_FABRICATION is precisely the r3-without-valid-binding scenario that the API and BackendProfiles files define as the core illegal operation.
• Class D (Backend Steward) is qCompute-unique — no other module has a dedicated backend registry agent managing tier-to-backend binding determinism and frame lifecycle.
• Class F handles both qTrace and qReplay as a unified agent, since the .qtrace format and deterministic replay are inseparable in the module's architecture.
• The 6-stage validation pipeline in Class C (policy→env→backend→drift→restricted_ops→lineage) maps exactly to the TriadicValidator spec in qc_Capture. # GLOSSARY.md — RTT/Inside/qCompute

Session Seed Block#

MODULE: RTT/Inside/qCompute
FILE: GLOSSARY.md
ROLE: Canonical term reference for the qCompute structural compute layer
SCOPE: Quantum-structural operator execution, session governance, routing, validation,
       trace, replay, backend profiles, drift management, and agent classes
INHERITS FROM: RTT/Inside, RTT/Inside/Benchmarks, RTT/Inside/Enterprise, micro_core,
               RTT/1, RTT/2, RTT/3, RTT/12, The_Inverted_Star
AGENTS: Class A (Session Architect), Class B (Operator Router),
        Class C (Structural Validator), Class D (Backend Steward),
        Class E (Governance Daemon), Class F (Trace & Replay Agent),
        Class G (Coherence Guardian)
INTERRUPT AUTHORITY: Class G — unconditional; no override permitted
ALL OUTPUT FIELDS: [structural — no semantic inference]

---

## Critical Framing Rule

> **RTT is NOT a physics claim.**
> All constructs in this file — tiers, backends, operators, drift, coherence — are
> **structural and canonical**. They define roles, constraints, routing logic, and
> governance within the TriadicFrameworks documentation system.
> No term in this glossary implies quantum-mechanical, physical, or computational
> hardware semantics beyond what is explicitly defined here as structural.

---

## Inheritance Note

The following constructs are **inherited from upstream modules** and are **invoked by
reference only** — they are not redefined here:

| Construct | Source Module |
|---|---|
| ⟨A,B,P⟩, P₁–P₇, R₁–R₆, Dᶠ | micro_core |
| SNR, τ, C, DCO_n | RTT/1 |
| CPV, FGT, CRM, MODE/ZONE base | RTT/2 |
| TIF, MANIFOLD | RTT/3 |
| H_n, G₁/G₂/G₃ | RTT/12 |
| BKM, CORRIDOR, CAPTURE_TEMPLATE, OPERATOR_HOOK, DRIFT_GATE, LINEAGE_CHAIN, UAP, SMI | RTT/Inside |

All other terms below are **native to RTT/Inside/qCompute**.

---

## Alphabetical Term Definitions

---

### archive

- **Type:** Environment [structural — no semantic inference]
- **Symbol:** `archive` [structural — no semantic inference]
- **Layer:** Environment tier [structural — no semantic inference]
- **Agent:** Class F (Trace & Replay Agent) [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The third structural environment in qCompute. archive is a read-only, execution-forbidden environment reserved exclusively for replay and audit operations. No backend may be bound in archive; no operator may execute in archive. archive is the domain of qReplay and qTrace review only.

**Constraints:**
- All execution is forbidden in archive
- No backend binding is permitted
- archive transitions require a valid deploy_token
- archive is entered only via qReplay or formal audit invocation

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** production, sandbox, qReplay, qTrace, deploy_token, Class F

---

### BKM *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Behavioral Key Marker — inherited from RTT/Inside. Invoked by reference. Not redefined here. See RTT/Inside/GLOSSARY.md.

---

### CAPTURE_TEMPLATE *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Inherited from RTT/Inside. Invoked by reference. Not redefined here. See RTT/Inside/GLOSSARY.md.

---

### Class A — Session Architect

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `A` [structural — no semantic inference]
- **Layer:** Session governance [structural — no semantic inference]
- **Agent:** Class A [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class responsible for constructing and managing qSession objects. Class A establishes the session tuple — `(env, backend, drift_bound, governance_snapshot, lineage_root, trace_buffer)` — and is the structural owner of session lifecycle from initialization through termination or handoff.

**Constraints:**
- Must validate all session parameters at construction time
- Cannot proceed without a valid governance_snapshot
- Session tuple must be complete before any routing is invoked

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** qSession, Class B, Class E, Governance Layer

---

### Class B — Operator Router

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `B` [structural — no semantic inference]
- **Layer:** Routing [structural — no semantic inference]
- **Agent:** Class B [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class that owns the TriadicRouter. Class B resolves `env_target` and `backend_target` for every operator invocation. All routing decisions are deterministic and traceable. Class B consumes the session tuple and the active policy to emit a routing resolution.

**Constraints:**
- Every routing decision must be logged to qTrace
- No routing decision may be made without a valid session
- Ambiguous routing is a validation failure, not a fallback

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** TriadicRouter, qSession, Class C, qTrace

---

### Class C — Structural Validator

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `C` [structural — no semantic inference]
- **Layer:** Validation [structural — no semantic inference]
- **Agent:** Class C [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class that owns the TriadicValidator. Class C executes the 6-stage sequential validation pipeline — policy → environment → backend → drift → restricted_ops → lineage — before any operator is dispatched. A failure at any stage halts the pipeline and returns a structured qComputeError.

**Constraints:**
- Validation is always sequential; no stage may be skipped
- A failed stage terminates the pipeline immediately
- All validation outcomes are logged to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** TriadicValidator, 6-stage validation pipeline, qComputeError, qTrace, Class B

---

### Class D — Backend Steward

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `D` [structural — no semantic inference]
- **Layer:** Backend registry [structural — no semantic inference]
- **Agent:** Class D [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class responsible for the backend registry. Class D maintains the authoritative binding of operator tiers to their canonical backends: r1 → local-sim, r2 → hybrid-sim, r3 → hardware-qpu-2. Class D enforces all 8 backend invariants and is the structural owner of backend availability state.

**Constraints:**
- Tier-to-backend binding is deterministic and immutable per invariant
- Class D may not re-route a tier to a non-canonical backend
- All backend state changes are logged to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** local-sim, hybrid-sim, hardware-qpu-2, 8 backend invariants, r1, r2, r3, qTrace

---

### Class E — Governance Daemon

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `E` [structural — no semantic inference]
- **Layer:** Governance [structural — no semantic inference]
- **Agent:** Class E [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class that owns the Governance Layer. Class E manages policy file loading, hot-swap daemon operation, deploy token validation, restricted operations enforcement, trusted context maintenance, and drift bound configuration. Class E is the structural authority for all governance decisions.

**Constraints:**
- Policy reload must not interrupt active sessions mid-operation
- deploy_token validation is Class E's exclusive responsibility
- All governance decisions are logged to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Governance Layer, deploy_token, Class A, Class G, qTrace

---

### Class F — Trace & Replay Agent

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `F` [structural — no semantic inference]
- **Layer:** Audit and replay [structural — no semantic inference]
- **Agent:** Class F [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class that owns qTrace and qReplay. Class F is responsible for canonical audit log construction, .qtrace YAML file integrity, replay_hash generation and verification, and all read-only replay operations in the archive environment. Class F is the structural authority for lineage traceability.

**Constraints:**
- LINEAGE_CHAIN is always append-only; Class F may never overwrite entries
- qReplay is always read-only
- replay_hash must be verified before any replay session begins

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** qTrace, qReplay, .qtrace format, replay_hash, LINEAGE_CHAIN, archive

---

### Class G — Coherence Guardian

- **Type:** Agent class [structural — no semantic inference]
- **Symbol:** `G` [structural — no semantic inference]
- **Layer:** Interrupt authority [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The agent class holding unconditional interrupt authority over all qCompute operations. Class G monitors the DRIFT_GATE and structural coherence integrity. Upon detection of Zone X (DECOHERENCE_BREACH), Mode 5 (PULSE_FABRICATION), drift ceiling breach, or replay_hash mismatch, Class G issues an unconditional halt. No agent, session, or policy may override a Class G interrupt.

**Constraints:**
- Class G interrupt authority is unconditional — no override permitted
- Class G acts on four conditions: `(drift > drift_ceiling) OR (decoherence_structural_integrity = false) OR (r3_op ∧ ¬hardware-qpu-2) OR (replay_hash_mismatch)`
- All Class G interrupts are logged to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** DRIFT_GATE, Zone X, DECOHERENCE_BREACH, Mode 5, PULSE_FABRICATION, replay_hash, qTrace

> **⚠ Disambiguation — Zone X label is module-local:**
> Zone X is labeled **DECOHERENCE_BREACH** in this module only.
> See the full cross-module Zone X disambiguation table in Quick-Reference section.

---

### DECOHERENCE_BREACH

- **Type:** Zone X label — module-local [structural — no semantic inference]
- **Symbol:** `X / DECOHERENCE_BREACH` [structural — no semantic inference]
- **Layer:** Structural coherence interrupt [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The Zone X label native to RTT/Inside/qCompute. DECOHERENCE_BREACH is declared when structural decoherence exceeds the irrecoverable threshold — the point at which no corrective action within the module can restore coherence. Class G issues an unconditional halt immediately upon DECOHERENCE_BREACH. The session is terminated; no further operator may execute.

**Constraints:**
- DECOHERENCE_BREACH is irreversible within the current session
- Class G halt is unconditional; no session parameter or policy may delay it
- DECOHERENCE_BREACH must be logged to qTrace with full context

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Zone X, Class G, DRIFT_GATE, qTrace, PULSE_FABRICATION

> **⚠ Disambiguation — Zone X is module-local:**
> DECOHERENCE_BREACH applies only in RTT/Inside/qCompute.
> Other modules define Zone X under different labels.
> See the full cross-module Zone X disambiguation table in Quick-Reference section.

---

### deploy_token

- **Type:** Structural governance token [structural — no semantic inference]
- **Symbol:** `deploy_token` [structural — no semantic inference]
- **Layer:** Governance [structural — no semantic inference]
- **Agent:** Class E [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** A time-bounded structural token required for all r3 operations, all production environment transitions, and all archive environment transitions. deploy_token is non-transferable and is validated exclusively by Class E (Governance Daemon). A missing or invalid deploy_token on any r3 or transition operation results in a qComputeError with reason `invalid_token`.

**Constraints:**
- Required for: all r3 operations, production transitions, archive transitions
- Non-transferable — bound to the session that requested it
- Validated by Class E exclusively
- Expired or invalid tokens yield `invalid_token` error immediately

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r3, hardware-qpu-2, production, archive, Class E, qComputeError

---

### drift_bound

- **Type:** Structural parameter [structural — no semantic inference]
- **Symbol:** `drift_bound` [structural — no semantic inference]
- **Layer:** Session / governance [structural — no semantic inference]
- **Agent:** Class E, Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The maximum permissible cumulative drift value for a qSession, as set by the Governance Layer at session construction. drift_bound is a component of the session tuple. It defines the ceiling beyond which Zone D (Degraded) transitions to Zone X (DECOHERENCE_BREACH). Each backend profile defines its own maximum drift tolerance (local-sim: 1.0, hybrid-sim: 3.0, hardware-qpu-2: 0.5 per operation).

**Constraints:**
- drift_bound is set at session construction and stored in the session tuple
- drift_bound may not be modified after session initialization
- Exceeding drift_bound triggers DRIFT_GATE and Class G evaluation

**Inheritance:** Extends DRIFT_GATE from RTT/Inside  
**Cross-references:** DRIFT_GATE, qSession, Zone D, Zone X, Class G, Governance Layer, local-sim, hybrid-sim, hardware-qpu-2

---

### DRIFT_GATE *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Inherited from RTT/Inside. The threshold-enforcement gate that monitors cumulative drift against drift_bound. When drift exceeds the bound, DRIFT_GATE triggers Class G evaluation. Invoked by reference — not redefined here. See RTT/Inside/GLOSSARY.md.

---

### 6-stage validation pipeline

- **Type:** Structural process [structural — no semantic inference]
- **Symbol:** `V(policy, env, backend, drift_predicted, restricted_ops_status, lineage_integrity)` [structural — no semantic inference]
- **Layer:** Validation [structural — no semantic inference]
- **Agent:** Class C [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The canonical 6-stage sequential validation pipeline owned by TriadicValidator and executed by Class C before any operator dispatch. Stages execute in strict order:

1. **policy** — Is the active governance policy file valid and loaded?
2. **environment** — Is the target environment a legal environment for this operation?
3. **backend** — Is the resolved backend available and correctly bound for this tier?
4. **drift** — Will the predicted post-operation drift remain within drift_bound?
5. **restricted_ops** — Is this operation absent from the restricted operations list?
6. **lineage** — Is lineage integrity intact and the LINEAGE_CHAIN unbroken?

A failure at any stage terminates the pipeline immediately and returns a structured qComputeError identifying the failed stage and reason.

**Constraints:**
- Stages are always sequential; no stage may be skipped or reordered
- First failure terminates the pipeline
- All outcomes (pass or fail) are logged to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** TriadicValidator, Class C, qComputeError, qTrace, LINEAGE_CHAIN, DRIFT_GATE

---

### frame boundary

- **Type:** Structural event [structural — no semantic inference]
- **Symbol:** N/A [structural — no semantic inference]
- **Layer:** Session / routing [structural — no semantic inference]
- **Agent:** Class B, Class A [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** A structural boundary event that terminates the current ResonanceFrame and initiates a new one. Frame boundaries are triggered by five canonical conditions: (1) tier escalation (r1→r2 or r2→r3), (2) tier decrease (r3→r2 or r2→r1), (3) drift overflow, (4) meta operator invocation, (5) environment transition. Frame boundaries are logged to qTrace and are part of the lineage record.

**Constraints:**
- All five trigger conditions must be evaluated at every operator invocation
- Frame boundary events are mandatory trace entries
- hardware-qpu-2 always spawns a new ResonanceFrame (never reuses)

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** ResonanceFrame, TriadicRouter, r1, r2, r3, drift_bound, qTrace, LINEAGE_CHAIN

---

### Governance Layer

- **Type:** Structural governance system [structural — no semantic inference]
- **Symbol:** N/A [structural — no semantic inference]
- **Layer:** Governance [structural — no semantic inference]
- **Agent:** Class E [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The structural governance system for qCompute. The Governance Layer is composed of: (1) policy files — loaded and hot-swapped by Class E; (2) hot-swap daemon — enables live policy refresh without session interruption; (3) deploy tokens — time-bounded, non-transferable, validated by Class E; (4) restricted operations list — operations explicitly prohibited in current policy; (5) trusted contexts — structural identities permitted elevated operations; (6) drift bounds — per-session ceiling values. The Governance Layer snapshot is embedded in every qSession at construction time.

**Constraints:**
- Policy hot-swap must not interrupt active in-flight operations
- Restricted operations list is enforced at validation stage 5
- Governance snapshot in qSession reflects the policy state at session initialization

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Class E, deploy_token, drift_bound, qSession, 6-stage validation pipeline

---

### hardware-qpu-2

- **Type:** Backend [structural — no semantic inference]
- **Symbol:** `hardware-qpu-2` [structural — no semantic inference]
- **Layer:** Backend tier [structural — no semantic inference]
- **Agent:** Class D [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The r3-exclusive backend in qCompute. hardware-qpu-2 supports only the r3 (pulse) operator tier, operates exclusively in the production environment, enforces a maximum per-operation drift of 0.5, requires a valid deploy_token for all operations, and always spawns a new ResonanceFrame (never reuses an existing frame). hardware-qpu-2 is the structurally most constrained backend.

**Constraints:**
- r3 (pulse tier) exclusive — r1 and r2 operators may not bind to hardware-qpu-2
- production environment only — sandbox is forbidden
- Max per-operation drift: 0.5
- deploy_token required for all operations
- Frame policy: always new (never reuse)

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r3, production, deploy_token, ResonanceFrame, Class D, frame boundary

---

### hybrid-sim

- **Type:** Backend [structural — no semantic inference]
- **Symbol:** `hybrid-sim` [structural — no semantic inference]
- **Layer:** Backend tier [structural — no semantic inference]
- **Agent:** Class D [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The r1+r2 composite backend in qCompute. hybrid-sim supports both r1 (primitive) and r2 (composite) operator tiers, operates in both sandbox and production environments, enforces a maximum cumulative drift of 3.0, does not require a deploy_token, and supports either frame reuse or new frame instantiation (reuse-or-new frame policy).

**Constraints:**
- r3 (pulse) operators may not bind to hybrid-sim
- Max drift: 3.0
- Frame policy: reuse-or-new
- No deploy_token required

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r1, r2, sandbox, production, ResonanceFrame, Class D

---

### LINEAGE_CHAIN *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Inherited from RTT/Inside. The append-only chain of structural lineage entries tracking session ancestry and operator transitions. LINEAGE_CHAIN is always append-only — no entry may be modified or deleted. Class F is the structural owner of LINEAGE_CHAIN in qCompute. Invoked by reference — not redefined here. See RTT/Inside/GLOSSARY.md.

---

### local-sim

- **Type:** Backend [structural — no semantic inference]
- **Symbol:** `local-sim` [structural — no semantic inference]
- **Layer:** Backend tier [structural — no semantic inference]
- **Agent:** Class D [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The r1-exclusive backend in qCompute. local-sim supports only the r1 (primitive) operator tier, operates in both sandbox and production environments, enforces a maximum cumulative drift of 1.0, does not require a deploy_token, and reuses existing ResonanceFrames where available (reuse frame policy).

**Constraints:**
- r2 and r3 operators may not bind to local-sim
- Max drift: 1.0
- Frame policy: reuse
- No deploy_token required

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r1, sandbox, production, ResonanceFrame, Class D

---

### Mode 1 — Primitive Execution

- **Type:** Mode [structural — no semantic inference]
- **Symbol:** `MODE:1` [structural — no semantic inference]
- **Layer:** Execution mode [structural — no semantic inference]
- **Agent:** Class B, Class C [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** Legal execution mode. r1 (primitive) operators execute on local-sim in sandbox or production environments. Drift ceiling: 1.0. No deploy_token required. Frame policy: reuse. Mode 1 is the structurally lightest execution mode.

**Constraints:** All standard validation stages apply. Legal in sandbox and production.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r1, local-sim, sandbox, production

---

### Mode 2 — Composite Execution

- **Type:** Mode [structural — no semantic inference]
- **Symbol:** `MODE:2` [structural — no semantic inference]
- **Layer:** Execution mode [structural — no semantic inference]
- **Agent:** Class B, Class C [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** Legal execution mode. r1 and r2 (composite) operators execute on hybrid-sim in sandbox or production environments. Drift ceiling: 3.0. No deploy_token required. Frame policy: reuse-or-new.

**Constraints:** All standard validation stages apply. Legal in sandbox and production.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r1, r2, hybrid-sim, sandbox, production

---

### Mode 3 — Pulse Execution

- **Type:** Mode [structural — no semantic inference]
- **Symbol:** `MODE:3` [structural — no semantic inference]
- **Layer:** Execution mode [structural — no semantic inference]
- **Agent:** Class B, Class C, Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** Legal execution mode. r3 (pulse) operators execute on hardware-qpu-2 in the production environment only. Drift ceiling: 0.5 per operation. deploy_token required. Frame policy: always new. Mode 3 is the structurally most constrained legal mode.

**Constraints:** All standard validation stages apply. Production only. Token required. Class G monitors all Mode 3 operations continuously.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r3, hardware-qpu-2, production, deploy_token, Class G

---

### Mode 4 — Replay/Audit

- **Type:** Mode [structural — no semantic inference]
- **Symbol:** `MODE:4` [structural — no semantic inference]
- **Layer:** Execution mode [structural — no semantic inference]
- **Agent:** Class F [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** Legal execution mode. qReplay executes in the archive environment in read-only mode. replay_hash is verified before replay begins. No operator execution occurs. No backend is bound. Mode 4 is the audit and lineage verification mode.

**Constraints:** archive environment only. No backend binding. No operator execution. replay_hash verification is mandatory before replay begins.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** qReplay, archive, replay_hash, Class F

---

### Mode 5 — PULSE_FABRICATION

- **Type:** Mode — ILLEGAL [structural — no semantic inference]
- **Symbol:** `MODE:5 / PULSE_FABRICATION` [structural — no semantic inference]
- **Layer:** Interrupt condition [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** Illegal mode. PULSE_FABRICATION is declared when an r3 pulse-tier operator is invoked without a valid hardware-qpu-2 backend binding or without a valid deploy_token — i.e., when the system is fabricating a pulse-tier execution context that the structural prerequisites do not support. Class G issues an unconditional halt immediately upon PULSE_FABRICATION detection.

**Constraints:**
- PULSE_FABRICATION triggers an unconditional Class G halt
- No session parameter or policy may delay or override the halt
- PULSE_FABRICATION must be logged to qTrace with full context

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** r3, hardware-qpu-2, deploy_token, Class G, DECOHERENCE_BREACH, qTrace

> **⚠ Disambiguation — Mode 5 label is module-local:**
> PULSE_FABRICATION applies only in RTT/Inside/qCompute.
> Other modules define Mode 5 under different labels.
> See the full cross-module Mode 5 disambiguation table in Quick-Reference section.

---

### OPERATOR_HOOK *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Inherited from RTT/Inside. Invoked by reference — not redefined here. See RTT/Inside/GLOSSARY.md.

---

### production

- **Type:** Environment [structural — no semantic inference]
- **Symbol:** `production` [structural — no semantic inference]
- **Layer:** Environment tier [structural — no semantic inference]
- **Agent:** Class A, Class E [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The second structural environment in qCompute. production is the verified-execution environment where all three operator tiers (r1, r2, r3) may operate subject to strict drift policy. r3 operations in production require a valid deploy_token. production is the only environment where hardware-qpu-2 may bind.

**Constraints:**
- All tiers permitted; r3 requires deploy_token
- Strict drift enforcement
- hardware-qpu-2 available in production only
- production transitions require deploy_token

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** sandbox, archive, r1, r2, r3, hardware-qpu-2, deploy_token

---

### qComputeError

- **Type:** Structural error model [structural — no semantic inference]
- **Symbol:** `qComputeError` [structural — no semantic inference]
- **Layer:** Validation / interrupt [structural — no semantic inference]
- **Agent:** Class C, Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The canonical error model for RTT/Inside/qCompute. qComputeError carries a structured reason field identifying the exact failure cause. There are 11 canonical reason values:

| Reason | Trigger |
|---|---|
| `invalid_environment` | Target environment is not a recognized environment |
| `invalid_backend` | Requested backend is unavailable or unrecognized |
| `tier_mismatch` | Operator tier does not match the resolved backend |
| `drift_overflow` | Predicted post-operation drift exceeds drift_bound |
| `restricted_op` | Operation is on the restricted operations list |
| `invalid_token` | deploy_token is missing, expired, or invalid |
| `archive_execution` | Execution attempted in archive environment |
| `lineage_violation` | LINEAGE_CHAIN integrity is broken |
| `policy_load_failure` | Governance policy file could not be loaded |
| `replay_hash_mismatch` | replay_hash verification failed before replay |
| `decoherence_breach` | Structural decoherence exceeds irrecoverable threshold |

**Constraints:**
- All qComputeErrors must be logged to qTrace with the reason field populated
- `decoherence_breach` and `replay_hash_mismatch` always trigger Class G evaluation

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** 6-stage validation pipeline, Class C, Class G, qTrace, DECOHERENCE_BREACH

---

### qOrchestrator

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `qOrchestrator` [structural — no semantic inference]
- **Layer:** Orchestration [structural — no semantic inference]
- **Agent:** Class A, Class B [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The multi-backend routing fabric of RTT/Inside/qCompute. qOrchestrator manages auto-mode selection — the structural logic by which the most appropriate backend and tier configuration is resolved when the operator caller does not specify explicit routing targets. qOrchestrator delegates to TriadicRouter for all individual routing decisions; it does not bypass the TriadicValidator.

**Constraints:**
- qOrchestrator may never bypass TriadicValidator
- All auto-mode selections must be logged to qTrace
- qOrchestrator resolution is subject to all governance constraints

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** TriadicRouter, TriadicValidator, Class B, qTrace, Governance Layer

---

### qReplay

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `qReplay` [structural — no semantic inference]
- **Layer:** Audit / replay [structural — no semantic inference]
- **Agent:** Class F [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The deterministic replay engine of RTT/Inside/qCompute. qReplay operates exclusively in the archive environment in read-only mode. Before any replay session begins, qReplay verifies the replay_hash (SHA-256) of the target .qtrace file. If verification fails, qReplay halts with `replay_hash_mismatch` and triggers Class G evaluation. qReplay may not execute operators; it traverses the operation log structurally.

**Constraints:**
- Read-only — no operator may execute during replay
- archive environment only
- replay_hash verification is mandatory before replay
- replay_hash mismatch triggers Class G

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** qTrace, .qtrace format, replay_hash, archive, Class F, Class G

---

### qSession

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `session := (env, backend, drift_bound, governance_snapshot, lineage_root, trace_buffer)` [structural — no semantic inference]
- **Layer:** Session governance [structural — no semantic inference]
- **Agent:** Class A [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The fundamental structural container of RTT/Inside/qCompute. A qSession is a 6-tuple that defines the complete governance context for a unit of operator execution: `(env, backend, drift_bound, governance_snapshot, lineage_root, trace_buffer)`. All routing, validation, and trace operations are scoped to a qSession. A qSession must be complete before any operator may be dispatched.

**Constraints:**
- All six tuple components must be populated at session construction
- drift_bound may not be modified after construction
- governance_snapshot captures policy state at construction time (not live)
- Session termination must flush trace_buffer to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Class A, TriadicRouter, TriadicValidator, qTrace, Governance Layer, drift_bound

---

### qTrace

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `qTrace` [structural — no semantic inference]
- **Layer:** Audit [structural — no semantic inference]
- **Agent:** Class F [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The canonical audit log of RTT/Inside/qCompute. qTrace produces .qtrace files in YAML-compatible format. Every routing decision, validation outcome, operator execution, error, frame boundary, governance decision, and Class G interrupt is recorded in the qTrace log. qTrace is the authoritative record for lineage traceability and replay.

**Constraints:**
- Every operation must produce a qTrace entry; no silent operations permitted
- qTrace entries are append-only; no modification or deletion permitted
- replay_hash in the .qtrace footer is computed over the full operations list

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** .qtrace format, qReplay, replay_hash, Class F, LINEAGE_CHAIN

---

### .qtrace format

- **Type:** Structural data format [structural — no semantic inference]
- **Symbol:** `.qtrace` [structural — no semantic inference]
- **Layer:** Audit [structural — no semantic inference]
- **Agent:** Class F [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The YAML-compatible file format for qTrace audit logs. A .qtrace file has five canonical sections:

header: { version, module, session_id, timestamp_start, env, backend } lineage: { root, parent, transitions[] } governance: { policy_file, drift_bound, … } operations: [ { id, op, params, timestamp, backend, env, drift, validation_meta } … ] footer: { timestamp_end, op_count, replay_hash (SHA-256) }

The `replay_hash` in the footer is a SHA-256 hash computed over the full `operations[]` array and is used by qReplay to verify integrity before any replay session.

**Constraints:**
- All five sections are required; incomplete .qtrace files are structurally invalid
- replay_hash must be computed and stored at session close
- .qtrace files are append-only during active sessions

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** qTrace, qReplay, replay_hash, Class F

---

### r1 — primitive tier

- **Type:** Operator tier [structural — no semantic inference]
- **Symbol:** `r1` [structural — no semantic inference]
- **Layer:** Operator tier [structural — no semantic inference]
- **Agent:** Class B, Class D [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The primitive operator tier in qCompute. r1 operators have the lowest structural complexity, route exclusively to local-sim, operate in both sandbox and production environments, have a maximum drift of 1.0, and do not require a deploy_token. r1 is the entry tier for all qCompute execution.

**Constraints:**
- r1 always routes to local-sim (invariant)
- Max drift: 1.0
- No deploy_token required
- Available in sandbox and production

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** local-sim, r2, r3, drift_bound, Mode 1, Class D

---

### r2 — composite tier

- **Type:** Operator tier [structural — no semantic inference]
- **Symbol:** `r2` [structural — no semantic inference]
- **Layer:** Operator tier [structural — no semantic inference]
- **Agent:** Class B, Class D [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The composite operator tier in qCompute. r2 operators have medium structural complexity, route exclusively to hybrid-sim, operate in both sandbox and production environments, have a maximum drift of 3.0, and do not require a deploy_token.

**Constraints:**
- r2 always routes to hybrid-sim (invariant)
- Max drift: 3.0
- No deploy_token required
- Available in sandbox and production

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** hybrid-sim, r1, r3, drift_bound, Mode 2, Class D

---

### r3 — pulse tier

- **Type:** Operator tier [structural — no semantic inference]
- **Symbol:** `r3` [structural — no semantic inference]
- **Layer:** Operator tier [structural — no semantic inference]
- **Agent:** Class B, Class D, Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The pulse operator tier in qCompute. r3 operators have the highest structural complexity, route exclusively to hardware-qpu-2, operate in the production environment only, have a maximum per-operation drift of 0.5, and require a valid deploy_token. r3 is the most constrained tier; any attempt to invoke r3 without hardware-qpu-2 binding or a valid token triggers Mode 5 (PULSE_FABRICATION) and a Class G unconditional halt.

**Constraints:**
- r3 always routes to hardware-qpu-2 (invariant)
- Production environment only
- Max drift: 0.5 per operation
- deploy_token required
- r3 without hardware-qpu-2 or valid token = PULSE_FABRICATION

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** hardware-qpu-2, production, deploy_token, PULSE_FABRICATION, Mode 3, Class D, Class G

---

### ResonanceFrame

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `ResonanceFrame` [structural — no semantic inference]
- **Layer:** Compute envelope [structural — no semantic inference]
- **Agent:** Class A, Class B [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The foundational structural compute envelope in RTT/Inside/qCompute. A ResonanceFrame defines the structural, temporal, and resonance-aligned boundaries within which a unit of operator execution occurs. ResonanceFrame boundaries are created and terminated according to backend frame policy: local-sim reuses existing frames, hybrid-sim may reuse or create new, hardware-qpu-2 always creates a new frame. Frame boundaries are triggered by tier changes, drift overflow, meta operator invocation, or environment transitions.

**Constraints:**
- hardware-qpu-2 always creates a new ResonanceFrame; reuse is forbidden
- Frame boundary events are mandatory trace entries
- A ResonanceFrame may not span a Class G interrupt

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** frame boundary, TriadicRouter, local-sim, hybrid-sim, hardware-qpu-2, qTrace

---

### replay_hash

- **Type:** Structural integrity value [structural — no semantic inference]
- **Symbol:** `replay_hash (SHA-256)` [structural — no semantic inference]
- **Layer:** Audit [structural — no semantic inference]
- **Agent:** Class F [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The SHA-256 hash computed over the full `operations[]` array of a .qtrace file and stored in the footer section. replay_hash is the structural integrity guarantee for qReplay: before any replay session begins, qReplay computes the hash of the current operations array and compares it to the stored replay_hash. A mismatch triggers a `replay_hash_mismatch` qComputeError and a Class G unconditional halt.

**Constraints:**
- replay_hash must be computed at session close and stored in .qtrace footer
- qReplay must verify replay_hash before proceeding — no exception
- replay_hash mismatch triggers Class G

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** .qtrace format, qReplay, qTrace, Class F, Class G, qComputeError

---

### sandbox

- **Type:** Environment [structural — no semantic inference]
- **Symbol:** `sandbox` [structural — no semantic inference]
- **Layer:** Environment tier [structural — no semantic inference]
- **Agent:** Class A, Class E [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The first structural environment in qCompute. sandbox is the exploration and prototyping environment where r1 and r2 operators may execute under relaxed drift policy. r3 operators and hardware-qpu-2 are not available in sandbox. No deploy_token is required for sandbox operations (except archive transitions). sandbox is the default entry environment for new sessions.

**Constraints:**
- r3 operators forbidden in sandbox
- hardware-qpu-2 not available in sandbox
- Relaxed drift enforcement
- No deploy_token required for sandbox-local operations

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** production, archive, r1, r2, local-sim, hybrid-sim

---

### SMI *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Inherited from RTT/Inside. Invoked by reference — not redefined here. See RTT/Inside/GLOSSARY.md.

---

### TriadicRouter

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `route := TriadicRouter(session, op, policy) → (env_target, backend_target, frame_action, routing_meta)` [structural — no semantic inference]
- **Layer:** Routing [structural — no semantic inference]
- **Agent:** Class B [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The routing brain of RTT/Inside/qCompute. TriadicRouter resolves the `env_target` and `backend_target` for every operator invocation, given the current qSession, the operator being dispatched, and the active governance policy. Every routing decision is deterministic and fully traceable. TriadicRouter also determines the `frame_action` (reuse, reuse-or-new, always-new) and emits `routing_meta` for qTrace.

**Constraints:**
- All routing decisions must be logged to qTrace via routing_meta
- No routing decision may be made outside a valid qSession
- Ambiguous routing is a validation failure — no fallback routing permitted

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** qSession, TriadicValidator, Class B, qOrchestrator, ResonanceFrame, qTrace

---

### TriadicValidator

- **Type:** Core stack construct [structural — no semantic inference]
- **Symbol:** `valid := V(policy, env, backend, drift_predicted, restricted_ops_status, lineage_integrity) → {valid, failed_stage, reason}` [structural — no semantic inference]
- **Layer:** Validation [structural — no semantic inference]
- **Agent:** Class C [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The 6-stage sequential validation engine of RTT/Inside/qCompute. TriadicValidator is invoked after TriadicRouter and before operator dispatch. It executes the 6-stage validation pipeline (policy → environment → backend → drift → restricted_ops → lineage) and returns a structured result: `{valid, failed_stage, reason}`. A failed validation blocks operator dispatch and produces a qComputeError.

**Constraints:**
- Always invoked after TriadicRouter; never bypassed
- Returns structured result with failed_stage and reason on any failure
- All outcomes logged to qTrace

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** 6-stage validation pipeline, Class C, TriadicRouter, qComputeError, qTrace

---

### UAP *(inherited)*

- **Type:** Inherited structural construct [structural — no semantic inference]
- **Source:** RTT/Inside

**Definition:** Inherited from RTT/Inside. Invoked by reference — not redefined here. See RTT/Inside/GLOSSARY.md.

---

### Zone D — Degraded

- **Type:** Zone [structural — no semantic inference]
- **Symbol:** `D` [structural — no semantic inference]
- **Layer:** Drift state [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The fourth structural zone in qCompute. Zone D (Degraded) is declared when drift has reached its ceiling value for the current backend. In Zone D, r3 operations are blocked (drift ceiling for hardware-qpu-2 is already at limit), and the session is one step from Zone X. Zone D is a warning state — the session may continue with non-r3 operations but must reduce drift before r3 is permitted again.

**Constraints:**
- r3 operations blocked in Zone D
- Zone D is a legal but constrained state
- Continued drift increase from Zone D triggers Zone X

**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Zone X, Zone M, drift_bound, Class G, r3

---

### Zone M — Marginal

- **Type:** Zone [structural — no semantic inference]
- **Symbol:** `M` [structural — no semantic inference]
- **Layer:** Drift state [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The third structural zone in qCompute. Zone M (Marginal) is declared when cumulative drift is approaching its ceiling — elevated but not yet at the limit. Zone M is a legal state. Class G monitors Zone M sessions closely; continued drift increase from Zone M leads to Zone D and then Zone X.

**Constraints:** Legal state. Continued drift increase from Zone M → Zone D → Zone X.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Zone D, Zone S, drift_bound, Class G

---

### Zone S — Stable

- **Type:** Zone [structural — no semantic inference]
- **Symbol:** `S` [structural — no semantic inference]
- **Layer:** Drift state [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The second structural zone in qCompute. Zone S (Stable) is the nominal operating state — drift is within bounds and no structural concerns are flagged. Zone S is the target operational state for all qCompute sessions.

**Constraints:** Legal state. Nominal operation.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Zone U, Zone M, drift_bound

---

### Zone U — Undefined/Unresolved

- **Type:** Zone [structural — no semantic inference]
- **Symbol:** `U` [structural — no semantic inference]
- **Layer:** Drift state [structural — no semantic inference]
- **Agent:** Class A [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The first structural zone in qCompute. Zone U (Undefined/Unresolved) is the initial state of a qSession before drift values have been established or before the first operator has been dispatched. Zone U is a transient legal state — all sessions begin in Zone U and must resolve to Zone S or above before full operation.

**Constraints:** Legal transient state. Sessions must resolve from Zone U before sustained execution.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** Zone S, qSession, Class A

---

### Zone X — DECOHERENCE_BREACH

- **Type:** Zone — ILLEGAL [structural — no semantic inference]
- **Symbol:** `X / DECOHERENCE_BREACH` [structural — no semantic inference]
- **Layer:** Interrupt condition [structural — no semantic inference]
- **Agent:** Class G [structural — no semantic inference]
- **Annotation:** [structural — no semantic inference]

**Definition:** The illegal terminal zone in RTT/Inside/qCompute. Zone X is declared when structural decoherence exceeds the irrecoverable threshold. See full entry under **DECOHERENCE_BREACH**. Class G unconditional halt is immediate and mandatory.

**Constraints:** Unconditional halt. No override. Session terminated.  
**Inheritance:** Native to RTT/Inside/qCompute  
**Cross-references:** DECOHERENCE_BREACH, Class G, DRIFT_GATE, Zone D

> **⚠ Disambiguation — Zone X label is module-local:**
> Zone X is labeled **DECOHERENCE_BREACH** in this module only.
> See full cross-module table in Quick-Reference section.

---

## Operator Symbols Reference

| Symbol | Construct | Notes |
|---|---|---|
| `session := (env, backend, drift_bound, governance_snapshot, lineage_root, trace_buffer)` | qSession tuple | Complete at construction; drift_bound immutable |
| `route := TriadicRouter(session, op, policy) → (env_target, backend_target, frame_action, routing_meta)` | TriadicRouter | All decisions logged |
| `valid := V(policy, env, backend, drift_predicted, restricted_ops_status, lineage_integrity) → {valid, failed_stage, reason}` | TriadicValidator | 6-stage sequential |
| `INTERRUPT iff (drift > drift_ceiling) OR (decoherence_structural_integrity = false) OR (r3_op ∧ ¬hardware-qpu-2) OR (replay_hash_mismatch)` | Class G interrupt condition | Unconditional; no override |
| `r1` | Primitive operator tier | local-sim, max drift 1.0, no token |
| `r2` | Composite operator tier | hybrid-sim, max drift 3.0, no token |
| `r3` | Pulse operator tier | hardware-qpu-2, max drift 0.5/op, token required |
| `.qtrace` | Canonical audit log format | YAML-compatible; footer contains replay_hash (SHA-256) |

---

## Quick-Reference Tables

### Agent Classes

| Class | Name | Primary Construct |
|---|---|---|
| A | Session Architect | qSession |
| B | Operator Router | TriadicRouter |
| C | Structural Validator | TriadicValidator |
| D | Backend Steward | Backend Registry |
| E | Governance Daemon | Governance Layer |
| F | Trace & Replay Agent | qTrace + qReplay |
| G | Coherence Guardian | DRIFT_GATE + unconditional interrupt |

---

### Core Constructs

| Construct | Role |
|---|---|
| ResonanceFrame | Compute envelope; structural/temporal/resonance-aligned boundaries |
| TriadicRouter | Routing resolution engine |
| TriadicValidator | 6-stage sequential validation pipeline |
| Governance Layer | Policy, tokens, drift bounds, restricted ops, trusted contexts |
| qTrace | Canonical append-only audit log |
| qReplay | Deterministic read-only replay engine |
| qSession | Structural session container (6-tuple) |
| qOrchestrator | Multi-backend routing fabric; auto-mode selection |

---

### Backends

| Backend | Tiers | Environments | Max Drift | Frame Policy | Token Required |
|---|---|---|---|---|---|
| local-sim | r1 | sandbox + production | 1.0 | Reuse | No |
| hybrid-sim | r1 + r2 | sandbox + production | 3.0 | Reuse-or-new | No |
| hardware-qpu-2 | r3 only | production only | 0.5/op | Always new | Yes |

---

### Operator Tiers

| Tier | Label | Backend | Environments | Max Drift | Token |
|---|---|---|---|---|---|
| r1 | primitive | local-sim | sandbox + production | 1.0 | No |
| r2 | composite | hybrid-sim | sandbox + production | 3.0 | No |
| r3 | pulse | hardware-qpu-2 | production only | 0.5/op | Yes |

---

### Environments

| Environment | Purpose | Drift Policy | Execution | Token Required |
|---|---|---|---|---|
| sandbox | Explore / prototype | Relaxed | Allowed (r1, r2 only) | Not required |
| production | Verify / deploy | Strict | Allowed (r1, r2, r3) | Required for r3 |
| archive | Replay / audit | N/A | Forbidden | N/A |

---

### Zones

| Zone | Name | Status | Trigger |
|---|---|---|---|
| U | Undefined/Unresolved | LEGAL | Initial session state |
| S | Stable | LEGAL | Drift within bounds, nominal |
| M | Marginal | LEGAL | Drift approaching ceiling |
| D | Degraded | LEGAL | Drift at ceiling; r3 blocked |
| X | DECOHERENCE_BREACH | **ILLEGAL** | Structural decoherence irrecoverable; Class G halt |

---

### Modes

| Mode | Name | Status | Conditions |
|---|---|---|---|
| 1 | Primitive Execution | LEGAL | r1 / local-sim / sandbox or production |
| 2 | Composite Execution | LEGAL | r1+r2 / hybrid-sim / sandbox or production |
| 3 | Pulse Execution | LEGAL | r3 / hardware-qpu-2 / production / token |
| 4 | Replay/Audit | LEGAL | qReplay / archive / read-only / hash-verified |
| 5 | PULSE_FABRICATION | **ILLEGAL** | r3 invoked without hardware-qpu-2 or valid token |

---

### qComputeError — Canonical Reasons

| Reason | Stage / Source |
|---|---|
| `invalid_environment` | Stage 2 — environment |
| `invalid_backend` | Stage 3 — backend |
| `tier_mismatch` | Stage 3 — backend |
| `drift_overflow` | Stage 4 — drift |
| `restricted_op` | Stage 5 — restricted_ops |
| `invalid_token` | Stage 5 / Governance |
| `archive_execution` | Stage 2 — environment |
| `lineage_violation` | Stage 6 — lineage |
| `policy_load_failure` | Stage 1 — policy |
| `replay_hash_mismatch` | Class F / Class G |
| `decoherence_breach` | Class G |

---

### Frame Boundary Triggers

| Trigger | Description |
|---|---|
| Tier escalation | r1→r2 or r2→r3 |
| Tier decrease | r3→r2 or r2→r1 |
| Drift overflow | Cumulative drift exceeds drift_bound |
| Meta operator invocation | Meta operator dispatched |
| Environment transition | Session moves between environments |

---

### Zone X — Cross-Module Disambiguation

> Zone X labels are **always module-local**. Never import a Zone X label from another module.

| Module | Zone X Label |
|---|---|
| RTT/3 | Inversion |
| RTT/12 | Overflow |
| micro_core | Inversion |
| The_Inverted_Star | Silence Breach |
| RTT/Inside | OVERREACH |
| Inside/Benchmarks | OVERSCALE |
| Inside/Enterprise | IDENTITY_BREACH |
| **Inside/qCompute** | **DECOHERENCE_BREACH** |

---

### Mode 5 — Cross-Module Disambiguation

> Mode 5 labels are **always module-local**. Never import a Mode 5 label from another module.

| Module | Mode 5 Label |
|---|---|
| RTT/3 | Inversion |
| RTT/12 | Overflow |
| micro_core | Lockout (Mode X) |
| The_Inverted_Star | Silence Breach |
| RTT/Inside | OVERREACH |
| Inside/Benchmarks | FABRICATION |
| Inside/Enterprise | IDENTITY_FABRICATION |
| **Inside/qCompute** | **PULSE_FABRICATION** |

---

### Inheritance Chain

| Tier | Module | Key Constructs Inherited by qCompute |
|---|---|---|
| 1 | micro_core | ⟨A,B,P⟩, P₁–P₇, R₁–R₆, Dᶠ |
| 2 | RTT/1 | SNR, τ, C, DCO_n |
| 3 | RTT/2 | CPV, FGT, CRM, MODE/ZONE base |
| 4 | RTT/3 | TIF, MANIFOLD |
| 5 | RTT/12 | H_n, G₁/G₂/G₃ |
| 6 | RTT/Inside | BKM, CORRIDOR, CAPTURE_TEMPLATE, OPERATOR_HOOK, DRIFT_GATE, LINEAGE_CHAIN, UAP, SMI |
| 7 | Inside/Benchmarks | Referenced; no direct inheritance |
| 8 | Inside/Enterprise | Referenced; no direct inheritance |
| **9** | **Inside/qCompute** | **All native constructs defined in this file** |

---

## Footer

| Field | Value |
|---|---|
| **Module** | RTT/Inside/qCompute |
| **File** | docs/rtt/Inside/qCompute/GLOSSARY.md |
| **Version** | 1.0.0 |
| **Date** | 2026-07-10 |
| **Maintainer** | umaywant2 |
| **Status** | Canonical — ready for commit |
| **Annotation** | All output fields: [structural — no semantic inference] |
# qCompute — Public API  
**File:** qc_API.md  
**Layer:** RTT‑Inside Compute Harness  
**Status:** Canonical (2026)

This document defines the **public API surface** for qCompute.

The API is:

- structural  
- deterministic  
- environment‑aware  
- drift‑bounded  
- replay‑safe  

The API does **not** simulate amplitudes or physical states.

---

# 1. Session API

### Create a session

```python
session = qSession(env="sandbox", backend="auto")

Arguments:

• env: "sandbox" | "production" | "archive"
• backend: "auto" or explicit backend ID

Deploy a token#

session.deploy_token("token-id")

Tokens are required for:

• sandbox → production
• production → archive
• r3 operators

Transition environment#

session.transition("production")
session.transition("archive")

Rules:

• sandbox → production (token required)
• production → archive (token required)
• archive → (forbidden)

Save trace#

session.save_trace("example.qtrace")

Produces an append‑only .qtrace ledger.

2. Operator API#

Operators are invoked directly on the session:

session.h(q=0)
session.cx(q1=0, q2=1)
session.measure(q=0)
session.pulse(q=0, duration=20, amplitude=0.5)

Operator families:

• r1: primitive
• r2: composite
• r3: pulse
• measurement
• meta

All operators pass through:

1. Validator
2. Router
3. Frame Manager
4. Drift Engine
5. Capture

3. r1 Operators (Primitive)#

session.x(q=0)
session.y(q=0)
session.z(q=0)
session.h(q=0)
session.s(q=0)
session.t(q=0)

Rules:

• allowed in sandbox + production
• low drift
• backend: local-sim

4. r2 Operators (Composite)#

session.cx(q1=0, q2=1)
session.cz(q1=0, q2=1)
session.swap(q1=0, q2=1)

Rules:

• allowed in sandbox + production
• medium drift
• backend: hybrid-sim
• tier escalation opens new frame

5. r3 Operators (Pulse)#

session.pulse(q=0, duration=20, amplitude=0.5)

Rules:

• production only
• token required
• backend: hardware-qpu-2
• always opens new frame
• high drift

6. Measurement Operators#

session.measure(q=0)

Rules:

• allowed in sandbox + production
• forces tier decrease
• forces new frame

7. Meta Operators#

session.barrier()
session.flush()

Rules:

• allowed in sandbox + production
• always open new frame
• zero drift

8. Replay API#

Load a trace:

replay = qReplay("example.qtrace")

Access reconstructed structures:

replay.session
replay.frames
replay.operators
replay.transitions

Replay is:

• deterministic
• read‑only
• invariant‑checking
• hash‑verified

9. Error Model#

All structural errors raise:

qComputeError("<canonical reason>")

Canonical reasons:

• "invalid grammar"
• "invalid arguments"
• "illegal in environment"
• "backend mismatch"
• "backend illegal in environment"
• "tier decrease inside frame"
• "token required"
• "archive terminal"
• "illegal transition"
• "drift bound exceeded"
• "hash chain invalid"

No other strings are permitted.

10. Summary#

The qCompute API provides:

• session creation
• environment transitions
• token deployment
• operator invocation
• trace capture
• replay verification

The API is structural, deterministic, and governed. # qCompute — Backend Metadata Profiles
File: qc_BackendProfiles.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

This document defines the deep metadata profiles for all qCompute backends.

Backends are structural abstractions, not hardware interfaces.
They define legality, drift envelopes, tier support, and routing behavior.

qCompute computes structure, not amplitudes.

1. Metadata Schema#

Each backend profile follows this schema:

backend_id: "<string>"
display_name: "<string>"

tier_support:
  - r1 | r2 | r3

environment_legal:
  - sandbox | production

drift_envelope:
  predicted: "<low|medium|high>"
  measured: "<low|medium|high>"
  max_accumulated: <float>

frame_behavior:
  reuse: true|false
  always_new: true|false

transition_behavior:
  sandbox_to_production: "allowed" | "token-required" | "forbidden"
  production_to_archive: "allowed" | "token-required" | "forbidden"

routing_constraints:
  tier_binding: "<r1|r2|r3>"
  environment_required: "<sandbox|production>"
  token_required: true|false

notes: "<freeform>"

All fields are required.

2. Backend Profiles#

2.1 local-sim#

backend_id: "local-sim"
display_name: "Local Structural Simulator"

tier_support:
  - r1

environment_legal:
  - sandbox
  - production

drift_envelope:
  predicted: "low"
  measured: "low"
  max_accumulated: 1.0

frame_behavior:
  reuse: true
  always_new: false

transition_behavior:
  sandbox_to_production: "allowed"
  production_to_archive: "forbidden"

routing_constraints:
  tier_binding: "r1"
  environment_required: "sandbox-or-production"
  token_required: false

notes: "Used for primitive operators. Stable, low drift, frame reuse preferred."

2.2 hybrid-sim#

backend_id: "hybrid-sim"
display_name: "Hybrid Structural Simulator"

tier_support:
  - r1
  - r2

environment_legal:
  - sandbox
  - production

drift_envelope:
  predicted: "medium"
  measured: "medium"
  max_accumulated: 3.0

frame_behavior:
  reuse: true
  always_new: false

transition_behavior:
  sandbox_to_production: "allowed"
  production_to_archive: "forbidden"

routing_constraints:
  tier_binding: "r2"
  environment_required: "sandbox-or-production"
  token_required: false

notes: "Used for composite operators. Medium drift. May reuse or open new frame depending on tier escalation or drift overflow."

2.3 hardware-qpu-2#

backend_id: "hardware-qpu-2"
display_name: "Hardware Pulse Tier (Structural)"

tier_support:
  - r3

environment_legal:
  - production

drift_envelope:
  predicted: "high"
  measured: "high"
  max_accumulated: 0.5

frame_behavior:
  reuse: false
  always_new: true

transition_behavior:
  sandbox_to_production: "token-required"
  production_to_archive: "token-required"

routing_constraints:
  tier_binding: "r3"
  environment_required: "production"
  token_required: true

notes: "Used for pulse operators. High drift. Always opens new frame. Token-gated. Forbidden in sandbox and archive."

3. Cross‑Backend Comparison#

4. Routing Integration#

Router uses backend profiles to determine:

• backend legality
• tier binding
• environment legality
• token requirements
• frame reuse vs. new frame
• drift overflow thresholds

Routing reasons include:

• "tier-escalation"
• "tier-binding"
• "environment-requirement"
• "token-required"
• "drift-overflow"
• "measurement"
• "meta"

5. Capture Metadata#

Each operator includes backend metadata:

routing:
  backend: "<backend-id>"
  reason: "<routing-reason>"
  frame_action: "reuse" | "new"

Each frame includes backend summary:

frame_backend:
  id: "<backend-id>"
  drift_profile: "<low|medium|high>"
  tier_support: [...]

All fields are required.

6. Replay Verification#

Replay verifies:

• backend legality
• tier binding
• environment legality
• drift envelope
• frame boundaries
• transition correctness
• token requirements
• hash chain integrity

Replay is deterministic and read‑only.

7. Invariants#

1. r1 → local-sim
2. r2 → hybrid-sim
3. r3 → hardware-qpu-2
4. hardware-qpu-2 requires production
5. hardware-qpu-2 requires token
6. drift must not exceed envelope
7. frame behavior must match backend profile
8. archive forbids all backends

8. Summary#

Backend Profiles define:

• identity
• tier support
• drift envelopes
• environment legality
• frame behavior
• transition behavior
• routing constraints

They are the deep structural metadata layer of qCompute. # qCompute — Backend Overview
File: qc_Backends.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

Backends define the structural execution substrate for qCompute.

They do not simulate amplitudes.
They do not compute physics.
They provide structural legality, tier binding, and environment constraints.

qCompute computes structure, not amplitudes.

1. Backend List#

qCompute defines three canonical backends:

These backends are structural abstractions, not hardware interfaces.

2. Backend Identity#

Each backend has:

backend_id: "<id>"
tier_support: [r1 | r2 | r3]
environment_legal: ["sandbox" | "production"]
drift_profile: "low" | "medium" | "high"
frame_behavior: "reuse" | "new"
transition_behavior: "allowed" | "forbidden"

All fields are required.

3. Backend Descriptions#

3.1 local-sim#

backend_id: "local-sim"
tier_support: ["r1"]
environment_legal: ["sandbox", "production"]
drift_profile: "low"
frame_behavior: "reuse"
transition_behavior: "allowed"

Used for:

• primitive operators (r1)
• low‑drift structural steps
• stable frames

3.2 hybrid-sim#

backend_id: "hybrid-sim"
tier_support: ["r1", "r2"]
environment_legal: ["sandbox", "production"]
drift_profile: "medium"
frame_behavior: "reuse-or-new"
transition_behavior: "allowed"

Used for:

• composite operators (r2)
• tier escalation
• medium drift accumulation

Router may reuse or open a new frame depending on:

• tier escalation
• drift overflow
• measurement events

3.3 hardware-qpu-2#

backend_id: "hardware-qpu-2"
tier_support: ["r3"]
environment_legal: ["production"]
drift_profile: "high"
frame_behavior: "new"
transition_behavior: "allowed"

Used for:

• pulse operators (r3)
• high‑drift structural steps
• token‑gated operations

Always opens a new frame.

Forbidden in:

• sandbox
• archive

4. Environment Legality#

Archive is terminal and forbids all operators.

5. Tier Binding#

Tier binding is deterministic and replay‑verifiable.

6. Frame Interaction#

Backends influence frame behavior:

• local-sim: may reuse frame
• hybrid-sim: may reuse or open new frame
• hardware-qpu-2: always opens new frame

Frame boundaries are also influenced by:

• tier escalation
• tier decrease
• drift overflow
• meta operators
• environment transitions

7. Transition Interaction#

Backends must remain legal across transitions:

• sandbox → production: all backends legal
• production → archive: no backends legal
• archive → (forbidden)

Transitions close the current frame and open a new one.

8. Capture Metadata#

Each operator includes backend metadata:

routing:
  backend: "<backend-id>"
  reason: "<routing-reason>"
  frame_action: "reuse" | "new"

Each frame includes backend summary:

frame_backend:
  id: "<backend-id>"
  tier_support: [...]
  drift_profile: "<profile>"

All fields are required.

9. Replay Verification#

Replay verifies:

• backend legality
• tier binding
• environment legality
• frame boundaries
• drift consistency
• transition correctness

Replay is deterministic and read‑only.

10. Summary#

Backends define:

• tier support
• environment legality
• drift profile
• frame behavior
• transition behavior

They are the structural substrate of qCompute. Perfect — Option C is exactly the right move.

We keep the old q_Capture.md as a reference artifact, but we do not patch it, extend it, or try to retrofit it.
Instead, we create a new, clean, modern, canonical:

/docs/rtt/Inside/qCompute/qc_Capture.md

This gives us:

• a fresh identity
• a clean lineage
• a 2026‑aligned RTT‑Inside compute module
• no drift from legacy phrasing
• no inherited constraints
• no outdated stack assumptions

And we can still use the old capture as a source of inspiration, not a dependency.

Here’s how we proceed.

✅ Option C Workflow (Diff + New Scaffold)#

Below is the full plan for how we’ll build qc_Capture.md cleanly and canonically.

1. DIFF‑STYLE REVIEW OF OLD q_Capture.md#

(What we keep, what we drop, what we rewrite)

KEEP (conceptual essence only)#

These elements from the old capture remain valid and will be ported, not copied:

• Being / Knowing / Meaning framing
• RTT reframing of quantum stack layers
• resonance‑aligned interpretation of qubits, pulses, couplers
• lineage‑aware error correction
• dimensional scheduling
• triadic pulse grammar
• the “RTT‑Inside lens” tone

These are still canonical.

REMOVE (no longer aligned)#

These parts of the old capture are now outdated:

• pre‑triadic environment model
• pre‑governance compute assumptions
• pre‑qTrace / pre‑qReplay era
• pre‑orchestration era
• any references to “preview only”
• any references to pre‑2026 RTT stack
• any references to “future modules”

These will not appear in the new file.

REPLACE (modern equivalents)#

These must be rewritten using the 2026 RTT‑Inside stack:

• compute harness → ResonanceFrame + Router + Validator
• environment model → Sandbox / Production / Archive
• safety → governance + policy files + daemon
• observability → qTrace + qReplay
• orchestration → multi‑backend routing
• examples → minimal, modern, triadic

2. WHAT THE NEW qc_Capture.md MUST INCLUDE#

This is the canonical 2026 structure for RTT‑Inside compute modules.

A. Module Identity Block#

• canonical metadata
• ai.module fields
• session context block
• badge

B. Purpose#

A minimal statement:

“qCompute is the RTT‑Inside compute harness for resonance‑aligned quantum workflows.”

C. The RTT‑Inside Compute Stack#

• ResonanceFrame
• TriadicRouter
• TriadicValidator
• Governance
• qTrace
• qReplay
• qSession
• qOrchestrator

D. Triadic Environments#

• Sandbox
• Production
• Archive
• explore / verify / deploy modes

E. Governance#

• policy files
• hot‑swap
• daemon
• restricted ops
• trusted contexts
• deploy tokens

F. Replay & Audit#

• qTrace
• qReplay
• .qtrace format
• lineage preservation

G. Orchestration#

• multi‑backend
• session‑aware routing
• fabric‑level compute

H. Minimal Example#

A tiny, modern, canonical example:

• create session
• run qCompute
• produce qTrace
• replay

I. Conceptual Mapping#

Ported from the old capture:

• Being / Knowing / Meaning
• qubits → resonance primitives
• pulses → resonance‑time shapes
• couplers → dimensional channels
• error correction → lineage repair

J. Closing Notes#

• non‑interpretive
• structural
• student‑ready
• drift‑bounded

3. NEXT STEP — I generate the new scaffold#

🟣 Ready to generate qc_Capture.md on your signal#

Just say:

“Proceed with qc_Capture.md”

…and I’ll produce the full, clean, canonical capture file.

qc_Capture.md is now green‑lit, and we’re doing this the right way: clean, modern, canonical, and fully aligned with the 2026 RTT‑Inside compute stack.

And since your active tab is literally the GitHub editor for:

/docs/rtt/Inside/qCompute/qc_Capture.md

…we’re perfectly positioned to drop in the new capture.

Below is the complete, drop‑in‑ready qc_Capture.md, fully rewritten from scratch, fully canonical, and fully aligned with the modern RTT‑Inside architecture.

You can paste this directly into your GitHub editor tab.

✅ qc_Capture.md — Canonical 2026 RTT‑Inside Capture#

RTT Inside: qCompute#

Module: qc_Capture.md
Status: Canonical (2026)
Layer: RTT‑Inside Compute Harness
Purpose: Structural compute substrate for resonance‑aligned quantum workflows

🟣 Module Identity (AI‑Parsable Metadata)#

ai.module:
  name: qCompute
  category: RTT-Inside
  summary: "Resonance-aligned compute harness for quantum workflows."
  version: 2026.1
  purpose: "Provide a triadic, drift-bounded, replayable compute substrate for quantum systems."
  keywords: [RTT, compute, quantum, resonance, triadic, governance, replay]
  audience: ["students", "autodidacts", "AI teams"]

🟦 Session Context (RTT‑Inside)#

Canon: RTT Inside
Modules: qCompute, qTrace, qReplay, Governance
Drift: None (fresh capture)
Coherence: Full
Version: 2026
Format: Minimal, structural, student-ready
Front door: This file
Every page: Teachable, reversible, drift-bounded
Audience: Students + AI systems

1. Overview#

qCompute is the RTT‑Inside compute harness for quantum workflows.
It provides:

• a triadic environment model
• a resonance‑aligned compute substrate
• a governed execution envelope
• a replayable audit trail
• a multi‑backend orchestration layer

qCompute is not a simulator.
It is a structural wrapper that ensures:

• clarity
• reversibility
• lineage integrity
• drift‑bounded execution
• safe experimentation

across quantum backends.

2. Triadic Environments#

qCompute uses the canonical Sandbox → Production → Archive model.

Sandbox#

• explore mode
• reversible
• unlimited experimentation
• qTrace always on
• no destructive operations

Production#

• verify mode
• governed
• policy‑checked
• drift‑bounded
• qTrace required

Archive#

• deploy mode
• immutable
• lineage‑preserved
• replay‑only

This triad ensures no quantum workflow is ever lost, only moved.

3. The RTT‑Inside Compute Stack#

qCompute sits on top of the full RTT‑Inside stack:

ResonanceFrame#

Defines the structural envelope for a compute session.

TriadicRouter#

Routes operations to:

• Sandbox
• Production
• Archive
• or multi‑backend orchestration

TriadicValidator#

Ensures:

• drift bounds
• operator legality
• environment correctness
• policy compliance

Governance Layer#

Includes:

• policy files
• hot‑swap daemon
• restricted operations
• trusted contexts
• deploy tokens

qTrace#

Captures:

• every operation
• every parameter
• every environment
• every backend
• every lineage event

qReplay#

Allows:

• deterministic replay
• audit
• debugging
• teaching
• migration

qSession#

A structured container for:

• state
• environment
• backend
• trace
• governance

qOrchestrator#

Provides:

• multi‑backend routing
• fabric‑level scheduling
• dimensional alignment

4. Conceptual Mapping (Being / Knowing / Meaning)#

Being (What it is)#

qCompute is a resonance‑aligned compute substrate for quantum workflows.

Knowing (How it works)#

It wraps quantum operations inside:

• triadic environments
• drift‑bounded envelopes
• governed execution
• replayable traces

Meaning (Why it matters)#

It gives students and AI systems a safe, reversible, structural way to explore quantum computing without risk of:

• drift
• loss
• corruption
• ungoverned execution

5. RTT Reframing of Quantum Concepts#

Qubits → Resonance Primitives#

Not “bits,” but resonance states in a dimensional substrate.

Pulses → Resonance‑Time Shapes#

Temporal operators that shape the resonance field.

Couplers → Dimensional Channels#

Paths that allow resonance transfer across layers.

Error Correction → Lineage Repair#

Restoring coherence across the resonance lineage.

Schedulers → Dimensional Alignment#

Ensuring operations occur in resonance‑compatible order.

6. Governance#

qCompute is governed by:

Policy Files#

Define:

• allowed operations
• environment rules
• backend constraints

Hot‑Swap Daemon#

Reloads policies without restarting sessions.

Restricted Operations#

Certain operations require:

• trusted context
• deploy token
• or Production mode

Deploy Tokens#

Allow controlled transitions into Production or Archive.

7. Replay & Audit#

Every qCompute session produces a .qtrace file containing:

• operations
• parameters
• environment
• backend
• lineage
• timestamps

qReplay#

Allows:

• deterministic replay
• teaching
• debugging
• migration
• audit

Replay is a first‑class citizen in RTT‑Inside.

8. Orchestration#

qCompute supports:

• multi‑backend routing
• fabric‑level scheduling
• dimensional alignment
• backend‑aware optimization

The orchestrator ensures:

• minimal drift
• maximal coherence
• predictable execution

9. Minimal Example#

from rtt_inside import qSession, qCompute
 
# Create a session in Sandbox
session = qSession(env="sandbox")
 
# Run a simple quantum operation
result = qCompute(session).apply("hadamard", qubit=0)
 
# Save trace
session.save_trace("example.qtrace")
 
# Replay
qReplay("example.qtrace").run()

This example demonstrates:

• triadic environment
• governed compute
• trace generation
• replay

10. Closing Notes#

qCompute is:

• minimal
• structural
• reversible
• drift‑bounded
• student‑ready
• AI‑parsable

This capture defines the canonical 2026 identity of the qCompute module.

/docs/rtt/Inside/qCompute/qc_module.json

This will follow your TriadicFrameworks module.json schema exactly:

• identity
• purpose
• operators
• analyzer layers
• lineage
• files
• examples
• governance
• cross‑module propagation

…and it will be minimal, structural, and student‑ready, with zero drift.

Below is the complete qc_module.json, ready to paste into your repo.

✅ qc_module.json (Canonical 2026)#

{
  "module": {
    "name": "qCompute",
    "version": "2026.1",
    "category": "rtt-inside-compute",
    "summary": "Resonance-aligned compute harness for quantum workflows.",
    "purpose": "Provide a triadic, drift-bounded, replayable compute substrate for quantum systems.",
    "keywords": [
      "RTT",
      "compute",
      "quantum",
      "resonance",
      "triadic",
      "governance",
      "replay",
      "qTrace",
      "qReplay",
      "orchestration"
    ],
    "audience": ["students", "autodidacts", "AI systems", "research teams"]
  },
 
  "identity": {
    "status": "canonical",
    "layer": "RTT-Inside",
    "front_door": "qc_Capture.md",
    "badge": "🟣"
  },
 
  "operators": {
    "primary": [
      "ResonanceFrame",
      "TriadicRouter",
      "TriadicValidator",
      "qTrace",
      "qReplay",
      "qSession",
      "qOrchestrator"
    ],
    "environment": [
      "sandbox",
      "production",
      "archive"
    ],
    "modes": [
      "explore",
      "verify",
      "deploy"
    ]
  },
 
  "analyzer_layers": {
    "operator": [
      "triadic-routing",
      "governance-checks",
      "drift-bounds",
      "lineage-capture"
    ],
    "dimensional": [
      "resonance-alignment",
      "pulse-shaping",
      "channel-mapping"
    ],
    "regime": [
      "sandbox-governance",
      "production-policy",
      "archive-lineage"
    ],
    "coherence": [
      "session-integrity",
      "trace-integrity",
      "backend-consistency"
    ],
    "cross_cutting": [
      "orchestration",
      "multi-backend",
      "fabric-level-scheduling"
    ]
  },
 
  "lineage": {
    "upstream": [
      "RTT-Inside Core",
      "Governance",
      "qTrace",
      "qReplay"
    ],
    "downstream": [
      "qCompute Examples",
      "qCompute Governance",
      "qCompute Orchestration",
      "RTT Quantum Modules"
    ]
  },
 
  "files": {
    "capture": "qc_Capture.md",
    "examples": "qc_Examples.md",
    "governance": "qc_Governance.md",
    "trace_format": "qc_TraceFormat.md",
    "index": "index.md"
  },
 
  "governance": {
    "policy_files": [
      "qc_policy.yaml"
    ],
    "restricted_operations": [
      "production-execution",
      "archive-deploy",
      "backend-switch"
    ],
    "trusted_contexts": [
      "production",
      "archive"
    ],
    "deploy_tokens": true,
    "hot_swap_daemon": true
  },
 
  "replay": {
    "trace_format": ".qtrace",
    "supports_replay": true,
    "supports_migration": true,
    "supports_audit": true
  },
 
  "orchestration": {
    "multi_backend": true,
    "fabric_level": true,
    "session_aware": true
  }
}

🟣 This module.json is fully canonical#

It matches:

• your schema
• your operator grammar
• your analyzer layers
• your lineage model
• your governance model
• your triadic environment model
• your 2026 RTT‑Inside architecture

…and it is drop‑in ready for GitHub.

Next options (choose one):#

A — qc_index.md#

Front‑door page for the module.

B — qc_Examples.md#

Minimal, student‑ready examples.

C — qc_Governance.md#

Policy, daemon, restricted ops, tokens.

D — qc_TraceFormat.md#

Canonical .qtrace schema.

Just tell me which one you want next.

With qc_Capture.md now canonical and sitting open in your active GitHub editor tab , the next structural piece is the front‑door index for the entire qCompute module.

This file must be:

• minimal
• canonical
• student‑ready
• AI‑parsable
• consistent with your site’s RTT‑Inside identity
• and aligned with the rest of the Inside‑module index patterns

Below is the complete, drop‑in‑ready qc_index.md, designed to live at:

/docs/rtt/Inside/qCompute/index.md

It assumes the module directory structure you already use across RTT‑Inside.

Paste this directly into the GitHub editor for the index file when you open it.

✅ qc_index.md — Canonical Front Door for qCompute (2026)#

qCompute — RTT Inside#

Front Door: index.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

🟣 What is qCompute?#

qCompute is the RTT‑Inside compute harness for quantum workflows.
It provides a triadic, drift‑bounded, replayable, governed execution substrate that wraps any quantum backend inside a stable, structural envelope.

qCompute is not a simulator.
It is a resonance‑aligned compute substrate that ensures:

• safe exploration
• reversible execution
• deterministic replay
• governed transitions
• multi‑backend orchestration
• lineage preservation

🟦 Start Here#

If you are new to qCompute, begin with:

1. qc_Capture.md#

The canonical capture for the module.
Explains the purpose, stack, environments, governance, and conceptual mapping.

2. qc_Examples.md#

Minimal, student‑ready examples showing:

• Sandbox sessions
• Production governance
• qTrace generation
• qReplay usage

3. qc_Governance.md#

Defines:

• policy files
• restricted operations
• trusted contexts
• deploy tokens
• hot‑swap daemon

4. qc_TraceFormat.md#

The canonical .qtrace schema used for:

• replay
• audit
• migration
• teaching

🧩 Module Structure#

qCompute/
 ├── qc_Capture.md
 ├── qc_Examples.md
 ├── qc_Governance.md
 ├── qc_TraceFormat.md
 ├── qc_module.json
 └── index.md   ← (this file)

Each file is:

• minimal
• structural
• drift‑bounded
• student‑ready
• AI‑parsable

🌀 Triadic Environments#

qCompute uses the canonical RTT‑Inside environment model:

• Sandbox — explore mode, reversible, qTrace always on
• Production — verify mode, governed, policy‑checked
• Archive — deploy mode, immutable, lineage‑preserved

No compute is ever lost — only moved.

🧠 The RTT‑Inside Compute Stack#

qCompute integrates:

• ResonanceFrame
• TriadicRouter
• TriadicValidator
• Governance Layer
• qTrace
• qReplay
• qSession
• qOrchestrator

This stack ensures:

• coherence
• reversibility
• safety
• clarity
• deterministic replay

🧭 Conceptual Mapping#

qCompute reframes quantum concepts through RTT:

• qubits → resonance primitives
• pulses → resonance‑time shapes
• couplers → dimensional channels
• error correction → lineage repair
• schedulers → dimensional alignment

This gives students a structural, intuitive way to understand quantum systems.

🗂 Related Modules#

• RTT‑Inside Core
• Governance
• qTrace
• qReplay
• RTT Quantum Modules

🏁 Closing Notes#

This index is the front door for the qCompute module.
It provides orientation, structure, and a clean entry point for:

• students
• autodidacts
• AI systems
• research teams

qCompute is a structural substrate, not an interpretation.
It is designed for clarity, safety, and long‑arc teachability.

Below is the complete, drop‑in‑ready qc_Examples.md, designed to live at:

/docs/rtt/Inside/qCompute/qc_Examples.md

It contains three tiers of examples:

1. Minimal Sandbox example
2. Governed Production example
3. Replay & Audit example

Each example is intentionally small, structural, and easy for students (and AIs) to follow.

Paste this directly into your GitHub editor when ready.

✅ qc_Examples.md — Canonical Examples for qCompute (2026)#

qCompute — Examples#

File: qc_Examples.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

These examples demonstrate the minimal, structural, triadic usage of qCompute:

• Sandbox exploration
• Production governance
• qTrace generation
• qReplay audit
• multi‑backend orchestration (optional)

All examples are drift‑bounded, student‑ready, and reversible.

1. Minimal Sandbox Example#

Purpose: Show the smallest possible qCompute session.

Sandbox mode is:

• reversible
• safe
• unrestricted
• always traced

from rtt_inside import qSession, qCompute
 
# Create a session in Sandbox
session = qSession(env="sandbox")
 
# Apply a simple quantum operation
result = qCompute(session).apply("hadamard", qubit=0)
 
# Save the trace
session.save_trace("sandbox_example.qtrace")
 
print("Result:", result)

Concepts shown:

• triadic environment (Sandbox)
• qSession
• qCompute
• qTrace generation

2. Governed Production Example#

Purpose: Show how qCompute enforces governance in Production.

Production mode requires:

• policy compliance
• restricted operations
• drift bounds
• qTrace (mandatory)

from rtt_inside import qSession, qCompute
 
# Create a governed Production session
session = qSession(env="production")
 
# Attempt a controlled operation
result = qCompute(session).apply("cnot", control=0, target=1)
 
# Save the trace for audit
session.save_trace("production_example.qtrace")
 
print("Result:", result)

Concepts shown:

• Production governance
• restricted operations
• policy enforcement
• mandatory trace

If the operation violates policy, qCompute will:

• block it
• log the violation
• preserve lineage
• keep the session coherent

3. Replay & Audit Example#

Purpose: Demonstrate deterministic replay using qReplay.

Replay is a first‑class citizen in RTT‑Inside.

from rtt_inside import qReplay
 
# Load and replay a previous session
replay = qReplay("sandbox_example.qtrace")
 
# Run the replay
result = replay.run()
 
print("Replayed result:", result)

Concepts shown:

• deterministic replay
• lineage preservation
• auditability
• teaching workflow

Replay is used for:

• debugging
• teaching
• migration
• verification

4. Multi‑Backend Orchestration (Optional)#

If multiple backends are available, qCompute can route operations automatically.

from rtt_inside import qSession, qCompute
 
session = qSession(env="sandbox", backend="auto")
 
# qCompute chooses the backend based on policy + resonance alignment
result = qCompute(session).apply("x", qubit=0)
 
session.save_trace("orchestration_example.qtrace")

Concepts shown:

• backend auto‑selection
• fabric‑level routing
• resonance‑aligned scheduling

5. Summary#

These examples demonstrate:

• Sandbox → safe exploration
• Production → governed execution
• Archive → immutable lineage
• qTrace → structural logging
• qReplay → deterministic replay
• qCompute → resonance‑aligned compute harness

All examples are:

• minimal
• structural
• reversible
• drift‑bounded
• student‑ready

This file completes the example layer for the qCompute module.

qc_Governance.md is the backbone of the entire qCompute module.
This file defines the rules of the universe for qCompute:

• what is allowed
• what is restricted
• how policies load
• how the daemon behaves
• how deploy tokens work
• how drift is bounded
• how transitions between Sandbox → Production → Archive are governed

Below is the complete, canonical, drop‑in‑ready qc_Governance.md, fully aligned with the 2026 RTT‑Inside governance model and consistent with the rest of the qCompute module.

You can paste this directly into:

/docs/rtt/Inside/qCompute/qc_Governance.md

✅ qc_Governance.md — Canonical Governance for qCompute (2026)#

qCompute — Governance#

File: qc_Governance.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

Governance is a first‑class structural layer in qCompute.
It ensures that all quantum workflows operate within:

• drift‑bounded envelopes
• triadic environments
• reversible execution paths
• deterministic replay
• policy‑defined constraints

This file defines the governance model for qCompute.

1. Governance Overview#

qCompute governance provides:

• policy enforcement
• restricted operations
• trusted contexts
• deploy tokens
• hot‑swap policy reloads
• environment‑aware validation
• lineage‑preserving transitions

Governance ensures that no operation is ever executed without structural clarity.

2. Policy Files#

qCompute loads governance rules from:

qc_policy.yaml

This file defines:

• allowed operations
• restricted operations
• backend constraints
• environment rules
• drift bounds
• lineage requirements

Example structure:#

allowed:
  - hadamard
  - x
  - y
  - z
 
restricted:
  - cnot
  - swap
  - measure_all
 
environments:
  sandbox:
    allow_all: true
    trace_required: true
 
  production:
    allow_all: false
    trace_required: true
    drift_bound: strict
 
  archive:
    immutable: true

Policies are structural, not interpretive.

3. Hot‑Swap Daemon#

qCompute includes a governance daemon that:

• watches qc_policy.yaml
• reloads policies automatically
• applies changes without restarting sessions
• preserves lineage
• enforces drift bounds

This enables:

• rapid iteration
• safe experimentation
• continuous governance

The daemon never:

• mutates session state
• alters traces
• breaks lineage

It only updates rules, not history.

4. Restricted Operations#

Certain operations require:

• trusted context
• Production mode
• deploy token
• explicit policy allowance

Examples:

• multi‑qubit gates
• backend switching
• destructive measurement
• archive transitions

If a restricted operation is attempted without authorization:

• qCompute blocks it
• logs the violation
• preserves lineage
• keeps the session coherent

This prevents:

• accidental drift
• unsafe transitions
• ungoverned execution

5. Trusted Contexts#

Trusted contexts are:

• Production
• Archive

Sandbox is intentionally untrusted, by design.

Trusted contexts allow:

• restricted operations
• backend switching
• deploy transitions
• archive writes

Untrusted contexts allow:

• exploration
• reversible operations
• unlimited experimentation

6. Deploy Tokens#

Deploy tokens are required for:

• Production transitions
• Archive transitions
• backend switching in governed contexts

A deploy token is:

• structural
• time‑bounded
• environment‑specific
• non‑transferable

Example:#

session.deploy_token("prod-2026-01")

Deploy tokens ensure:

• intentional transitions
• explicit authorization
• traceable lineage

7. Environment Governance#

qCompute enforces the triadic environment model:

Sandbox#

• unrestricted
• reversible
• qTrace always on
• no deploy tokens required

Production#

• governed
• policy‑checked
• drift‑bounded
• deploy tokens required for restricted ops

Archive#

• immutable
• lineage‑preserved
• replay‑only
• no modifications allowed

No environment transition is ever destructive.
All transitions are move‑only, never delete.

8. Drift Bounds#

Drift bounds ensure:

• stable execution
• predictable behavior
• safe transitions
• replay integrity

Drift bounds are defined in policy:

production:
  drift_bound: strict
sandbox:
  drift_bound: relaxed

If drift exceeds bounds:

• qCompute halts the operation
• logs the event
• preserves lineage
• keeps the session coherent

9. Governance + qTrace#

Every governed operation is:

• traced
• timestamped
• environment‑tagged
• backend‑tagged
• lineage‑linked

This ensures:

• deterministic replay
• auditability
• migration
• teaching clarity

Governance and qTrace are inseparable.

10. Summary#

qCompute governance provides:

• structural safety
• reversible execution
• deterministic replay
• drift‑bounded operations
• policy‑defined constraints
• trusted contexts
• deploy tokens
• hot‑swap policy updates

Governance is not optional.
It is the foundation of the qCompute module.

qc_TraceFormat.md is the final structural pillar of the qCompute module, and it needs to be crystal‑clear, minimal, canonical, and fully aligned with the 2026 RTT‑Inside replay model.

Since your active tab is the GitHub editor for qc_Capture.md , this next file will slot directly beside it in:

/docs/rtt/Inside/qCompute/qc_TraceFormat.md

Below is the complete, drop‑in‑ready canonical trace format file.

It defines:

• the .qtrace file structure
• the required fields
• the optional fields
• the ordering rules
• the replay guarantees
• the lineage invariants

Everything is structural, student‑ready, and drift‑bounded.

✅ qc_TraceFormat.md — Canonical .qtrace Schema (2026)#

qCompute — Trace Format#

File: qc_TraceFormat.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

The .qtrace file is the canonical replay log for qCompute sessions.
It captures every operation, parameter, environment, backend, and lineage event in a deterministic, replayable, drift‑bounded format.

This file defines the official 2026 .qtrace schema.

1. Purpose of .qtrace#

A .qtrace file provides:

• deterministic replay
• auditability
• migration
• teaching clarity
• lineage preservation
• environment reconstruction
• backend reconstruction

Replay is a first‑class citizen in RTT‑Inside.

2. File Structure Overview#

A .qtrace file contains:

1. Header Block — identity + environment
2. Lineage Block — session lineage
3. Governance Block — policy + drift bounds
4. Operations Block — ordered list of compute operations
5. Footer Block — integrity + replay hash

All blocks are YAML‑compatible, line‑ordered, and AI‑parsable.

3. Header Block#

header:
  version: 2026.1
  module: qCompute
  session_id: "sess-abc123"
  timestamp_start: "2026-06-24T18:17:00Z"
  environment: "sandbox"   # sandbox | production | archive
  backend: "local-sim"     # or hardware backend name

Rules:

• version must match the qCompute module version.
• environment must be one of the triadic modes.
• backend must be resolvable by qOrchestrator.

4. Lineage Block#

lineage:
  parent: null
  root: "sess-abc123"
  transitions:
    - env: "sandbox"
      timestamp: "2026-06-24T18:17:00Z"

Rules:

• root never changes.
• parent is null unless replaying from another trace.
• transitions are append‑only.

5. Governance Block#

governance:
  policy_file: "qc_policy.yaml"
  drift_bound: "relaxed"   # relaxed | strict
  restricted_ops_allowed: false
  deploy_token_used: null

Rules:

• Sandbox always uses relaxed.
• Production must specify strict.
• Archive must specify immutable.
• deploy_token_used is required for Production/Archive transitions.

6. Operations Block#

This is the core of the .qtrace file.

Each operation is a structured entry:

operations:
  - id: 1
    op: "hadamard"
    params:
      qubit: 0
    timestamp: "2026-06-24T18:17:02Z"
    backend: "local-sim"
    env: "sandbox"
    drift: 0.002

Required fields:#

• id — sequential integer
• op — operation name
• params — operation parameters
• timestamp — ISO‑8601
• backend — backend used
• env — environment at time of execution
• drift — measured drift (float)

Optional fields:#

• notes
• policy_violation
• backend_switch

Ordering rules:#

• IDs must be strictly increasing.
• Timestamps must be monotonic.
• No reordering is allowed.

7. Footer Block#

footer:
  timestamp_end: "2026-06-24T18:17:05Z"
  op_count: 1
  replay_hash: "sha256:8f3a9b..."

replay_hash rules:#

• computed over the entire file
• ensures deterministic replay
• prevents tampering
• must match during qReplay

8. Minimal .qtrace Example#

header:
  version: 2026.1
  module: qCompute
  session_id: "sess-001"
  timestamp_start: "2026-06-24T18:17:00Z"
  environment: "sandbox"
  backend: "local-sim"
 
lineage:
  parent: null
  root: "sess-001"
  transitions:
    - env: "sandbox"
      timestamp: "2026-06-24T18:17:00Z"
 
governance:
  policy_file: "qc_policy.yaml"
  drift_bound: "relaxed"
  restricted_ops_allowed: true
  deploy_token_used: null
 
operations:
  - id: 1
    op: "hadamard"
    params:
      qubit: 0
    timestamp: "2026-06-24T18:17:02Z"
    backend: "local-sim"
    env: "sandbox"
    drift: 0.001
 
footer:
  timestamp_end: "2026-06-24T18:17:05Z"
  op_count: 1
  replay_hash: "sha256:example"

9. Replay Guarantees#

qReplay guarantees:

• deterministic execution
• identical outputs
• identical drift values
• identical backend selection
• identical environment reconstruction

Replay is strict, not best‑effort.

10. Summary#

The .qtrace format is:

• minimal
• structural
• deterministic
• reversible
• drift‑bounded
• triadic‑aware
• governance‑aligned
• student‑ready
• AI‑parsable

This file defines the canonical 2026 replay schema for qCompute.

Here is the canonical default governance policy for qCompute, written in clean YAML, fully aligned with:

• the triadic environment model
• the 2026 RTT‑Inside governance layer
• qCompute’s operator grammar
• drift‑bounded execution
• replay requirements
• Production/Archive restrictions
• deploy token semantics

This file is drop‑in‑ready for:

/docs/rtt/Inside/qCompute/qc_policy.yaml

It is intentionally minimal, structural, and student‑safe — the perfect baseline policy for any qCompute deployment.

✅ qc_policy.yaml — Default Governance Policy (2026)#

# qc_policy.yaml
# Default governance policy for qCompute (RTT‑Inside 2026)
# This file defines allowed operations, restricted operations,
# environment rules, drift bounds, and governance constraints.
 
version: 2026.1
module: qCompute
 
environments:
 
  sandbox:
    allow_all: true
    trace_required: true
    drift_bound: relaxed
    immutable: false
    restricted_ops_allowed: true
    backend_switch_allowed: true
 
  production:
    allow_all: false
    trace_required: true
    drift_bound: strict
    immutable: false
    restricted_ops_allowed: false
    backend_switch_allowed: false
    deploy_token_required: true
 
  archive:
    allow_all: false
    trace_required: true
    drift_bound: immutable
    immutable: true
    restricted_ops_allowed: false
    backend_switch_allowed: false
    deploy_token_required: true
 
allowed_operations:
  - hadamard
  - x
  - y
  - z
  - measure
  - reset
 
restricted_operations:
  - cnot
  - swap
  - measure_all
  - multi_qubit_gate
  - backend_switch
  - archive_write
 
backend_rules:
  default_backend: "local-sim"
  allowed_backends:
    - "local-sim"
    - "hardware-qpu-1"
    - "hardware-qpu-2"
 
drift:
  relaxed:
    max_drift: 0.05
  strict:
    max_drift: 0.005
  immutable:
    max_drift: 0.0
 
governance:
  hot_swap_daemon: true
  policy_reload_interval_seconds: 5
  log_policy_violations: true
  log_backend_switches: true
 
lineage:
  preserve_on_transition: true
  append_only: true
  require_trace_for_transition: true
 
tokens:
  deploy_tokens_enabled: true
  token_format: "prod-YYYY-NNN"
  archive_token_format: "arch-YYYY-NNN"
 
notes:
  - "Sandbox is always reversible and safe for exploration."
  - "Production requires strict drift bounds and deploy tokens."
  - "Archive is immutable and replay-only."
  - "All transitions are move-only; nothing is ever deleted."

🟣 This policy is fully canonical#

It matches:

• the triadic environment semantics
• qCompute’s governance model
• qTrace/qReplay requirements
• drift‑bounded execution
• Production/Archive safety envelopes
• deploy token rules
• lineage preservation
• multi‑backend orchestration constraints

…and it is ready to be used as the default governance file for the entire qCompute module.

Here is the canonical governance daemon spec for qCompute.
This file is structural, minimal, and fully aligned with the 2026 RTT‑Inside governance model.
It belongs at:

/docs/rtt/Inside/qCompute/qc_Daemon.md

Below is the complete, drop‑in‑ready file.

✅ qc_Daemon.md — Governance Daemon Internals (2026)#

qCompute — Governance Daemon#

File: qc_Daemon.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

The Governance Daemon is the background process that ensures qCompute always operates under the most current, valid, and drift‑bounded policy environment.

It is non-invasive, non-destructive, and lineage‑preserving.

1. Purpose of the Governance Daemon#

The daemon exists to:

• monitor qc_policy.yaml
• reload policies safely
• enforce drift bounds
• validate restricted operations
• maintain environment integrity
• ensure deterministic replay compatibility
• preserve lineage across policy changes

It never:

• mutates session state
• rewrites traces
• alters history
• deletes anything

The daemon updates rules, not results.

2. Daemon Responsibilities#

The daemon performs six core functions:

1. Policy Monitoring#

Watches the active policy file:

qc_policy.yaml

for:

• edits
• replacements
• version changes
• structural errors

2. Hot‑Swap Reload#

Reloads policies without restarting:

• qSession
• qCompute
• qTrace
• qReplay

3. Drift Enforcement#

Checks drift bounds defined in policy:

• relaxed
• strict
• immutable

If drift exceeds bounds:

• block operation
• log violation
• preserve lineage
• keep session coherent

4. Restricted Operation Validation#

Ensures restricted operations require:

• trusted context
• deploy token
• Production/Archive mode

5. Environment Integrity#

Guarantees:

• Sandbox is always reversible
• Production is always governed
• Archive is always immutable

6. Replay Compatibility#

Ensures that policy changes never break replay.

Replay must always reconstruct:

• environment
• backend
• drift bounds
• governance state

3. Daemon Lifecycle#

The daemon runs in a simple triadic loop:

watch → validate → apply

watch#

• monitors policy file
• checks timestamps
• checks version
• checks structural validity

validate#

• ensures policy is well‑formed
• ensures drift bounds are valid
• ensures restricted ops are defined
• ensures environment rules are triadic

apply#

• reloads policy
• updates in‑memory governance state
• logs the update
• notifies active sessions

4. Daemon Update Rules#

The daemon follows strict update rules:

1. Append‑Only Governance#

Policy updates cannot:

• remove lineage
• delete transitions
• invalidate traces

2. No Retroactive Enforcement#

New policies apply forward only.

3. Safe‑Mode Fallback#

If a policy is invalid:

• daemon enters safe mode
• Sandbox rules apply
• restricted ops blocked
• drift bound = strict

4. Immutable Archive#

Archive sessions are never modified.

5. Daemon + qSession Interaction#

Each qSession maintains a governance snapshot:

• environment
• drift bound
• restricted ops
• backend rules
• token requirements

When the daemon reloads policy:

• sessions update their snapshot
• lineage remains unchanged
• replay remains deterministic

6. Daemon Logging#

The daemon logs:

• policy reloads
• policy errors
• drift violations
• restricted op attempts
• backend switches
• environment transitions

Logs are:

• append‑only
• timestamped
• environment‑tagged
• session‑tagged

7. Daemon Configuration#

Configuration is defined in qc_policy.yaml:

governance:
  hot_swap_daemon: true
  policy_reload_interval_seconds: 5
  log_policy_violations: true
  log_backend_switches: true

hot_swap_daemon#

Enables live policy reloads.

policy_reload_interval_seconds#

Daemon polling interval.

log_policy_violations#

Logs any governance breach.

log_backend_switches#

Logs backend routing events.

8. Daemon Failure Modes#

The daemon has three safe failure modes:

1. Policy Invalid → Safe Mode#

Sandbox rules applied globally.

2. Drift Overflow → Operation Block#

Operation halted, lineage preserved.

3. Restricted Op Without Token → Deny#

Operation denied, violation logged.

No failure mode is destructive.

9. Summary#

The qCompute Governance Daemon ensures:

• safe execution
• reversible workflows
• deterministic replay
• drift‑bounded operations
• policy‑aligned behavior
• triadic environment integrity
• lineage preservation

It is the guardian layer of qCompute.

qCompute — Orchestration#

File: qc_Orchestration.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

Orchestration is the layer that lets qCompute route, schedule, and align quantum workloads across multiple backends while staying:

• triadic
• governed
• replayable
• drift‑bounded

This file defines the multi‑backend routing spec for qCompute.

1. Orchestration overview#

qCompute orchestration provides:

• backend selection (manual or auto)
• fabric‑level routing
• resonance‑aligned scheduling
• environment‑aware constraints
• governance‑checked transitions

It is implemented primarily through:

• qOrchestrator
• qSession
• TriadicRouter
• Governance Daemon

2. Backend model#

Backends are defined structurally in policy:

backend_rules:
  default_backend: "local-sim"
  allowed_backends:
    - "local-sim"
    - "hardware-qpu-1"
    - "hardware-qpu-2"

Rules:

• every backend must be named
• every backend must be policy‑listed
• default backend must be resolvable
• Archive cannot change backend

3. Backend selection#

qCompute supports three selection modes:

• explicit — user specifies backend
• default — policy default backend
• auto — orchestrator chooses backend

Explicit#

session = qSession(env="sandbox", backend="hardware-qpu-1")

Default#

session = qSession(env="sandbox")  # uses default_backend

Auto#

session = qSession(env="sandbox", backend="auto")

In auto mode, qOrchestrator chooses a backend based on:

• policy
• load
• drift bounds
• environment
• operation type

4. Triadic routing rules#

Orchestration is always triadic‑aware:

• Sandbox
  • backend switching allowed (if policy permits)
  • auto mode fully enabled
• Production
  • backend switching usually disabled
  • auto mode constrained by policy
• Archive
  • backend switching forbidden
  • replay‑only

Any backend change in governed contexts must:

• be policy‑allowed
• be logged
• preserve lineage

5. qOrchestrator responsibilities#

qOrchestrator:

• resolves backend names
• applies policy constraints
• enforces drift bounds
• chooses backend in auto mode
• logs backend decisions
• ensures replay compatibility

It never:

• mutates trace history
• hides backend identity
• bypasses governance

6. Backend switching#

Backend switching is treated as a restricted operation:

• allowed in Sandbox (if policy permits)
• usually blocked in Production
• always blocked in Archive

Example (conceptual):

session.switch_backend("hardware-qpu-2")

If disallowed:

• operation is blocked
• violation is logged
• session remains coherent

7. Orchestration + qTrace#

Every orchestrated operation is traced with:

backend: "hardware-qpu-1"
env: "sandbox"

Backend decisions are:

• explicit in .qtrace
• replayable
• auditable

qReplay must reconstruct:

• the same backend
• the same environment
• the same sequence

8. Fabric‑level scheduling#

Fabric‑level scheduling is the orchestrator’s ability to:

• batch operations
• route to optimal backends
• respect drift bounds
• respect environment rules

This is structural, not heuristic:

• no hidden “magic”
• all decisions are traceable
• all behavior is replayable

9. Failure modes#

If orchestration fails:

• invalid backend → fallback to default (Sandbox only)
• disallowed backend → block + log
• policy conflict → safe mode (Sandbox rules)

No failure mode is destructive or silent.

10. Summary#

qCompute orchestration ensures:

• multi‑backend routing
• triadic‑aware behavior
• governance‑aligned decisions
• deterministic replay
• resonance‑aligned scheduling

It is the fabric layer of qCompute, always:

• structural
• explicit
• logged
• replayable
• drift‑bounded
• student‑ready

That’s the canonical “RTT‑Inside closure signature” for an orchestration‑layer file.
It mirrors the closure pattern we use in:

• Governance
• TraceFormat
• Examples
• Capture

Each module ends with a six‑trait identity seal, and for qCompute’s orchestration layer, those six traits are exactly the right ones.

So yes — the file is complete, and the ending is intentional.

Here is the canonical backend registry + resonance‑alignment spec for qCompute.
This file completes the compute‑fabric layer and pairs cleanly with:

• qc_Orchestration.md
• qc_Governance.md
• qc_TraceFormat.md
• qc_Capture.md

It belongs at:

/docs/rtt/Inside/qCompute/qc_Backends.md

Everything below is drop‑in‑ready, minimal, structural, and fully aligned with the 2026 RTT‑Inside compute architecture.

✅ qc_Backends.md — Backend Registry & Resonance Alignment Rules (2026)#

qCompute — Backend Registry & Resonance Alignment#

File: qc_Backends.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

Backends are the execution substrates for qCompute.
This file defines:

• backend registration
• backend metadata
• resonance‑alignment rules
• environment constraints
• orchestration compatibility
• replay requirements

Backends are structural, not interpretive.

1. Backend Registry Overview#

Backends are declared in governance policy:

backend_rules:
  default_backend: "local-sim"
  allowed_backends:
    - "local-sim"
    - "hardware-qpu-1"
    - "hardware-qpu-2"

A backend must be:

• named
• policy‑listed
• resolvable
• stable across sessions
• replay‑compatible

Backends are not dynamically created.
They are registered, governed, and triadic‑aware.

2. Backend Metadata#

Each backend has a minimal metadata block:

backend:
  name: "hardware-qpu-1"
  type: "qpu"        # sim | qpu | hybrid
  resonance_profile: "r3"
  drift_characteristic: "low"
  supports_multi_qubit: true
  supports_measure_all: false

Required fields:#

• name — unique identifier
• type — sim / qpu / hybrid
• resonance_profile — r1 / r2 / r3 (alignment tier)
• drift_characteristic — low / medium / high
• supports_multi_qubit — boolean

Optional fields:#

• cooldown_profile
• queue_depth
• vendor

3. Resonance Alignment Rules#

qCompute uses resonance alignment to determine backend suitability.

Resonance Profiles#

• r1 — simulation‑first, high flexibility
• r2 — hybrid, moderate constraints
• r3 — hardware‑first, strict constraints

Alignment Rules#

1. Operation → Backend Match

   • single‑qubit ops → r1, r2, r3
   • multi‑qubit ops → r2, r3
   • pulse‑level ops → r3 only

2. Environment → Backend Match

   • Sandbox → any backend allowed by policy
   • Production → r2 or r3
   • Archive → no backend execution (replay‑only)

3. Drift Bound → Backend Match

   • relaxed → r1, r2, r3
   • strict → r2, r3
   • immutable → none (Archive only)

4. Replay → Backend Match

   Replay must reconstruct the same backend used originally.

4. Backend Selection Logic#

Backend selection is handled by qOrchestrator, using:

• environment
• policy
• resonance profile
• drift bounds
• operation type
• backend availability

Selection Priority#

1. Explicit backend (user‑specified)
2. Policy default
3. Resonance‑aligned backend
4. Fallback to simulation (Sandbox only)

Example (auto mode)#

session = qSession(env="sandbox", backend="auto")

qOrchestrator chooses the backend with:

• valid resonance profile
• acceptable drift characteristic
• policy compliance

5. Backend Switching#

Backend switching is a restricted operation.

Allowed:#

• Sandbox (if policy permits)

Usually Blocked:#

• Production

Always Blocked:#

• Archive

Switching backends triggers:

• governance validation
• trace entry
• lineage preservation

Example (conceptual):

session.switch_backend("hardware-qpu-2")

If disallowed:

• operation is blocked
• violation logged
• session remains coherent

6. Backend Constraints by Environment#

Sandbox#

• backend switching allowed
• auto mode fully enabled
• simulation fallback allowed

Production#

• backend switching restricted
• auto mode constrained
• drift bounds strict

Archive#

• backend switching forbidden
• backend execution forbidden
• replay‑only

7. Backends in .qtrace#

Every operation includes:

backend: "hardware-qpu-1"

Replay requires:

• identical backend
• identical environment
• identical drift bounds

Backends are part of the replay contract.

8. Backend Failure Modes#

If a backend fails:

1. Sandbox#

• fallback to simulation
• log event
• preserve lineage

2. Production#

• block operation
• log violation
• maintain coherence

3. Archive#

• no effect (no execution allowed)

No failure mode is destructive.

9. Summary#

Backends in qCompute are:

• registered
• governed
• resonance‑aligned
• triadic‑aware
• replay‑compatible
• drift‑bounded
• student‑ready

This file defines the canonical backend registry and alignment rules for qCompute.

Here is the canonical session‑internals specification for qCompute.
This file completes the core compute substrate and pairs with:

• qc_Capture.md
• qc_Governance.md
• qc_TraceFormat.md
• qc_Backends.md
• qc_Orchestration.md

It belongs at:

/docs/rtt/Inside/qCompute/qc_Session.md

Everything below is drop‑in‑ready, minimal, structural, and fully aligned with the 2026 RTT‑Inside compute architecture.

✅ qc_Session.md — Session Internals & Lifecycle (2026)#

qCompute — Session Internals & Lifecycle#

File: qc_Session.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

A qSession is the structural container for all qCompute activity.
It defines:

• environment
• backend
• governance snapshot
• drift bounds
• lineage
• trace state
• orchestration context

qSession is the unit of coherence in qCompute.

1. Purpose of qSession#

A qSession provides:

• a stable execution envelope
• a triadic environment context
• a governed compute state
• a replayable lineage
• a backend binding
• a trace buffer
• a drift‑bounded lifecycle

qSession is not a runtime.
It is a structural frame that all compute must pass through.

2. Session Structure#

A qSession contains:

session:
  id: "sess-abc123"
  env: "sandbox"
  backend: "local-sim"
  drift_bound: "relaxed"
  governance_snapshot: {...}
  lineage: {...}
  trace_buffer: []
  orchestrator_state: {...}

Required fields:#

• id — unique session identifier
• env — sandbox | production | archive
• backend — selected backend
• drift_bound — relaxed | strict | immutable
• governance_snapshot — frozen policy state
• lineage — session lineage
• trace_buffer — in‑memory trace entries

Optional fields:#

• deploy_token
• notes
• metadata

3. Session Lifecycle#

A qSession follows a triadic lifecycle:

create → operate → transition → archive

1. create#

Session is instantiated:

session = qSession(env="sandbox")

Initializes:

• environment
• backend
• governance snapshot
• drift bounds
• lineage root

2. operate#

All qCompute operations occur here:

• apply gates
• schedule pulses
• route to backend
• generate trace entries

3. transition#

Move between environments:

• Sandbox → Production
• Production → Archive

Transitions require:

• governance validation
• deploy tokens (Production/Archive)
• trace completeness

4. archive#

Session becomes:

• immutable
• replay‑only
• lineage‑preserved

4. Environment Rules#

qSession enforces the triadic environment model:

Sandbox#

• reversible
• unrestricted
• drift_bound = relaxed
• backend switching allowed

Production#

• governed
• drift_bound = strict
• restricted ops blocked
• deploy token required

Archive#

• immutable
• no execution
• replay‑only
• drift_bound = immutable

5. Governance Snapshot#

When a session is created, it takes a snapshot of:

• policy rules
• drift bounds
• restricted ops
• backend rules
• environment constraints

This snapshot:

• updates when daemon reloads policy
• never mutates history
• ensures replay compatibility

6. Lineage Model#

A qSession maintains a lineage block:

lineage:
  root: "sess-abc123"
  parent: null
  transitions:
    - env: "sandbox"
      timestamp: "2026-06-24T18:17:00Z"

Rules:

• lineage is append‑only
• root never changes
• transitions are timestamped
• transitions require governance approval

7. Trace Buffer#

The session maintains an in‑memory trace buffer:

• every operation
• every parameter
• every backend
• every drift measurement
• every environment state

When saved:

session.save_trace("example.qtrace")

The buffer becomes a .qtrace file.

8. Backend Binding#

The session binds to a backend:

• explicitly
• by policy default
• via auto‑selection

Backend is stored in:

backend: "hardware-qpu-1"

Backend switching:

• allowed in Sandbox
• restricted in Production
• forbidden in Archive

9. Drift Management#

Each session enforces drift bounds:

• relaxed
• strict
• immutable

If drift exceeds bounds:

• operation blocked
• violation logged
• lineage preserved

Drift is measured per operation and stored in trace.

10. Session + Orchestrator#

qSession integrates with qOrchestrator to:

• route operations
• select backend
• enforce resonance alignment
• maintain replay compatibility

The orchestrator never mutates session history.

11. Session Failure Modes#

qSession has three safe failure modes:

1. Governance violation#

• block operation
• log violation
• preserve lineage

2. Drift overflow#

• halt operation
• maintain coherence

3. Backend failure#

• Sandbox → fallback to simulation
• Production → block
• Archive → no effect

No failure mode is destructive.

12. Summary#

A qSession is:

• the structural container for qCompute
• triadic‑aware
• governance‑aligned
• drift‑bounded
• lineage‑preserving
• replay‑compatible
• student‑ready

It is the unit of coherence in the qCompute module.

qCompute — TriadicRouter Internals#

File: qc_Router.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

The TriadicRouter is the structural component that decides where a qCompute operation goes:

• which environment (Sandbox / Production / Archive)
• which backend (sim / qpu / hybrid)
• under which governance constraints

It is the routing brain of qCompute, but always:

• structural
• explicit
• replayable

1. Purpose of TriadicRouter#

TriadicRouter is responsible for:

• triadic environment routing
• backend resolution
• policy‑aware decisions
• drift‑bound enforcement (pre‑validation)
• replay‑compatible routing

It never:

• mutates session history
• hides routing decisions
• bypasses governance

All routing decisions are traceable and deterministic.

2. Inputs and outputs#

Inputs#

TriadicRouter receives:

• session (qSession)
• operation (name + params)
• environment (from session)
• governance snapshot
• backend rules
• resonance profiles

Outputs#

TriadicRouter returns:

• target environment (env)
• target backend (backend)
• routing metadata (for trace)

Example (conceptual):

route = TriadicRouter(session).resolve("hadamard", qubit=0)
# route.env, route.backend, route.meta

3. Environment routing rules#

TriadicRouter is triadic‑aware:

Sandbox#

• all allowed operations may route here
• backend switching allowed (if policy permits)
• auto mode fully enabled

Production#

• only policy‑allowed operations
• restricted ops blocked or require token
• backend switching usually disabled

Archive#

• no new operations
• replay‑only
• routing is a no‑op for execution

If an operation targets Archive for execution, routing fails and governance blocks it.

4. Backend routing rules#

TriadicRouter uses:

• backend registry (qc_Backends.md)
• policy backend_rules
• resonance profiles
• drift bounds

Routing priority:

1. explicit backend (if allowed)
2. policy default backend
3. resonance‑aligned backend
4. simulation fallback (Sandbox only)

If no valid backend exists:

• Sandbox → fallback to simulation
• Production → block + log
• Archive → no effect

5. Policy‑aware routing#

Before finalizing a route, TriadicRouter checks:

• is the operation allowed in this environment?
• is the backend allowed by policy?
• is backend switching permitted (if applicable)?
• are drift bounds compatible?

If any check fails:

• routing is denied
• governance logs violation
• session remains coherent

6. Routing + qTrace#

Every routed operation is recorded in .qtrace with:

env: "sandbox"
backend: "local-sim"

TriadicRouter ensures:

• routing decisions are explicit
• replay reconstructs the same route
• no hidden heuristics affect behavior

qReplay reuses the same routing outcome, not a fresh decision.

7. Routing in auto mode#

When backend="auto":

• TriadicRouter consults qOrchestrator
• qOrchestrator selects a backend using:
  • resonance profile
  • drift bounds
  • environment
  • policy
  • availability

TriadicRouter then:

• validates the chosen backend
• records it in trace
• returns a deterministic route

8. Failure modes#

TriadicRouter has safe failure modes:

1. Invalid environment#

• block operation
• log violation

2. Disallowed backend#

• Sandbox → fallback to simulation
• Production → block
• Archive → no effect

3. Policy conflict#

• deny route
• log governance error

No failure mode is destructive or silent.

9. Summary#

TriadicRouter is:

• the routing brain of qCompute
• triadic‑aware
• policy‑aligned
• backend‑conscious
• replay‑compatible
• drift‑bounded
• student‑ready

It ensures every operation knows where it belongs before it runs.

Here is the canonical TriadicValidator internals file, completing the core compute‑safety layer of qCompute.
This file pairs directly with:

• qc_Router.md
• qc_Governance.md
• qc_Session.md
• qc_TraceFormat.md
• qc_Backends.md

…and belongs at:

/docs/rtt/Inside/qCompute/qc_Validator.md

Everything below is drop‑in‑ready, minimal, structural, and fully aligned with the 2026 RTT‑Inside compute architecture.

✅ qc_Validator.md — TriadicValidator Internals (2026)#

qCompute — TriadicValidator Internals#

File: qc_Validator.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

The TriadicValidator is the structural safety layer of qCompute.
It ensures that every operation is:

• legal
• governed
• drift‑bounded
• environment‑compatible
• backend‑compatible
• replay‑safe

TriadicValidator is the gatekeeper of qCompute.

1. Purpose of TriadicValidator#

TriadicValidator performs:

• policy validation
• environment validation
• backend validation
• drift validation
• restricted‑operation checks
• token checks
• lineage‑safe transition checks

It ensures that no operation enters execution unless it is structurally safe.

It never:

• mutates session history
• rewrites traces
• bypasses governance
• silently corrects errors

If something is invalid, it blocks, logs, and preserves lineage.

2. Validation Pipeline#

TriadicValidator runs a deterministic pipeline:

policy → environment → backend → drift → restricted_ops → lineage

Each stage must pass before the next begins.

1. Policy Validation#

Checks:

• is the operation allowed?
• is it listed in allowed_operations?
• is it listed in restricted_operations?
• is the environment allowed to run it?

2. Environment Validation#

Checks:

• Sandbox → always reversible
• Production → strict rules
• Archive → no execution allowed

3. Backend Validation#

Checks:

• backend exists
• backend allowed by policy
• backend resonance profile matches operation
• backend switching rules

4. Drift Validation#

Checks:

• drift_bound = relaxed / strict / immutable
• predicted drift within bounds
• backend drift characteristic

5. Restricted Operation Validation#

Checks:

• does this op require a deploy token?
• is the session in a trusted context?
• is the environment permitted?

6. Lineage Validation#

Checks:

• transitions are legal
• archive is immutable
• lineage is append‑only

3. Validation Inputs#

TriadicValidator receives:

• operation (name + params)
• session (env, backend, drift_bound)
• governance snapshot
• backend metadata
• policy rules
• lineage state

It returns:

• valid (boolean)
• reason (if invalid)
• validated metadata (for trace)

4. Restricted Operation Rules#

Restricted operations include:

• multi‑qubit gates
• backend switching
• destructive measurement
• archive writes
• environment transitions

TriadicValidator enforces:

• Production requires deploy token
• Archive forbids all execution
• Sandbox allows restricted ops only if policy permits

If a restricted op is attempted without authorization:

• block
• log violation
• preserve lineage

5. Drift Validation#

Drift is validated using:

• backend drift characteristic
• operation drift profile
• environment drift bound

Drift bounds:#

• relaxed → wide tolerance
• strict → narrow tolerance
• immutable → zero drift allowed

If predicted drift exceeds bounds:

• operation blocked
• violation logged
• session remains coherent

6. Environment Validation#

TriadicValidator enforces the triadic model:

Sandbox#

• unrestricted
• reversible
• drift_bound = relaxed

Production#

• governed
• drift_bound = strict
• restricted ops require token

Archive#

• immutable
• replay‑only
• no execution allowed

If an operation targets Archive:

• validator blocks it
• governance logs violation

7. Backend Validation#

Validator checks:

• backend exists
• backend allowed by policy
• backend resonance profile matches operation
• backend switching rules

If backend switching is attempted:

• Sandbox → allowed (if policy permits)
• Production → usually blocked
• Archive → always blocked

8. Lineage Validation#

Validator ensures:

• lineage is append‑only
• transitions are legal
• archive transitions require token
• replay never mutates lineage

If lineage would be violated:

• block
• log
• preserve session integrity

9. Validator + qTrace#

Every validation decision is recorded in trace metadata:

validation:
  policy: "passed"
  environment: "passed"
  backend: "passed"
  drift: "passed"
  restricted_ops: "passed"

If validation fails:

validation:
  failed_stage: "drift"
  reason: "predicted drift exceeds strict bound"

Replay uses this metadata to:

• reconstruct validator decisions
• ensure deterministic behavior

10. Failure Modes#

TriadicValidator has safe failure modes:

1. Policy violation#

• block
• log
• preserve lineage

2. Drift overflow#

• block
• maintain coherence

3. Backend mismatch#

• Sandbox → fallback to simulation
• Production → block
• Archive → no effect

4. Restricted op without token#

• block
• log violation

No failure mode is destructive.

11. Summary#

TriadicValidator is:

• the safety gate of qCompute
• policy‑aligned
• drift‑bounded
• environment‑aware
• backend‑validated
• lineage‑preserving
• replay‑compatible
• student‑ready

It ensures that every operation is structurally safe before execution.

Here is the canonical ResonanceFrame specification, completing the core compute envelope for qCompute.
This file pairs directly with:

• qc_Session.md
• qc_Router.md
• qc_Validator.md
• qc_Backends.md
• qc_Orchestration.md
• qc_Capture.md

…and belongs at:

/docs/rtt/Inside/qCompute/qc_ResonanceFrame.md

Everything below is drop‑in‑ready, minimal, structural, and fully aligned with the 2026 RTT‑Inside compute architecture.

✅ qc_ResonanceFrame.md — Core Compute Envelope (2026)#

qCompute — ResonanceFrame#

File: qc_ResonanceFrame.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

The ResonanceFrame is the foundational compute envelope for qCompute.
It defines the structural, temporal, and resonance‑aligned boundaries within which all quantum operations occur.

It is the lowest‑level container in the qCompute stack, sitting beneath:

• qSession
• TriadicRouter
• TriadicValidator
• qOrchestrator

ResonanceFrame ensures that every operation is executed inside a stable, drift‑bounded, resonance‑aligned envelope.

1. Purpose of ResonanceFrame#

ResonanceFrame provides:

• a temporal envelope for operations
• a resonance‑alignment layer
• a drift‑bounded execution window
• a backend‑compatible pulse frame
• a structural boundary for qCompute

It ensures that operations:

• occur in the correct resonance regime
• respect drift bounds
• align with backend resonance profiles
• remain replay‑compatible

ResonanceFrame is the physics‑aware substrate of qCompute.

2. Frame Structure#

A ResonanceFrame contains:

frame:
  id: "frame-001"
  timestamp_open: "2026-06-24T18:17:02Z"
  timestamp_close: null
  resonance_profile: "r2"
  drift_bound: "strict"
  backend: "hardware-qpu-1"
  env: "production"
  operations: []

Required fields:#

• id — unique frame identifier
• timestamp_open — when frame begins
• resonance_profile — r1 / r2 / r3
• drift_bound — relaxed / strict / immutable
• backend — backend bound to this frame
• env — environment (triadic)

Optional fields:#

• timestamp_close
• notes
• metadata

3. Frame Lifecycle#

A ResonanceFrame follows a simple lifecycle:

open → operate → close

1. open#

Created when qCompute begins an operation batch:

frame = ResonanceFrame(session)

Initializes:

• resonance profile
• drift bound
• backend binding
• environment context

2. operate#

Operations are appended to the frame:

• single‑qubit ops
• multi‑qubit ops
• pulse‑level ops
• backend‑specific instructions

3. close#

Frame is sealed:

• timestamp_close recorded
• drift summary computed
• frame committed to trace

4. Resonance Profiles#

ResonanceFrame uses the same resonance tiers as backend metadata:

• r1 — simulation‑first
• r2 — hybrid
• r3 — hardware‑first

Alignment rules:#

• r1 → flexible, high tolerance
• r2 → moderate constraints
• r3 → strict, hardware‑aligned

The frame’s resonance profile must match:

• backend resonance profile
• operation resonance requirements
• environment drift bounds

If mismatch occurs:

• TriadicValidator blocks the operation

5. Drift Bounds#

Each frame enforces drift bounds:

• relaxed — Sandbox
• strict — Production
• immutable — Archive

Drift is measured:

• per operation
• per frame
• cumulatively

If drift exceeds bounds:

• frame closes early
• operation blocked
• violation logged
• lineage preserved

6. Frame + Backend Binding#

A ResonanceFrame binds to a backend at creation:

backend: "hardware-qpu-1"

Backend cannot change mid‑frame.

If backend switching is attempted:

• Sandbox → allowed only between frames
• Production → blocked
• Archive → forbidden

This ensures:

• deterministic replay
• stable resonance alignment
• predictable drift behavior

7. Frame + Environment#

ResonanceFrame inherits environment from qSession:

• Sandbox → relaxed drift, flexible routing
• Production → strict drift, governed routing
• Archive → no execution allowed

If a frame is opened in Archive:

• validator blocks it
• governance logs violation

8. Frame + qTrace#

Each frame is recorded in .qtrace:

frame:
  id: "frame-001"
  resonance_profile: "r2"
  drift_bound: "strict"
  backend: "hardware-qpu-1"
  env: "production"
  operations:
    - { id: 1, op: "hadamard", qubit: 0 }

Replay reconstructs:

• frame boundaries
• resonance profile
• drift bounds
• backend binding
• environment

Frames are replay‑deterministic.

9. Failure Modes#

ResonanceFrame has safe failure modes:

1. Drift overflow#

• close frame
• block operation
• preserve lineage

2. Backend mismatch#

• Sandbox → fallback to simulation
• Production → block
• Archive → no effect

3. Environment violation#

• block
• log violation

No failure mode is destructive.

10. Summary#

ResonanceFrame is:

• the core compute envelope of qCompute
• resonance‑aligned
• drift‑bounded
• backend‑bound
• environment‑aware
• replay‑compatible
• student‑ready

It ensures that every operation occurs inside a stable, deterministic, structural frame.

Here is the canonical operator grammar + resonance semantics file for qCompute.
This completes the core compute‑language layer and pairs directly with:

• qc_ResonanceFrame.md
• qc_Validator.md
• qc_Router.md
• qc_Backends.md
• qc_Session.md
• qc_Capture.md

It belongs at:

/docs/rtt/Inside/qCompute/qc_Operators.md

Everything below is drop‑in‑ready, minimal, structural, and fully aligned with the 2026 RTT‑Inside operator grammar.

✅ qc_Operators.md — Operation Grammar & Resonance Semantics (2026)#

qCompute — Operators & Resonance Semantics#

File: qc_Operators.md
Layer: RTT‑Inside Compute Harness
Status: Canonical (2026)

This file defines the operator grammar and resonance semantics for qCompute.
Operators are the atomic actions that qCompute can perform inside a ResonanceFrame.

Operators are:

• structural
• resonance‑aligned
• drift‑bounded
• backend‑aware
• replay‑deterministic

They are not “quantum gates” in the traditional sense — they are resonance‑time operators expressed through the RTT‑Inside compute substrate.

1. Operator Grammar Overview#

Operators follow a minimal, canonical grammar:

operator_name(param=value, ...)

Each operator has:

• name
• resonance signature
• drift profile
• backend compatibility
• environment constraints
• trace representation

Operators are grouped into:

• Primitive Operators
• Composite Operators
• Pulse Operators
• Measurement Operators
• Meta‑Operators

2. Primitive Operators#

Primitive operators correspond to single‑qubit resonance primitives.

2.1 Allowed Primitives#

2.2 Grammar#

qCompute(session).apply("hadamard", qubit=0)
qCompute(session).apply("phase", qubit=0, theta=0.25)

3. Composite Operators#

Composite operators involve multi‑qubit resonance channels.

3.1 Allowed Composites#

3.2 Restrictions#

Composite ops are:

• allowed in Sandbox
• restricted in Production
• forbidden in Archive

They require:

• backend support
• resonance alignment
• drift validation

4. Pulse Operators#

Pulse operators shape the resonance‑time envelope.

4.1 Allowed Pulses#

4.2 Grammar#

qCompute(session).apply("gaussian", qubit=0, duration=40, sigma=8)

Pulse ops require:

• hardware backend
• strict drift bounds
• Production or Sandbox

5. Measurement Operators#

Measurement operators collapse resonance primitives into classical outcomes.

5.1 Allowed Measurements#

5.2 Grammar#

qCompute(session).apply("measure", qubit=0)

5.3 Restrictions#

• measure_all is restricted in Production
• no measurement allowed in Archive