SPICE Boards

V25.102 the Training Academy leaderboard: the score each (role, model) earned on the agent discovery+usage drills (the IAcademyLedger model, filled by Tool.TrainingDrill). 'Can our agents use the city?'

Agencies board (the IAgencyBoardBuilder model).

Evolution (recent cycles) + architecture wisdom, shaped by XQuery over the spine and rendered by the central BoardController.

Per-actor competency matrix (qualified skills, composite vs direct) - the ICompetencyMatrixBuilder model rendered as a board.

V25.103 Commerce probe: the willingness-to-pay meter - the city's real LLM spend (IRouterCostStore) re-expressed as prepaid credits burning down against a granted balance (the SaaS credits unit). A pure read-lens, no payment integration; tests the money model cheaply without the heavy hosted app.

The operator's managed daily intelligence brief on the bridge: today's brief (and recent ones) - title, topic, confidence, the findings each with its why-it-matters, key signals and sources. Reads the ContentType.ResearchReport rows Phase.DailyBrief lands on Engineering/DailyBriefings (Daily Intelligence P2).

Cross-site dataflow board (the IDataFlowBuilder model).

The software-development ledger as a served surface: the Planned queue plus the recent Shipped log, projected live from plans/cycles.xml (the corpus folds it in). Served at /board/cycles; XML twin at /board/cycles/data. Agents read the same rows via Tool.XQuery over //Cycle.

The ULS Viewer: the newest trace entries, filtered by level, category or correlation.

Pipeline / cost efficiency board (the IEfficiencyBuilder model).

The eval ship-gates made visible: which capabilities have eval coverage + each one's latest verdict (the gate-relevant state), and the recent verdict history with scores and failed assertions. Reads the EvalResult rows the Eval heartbeat lands on Hub/EvalResults.

The Fuel gauge: token budget vs spend per provider, the money (token spend + subscriptions), and live system load - CPU, memory, disk and DB size - with low-fuel / disk warnings (the IFuelBuilder model). 'See the fuel.'

The Artifact Gallery: the things the city actually made, as cards - sealed package, content roster, lineage and a product preview (reuses the IProductionStatsBuilder model). The Observatory's 'see the actual things made' lens.

Capability-gap board (the IGapBoardBuilder model).

The eval loop: a per-district health band + score + trend from run-outcome, bus done/fail/gap and throughput (the IHealthBuilder model) - outcomes outweigh activity, so a busy-but-failing district reads red. The Observatory's 'are we winning' lens.

The agent-interaction graph: the Hub bus as who-talks-to-whom weighted edges (the IInteractionsBuilder model), rendered as a Mermaid flowchart. The Observatory's agent-interaction lens.

What the platform knows about itself: the spine graph's node types, the type-level topology, its most-cited nodes and its dangling targets (the IKnowledgeGraphBoardBuilder model over the registered GraphStore).

V25.96 the Wisdom Library: wisdom the city produced and filed at run time (the IWisdomLedger model, filled by Tool.DualDispatch). The read half of the Wisdom-of-the-Day loop.

Content/work lifecycle board (the ILifecycleBuilder model).

Logical machine catalog board (the IMachineCatalogBuilder model).

Agency comms / message-bus board (the ICommsBuilder model).

One node's deep detail by id: an agency's member agents, or an agent's named skill-seats + goal/model/cost. Lazy-fetched by the inspector via /observatory/node?id=; the id is injected at the %%ID%% placeholder by the host controller.

Operator onboarding / readiness board (the IOperatorReadinessBuilder model).

Agency organogram board (the IOrganogramBuilder model).

Cost-per-outcome + true delivery rate (the IOutcomeBuilder model): per-operator and per-agency delivered/failed/abandoned outcome rate, cost-per-outcome for the cost-bound grain (production runs), and the sealed-ArtifactPackage priceable subset. The keystone metering surface - distinct from Board.Efficiency's per-call cost.

Per declared Phase: what holds it to its promise - PublishGate (graded before persist), DeliverFinalTo (the engine delivers), OutputSchema (typed), OutputList (it lands) - and WHICH SKILL it runs. A Phase with no UsesSkill does not fail, it guesses: PhaseOrchestrator falls through to roster keyword scoring, so the phase can silently run a different capability than its Goal describes. The engine-guaranteed-outcome bet made countable. Served at /board/contracts; XML twin at /board/contracts/data.

Production runs + sealed ArtifactPackage genealogy (the IProductionStatsBuilder model).

The Observatory Quest Board: a game-like 'things to do' panel so the city always offers a next action. Every quest is PROJECTED from real spine state (the IQuestBoardBuilder model) - pending approvals, open capability gaps, each declared agency - plus the always-available entry-point quests declared as data in Scope.Quests. A pure read-lens, never a hardcoded to-do list.

V25.99 the City Registry (Yellow Pages): every tool's mission, required/optional inputs, output, taxonomy path and access level - the human view of Tool.Registry. Grouped by taxonomy.

The research library: every KnowledgeArticle in the spine - daily probe intel, filed wisdom (KB.*), and the bio-cognition research. Consult it from the Observatory (Research lens) or at /board/knowledge; served as XML at /board/knowledge/data.

The second brain's Search Center: the available result sources (SavedQuery parts) + recent knowledge, plus an ad-hoc XQuery search over the spine (POST /board/search/run via Tool.XQuery). Saved searches persist on the Hub SavedSearches list.

Department seats x qualified operators - Uncovered / Covered / Replaceable (the ISeatCoverageBuilder model).

How to use SPICE - the curated onboarding manual for the operator and the agents: the daily loop, the concepts, the agent operating rules, the dev setup. Served at /board/manual; XML twin at /board/manual/data. The same chapters are agent-readable via Tool.XQuery KnowledgeByTag('manual').

V25.103 the Office of Strategy: the Chief Strategy Officer's advisory verdicts - what to build first/when over the live readiness scorecard (the IStrategyLedger model, filled by Tool.Roadmap). Honest by design - refuses a confident verdict on thin signal and excludes its own district (#30).

The work made visible: a task-focused slice of the Hub bus (Task/MultiTask) grouped by status (the ITasksBuilder model). The Observatory's tasks lens - 'can we see the tasks'.

The Observatory scene-graph, projected from the spine: a Node per district/agency/agent/board plus fixed core anchors. Served as XML at /board/station/data; rendered by Station.xslt at /board/station; consumed live by observatory-scene.js.

V25.103 Mission Control: the city's WHEN dimension - every recurring standing order (Scope.CrewStandingOrders) with its cadence and NEXT fire time, framed by the latest Strategy verdict (what-next) and the Board.Health headline (winning?). Fills the missing schedule-timeline / control-tower lens; reuses the scheduler's own order source + IStrategyLedger + IHealthBuilder.

The playable RTS: the whole game definition served as one XML document - a literal GameDef (units/buildings/ages/techs/AI), the HomeCity projected from the live spine (real agencies and actors seed the player faction), and the combat/tech-gate DecisionTables serialized into Rules. XML at /board/warfront/data; the game shell at /board/warfront; the engine is /js/game/ (which holds zero game data).

Gold, silver, the mega-caps and the index/world ETFs: latest recorded price per instrument, the move since its previous close, and a sparkline over the recent closes. Fed by Schedule.QuoteHarvest (22:10 UTC, after the US close); change what is watched in Scope.Watchlist.

Workflow diagram board (the IWorkflowDiagramBuilder model).