@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/skills/figma-android/README.md

@@ -0,0 +1,36 @@
+# figma-android — Android Platform Skills
+
+Platform peer to `pipeline/skills/figma-ios/`.
+
+## What lives here
+
+Platform-specific skills for generating Jetpack Compose components from Figma designs:
+
+| Skill | Subphase | Sibling in figma-ios |
+|---|---|---|
+| `figma-to-component` | Orchestrator (3.0 – 3.8) | `figma-ios/figma-to-component` |
+| `figma-component-implement` | 3.4 (code gen: Compose) | `figma-ios/figma-component-implement` |
+| `figma-component-test` | 3.5 (Compose Testing + Paparazzi) | `figma-ios/figma-component-test` |
+| `figma-component-code-connect` | 3.6 (Code Connect for Compose) | `figma-ios/figma-component-code-connect` |
+| `figma-component-wiki` | 3.7 (wiki — platform-aware rendering) | `figma-ios/figma-component-wiki` |
+
+## What's NOT here (yet)
+
+The platform-**agnostic** skills — `figma-commit`, `figma-iterate`, `figma-issue`, `figma-review`, `figma-setup`, `figma-validate`, `figma-utility`, `figma-fix`, `figma-mend`, `figma-ui-patterns`, `figma-remote-mcp-auth`, `figma-cli-*`, `performance-*`, etc. — live under [`pipeline/skills/figma-common/`](../figma-common/) (WS-7b ✓). Both iOS and Android orchestrators dispatch there without duplication.
+
+## Routing
+
+Multi-agent Phase 3 reads `figmaConfig.project.platform`:
+
+- `"ios"` → dispatches to `figma-ios/figma-to-component`
+- `"android"` → dispatches to `figma-android/figma-to-component` (this directory)
+
+See `pipeline/commands/multi-agent/refs/component-dispatch.md` for the full contract.
+
+## Build target
+
+Android orchestrator expects `figmaConfig.build.gradleModule` to be set (e.g. `:components:button`). Missing → halt with a clear error. See `pipeline/schemas/figma-project-config.schema.json` v2.0.0 for the full `build` shape.
+
+## Status
+
+All five skills stamped `status: wip-v5` — contracts + skeleton in place, not yet validated against a real Android project. Fill in the reference implementation detail as a downstream integration lands (follow-up issues will be opened per skill).

package/pipeline/skills/figma-android/figma-component-code-connect/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: figma-component-code-connect
+description: Generate Code Connect for Compose mappings — {Name}.figma.kt registers the composable with Figma's Code Connect so designers see live code snippets for each variant. Android peer to pipeline/skills/figma-ios/figma-component-code-connect.
+user-invocable: true
+argument-hint: <component-name>
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+status: wip-v5
+sourced-from: derived-from/figma-ios/figma-component-code-connect
+platform: android
+---
+
+# figma-component-code-connect — Code Connect for Compose
+
+> **WS-7 v5.0.0** — Subphase 3.6 for Android. Generates `{Name}.figma.kt` so Figma's Dev Mode shows Compose usage for every variant of the component, classified by the Figma variant properties read in subphase 3.1.
+
+## Output
+
+`{Name}.figma.kt` beside the composable:
+
+```kotlin
+@FigmaConnect("https://www.figma.com/design/abc/?node-id=123-456")
+class ButtonPrimaryFigmaConnect {
+    @FigmaProperty.Boolean("Enabled") var enabled: Boolean = true
+    @FigmaProperty.Enum("Style", mapping = [
+        "Primary"   to ButtonStyle.Primary,
+        "Secondary" to ButtonStyle.Secondary,
+        "Ghost"     to ButtonStyle.Ghost,
+    ])
+    var style: ButtonStyle = ButtonStyle.Primary
+
+    @FigmaProperty.Text("Title") var title: String = ""
+
+    @Composable
+    fun Example() {
+        ButtonPrimary(
+            ButtonPrimaryConfiguration()
+                .title(title)
+                .style(style)
+                .enabled(enabled)
+        )
+    }
+}
+```
+
+Variant property names come from the Figma node (fetched in 3.1). Mapping tables translate Figma's "Primary"/"Secondary" strings to the Compose `ButtonStyle` enum.
+
+## Publish
+
+```bash
+figma code-connect publish --type kotlin --dir ${module-path}
+```
+
+Requires `figma-cli` with a valid PAT (resolved via `keychainMapping.figma`). Token missing → Token Save Flow. Publish failure → halt + error.
+
+## Failure handling
+
+- Figma property does not map cleanly to an enum → halt with an actionable message listing the unmapped variants; no partial publish.
+- Composable signature changed between 3.4 and 3.6 → auto-fix the `Example()` body from the current Configuration.
+
+## Cross-CLI parity
+
+iOS and Android Code Connect skills emit identical progress lines, publish via the same `figma code-connect publish` CLI, and halt on variant mapping ambiguity the same way. `smoke-figma-android-parity.sh` asserts skill inventory match.

package/pipeline/skills/figma-android/figma-component-implement/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: figma-component-implement
+description: Generate a Jetpack Compose component (Configuration data class + Composable + Modifier extensions + Preview + README) from gathered Figma data. Android peer to pipeline/skills/figma-ios/figma-component-implement.
+user-invocable: true
+argument-hint: <figma-url> | <component-name>
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+status: wip-v5
+sourced-from: derived-from/figma-ios/figma-component-implement
+platform: android
+---
+
+# figma-component-implement — Compose Code Generation
+
+> **WS-7 v5.0.0** — Called by the Android `figma-to-component` orchestrator during subphase 3.4. Reads `agent-state.json.phases["3"].subphases["3.1-gather"]` for the fetched Figma tree + token map and writes Kotlin + Compose artefacts.
+
+## Inputs
+
+```
+{
+  componentName:    "ButtonPrimary",             // PascalCase from registry
+  componentPath:    "components/Button/ButtonPrimary",
+  figmaTree:        <node object>,               // from 3.1-gather
+  tokenMap:         <Figma → token symbol map>,  // from 3.3-token-mapping
+  testingIds:       <semantic IDs>,              // from 3.2a
+  localization:     <strings map>,               // from 3.2b
+  accessibility:    <a11y metadata>,             // from 3.2c
+  analytics:        <events>,                    // from 3.2d
+  figmaConfig:      <figma-project-config v2.0.0>,
+  agentState:       <path>,                      // for progress emission + subphase record
+  dev:              boolean                      // --dev elides some steps (see below)
+}
+```
+
+## Outputs
+
+Four Kotlin files beside the component's package, plus a README:
+
+### 1. `{Name}Configuration.kt`
+
+Pure data class. Every variable knob lives here — the composable itself holds no state beyond its `Configuration` parameter. Marked `@Immutable` so Compose can skip recomposition when the instance is `equals`:
+
+```kotlin
+@Immutable
+data class ButtonPrimaryConfiguration(
+    val title: String = "",
+    val style: ButtonStyle = ButtonStyle.Primary,
+    val isEnabled: Boolean = true,
+    val onClick: () -> Unit = {}
+) {
+    enum class ButtonStyle { Primary, Secondary, Ghost }
+}
+```
+
+Rules:
+
+- `@Immutable` OR `@Stable` — never raw. `@Immutable` when all properties are primitives / immutable; `@Stable` when you guarantee structural stability.
+- Default values for every property so call sites can use `copy()` idiomatically (fluent-API equivalent).
+- Callbacks typed as named function types (`val onClick: () -> Unit = {}`) — never `Any?`.
+- Enums inside the Configuration's companion or nested scope — mirrors SwiftUI Configuration style.
+
+### 2. `{Name}.kt` (the composable)
+
+```kotlin
+@Composable
+fun ButtonPrimary(
+    configuration: ButtonPrimaryConfiguration,
+    modifier: Modifier = Modifier,
+) {
+    val shape = MaterialTheme.customShapes.mediumRadius
+    Surface(
+        modifier = modifier.semantics {
+            testTag = TestingIdentifiers.buttonPrimary
+            contentDescription = stringResource(R.string.btn_primary_a11y)
+        },
+        shape = shape,
+        color = MaterialTheme.colorScheme.primary,
+    ) {
+        // body uses ONLY configuration + MaterialTheme tokens
+    }
+}
+```
+
+Rules:
+
+- Signature is always `(configuration: XConfiguration, modifier: Modifier = Modifier)`. The `modifier` param is the caller's slot; nothing else.
+- `testTag` from `testingIds`; `contentDescription` from `accessibility.label` or `stringResource(R.string...)`.
+- No hardcoded `dp` / `Color(0xFF...)` / `TextStyle(...)` — every value reads from `MaterialTheme.*` or the project's theme extension.
+- No `LaunchedEffect` / `rememberCoroutineScope` for stateful behaviour — keep the composable pure. If async is needed, surface it via Configuration callbacks (the caller orchestrates).
+
+### 3. `{Name}Modifiers.kt`
+
+Fluent modifier-style helpers. Android idiom: extension functions on the Configuration type:
+
+```kotlin
+fun ButtonPrimaryConfiguration.title(value: String) = copy(title = value)
+fun ButtonPrimaryConfiguration.style(value: ButtonStyle) = copy(style = value)
+fun ButtonPrimaryConfiguration.enabled(value: Boolean = true) = copy(isEnabled = value)
+fun ButtonPrimaryConfiguration.onClick(block: () -> Unit) = copy(onClick = block)
+```
+
+Call sites read fluently:
+
+```kotlin
+ButtonPrimary(
+    ButtonPrimaryConfiguration()
+        .title("Save")
+        .style(.Secondary)
+        .onClick { viewModel.save() }
+)
+```
+
+### 4. `{Name}Preview.kt`
+
+`@Preview` covering meaningful variants. At minimum:
+
+```kotlin
+@Preview(name = "default",  showBackground = true)
+@Preview(name = "dark",     showBackground = true, uiMode = UI_MODE_NIGHT_YES)
+@Preview(name = "rtl",      showBackground = true, locale = "ar")
+@Preview(name = "fontScale",showBackground = true, fontScale = 1.5f)
+@Composable
+private fun ButtonPrimaryPreview() {
+    AppTheme { ButtonPrimary(ButtonPrimaryConfiguration().title("Save")) }
+}
+```
+
+`--dev` may emit only `default` + `dark` previews; full set lands in non-dev runs.
+
+### 5. `README.md`
+
+Variant matrix + usage example. Format mirrors the iOS peer's `FIGMA.md` so wiki generators can read both without code branches.
+
+## Progress emission
+
+Per the WS-11 contract, emit the following inline before each write:
+
+```
+→ writing Configuration {Name}Configuration.kt
+→ writing Composable {Name}.kt
+→ writing Modifiers {Name}Modifiers.kt
+→ writing Preview {Name}Preview.kt
+→ writing README.md
+→ running gradle compileDebugKotlin  (verification)
+```
+
+## Build verification
+
+After writing, run (with the build-queue lock from `refs/phases/operations.md`):
+
+```bash
+./gradlew :${module}:compileDebugKotlin --console=plain
+```
+
+Compile errors → up to 3 auto-fix cycles via Sonnet (iOS peer allows the same). Still failing → halt and surface via `state.phases["3"].errors[]`.
+
+## Cross-CLI parity
+
+The iOS and Android implement skills emit identical progress-line shapes and write the same 5-file set (Configuration + Component + Modifiers + Preview + README), just in the target language. `smoke-figma-android-parity.sh` asserts that every iOS implement output has an Android peer file name.

package/pipeline/skills/figma-android/figma-component-test/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: figma-component-test
+description: Generate Compose Testing + Paparazzi/Roborazzi snapshot + unit tests for a Jetpack Compose component. Android peer to pipeline/skills/figma-ios/figma-component-test.
+user-invocable: true
+argument-hint: <component-name>
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+status: wip-v5
+sourced-from: derived-from/figma-ios/figma-component-test
+platform: android
+---
+
+# figma-component-test — Compose Test Suite
+
+> **WS-7 v5.0.0** — Subphase 3.5 for Android. Three-layer test strategy mirroring the iOS peer (ViewInspector → Compose Testing, Snapshot → Paparazzi/Roborazzi, Unit → JUnit).
+
+## Three-layer strategy (Android)
+
+| Layer | Tool | What it verifies |
+|---|---|---|
+| **Structural** | Compose Testing (`createComposeRule()`) | Semantic tree, node existence, applied modifiers, click + input actions |
+| **Visual** | Paparazzi (JVM) or Roborazzi | Pixel-accurate render: light/dark, LTR/RTL, multi-density, multi-fontScale |
+| **Behavioural** | JUnit + Turbine | State changes, callback invocation, configuration copy semantics |
+
+The orchestrator picks Paparazzi by default (JVM-side, fast). Override by setting `figmaConfig.build.snapshotEngine = "roborazzi"` when the project already wires Robolectric.
+
+## Generated files
+
+### 1. `{Name}ComposeTest.kt` (structural)
+
+```kotlin
+class ButtonPrimaryComposeTest {
+    @get:Rule val composeRule = createComposeRule()
+
+    @Test
+    fun default_config_renders_title_and_is_clickable() {
+        var clicked = false
+        composeRule.setContent {
+            AppTheme {
+                ButtonPrimary(
+                    ButtonPrimaryConfiguration()
+                        .title("Save")
+                        .onClick { clicked = true }
+                )
+            }
+        }
+
+        composeRule.onNodeWithText("Save")
+            .assertIsDisplayed()
+            .assertHasClickAction()
+            .performClick()
+
+        assertThat(clicked).isTrue()
+    }
+
+    @Test
+    fun disabled_state_is_not_clickable() {
+        // ... covers isEnabled=false path
+    }
+}
+```
+
+Rules:
+- Prefer `onNodeWithTag(TestingIdentifiers.buttonPrimary)` over `onNodeWithText` when the text is localised.
+- Every interactive state (enabled, disabled, loading) gets a test.
+- No `Thread.sleep` — use `composeRule.waitUntil { ... }` or `runTest` for coroutine flows.
+
+### 2. `{Name}SnapshotTest.kt` (visual)
+
+Paparazzi variant:
+
+```kotlin
+class ButtonPrimarySnapshotTest {
+    @get:Rule val paparazzi = Paparazzi(
+        deviceConfig = DeviceConfig.PIXEL_6,
+        theme = "AppTheme",
+        renderingMode = SessionParams.RenderingMode.SHRINK
+    )
+
+    @Test fun primary_light()     { paparazzi.snapshot { variant(ButtonStyle.Primary, dark = false) } }
+    @Test fun primary_dark()      { paparazzi.snapshot { variant(ButtonStyle.Primary, dark = true)  } }
+    @Test fun secondary_rtl()     { paparazzi.snapshot { variant(ButtonStyle.Secondary, rtl = true) } }
+    @Test fun fontScale_large()   { paparazzi.snapshot { variant(ButtonStyle.Primary, fontScale = 1.5f) } }
+}
+```
+
+Minimum matrix: primary × (light, dark) × (LTR, RTL) × (default, large fontScale) = 8 snapshots per component. `--dev` elides fontScale row.
+
+### 3. `{Name}ConfigurationTest.kt` (unit)
+
+```kotlin
+class ButtonPrimaryConfigurationTest {
+    @Test fun copy_preserves_unchanged_fields() {
+        val base = ButtonPrimaryConfiguration().title("A").style(ButtonStyle.Primary)
+        val changed = base.title("B")
+        assertThat(changed.title).isEqualTo("B")
+        assertThat(changed.style).isEqualTo(base.style)
+    }
+}
+```
+
+Covers: fluent modifier semantics, default values, enum exhaustiveness.
+
+## Build + run
+
+```bash
+# JVM side (Paparazzi + Configuration unit tests)
+./gradlew :${module}:testDebugUnitTest --console=plain
+
+# Instrumented side (Compose Testing)
+./gradlew :${module}:connectedDebugAndroidTest --console=plain
+
+# Paparazzi record (only when snapshots are intentionally updated)
+./gradlew :${module}:recordPaparazziDebug
+```
+
+On failure — up to 3 auto-fix cycles, then halt.
+
+## Cross-CLI parity
+
+Both CLIs emit identical progress lines, generate the same 3-file set (compose + snapshot + configuration), and honour `figmaConfig.build.snapshotEngine`. `smoke-figma-android-parity.sh` asserts the inventory match with the iOS peer.

package/pipeline/skills/figma-android/figma-component-wiki/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: figma-component-wiki
+description: Component wiki generation for Android. Dispatches to the same 4-mode adapter set as the iOS peer (submodule / in-repo / github-wiki / separate-repo). Body rendering reads the Kotlin composable + sibling README.md instead of Swift + FIGMA.md.
+user-invocable: true
+argument-hint: <figma-url> | <component-name>
+allowed-tools: Read, Write, Glob, Grep, Bash
+status: wip-v5
+sourced-from: derived-from/figma-ios/figma-component-wiki
+platform: android
+---
+
+# figma-component-wiki — Component Wiki (Android)
+
+> **WS-7 v5.0.0** — Android peer to `pipeline/skills/figma-ios/figma-component-wiki`. Identical dispatch contract (Phase 7 Report Step 2 → `{componentName, componentPath, figmaConfig, agentState}` → `{writtenPaths[], committedSha?, pushedRemote?}`). Identical 4-adapter matrix (submodule / in-repo / github-wiki / separate-repo). Only the markdown rendering differs: reads Kotlin composable signature + sibling `README.md` rather than SwiftUI `+Modifiers.swift` + `FIGMA.md`.
+
+See `pipeline/skills/figma-ios/figma-component-wiki/SKILL.md` for the full adapter table and dispatch contract — shared verbatim.
+
+## Android-specific rendering notes
+
+- Parameter table reads the Composable signature AND the Configuration data class:
+  ```kotlin
+  @Composable fun ButtonPrimary(configuration: ButtonPrimaryConfiguration, modifier: Modifier = Modifier)
+  ```
+  Yields: `configuration: ButtonPrimaryConfiguration`, `modifier: Modifier`. Nested Configuration properties are rendered as a second table (one row per knob).
+- Code examples quote `@Preview` bodies rather than SwiftUI `#Preview` bodies.
+- Design tokens section reads `MaterialTheme.colorScheme.*` + `MaterialTheme.typography.*` references grepped from the composable.
+- Accessibility notes read `.semantics { ... }` blocks instead of `.accessibility*` modifiers.
+
+## Python helpers
+
+Shared with the iOS peer — same `pipeline/scripts/wiki/sidebar-generator.py` and `pipeline/scripts/wiki/status-page.py` land in WS-5b. The helpers are platform-agnostic (they read component markdown files, not Swift or Kotlin sources).
+
+## Cross-CLI parity
+
+Byte-identical progress lines, identical adapter dispatch, identical return schema. Wiki layout convergence across iOS and Android is an explicit goal — the same `/components/{Category}/{Name}.md` path structure on every project regardless of platform.

package/pipeline/skills/figma-android/figma-to-component/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: figma-to-component
+description: Figma-to-Compose component implementation workflow for Android. Takes a Figma URL and produces a production-ready Jetpack Compose component through the same 8-phase pipeline shape as the iOS peer — data gathering, analysis, code generation, testing, Code Connect, documentation.
+user-invocable: true
+argument-hint: <figma-url> | phase-<N> | status
+allowed-tools: Task, Read, Glob, Grep, Bash, Write, Edit, AskUserQuestion
+status: wip-v5
+sourced-from: derived-from/figma-ios/figma-to-component
+platform: android
+---
+
+# figma-to-component — Android Orchestrator
+
+> **WS-7 v5.0.0** — Platform peer to `pipeline/skills/figma-ios/figma-to-component`. Same 8-phase shape; platform-specific phases (3-Token Mapping, 4-Code Gen, 5-Tests, 6-Code Connect) target Kotlin / Jetpack Compose / Paparazzi / Code Connect for Compose. Common phases (0-Init, 1-Gather, 2A–2D utilities, 7-Wiki, 8-Cleanup) share logic with the iOS peer — implementations stay in this skill for now; a `figma-common/` refactor lands in WS-7b.
+
+## Dispatch entry
+
+Called from multi-agent Phase 3 when `state.taskType === "component"` AND `figmaConfig.project.platform === "android"`. See `pipeline/commands/multi-agent/refs/component-dispatch.md` for the full dispatch contract shared with the iOS peer (same input/output schema, subphase state shape).
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| Figma URL | Yes | `https://www.figma.com/design/{fileKey}/...?node-id={nodeId}` |
+| `phase-<N>` | No | Resume a specific subphase instead of running the full chain |
+| `status` | No | Print subphase progress from `state.phases["3"].subphases[]` and exit |
+
+```
+/figma-to-component https://www.figma.com/design/abc/?node-id=123-456
+/figma-to-component phase-4a   # resume at Kotlin Configuration generation
+/figma-to-component status
+```
+
+## Phase order (Android-flavoured)
+
+| # | Phase | Platform-specific? | Notes |
+|---|---|---|---|
+| 3.0 | Init | no | Node-id parse, registry lookup, worktree confirm |
+| 3.1 | Gather | no | Figma API/MCP fetch, design tokens, properties |
+| 3.2a | Testing identifiers | no | Platform-agnostic semantic IDs (shared with iOS) |
+| 3.2b | Localization | no | Shared strings — lands in `{repos.common}` |
+| 3.2c | Accessibility | partial | `contentDescription` / `Role` / `semantics {}` vs SwiftUI's `.accessibility*` — the generator knows both |
+| 3.2d | Analytics | no | Shared analytics keys |
+| 3.3 | Token Mapping | **yes** | Maps Figma tokens → MaterialTheme dimensions / colorScheme / typography; outputs a per-project `DesignTokens.kt` if missing |
+| 3.4a | Configuration | **yes** | `{Name}Configuration.kt` — data class with all properties, marked `@Immutable`/`@Stable` for Compose skippability |
+| 3.4b | View | **yes** | `{Name}Screen.kt` or `{Name}.kt` — `@Composable fun {Name}(configuration: {Name}Configuration, modifier: Modifier = Modifier)` |
+| 3.4c | Docs | no | `README.md` next to the composable |
+| 3.4d | Preview | **yes** | `@Preview` functions covering variants (device, darkMode, RTL, fontScale) |
+| 3.4e | Modifiers | **yes** | Kotlin extension functions on `Modifier` or on the Configuration type — the fluent API the iOS peer expresses as `+Modifiers.swift` |
+| 3.5a | Structural tests | **yes** | `createComposeRule()` + semantic matchers (`onNodeWithText`, `onNodeWithTag`, `onNodeWithContentDescription`) |
+| 3.5b | Snapshot | **yes** | Paparazzi or Roborazzi snapshot tests covering light/dark, LTR/RTL, Dynamic Font Scale |
+| 3.5c | Unit | yes (opt) | Logic-only unit tests; `--dev` may elide |
+| 3.6 | Code Connect | **yes** | Code Connect for Compose — `{Name}.figma.kt` with `@FigmaConnect` variant mappings |
+| 3.7 | Wiki | no | Delegates to `figma-component-wiki` — same 4-mode adapter as iOS |
+| 3.8 | Cleanup | no | Artifact pruning, state finalize |
+
+## Delegation graph
+
+```
+figma-to-component (this skill)
+├─ phase 3.4 (code gen)     → figma-component-implement  (Android peer)
+├─ phase 3.5 (tests)        → figma-component-test        (Android peer)
+├─ phase 3.6 (code connect) → figma-component-code-connect (Android peer)
+└─ phase 3.7 (wiki)         → figma-component-wiki        (Android peer — mode-aware adapter)
+```
+
+The platform-agnostic subphases (3.0–3.3, 3.2a–d, 3.8) use the same logic as the iOS orchestrator — they read `figmaConfig` + Figma API results and write registry entries that don't care about language target. WS-7b extracts those to `pipeline/skills/figma-common/` so both platforms import rather than duplicate.
+
+## Build target resolution
+
+Reads from `figmaConfig.build`:
+
+```json
+{
+  "gradleModule": ":components:button",
+  "variant": "debug",
+  "buildType": "release"
+}
+```
+
+Invokes build via:
+
+```bash
+./gradlew :${build.gradleModule//:/}:assembleDebug
+./gradlew :${build.gradleModule//:/}:testDebugUnitTest
+```
+
+If `build.gradleModule` is missing, halt with a clear "configure `figmaConfig.build.gradleModule` for Android" message. Do not guess.
+
+## Component output locations
+
+Default layout — override per project via `figmaConfig.repos` and `figmaConfig.artifactBasePath`:
+
+| Artifact | Path |
+|---|---|
+| Composable + Configuration | `{repos.components.path}/src/main/java/.../components/{Category}/{Name}/{Name}.kt` |
+| Modifiers extensions | Same directory as the composable |
+| Unit tests | `{repos.components.path}/src/test/java/.../components/{Category}/{Name}Test.kt` |
+| Instrumented/Compose tests | `{repos.components.path}/src/androidTest/java/.../components/{Category}/{Name}ComposeTest.kt` |
+| Snapshot tests | Beside Compose tests, using Paparazzi's `@get:Rule val paparazzi = Paparazzi(...)` |
+| Code Connect | `{repos.components.path}/src/main/java/.../components/{Category}/{Name}/{Name}.figma.kt` |
+| Component artifacts | `{artifactBasePath}/{Category}/{Name}/` (screenshots, specs — platform-agnostic) |
+
+## Design token conventions
+
+Tokens for Compose land in `MaterialTheme`:
+
+- Spacing → `CustomSpacing` extension on `MaterialTheme` (or vanilla `dp` constants if the project has no theme wrapper)
+- Color → `MaterialTheme.colorScheme.{name}` or project's `CustomColorScheme`
+- Typography → `MaterialTheme.typography.{name}`
+- Radius → `CustomShapes` extension
+
+The generator reads `figmaConfig.tokens.*Path` to locate the theme file and resolves symbolic tokens (e.g. `Spacing.spacing16`) in the same way the iOS peer resolves `.Spacing.spacing16`. No magic numbers land in the composable.
+
+## Cross-CLI parity
+
+Claude Code and Copilot CLI implementations MUST:
+
+- Accept identical arguments (`<figma-url>`, `phase-<N>`, `status`).
+- Emit byte-identical progress lines via the WS-11 contract.
+- Write the same `state.phases["3"].subphases[]` schema so multi-agent's phase-tracker renders identically.
+- Resolve `figmaConfig.build.gradleModule` the same way.
+
+`smoke-figma-android-parity.sh` asserts the platform-specific skill inventory matches the iOS peer (same skill names exist on both sides).

package/pipeline/skills/figma-common/README.md

@@ -0,0 +1,57 @@
+# figma-common — Platform-agnostic figma-to-component skills
+
+Shared skills that both `pipeline/skills/figma-ios/` (SwiftUI) and `pipeline/skills/figma-android/` (Jetpack Compose) dispatch. Moved here by WS-7b of the v5.0.0 rebuild so the platform trees stay lean and there's no duplication.
+
+## What lives here (27 skills)
+
+**Workflow orchestration:**
+
+- `figma-component-start` — Issue → branches, check out worktree
+- `figma-component-confluence-sync` — Phase 7b: wiki markdown → Confluence XHTML
+- `figma-component-status-update` — Refresh Confluence dashboard
+- `figma-commit` — 14-item review + PR creation
+- `figma-iteration-commit` — Commit to iteration/develop + PR
+
+**Batch + iterate:**
+
+- `figma-iterate` — Auto loop: pick → implement → commit
+- `figma-cli-iterate` — Full CLI iterate (all phases)
+- `figma-cli-lean-iterate` — Iterate skipping test + wiki
+- `figma-cli-iterate-mend` — Re-implement discarded components
+- `figma-cli-skip` — Mark component as skipped
+- `figma-skip` — Skip + update Confluence dashboard
+
+**Issue + review:**
+
+- `figma-issue` — Create GitHub issue + optional Jira (feeds WS-6 triad)
+- `figma-review` — Interactive review gate (approve / bug / skip)
+- `figma-validate` — Pre-implementation validation
+- `figma-fix` — Targeted bug fix from review findings
+- `figma-mend` — Re-implement component from scratch
+
+**Setup + utility:**
+
+- `figma-setup` — Environment setup wizard (MCP, tokens, Code Connect CLI)
+- `figma-remote-mcp-auth` — Figma MCP OAuth flow
+- `figma-utility` — Figma data fetch (screenshots, metadata)
+- `figma-ui-patterns` — UI pattern library index
+- `figma-form-integration` — Form protocol adapter (shared UX)
+- `figma-price-integration` — Price protocol adapter (shared UX)
+
+**Performance batch:**
+
+- `performance-start`, `performance-swiftui`, `performance-tour`, `performance-review-next`, `performance-iteration-commit-all`
+
+## What does NOT live here
+
+Platform-specific skills stay under `figma-ios/` or `figma-android/`:
+
+- `figma-to-component` — orchestrator (platform-specific build command)
+- `figma-component-implement` — Swift / Kotlin code generator
+- `figma-component-test` — SwiftUI ViewInspector / Compose Testing
+- `figma-component-code-connect` — Swift / Kotlin Code Connect
+- `figma-component-wiki` — same 4-adapter contract, but platform-aware rendering
+
+## Invocation
+
+Both platforms' orchestrators call the same common skill paths — no CLI or platform routing needed. The cross-CLI contract (`refs/cross-cli-contract.md` § 1.1) enforces the inventory.