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.