ratatoskr/docs/contracts/web_debug_surface.contract.md

contract_version, module, purpose, target_module, scope, depends_on, used_by, language, complexity, estimated_loc, confidence, assumptions, functions, invariants

contract_version	module	purpose	target_module	scope	depends_on	used_by	language	complexity	estimated_loc	confidence	assumptions	functions	invariants
2.1	ratatoskr.web	v0.19.2 web debug-surface parity: 3 admin/debug panes (Tools inventory, BifrostState, AdminEvents SSE) proxied server-side with the admin key server-held, plus a reliable PAD-refresh poll and a non-engine reasoning indicator in the transcript.	ratatoskr.web (server.py routes + entrypoint.py + static/index.html)	v0.19.2 web debug-surface parity — bring the browser surface (now the PRIMARY debug surface) to TUI parity. THREE new admin/debug panes proxied server-side + TWO transcript affordances. (1) Tools inventory: GET /api/sessions/{id}/tools proxies owner-scoped get_session_tools into the tools pane (what the LLM HAS at turn-fire), above the live tool events. (2) BifrostState pane: GET /api/sessions/{id}/bifrost proxies admin-scoped get_session_bifrost; the admin key is SERVER-HELD (app.state.admin_key from RATATOSKR_ADMIN_API_KEY), never sent to the browser. (3) AdminEvents pane: GET /api/admin/events is an SSE proxy of stream_admin_events, session-filtered SERVER-side (heartbeats + other-session events dropped), re-emitted under a fixed 'admin_event' name so every dotted type renders with one browser listener. (4) PAD refresh: the persona/affect pane polls a bounded window instead of a single 2s shot that raced the post-turn-async affect.emit. (5) Reasoning indicator: an ephemeral, clearly-non-engine transcript line on `thinking` deltas, cleared when text begins. Direct in-session TDD (the #17/#18 pattern); this contract is authored post-implementation to anchor the heid code review (the client wrappers get_session_tools/get_session_bifrost/stream_admin_events are already contracted in the sessions/sse_client specs — this contract governs the WEB proxy + presenter surface only).	httpx starlette ratatoskr.sessions ratatoskr.sse_client	ratatoskr.web.entrypoint	python + vanilla JS (single-file SPA, no build)	medium	290	0.8	The three client wrappers exist and are already contracted: get_session_tools(client, session_id)->dict (owner-scoped, consumer bearer; non-200 -> SessionApiFailed), get_session_bifrost(client, session_id, *, admin_key)->dict (OVERRIDES Authorization with admin_key; non-200 -> SessionApiFailed), stream_admin_events(client, *, admin_key)->AsyncIterator[AdminEvent] (non-200 -> SseConnectFailed; mid-drop -> SseConnectionDropped). The web routes are thin proxies over them; they add NO new upstream semantics. AdminEvent = {id:int, type:str, timestamp:str|None, data:dict}. data MOST carry session_id (INV-049). type is a dotted namespace (session.*/turn.*/key.*/system.*). The web SPA is a single static/index.html served per-request via FileResponse (edits land on browser refresh; server code changes need a restart). Model/tool/admin content is UNTRUSTED text (INV-004) — every render path escapes first (esc() via textContent, or JSON.stringify wrapped in esc()). The internal-LAN trust model (0.0.0.0, no auth/TLS/CORS) is deliberate operator direction. Admin-scoped DATA becoming LAN-visible is accepted under that model; the admin KEY must nonetheless never cross to the browser. Tests: respx mocks the upstream endpoints (absolute w.example URLs) driven through the TestClient; the AdminEvents SSE proxy is tested with a finite mocked SSE byte-stream asserting the filter + fixed event name. Live-proven against ratatoskr:sindra on personal :8081.	name signature description preconditions postconditions steps flexibility _session_tools_endpoint async _session_tools_endpoint(request: Request) -> JSONResponse GET /api/sessions/{session_id}/tools — proxy owner-scoped tool inventory. session_id in path_params. POST-001: 200 with the upstream inventory dict verbatim on success. POST-002: on SessionApiFailed(status) -> JSONResponse({error_code:'session_tools_unavailable', status}, status_code=status) — status-preserving. Open client_factory() client; await get_session_tools(client, session_id); return 200. Except SessionApiFailed -> status-preserving envelope. prescriptive name signature description preconditions postconditions steps flexibility _session_bifrost_endpoint async _session_bifrost_endpoint(request: Request) -> JSONResponse GET /api/sessions/{session_id}/bifrost — proxy admin-scoped Bifrost dispatch state. session_id in path_params. PRE-001 (fail-visible): app.state.admin_key must be truthy; else 400 admin_key_not_configured with NO upstream call. POST-001: the admin key is read from app.state.admin_key ONLY; it is passed to get_session_bifrost(admin_key=...) and NEVER placed in a response body or surfaced to the browser. POST-002: 200 with the upstream state dict verbatim on success. POST-003: on SessionApiFailed(status) -> {error_code:'bifrost_state_unavailable', status} at status_code=status (notably 404 not-bound, 403 scope-denied). If not admin_key -> 400. Open client; await get_session_bifrost(client, session_id, admin_key=admin_key); 200. Except SessionApiFailed -> status-preserving envelope. prescriptive name signature description postconditions flexibility _admin_event_matches_web _admin_event_matches_web(ev: AdminEvent, session_id: str | None) -> bool AdminEvents session-filter (mirrors the TUI _admin_event_matches, design-brief §6). POST-001: ev.type == 'system.heartbeat' -> False (keepalive noise dropped). POST-002: ev.type.startswith('system.') (non-heartbeat) -> True (stream-integrity signals always pass). POST-003: otherwise -> True IFF session_id is not None AND ev.data.get('session_id') == session_id (per-session scoping; a None session_id forwards NO non-system event). prescriptive name signature description preconditions postconditions steps flexibility _admin_events_endpoint async _admin_events_endpoint(request: Request) -> Response GET /api/admin/events?session_id=... — SSE proxy of stream_admin_events, session-filtered server-side. PRE-001 (fail-visible): app.state.admin_key truthy; else 400 admin_key_not_configured with NO stream opened. POST-001: returns StreamingResponse(media_type='text/event-stream'); the admin key never crosses to the browser. POST-002: ONLY events passing _admin_event_matches_web(ev, session_id) are forwarded; each is re-emitted under the FIXED SSE event name 'admin_event' with {id,type,timestamp,data} in the payload (the real dotted type rides in the payload, so one browser listener renders every type — nothing silently dropped by name). POST-003: SseConnectFailed/SseConnectionDropped/MalformedSseId/MalformedSseData -> a single 'stream_error' SSE frame, then the stream ends (best-effort; never raises to the browser). POST-004: asyncio.CancelledError (browser disconnect) re-raises to unwind the generator; the upstream client is aclose()'d in finally on every exit path. If not admin_key -> 400. gen(): open client; async-for ev in stream_admin_events(admin_key); skip unless _admin_event_matches_web; yield _format_sse('admin_event', {...}). Except SSE errors -> yield stream_error. Except CancelledError -> raise. Finally aclose(). Return StreamingResponse(gen()). prescriptive name signature description postconditions flexibility create_app (amendment) create_app(client_factory, *, end_user_id=None, bifrost_consumer_key=None, bifrost_visible_host=None, affect_read_url=None, admin_key=None) -> Starlette New optional admin_key param stored at app.state.admin_key; entrypoint passes RATATOSKR_ADMIN_API_KEY. Three new routes registered. POST-001: app.state.admin_key = admin_key (default None -> the two admin routes fail-visible per their PRE-001). POST-002: routes /api/sessions/{session_id}/tools, /api/sessions/{session_id}/bifrost, /api/admin/events added; existing routes unchanged. closed name signature description postconditions flexibility reasoning indicator (index.html: showThinkingNote / hideThinkingNote) showThinkingNote() ; hideThinkingNote() // called from the turn SSE loop Ephemeral transcript affordance signalling reasoning inference — clearly NOT engine output. POST-001: on the first `thinking` delta, an italic '<Agent> <phrase>' line (✦ glyph, rotating phrase) is shown; it supersedes any live 'awaiting first token' heartbeat. POST-002: the agent display name is derived from state.agentId and rendered via textContent (NEVER innerHTML) — INV-004 holds even for an adversarial agent_id. POST-003: it is removed the instant the first `text` delta arrives, and on any terminal (done/error/cancelled); the rotation interval is cleared on removal (no leaked setInterval). prescriptive name signature description postconditions flexibility PAD refresh poll (index.html: terminal() done-branch) on Done: poll loadPersona over [1500,3500,6500,10500]ms Catch the post-turn-async affect.emit without racing it (replaces the single 2s shot). POST-001: loadAffect sets state.lastAffectAt = snap.emitted_at; the poll captures beforeAt and stops (settled) once state.lastAffectAt !== beforeAt. POST-002: a scheduled poll no-ops if a NEW turn has started (state.turnId truthy) or already settled — no refresh of a stale agent, no unbounded polling. open name signature description postconditions flexibility web pane renderers (index.html: renderToolsInventory / renderBifrostState / openAdminEvents) renderToolsInventory(inv) ; renderBifrostState(b) ; openAdminEvents(sessionId) Render the three new surfaces; all content escaped (INV-004). POST-001: every dynamic value (agent_id, tool names/descriptions, endpoint, caps, admin event type + data) is passed through esc() or esc(JSON.stringify(...)); no upstream string reaches innerHTML unescaped. POST-002: openAdminEvents closes a prior EventSource before opening a new one (state.adminES); the admin data blob renders via esc(JSON.stringify(d.data)). POST-003: renderToolsInventory prepends the static inventory ABOVE live tool events without clobbering them (a re-render replaces only the .tools-inventory block). POST-004: the Tools inventory renders tool NAMES only — a compact comma-joined summary ('what does the LLM have', the debug glance); per-tool DESCRIPTIONS are surfaced in the BifrostState pane's tools list, deliberately NOT duplicated here. (Heid panel Hulda/Regin precision finding — accepted: contract wording clarified, code unchanged; the earlier 'names/descriptions' phrasing in INV-004 refers to the SET of value types that MAY appear across the new panes and must be escaped, not a mandate that every pane render descriptions.) open name signature description postconditions flexibility renderAffectPane + trend (v0.19.4 — relation_edge/1 render + sparkline) renderAffectPane(snap) ; pushAffectHistory(snap) ; sparkline(vals) ; trendDelta(vals) Render the Tier-3 affect snapshot as PAD mood + the durable per-entity relational model, each value with a Δ-vs-previous + a session-lived sparkline. POST-001: reads snap.relations (relation_edge/1: target_entity + trust_ability/benevolence/integrity + warmth as {value,confidence,evidence_count} + agency + relation_context + obligation_balance) — the CURRENT Worldtree emit shape; falls back to the legacy flat snap.valence for an older emitter. SUPERSEDES the #18-D2 contract's valence assumption (Worldtree's #265 Vili rework replaced valence/regard with the relation_edge/trust model; the old renderer read snap.valence and showed an empty 'valence (0)' — the bug this fixes). POST-002: each metric shows current value + Δ-vs-previous (▲/▼) + a unicode sparkline auto-scaled to its OWN observed range (flat ▄ when sub-0.01 stable — no noise amplification), drawn from AFFECT_HIST (rolling, HIST_CAP=24, session-lived). POST-003: pushAffectHistory dedupes by emitted_at so the ~4x/turn post-turn PAD poll contributes ONE sample/turn; history is CLIENT-side only (lost on reload — durable cross-session history via a provider-side snapshot log is a deferred follow-up, NOT built here). POST-004: INV-001 honesty — no fabricated Tier-1 fields (no synthesized dominant_emotion). INV-004 — head() escapes its whole argument (incl. target_entity + relation_context from the snapshot) and metric() escapes every cell; numeric values go through toFixed, never innerHTML-raw. open	INV-004 (untrusted-render): ALL model / tool / admin / agent-supplied text is escaped before entering the DOM (esc via textContent, or esc(JSON.stringify)). No new render path introduces an innerHTML sink for upstream content. This is the highest-value review target — the new JS render paths are NOT unit-tested. INV-ADMIN-KEY: the admin key exists ONLY at app.state.admin_key (from RATATOSKR_ADMIN_API_KEY). It is never serialized into any response, never sent to the browser, never logged. The browser receives only the session-filtered RESULT of admin-scoped reads. INV-FILTER: AdminEvents filtering happens SERVER-side (_admin_event_matches_web) — the browser never receives the cross-session admin firehose; only active-session events + non-heartbeat system.* cross the wire. INV-FAIL-VISIBLE: both admin routes return 400 admin_key_not_configured when the key is absent — never a silent empty pane, never an upstream call with an empty bearer. INV-LIFECYCLE: SSE generators and EventSources are cleaned up on every exit path (upstream client aclose() in finally; setInterval cleared in hideThinkingNote; prior EventSource closed before re-open) — no leaked connections, tasks, or timers. INV-ADDITIVE: existing routes, panes, and the turn-stream path are unchanged; the 3 new routes + 2 new tabs are purely additive (59 web tests incl. all prior ones stay green).

v0.19.2 — web debug-surface parity (BifrostState · AdminEvents · Tools · PAD-poll · reasoning)

Context

The browser surface is now the operator's PRIMARY debug surface, and it lagged the TUI: the TUI gained Tools/BifrostState/AdminEvents panes (v0.18.9–.11) that were never ported to the web. This change closes that gap and adds two transcript affordances (a reliable PAD refresh + a reasoning indicator). The client wrappers already existed and are contracted elsewhere; this contract governs the WEB proxy routes + the SPA presenter paths, whose JS render code is not unit-tested — hence the cross-frontier code review.

Review focus (for the heid panel)

1. INV-004 escaping in every new render path — the un-unit-tested surface; the exact class of bug (renderPersonaPane fabricating a Tier-1 field) that only a cross-model review caught on #18 D2.
2. INV-ADMIN-KEY — confirm the admin key never reaches a response body or the browser.
3. AdminEvents SSE proxy (_admin_events_endpoint) — generator/filter/lifecycle: fixed event name, server-side filter, stream_error on failure, aclose() on every path, CancelledError re-raise on disconnect.
4. PAD-poll stop-condition — does emitted_at advancement + the state.turnId guard correctly stop the poll without racing or leaking timers?
5. Reasoning indicator lifecycle — shown on first thinking, removed on first text or terminal, interval cleared (no leaked setInterval), name via textContent.