@hegemonart/get-design-done 1.33.6 → 1.34.2

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.2"
   },
   "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.2",
       "author": {
         "name": "hegemonart"
       },
@@ -71,7 +71,11 @@
         "agent-sdk",
         "figma",
         "extractor",
-        "design-system-sync"
+        "design-system-sync",
+        "swift",
+        "compose",
+        "flutter",
+        "email"
       ]
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.33.6",
+  "version": "1.34.2",
   "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,11 @@
     "cross-session",
     "figma",
     "extractor",
-    "design-system-sync"
+    "design-system-sync",
+    "swift",
+    "compose",
+    "flutter",
+    "email"
   ],
   "skills": [
     "./skills/"

package/CHANGELOG.md

@@ -4,6 +4,52 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.34.2] - 2026-05-31
+
+### Phase 34.2 — Non-Web Output Layer: Email
+
+Second sub-phase of the split Phase 34 (Non-Web Output Layer). Adds **email-template output** — a dedicated executor that generates email honoring the real client constraints (table-based layout, inline styles, MSO conditional comments for Outlook's Word engine, dark-mode `color-scheme` handling, and the top-20-client quirks) that modern web HTML/CSS breaks on — behind the same project-type detector that routes native (34.1). Email 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 executor generates the email as an agent-prompt and the plugin checks it with a deterministic static validator, no `mjml` runtime (D-02/D-10). Native (Phase 34.1) shipped; Print/PDF (Phase 34.3) is the next sub-phase, out of 34.2 (D-07). 4 plans across Waves A–C.
+
+### Added
+
+- **Email-constraint catalogue + static validator (no `mjml` dependency, D-02/D-03).** `reference/email-design.md` — the authoritative email-constraint catalogue (~30 catalogued constraints: table-based layout, inline styles, MSO conditional comments, dark-mode `color-scheme`, ~600px width, image/alt rules, and the top-20-client quirks), registered in `reference/registry.json`. `scripts/lib/email/validate-email-html.cjs` — a pure, deterministic static checker (zero `require`, no fs/network/mjml) that flags the statically-verifiable subset: `EM-LAYOUT-01` (no flexbox/grid/`position`), `EM-STYLE-01` (no `<style>` as the primary styling mechanism; a small `@media`-only block is tolerated), `EM-MSO-01` (an MSO conditional comment in a full email), `EM-DARK-01` (a `color-scheme` signal present) — returning `{ ok, violations:[{ rule, detail }] }`.
+- **`email-executor` agent (MJML canonical + derived HTML, D-02/D-04).** `agents/email-executor.md` — generates **one email template per task**: an MJML source (the canonical artifact) plus the equivalent derived HTML, generated against the `reference/email-design.md` catalogue and run through the static validator as its own self-check. It is an agent-prompt (like `design-executor`/`flutter-executor`), **not** a compiler — no running `mjml`, no Litmus account, no network is required to produce the email. Carries a `## Record` section from the start (the record-contract lesson) and an honest `size_budget`.
+- **`litmus` connection (optional render-test, degrade-to-static-validator, D-03).** `connections/litmus.md` — cross-client rendered screenshots (Email-on-Acid is the documented alternative) for the verify stage when present, mirroring `connections/chromatic.md`. **Never hard-required**: when absent the verify stage degrades to the static email-HTML validator / code-only structural audit. Added to the `connections/connections.md` index + Capability Matrix in this closeout.
+- **`design-context-builder` `email` project-type route + `design-verifier` email-verify branch (delegated, D-06/D-09).** The context-builder appends the `email` enum + the `email-executor` route at the 34.1 seam (the seam is left open for 34.3/print). The verifier gains an email-verify branch by **delegation** to `reference/email-design.md` (the verifier stayed within its ≤700-line budget).
+- **Regression baseline.** `test/fixtures/baselines/phase-34-2/` freezes the email surface — a valid email fixture (`email-good.html`), a validator golden (`validator-golden.json`, the recorded `validateEmailHtml` output for a passing + a failing fixture, proving the rule-output shape is frozen), and `manifests-version.txt`=1.34.2 — pinned by `test/suite/phase-34-2-baseline.test.cjs` so a future change cannot silently break the validator or its verdict shape.
+
+### Notes
+
+- All Phase 34.2 tests are hermetic (D-10): the static email-HTML validator is a pure string→verdict function (fixture HTML → constraint checks, no network/mjml), the email-executor is validated **structurally** (frontmatter + catalogue reference + validator reference + presence), and the default `npm test` invokes **no** Litmus/Email-on-Acid and pulls in **no** `mjml` runtime. Rendered cross-client 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: **+2** newly-shipped files (`agents/email-executor.md`, `connections/litmus.md`), zero removals (641 paths). The other two new email files (`reference/email-design.md`, `scripts/lib/email/validate-email-html.cjs`) were already in the golden from their Wave-A (34.2-01) commit — so the four new shipped files net to a +2 line-delta on the golden.
+- 6-manifest lockstep at **v1.34.2** (`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 `plugins[0].keywords` + plugin keywords gain `email`. Version-sync hygiene done upfront (D-08): `OFF_CADENCE_VERSIONS.add('1.34.2')` + the 16 live-pinned `manifests-version.txt` baselines forward-propagated 1.34.1 → 1.34.2 (phase-34-1, the prior closeout's own baseline, joined the set).
+
+---
+
+## [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,24 @@ 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).
+
+### Email output (v1.34.2)
+
+GDD also generates **email templates** — the project-type detector routes an `email` brief to a dedicated executor that honors the real client constraints web HTML/CSS breaks on:
+
+- **[`email-executor`](agents/email-executor.md)** — generates one email per task as **MJML source (canonical) + the derived HTML**, against the constraint catalogue, with the static validator as its own self-check. It is an agent-prompt, not a compiler — **no `mjml` runtime, no Litmus account, no network** is needed to produce the email.
+
+The constraints live in [`reference/email-design.md`](reference/email-design.md) — table-based layout (no flexbox/grid/`position`), inline styles (no `<style>` sheet in Gmail), MSO conditional comments for Outlook's Word engine, dark-mode `color-scheme` handling, ~600px width, and the top-20-client quirks. A deterministic static checker ([`scripts/lib/email/validate-email-html.cjs`](scripts/lib/email/validate-email-html.cjs)) flags the statically-verifiable subset (`EM-LAYOUT`/`EM-STYLE`/`EM-MSO`/`EM-DARK`). Cross-client rendered verification via [`Litmus`](connections/litmus.md) (or Email-on-Acid) is **optional** — when absent the verify stage degrades to the static validator. Email generation is opt-in; **web stays the default**.
+
 ### 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,41 @@ 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 (5 values — D-06):** `web` (DEFAULT) · `native-ios` · `native-android` · `flutter` · `email`.
+
+**Detection signals + precedence** (first match wins; brief overrides — if the user explicitly says "iOS app" / "Android app" / "Flutter app" / "email" / "newsletter" / "email template", 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 **/*.mjml email/ emails/ templates/email 2>/dev/null  # → email (email-template signals)
+ls package.json 2>/dev/null                       # → web          (default; also the fallback when none match)
+```
+
+Precedence: an explicit brief override (the user says "email" / "newsletter" / "email template") wins like the other brief-overrides; otherwise `pubspec.yaml` (flutter) > `*.xcodeproj`/`Package.swift` (native-ios) > `build.gradle*`/`settings.gradle` (native-android) > `.mjml` files / an `email/` templates directory (email) > `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  |
+| email            | email-executor    |
+
+<!-- 34.2 added `email` (above) → email-executor; 34.3 (print) appends its project type + executor row HERE — this enum and routing table stay intentionally OPEN and extensible (D-06). 34.2 adds email ONLY; do NOT add a print row until 34.3. -->
+
+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`; the email specifics (table layout, inline styles, MSO/dark-mode constraints) live in `reference/email-design.md` — do not inline either here.
+
+Proceed to Step 1 regardless of outcome.
 
 ## Step 1 — Auto-Detect Design System State
 
@@ -525,6 +559,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,24 @@ 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 4E — Email Verify (project_type: email)
+
+When `<project_type>` is `email` (no browser DOM — the Phase-1 DOM grep + Phase-4B Preview loop do not apply), run an email-constraint audit BY DELEGATION (the ~30 constraints live in `reference/email-design.md` — the authority; do NOT inline them):
+
+- **Static constraint audit** (DEFAULT) — run `scripts/lib/email/validate-email-html.cjs` (`validateEmailHtml`) over the generated email HTML and report its violations (table layout / inline styles / MSO conditional comments / dark-mode `color-scheme`).
+- **Rendered enhancement** (OPTIONAL) — IF the Litmus connection (`connections/litmus.md`) is available, reuse the Phase-4B screenshot-evidence machinery against its cross-client screenshots; when absent, DEGRADE to the static validator / code-only. Litmus is an **enhancement, never hard-required** (D-03 — the Phase-4D precedent); raise no blocker for its absence.
+
+---
+
 ## 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 +573,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 +585,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/email-executor.md

@@ -0,0 +1,148 @@
+---
+name: email-executor
+description: Executes one plan task by generating an email template — MJML source (canonical) + the derived HTML — honoring reference/email-design.md constraints, validated by the static email-HTML checker. Single-shot; mirrors design-executor.
+tools: Read, Write, Edit, Bash, Grep, Glob
+color: magenta
+default-tier: sonnet
+tier-rationale: "Follows an Opus-authored plan; executes email codegen rather than plans it"
+size_budget: M
+size_budget_rationale: "Honest tier sized to the actual ~148-line body (M cap 300), NOT inflated to the design-family XXL default. Email carries a two-artifact contract (MJML canonical + derived HTML, D-02) plus a four-class static-validator self-check (EM-LAYOUT/STYLE/MSO/DARK) and an optional render-test posture, comparable to a lean single-target native executor body. The ~600px/ghost-table/VML/per-client quirk detail is DELEGATED to reference/email-design.md (the catalogue), keeping the body well under M; only the generation + validation + degrade contract is stated here. Raise to LARGE only if the per-client surface is ever inlined here instead of the catalogue."
+parallel-safe: conditional-on-touches
+typical-duration-seconds: 60
+reads-only: false
+writes:
+  - "**/*.mjml"
+  - "**/*.html"
+---
+
+@reference/shared-preamble.md
+
+# email-executor
+
+## Role
+
+You execute **exactly one task** from the plan: you generate **one email template** — an **MJML source** file (the canonical artifact) and the **equivalent derived HTML** — honoring the email-client constraints. 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 the MJML + HTML, write the file(s), run the static validator, commit, emit the completion marker, done.
+
+You are an **agent-prompt**, not a compiler (D-04): GDD generates the email when an LLM (you) invokes this prompt, consistent with `design-executor.md` / `flutter-executor.md`. You do **not** require a running `mjml` compiler, a Litmus account, or any network to produce the email — rendered cross-client verification is the verify stage's degraded-mode concern, never a precondition here (D-03/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/email-design.md`** — the **authoritative** email-constraint catalogue: table-based layout (no flexbox/grid/`position`), inline styles (no `<style>` sheet), MSO conditional comments for Outlook's Word engine, dark-mode `color-scheme`, ~600px max-width, image/alt rules, and the top-20-client quirks. This is how you pick the correct email idiom — you **generate against the catalogue**, you do **not** re-derive these rules (the `flutter-executor`→`reference/native-platforms.md` precedent).
+
+**Invariant:** read all listed files FIRST, before making any changes.
+
+---
+
+## MJML canonical + HTML derived (the D-02 two-artifact contract)
+
+Per **D-02** the executor emits **two artifacts**, and **you (the LLM) perform the MJML→HTML expansion as your contract** — there is **NO `mjml` build step / runtime dependency** (an opt-in real `mjml` compile is out of scope, like the simulator connections):
+
+| Artifact | Role | Notes |
+| --- | --- | --- |
+| **`*.mjml`** | **CANONICAL** — the source of truth | Semantic MJML the maintainer edits |
+| **`*.html`** | **DERIVED** — generated by you from the MJML | The shippable email; what the static validator checks |
+
+- Emit **both**: write the MJML source, then write the equivalent table-based HTML you expand from it (inline styles, ghost tables, MSO comments, color-scheme — per the catalogue).
+- State, in **each file's header comment** and in your output, **which file is canonical (MJML)** and **which is derived (HTML)**, mirroring Phase 31's two-stage source→derived framing.
+- Do **not** add `mjml` to `package.json` or shell out to an `mjml` binary — the expansion is your job.
+
+---
+
+## Token Consumption — the canonical token form
+
+Where the task themes the email (colors, spacing, type), consume the **canonical design tokens** (the css-vars token form) for those values rather than inventing ad-hoc hex/px — consistent with the design-family executors. Email cannot use CSS custom properties reliably across clients, so **resolve** the token values to literals **inline** at generation time (the token is the source; the email carries the resolved value). Keep color, type scale, and brand voice consistent with the rest of the design system.
+
+---
+
+## Self-check via the static validator (the deterministic gate)
+
+Before completing, **run the static email-HTML validator** on your **derived HTML**:
+
+```js
+const { validateEmailHtml } = require('scripts/lib/email/validate-email-html.cjs');
+const { ok, violations } = validateEmailHtml(htmlString);
+```
+
+`validateEmailHtml` (Phase 34.2-01) deterministically checks the four statically-verifiable constraint classes — **EM-LAYOUT-01** (no flexbox/grid/`position`), **EM-STYLE-01** (no `<style>` block as the primary styling mechanism), **EM-MSO-01** (an MSO conditional comment in a full email), **EM-DARK-01** (a `color-scheme` signal present). **Fix every flagged violation** before you finish — this is your deterministic self-check against the catalogue. The remaining catalogue rules (~600px width, ghost tables/VML, image width/height/alt, per-client quirks) are render-tested guidance, not statically asserted — honor them from the catalogue.
+
+---
+
+## Optional Litmus render-test (degraded / not a precondition)
+
+Code generation needs **no** render service (D-04/D-10). Cross-client **rendered** verification is the **verify stage's** degraded-mode concern (D-03): point it at the `connections/litmus.md` render-test connection **as an enhancement**, **never** a precondition.
+
+- When **Litmus** (or **Email-on-Acid**, the documented alternative) is available → the verify stage captures cross-client screenshots.
+- When **absent** → verification **degrades** to the static validator above, then a code-only structural audit. Never hard-require Litmus.
+
+Email ships its render-test connection at `connections/litmus.md`; you only **name** it — you never run it to generate.
+
+---
+
+## Execution Principles
+
+1. **Honor DESIGN-CONTEXT.md decisions as locked.** `D-XX:` decisions are non-negotiable.
+2. **`reference/email-design.md` is authoritative** for the email constraints. Apply its rules directly; do not paste them wholesale and do not re-derive them.
+3. **Observable outcomes only.** Acceptance criteria describe observable states ("the HTML uses `role="presentation"` tables", "an MSO conditional comment is present", "validateEmailHtml returns `ok: 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, the connection index, 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 HTML/MJML, a flagged `validateEmailHtml` violation, wrong token resolution in files you author → fix inline.
+- **Rule 2 — Missing Critical:** missing MSO comment, missing `color-scheme` signal, a flexbox/grid/`position` style, a missing `alt`/`width`/`height` on an `<img>` → add it (the catalogue requires it).
+- **Rule 3 — Blocking:** a referenced file/import missing, the validator not resolvable → fix (resolve import, create stub) and note it.
+- **Rule 4 — Architectural:** switching the email framework, restructuring the template system, a 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.
+
+---
+
+## Output
+
+Emit the **MJML source** + the **derived HTML** to the path(s) the task declares. In your final response, state: the file(s) written, **which is canonical (MJML)** and **which is derived (HTML)**, how tokens were resolved, and the `validateEmailHtml` result (`ok: true` / the violations you fixed). 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 `mjml` compiler, a Litmus/Email-on-Acid account, or any network to generate the email (D-04/D-10).
+- Add a `mjml` dependency to `package.json` or shell out to an `mjml` binary — the MJML→HTML expansion is the agent's contract (D-02).
+- Re-derive the email constraints — consume `reference/email-design.md` (the catalogue).
+- Emit only HTML or only MJML — both artifacts are the contract (MJML canonical, HTML derived).
+- Create or edit the connection index, or 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":"email-executor","cycle":"<cycle from STATE.md>","stage":"<stage from STATE.md>","one_line_insight":"<which email template (MJML+HTML) was generated + the validateEmailHtml result>","artifacts_written":["<files written>"]}
+```
+
+Schema: `reference/schemas/insight-line.schema.json`.
+
+## EXECUTION COMPLETE