Fifteen screens, three surfaces, one operating system.

The landing surface. Every active report — brief, pressure test, cold read — shows up as a card with client, version, archetype, status, rubric binding, and where the viz pipeline currently sits. Five-stat strip up top: active reports, drafts, in review, published-week-to-date, unresolved comments.

Filters by client, archetype, status, editor, and date range. The "pinned" pilot stays visible. One primary CTA — New Report — kicks off intake.

Paste, dictate, or forward — the intake accepts anything. The system extracts client, cadence, archetype (Editorial Brief / Pressure Test / Cold Read), the declared peer set, the rubric version, and the open questions. The right pane plays it back as a structured read-through so the operator can confirm or correct before generation.

The three archetype cards at top-right make the grammar visible: Editorial is declarative (the argument exists, make it). Pressure Test is adversarial (the argument is weak, name what breaks). Cold Read is exploratory (there is no argument yet, find one).

The generation surface is the inside of the machine, shown. As each section composes — Hero, Numbers Spine, Stack Rank, Gap Analysis, Brand Power — the operator sees the running state, the citations pulling in, and the rubric checks passing or gap-flagging. Nothing hidden. Nothing generated without a source.

The bottom panel is a live transcript; every claim, every rubric verification, every gap-flag emits a line. If the operator needs to steer, they type directly into the steering box on the right — e.g. "In §E, sort the rubric table by agentic tier first."

The editor. Left pane is the Section Inventory — the 19-section grammar, each with its status (ready, stale, gap-flagged). Middle pane is the document itself, rendered as the client will see it, but fully editable. Right pane is the Talk to the draft conversation — the operator edits in prose, not keystrokes.

Comments (Diana's, Nuri's, Limore's) thread against sections. Headline chrome at top exposes the command vocabulary: stack rank by loyalty-weighted betweenness, demote to optional, emit gap-flag. Three-layer command surface built out: hover quick-actions, slash palette, help drawer.

The rubric is not a style guide — it's a contract. Every KPI-bearing paragraph must have a declared source, a tier, a resolution, and a publication gate. Rubric Studio is where an operator authors and binds those rules to a vertical ("SAP Services v0.2"), commits a version, and traces every call-site across the corpus.

On miss, the engine emits a gap-flag. On hit, the paragraph clears the gate. This surface was the unlock for making generation auditable — without it, "the report has numbers" becomes "we hope the numbers are right."

The client-facing output. What an operator makes inside the Studio ships here. Editorial long-form — hero, How to read, Decision Snapshot, Numbers Spine, Stack Rank, Pipeline, Gap Analysis, Brand Power Pentagon (now SAS), Who Does, Me Together, Closing. Every number clickable back to its source; every chart resolvable as a standalone viewport via the Viz Hub.

Share, Print, Download PDF built into the chrome. Right rail is the section contents, always visible. The brief becomes a document that a CMO, a CRO, and an analyst each get what they need out of.

Every brief is version-controlled at the section level. Versions surface tracks every revision, who made it, what changed, why it changed, and what moved downstream (rubric bindings, viz viewports, source tier). The timeline reads like a git log rendered in Playfair — which is, literally, what it is.

Two-pane: timeline on the left, diff detail on the right. The "what changed" pane carries short composed rationale, not opaque JSON — because Limore and Nuri are the readers, not me.

The roster. For the micro-drama pilot: sixteen companies scored across six dimensions — Content & IP (25%), Market Presence (20%), Revenue (20%), Momentum (15%), Tech (10%), Brand (10%). Trailing-90 evidence window. Re-ranked monthly. Next scan date stamped.

The page is a stack-rank deliverable in its own right — but more importantly, it's the intake input for every brief we write in that vertical. When TruData gets scored, it's scored against this ranking, not against a set we invented on the fly.

Every brief ships with a method companion. The appendix documents scope, ontology version, entity & relation definitions, rubric composite weights, metric definitions, gates and guardrails, panel composition, source ledger, changelog, known limitations, glossary. This is the document a skeptical reader should be able to pick apart — and the one the next issue will be diffed against.

It also serves as the client-proof for the methodology layer. When a CMO asks "where did the 0.828 modularity come from?" — this is the page that answers it, with every denominator visible.

The hub index. Five stat tiles up top — documents in corpus, topical clusters, modularity Q, strategic gaps, peers in vertical — render the quantitative shape of the argument. Below: six viewport cards, each navigable to its interactive view.

Crucially, this is the client-facing surface. Anything Studio-internal (rubric authoring, version diffs, steering transcripts) stays out of the Hub.

Ninety-eight documents, sixteen clusters, modularity 0.828. The topology viewport is the foundation — it's what tells the operator that the vertical has structure, what the clusters are named, and which bridges carry the strategic weight. Interactive focus + pin on click. Bridge terms called out in the legend.

Every other viewport is a lens on this graph. Gap Radar reads it as severity × tractability. Peer Stack reads it as competitive posture. Pentagon reads it as brand power dimensions. Same graph, rotated.

Gaps plotted on severity × tractability. Connective lines show which gap compounds into which — G1 is the target, G2 is the lever that unlocks G1, G3 is the follow-on. Register on the right gives each gap a title, headline claim, and the two quantitative marks that make it real (e.g. Unaided recall 22 vs peer 58).

This is the viewport the CMO reads first. Three gaps is the tractable number; each gets priced as a move.

The Structural Advantage Score (SAS) rendered as a pentagon across five dimensions: awareness, trust, mission, differentiation, loyalty. Per-vertical weighting profile. Comparable to peer median so the reader sees where the subject structurally wins and loses — not on a 0-to-100 composite, but on the specific axes.

Note: SAS is the rename. BPS was the working title; v0.2a froze SAS as the canonical term. The screen retains BPS in the URL slug for now.

The declared peer set plotted on the two axes that actually discriminate in this category — pipeline × extension posture. TruData sits low-left. Movement north-east is the thesis. The peer table on the right shows the full ranking with pipe, ext, BPS, and subject highlighted in critical red.

This is where "we rank 6/6" becomes a visualization the client understands. It's also where the Stack Rank feeds in as the intake artifact — the peer set was not chosen by us, it was inherited from the vertical.

The composite viewport. All five prior views collapsed into a single analytic surface: topology shape (quant), gap register (list), SAS pentagon (scored), peer stack (positional), and the stack rank (ordinal). This is the one the analyst opens when she wants the whole picture in one place.

Also the surface we'll use to let advanced clients query — the composite is where the generative hooks sit (what-if this peer, what-if this rubric, what-if this gap).