noolog-app

Slint (Rust-native) desktop client for Noolog — a White-Flame audit-trace view over the NSED / quorum-rs multi-agent deliberation engine. Left pane = the clean client deliverable; right pane = the full deliberation trace (the centerpiece). See docs/SPEC.md for the product spec and docs/IMPLEMENTATION_NOTES.md for how the shipped engine schema maps onto it.

Architecture

One package (lib noolog_trace + bin noolog) over a workspace of pure helper crates. The evidence/logic layers are headless (SPEC §4 M1 — CI-provable without Slint or a GPU); only the bin pulls the renderer.

Target / crate	What	GPU
lib noolog_trace	headless model: wire types, TraceGraph (+ agent_phase/claim_tally/flagged_claims/dissents/final_agreement/compliance/transcript_*), convergence, reveal, budgetwire, loader, demo, auth launch-gate	none — CI-provable
crate noolog-graph	pure layout + report logic: swimlane/branch DAG, matrix, blame, transcript + compliance + CSV rendering	none
crate noolog-ui	the @noolog_ui Slint component library (White-Flame widgets, theme from design/tokens.json)	—
crate noolog-3d	portable 3D noosphere (deps-free core + glow GL backend behind a flag)	GL (opt)
crate noolog-web	WASM build of the shell for phone/PWA preview	femtovg
bin noolog	Slint shell: Split-Brain UI, base-trunk audit trace, compliance console, live SSE + budget poll, desktop biometric unlock	femtovg / software

flowchart LR
  SSE["GET /job/{id}/stream (SSE)"] --> W[wire::DeliberationEvent]
  JSONL["captured .jsonl / demo"] --> W
  W --> TG[model::TraceGraph]
  BUD["GET /deliberation/{id}/budget (~4s poll)"] --> P
  TG --> P[main::present]
  P --> UI[Slint shell: console · audit trace · evals · agents]
  TG --> CMP["compliance() / transcript_*()"]
  CMP --> EXP["Export .md + rounds.csv (~/Downloads)"]
  TOK[design/tokens.json] -->|build.rs| TH[ui/theme.slint]
  TH --> UI
  TOKN["~/.nsed/operator.token"] --> GATE["auth::launch_gate"]
  GATE -->|lock on| BIO["biometric unlock (Touch ID / Hello)"]
  BIO --> UI

Server auth stays invite/token redeem; biometrics is a LOCAL guard on the stored token (web/PWA WebAuthn is a separate track, T013). The headless core is deliberately independent of the heavy quorum server crate: src/wire.rs mirrors the exact SSE payloads so the evidence layer builds and tests with only serde + serde_json — no axum/nats/LLM graph, no GPU.

Renderer policy — NO Skia

Skia is banned (Google-origin). Cargo.toml pins renderer-femtovg (GPU tier-1) + renderer-software (CPU / headless-CI fallback); never renderer-skia. See docs/RENDERER.md. Run with SLINT_BACKEND=winit-femtovg (or winit-software).

Build / run / test

# Headless evidence layer — no Slint, no GPU (this is what CI gates on):
cargo test --no-default-features --lib

# Full build + tests (Slint shell included):
cargo test
cargo build --release

# Run the demo (labelled in-repo deliberation, no server needed):
./target/release/noolog                 # or: cargo run

# Replay a captured SSE stream. One JSON object per line; `data` must be a JSON
# object (not a stringified payload), e.g.:
#   {"event":"round_summary","data":{"round":1,"convergence_score":0.9,"proposal_scores":[]}}
./target/release/noolog --stream capture.jsonl

# Live: stream a running job from the orchestrator:
NOOLOG_BASE_URL=https://api.peeramid.xyz NOOLOG_TOKEN=… ./target/release/noolog --job <job_id>

Previewing the UI (slint-viewer) vs running the app (cargo run)

# Static visual + compile check of every screen with MOCK data:
slint-viewer --library noolog_ui=crates/noolog-ui/ui demo/preview.slint

The slint-viewer preview is a visual/compile check only — it renders the screens from demo/preview.slint's mock data with no Rust backend. Purely-Slint interactions work there (screen switch via the top toolbar, thread fold/focus/collapse, keyboard nav, flame transitions), but anything host-driven does not run in the preview:

• text search (Slint has no substring match → filtering is Rust-side),
• mailbox counts and the live network fetches (inbox list, policy catalog, budget),
• launching / streaming a real job.

For the interactive app with all of that live, use cargo run (Demo mode, the labelled in-repo deliberation) or --job <id> against a real orchestrator. The demo gate in this repo only checks that preview.slint compiles, not that it's functional.

Dev workflow

make help            # list common commands
make install-hooks   # pre-commit gate: cargo fmt --check + clippy -D warnings
make ci              # run the CI gates locally (fmt-check -> clippy -> tests)
make headless        # fast: build + test the no-GPU core only

Crash diagnostics: any panic is appended to ~/.nsed/crash.log (message + location + backtrace, captured even without RUST_BACKTRACE). If the app crashes on an interaction, send that file — it points straight at the source line.

CI (.github/workflows/ci.yml, GitHub-Actions compatible) runs the same gates: format, clippy (-D warnings), the headless core (no system deps), the full Slint build/test, and a spell check.

Design tokens

design/tokens.json is the single source of truth for the White-Flame palette/typography/motion. build.rs generates ui/theme.slint (git-ignored) from it; the landing's css/tokens.css must derive from the same file or screenshots drift (SPEC M2). See docs/DESIGN_TOKENS.md.

Deploy

Distributed desktop binary (release binaries), not a web service — only the landing is a container-platform deploy (SPEC §5). This is a UX demonstrator of the already-shipped engine.