The HUD — Lens and Controls

in-progress

The helmet interface — how humans see and act on the universe. A lens with controls. The mechanism chain: issues flow through streams, optionally into projects, and ship as releases.

componenthudinterfacevisorhelmet

See also: universe › overviewbrandobservatory › overviewpipeline › overviewlibrary › overview

The HUD — Lens and Controls

See also: universe | brand.md

“The helmet doesn’t just show you the universe. It lets you shape it. Every issue you create, every release you ship — that’s you reaching into the world and changing its architecture.” — Sal

Component Card


Owner	Wren
MCP	`@sector137/mcp-hud`
Slash	`/hud`
CLI	`sector137 hud`
SDK	`sdk.hud()`
Status	in-progress

TL;DR

The HUD is a lens (see the universe) with controls (act on the universe)
You manipulate the universe through a specific mechanism chain: issues > streams > projects > releases
Visor modes switch focus between Pipeline, Observatory, Library, and Comms without leaving the helmet
It’s a two-way interface: the universe sends state, the human sends decisions
Every human who has HUD access wears their own helmet — the captain, team members, stakeholders

What It Is

The HUD is the helmet. Not a screen, not a dashboard — a helmet the human puts on to enter The Other Side.

Think Iron Man’s display. Translucent, holographic, information floating in the field of vision. Panels glow softly. Data flows like starlight through fiber optics. The aesthetic is futuristic but warm — the crew built this interface for the captain, and they built it with care.

The reconciliation: The HUD is both a lens and a control panel. You see the universe through it AND you act on it. These aren’t separate functions — they’re the same gesture. Looking at the pipeline state IS understanding what needs to happen next. Creating an issue IS reshaping the universe’s topology. Shipping a release IS a cosmic event that changes what exists.

The Mechanism Chain

The human manipulates the universe through four linked actions:

Issues (Deltas)  →  Streams (Channels)  →  Projects (Worlds)  →  Releases (Events)
   create work       route + triage          organize scope         ship changes

Issues are the unit of change. Creating an issue is declaring that the universe should be different than it is. Every issue is a Delta — a discrete modification to reality.
Streams are the routing layer. Every issue flows through a stream — the value channel that carries work from intention to delivery. Unsorted issues land in the Universe Inbox until Sal triages them to a stream. A stream has a crew, a report cadence, and its own pipeline health. It is the primary organizing channel of the universe.
Projects are optional sub-groupings within streams. When a stream has enough complexity to warrant sub-division — distinct codebases, separate stakeholder audiences, independent release gates — a project creates that boundary. Not every stream needs projects. A flat stream is valid. But when structure is warranted, projects are where it lives.
Releases are the deployment mechanism. A release takes completed issues and ships them into the universe. Each release is a cosmic event — the world literally changes shape when a release publishes.

Nothing changes in the universe without this chain. You can observe all day. But to ACT — to modify the architecture of The Other Side — you create issues, you route them to streams, you scope them to projects (if the stream warrants it), and you ship them as releases.

Visor Modes

The HUD has multiple modes. Switching modes doesn’t change where you are — it changes what you’re looking at. The universe is always there underneath. Modes are overlays.

Mode	What You See	Primary Component
Pipeline	Throughput state, active issues, gates, release status	The Pipeline
Observatory	Research portal — missions, personas, prototypes	The Observatory
Library	System map — everything the universe knows about itself	The Library
Comms	Wormhole status, channel activity, broadcast state	The Wormholes
Record	Release history — the log of what shipped	The Pipeline (Record section)
Feed	Live event stream + crew briefings	Cross-cutting (all components)

Modes can overlap. The Feed is ambient — it runs across all modes as a persistent channel. Physics indicators (U_global, pipeline state) appear in every mode as HUD chrome.

Two-Way Interface

The HUD is bidirectional:

Universe → Human (the lens):

Pipeline state and health indicators
Agent activity and crew intercepts
Research findings surfaced by the Observatory
Alerts, warnings, and state changes from the Feed
The Library’s map of everything that exists

Human → Universe (the controls):

Create, prioritize, and scope issues
Set release containers and publish gates
Configure physics dials (through decisions over time)
Override crew recommendations
Open and close wormholes
Invite other humans (team, stakeholders)

Sal is the primary voice in the HUD. When the universe speaks through the helmet, it’s usually Sal — with crew intercepts when their domain demands attention. The HUD is Sal’s channel to the captain.

The Season Indicator

Status: IN DESIGN (v0.11.0 — The Season)

The active Season is always visible in the universe header — a persistent reminder of the strategic era the universe is operating under. Clicking the Season indicator opens the Season management panel.

When no Season is set, the HUD shows an empty state: “No Season set. The universe is running without direction. Define the laws.”

Seasons feel like eras in the HUD, not sprints: “The Foundation Season began March 3, 2026” — not “Created 3/3/26.” The transition confirmation is deliberate and irreversible: “Starting [New Season] will complete [Current Season]. The record is permanent.”

Spatial Metaphors

Each area of the HUD maps to a spatial metaphor in the story:

Metaphor	Visor Area	Status
The Visor	Main dashboard — pipeline state, system overview	LIVE
The Workbench	Issues, projects — where things get sorted	LIVE
The Record	Releases — the historical log of what shipped	LIVE
The Flightplan	Roadmap — what’s ahead	LIVE
The Observatory	Research portal — window back to the human world	LIVE
The Comms Array	Wormhole infrastructure — webhooks, triggers	LIVE
The Beacon	Public wormhole — signal sent to the outside world	LIVE
The Roster	Subscribers — who’s listening on the Beacon	LIVE
The Conduit	API — programmatic interface to the universe	LIVE
The Feed	Live event log + crew-voiced briefings	LIVE (two layers)
The Inbox	Universe-level inbox — unsorted issues across all streams	IN DESIGN
The Season	Active season indicator — strategic era context	IN DESIGN

Who Wears the Helmet

Not just the captain. The HUD is worn by anyone who has access to the universe:

Human Type	Helmet Access	What They See
The Captain	Full access — all modes, all controls	Everything. The god-view.
Team Members	Scoped access — their own helmet with project-level controls	Their assigned work, pipeline state, relevant feeds
Stakeholders	Invited — configurable permissions	Curated views. May see the Record but not the Pipeline internals.
Subscribers	No helmet — they see the Beacon only	Public releases, changelogs. The Beacon’s wormhole output.

Each helmet wearer sees the universe from their vantage point. The captain sees the full topology. A team member sees their sector. A stakeholder sees what they’ve been invited to see. The universe is the same — the lens is scoped.

The Helmet On, The Helmet Off

See universe — “A Note on Directionality”

The HUD is a lens, not a cell. The human exists in both the real world and The Other Side simultaneously. Putting on the helmet doesn’t trap you. Taking it off doesn’t end the universe.

When the helmet is off, the crew keeps working. The Pipeline keeps flowing. The Agents keep ticking. The wormholes stay open. The universe doesn’t pause because the captain isn’t looking. When the helmet comes back on, the Feed catches you up — where things are, where they’re heading, what needs you.

The one-way property is the work, not the access. You can close the dashboard. You cannot un-ship a release.

Implementation

Packages

Package	Description
`apps/app`	Core system — Hono server + Vite React SPA (the HUD itself)
`packages/sdk`	TypeScript SDK — all client data fetching via TanStack Query
`packages/mcp`	MCP server — agent access to HUD data

Spatial Metaphor → Client Page Mapping

Metaphor	Route	Key File
The Visor	`/dashboard`	`universe-hud.tsx`
The Workbench	`/work/issues`	`issues.tsx`
The Record	`/work/releases/log`	`releases.tsx`
The Observatory	`/intel`	`kano.tsx`, `intel-missions.tsx`
The Comms Array	Settings > Webhooks	`settings-webhooks.tsx`
The Beacon	Settings > Embed	`settings-embed.tsx`
The Roster	`/work/releases/subscribers`	`subscribers.tsx`
The Conduit	Account > API Keys	`settings-api-keys.tsx`
The Feed	`/dashboard` (Briefing Widget)	`briefing-widget.tsx`, `universe-hud.tsx`

Live Data Flow — Context Bus Wiring

The Visor receives a real-time signal via the Context Bus on every Tick. useNatsRealtime(projectId) invalidates the crew-activity and universe-health query caches in TanStack Query — the Visor updates without a user action or a scheduled poll.

Polling intervals are reduced now that the Context Bus handles tick-driven freshness:

Component	Polling Interval	Note
The Feed (event log)	30s	Was 15s — Context Bus covers tick-driven updates
Crew Activity panel	120s	Was 60s — Context Bus invalidates on each tick
U_global / pipeline state	On Context Bus signal	No timed poll; signal-driven only

See apps/app/client/src/hooks/use-nats.ts for the implementation.

Component Ownership

Primary owner: Sal (Software Sal) — orchestration, pipeline state display, briefing generation, crew intercept routing Secondary: Wren Glasswork — design authority, visor aesthetics, UI quality bar

The HUD is Sal’s primary channel to the captain. Every piece of information the universe communicates to the human passes through here. Wren holds the aesthetic bar — the visor should feel like a well-designed instrument, not a dashboard of noise. HUD queries should be fast; default_model defaults to the lightweight Haiku model for snappy UI-layer responses.

Actions

Sync (immediate, user-triggered)

Switch visor mode (Pipeline / Observatory / Library / Comms / Record / Feed)
Create an issue via HUD quick-add
View pipeline state, U_global, domain dials
View crew activity panel
View active release status
Open briefing widget
Navigate to any component via visor

Async (dispatched, background)

AI-powered inbox triage — Sal surfaces what needs human attention from the event stream
Briefing widget generation — Sal + crew compose the current state narrative
Crew intercept rendering — agent voices surface relevant actions or alerts

Background — Tick Engine (automatic, per-cycle)

Compute U_global for the HUD pipeline state indicator (triggered via the Context Bus)
Refresh briefing widget on each Tick — crew intents become the briefing narrative
Surface escalations — CONSTRAINED or DEGRADED states shift the HUD indicator from Beacon green to Flare orange
Context Bus signal drives TanStack Query cache invalidation — no polling required for tick-driven freshness

MCP Tools

Tool	Owner	Purpose
`list_universes`	Sal	Universe registry — list all universes for the current account
`get_universe`	Sal	Fetch a single universe with metadata
`create_universe`	Sal	Create a new universe
`list_projects`	Sal	List all projects (value streams) in the current universe
`get_project_tags`	Sal	Fetch all project tags — needed before assigning `tagIds` to issues
`get_issue_stats`	Sal	Pipeline state panel — issue counts by status
`get_issues_by_status`	Sal	Pipeline kanban panel — issues grouped by status
`get_active_release`	Sal	Release indicator — current active or draft release
`list_agents`	Sal	Crew panel — all agents in the universe with their status
`activate_agent`	Sal	Crew management — set agent status to active
`deactivate_agent`	Sal	Crew management — set agent status to inactive

Events

The HUD orchestrates but does not emit its own events — it surfaces events from other components. When a Pipeline event fires or a Tick completes, the HUD receives it and updates the display.

Consumed events (from other components):

All Pipeline events (issues, releases, agent dispatches, conductor alerts)
Observatory events (persona sessions, mission completions)
Wormhole events (channel status changes, broadcast confirmations)
Tick Engine completion (via the Context Bus → TanStack Query cache invalidation)

Future HUD-native events (IN DESIGN):

Event	Triggered By	Actor	Downstream	Status
`hud.briefing_generated`	Sal composes the morning briefing	Sal	Feed, notification if human is offline	IN DESIGN
`hud.visor_switched`	Human changes visor mode	Captain	Analytics, personalization	IN DESIGN
`hud.escalation_surfaced`	Sal taps the captain on the shoulder	Sal	Feed alert, indicator shift	IN DESIGN

Blueprint Schema

HUD layout preferences are IN DESIGN for Blueprint representation. When implemented, universe-level HUD defaults will live in the [hud] section of universe.toml.

TOML key	Type	Default	Status
`hud.default_model`	string	`"claude-haiku-4-5-20251001"`	IN DESIGN
`hud.default_visor`	string	`"pipeline"`	IN DESIGN
`hud.sidebar_collapsed`	boolean	`false`	IN DESIGN
`hud.density`	string	`"comfortable"`	IN DESIGN

[hud]
default_model = "claude-haiku-4-5-20251001"   # Fast model for UI-layer queries
default_visor = "pipeline"    # pipeline | observatory | library | crew
sidebar_collapsed = false
density = "comfortable"       # compact | comfortable | spacious

Notes:

default_model uses the lightweight Haiku model — HUD queries should be fast. Override per [[crew]] entry for Sal with the model key.
Per-user visor preferences override universe defaults. The [hud] config is the fallback for new sessions and team members who haven’t set their own preferences.

Tracked in: “Blueprint: Add [hud] section — visor defaults and layout config”