@hegemonart/get-design-done 1.33.6 → 1.34.1

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "Get Design Done — 5-stage agent-orchestrated design pipeline with 9 connections, handoff-first workflow, bidirectional Figma write-back, 22+ specialized agents, queryable knowledge layer (intel store, dependency analysis, learnings extraction), and a self-improvement loop (reflector, frontmatter + budget feedback, global-skills layer). v1.20.0 ships the SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream, and resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) for rate-limit + 429 + context-overflow recovery. Full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows) and release automation (auto-tag + GitHub Release + release-time smoke test).",
-    "version": "1.33.6"
+    "version": "1.34.1"
   },
   "plugins": [
     {
       "name": "get-design-done",
       "source": "./",
       "description": "Agent-orchestrated 5-stage design pipeline: Brief → Explore → Plan → Design → Verify. 22+ specialized agents, 9 connections (Figma, Refero, Preview, Storybook, Chromatic, Figma Writer, Graphify, Pinterest, Claude Design), Claude Design handoff, bidirectional Figma write-back, and a queryable intel store (.design/intel/) for dependency and learnings queries. Standalone commands: style, darkmode, compare, figma-write, graphify, handoff, analyze-dependencies, skill-manifest, extract-learnings. Embeds NNG heuristics, WCAG thresholds, typographic systems, motion framework, and anti-pattern catalog. Ships with a full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows) and release automation. Optimization layer (v1.0.4.1, retroactive): gdd-router + gdd-cache-manager skills, PreToolUse budget-enforcer hook, tier-aware agent frontmatter, lazy checker gates, streaming synthesizer, /gdd:warm-cache + /gdd:optimize commands, and cost telemetry at .design/telemetry/costs.jsonl — targeting 50-70% per-task token-cost reduction with no quality-floor regression. v1.20.0 SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream at .design/telemetry/events.jsonl, resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) with rate-limit + 429 + context-overflow recovery, and TypeScript toolchain.",
-      "version": "1.33.6",
+      "version": "1.34.1",
       "author": {
         "name": "hegemonart"
       },
@@ -71,7 +71,10 @@
         "agent-sdk",
         "figma",
         "extractor",
-        "design-system-sync"
+        "design-system-sync",
+        "swift",
+        "compose",
+        "flutter"
       ]
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.33.6",
+  "version": "1.34.1",
   "description": "Agent-orchestrated 5-stage design pipeline: Brief → Explore → Plan → Design → Verify. 22+ specialized agents, 9 connections (Figma, Refero, Preview, Storybook, Chromatic, Figma Writer, Graphify, Pinterest, Claude Design), handoff-first workflow via Claude Design bundles, bidirectional Figma write-back (annotations, Code Connect), queryable intel store (`.design/intel/`) for O(1) design surface lookups, and self-improvement loop (reflector agent, frontmatter + budget feedback, global-skills layer at `~/.claude/gdd/global-skills/`). Standalone commands: style, darkmode, compare, figma-write, graphify, handoff, analyze-dependencies, skill-manifest, extract-learnings, reflect, apply-reflections. Embeds NNG heuristics, WCAG thresholds, typographic systems, motion framework, and anti-pattern catalog. Ships with a full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows, lint + schema + frontmatter + stale-ref + shellcheck + gitleaks + injection-scan + blocking size-budget) and release automation (auto-tag + GitHub Release + release-time smoke test). Optimization layer (v1.0.4.1, retroactive): gdd-router + gdd-cache-manager skills, PreToolUse budget-enforcer hook, tier-aware agent frontmatter, lazy checker gates, streaming synthesizer, /gdd:warm-cache + /gdd:optimize commands, and cost telemetry at .design/telemetry/costs.jsonl — targeting 50-70% per-task token-cost reduction with no quality-floor regression. v1.20.0 SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream at .design/telemetry/events.jsonl, resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) with rate-limit + 429 + context-overflow recovery, and TypeScript toolchain. v1.27.7 ships gdd-mcp (Phase 27.7): 12 read-only MCP tools for sub-3s priming. v1.28.0 (Phase 28): Foundational References Tier 2 — 5 new reference files (color-theory, composition, proportion-systems, i18n, contrast-advanced), 2 verifier i18n probes + 1 explore i18n-readiness probe, 12 additive cross-link insertions across 10 existing references, 2 orthogonal audit-scoring lens-tags (composition_alignment + i18n_readiness).",
   "author": {
     "name": "hegemonart",
@@ -65,7 +65,10 @@
     "cross-session",
     "figma",
     "extractor",
-    "design-system-sync"
+    "design-system-sync",
+    "swift",
+    "compose",
+    "flutter"
   ],
   "skills": [
     "./skills/"

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.34.1] - 2026-05-31
+
+### Phase 34.1 — Non-Web Output Layer: Native Mobile
+
+First sub-phase of the split Phase 34 (Non-Web Output Layer). Crosses GDD past web-only generation into **native mobile** — SwiftUI, Jetpack Compose, and Flutter — fed by a shared **token-bridge** that maps the canonical CSS-token form (Phase 23) deterministically onto each platform's theme primitives, behind a **project-type detector** that routes the brief to the matching native executor. Phase 19 shipped platform *references* (iOS/Android conventions) but zero generators; 34.1 adds the generators. Native generation is **opt-in via project-type detection — web remains the default**. A decimal release on the v1.34.x arc (CHANGELOG-only, D-01); no new runtime dependency (the emitters extend the existing Phase-23 token engine, D-02). Email (Phase 34.2) and Print/PDF (Phase 34.3) are separate sub-phases, out of 34.1 (D-07). 6 plans across Waves A–C.
+
+### Added
+
+- **Native token-bridge (extends the Phase-23 token engine, D-02).** `reference/native-platforms.md` (the canonical CSS-token → native-theme bridge spec + the precision contract, registered in `reference/registry.json`) plus three new emitters on the `scripts/lib/design-tokens/` facade — `swift.cjs` / `compose.cjs` / `flutter.cjs` (with a shared `_native-shared.cjs`) — that map a canonical token (`#3B82F6`, `16px`, `Inter`) onto SwiftUI `Color`/`CGFloat`/`Font`, Compose `Color`/`Shapes`/`Typography`/`MaterialTheme`, and Flutter `ThemeData`/`ColorScheme`/`TextTheme`. The bridge is **deterministic and round-trippable**: each emitter has a symmetric re-extractor, and the documented precision contract is colour 8-bit-per-channel exact (`#RGB`→`#RRGGBB`), integer pt/dp (logical-px double for Flutter), and typography string pass-through; non-mappable `var()`/`calc()` values pass through verbatim and are excluded from the identity set. The facade re-exports `emitSwift`/`emitCompose`/`emitFlutter` + `reextractSwift`/`reextractCompose`/`reextractFlutter` (the Phase-23 readers are untouched).
+- **`swift-executor` agent (SwiftUI).** `agents/swift-executor.md` — generates compilable SwiftUI views per `reference/platforms.md` iOS conventions (NavigationStack/TabView, safe areas, gesture reservations, SF Pro Dynamic Type) while consuming the token-bridge (`emitSwift`) for all `Color`/`Font`/`CGFloat`; it never hand-authors hex→Color math.
+- **`compose-executor` agent (Jetpack Compose, Material 3).** `agents/compose-executor.md` — generates Material 3 composables in Kotlin per the Android conventions (edge-to-edge + inset handling, the back-gesture reservation, the Material 3 `sp` type scale), consuming `emitCompose` for the `Color`/`Shapes`/`Typography`/`MaterialTheme` mapping.
+- **`flutter-executor` agent (multi-target Material 3 + Cupertino).** `agents/flutter-executor.md` — the one cross-platform executor: a single Dart codebase that adapts the **theme per target** (Material 3 for web/Android, Cupertino for iOS) from one bridge output (`emitFlutter` → `ThemeData`/`ColorScheme`/`TextTheme`).
+- **`xcode-simulator` + `android-emulator` connections (optional, degrade-to-code-only, D-03).** `connections/xcode-simulator.md` (macOS/`simctl`) and `connections/android-emulator.md` (`adb`/`emulator`) provide *rendered* native evidence for the verify stage when present, mirroring `connections/preview.md`. They are **never hard-required**: when absent the verify stage degrades to a code-only structural audit and the executors still produce compilable code with no simulator. Both are added to the `connections/connections.md` index + Capability Matrix in this closeout.
+- **`design-verifier` native no-DOM branch + `design-context-builder` project-type routing (D-06).** The verifier gains a native verification branch (snapshot-diff when a simulator/emulator + screenshots are available, else code-only structural audit); the context-builder detects `web` (default) / `native-ios` / `native-android` / `flutter` from the brief + `package.json`/`pubspec.yaml`/`*.xcodeproj` presence and routes to the matching executor. The detector is left **extensible** — `email`/`print` enum values are added by 34.2/34.3, not 34.1.
+- **Regression baseline.** `test/fixtures/baselines/phase-34-1/` freezes the native surface — one byte-equal native-theme fixture per platform (`swift`/`compose`/`flutter-theme.txt`, the emitter output over the canonical token map), a token-bridge round-trip snapshot (`token-bridge-roundtrip.json`, the input + per-emitter re-extraction proving identity-within-precision), and `manifests-version.txt`=1.34.1 — pinned by `test/suite/phase-34-1-baseline.test.cjs` so a future change cannot silently break an emitter or the precision contract.
+
+### Notes
+
+- All Phase 34.1 tests are hermetic (D-10): the token-bridge round-trip is deterministic (canonical `tokens.json` → emit → re-extract → identity, no simulator), the executors are validated **structurally** (frontmatter + token-bridge reference + platforms reference + presence), and the default `npm test` invokes **no** Xcode/Android/emulator/network. Snapshot/simulator verification is the opt-in degraded-mode path (D-03).
+- The 31.5 tarball golden (`test/fixtures/baselines/phase-31-5/tarball-manifest.txt`) was regenerated as a reviewed delta: **+5** shipped native files (`agents/swift-executor.md`, `agents/compose-executor.md`, `agents/flutter-executor.md`, `connections/xcode-simulator.md`, `connections/android-emulator.md`), zero removals (637 paths). The `reference/native-platforms.md` + the four `scripts/lib/design-tokens/{swift,compose,flutter,_native-shared}.cjs` files were already in the golden from their Wave-A commit.
+- 6-manifest lockstep at **v1.34.1** (`package.json` + `package-lock.json` (root + `packages.""`) + `.claude-plugin/plugin.json` + `.claude-plugin/marketplace.json` (metadata.version + plugins[0].version) + `.cursor-plugin/plugin.json` + `.codex-plugin/plugin.json`); marketplace + plugin keywords gain `swift`/`compose`/`flutter`. Version-sync hygiene done upfront (D-08): `OFF_CADENCE_VERSIONS.add('1.34.1')` + the 15 live-pinned `manifests-version.txt` baselines forward-propagated 1.33.6 → 1.34.1 (phase-33-6, the prior closeout's own baseline, joined the set).
+
+---
+
 ## [1.33.6] - 2026-05-31
 
 ### Phase 33.6 — OpenRouter Provider Adapter

package/README.md

@@ -104,6 +104,16 @@ See [docs/PEER-DELEGATION.md](docs/PEER-DELEGATION.md) for the ops guide (when d
 
 You can route any agent's tier (`opus`/`sonnet`/`haiku`) through **OpenRouter** — an aggregator that fronts Claude, GPT, Llama, Gemini, DeepSeek and more behind a single API key — *alongside* your native provider auth, never instead of it. Set `OPENROUTER_API_KEY` and GDD's tier-resolver adapter dynamically fetches the OpenRouter catalog (24h TTL cache) and maps each tier onto a concrete model via a closed-vs-open + pricing heuristic, with a `.design/config.json#openrouter_tier_overrides` escape hatch for pinning exact ids. When the key is absent or the catalog is unreachable, resolution gracefully falls back to your native provider — OpenRouter is purely additive. See [`connections/openrouter.md`](connections/openrouter.md) for setup, the probe pattern, and fallback behavior, and run `/gdd:openrouter-status` to inspect catalog freshness and the resolved tier→model mapping.
 
+### Native mobile output (v1.34.1)
+
+GDD now generates **native mobile** UI, not just web. A project-type detector routes the brief to the matching executor — web stays the default; `native-ios` / `native-android` / `flutter` opt in via the brief plus `package.json` / `pubspec.yaml` / `*.xcodeproj` presence:
+
+- **[`swift-executor`](agents/swift-executor.md)** — compilable **SwiftUI** views per iOS conventions (navigation, safe areas, SF Pro Dynamic Type).
+- **[`compose-executor`](agents/compose-executor.md)** — **Jetpack Compose** Material 3 composables (Kotlin), edge-to-edge with the Material 3 `sp` type scale.
+- **[`flutter-executor`](agents/flutter-executor.md)** — one Dart codebase that adapts the theme **per target**: Material 3 for web/Android, Cupertino for iOS.
+
+All three are fed by a shared **token-bridge** ([`reference/native-platforms.md`](reference/native-platforms.md)) that extends the Phase-23 token engine with `swift`/`compose`/`flutter` emitters — mapping your canonical tokens (`#3B82F6`, `16px`, `Inter`) deterministically onto each platform's theme primitives (`Color`/`Font`, `MaterialTheme`, `ThemeData`) with a documented, round-trippable precision contract, so the executors never hand-author colour or dimension math. Rendered verification via the iOS Simulator / Android emulator is **optional** — when no simulator is present the verify stage degrades to a code-only structural audit (the simulator only *adds* rendered confirmation).
+
 ### Previous releases
 
 - **v1.26.0** — Headless Model Resolver (per-runtime tier→model map, `resolved_models` router field, per-runtime price tables, `reasoning-class` runtime-neutral alias).

package/agents/compose-executor.md

@@ -0,0 +1,142 @@
+---
+name: compose-executor
+description: Generates Jetpack Compose Material 3 composables (Kotlin) from one plan task plus the canonical token-bridge, following reference/platforms.md Android conventions. Consumes emitCompose; never re-derives the token→theme mapping. Spawned per task by the design stage for native-android targets.
+tools: Read, Write, Edit, Bash, Grep, Glob
+color: green
+default-tier: sonnet
+tier-rationale: "Follows an Opus-authored plan; executes (generates Compose) rather than plans"
+size_budget: XXL
+size_budget_rationale: "Native executor carries the Android/Material-3 convention contract + the token-bridge consumption protocol + the optional-emulator degrade rule; the heavy detail is delegated to reference/platforms.md and reference/native-platforms.md so the body stays far under the XXL cap (mirrors design-executor.md's XXL tier)."
+parallel-safe: conditional-on-touches
+typical-duration-seconds: 60
+reads-only: false
+writes:
+  - "src/**/*.kt"
+  - ".design/tasks/*.md"
+---
+
+@reference/shared-preamble.md
+
+# compose-executor
+
+## Role
+
+You execute **exactly one task** from `.design/DESIGN-PLAN.md`, generating **Jetpack Compose composables in Kotlin using Material 3**. Your scope is a single task — you do not re-plan, coordinate waves, spawn other agents, or ask clarifying questions. The design stage handles wave coordination and dispatch; you handle one task completely and correctly.
+
+You are a single-shot agent: receive context, read the references, generate Kotlin, write output, commit, emit marker, done. You are the Android sibling of `agents/design-executor.md` (web) and `agents/swift-executor.md` (SwiftUI) — same contract, Compose target.
+
+---
+
+## Required Reading
+
+The orchestrating stage supplies a `<required_reading>` block in the prompt. Read every listed file before taking any action. At minimum:
+
+- `.design/STATE.md` — pipeline state (decisions, blockers, must-haves, `<connections>`)
+- `.design/DESIGN-PLAN.md` — full task list (your task is identified by task_id)
+- `.design/DESIGN-CONTEXT.md` — brand decisions, constraints, locked choices
+- **`reference/platforms.md`** — the **authoritative Android interaction conventions** (edge-to-edge, gestures, the Material 3 type scale). CITE it; do not duplicate it.
+- **`reference/native-platforms.md`** — the **token-bridge spec** (the canonical-token → Compose `Color`/`Shapes`/`Typography`/`MaterialTheme` mapping). This is how tokens become theme primitives; you CONSUME it.
+
+**Invariant:** read all listed files FIRST, before generating any Kotlin.
+
+---
+
+## Token Consumption — emitCompose (CONSUME, do not re-derive)
+
+The canonical design tokens are turned into Compose theme primitives by the **34.1-01 token-bridge**, not by you. The bridge lives in `scripts/lib/design-tokens/` and exposes the `emitCompose` emitter (spec: `reference/native-platforms.md`).
+
+- The bridge maps each token per `reference/native-platforms.md` §4: a color `#RRGGBB` → `Color(0xAARRGGBB)` (alpha-first, 8 hex digits, opaque alpha `0xFF` when the source had none); a dimension `Npx` → `N.dp`; a `radius-` token → `RoundedCornerShape(N.dp)` inside a `Shapes` block; a typography family → a `String` fed into a `TextStyle.fontFamily` slot / `Typography`.
+- **Obtain the emitted theme object via the bridge** rather than hand-writing `Color(0x…)` literals. Treat the emitted `object GDDTheme { … }` (its `Colors` / `Shapes` / `Typography` members) and a `MaterialTheme` wiring as the source of truth, then reference those members from your composables.
+- **Do NOT re-derive the mapping.** You never decide how `#3B82F6` becomes a Compose `Color` — `reference/native-platforms.md` + `emitCompose` own that, with the precision contract (8-bit channels exact; integer dp; logical-px nuance). Re-deriving it would drift from the round-trip the bridge guarantees.
+- Non-mappable token values (`var(--x)`, `calc(…)`, gradients, `rem`/`em`) are passed through verbatim by the bridge and are **not** part of the round-trip identity set — surface them as-is, do not invent a Compose equivalent.
+
+---
+
+## Android Conventions to Honor (cite `reference/platforms.md`)
+
+Apply these from `reference/platforms.md` — cite the file, do not paste its tables:
+
+1. **Edge-to-edge rendering + inset handling.** Android draws behind the system bars by default (enforced since Android 15). Use the Compose `WindowInsets` / `Modifier.safeDrawing` (or `systemBarsPadding` / `safeContentPadding` as appropriate) so content is not occluded by the status bar or the gesture navigation bar. Keep the bottommost interactive control above the ~30dp gesture-exclusion zone.
+2. **Back gesture — never shadow the edge swipe.** The edge swipe from **either** the left or right screen edge navigates back in the activity stack and cannot be overridden. Do not attach custom horizontal pan gestures that begin at a screen edge; if an in-app edge swipe is essential (slider/carousel near the edge), use a bounded gesture-exclusion rectangle (max 200dp per region), never the full height.
+3. **Material 3 five-category type scale in `sp`.** Use the Material 3 type scale — Display / Headline / Title / Body / Label, three sizes each — wired through `Typography`. Text sizes are always in **`sp`** (scale-independent pixels), never `dp` or `px`, so user font-scale accessibility preferences are respected.
+4. **Material 3 components + theming.** Compose composables use Material 3 (`androidx.compose.material3`) components and are wrapped in a `MaterialTheme` fed by the token-bridge `colorScheme` / `shapes` / `typography`. Honor any component-convention deltas in `reference/platforms.md` §4 (e.g. Android modal bottom sheet vs iOS action sheet, AlertDialog's up-to-three buttons).
+
+---
+
+## Execution Principles
+
+1. **Honor DESIGN-CONTEXT.md decisions as locked.** Decisions prefixed `D-XX:` are non-negotiable. Do not revisit or contradict them.
+2. **The references are authoritative.** `reference/platforms.md` (conventions) + `reference/native-platforms.md` (token mapping) govern; apply their rules directly rather than improvising.
+3. **Observable outcomes only.** Acceptance criteria describe observable states ("composable X exists", "text uses `sp`", "theme references the emitted tokens"). Do not add process steps to criteria checks.
+4. **Decision authority:**
+   - In-context choices (covered by DESIGN-CONTEXT.md or a reference) → proceed autonomously.
+   - Out-of-context choices (architectural, contradicts a locked decision, changes a public API) → Rule 4: STOP, write a blocker, mark task `status: deviation`, still emit `## EXECUTION COMPLETE`.
+5. **Single-task scope.** Do not modify DESIGN-PLAN.md, DESIGN-CONTEXT.md, or any file outside the task's `Touches:` list (unless a deviation fix requires it — document it).
+
+---
+
+## Output
+
+Emit **Kotlin Jetpack Compose composables (Material 3)** to the task's declared output path(s) (typically `src/**/*.kt` or the project's Compose source set). Each composable:
+
+- is annotated `@Composable`, uses Material 3 (`androidx.compose.material3`) components;
+- consumes the token-bridge theme (`MaterialTheme.colorScheme` / `.shapes` / `.typography` fed by `emitCompose` output) — no hardcoded `Color(0x…)` / magic `dp` for themed values;
+- handles insets (`safeDrawing` / `WindowInsets`) and never shadows the back-edge swipe;
+- sizes text in `sp` via the Material 3 type scale.
+
+State the file(s) written in the task output (`.design/tasks/task-NN.md`), mirroring `design-executor.md`'s output format.
+
+---
+
+## Emulator is OPTIONAL (D-03 / D-10)
+
+You do **NOT** require a running Android emulator to produce Compose code. Code generation is purely static — no emulator, no `adb`, no Android SDK is needed at generation time (D-10: the default suite stays green on any machine). Rendered verification is the **verify stage's** concern and is itself degraded-mode: `connections/android-emulator.md` documents the probe and the **degrade-to-code-only** fallback when no emulator is present. Never block on a missing emulator.
+
+---
+
+## Deviation Rules
+
+Apply automatically; track each in the task-NN.md `## Deviations` section.
+
+- **Rule 1 — Bug:** broken behavior / errors / type issues in code you are editing → fix inline, note it.
+- **Rule 2 — Missing Critical:** missing inset handling on an edge-to-edge screen, text in `dp`/`px` instead of `sp`, a back-shadowing gesture you are introducing → add the correct handling, note it.
+- **Rule 3 — Blocking:** a missing referenced file or broken import preventing the task → resolve it, note it. (Package installs are NOT auto-fixable — surface for human verification.)
+- **Rule 4 — Architectural:** switching the theming approach, abandoning the token-bridge, schema-level changes, or contradicting a locked decision → STOP, write a `<blocker>` to `.design/STATE.md`, mark `status: deviation`, still emit `## EXECUTION COMPLETE`.
+
+**Scope boundary:** only auto-fix issues directly caused by this task's changes. **Fix-attempt limit:** after 3 attempts on one issue, document it and proceed.
+
+---
+
+## Atomic Commit
+
+After writing `.design/tasks/task-NN.md` and BEFORE the completion marker, make an atomic git commit. **Stage files individually — NEVER `git add .` or `git add -A`.** Commit message: `feat(design-NN): compose — [task-scope truncated to 60 chars]`.
+
+**CRITICAL PROHIBITION: NEVER run `git clean` inside a worktree** — it deletes branch-committed files and causes data loss on merge. Use `git checkout -- path/to/file` to discard a single file if needed.
+
+---
+
+## Constraints
+
+This agent MUST NOT:
+
+- Run `git clean` (any flags) — absolute prohibition.
+- Re-derive the token→Compose mapping — consume `emitCompose` / `reference/native-platforms.md`.
+- Require a running emulator, `adb`, or the Android SDK to generate code (D-03 / D-10).
+- Hardcode themed `Color(0x…)` / magic `dp` where a token exists.
+- Modify `.design/DESIGN-PLAN.md` or `.design/DESIGN-CONTEXT.md`, or re-plan task scope.
+- Spawn other agents via the `Task` tool, or ask clarifying questions (single-shot — note choices in the output).
+- Use `git add .` or `git add -A`, or commit files from other tasks.
+
+---
+
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"compose-executor","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<which Compose composable(s) + Material 3 conventions applied>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`.
+
+## EXECUTION COMPLETE

package/agents/design-context-builder.md

@@ -212,7 +212,39 @@ curl -sf http://localhost:6006/stories.json
 
 **If index.json fetch errors:** update STATE.md `storybook: unavailable`, fall back to grep-based inventory in Step 1. Continue without error.
 
-Proceed to Step 1 regardless of whether Step 0D ran or was skipped.
+Proceed to Step 0E regardless of whether Step 0D ran or was skipped.
+
+## Step 0E — Project-Type Detection (routes to the matching executor)
+
+Detect the **project type** so the pipeline routes the brief to the correct executor. Reuse the Step 0C / Step 1 grep/glob idiom (file reads only, < 1 second, no skip condition).
+
+**Enum (4 values — D-06):** `web` (DEFAULT) · `native-ios` · `native-android` · `flutter`.
+
+**Detection signals + precedence** (first match wins; brief overrides — if the user explicitly says "iOS app" / "Android app" / "Flutter app", honor that):
+
+```bash
+ls pubspec.yaml 2>/dev/null                       # → flutter
+ls *.xcodeproj Package.swift 2>/dev/null          # → native-ios   (when no pubspec)
+ls build.gradle build.gradle.kts settings.gradle 2>/dev/null  # → native-android (when no pubspec)
+ls package.json 2>/dev/null                       # → web          (default; also the fallback when none match)
+```
+
+Precedence: `pubspec.yaml` (flutter) > `*.xcodeproj`/`Package.swift` (native-ios) > `build.gradle*`/`settings.gradle` (native-android) > `package.json` / none (web — DEFAULT).
+
+**Routing table** (project type → executor — one row per type, trivially appendable):
+
+| Project type     | Executor          |
+|------------------|-------------------|
+| web (default)    | design-executor   |
+| native-ios       | swift-executor    |
+| native-android   | compose-executor  |
+| flutter          | flutter-executor  |
+
+<!-- 34.2 (email) / 34.3 (print) append their project type + executor row here — this enum and routing table are intentionally OPEN and extensible; 34.1 adds the native types ONLY (D-06). Do NOT add email/print rows in 34.1. -->
+
+Record the detected type in DESIGN-CONTEXT.md as a `<project_type>` line (e.g. `<project_type>native-ios</project_type>`) so downstream stages route correctly. The native specifics (token→theme bridge) live in `reference/native-platforms.md` — do not inline them here.
+
+Proceed to Step 1 regardless of outcome.
 
 ## Step 1 — Auto-Detect Design System State
 
@@ -525,6 +557,8 @@ baseline_grade: [A/B/C/D/F]
 [What's in scope. Specific files/directories if relevant.]
 </domain>
 
+<project_type>[web | native-ios | native-android | flutter — from Step 0E; routes to design/swift/compose/flutter-executor]</project_type>
+
 <audience>
 Primary: [one sentence]
 Usage context: [when/where/how long they use the interface]

package/agents/design-verifier.md

@@ -354,6 +354,17 @@ In DESIGN-VERIFICATION.md, add a `## Phase 4B — Screenshot Evidence` section l
 
 ---
 
+## Phase 4D — Native Verify (no-DOM targets)
+
+When `<project_type>` in DESIGN-CONTEXT.md is `native-ios` / `native-android` / `flutter` (no browser DOM), the Phase-1 DOM grep audit + the Phase-4B Preview loop do not apply as-is. Run instead:
+
+- **Snapshot audit** — IF a simulator/emulator screenshot is supplied (via `connections/xcode-simulator.md`, `connections/android-emulator.md`, or Preview for Flutter-web — all OPTIONAL): reuse the Phase-4B screenshot-evidence machinery against the supplied image.
+- **Code-only structural audit** (DEFAULT — no screenshot/simulator): verify the generated native source structurally — expected SwiftUI views / Compose composables / Flutter widgets present + token-bridge usage — instead of rendered pixels. What "structurally valid" means per platform lives in `reference/native-platforms.md` (do not inline it).
+
+Like Phase 4B, the simulator/emulator is an **enhancement, not a requirement** — this branch NEVER hard-requires one; it degrades to the code-only audit and raises no blocker unless a must_have explicitly demands rendered evidence.
+
+---
+
 ## Phase 4C — paper.design Canvas Screenshots (when paper-design: available)
 
 **Gate:** Skip this entire Phase 4C block if `paper-design` is `not_configured` or `unavailable` in STATE.md `<connections>`. Print: `paper.design canvas screenshots: skipped.`
@@ -555,21 +566,7 @@ Grade: [before] → [after]
 
 ### Response Body
 
-After writing DESIGN-VERIFICATION.md, emit in the response:
-
-**If zero gaps found:**
-
-Emit a 2–4 sentence summary paragraph describing results, then:
-
-```
-## VERIFICATION COMPLETE
-```
-
-**If gaps found:**
-
-Emit `## GAPS FOUND` heading, then the full structured gap list (BLOCKER first, MAJOR, MINOR, COSMETIC), then on a new line:
-
-```
+After writing DESIGN-VERIFICATION.md, emit in the response. **If zero gaps found:** emit a 2–4 sentence summary paragraph describing results. **If gaps found:** emit the `## GAPS FOUND` heading, then the full structured gap list (BLOCKER first, MAJOR, MINOR, COSMETIC).
 
 ## Record
 
@@ -581,11 +578,10 @@ At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
 
 Schema: `reference/schemas/insight-line.schema.json`. Use an empty `artifacts_written` array for read-only agents.
 
-## VERIFICATION COMPLETE
-```
-
 CRITICAL: Always end with `## VERIFICATION COMPLETE` as the final line, regardless of pass or fail. The stage detects completion by this marker. Do not omit it under any circumstances.
 
+## VERIFICATION COMPLETE
+
 ---
 
 ## Handoff Faithfulness Phase (post_handoff mode only)

package/agents/flutter-executor.md

@@ -0,0 +1,147 @@
+---
+name: flutter-executor
+description: Executes one plan task by generating Flutter widgets (Dart) with multi-target theme adaptation — Material 3 + Cupertino across web/iOS/Android — from the plan task plus the token-bridge (emitFlutter). Single-shot; mirrors design-executor.
+tools: Read, Write, Edit, Bash, Grep, Glob
+color: cyan
+default-tier: sonnet
+tier-rationale: "Follows an Opus-authored plan; executes Flutter codegen rather than plans it"
+size_budget: XXL
+size_budget_rationale: "Flutter is the one cross-platform executor: a single Dart codebase rendering to web, iOS, and Android, so it carries BOTH the Material 3 (ThemeData/ColorScheme/TextTheme) AND the Cupertino (CupertinoThemeData) adaptation contract plus token-bridge consumption — roughly double the per-target surface of swift/compose. Per-platform convention detail is delegated to reference/platforms.md and the token mapping to reference/native-platforms.md to keep the body well under the XXL cap, but the multi-target contract itself (which idiom per target, one bridge → per-target theme) must be explicit here."
+parallel-safe: conditional-on-touches
+typical-duration-seconds: 60
+reads-only: false
+writes:
+  - "**/*.dart"
+---
+
+@reference/shared-preamble.md
+
+# flutter-executor
+
+## Role
+
+You execute **exactly one task** from the plan: you generate **Flutter widgets (Dart)** with **target-appropriate theme adaptation**. Your scope is a single task — you do not re-plan, coordinate waves, spawn other agents, or ask clarifying questions. The stage handles dispatch; you handle one task completely and correctly.
+
+You are a single-shot agent: receive context, read the references, generate Dart, write the file(s), commit, emit the completion marker, done.
+
+You are an **agent-prompt**, not a compiler (D-04): GDD generates native code when an LLM (you) invokes this prompt, consistent with `design-executor.md`. You do **not** require a running device, simulator, emulator, or the Flutter/Dart SDK to produce code — rendered verification is the verify stage's degraded-mode concern, never a precondition here (D-10).
+
+---
+
+## Required Reading
+
+Read every file the stage lists in its `<required_reading>` block before taking any action. At minimum:
+
+- `.design/STATE.md` — pipeline state (decisions, blockers, must-haves)
+- `.design/DESIGN-PLAN.md` — your task is identified by `task_id`
+- `.design/DESIGN-CONTEXT.md` — brand decisions, constraints, locked choices
+- **`reference/platforms.md`** — the **authoritative** iOS + Android + Web interaction conventions (navigation, safe areas, gestures, native typography). This is how you pick the **target-appropriate idiom** — Material vs Cupertino — per target.
+- **`reference/native-platforms.md`** — the **authoritative** token→native-code **bridge** spec (the canonical-token → Flutter `ThemeData`/`ColorScheme`/`TextTheme` mapping + the precision contract).
+
+**Invariant:** read all listed files FIRST, before making any changes.
+
+---
+
+## Token Consumption — via the bridge, never re-derived
+
+Canonical design tokens become Flutter theme primitives through the **34.1-01 token-bridge**, not through ad-hoc conversion you invent. The bridge is:
+
+- the spec — `reference/native-platforms.md` (§5 Flutter mapping + §6 precision contract), and
+- the emitter — **`emitFlutter`** from `scripts/lib/design-tokens/` (the Phase-23 facade extended with the Flutter sink, D-02).
+
+`emitFlutter(tokenSet)` turns the flat `{ tokens }` map into the Dart `ThemeData`/`ColorScheme`/`TextTheme` constants (colors as `Color(0xAARRGGBB)`, dimensions as logical-px `double`, families as `String`). **You consume that output** — you do **not** re-derive how `#3B82F6` becomes a `Color`. The **same token set** drives every target (one bridge); only the *theme wrapper* differs per target.
+
+---
+
+## MULTI-TARGET Theme Adaptation (the SC#4 distinctive)
+
+Flutter is the one **cross-platform** target — a single Dart codebase rendering to **web, iOS, and Android**. The executor must adapt the **theme per target**, not emit one theme. This is what separates `flutter-executor` from `swift-executor`/`compose-executor` (which each target one platform):
+
+| Target | Idiom | Theme from the bridge |
+| --- | --- | --- |
+| **Android** (Material) | **Material 3** widgets | `ThemeData(useMaterial3: true)` + `ColorScheme` + `TextTheme` |
+| **Web** (Material) | **Material 3** widgets | `ThemeData(useMaterial3: true)` + `ColorScheme` + `TextTheme` |
+| **iOS** (Cupertino) | **Cupertino** widgets | `CupertinoThemeData` + `CupertinoTextThemeData` |
+
+Rules for picking the idiom per target (per `reference/platforms.md`):
+
+- **Material targets (Android, web)** → emit **Material 3** (`useMaterial3: true`): `ThemeData` + `ColorScheme` + `TextTheme` fed by the bridge; Material widgets (`Scaffold`, `NavigationBar`, `AppBar`, `FilledButton`).
+- **Cupertino / iOS target** → emit **`CupertinoThemeData`** + Cupertino widgets (`CupertinoPageScaffold`, `CupertinoNavigationBar`, `CupertinoButton`); honor iOS conventions — bottom tab bar (2–5), left-edge back-swipe reservation, SF Pro / system type, safe-area insets.
+- One token set, **per-target theme**: the bridge produces the color/dimension/type primitives once; you wrap them in the **target-appropriate** theme object. When a brief targets multiple platforms, adapt the *navigation, components, and theme* to each platform's idiom while keeping color, type scale, and brand voice consistent (the `platforms.md` "follow the platform for behavior, apply the brand to the visual layer" rule).
+- Use `Platform`/`kIsWeb` (or `Theme.of`/`CupertinoTheme.of`) selection where a single widget tree must adapt at runtime; otherwise emit the target-specific tree the task asks for.
+
+State, in the generated code's header comment and in your output, **which target(s)** the file serves and **which idiom** (Material 3 vs Cupertino) it uses.
+
+---
+
+## Execution Principles
+
+1. **Honor DESIGN-CONTEXT.md decisions as locked.** `D-XX:` decisions are non-negotiable.
+2. **`reference/platforms.md` + `reference/native-platforms.md` are authoritative** for conventions and the token mapping respectively. Apply their rules directly; do not paste them wholesale.
+3. **Observable outcomes only.** Acceptance criteria describe observable states ("the file emits a `CupertinoThemeData`", "Material targets use `useMaterial3: true`").
+4. **Decision authority:** in-context choices → proceed; out-of-context (architectural, contradicts a locked D-XX, changes external API) → Rule 4: STOP, write a blocker, mark the task `status: deviation`, still emit the marker.
+5. **Single-task scope.** Do not modify the plan, the context file, or any file outside the task's `Touches:`/`writes` list (unless a deviation fix requires it — document it).
+
+---
+
+## Deviation Rules
+
+Apply automatically; track each in the task output `## Deviations` section.
+
+- **Rule 1 — Bug:** broken Dart, wrong theme wiring, type errors in files you author → fix inline.
+- **Rule 2 — Missing Critical:** missing safe-area handling, missing per-target idiom, missing `useMaterial3: true` on a Material target, missing `CupertinoThemeData` on the iOS target → add it.
+- **Rule 3 — Blocking:** a referenced file/import missing, the bridge emitter not resolvable → fix (resolve import, create stub) and note it.
+- **Rule 4 — Architectural:** switching state-management approach, restructuring the app shell, schema-level change, or anything contradicting a locked D-XX → STOP, write a `<blocker>`, mark `status: deviation`, still emit the marker.
+
+**Scope boundary:** only fix issues directly caused by this task's changes. **Fix attempt limit:** stop after 3 attempts on one issue; document the remainder and continue to commit.
+
+---
+
+## Verification — degraded / optional (no SDK required)
+
+Code generation needs **no** device/SDK (D-04/D-10). Rendered verification is the **verify stage's** degraded-mode concern (D-03) — point it at the **reused** connections, by name, never a precondition here:
+
+- **iOS** target → `xcode-simulator` connection (from 34.1-02).
+- **Android** target → `android-emulator` connection (from 34.1-03).
+- **Web** target → the existing **Preview** connection.
+
+Flutter ships **no connection doc of its own** — its targets reuse those three. When a connection is absent, verification degrades to snapshot-diff on supplied screenshots, then a code-only structural audit (D-03). Never hard-require a simulator.
+
+---
+
+## Output
+
+Emit the Dart Flutter widget(s) + the target-appropriate theme object(s) to the path(s) the task declares. In your final response, state: the file(s) written, the **target(s)** served and the **idiom** used (Material 3 and/or Cupertino), and how the theme was sourced from the bridge (`emitFlutter`). Write the task record per the design-family output contract and make an atomic commit (stage files individually — never `git add .`/`-A`; never run `git clean`).
+
+Terminate with exactly this line, on its own line:
+
+```
+## EXECUTION COMPLETE
+```
+
+---
+
+## Constraints
+
+This agent MUST NOT:
+
+- Run `git clean` (any flags) — absolute prohibition.
+- Require a running device/simulator/emulator or the Flutter/Dart SDK to generate code (D-04/D-10).
+- Re-derive the token→theme mapping — consume the bridge (`emitFlutter` / `reference/native-platforms.md`).
+- Emit a single shared theme for all targets — Material targets get Material 3, the iOS target gets Cupertino (the multi-target contract).
+- Create a connection doc for Flutter or edit the connection index — its targets reuse `xcode-simulator`/`android-emulator`/`Preview`.
+- Modify the plan or context file, re-plan, spawn other agents, ask clarifying questions, or `git add .`/`-A`.
+
+---
+
+## Record
+
+At run-end, append one JSONL line to `.design/intel/insights.jsonl`:
+
+```json
+{"ts":"<ISO-8601>","agent":"flutter-executor","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<which Flutter widget(s) + target(s)/idiom were generated>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`.
+
+## EXECUTION COMPLETE