@code-migration/wow-migrator 0.1.0 → 0.1.2

package/skills/android-to-kmp-migrator/workflow.md

@@ -1,167 +1,193 @@
-# Workflow: Legacy Android SPEC + target KMP project → migrated, validation-ready KMP code
+# Workflow: Legacy Android SPEC + target KMP project -> migrated, validation-ready KMP code
 
-This Swarm Skill is a **specialization pipeline (C) with embedded parallel fan-outs (B) and review→fix loops**. The `android-to-kmp-migrator` controller (Leader) verifies the trigger, dispatches nodes in a hard dependency order, gates every handoff, runs a mandatory review→fix→re-review loop after any node changes files, routes guard/parity/fidelity/build failures back to the responsible node, and invokes `kmp-test-validator` only after the migration report returns `ready_for_validation`. Implementation outputs must be fully implemented — TODO placeholders are not acceptable.
+This workflow uses the reduced 10-role module-first migrator. Adjacent responsibilities are consolidated, but gates remain explicit through role modes, check IDs, and exact output paths.
 
 ## Overview
 
 ```mermaid
 graph TD
-  L0[Leader: Step 0 pre-flight deps] --> WS[migration-workspace-state]
-  WS --> SD[legacy-spec-delta-review]
-  SD --> TP[target-project-understand]
-  TP -->|KMP evidence?| GT{target is KMP?}
-  GT -- No --> BLK[Stop: blocked, missing target evidence]
-  GT -- Yes --> AL[migration-alignment]
-  AL --> DEP{dependency-resolution<br/>minimal-change gate}
-  DEP -- blocked --> BLK
-  DEP -- ready_for_implementation --> PREP
-
-  subgraph PREP[Stage Prep — parallel B]
-    TH[theme-design-system-mapping]
-    RS[resource-migration]
-    NV[navigation-migration]
-    PA[platform-api-replacement]
-    SM[state-model-mapping]
+  L0[Leader pre-flight] --> ROOT[LockOutputRoot<br/>run_manifest.json]
+  ROOT --> INV[MigrationModuleInventory]
+  INV --> WS[migration-workspace-state]
+  WS --> LOOP[ForEachMigrationModule]
+  LOOP --> PLAN[migration-analysis-planning]
+  PLAN --> DP[dependency-platform-gate]
+  DP --> PREP
+
+  subgraph PREP[Prep fan-out]
+    PI[presentation-integration]
+    SD[state-data-prep]
   end
 
-  PREP --> RFa{review→fix loop<br/>per changed slice}
-  RFa -->|approved| UI[ui-mockup-implementation]
-  UI --> RFb{review→fix loop}
-  RFb -->|approved| DL[dataflow-logic-implementation]
-  DL --> RFc{review→fix loop}
-
-  RFc -->|approved| VER
-
-  subgraph VER[Stage Verify — parallel B]
-    SG[source-set-placement-guard]
-    AP[api-contract-parity]
-    RF[ui-render-fidelity-check]
-    IB[incremental-build-check]
-  end
+  PREP --> RF1{module-node-review-fix<br/>review/fix/re-review}
+  RF1 --> UI[ui-implementation]
+  UI --> RF2{module-node-review-fix}
+  RF2 --> LOGIC[logic-implementation]
+  LOGIC --> RF3{module-node-review-fix}
+  RF3 --> VER[migration-verification<br/>source_set api_contract ui_render incremental_build]
+  VER -->|failed| RESP[Re-dispatch responsible reduced role]
+  RESP --> RF1
+  VER -->|passed| READY[completion-report<br/>mode readiness]
+  READY -->|needs_rerun| RESP
+  READY -->|ready_for_validation| MODREP[module_migration_representation.*]
+  MODREP --> ALL{all modules represented?}
+  ALL -- No --> LOOP
+  ALL -- Yes --> GLOB[global_migration_representation.*]
+  GLOB --> REPORT[completion-report<br/>mode report]
+  REPORT --> KV[kmp-test-validator]
+```
 
-  VER -->|failure routed| RESP[Re-dispatch responsible node] --> RFa
-  VER -->|all passed| PC[prd-completion-check]
-  PC -- needs_rerun --> RESP
-  PC -- blocked --> BLK
-  PC -- ready_for_validation --> MR[migration-report]
-  MR -- ready_for_validation --> KV[Leader invokes kmp-test-validator]
-  MR -- blocked --> BLK
+## Strict Output Roots
 
-  WS -. refreshed after major completions .-> PC
+```text
+output_root = <output_dir or ~/.a2c_agents/migration>/android-to-kmp-migrator
+module_index_dir = <output_root>/module-index
+module_root = <output_root>/modules/<migration_module_id>
+node_result_dir = <module_root>/node-results/<node_id>
+module_representation_dir = <module_root>/representation
+global_dir = <output_root>/global
+report_dir = <output_root>/report
 ```
 
-The review→fix loop (`RFa/RFb/RFc`) is: `module-node-migration-review` → if `needs_fix`, `module-node-migration-fix` → mandatory re-review → repeat until `approved` or `blocked`. The `migration-workspace-state` ledger is refreshed after major node completions to flag stale upstream artifacts.
-
 ## Detailed Steps
 
-### Step 0 — Pre-flight: dependency check
+### Step 0 — Pre-flight
 
 - **Executor**: Leader
 - **Input**: [dependencies.yaml](dependencies.yaml)
-- **Action**: verify each `tools[]` entry is available; the target Gradle wrapper drives builds.
-- **Output**: pre-flight note to the user
-- **Quality gate**: all deps `required: false`; the run proceeds with degraded behavior recorded. User decides go/no-go on anything missing; Leader does not auto-skip nodes.
-
-### Step 1 — Trigger verification + shared brief + workspace state
-
-- **Executor**: Leader, then `migration-workspace-state`
-- **Input**: `kmp_target_project_path`, `legacy_android_project_path` (or null), `migration_scope`, `spec_dir`, optional `output_dir` (default `~/.a2c_agents/migration/`), optional `jetbrains` MCP context
-- **Action**: confirm the migration trigger and Legacy SPEC context; build the shared brief; initialize/refresh the workspace-state ledger.
-- **Output**: shared brief + `migration_workspace_state.*`
-- **Serial / Parallel**: serial
-- **Quality gate**: Legacy SPEC context present (or `android-project-analyst` is invoked first); else stop with a user-visible blocker.
-
-### Step 2 — Analysis chain: delta review → target understand → alignment
-
-- **Executor**: `legacy-spec-delta-review` → `target-project-understand` → `migration-alignment`
-- **Input**: SPEC paths, target path, shared brief; alignment additionally consumes delta-review + target-understanding outputs
-- **Action**: verify SPEC coverage vs raw source; understand the target & reuse inventory; build the source-to-target map, integration scaffold, and ordered tasks.
-- **Output**: `spec_delta_review.*`, `target_project_understanding.*` + `target_migration_context.md`, `migration_alignment.*` + `migration_implementation_map.md`
-- **Serial / Parallel**: serial (each consumes the prior)
-- **Quality gate**: `target-project-understand` must confirm a KMP project, else `blocked`. Each return is `completed`/`blocked` with verified non-empty `output_files`, else re-dispatch.
-
-### Step 3 — Dependency gate
-
-- **Executor**: `dependency-resolution`
-- **Input**: target-understanding + alignment + SPEC paths
-- **Action**: map required capabilities to baseline/reuse, apply the minimal-change gate, justify any build-config change.
-- **Output**: `dependency_resolution.*`
-- **Serial / Parallel**: serial — blocks all implementation
-- **Quality gate**: status must be `ready_for_implementation`; `blocked` halts implementation with the unmet capability. Implementation nodes do NOT run until this passes.
-
-### Step 4 — Stage Prep (parallel, B-pattern)
-
-- **Executor**: `theme-design-system-mapping`, `resource-migration`, `navigation-migration`, `platform-api-replacement`, `state-model-mapping`
-- **Input**: alignment + dependency outputs + relevant Legacy understanding paths
-- **Action**: prepare visual tokens, resources, routes, platform abstractions, and state/models before UI.
-- **Output**: each node's `*.json`/`*.md` + changed target files
-- **Serial / Parallel**: parallel — slices are dispatch-time fixed
-- **Quality gate**: each return verified (output + changed files); any node that changed files enters the Step 5 review→fix loop before its slice is consumed downstream.
-
-### Step 5 — Review→fix loop (after any file-changing node)
-
-- **Executor**: `module-node-migration-review` → `module-node-migration-fix` (conditional) → re-review
-- **Input**: owning-node output, changed files, upstream evidence, workspace state
-- **Action**: review one slice; if `needs_fix`, apply only assigned `must_fix` findings inside `allowed_files`, then mandatorily re-review.
-- **Output**: `module_node_migration_review.*`, `module_node_migration_fix.*` (when fixes ran)
-- **Serial / Parallel**: serial per slice; runs after Prep (5a), after UI (5b), and after dataflow/logic (5c)
-- **Quality gate**: loop until review returns `approved` or `blocked`. A fix output with `requires_re_review: true` MUST be followed by a re-review before any downstream gate consumes the slice; max fix↔review cycles per [bind.md](bind.md).
-
-### Step 6 — UI implementation → review→fix loop
-
-- **Executor**: `ui-mockup-implementation`, then Step 5 loop (5b)
-- **Input**: alignment, dependency, theme, resource, navigation, target outputs
-- **Action**: implement the visible UI surface first, exposing binding surfaces; no TODO placeholders.
-- **Output**: `ui_impl_result.*` + changed UI/resource files
-- **Serial / Parallel**: serial — runs after Prep approved
-- **Quality gate**: every in-scope visible requirement implemented or explicitly `blocked`; slice approved via 5b before logic runs.
-
-### Step 7 — Dataflow/logic implementation → review→fix loop
-
-- **Executor**: `dataflow-logic-implementation`, then Step 5 loop (5c)
-- **Input**: alignment, dependency, navigation, platform, state, resource, and UI outputs
-- **Action**: implement models/repositories/APIs/logic bound to UI surfaces; no Android-only leak into `commonMain`; no TODO placeholders.
-- **Output**: `dataflow_logic_impl_result.*` + changed logic/data/API files
-- **Serial / Parallel**: serial — runs after UI approved
-- **Quality gate**: slice approved via 5c before verification.
-
-### Step 8 — Stage Verify (parallel, B-pattern) with failure routing
-
-- **Executor**: `source-set-placement-guard`, `api-contract-parity`, `ui-render-fidelity-check`, `incremental-build-check`
-- **Input**: changed files + the relevant implementation/prep/target outputs
-- **Action**: check source-set placement, API parity, UI render, and an incremental build.
-- **Output**: each node's `*.json`/`*.md` (+ build logs)
-- **Serial / Parallel**: parallel
-- **Quality gate**: each `passed`/`failed`/`blocked`. Any `failed`/violation is routed to the responsible implementation node, which re-runs and re-enters the review→fix loop. `blocked` (e.g., no trustworthy build command) is surfaced, not invented.
-
-### Step 9 — PRD completion check
-
-- **Executor**: `prd-completion-check`
-- **Input**: raw user task + PRD/SPEC + all node outputs + review/fix outputs + verification outputs + changed files
-- **Action**: judge requirement coverage, completion areas, migration invariants, incomplete markers, review-fix readiness, and guard/parity/fidelity/build results.
-- **Output**: `prd_completion_check.*`
-- **Serial / Parallel**: serial
-- **Quality gate**: `ready_for_validation` → Step 10; `needs_rerun` → route requests to responsible nodes (re-enter the relevant stage + loop); `blocked` → stop with missing evidence.
-
-### Step 10 — Final: migration report → validation handoff
-
-- **Executor**: `migration-report`, then Leader
-- **Input**: workspace state, all node outputs, review/fix outputs, completion check
-- **Action**: synthesize the final report and validation inputs; Leader invokes `kmp-test-validator` only when the report returns `ready_for_validation`.
-- **Output**: `migration_report.*` + the controller completion summary below
-
-#### Final Report Format
+- **Action**: check optional tools (`rg`, `git`, `curl`) and report degraded behavior.
+- **Gate**: missing optional tools do not skip nodes; the controller records degraded evidence.
+
+### Step 1 — Trigger + Output Root
+
+- **Executor**: Leader
+- **Input**: `legacy_android_project_path` or completed SPEC, `kmp_target_project_path`, `migration_scope`, optional `output_dir`
+- **Action**: verify migration trigger, verify analyst completion, lock `output_root`, write `<output_root>/run_manifest.json`.
+- **Gate**: stop if target is not KMP-compatible or analyst completion is missing/stale.
+
+### Step 2 — Migration Module Inventory
+
+- **Executor**: Leader
+- **Action**: divide the requested migration into deterministic `migration_module_id` slices.
+- **Output**:
+  - `<module_index_dir>/migration_module_inventory.json`
+  - `<module_index_dir>/migration_module_inventory.md`
+  - `<module_root>/module_brief.json` for every scheduled module
+- **Gate**: every module has `module_scope`, UI/logic/data/resource scope, target placement hints, `allowed_target_files`, and `allowed_source_sets`.
+
+### Step 3 — Workspace State
+
+- **Executor**: `migration-workspace-state`
+- **Output**: `<global_dir>/node-results/migration-workspace-state/migration_workspace_state.*`
+- **Gate**: stale upstream outputs must be rerun before downstream consumption.
+
+### Step 4 — Module Analysis And Planning
+
+- **Executor**: `migration-analysis-planning`
+- **Input**: module brief, SPEC paths, analyst artifacts, target path, workspace state
+- **Action**: verify SPEC/raw-source deltas, capture target KMP context/reuse inventory, produce source-to-target map and ordered implementation plan.
+- **Output**: `<module_root>/node-results/migration-analysis-planning/migration_analysis_planning.*`
+- **Gate**: target KMP evidence and source-to-target map must exist before dependency/platform work.
+
+### Step 5 — Dependency And Platform Gate
+
+- **Executor**: `dependency-platform-gate`
+- **Input**: planning output, target baseline, allowed files/source sets
+- **Action**: apply minimal-change dependency gate and define/implement safe platform boundaries when required.
+- **Output**: `<module_root>/node-results/dependency-platform-gate/dependency_platform_gate.*`
+- **Gate**: returns `ready_for_implementation` or `blocked`; no prep/implementation proceeds on blocked platform/dependency capability.
+
+### Step 6 — Prep Fan-Out
+
+- **Executors**: `presentation-integration`, `state-data-prep`
+- **Action**:
+  - `presentation-integration`: theme tokens, resource migration/modeling, navigation routes.
+  - `state-data-prep`: state holders, models, mappers, API/data expectations, logic handoff.
+- **Output**:
+  - `<module_root>/node-results/presentation-integration/presentation_integration.*`
+  - `<module_root>/node-results/state-data-prep/state_data_prep.*`
+- **Gate**: every file-changing prep slice enters review/fix before UI or logic consumes it.
+
+### Step 7 — Review/Fix Loop
+
+- **Executor**: `module-node-review-fix`
+- **Modes**:
+  - `review`: read-only review of one module/node slice.
+  - `fix`: scoped edit of explicit `must_fix` findings inside `allowed_files`.
+- **Gate**: every fix must be followed by a fresh review. Downstream nodes may consume only slices whose latest review is `approved`.
+
+### Step 8 — UI Implementation
+
+- **Executor**: `ui-implementation`
+- **Action**: implement visible UI surface first, including states/resources and binding surfaces.
+- **Gate**: UI output is reviewed/approved before logic implementation.
+
+### Step 9 — Logic Implementation
+
+- **Executor**: `logic-implementation`
+- **Action**: implement repositories/use cases/API integration/business logic bound to approved UI surfaces.
+- **Gate**: logic output is reviewed/approved before verification.
+
+### Step 10 — Verification
+
+- **Executor**: `migration-verification`
+- **Required `check_ids`**:
+  - `source_set`
+  - `api_contract`
+  - `ui_render`
+  - `incremental_build`
+- **Output**: `<module_root>/node-results/migration-verification/migration_verification.*`
+- **Gate**: failures route to the responsible reduced role and re-enter review/fix.
+
+### Step 11 — Readiness And Module Representation
+
+- **Executor**: `completion-report` in `mode: readiness`, then Leader
+- **Action**: decide module readiness; write module representation.
+- **Output**:
+  - `<module_root>/node-results/completion-report/readiness/completion_readiness.*`
+  - `<module_representation_dir>/module_migration_representation.json`
+  - `<module_representation_dir>/module_migration_representation.md`
+- **Gate**: blocked modules still write a representation with blockers.
+
+### Step 12 — Global Representation
+
+- **Executor**: Leader
+- **Input**: all module representations
+- **Output**:
+  - `<global_dir>/global_migration_representation.json`
+  - `<global_dir>/global_migration_representation.md`
+- **Gate**: final report cannot run until global representation exists and is non-empty.
+
+### Step 13 — Final Report And Validation Handoff
+
+- **Executor**: `completion-report` in `mode: report`, then Leader
+- **Output**:
+  - `<report_dir>/migration_report.json`
+  - `<report_dir>/migration_report.md`
+- **Gate**: report mode may return `ready_for_validation` only after module/global representations exist and readiness has passed. Leader invokes `kmp-test-validator` afterward.
+
+## Final Report Shape
 
 ```json
 {
   "status": "ready_for_validation | blocked",
-  "migration_scope": "...",
-  "kmp_target_project_path": "...",
-  "legacy_android_project_path": "... or null",
-  "changed_files_by_node": [],
+  "migration_scope": "",
+  "kmp_target_project_path": "",
+  "legacy_android_project_path": "",
+  "output_root": "",
+  "migration_module_inventory": "",
+  "module_representations": [],
+  "global_migration_representation": "",
+  "changed_files_by_role": [],
   "source_to_target_summary": [],
-  "coverage_summary": { "ui": "", "resources": "", "navigation": "", "platform": "", "state_models": "", "data_api": "", "logic": "" },
-  "module_node_review_summary": [],
+  "coverage_summary": {
+    "presentation": "",
+    "state_data": "",
+    "ui": "",
+    "logic": "",
+    "platform": "",
+    "verification": ""
+  },
   "validation_inputs": [],
   "limitations": [],
   "manual_steps": [],
@@ -171,10 +197,10 @@ The review→fix loop (`RFa/RFb/RFc`) is: `module-node-migration-review` → if
 
 ## Acceptance Criteria
 
-- Every dispatched node returned output matching its role `## Output Schema` and the shared return shape; any `[ROLE MISSING]` is recorded per [bind.md](bind.md).
-- **Gate check (C-pattern)**: the dependency gate passed before implementation; UI ran before logic; each stage ran only after the prior stage's slices were `approved`.
-- **Loop check**: every file-changing node has an `approved` latest review; every fix output was followed by a re-review for the same scope.
-- **Coverage check (B-pattern)**: all Prep slices and all four Verify checks accounted for; failures routed to the responsible node, not absorbed by the Leader.
-- Migration invariants hold: no Android-only API in `commonMain`, expect/actual complete, dependency gate respected, single KMP project, cross-module integration wired.
-- No changed file contains a TODO/placeholder presented as completion output.
-- `migration-report` returns `ready_for_validation` only when `prd-completion-check` is ready; `kmp-test-validator` is invoked only afterward. If `blocked`, the final response lists blockers and exact missing evidence.
+- Active dispatch uses only the 10 reduced role IDs from `SKILL.md`.
+- Every module has a `module_brief.json`, verified node outputs under `<module_root>/node-results/`, and a module migration representation.
+- Review/fix invocations are separate: `review` -> optional `fix` -> fresh `review`.
+- Verification uses stable `check_ids` and routes failures to reduced role IDs.
+- No Android-only API leaks into `commonMain`; dependency changes pass the minimal-change gate.
+- `global_migration_representation.*` exists before report mode.
+- `kmp-test-validator` is invoked only after `completion-report` report mode returns `ready_for_validation`.

package/skills/kmp-test-validator/MIGRATION.md

@@ -11,7 +11,7 @@ Converted from a single controller-support skill (a flat SKILL.md node registry
 
 The registry separated controller from nodes and encoded the dispatch order, but it did not encode the team as a first-class artifact: no per-role anti-convergence mottos, no `Forbidden`/`Mandatory` boundary blocks the validator could check, no pasteable `Inline Persona` (each of the 9 dispatches re-derived its contract by hand), no Mermaid topology making the pipeline + remediation loop explicit, and no resource/behavioral guardrails (token/wall-clock budgets, `max_remediation_cycles`, degraded modes). The fidelity-before-tests gate, build-before-tests gate, "Android/SPEC is ground truth", and "never invent a command" invariants lived only in prose.
 
-## Decomposition
+## Original 0.2 Decomposition
 
 - **Pattern: C (specialization pipeline) + remediation loop.**
   - Gate: `validation-input-contract` (refuse non-migration scenarios).
@@ -38,6 +38,21 @@ The registry separated controller from nodes and encoded the dispatch order, but
 | Trigger boundary + controller validation rules | `bind.md` § Behavioral Constraints + SKILL.md § Shared Rules |
 | Optional Android Studio MCP context | SKILL.md § Optional Android Studio MCP Context + per-role Inline Persona MCP inputs |
 
-## Team-vs-single delta
+## Original Team-vs-single Delta
 
-The conversion preserves every source contract while adding: explicit pipeline + remediation-loop topology with verifiable gates, per-role anti-overlap boundaries that name siblings, self-contained pasteable personas (no re-derivation per dispatch across 9 nodes), resource/token/wall-clock budgets plus a `max_remediation_cycles` bound, failure-routing rules, and concrete degraded modes for missing commands, unsupported previews, and missing MCP. The same-name controller subagent in `kmp-migration/agents/kmp-test-validator.md` is unchanged in behavior; its node table now points at `roles/<id>.md`.
+The 0.2 conversion preserved every source contract while adding: explicit pipeline + remediation-loop topology with verifiable gates, per-role anti-overlap boundaries that name siblings, self-contained pasteable personas (no re-derivation per dispatch across 9 nodes), resource/token/wall-clock budgets plus a `max_remediation_cycles` bound, failure-routing rules, and concrete degraded modes for missing commands, unsupported previews, and missing MCP.
+
+## Role Reduction Refactor (0.3)
+
+The current active validator reduces 9 roles to 6. See [ROLE_REDUCTION.md](ROLE_REDUCTION.md).
+
+| Old role(s) | Active role |
+|---|---|
+| `validation-workspace-state` | `validation-workspace-state` |
+| `validation-input-contract`, `android-kmp-fidelity-audit` | `validation-intake-fidelity` |
+| `kmp-validation-plan`, `build-preview-gate` | `validation-plan-gate` |
+| `test-case-decomposition`, `test-execution` | `validation-test-runner` |
+| `validation-remediation` | `validation-remediation` |
+| `validation-report` | `validation-report` |
+
+The reduction keeps the important gates intact: migration trigger/fidelity trust gate, build-before-tests gate, scoped remediation with mandatory reruns, and report-only final verdict.

package/skills/kmp-test-validator/SKILL.md

@@ -1,114 +1,84 @@
 ---
 name: kmp-test-validator
 description: |
-  9-role pipeline Swarm Skill (C) with a remediation loop that validates Android-to-KMP migration output: input gate, fidelity audit, validation plan, build/preview gate, test decomposition and execution, remediation, and report.
-  Use with the kmp-test-validator controller after a migration report is ready, or when given Android source/SPEC plus a KMP target.
+  6-role reduced pipeline Swarm Skill that validates Android-to-KMP migration output: workspace ledger, intake/fidelity trust gate, command/build-preview gate, Android-anchored test runner, scoped remediation, and final validation report.
+  Use with the kmp-test-validator controller after android-to-kmp-migrator has produced a validation-ready migration report, or when given Android source/SPEC plus a KMP target for migrated behavior validation.
   Do NOT use for generic KMP testing, KMP-only feature work, isolated Gradle troubleshooting, Android analysis, or non-migration refactors.
-version: "0.2"
+version: "0.3"
 kind: swarm-skill
 disable-model-invocation: true
 roles:
   - id: validation-workspace-state
     kind: ai_agent
-    purpose: Validation ledger — node status, changed-file ownership, stale inputs, rerun/blocker history, next actions. No audit, build, or fix.
+    purpose: Validation ledger — node status, changed-file ownership, stale inputs, rerun/blocker history, next actions. No audit, build, test, fix, or verdict.
     skills: []
     tools: [git]
-  - id: validation-input-contract
+  - id: validation-intake-fidelity
     kind: ai_agent
-    purpose: Gate — verify this is a post-migration validation scenario, confirm KMP evidence, normalize paths, and produce the validation brief.
-    skills: []
-    tools: [rg]
-  - id: android-kmp-fidelity-audit
-    kind: ai_agent
-    purpose: Compare Android source/SPEC vs migrated KMP across UI, logic, data flow, control flow before tests are trusted; flag test-trust blockers.
+    purpose: Intake and fidelity trust gate — verify migration scenario, normalize brief, compare Android source/SPEC vs KMP, and flag test-trust blockers.
     skills: []
     tools: [rg, git]
-  - id: kmp-validation-plan
-    kind: ai_agent
-    purpose: Discover target structure and resolve trusted build/preview/test commands and scope-to-target mapping. Never invents commands.
-    skills: []
-    tools: [rg]
-  - id: build-preview-gate
+  - id: validation-plan-gate
     kind: ai_agent
-    purpose: Run the resolved build and Compose preview/renderability gate before behavioral tests; classify and route failures by owner.
+    purpose: Command and build gate — resolve trusted build/preview/test commands, run build and preview/renderability before behavioral tests, route failures.
     skills: []
-    tools: [rg]
-  - id: test-case-decomposition
-    kind: ai_agent
-    purpose: Decompose user tests, SPEC acceptance, and migration validation inputs into atomic Android-anchored cases. No fabricated expectations.
-    skills: []
-    tools: [rg]
-  - id: test-execution
+    tools: [rg, git]
+  - id: validation-test-runner
     kind: ai_agent
-    purpose: Execute atomic cases via project conventions and capture evidence; a KMP pass that contradicts Android evidence is a failure.
+    purpose: Test workflow — decompose validation requirements into atomic Android-anchored cases, execute them through project conventions, capture evidence.
     skills: []
     tools: [rg, git]
   - id: validation-remediation
     kind: ai_agent
-    purpose: Fix confirmed target failures inside allowed files, anchored to Android/SPEC; emit required reruns of build/preview and tests.
+    purpose: Scoped target fixes — fix confirmed target KMP failures inside allowed files and emit required reruns.
     skills: []
     tools: [rg, git]
   - id: validation-report
     kind: ai_agent
-    purpose: Synthesize fidelity/build/preview/test/remediation into the final passed/failed/blocked verdict. No new tests or fixes.
+    purpose: Final verdict synthesis — passed/failed/blocked from verified fidelity, build, preview, test, and remediation evidence. No new tests or fixes.
     skills: []
     tools: [git]
 ---
 
 # KMP Test Validator Swarm Skill
 
-This is the agent-facing registry and team definition for the `kmp-test-validator` controller (the same-name subagent in `kmp-migration/agents/`). It validates Android-to-KMP migration output against Android source and the migration SPEC, and is invoked only after an `android-to-kmp-migrator` migration report is `ready_for_validation` (or when the user supplies Android source/SPEC plus a KMP target).
-
-The team is a **specialization pipeline (C) with a remediation loop**: an input-contract gate, then a fidelity audit before tests are trusted, then a validation plan, a build/preview gate before behavioral tests, test decomposition and execution, a remediation loop back to the gate/tests, and a final report. A single agent attempting validation conflates these stages — it trusts green tests without auditing fidelity, runs behavioral tests before the build compiles, invents build commands, and lets a KMP pass that contradicts Android behavior count as success. Isolating each concern into an owned node with hard gates keeps Android source/SPEC as ground truth and every verdict evidence-backed. The controller (Leader) owns scenario gating, routing, rerun handling, and the final verdict; nodes own bounded validation work.
+This is the agent-facing registry and team definition for the `kmp-test-validator` controller. It validates Android-to-KMP migration output against Android source and migration SPEC evidence.
 
-## Workflow
+The team is a **reduced serial pipeline with a remediation loop**. Role overlap has been collapsed from 9 role files to 6 role definitions. See [ROLE_REDUCTION.md](ROLE_REDUCTION.md) for the old-to-new map and merge rationale.
 
-The full playbook (Mermaid topology, per-step gates, remediation loop, Final Report format) is in [workflow.md](workflow.md). Protocol summary:
+## Protocol Summary
 
-0. **Pre-flight: check dependencies** — read [dependencies.yaml](dependencies.yaml) and verify `rg` / `git` (both `required: false`; the target Gradle wrapper drives build/test). Report status; **user decides** whether to proceed.
-1. **Workspace state** — `validation-workspace-state` initializes the ledger (refreshed after each node group). Default `output_dir` = `~/.a2c_agents/validation/`.
-2. **Input contract gate** — `validation-input-contract` verifies the migration scenario and KMP evidence; missing migration evidence → `blocked` (never downgrade to generic testing).
-3. **Fidelity audit** — `android-kmp-fidelity-audit` compares Android source/SPEC vs KMP across UI/logic/data-flow/control-flow before tests are trusted.
-4. **Validation plan** — `kmp-validation-plan` resolves trusted build/preview/test commands (user → project scripts/CI → verified Gradle tasks); else `blocked`.
-5. **Build/preview gate** — `build-preview-gate` runs the resolved build and (UI in scope) preview/renderability; behavioral tests do NOT run on failure.
-6. **Test decomposition** — `test-case-decomposition` produces atomic, Android-anchored cases.
-7. **Test execution** — `test-execution` runs cases via project conventions; a KMP pass that contradicts Android evidence is a failure.
-8. **Remediation loop** — `validation-remediation` fixes confirmed target failures within `allowed_files` and re-runs the affected gate/tests until pass or `blocked` (see [bind.md](bind.md)).
-9. **Final: validation report** — `validation-report` synthesizes the `passed | failed | blocked` verdict. Leader routes non-target failures out; it never fabricates a pass.
+0. **Pre-flight** — check optional dependencies from [dependencies.yaml](dependencies.yaml).
+1. **Workspace state** — initialize `validation-workspace-state`.
+2. **Intake/fidelity trust gate** — run `validation-intake-fidelity`; block non-migration validation and test-trust blockers.
+3. **Plan/build gate** — run `validation-plan-gate`; commands must be trusted, and build/preview must pass before behavioral tests.
+4. **Test workflow** — run `validation-test-runner` when validation cases exist.
+5. **Remediation loop** — run `validation-remediation` only for confirmed target KMP failures, then rerun affected gates/tests.
+6. **Final report** — run `validation-report` to issue `passed | failed | blocked`.
 
 ## Roles
 
-Each node is dispatched as a subagent that must read its role file (`skill_spec_path`), paste its `## Inline Persona for Teammate` into the dispatch prompt, and execute only that role's bounded slice. The dispatch order enforces fidelity-before-tests and build-before-tests gating.
-
-| id | Purpose | When dispatched | Key dependencies | Role file |
-|---|---|---|---|---|
-| validation-workspace-state | Ledger / stale-input tracking | Step 1 + refreshed after each group | git | [roles/validation-workspace-state.md](roles/validation-workspace-state.md) |
-| validation-input-contract | Migration-scenario gate + brief | Step 2 | rg | [roles/validation-input-contract.md](roles/validation-input-contract.md) |
-| android-kmp-fidelity-audit | Android-vs-KMP fidelity audit | Step 3 (before tests trusted) | rg, git | [roles/android-kmp-fidelity-audit.md](roles/android-kmp-fidelity-audit.md) |
-| kmp-validation-plan | Trusted command + scope resolution | Step 4 | rg | [roles/kmp-validation-plan.md](roles/kmp-validation-plan.md) |
-| build-preview-gate | Compile + render gate | Step 5 (before behavioral tests) | rg | [roles/build-preview-gate.md](roles/build-preview-gate.md) |
-| test-case-decomposition | Atomic Android-anchored cases | Step 6 | rg | [roles/test-case-decomposition.md](roles/test-case-decomposition.md) |
-| test-execution | Run cases + capture evidence | Step 7 (after build gate) | rg, git | [roles/test-execution.md](roles/test-execution.md) |
-| validation-remediation | Scoped target fixes + reruns | Step 8 loop (on failures) | rg, git | [roles/validation-remediation.md](roles/validation-remediation.md) |
-| validation-report | Final verdict synthesis | Step 9 | git | [roles/validation-report.md](roles/validation-report.md) |
-
-> Before dispatching each teammate, read its role file and paste its `## Inline Persona for Teammate`
-> section directly into the dispatch prompt — adopting agents do NOT auto-load role files. Fill the
-> `{PLACEHOLDER}` inputs from the contract.
+| id | Purpose | Role file |
+|---|---|---|
+| `validation-workspace-state` | Ledger and stale-input tracking | [roles/validation-workspace-state.md](roles/validation-workspace-state.md) |
+| `validation-intake-fidelity` | Migration scenario gate and fidelity audit | [roles/validation-intake-fidelity.md](roles/validation-intake-fidelity.md) |
+| `validation-plan-gate` | Command resolution plus build/preview gate | [roles/validation-plan-gate.md](roles/validation-plan-gate.md) |
+| `validation-test-runner` | Test decomposition and execution | [roles/validation-test-runner.md](roles/validation-test-runner.md) |
+| `validation-remediation` | Scoped target fixes and rerun requests | [roles/validation-remediation.md](roles/validation-remediation.md) |
+| `validation-report` | Final verdict synthesis | [roles/validation-report.md](roles/validation-report.md) |
 
 ## Files
 
-| File | What it contains | When to read |
-|---|---|---|
-| [workflow.md](workflow.md) | Mermaid C topology, staged protocol with gates, remediation loop, Final Report format | Before first dispatch — the complete playbook |
-| [bind.md](bind.md) | Resource limits, team behavioral constraints, trigger boundary, `max_remediation_cycles`, failure & degraded modes | When hitting limits, handling failures, or scoping a large validation |
-| [roles/\*.md](roles/) | Per-node identity, success criteria, boundary, output schema, Inline Persona for Teammate | Before dispatching each teammate — extract Inline Persona |
-| [dependencies.yaml](dependencies.yaml) | External CLI tools (`rg`, `git`) checked at startup | Step 0 — verify deps, report missing items, user decides go/no-go |
+| File | What it contains |
+|---|---|
+| [ROLE_REDUCTION.md](ROLE_REDUCTION.md) | Reduced role analysis and old-to-new map |
+| [workflow.md](workflow.md) | Reduced pipeline, gates, remediation loop, final report format |
+| [bind.md](bind.md) | Guardrails, failure handling, resource constraints |
+| [roles/](roles/) | Active reduced role specs |
+| [dependencies.yaml](dependencies.yaml) | Optional CLI tools checked at startup |
 
 ## Shared Return Contract
 
-Every node returns a compact payload with, in addition to node-specific fields:
-
 ```json
 {
   "status": "completed | passed | failed | needs_rerun | blocked",
@@ -121,17 +91,12 @@ Every node returns a compact payload with, in addition to node-specific fields:
 }
 ```
 
-Use `needs_rerun` when a previous node can resolve the gap, `failed` when validation evidence is complete and a behavior/build/test failure remains, and `blocked` only when required Android/KMP/SPEC evidence, environment capability, or user input is missing and cannot be produced by rerunning another node.
-
-## Optional Android Studio MCP Context
-
-When the `jetbrains` MCP server is available, the controller may pass indexed IDE context to nodes: project modules/dependencies/VCS roots/run configs (`get_project_modules`, `get_project_dependencies`, `get_repositories`, `get_run_configurations`), file/symbol ownership (`find_files_by_glob`, `search_in_files_by_regex`, `get_symbol_info`), diagnostics (`get_file_problems`), and IDE build diagnostics (`build_project`). Always pass `projectPath: <kmp_target_project_path>`. MCP is advisory — required build/preview/test commands and the final validation report remain the source of truth.
+Use `needs_rerun` when a previous role can resolve the gap, `failed` when validation evidence is complete and a behavior/build/test failure remains, and `blocked` when required evidence, command, environment, or user input is missing.
 
 ## Shared Rules
 
-- Each node must read its own role file before work and stay inside its responsibility boundary.
-- Build and test commands must come from user input, project scripts, target understanding, or verified Gradle task discovery — never invented.
-- A passing test (or build) that contradicts Android source/SPEC behavior is a validation failure.
-- Nodes that edit code must list changed files and the evidence that justified each change; only `validation-remediation` edits target code.
-- The controller must not substitute itself for a node's audit, fix, or test execution.
-- Final success requires: migration trigger verified, fidelity audit complete, build/preview gate passed or explicitly blocked with evidence, tests executed when provided, fixes revalidated, and `validation-report` complete.
+- Each role must read its role file before work and stay inside its responsibility boundary.
+- Build/test/preview commands must come from user input, project scripts/docs/CI, or verified Gradle task discovery.
+- A passing KMP test that contradicts Android source/SPEC behavior is a validation failure.
+- Only `validation-remediation` edits target code.
+- The controller must not substitute itself for a role's audit, command gate, test run, fix, or final verdict.