View
PurposeiOS handoff reference

A versioned handoff reference for the iOS engineering team. Starting at wireframe fidelity is intentional — it proves the process has real value before branded UI exists. Design will evolve; that's not a risk, it's the assumption the system is built on. Token names are stable from v0, so every line of SwiftUI written today stays valid as values are refined. Each version adds screens or improves values; the hub, iOS package, and Figma variables update together.

TypographyUIFont.TextStyle / SwiftUI .font()
ColorsSemantic UIColor / Color(.semanticInfo)
Radiuscontrol 8pt · panel 12pt · card 16pt
SpacingSwiftUI .padding() / .spacing()

Dark / light mode toggle on the dashboard proto controls section. All tokens resolve to different values per mode — test both before shipping. Figma variables mirror this token set exactly — synced via the Figma MCP use_figma tool (see Figma MCP section below).

Changelog

how updates are delivered

The hub is versioned. Each version is a stable, usable state — v0.1 is not a draft, it's a working reference. Changes happen in batches: a round of Figma refinement, a new screen tokenized, a token value updated. When a batch is ready, the version increments, this page reflects it, and the iOS package updates automatically.

current · v0.1March 2026

What's in v0.1

  • ✓Header: Miles wordmark left-aligned, solid bg (no backdrop blur), sticky flush to top-0
  • ✓Filter pills: sticky-until-displaced — locked to header bottom, peeled away by AI card scroll
  • ✓Stats bento: dots removed, score to 1 decimal, label renamed 'Miles Score', delta arrow inline
  • ✓Activity feed: chevrons removed, all 4 card types fully iOS-tokenized
  • ✓Map: vehicle status label moved below avatar; filter pills repositioned above map
  • ~Figma: dashboard variable-linking via use_figma (in progress)
v0March 2026

What's in v0

  • ✓Dashboard fully tokenized — zero non-token color or radius utilities
  • ✓Typography: 18 roles mapped to iOS HIG Dynamic Type (.largeTitle → .caption2)
  • ✓Color tokens: semantic light + dark mode, full primitive palette
  • ✓Radius (control 8pt · panel 12pt · card 16pt) + spacing scale
  • ✓iOS Swift package — MilesTokens.swift with adaptive Color, Radius, and Spacing enums
  • ✓Figma: dashboard screen capture complete, token variables synced via Figma MCP use_figma
How future versions work

As Figma refines values or new screens are tokenized, changes are batched and the hub version increments. The iOS Swift package re-downloads with updated values. Figma-linked token values update automatically via the hub plugin. Existing SwiftUI code referencing stable token names requires no changes — only the underlying values improve.

  • v0.1 → v0.2: Trip detail screen tokenized + added to screen inventory
  • v0.2 → v0.3: Figma dashboard variable-linking complete, color values refined
  • v0.x → v1: Full dashboard + 2–3 additional screens, Figma fully linked

When a new version ships — iOS checklist

  • →Check the changelog — The version badge at the top of this page increments when a new version ships. Review the entry to understand scope before doing anything else.
  • ↓Re-download the iOS package if token values changed — If the changelog notes refined color, radius, or spacing values — re-download MilesTokens.swift from the button at the top of this page and drop it into Xcode.
  • ⚠If breaking changes are listed — SwiftUI update required — Token names are stable by design and almost never change. But if a name is renamed or removed, it will appear as a breaking change with a warning block in the changelog entry — with the old name, new name, and exact update needed. This is rare and will always be explicit.
  • ✓No breaking changes listed — no code changes needed — If there is no breaking changes block, your SwiftUI code is unaffected. Color(.semanticSuccess), .cornerRadius(16), .font(.headline) — all stable. Only the resolved values improve.
  • ○New screens in the inventory — No action needed until you're ready to build them. They enter the same loop when the time comes.

Getting started

Everything needed to start building is here now. As versions increment, the same references update in place — the prototype, token ZIP, and Figma are always accessible from this page.

Always available
Live dashboard prototypeAll screen states: fleet view, one vehicle driving, trip in progress, trip complete. Toggle between them with the proto controls at the bottom of the dashboard.Open dashboard →
Typography — 18 rolesEvery text style on the dashboard maps to a named iOS HIG role (e.g. .largeTitle, .headline, .caption2) with the exact SwiftUI modifier. See Typography scale below.
Color tokensSemantic tokens (surface, text, stroke, success/warning/danger/info) with light and dark values. Each has an explicit UIColor / SwiftUI Color mapping in the Dashboard parity section below.
Radius + spacingThree radius tokens: control 8pt, panel 12pt, card 16pt — each maps to .cornerRadius(). Spacing follows Tailwind multiples: 4px base, used as SwiftUI .padding() or .spacing().
iOS Swift packageGenerated on demand from live token files — MilesTokens.swift with adaptive Color, Radius, and Spacing enums ready to drop into Xcode. Re-download after any token update.↓ Download iOS package →
Figma MCP (use_figma)Figma MCP is now write-capable via the use_figma tool. An AI agent can sync tokens directly from the JSON files to Figma Variables, capture screens as layers, and bind variables — all without a plugin. It can also inspect token-linked layers by name, returning exact token names and resolved values as a reference during iOS development.
Recommended AI-assisted approach

Open the dashboard in a browser alongside your Xcode project. Feed both this URL and the source file to your AI assistant and use a prompt like:

“Here is a running web prototype at localhost:3000/sandboxes/miles-proto-4/dashboard and its source. Recreate the FleetView screen in SwiftUI. Use the typography and color mappings documented in the hub page to translate each Tailwind class to its iOS equivalent — .largeTitle for text-3xl font-bold, .cornerRadius(16) for rounded-card, Color(.semanticSuccess) for text-semantic-success, etc.”

Providing both the prototype URL and source to an AI assistant can accelerate SwiftUI development. As Figma fidelity grows, token values update in place — the same SwiftUI calls remain valid throughout.

What Figma provides
  • ·A canonical design artifact for sign-off and stakeholder review
  • ·Variable-linked layers — toggling Light ↔ Dark in Figma verifies every token in one click
  • ·AI-extractable variable bindings per layer — an AI assistant can query token-linked layers by name, returning exact token names and resolved values as a reference at any point in iOS development
  • ·Designer refinements to color values, radius, or spacing — updates sync back to this hub and are picked up by the iOS build without any structural changes
  • ·Flat PNG exports for mockup decks, stakeholder presentations, and marketing assets — a free by-product of token-linked screens

Design → iOS pipeline

repeatable method

Token names are stable from the start. iOS development and Figma refinement run in parallel — no sync gate, no fidelity milestone to wait for. Token values improve continuously; the hub always reflects current state.

Design → iOS process diagram
UX Flow → Token Source of Truth → iOS Build + Figma (parallel) → Testing → feedback loops back → version bump.
Phase 1 — Reference ready
done
  1. 1
    Design in the browserDashboard prototype built with semantic tokens throughout. All screen states wired up and interactive. Hub compliance checker confirms every color and radius is token-bound.
  2. 2
    Hub confirms stylesTypography (18 roles → iOS HIG), color tokens (with UIColor equivalents), radius, spacing, and compliance audit all reflect live code — not a static spec. Layout and component structure are defined. The hub and the prototype stay synced — changes to either flow back to the other.
iOS development entry point

Build now. The values will catch up.

Component hierarchy, navigation flow, and token names are all stable at v0. Wire up Color(.semanticSuccess), .cornerRadius(16), .font(.headline) now — these won't change. Exact hex values, typeface choices, and fine spacing will be refined through Figma and absorbed automatically when you re-download the iOS package.

Phase 2 — Parallel tracks
in progress

iOS development and Figma run simultaneously. Neither waits for the other. As Figma values are refined they flow back into the hub; as new screens are built they enter the same loop.

iOS track
  1. 3
    Build component structureSwiftUI views, navigation, screen states — mirroring the web prototype component names (FleetView, VehicleCardContent, TripsFeed, etc.). Use this hub as the reference.
  2. 4
    Wire token-mapped stylesApply Color, Font, and cornerRadius using the hub mappings. Once Figma screens are token-linked, use Figma MCP to inspect any layer directly — it returns exact token names and resolved values as a live reference alongside the hub.
Figma track
  1. 5
    Run 5-prompt capture workflowBuild → Audit → Tokens → Bind → Components. Agent-driven end-to-end via generate_figma_design and use_figma. Full prompts in the Capture Prompts section.
  2. 6
    Refine → sync back → version bumpDesigner refines color values, radius, or spacing in Figma. A Figma MCP agent reads the updated values and writes them back to lib/design-system/tokens/. Hub updates, iOS package reflects them, version increments.
  3. ↗
    Frame itExport token-linked screens as flat PNGs for stakeholder decks, mockups, and marketing assets. A free by-product of the variable-linked Figma file — no extra work once screens are tokenized.
Ongoing — expand scope
repeating

Every new feature or page enters at the same point: UX Flow. A new screen gets prototyped there first, which keeps the hub (Token Source of Truth) and the prototype synced. From there the same pipeline applies — tokenize, capture, refine, version bump. The token system, Swift package, and Figma tooling are all reusable — only scope grows.

TestFlight feedback splits two ways: UX/flow issues return to the prototype; visual issues return to Figma. Either path feeds back into the next version batch through the same pipeline.

Adopting a new screen — 3 steps

  1. A
    Tokenize the web screenReplace raw Tailwind color and radius classes with semantic token equivalents. Run the compliance checker to confirm zero non-token utilities remain.
  2. B
    Run the 5-prompt capture workflowSet <dashboard-url> to the new screen's URL in the Capture Prompts section and run prompts 1–5. The same workflow applies to every screen — no setup changes needed.
  3. C
    Update screen inventoryMark the screen as tokenized and Figma-captured below. The hub, iOS package, and Figma are immediately up to date — the loop continues.

Figma capture prompts

save URLs below · then copy

Five sequential prompts — run in order for each screen. Structure first, then audit, variables, tokenize, and componentize. Each step builds on the last.

Saved URLs

Saved to browser localStorage — persists across page reloads.

1Build

Agent reads the /figma-use skill, creates a new Figma file, and uses generate_figma_design to translate the live page into layers. Structure, hierarchy, auto layout, and semantic layer naming only — hardcoded values throughout.

Read the /figma-use skill. Create a new Figma file. Use the generate_figma_design
tool to translate the live page into Figma layers:
<dashboard-url>

Focus on structure only — layout, hierarchy, naming, and auto layout throughout.
Layer names must mirror the source code exactly, no Figma defaults like "Frame 12"
or "Group 3". Hardcoded values are fine for now.

We'll bind tokens and extract components in later steps.
capture looks right
2Audit

Agent inspects the live page code and the design hub, then outputs a structured brief: all design tokens (colors, spacing, type, radii), a component inventory, and layout structure. This brief drives Step 3.

Inspect the live page code at:
<dashboard-url>

And the design hub:
<hub-url>

Output a brief covering: all design tokens (colors, spacing, type, radii), a
component inventory, and layout structure.

This brief will be used directly in the next step to set up variables and styles
in the created file.
brief is ready
3Tokens

Agent reads /figma-use and uses the Phase 2 brief to set up all Figma variables and styles via use_figma — colors (primitives first, then semantic aliases), type styles, spacing, and radii. Token names match source exactly.

Read the /figma-use skill. Using the Phase 2 brief, set up all variables and styles
via the use_figma tool in the created file — colors (primitives then aliases), type
styles, spacing, and radii. Match source token names exactly.

We'll tokenize the frame next, but not yet. Confirm what was created and flag
anything that didn't map cleanly.
variables confirmed
4Bind

Agent reads /figma-use and re-inspects the live page, then binds every layer to the correct variable from Step 3 — no raw values anywhere. Takes a screenshot and does a self-healing pass to correct visual drift. Done when zero raw values remain and the frame matches the live page.

Read the /figma-use skill. Re-inspect the live page code at:
<dashboard-url>

Using the use_figma tool, go through every layer in the Figma frame and bind it to
the correct variable from Phase 3. No raw values anywhere — every color, spacing,
type, and radii value must reference a token.

For each binding, confirm it's correct against the source — not just visually
plausible. Flag anything that couldn't be bound cleanly and explain why.

After all values are bound, take a screenshot of the frame and do a self-healing
pass — compare against the live page and correct any remaining visual drift before
moving to Step 5.

We're done when there are zero raw values left and the frame matches the live page.
frame is fully bound
5Components

Agent reads /figma-use and extracts all repeating patterns into proper Figma components with variants. All components use existing variables — no new raw values. Main frame references components, not raw layers.

Read the /figma-use skill. Using the use_figma tool, extract all repeating patterns
from the tokenized frame into proper Figma components.

Each component should have correct variants where the source has states or
variations. All components must use existing variables — no new raw values. Layer
naming inside components must continue to mirror the source code.

Confirm when all repeating elements have been extracted and the main frame
references components rather than raw layers.

Apply updates

Figma → tokens → version bump

After the designer refines values in Figma, this prompt reads the updated variable values and writes them back to the token source files, then increments the version. Runs a drift report first — nothing is written until the changes are confirmed.

Saved to localStorage — shared with the Capture Prompts section.

Sync back prompt
Read the /figma-use skill. Inspect the Figma file at:
<figma-url>

Compare the current Figma variable values against the token source files:
  lib/design-system/tokens/primitives.json
  lib/design-system/tokens/semantic-light.json
  lib/design-system/tokens/semantic-dark.json
  lib/design-system/tokens/sizing.json

Step 1 — Drift report
List every token where the Figma value differs from the source file. For each:
- Token name
- Current source value
- Refined Figma value

Do not write anything yet. Confirm the list looks intentional before proceeding.

Step 2 — Write back
Update the matching token JSON files with the confirmed values. Match token names
exactly — do not rename, restructure, or add new tokens.

Step 3 — Version bump
Update versions.json:
- Increment the version number
- Add a changelog entry listing what changed and why
- Mark any token renames as breaking changes if applicable

Summarize: what changed, which files were updated, and the new version number.

Figma MCP

use_figma · write-capable · no plugin needed

As of March 24, 2026, Figma's MCP server gained write capability via the use_figma tool. AI agents (Claude Code, Cursor, Codex, etc.) can now create and modify Figma files directly — variables, components, auto-layout, text styles — without any plugin install. This replaces the custom hub plugin entirely.

What use_figma replaces and enables
Token syncAgent reads lib/design-system/tokens/*.json and writes all Figma Variables (primitives · semantic light/dark · sizing). Semantic tokens are aliased to primitives for automatic Light↔Dark switching. Idempotent — safe to re-run after any token change.
Miles/* text styles18 iOS-specific text styles written from /hub/typography. Applied to text layers via the style panel, not as variables. Re-run any time the type scale changes.
Screen captureCapture prompts still create layers with hardcoded values and semantic names. use_figma then applies variable bindings from the checklist — the same two-step workflow, now agent-applied end-to-end.
Design inspectionRead capability is unchanged — agents can still inspect token-linked layers by name, returning exact token names and resolved values as an iOS development reference at any point.
Token sync — what to tell the agent

“Read lib/design-system/tokens/primitives.json, semantic-light.json, semantic-dark.json, and sizing.json. Using use_figma, write all tokens to the Figma file as Variables — primitives collection (Base mode), semantic collection (Light + Dark modes with aliases to primitives), and sizing collection (Base mode). Also write all 18 type styles from /hub/typography as Miles/* text styles. The Figma file is [FIGMA_URL].”

Run this any time tokens change. It's idempotent — existing variables update in place, missing ones are created.

What gets written to Figma
primitives ✦Base — full color palette: neutral scale, green/blue/yellow/red status stops, brand greens, black, white
semantic ✦Light · Dark — all surface, text, stroke, and status colors; each aliased to its matching primitive for automatic mode-switching
sizing ✦Base — spacing scale, borderRadius/control·panel·card·pill, boxShadow/card (STRING — apply manually: Y 24, blur 70, black 8%)
Miles/* text styles ✦18 iOS-specific styles — apply to text layers via the style panel, not as variables
Skills

Skills are markdown instruction files that guide how agents use use_figma — which steps to take, what conventions to follow, what good output looks like. The figma-use skill is the foundation all others build on. Miles-specific conventions (token naming, component hierarchy, iOS handoff intent) can be encoded as a skill to make agent output consistently brand-aligned without re-explaining context each time.

Hub endpoints (available to agents)
  • GET /tokens — combined token JSON (all sets)
  • GET /typography — text style bootstrap data
  • GET /manifest — hub index
  • GET /component-specs — component → token contract

Color · Primitives

color/neutral/50#fafafa
color/neutral/100#f5f5f5
color/neutral/200#e5e5e5
color/neutral/300#d4d4d4
color/neutral/400#a3a3a3
color/neutral/500#737373
color/neutral/600#525252
color/neutral/700#404040
color/neutral/800#262626
color/neutral/900#171717
color/neutral/950#0a0a0a
color/green/400#4ade80
color/green/600#16a34a
color/green/brand-light#03c76a
color/green/brand-dark#03ff7f
color/blue/300#93c5fd
color/blue/600#2563eb
color/yellow/400#facc15
color/yellow/600#ca8a04
color/red/400#f87171
color/red/600#dc2626
color/white#ffffff
color/black#000000

Color · Semantic (light mode)

background#fafafa
foreground#0a0a0a
text/primary#0a0a0a
text/secondary#404040
text/muted#737373
text/inverse#fafafa
brand/primary#0a0a0a
brand/inverse#ffffff
surface/subtle#f5f5f5
surface/strong#e5e5e5
surface/card#ffffff
stroke/muted#e5e5e5
stroke/strong#d4d4d4
semantic/info#2563eb
semantic/success#16a34a
semantic/warning#ca8a04
semantic/danger#dc2626

Spacing

spacing/00
spacing/14px
spacing/28px
spacing/312px
spacing/416px
spacing/520px
spacing/624px
spacing/832px
spacing/1040px
spacing/1248px
spacing/1664px
spacing/2080px
spacing/2496px
spacing/page40px
spacing/section48px
spacing/gutter24px

Border radius · Shadow

borderRadius/control.cornerRadius(8)
borderRadius/panel.cornerRadius(12)
borderRadius/card.cornerRadius(16)
borderRadius/pillCapsule()
boxShadow/cardmap · from miles

Typography scale — iOS handoff

18 roles · each maps to one iOS HIG Dynamic Type style or named custom role. Inter (web) ↔ SF Pro (iOS).

TitlesBodyStatsCaptionsSmall labelsMicroAI voice
Titles
Large Titletext-3xl font-bold leading-tight
largeTitle — 34pt Bold.largeTitle
The quick brown foxDashboard page header 'Miles'
Displaytext-2xl font-semibold uppercase leading-tight
title2 — 22pt (custom: uppercase + tight).title2 + .textCase(.uppercase)
The quick brown foxVehicle name — CIVIC / RAV4
Titletext-lg font-semibold leading-snug
title3 — 20pt.title3
The quick brown foxSection heading — trip complete vehicle name
Headlinetext-base font-semibold
headline — 17pt Semibold.headline
The quick brown foxPrimary card text — route name, card titles
Body
Subheadline Boldtext-sm font-semibold leading-none
subheadline — 15pt Semibold.subheadline.bold()
The quick brown foxKey data — driver name in strips, max speed in trip header, route names
Subheadlinetext-sm font-medium
subheadline — 15pt.subheadline
The quick brown foxSecondary interactive text — nav labels, tappable links, list items
Bodytext-sm leading-relaxed
body — 17pt Regular.body
The quick brown foxReading text — coaching descriptions, route labels
Stats
Stat — Largetext-4xl font-bold leading-none tabular-nums
custom: 36pt Bold tabularFont.system(size: 36, weight: .bold, design: .rounded).monospacedDigit()
The quick brown foxLive speed readout — primary mph number
Stat — Mediumtext-lg font-bold leading-none tabular-nums
custom: 18pt Bold tabularFont.system(size: 18, weight: .bold).monospacedDigit()
The quick brown foxBento stat values — Score, Engine status, Fuel % · Driver strip speed (secondary mph)
Captions
Caption Emphasizedtext-xs font-semibold
caption1 — 12pt Semibold.caption.bold()
The quick brown foxStatus chips — Driving in-progress header
Captiontext-xs font-medium
caption1 — 12pt.caption
The quick brown foxInteractive labels — See all / Not Emma? / overlay stats
Caption Mutedtext-xs
caption1 — 12pt Regular.caption.foregroundStyle(.secondary)
The quick brown foxSecondary metadata — timestamps, relation · score line
Small labels
Section Headertext-[11px] font-semibold uppercase tracking-wide
caption2 — 11pt Semibold Uppercase (UITableView section).caption2.bold().textCase(.uppercase).kerning(0.5)
The quick brown foxGrouped-list headers — VEHICLES · RECENT TRIPS · TO-DO
Caption 2text-[11px] font-medium
caption2 — 11pt.caption2
The quick brown foxSmallest labels — bento stat keys, mph unit, trip stat keys, avatar initials
Micro
Badgetext-[10px] font-semibold uppercase tracking-wide
custom: 10pt Semibold Uppercase (pill label)Font.system(size: 10, weight: .semibold).textCase(.uppercase)
The quick brown foxStatus pills — DRIVING (green) · PARKED (blue)
Micro Labeltext-[10px] font-medium uppercase tracking-wide
custom: 10pt Medium UppercaseFont.system(size: 10, weight: .medium).textCase(.uppercase)
The quick brown foxOverlay metadata — TRIP MAX SPEED map label
AI voice
AI Bodyfont-mono text-sm leading-relaxed
body — SFMono / Menlo 15pt (monospaced)Font.system(.body, design: .monospaced)
The quick brown foxMiles coaching card message — From Miles body text
AI Labelfont-mono text-[11px] font-medium uppercase tracking-wide
caption2 — SFMono 11pt UppercaseFont.system(.caption2, design: .monospaced).textCase(.uppercase)
The quick brown foxFROM MILES section header

Dashboard parity (tokenized dashboard)

Current classes used on the dashboard. Keep these aligned with Figma variables and token JSON.

Spacing (dashboard)

  • px-5, py-4, gap-4 → 20px
  • px-4, gap-3, p-4 → 16px
  • px-3, py-3, gap-2, p-3 → 12px
  • px-2.5, py-2.5, gap-1.5 → 10px
  • gap-1, py-1.5, pt-2 → 4–6px
  • gap-0.5, py-0.5 → 2px

Radius (dashboard)

  • rounded-card → 16px (map + primary cards)
  • rounded-panel → 12px (panels, bento, strips)
  • rounded-control → 8px (buttons, controls, thumbnails)
  • rounded-full → 9999px (badges, avatars)

Colors (dashboard)

  • bg-background / bg-surface-card / bg-surface-subtle (base surfaces)
  • text-text-primary / text-text-secondary / text-text-muted (typography)
  • border-stroke-muted / divide-stroke-muted / bg-stroke-strong (strokes)
  • text-semantic-success / warning / danger / info (status + intent)
  • bg-semantic-success / warning / info (dots, status markers, filled status pills)
  • bg-semantic-info + bg-semantic-success (filled PARKED / DRIVING pill backgrounds)
  • bg-foreground + text-background (inverse dark cards, overlays, Emma driver avatar)

Note: stroke-muted and surface-strong resolve to the same value in both modes (neutral-200 light / neutral-800 dark). The names are kept separate for semantic clarity — strokes vs hover surfaces — but share values by design.

Tab bar / Bottom nav (system colors — intentional)

_components/bottom-nav.tsx uses raw Tailwind system colors, not semantic tokens. This is intentional — these map directly to iOS UITabBar system tints.

  • bg-white/95 backdrop-blur-xl → UITabBar background (frosted glass)
  • border-neutral-200/80 → UITabBar top separator
  • text-blue-600 → active tab icon + label tint (iOS system blue)
  • text-neutral-400 → inactive tab icon + label
  • bg-blue-600 ring-2 ring-white → Miles tab notification badge dot
  • focus-visible:ring-blue-500 → keyboard focus ring

iOS mapping: active tint → UIColor.systemBlue · inactive → UIColor.systemGray2 · bar background → .systemBackground with UIBlurEffect(.systemMaterial)

Token compliance checklist

Dashboard color utility auditATTN
  • • Uses token classes for surface/text/stroke/semantic intent
  • • Uses only sanctioned radius utilities: `rounded-card`, `rounded-panel`, `rounded-control`, `rounded-full`
  • • Allows black gradient/overlay exceptions for map readability
  • • Source audited: dashboard/page.tsx
  • • Non-token color utility count: 14
  • • Non-token radius utility count: 0

Needs conversion

bg-amber-50bg-neutral-100border-2text-amber-600text-blue-600text-blue-700text-ellipsistext-emerald-600text-neutral-300text-neutral-400text-neutral-500text-neutral-700text-neutral-900text-surface-card
Bottom-nav color audit (system colors expected)ATTN
  • • Source audited: _components/bottom-nav.tsx
  • • Intentional system colors: blue-600 (active tint), neutral-400 (inactive), white/95 (bar bg)
  • • Unexpected non-token utilities: 2

Unexpected — review

ring-backgroundring-offset-background

Component inventory

Components used on the dashboard (1:1 with dashboard/page.tsx)

  • FleetViewDashboard header, map, vehicle list
  • VehicleCardContentSingle vehicle card (header, bento, live strip)
  • TripsFeedTrips page — unified wireframe feed (live trip · trip rows · score updates · events) grouped by day
  • AgentCoachingCardFrom Miles message + CTA
  • AgentCoachingCarouselHorizontal coaching cards + dot indicators
  • TodoPreviewDemo todos list
  • QuickActionsRoadside Assist button (when profile header)
  • LiveSpeedTrip speed + max (trip mode)
  • TripVehicleStatusVehicle health bento (trip mode)
  • TripDriverCardDriver avatar + name + score
  • TripInProgressDriving header, map, LiveSpeed, vehicle, driver
  • TripCompleteTrip summary card + coaching + back
  • MapViewMap with markers/route — supports labelColor to override pill color independently from marker dot
  • LinkInternal navigation
  • BottomNavTab bar (layout)

Screen inventory

1 of 37 tokenized

All screens in the prototype. Each screen moves through the same adoption pipeline — tokenize → Figma capture → variable linking → refine. The token system, hub, and tooling are shared across all screens; only the scope grows over time.

DoneIn progressPending
Core
ScreenTokenizedFigmaLinks
DashboardLead reference screen
✓ Done~ In progress
ProtoFigma
Trips
○ Pending○ Pending
ProtoFigma
Miles
○ Pending○ Pending
ProtoFigma
Insights
○ Pending○ Pending
ProtoFigma
Profile
○ Pending○ Pending
ProtoFigma
Trip flow
ScreenTokenizedFigmaLinks
Live trip
○ Pending○ Pending
ProtoFigma
Trip complete
○ Pending○ Pending
ProtoFigma
Trip detail
○ Pending○ Pending
ProtoFigma
Trip receipt
○ Pending○ Pending
ProtoFigma
Weekly recap
○ Pending○ Pending
ProtoFigma
Driver score
○ Pending○ Pending
ProtoFigma
Post drive prompts
○ Pending○ Pending
ProtoFigma
First trip summary
○ Pending○ Pending
ProtoFigma
Onboarding
ScreenTokenizedFigmaLinks
Signup
○ Pending○ Pending
ProtoFigma
Permissions
○ Pending○ Pending
ProtoFigma
Install
○ Pending○ Pending
ProtoFigma
Plug in device
○ Pending○ Pending
ProtoFigma
Scan device
○ Pending○ Pending
ProtoFigma
Pair device
○ Pending○ Pending
ProtoFigma
Device detected
○ Pending○ Pending
ProtoFigma
Ready to drive
○ Pending○ Pending
ProtoFigma
First trip ready
○ Pending○ Pending
ProtoFigma
Confirm address
○ Pending○ Pending
ProtoFigma
Drivers
ScreenTokenizedFigmaLinks
Drivers
○ Pending○ Pending
ProtoFigma
Add drivers
○ Pending○ Pending
ProtoFigma
Household
○ Pending○ Pending
ProtoFigma
Teen independence
○ Pending○ Pending
ProtoFigma
Who's driving
○ Pending○ Pending
ProtoFigma
Driver reassignment
○ Pending○ Pending
ProtoFigma
Device & account
ScreenTokenizedFigmaLinks
Device health
○ Pending○ Pending
ProtoFigma
Vehicle
○ Pending○ Pending
ProtoFigma
Settings
○ Pending○ Pending
ProtoFigma
Account
○ Pending○ Pending
ProtoFigma
Billing
○ Pending○ Pending
ProtoFigma
Notifications
○ Pending○ Pending
ProtoFigma
Help
○ Pending○ Pending
ProtoFigma
Locations
○ Pending○ Pending
ProtoFigma