figura-cli 0.16.1 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "figura-cli",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Command-line client for the Figura visualization SaaS",
   "license": "MIT",
   "type": "module",

package/skills/fig/SKILL.md

@@ -2,7 +2,7 @@
 name: fig
 description: "Mock up a screen as an on-brand, shareable HTML fig via your Figura team — render a UI state in seconds before writing the real code. Use when asked to visualize a screen, mock a UI, or 'make a fig'. iPhone-framed by default; browser frame for web/desktop."
 argument-hint: '<what to visualize>'
-allowed-tools: 'mcp__figura__figura_whoami, mcp__figura__figura_generate_fig, mcp__figura__figura_create_fig, mcp__figura__figura_revise_fig, mcp__figura__figura_publish_fig, mcp__figura__figura_commit_fig, Bash(figura *), Bash(bunx figura-cli *)'
+allowed-tools: 'mcp__figura__figura_whoami, mcp__figura__figura_fig_scaffold, mcp__figura__figura_generate_fig, mcp__figura__figura_create_fig, mcp__figura__figura_revise_fig, mcp__figura__figura_publish_fig, mcp__figura__figura_commit_fig, Bash(figura *), Bash(bunx figura-cli *)'
 ---
 
 # /fig — figure it out before you build it
@@ -102,16 +102,26 @@ so you hand it the studied structure in the brief (see step 3, "Server render").
      re-verify. If the response has no `binding` field (older CLI/MCP), confirm
      the team slug matches this project with the user before proceeding.
 
-2. **Default — build it yourself, with YOUR Claude.** Fetch the team's design
-   system — `bunx figura-cli brand --json` — and hand-build the fig's HTML against
-   it, then land it with **`figura_create_fig`**, setting
-   `area`, `orientation` (`portrait` / `landscape` / `both`), `mode` (`single` /
-   `compare` / `variations` — default to `compare` when Existing-first turned up a
-   baseline), `title`, and a real description. This uses the
-   caller's own Claude (the model running this skill) — no extra cost, full control
-   for precise broken-vs-proposed diptychs — and applies the team's brand from the
-   fetched design system. **Follow that design system verbatim; never invent brand
-   values.**
+2. **Default — build it yourself, with YOUR Claude.** Fetch the **canonical
+   authoring scaffold** — **`figura_fig_scaffold`** (CLI:
+   `bunx figura-cli fig scaffold --platform <mobile|web> [--device <id>] [--area <str>]`)
+   — and hand-build the fig's HTML against it, then land it with
+   **`figura_create_fig`**, setting `area`, `orientation` (`portrait` /
+   `landscape` / `both`), `mode` (`single` / `compare` / `variations` — default
+   to `compare` when Existing-first turned up a baseline), `title`, and a real
+   description. This uses the caller's own Claude (the model running this skill)
+   — no extra cost, full control for precise broken-vs-proposed diptychs.
+
+   The scaffold IS the source of truth: it's the **exact system prompt Figura
+   injects when it renders a fig server-side** — the design rules, exemplars,
+   accent hints, your team's composed brand, and the component/device kit
+   context, all in one. Follow it verbatim; never invent brand values or restate
+   design rules from memory. Match `--platform` to the target (a web fig's
+   scaffold composes the team's *web* brand surface, a mobile fig's the *mobile*
+   one). **Fallback if the scaffold fetch fails** (older engine/CLI, or the
+   `figura_fig_scaffold` tool is unavailable): fetch just the brand with
+   `bunx figura-cli brand --json` and author against that — the scaffold is the
+   preferred path, the raw brand is the degraded one.
 
    **Landing IS hosting — leave `publish` and `commit` unset.** Creating a fig
    always persists it to Figura (there is no separate "save it for real" step);
@@ -332,8 +342,9 @@ So when you **hand-build** a fig (the default path), do your part of the contrac
 - **MCP unavailable** (headless / cron, or no interactive auth): fall back to the
   CLI — `bunx figura-cli fig create` / `fig publish`, with `fig revise` /
   `fig revisions` for versions, `fig commit` / `fig uncommit` (or `--commit` on
-  the final create/revise) for the team library, and
-  `bunx figura-cli brand --json` for the brand.
+  the final create/revise) for the team library, `bunx figura-cli fig scaffold`
+  for the authoring scaffold, and `bunx figura-cli brand --json` for the raw
+  brand (the scaffold's fallback).
 - **`figura_create_fig`/`figura_revise_fig` itself fails** (no network, API down,
   auth expired): the fig never entered Figura, so there is no `id`/`viewUrl` to
   open. Only THEN write the HTML to a local scratch file (project-scoped —

package/skills/figura-brand/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: figura-brand
-description: "Introduce a repo to Figura — scan the codebase for its design system (design tokens, brand docs, app name) and set the team's Figura brand profile so generated figs are on-brand. Use when asked to import or sync a brand, set up Figura for a project, or 'introduce my repo to Figura'."
+description: "Introduce a repo to Figura — scan the codebase for its design system (design tokens, brand docs, app name) and set the team's Figura brand profile (STRUCTURED) so generated figs are on-brand. Use when asked to import or sync a brand, set up Figura for a project, 'introduce my repo to Figura', or upgrade an existing prose brand to structured."
 argument-hint: '[path to the repo or design-system directory]'
-allowed-tools: 'Read, Grep, Glob, Bash(figura *), Bash(bunx figura-cli *)'
+allowed-tools: 'Read, Grep, Glob, mcp__figura__figura_whoami, mcp__figura__figura_brand_schema, mcp__figura__figura_set_brand, Bash(figura *), Bash(bunx figura-cli *)'
 ---
 
 # Figura Brand — introduce a repo to Figura
@@ -12,6 +12,18 @@ profile** from it, so every fig the `/fig` skill / generator produces is on-bran
 You (Claude) do the synthesis — read the code and docs, then push the result. No
 figura.so UI.
 
+Author a **STRUCTURED brand** — a `{ identity, platforms }` object (colors, type,
+voice, per-platform surfaces) — not freeform prose. Structured is addressable,
+platform-partitioned, and versioned; prose is the fallback for when structured
+synthesis genuinely isn't possible.
+
+**The shape authority is the SERVER schema, not this doc.** Fetch it and author
+against it so the brand validates first try:
+`figura brand schema` (CLI) or the `figura_brand_schema` MCP tool → the JSON Schema
+`PUT /brand` validates. `reference/brand-format.md` is a short orientation +
+worked example only; the fetched schema is the source of truth for field
+names/shape/caps.
+
 `$ARGUMENTS` is an optional path to focus on (a repo root or a design-system
 directory). Default to the current repo.
 
@@ -33,6 +45,9 @@ here first. The brand is **team-wide and overwrites** the current one — never
 push without showing the user what you're about to set and getting an explicit
 OK.
 
+> **Upgrading an existing prose brand instead of a fresh import?** Jump to
+> [Upgrade a legacy prose brand to structured](#upgrade-a-legacy-prose-brand-to-structured).
+
 ## Workflow
 
 ### 1. Scan the repo for design signals
@@ -47,72 +62,145 @@ Hunt across whatever stack this repo uses — do not assume one framework:
 - **Brand voice + positioning** — `BRAND.md`, `STRATEGY.md`, design-system READMEs, marketing copy, the landing page hero. Capture the tone and any explicit voice lines / taglines.
 - **Identity** — app/brand name + one-line description: `package.json` (name/description), `Info.plist` (`CFBundleName`), app-store copy, the README's first paragraph.
 - **Role/usage notes** — inline comments next to tokens often state the role
-  (e.g. `// primary brand accent; record button`). Carry those into the tokens block.
+  (e.g. `// primary brand accent; record button`). Carry those into `color.role`/`meaning`.
+- **Signature components** — the product's distinctive UI pieces (a scrubber, a
+  reaction button, a dense data table), from component files — become
+  per-platform `components[]`.
 - **Product areas** — the app's own top-level sections, e.g. a tab bar, a
   sidebar's nav items, or the router's top-level route folders (`app/(tabs)/*`,
-  `src/routes/*`, `src/screens/*`). These become `surfaces` — THIS product's
-  real areas ("Feed", "Checkout"), never a generic placeholder list and never
-  another product's areas.
+  `src/routes/*`, `src/screens/*`). These become each platform's `surfaces[]` —
+  THIS product's real areas ("Feed", "Checkout"), never a generic placeholder
+  list and never another product's.
+- **Which platform(s)** — detect the target platform(s) so you only emit the
+  surfaces that apply:
+  - `mobile` — an iOS/Android/React-Native/Expo app (`*.xcodeproj`, `Info.plist`,
+    `android/`, `app.json`/Expo, SF Symbols usage, safe-area/tab-bar tokens).
+  - `web` — a web app / site (`index.html`, a web router, CSS media queries,
+    hover states, a `tailwind.config`).
+  - `desktop` — an Electron/Tauri/native-desktop shell.
+  - A product can target more than one — emit a `platforms` key for each.
 
 Use `Glob`/`Grep` to locate, `Read` to extract real values. Use the REAL hexes,
 fonts, and sizes from the repo — never invent them.
 
-### 2. Synthesize the brand profile
-
-Produce four fields (see `reference/brand-format.md` for the exact tokensBlock shape):
-
-- **name** — the product/brand name.
-- **appDescription** — one clause: what it is + who it's for.
-- **tokensBlock** — freeform plain text the fig generator reads verbatim:
-  - **Colors** — the real palette, each `#HEX — name — role` (role from the repo's comments/usage).
-  - **Brand gradient** — if the repo defines one, state it exactly (`linear-gradient(…)`).
-  - **Type** — display / body / mono faces (real font names + fallbacks) and the size scale.
-  - **Spacing / radius** — the base unit + scale.
-  - **Icon language** — SF Symbols / inline SVG / icon set the product uses; ban emoji if the brand does.
-  - **Voice** — 3–5 short brand voice lines + a one-line tone rule, inferred from the docs/copy.
-  - **Conventions** — any hard rules you found ("never use X", aspect ratios, chrome shape).
-- **surfaces** — THIS product's own key areas/sections, short labels (e.g.
-  `["Feed", "Profile", "Settings"]`), read from the real navigation/routes you
-  found in step 1. Drives the Studio Area picker. 3–10 is typical; skip
-  (leave unset) if the repo genuinely has no discoverable navigation — never
-  guess or reuse a generic/other-product list. Capped at 24 areas / 40
-  characters each.
+### 2. Synthesize the STRUCTURED brand
+
+Fetch the schema (`figura brand schema` / `figura_brand_schema`) and produce a
+`{ identity, platforms }` object plus a `name`, authoring against that schema
+EXACTLY (strict keys, hex 3/4/6/8 digits, no blank array entries, only
+`mobile`/`web`/`desktop` platform keys) so it validates first try.
+`reference/brand-format.md` is a quick orientation + one worked example.
+
+- **name** — the product/brand name (still required on the write).
+- **identity** — the SHARED brand: `colors` (real palette, each
+  `{ name, hex, role?, meaning? }`), `gradient` (if any), `type`
+  (`{ families, ramp, rules }`), `spacing`, `radius`, `voice`
+  (`{ nouns, promise, lines, tone }`), `forbidden` (hard guardrails as
+  `[{ id?, rule }]`).
+- **platforms** — a map with a key ONLY for each platform you detected in step 1.
+  Each surface: `components` (signature components as `[{ name, spec }]`), `icons`
+  (the platform's icon language), `layout` (its frame/shell law), `surfaces` (this
+  product's real areas), `bans` (platform-specific don'ts). Use the per-platform
+  **`tokensBlock`** escape-hatch ONLY for guidance that genuinely doesn't fit a
+  structured field — prefer a structured field.
 
 This synthesis IS the value — enrich the raw tokens with the roles, voice, and
 conventions you read from the repo. Keep it grounded in what's actually there.
-
-### 3. Confirm, then push
-
-Show the user the synthesized `name`, `appDescription`, `surfaces`, and the full
-`tokensBlock`, and confirm the target team (`figura whoami`). On approval:
-
-- **MCP (preferred):** call `figura_set_brand` with `{ name, appDescription, tokensBlock, surfaces }`.
-- **CLI fallback:** pipe the tokens block over stdin, pass surfaces as a flag —
+`appDescription` (one clause: what it is + who it's for) is optional and sent
+alongside.
+
+**Also write a `proseSource`** — a short human-readable description (a few brief
+paragraphs) of this brand: what a person would type to describe its colors, type,
+voice, and conventions. This is NOT a generation input; it's the editable source
+the web brand editor's "Author from a description" textarea seeds from. Send it on
+the push (next step) so a scan-authored brand still has a populated editable
+source, not a blank textarea. Ground it in the same signals you read from the
+repo — it should read as the prose a founder would write, not a dump of the JSON.
+
+### 3. Confirm, then push (structured)
+
+Show the user the `name`, `appDescription`, and the synthesized `{ identity,
+platforms }` (summarize the palette/type/voice + which platforms + their
+surfaces), and confirm the target team (`figura whoami`). On approval:
+
+Always send `proseSource` (the prose description from step 2) alongside the
+structured write so the web editor's textarea is seeded:
+
+- **MCP (preferred):** call `figura_set_brand` with `{ name, appDescription,
+  identity, platforms, proseSource }` (the `identity`/`platforms` objects directly).
+- **CLI fallback:** write the `{ identity, platforms }` JSON to a file and the prose
+  description to a second file, then pass `--structured` + `--prose-source`.
+  `--name` is still required:
   ```bash
-  cat <<'TOKENS' | figura brand set --name "<name>" --description "<one clause>" --tokens - --surfaces "Feed,Profile,Settings"
-  … the tokensBlock …
-  TOKENS
+  figura brand set --name "<name>" --description "<one clause>" \
+    --structured @brand.json --prose-source @brand-notes.txt
   ```
-  (Use `bunx figura-cli` in place of `figura` if it isn't on PATH.)
+  `brand.json` is the `{ "identity": {…}, "platforms": {…} }` object;
+  `brand-notes.txt` is the prose description. Pass both as **@files** — a single
+  command can't read stdin twice, so `--structured -` and `--prose-source` can't
+  share stdin. (Use `bunx figura-cli` in place of `figura` if it isn't on PATH.)
 
-A user can always add/rename/remove/reorder areas later on the brand page — this
-is a starting point, not a one-shot lock-in.
+A user can always add/rename/remove areas or edit tokens later — this is a
+starting point, not a one-shot lock-in.
 
 ### 4. Verify
 
-`figura brand --json` (or the `figura_whoami` → `figura brand` read) → confirm
-`isCustom: true` and that the saved tokens AND `surfaces` match what you set.
-The response also carries `platformProfile` — the engine auto-detects mobile /
-web / both from the tokens you just wrote (breakpoints, font stacks,
-safe-area/tab-bar tokens, hover
-states — deterministic, no LLM) every time you save, so nothing extra to do
-here. It only ever changes on its own until the team explicitly overrides it
-on the brand page (Studio then defaults its device frame off that value —
-iPhone for mobile, browser for web). Then tell the user the brand is set and
-suggest trying `/fig <a screen>` to see it render on-brand.
+`figura brand --json` (or `figura brand --json --platform <mobile|web|desktop>`)
+→ confirm `isCustom: true`, that the response carries the structured
+`{ identity, platforms }` you set, and that the composed `tokensBlock`/`surfaces`
+reflect them. (For a legacy prose fallback you'll see the prose `tokensBlock`
+instead.) The response also carries `platformProfile` — mobile/web/both, which the
+team can override later on the brand page (Studio defaults its device frame off
+it). Then tell the user the brand is set and suggest `/fig <a screen>` to see it
+render on-brand.
+
+## Upgrade a legacy prose brand to structured
+
+If the team already has a legacy PROSE brand (from an earlier onboarding), convert
+it to structured through the **server transform** (the single transform mechanism —
+same one the web brand editor uses; do NOT hand-parse the prose yourself). It's
+reversible.
+
+1. **Fetch the current brand** — `figura brand --json`. For a legacy brand this
+   returns the prose `tokensBlock` (+ `surfaces`, `forbidden`).
+2. **Transform it on the server** — pipe that prose to `figura brand structure`:
+   ```bash
+   figura brand --json | jq -r '.tokensBlock' | figura brand structure -
+   ```
+   (or `figura brand structure --prose @notes.txt`). The server GLM returns
+   schema-valid `{ identity, platforms }` on stdout (it does NOT save). On a
+   transform failure it errors with a clear message — edit the prose and retry.
+3. **Confirm the mapping with the user** — show the before (prose) → after
+   (structured `{ identity, platforms }`) and get an explicit OK. Flag anything the
+   transform dropped or that the prose didn't clearly specify.
+4. **Push structured** — save the reviewed JSON, AND pass the original prose that
+   was transformed as `--prose-source` (that prose IS the editable source, so the
+   web editor seeds from it):
+   `figura brand set --name <name> --structured @file.json --prose-source @notes.txt`.
+   (`notes.txt` = the original prose from step 2; if you piped `.tokensBlock`, write
+   it to a file first so you can pass it here.) Over MCP, send the same original
+   prose as `proseSource` on `figura_set_brand`.
+
+`brand set --structured` **snapshots a version first** (#707), so the upgrade is
+reversible: every brand write appends to the team's version history, and the team
+can restore the pre-upgrade prose version from the brand page's version history on
+figura.so if the mapping was wrong. Reassure the user of this before pushing.
+
+## Prose fallback (legacy — only if structured synthesis isn't possible)
+
+If the repo's design system genuinely can't be structured (e.g. it's a single
+freeform brand doc with no extractable tokens), fall back to a legacy PROSE brand
+so onboarding never hard-fails: send `tokensBlock` (freeform plain text) +
+`surfaces` (the product's areas) instead of `identity`/`platforms`.
+
+- **MCP:** `figura_set_brand` with `{ name, appDescription, tokensBlock, surfaces }`.
+- **CLI:** `cat tokens.txt | figura brand set --name "<name>" --tokens - --surfaces "Feed,Settings"`.
+
+A prose brand still renders; it's just not addressable. Prefer structured whenever
+you can extract real tokens.
 
 ## Output
 
 Report the brand you set (name + a one-line summary of the palette/type/voice you
-captured, plus the surfaces list) and confirm it's live for the team. Don't
-paste the entire tokensBlock again unless asked.
+captured, the platforms + their surfaces) and confirm it's live for the team.
+Don't paste the entire object again unless asked.

package/skills/figura-brand/reference/brand-format.md

@@ -1,80 +1,74 @@
-# tokensBlock format
-
-The brand profile's `tokensBlock` is **freeform plain text** injected verbatim
-into the fig-generation prompt. It is NOT JSON, NOT markdown — just clear,
-sectioned plain text with concrete values. Lead with hard rules; be terse.
-
-Aim for these sections (skip any the repo genuinely doesn't have; never invent
-values):
-
-```
-<NAME> BRAND GROUND-TRUTH (locked — these are NOT suggestions):
-
-WHAT <NAME> IS
-- One or two lines: what the product is, the platform, the core metaphor.
-- The pitch / tagline if there is one.
-
-COLORS (use ONLY these — never invent hues)
-- <#HEX> <Name> — <role/usage, from the repo's comments or how it's used>.
-- … one line per color. Note any opacity variants used over media.
-
-THE BRAND GRADIENT (only if the repo defines one)
-- EXACTLY one: linear-gradient(<deg>, <#HEX>, <#HEX>). Where it's allowed.
-
-TYPE
-- Display: <Font> — stack '<Font>', <fallbacks>. Where it's used + weight rule.
-- Body: <Font> — stack <fallbacks>. UI text.
-- Mono: <Font> — stack <fallbacks>. Numerics / code.
-- Scale: <the real size ramp, e.g. 12 / 14 / 16 / 20 / 24 / 36 / 48>.
-
-SPACING / RADIUS
-- Base unit + scale (e.g. 4-based: 4 8 12 16 24 32 …). Radius tokens (sm/md/lg/full).
-
-ICON LANGUAGE
-- The icon set the product uses (SF Symbols names / inline stroke SVG / a named set).
-- Ban emoji if the brand bans it.
-
-VOICE (3–5 lines, the brand's register)
-- Short example lines in the brand's actual tone (pull/adapt from brand docs/copy).
-- One tone rule (e.g. "terse, confident, never salesy").
-
-CONVENTIONS (hard rules found in the repo)
-- e.g. aspect ratios, chrome shape (pill/capsule), "never use <X>", dark-first, etc.
+# Structured brand format — orientation
+
+The brand profile is a **structured JSON object** — `{ identity, platforms }`. The
+**authoritative shape is the live JSON Schema**, not this file: fetch it with
+`figura brand schema` (CLI) or the `figura_brand_schema` MCP tool and author
+against THAT (it's derived server-side from the zod schema `PUT /brand` validates,
+so it can't drift). This page is only orientation + one worked example.
+
+Two halves:
+- **`identity`** — the SHARED brand (same on every platform): `colors`
+  (`[{ name, hex, role?, meaning? }]`), `gradient?`, `type?`
+  (`{ families?: { slot: fontName }, ramp?: number[], rules? }`), `spacing?`,
+  `radius?`, `voice?` (`{ nouns?, promise?, lines?, tone? }`), `forbidden?`
+  (`[{ id?, rule }]`).
+- **`platforms`** — a map keyed by `mobile` / `web` / `desktop`. Include ONLY the
+  platforms the product targets. Each surface: `components?` (`[{ name, spec }]`),
+  `icons?`, `layout?`, `surfaces?` (this product's real areas), `bans?`,
+  `tokensBlock?` (the prose ESCAPE HATCH for guidance that genuinely doesn't fit a
+  structured field — use sparingly).
+
+Validation the schema enforces (a violation is a 400 at `PUT /brand`): **strict
+keys** (an unknown/misspelled key is rejected); **hex** = `#` + exactly 3/4/6/8
+digits; **no blank** array entries; platform keys exactly `mobile`/`web`/`desktop`;
+caps on array lengths + string lengths (the fetched schema carries the exact
+numbers). Author against the fetched schema, not these prose notes.
+
+## Worked example — a web/desktop brand ("Ledgerline")
+
+```json
+{
+  "identity": {
+    "colors": [
+      { "name": "Fern", "hex": "#1F6F54", "role": "accent", "meaning": "primary actions; gradient start" },
+      { "name": "Brass", "hex": "#C9A227", "role": "accent", "meaning": "highlights + paid states; gradient end" },
+      { "name": "Bone", "hex": "#F4F2EC", "role": "surface", "meaning": "light surfaces + text on dark" },
+      { "name": "Ink", "hex": "#101312", "role": "ground", "meaning": "near-black base background" }
+    ],
+    "gradient": "linear-gradient(90deg, #1F6F54, #C9A227)",
+    "type": {
+      "families": { "display": "Fraunces", "body": "Inter", "mono": "JetBrains Mono" },
+      "ramp": [12, 14, 16, 18, 20, 24, 30, 36, 48],
+      "rules": "Fraunces semibold at display size; Inter 400/600 for UI; mono for amounts + ids."
+    },
+    "spacing": [4, 8, 12, 16, 20, 24, 32, 40, 48, 64],
+    "radius": [4, 8, 12, 999],
+    "voice": {
+      "nouns": ["ledger", "balance", "month-end"],
+      "promise": "Books, balanced.",
+      "lines": ["Every cent, accounted.", "Close the month, not your eyes."],
+      "tone": "Terse, dry, precise — never salesy."
+    },
+    "forbidden": [
+      { "id": "no-emoji", "rule": "Never use emoji; icons are inline stroke SVG." },
+      { "id": "squared", "rule": "Chrome is squared (radius 8), never pill." }
+    ]
+  },
+  "platforms": {
+    "web": {
+      "components": [
+        { "name": "dataTable", "spec": "Dense zebra-striped table; right-aligned numeric columns in mono; sticky header." },
+        { "name": "primaryButton", "spec": "Solid Fern fill, Bone text, radius 8, 40px tall." }
+      ],
+      "icons": "Inline stroke SVG (receipt, arrow-right, check-circle). currentColor, ~1.6 width.",
+      "layout": "Desktop-first two-column app shell: left nav rail + dense content. Tables are the hero.",
+      "surfaces": ["Invoices", "Clients", "Reports", "Settings"],
+      "bans": ["No pill buttons", "No hero illustrations — numbers first"]
+    }
+  }
+}
 ```
 
-## Worked example (fictional brand "Ledgerline" — abridged)
-
-```
-LEDGERLINE BRAND GROUND-TRUTH (locked):
-
-WHAT LEDGERLINE IS
-- A calm B2B invoicing web app. Dense tables, quiet confidence, desktop-first.
-- Numbers first. Tagline: "Books, balanced."
-
-COLORS (use ONLY these)
-- #1F6F54 Fern — primary brand accent; primary actions; gradient start.
-- #C9A227 Brass — secondary accent; highlights + paid states; gradient end.
-- #F4F2EC Bone — light surfaces + foreground on dark (a warm off-white).
-- #101312 Ink — near-black base background.
-
-THE BRAND GRADIENT
-- EXACTLY one: linear-gradient(90deg, #1F6F54, #C9A227). Wordmark/hero accents only.
-
-TYPE
-- Display: Fraunces — stack 'Fraunces', Georgia, serif. Semibold at display size.
-- Body: Inter — stack Inter, -apple-system, 'SF Pro Text', system-ui, sans-serif.
-- Mono: JetBrains Mono — amounts, invoice ids, dates.
-- Scale: 12 / 14 / 16 / 18 / 20 / 24 / 30 / 36 / 48.
-
-SPACING / RADIUS
-- 4-based scale: 4 8 12 16 20 24 32 40 48 64. Radius: sm 4, md 8, lg 12, full 999.
-
-ICON LANGUAGE
-- Inline stroke SVG (receipt, arrow-right, check-circle). NEVER emoji.
-
-VOICE
-- "Every cent, accounted." "Close the month, not your eyes." Terse, dry, precise — never salesy.
-
-CONVENTIONS
-- Tables are the hero. Chrome is squared (radius md, never pill). Light-first with a dark ledger mode.
-```
+A brand can hold more than one platform at once (a product shipping iOS + web sets
+both `platforms.mobile` and `platforms.web`, sharing one `identity`). Emit a
+platform key ONLY for a platform the product actually targets.