What it was asked. What it actually did.

from omniloop import Loop

# No adapter, no framework. `cfg` is your own config object;
# these fields become live, bounded, recorded controls.
loop = Loop(
    source=cfg,
    tunable=["kp", "kd", "max_torque"],
    limits={"max_torque": (-100.0, 100.0)},   # clamps are journaled
    journal="run.omni",
)
loop.watch_all_nonfinite(True)          # freeze on the first NaN
loop.watch("joint_torque", "greater_than", 100.0,
           requirement="REQ-SAFE-014")      # the trip names what it defends

while running:
    with loop.tick():   # applies edits, evaluates tripwires
        state = robot.read()
        robot.command(controller.step(state, cfg))
        loop.log(torque=state.torque)

// 1 kHz controller. Press Halt in the dashboard and the arm HOLDS —
// a loop that stops commanding does not pause, it falls.
omniloop::Config cfg;
cfg.halt_policy  = omniloop::HaltPolicy::Handoff;
cfg.halt_timeout = std::chrono::seconds(5);   // deadman
omniloop::Loop loop(cfg);

loop.tunable("kp", kp_, 0.0, 500.0);      // live slider, zero-copy
loop.limit("kp", 0.0, 400.0);             // hard envelope, in-process
loop.readout_array("joint_torque", torque_);
loop.watch_array_above("joint_torque", 100.0);
loop.deadline(std::chrono::microseconds(1000));

while (running_)
    loop.step([&]{ controller_.update(dt); },   // body
              [&]{ damping_.hold(dt); });       // fallback

from omniloop import load_events, JournalPlayer, verify_chain

# Before reading a trace somebody sent you, check it is the one they wrote.
result = verify_chain("run.omni")
if not result["ok"]:
    raise SystemExit(f"tampered or damaged: {result['break_at']}")

# Mutations, freezes, watchpoint trips and guardrail downgrades
for e in load_events("run.omni"):
    print(e["tick"], e["kind"], e["event"])

# Walk the run. `read_next_data_record` skips chain checkpoints.
player = JournalPlayer("run.omni")
while rec := player.read_next_data_record():
    if rec["kind"] == "telemetry":
        apply_state(rec["payload"])

# The robot froze at 03:14. The journal is the only witness.
$ omniloop why run.omni --tick 4350

      TICK  KIND        DETAIL
  --------  ----------  --------------------------------------------
      4348  mutation    p_gain: 1.2 -> 3.5  (by local)
      4349  control     resume
      4350  control     freeze_on_exception  ValueError: velocity limit

# Is this the file that was written, or a file that was edited?
$ omniloop verify run.omni
  declared chained : True
  records walked   : 8734
  checkpoints      : 137
[ok]   chain intact — no record was altered, removed, re-timed, or re-ordered.

# Did last night's rerun actually reproduce it?
$ omniloop diff run.omni replayed.omni
[fail] first divergence at tick 4350

# Is the channel live, or just holding a dead frame?
$ omniloop status
  Shared Memory IPC: [ok]   live — publishing at ~1004 Hz
  Telemetry Server:  [ok]   online (1 dashboard connected)

# The agent has the loop. Nobody is at the dashboard.
$ omniloop mcp --allow-control

→ omniloop_set_watchpoint(name="reward_mean", condition="non_finite")
→ omniloop_wait_for_halt()          # blocks. no polling a 1 kHz loop.

  halted: true   cause: watchpoint   tick: 8412
  watch_trip: reward_mean non_finite = nan
  exception:
    file: train.py   line: 214
    code_lines:  |  212  advantages = returns - values
                 |  213  advantages = (advantages - advantages.mean())
                 |  214              / advantages.std()   <-- std() == 0

→ omniloop_set_variable(name="p_gain", value=1.4)

  correlation_id: 5169c608…   observed: 0.0001   applied: true

# A clamped write is never reported as a success:
→ omniloop_set_variable(name="p_gain", value=9.0)

  observed: 0.005   applied: false
  note: the loop is NOT running the value that was asked for.

# And the envelope is armed in the loop's own core, not just at the relay:
→ omniloop_set_bounds(name="p_gain", min=0.0, max=2.0)

  enforced_by: [relay, target]   target_confirmed: true

// Handles, not &mut — so a tick can be open while the body reads state,
// and a dangling binding is unrepresentable.
let mut lp = Config::new()
    .halt_policy(HaltPolicy::Handoff)
    .halt_timeout(Duration::from_secs(5))
    .open()?;

let kp  = lp.tunable("kp", 120.0, 0.0..=500.0)?;
let err = lp.readout("tracking_error", 0.0)?;
lp.limit("kp", 0.0..=400.0)?;
lp.deadline(Duration::from_micros(1000))?;

while running {
    lp.step(
        || controller.update(dt),   // body
        || damping.hold(dt),        // fallback while halted
    );
}