@mmerterden/multi-agent-pipeline 11.1.0 → 11.3.0

package/pipeline/scripts/smoke-sync-delegation.sh

@@ -1,74 +0,0 @@
-#!/usr/bin/env bash
-# smoke-sync-delegation.sh  -  WS-9b contract.
-#
-# Verifies /multi-agent:sync (sync.md) documents the Step 0 delegation
-# to sync-figma-source.sh when figmaSource is configured.
-
-set -euo pipefail
-
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(cd "$HERE/../.." && pwd)"
-SYNC_DOC="$ROOT/pipeline/commands/multi-agent/sync.md"
-SYNC_SCRIPT="$ROOT/pipeline/scripts/sync-figma-source.sh"
-
-PASS=0
-FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-[ -f "$SYNC_DOC" ] || { echo "error: sync.md missing" >&2; exit 1; }
-[ -x "$SYNC_SCRIPT" ] || { echo "error: sync-figma-source.sh missing or not executable" >&2; exit 1; }
-
-echo "→ 1. sync.md lists figma source as Step 0"
-if grep -Fq "Step 0: FIGMA_SYNC" "$SYNC_DOC" || grep -Fq "FIGMA_SYNC" "$SYNC_DOC"; then
-  pass "Step 0 entry present"
-else
-  fail "Step 0 FIGMA_SYNC entry missing"
-fi
-
-echo ""
-echo "→ 2. sync.md references sync-figma-source.sh by path"
-if grep -Fq "pipeline/scripts/sync-figma-source.sh" "$SYNC_DOC"; then
-  pass "sync script path referenced"
-else
-  fail "sync script path missing from sync.md"
-fi
-
-echo ""
-echo "→ 3. sync.md documents the figmaSource preference gate"
-if grep -Fq "figmaSource.path" "$SYNC_DOC" || grep -Fq "figmaSource" "$SYNC_DOC"; then
-  pass "figmaSource pref gate documented"
-else
-  fail "figmaSource pref gate missing"
-fi
-
-echo ""
-echo "→ 4. sync.md notes skip behavior when figmaSource unset"
-if grep -qi "skip" "$SYNC_DOC" && grep -Fq "figmaSource" "$SYNC_DOC"; then
-  pass "skip-when-unset documented"
-else
-  fail "skip behavior not documented"
-fi
-
-echo ""
-echo "→ 5. sync.md mentions local-overlay marker (preservation)"
-if grep -Fq "local-overlay" "$SYNC_DOC"; then
-  pass "local-overlay preservation documented"
-else
-  fail "local-overlay preservation missing"
-fi
-
-echo ""
-echo "→ 6. sync.md puts FIGMA_SYNC BEFORE Step 1 (DETECT)"
-# Regex: FIGMA_SYNC line must appear before DETECT line
-FIGMA_LINE=$(grep -n "FIGMA_SYNC" "$SYNC_DOC" | head -1 | cut -d: -f1)
-DETECT_LINE=$(grep -nE "Step 1(\.[0-9]+)?: DETECT" "$SYNC_DOC" | head -1 | cut -d: -f1)
-if [ -n "$FIGMA_LINE" ] && [ -n "$DETECT_LINE" ] && [ "$FIGMA_LINE" -lt "$DETECT_LINE" ]; then
-  pass "FIGMA_SYNC precedes DETECT in step order"
-else
-  fail "FIGMA_SYNC must precede DETECT (got FIGMA=$FIGMA_LINE DETECT=$DETECT_LINE)"
-fi
-
-echo ""
-echo "══ sync-delegation smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ]

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

@@ -1,38 +0,0 @@
-# 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-evolve-component`, `figma-ui-patterns`, `figma-form-integration`, `figma-price-integration`, `figma-navigation`, `figma-overlays`, `figma-bottom-sheets`, `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.
-
-The cross-cutting **integration adapters** (`figma-form-integration`, `figma-price-integration`, `figma-navigation`, `figma-overlays`, `figma-bottom-sheets`) carry both an iOS (SwiftUI) and an Android (Jetpack Compose) section  -  the Android orchestrator uses the Compose section; the same emit-intent / caller-owns rules and the `figma-config` `ui.*` hooks apply on both platforms.
-
-## 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

@@ -1,62 +0,0 @@
----
-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

@@ -1,158 +0,0 @@
----
-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

@@ -1,120 +0,0 @@
----
-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

@@ -1,35 +0,0 @@
----
-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

@@ -1,124 +0,0 @@
----
-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).