aeon-monitor (binary)

Parent: Gnosis README

The aeon-monitor artifact is not a standalone package here. It is built from the distributed-inference crate as the aeon-monitor bin (Cargo.toml).

Getting Started

• What: terminal and browser-facing monitor output for the distributed-inference frame pipeline.
• Why: it lets you see mesh, spectrum, image, and visualization frames instead of only reading logs.
• How: build it from the parent package with pnpm --dir open-source/gnosis run aeon-monitor:build, then use it through the mesh or monitor commands described below.
• Next: read the projection model, then the build section, then follow the links into distributed-inference when you need the producing runtime.

Projection model (spectrum / mesh / image)

aeon-monitor is the terminal projection layer for PleromaticFrame: the same row-major grayscale raster + attributes contract covers NOAA APT scanlines and IQ spectrogram waterfalls. Mesh fork/race/fold hints attach as frame metadata (mesh_best_if_offset_hz, etc.), not as a separate renderer.

For the analogous pipeline in aeon-tui (RGBA manifold → ASCII synthesis), see ../aeon-tui/src/monitor/README.md and the knot_viz scene (default) or brain_mesh_depth scene — same idea: scalar field on a 2D grid, then glyphs.

The Rust monitor mirrors aeon-tui’s terminal sizing idea (process.stdout.columns / rows in controller.ts): it reads the TTY size each frame (Unix: TIOCGWINSZ on stdout; otherwise COLUMNS / LINES), fills the canvas, clears and redraws continuously, and keeps a one-line status strip at the bottom. Optional alternate screen (\x1b[?1049h) avoids scrolling the scrollback (disable with AEON_MONITOR_ALT_SCREEN=0).

Mesh Telemetry mode (--mesh)

aeon-monitor --mesh is a self-contained ASCII dashboard for the resilient R1 inference mesh (../distributed-inference/docs/R1_RESILIENT_MESH.md) — a terminal mode in the house style, not a web page. Same poll → render → ASCII shape as the skymesh and aeon-tui webcam scenes.

Each tick it polls every node's gossip-NodeStatus HTTP surface (GET /status, server-to-server so no CORS needed) and auto-discovers the rest of the fleet from GET /mesh/peers, then renders:

• a rotating 3D spiderweb projected to ASCII (the same projection idiom as render_handshake_cloud): nodes ride a tilted ring around a central ◉ HIVE, glyph by depth (@/O/o, x offline), color by health, gold + pulses travelling the spokes for in-flight requests; and
• an aeon-box telemetry table: per-node free-RAM bar, in-flight count + sparkline, load / battery / temp / uptime, and a FLEET line (lanes, total free RAM, in-flight, health verdict).

cargo run --release --features aeon-monitor-bin --bin aeon-monitor -- --mesh
# one frame + exit (snapshot):  ... --bin aeon-monitor -- --mesh --oneoff
# also serve the web face:      ... --bin aeon-monitor -- --mesh --serve 8722

Web face (skymesh): --mesh --serve <port> additionally publishes the SAME dashboard as a gnosis.monitor.v1 mesh-telemetry scene (a cell grid parsed from the ANSI render) at GET /monitor/frame.json?scene=mesh-telemetry + /monitor/stream?.... The skymesh app (apps/skymesh, client/views/VectorView.tsx → CellGrid) renders that grid with its monospace Screen, so the browser shows the identical ASCII spiderweb + table the terminal does — same scene pipeline as every other monitor scene, no device-side polling in the browser.

Flags / env: --nodes ip1,ip2,... (default the live fleet) or AEON_MESH_NODES; --mesh-port N (default 8090) or AEON_MESH_PORT; AEON_MESH_MS poll interval (default 1000); GNOSIS_AEON_MONITOR_MESH=1 to launch it; AEON_MONITOR_ALT_SCREEN=0 to disable the alternate screen.

Knot Theory Playground

The knot_viz scene is the default visualization in aeon-tui monitor mode. It serves static/knot-viz.html — an interactive WebGL-based knot visualization with hotkeys and virtual mouse support.

Access via browser at the URL displayed in the ASCII monitor, or serve standalone:

python3 -m http.server 8000 --directory open-source/gnosis/aeon-monitor/static
# Open http://localhost:8000/knot-viz.html

Interactive controls:

• F: Toggle fullscreen cinema mode (hides UI panels)
• Arrow keys: Rotate the knot visualization
• Mouse: Virtual cursor trails and interaction
• Hotkeys: See the HTML for full list of scene-specific controls

Build

From open-source/gnosis:

pnpm run aeon-monitor:build

Same as pnpm run monster-mesh:build:native-monitor. Binary output:

• distributed-inference/target/release/aeon-monitor (primary)
• Alternate layout: open-source/gnosis/target/release/aeon-monitor when built with a different --target-dir

Disk space (No space left on device)

Cargo needs free space under target/ (often several GB for distributed-inference). If writes fail with os error 28:

• Free disk, then cargo clean --manifest-path ./distributed-inference/Cargo.toml (or delete distributed-inference/target), and rebuild; or
• Redirect the build tree to a larger volume, for example: export CARGO_TARGET_DIR=/path/with/free-space/gnosis-di-target then run pnpm run aeon-monitor:build again.

Spectrogram producer (iq-waterfall-frame, optional feature)

Build the RTL rtl_u8 → waterfall → bincode frame tool:

pnpm run iq-waterfall-frame:build

Equivalent:

cargo build --manifest-path ./distributed-inference/Cargo.toml \
  --features spectrum-waterfall --bin iq-waterfall-frame --release \
  --target-dir ./distributed-inference/target

Binary: distributed-inference/target/release/iq-waterfall-frame.

Example (writes spectrum_waterfall.frame by default):

./distributed-inference/target/release/iq-waterfall-frame \
  --input ../.qa-artifacts/rtlsdr/hardware-capture.u8 \
  --output ./distributed-inference/spectrum_waterfall.frame \
  --iq-rate 2048000 \
  --center-hz 162400000 \
  --fft-size 512 \
  --rows 48 \
  --mesh-best-if-offset-hz 4500 \
  --mesh-best-score 0.31

Flags use --name value pairs (see --help by running without args — stderr lists usage). --input - reads stdin; --output - writes bincode to stdout.

NOAA APT render smoke

aeon-monitor renders NOAA APT grayscale scanline frames when PleromaticFrame.attributes["rf_protocol"] == "noaa_apt" with apt_width / apt_height.

Ingested noaa_apt.frame is drawn before the handshake voxel demo and before generic embedded PNG, so it stays visible next to the animated mesh thread.

From open-source/gnosis, generate a synthetic APT frame artifact:

pnpm run aeon-monitor:noaa-apt-synth-frame

NOAA-shaped asset from a PNG (your case)

If the raster is meant to be NOAA APT scanlines (not a generic screenshot), convert PNG → luma → proper APT contract — you get the NOAA APT SCANLINE RECONSTRUCTION banner and apt_width / apt_height metadata (optional RF CENTER):

pnpm run png-noaa-apt-frame:build
cargo run --manifest-path ./distributed-inference/Cargo.toml --bin png-noaa-apt-frame -- \
  /path/to/apt_image.png ./distributed-inference/noaa_apt.frame --center-hz 137100000

vs png-embed-frame: that path keeps the PNG file inside the frame (image_encoding=png) and shows PNG IMAGE in the monitor — still useful for arbitrary images, not the APT wire contract.

Then start the monitor from open-source/gnosis/distributed-inference so it auto-ingests ./noaa_apt.frame if present:

cd distributed-inference
cargo run --release --bin aeon-monitor

After pnpm run aeon-monitor:build, you can run the release binary directly instead, for example ./target/release/aeon-monitor from that same directory (paths depend on --target-dir).

Shell tip: Do not paste a bare line that is only # ... — in zsh that tries to run a command named #, which fails with command not found.

Spectrogram waterfall ingest

When PleromaticFrame.attributes["rf_projection"] == "spectrogram_waterfall" (see spectrum_waterfall), the monitor draws SPECTROGRAM WATERFALL plus IQ rate, dimensions, optional RF center, and optional mesh-fold lines.

At startup, aeon-monitor tries to load spectrum_waterfall.frame from the current working directory. Override the path:

export AEON_MONITOR_SPECTRUM_FRAME=/path/to/my_waterfall.frame

If a spectrogram frame is present in the mesh, it takes priority over the handshake voxel demo so operator RTL captures stay visible without disabling the demo thread.

PNG image (embedded file bytes)

aeon-monitor decodes PNG files to a luminance raster and draws it with the same ASCII ramp as NOAA / spectrogram (decimate to terminal size).

Contract: PleromaticFrame::png_image_embedded sets media_type: Image, image_encoding: png, and stores the entire PNG file in data (not raw pixels).

Ways to ingest

1. Raw path (no bincode step) — from open-source/gnosis/distributed-inference:

   export AEON_MONITOR_IMAGE_PNG=/path/to/screenshot.png
   cargo run --release --bin aeon-monitor

2. Bincode frame file (default path monitor_image.frame in cwd), e.g. bundle once then run without env:

   cargo run --manifest-path ./distributed-inference/Cargo.toml --bin png-embed-frame -- \
     /path/to/screenshot.png ./distributed-inference/monitor_image.frame

   Or set AEON_MONITOR_IMAGE_FRAME to another path.

Priority vs other layers: spectrogram → NOAA APT → embedded PNG → handshake voxel demo → other frames.

Use with monster-mesh

Set GNOSIS_AEON_MONITOR_BIN to an explicit path, or rely on probe order documented in rtlsdr-mock-sim/README.md. Local MCP helpers: mesh-local-mcp/README.md (gnosis_aeon_monitor_probe, gnosis_aeon_monitor_build, gnosis_aeon_monitor_set_bin, gnosis_mesh_runtime_snapshot). HTTP snapshot surface: GET /mesh/status.

Nx

From repo root: pnpm run a0 -- run distributed-inference:build-aeon-monitor.