@code-migration/wow-migrator 0.1.0 → 0.1.2

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

@@ -1,203 +1,165 @@
 ---
 name: android-to-kmp-migrator
 description: |
-  20-role pipeline Swarm Skill (C+B) that migrates Legacy Android into an existing KMP target project: analysis, dependency gate, parallel prep, UI-then-logic implementation, review→fix loops, verification, and a migration report.
-  Use with the android-to-kmp-migrator controller to port Android UI, resources, navigation, state, and logic into one KMP project, then hand to kmp-test-validator.
+  10-role reduced module-first Swarm Skill (C+B) that migrates Legacy Android into an existing KMP target project with strict output roots, migration-module inventory, per-module node results, module/global representations, review-fix modes, verification checks, and a validation-ready migration report.
+  Use with the android-to-kmp-migrator controller to port Android UI, resources, navigation, state, data, platform behavior, and logic into one KMP project by migrating each module first, then synthesizing a global migration representation for kmp-test-validator.
   Do NOT use for Legacy Android analysis, KMP-only feature work, quick lookups, or non-migration refactors.
-version: "0.2"
+version: "0.4"
 kind: swarm-skill
 disable-model-invocation: true
 roles:
   - id: migration-workspace-state
     kind: ai_agent
-    purpose: State ledger — node status, changed-file ownership, stale outputs, rerun/blocker history, next actions. No code analysis or edits.
+    purpose: State ledger owner — node status, changed-file ownership, stale outputs, rerun/blocker history, next actions. No code analysis or edits.
     skills: []
     tools: [git]
-  - id: legacy-spec-delta-review
+  - id: migration-analysis-planning
     kind: ai_agent
-    purpose: Cross-check Legacy SPEC vs raw source for missing coverage and contradictions; classify and route deltas. Raw source wins.
+    purpose: Analysis and planning owner — Legacy SPEC/raw-source deltas, target KMP understanding, reuse inventory, source-to-target map, integration scaffold, and ordered module tasks.
     skills: []
     tools: [rg]
-  - id: target-project-understand
+  - id: dependency-platform-gate
     kind: ai_agent
-    purpose: First migration node — verify KMP target, capture baseline env, detect relevant sub-module, build reuse inventory and constraints.
+    purpose: Dependency and platform owner — minimal-change dependency readiness plus Android-only API replacement strategy and expect/actual/platform-source-set plan.
     skills: []
     tools: [rg]
-  - id: migration-alignment
+  - id: presentation-integration
     kind: ai_agent
-    purpose: Build source-to-target map, integration scaffold, and ordered implementation tasks; record SPEC/Design/Plan deltas. No implementation.
-    skills: []
-    tools: [rg]
-  - id: dependency-resolution
-    kind: ai_agent
-    purpose: Minimal-change build gate — map capabilities to baseline/reuse, justify any build-config change. Returns dependency readiness.
-    skills: []
-    tools: [rg]
-  - id: theme-design-system-mapping
-    kind: ai_agent
-    purpose: Map Legacy visual tokens to target design-system tokens/components, reuse-first; produce UI guidance and visual gaps.
-    skills: []
-    tools: [rg]
-  - id: resource-migration
-    kind: ai_agent
-    purpose: Migrate or model local & online resources into target KMP conventions, preserving semantics; record resource gaps.
+    purpose: Presentation integration owner — theme/design tokens, resources, online media modeling, navigation routes, presentation gaps, and UI handoff.
     skills: []
     tools: [rg, curl]
-  - id: navigation-migration
+  - id: state-data-prep
     kind: ai_agent
-    purpose: Migrate routes, parameters, back behavior, deep links, and result passing into target navigation; record route gaps.
+    purpose: State and data preparation owner — state holders, DTO/domain/UI models, mappers, API/data contract expectations, and logic handoff.
     skills: []
     tools: [rg]
-  - id: platform-api-replacement
+  - id: ui-implementation
     kind: ai_agent
-    purpose: Replace Android-only APIs with target-safe abstractions or expect/actual; keep Android-only code out of commonMain.
+    purpose: UI implementation owner — migrated Compose UI layout/components/states/resources first, with binding surfaces and no business logic.
     skills: []
     tools: [rg]
-  - id: state-model-mapping
+  - id: logic-implementation
     kind: ai_agent
-    purpose: Map state holders and DTO/domain/UI models to target structures, preserving state semantics; hand off to the logic node.
+    purpose: Logic implementation owner — repositories/use cases/API integration/state propagation/business logic bound to approved UI surfaces.
     skills: []
     tools: [rg]
-  - id: ui-mockup-implementation
-    kind: ai_agent
-    purpose: Implement migrated UI layout/components/states/resources first in the target project; expose binding surfaces. No business logic.
-    skills: []
-    tools: [rg]
-  - id: dataflow-logic-implementation
-    kind: ai_agent
-    purpose: Implement architecture, data flow, API integration, navigation effects, lifecycle, and business logic bound to UI surfaces.
-    skills: []
-    tools: [rg]
-  - id: module-node-migration-review
-    kind: ai_agent
-    purpose: Read-only review of one migration slice for contract/scope/parity/conventions/handoff; classify and route must-fix findings.
-    skills: []
-    tools: [rg, git]
-  - id: module-node-migration-fix
+  - id: module-node-review-fix
     kind: ai_agent
-    purpose: Apply assigned must-fix findings inside allowed files only; preserve conventions; require mandatory re-review.
+    purpose: Review/fix owner with strict modes — read-only review or scoped fix for one module/node slice; fresh re-review required after every fix.
     skills: []
     tools: [rg, git]
-  - id: source-set-placement-guard
+  - id: migration-verification
     kind: ai_agent
-    purpose: Verify KMP source-set placement; catch Android-only APIs in shared code and missing/duplicate actuals; route violations.
+    purpose: Verification owner — source-set, API contract, UI render/fidelity, and incremental build checks with stable check IDs and routed failures.
     skills: []
     tools: [rg, git]
-  - id: api-contract-parity
+  - id: completion-report
     kind: ai_agent
-    purpose: Diff migrated KMP API contracts vs Legacy API/data evidence; classify and route mismatches. No fixes.
-    skills: []
-    tools: [rg]
-  - id: ui-render-fidelity-check
-    kind: ai_agent
-    purpose: Verify migrated screens render and cover visual states/resources/theme; route UI failures. Static coverage when no render command.
-    skills: []
-    tools: [rg]
-  - id: incremental-build-check
-    kind: ai_agent
-    purpose: Run the smallest trustworthy target build/check; parse failures and route to responsible nodes. Early gate, not final validation.
-    skills: []
-    tools: [git]
-  - id: prd-completion-check
-    kind: ai_agent
-    purpose: Judge readiness vs PRD/raw task/SPEC/node outputs and invariants; emit node-routed rerun requests or ready_for_validation.
+    purpose: Completion/report owner with strict modes — readiness/rerun/blocker decisions and final migration_report handoff after module/global representations exist.
     skills: []
     tools: [rg, git]
-  - id: migration-report
-    kind: ai_agent
-    purpose: Synthesize final migration report and validation inputs for kmp-test-validator; ready_for_validation only when completion is ready.
-    skills: []
-    tools: [git]
 ---
 
 # Android To KMP Migrator Swarm Skill
 
-This is the agent-facing registry and team definition for the `android-to-kmp-migrator` controller (the same-name subagent in `kmp-migration/agents/`). It converts a Legacy Android SPEC plus an existing KMP target project into migrated, validation-ready KMP code.
+This is the agent-facing registry and team definition for the `android-to-kmp-migrator` controller. It converts a completed Legacy Android SPEC plus an existing KMP target project into migrated, validation-ready KMP code through a module-first schedule.
 
-The team is a **specialization pipeline (C) with embedded parallel fan-outs (B) and review→fix loops**: a serial analysis chain feeds a dependency gate, then a parallel prep stage, then UI-before-logic implementation, then parallel verification, completion check, and report. A single agent attempting the whole migration blurs the hard stage boundaries — it implements logic before the UI surface exists, skips the dependency minimal-change gate, lets Android-only APIs leak into `commonMain`, and self-approves its own work. Isolating each concern into an owned node with hard handoff gates and a mandatory review→fix→re-review loop keeps every change scoped, traceable, and reviewed before downstream nodes consume it. The controller (Leader) owns routing, contract enforcement, rerun handling, and the `kmp-test-validator` handoff; nodes own bounded target-understanding and implementation work.
+The team is a **reduced specialization pipeline (C) with embedded parallel fan-outs (B)**. Role overlap has been collapsed into 10 role definitions; safety is preserved through explicit dispatch modes and strict path contracts. See [ROLE_REDUCTION.md](ROLE_REDUCTION.md) for the old-to-new mapping and merge rationale.
 
-## Workflow
+## Protocol Summary
 
-The full playbook (Mermaid topology, per-step gates, review→fix loop, failure routing, Final Report format) is in [workflow.md](workflow.md). Protocol summary:
-
-0. **Pre-flight: check dependencies** — read [dependencies.yaml](dependencies.yaml) and verify `rg` / `git` / `curl` (all `required: false`; the target Gradle wrapper drives builds). Report status; **user decides** whether to proceed.
-1. **Trigger + shared brief + workspace state** — Leader confirms the migration trigger and Legacy SPEC context, builds the shared brief, and initializes `migration-workspace-state`. Default `output_dir` = `~/.a2c_agents/migration/`.
-2. **Analysis chain (serial)** — `legacy-spec-delta-review` → `target-project-understand` (must confirm KMP, else `blocked`) → `migration-alignment`.
-3. **Dependency gate** — `dependency-resolution` must return `ready_for_implementation` before any implementation node runs (minimal-change gate; see [bind.md](bind.md)).
-4. **Stage Prep (parallel)** — `theme-design-system-mapping`, `resource-migration`, `navigation-migration`, `platform-api-replacement`, `state-model-mapping`.
-5. **Review→fix loop** — after any file-changing node: `module-node-migration-review` → `module-node-migration-fix` (if `needs_fix`) → mandatory re-review, until `approved`.
-6. **UI implementation** — `ui-mockup-implementation` (before logic), then the review→fix loop.
-7. **Dataflow/logic implementation** — `dataflow-logic-implementation`, then the review→fix loop.
-8. **Stage Verify (parallel)** — `source-set-placement-guard`, `api-contract-parity`, `ui-render-fidelity-check`, `incremental-build-check`; failures route back to the responsible node.
-9. **Completion check** — `prd-completion-check` → `ready_for_validation`, `needs_rerun` (route to nodes), or `blocked`.
-10. **Final: migration report** — `migration-report` returns `ready_for_validation` only when completion is ready; the Leader then invokes `kmp-test-validator`. Leader routes failures verbatim, never mediates.
+0. **Pre-flight** — verify optional dependencies from [dependencies.yaml](dependencies.yaml).
+1. **Trigger + output root** — lock `output_root = <output_dir or ~/.a2c_agents/migration>/android-to-kmp-migrator`; write `run_manifest.json`.
+2. **Migration module inventory** — write `module-index/migration_module_inventory.json` and `.md`; write each module's `module_brief.json`.
+3. **Workspace state** — initialize and refresh `migration-workspace-state` under `<output_root>/global/node-results/migration-workspace-state/`.
+4. **Per-module planning** — run `migration-analysis-planning`.
+5. **Per-module dependency/platform gate** — run `dependency-platform-gate`.
+6. **Per-module prep fan-out** — run `presentation-integration` and `state-data-prep` when inputs allow.
+7. **Review/fix loop** — run `module-node-review-fix` in `review` mode; if needed, run `fix` mode; then run a fresh `review`.
+8. **UI then logic** — run `ui-implementation`, review/fix, then `logic-implementation`, review/fix.
+9. **Verification** — run `migration-verification` with required `check_ids`: `source_set`, `api_contract`, `ui_render`, `incremental_build`.
+10. **Completion/report** — run `completion-report` in `readiness` mode, write module/global representations, then run `completion-report` in `report` mode and hand off to `kmp-test-validator`.
 
 ## 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 upstream→downstream data availability and the review→fix gates.
-
-| id | Purpose | When dispatched | Key dependencies | Role file |
-|---|---|---|---|---|
-| migration-workspace-state | State ledger / stale-output tracking | Step 1 + refreshed after major completions | git | [roles/migration-workspace-state.md](roles/migration-workspace-state.md) |
-| legacy-spec-delta-review | SPEC-vs-source delta review | Step 2 (serial) | rg | [roles/legacy-spec-delta-review.md](roles/legacy-spec-delta-review.md) |
-| target-project-understand | Target KMP understanding + reuse inventory | Step 2 (serial) | rg | [roles/target-project-understand.md](roles/target-project-understand.md) |
-| migration-alignment | Source-to-target map + ordered tasks | Step 2 (serial) | rg | [roles/migration-alignment.md](roles/migration-alignment.md) |
-| dependency-resolution | Minimal-change dependency gate | Step 3 (gate) | rg | [roles/dependency-resolution.md](roles/dependency-resolution.md) |
-| theme-design-system-mapping | Visual token mapping | Step 4 (parallel prep) | rg | [roles/theme-design-system-mapping.md](roles/theme-design-system-mapping.md) |
-| resource-migration | Local & online resource migration | Step 4 (parallel prep) | rg, curl | [roles/resource-migration.md](roles/resource-migration.md) |
-| navigation-migration | Route/param/back/deep-link migration | Step 4 (parallel prep) | rg | [roles/navigation-migration.md](roles/navigation-migration.md) |
-| platform-api-replacement | Android-only API → expect/actual | Step 4 (parallel prep) | rg | [roles/platform-api-replacement.md](roles/platform-api-replacement.md) |
-| state-model-mapping | State holder & model mapping | Step 4 (parallel prep) | rg | [roles/state-model-mapping.md](roles/state-model-mapping.md) |
-| ui-mockup-implementation | UI surface implementation (first) | Step 6 (after prep approved) | rg | [roles/ui-mockup-implementation.md](roles/ui-mockup-implementation.md) |
-| dataflow-logic-implementation | Data/API/logic implementation | Step 7 (after UI approved) | rg | [roles/dataflow-logic-implementation.md](roles/dataflow-logic-implementation.md) |
-| module-node-migration-review | Read-only per-slice review | Step 5 loop (after any file change) | rg, git | [roles/module-node-migration-review.md](roles/module-node-migration-review.md) |
-| module-node-migration-fix | Scoped must-fix application | Step 5 loop (on needs_fix) | rg, git | [roles/module-node-migration-fix.md](roles/module-node-migration-fix.md) |
-| source-set-placement-guard | KMP source-set boundary guard | Step 8 (parallel verify) | rg, git | [roles/source-set-placement-guard.md](roles/source-set-placement-guard.md) |
-| api-contract-parity | Migrated vs Legacy API parity | Step 8 (parallel verify) | rg | [roles/api-contract-parity.md](roles/api-contract-parity.md) |
-| ui-render-fidelity-check | Render + visual-state coverage | Step 8 (parallel verify) | rg | [roles/ui-render-fidelity-check.md](roles/ui-render-fidelity-check.md) |
-| incremental-build-check | Smallest target build/check gate | Step 8 (parallel verify) | git | [roles/incremental-build-check.md](roles/incremental-build-check.md) |
-| prd-completion-check | Readiness verdict + rerun routing | Step 9 | rg, git | [roles/prd-completion-check.md](roles/prd-completion-check.md) |
-| migration-report | Final report + validation inputs | Step 10 | git | [roles/migration-report.md](roles/migration-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.
+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 bounded slice.
+
+| id | Purpose | When dispatched | Role file |
+|---|---|---|---|
+| `migration-workspace-state` | Ledger and stale-output tracking | Global and module refreshes | [roles/migration-workspace-state.md](roles/migration-workspace-state.md) |
+| `migration-analysis-planning` | SPEC deltas, target understanding, alignment | Per-module first stage | [roles/migration-analysis-planning.md](roles/migration-analysis-planning.md) |
+| `dependency-platform-gate` | Dependency readiness and platform replacement | Before prep/implementation | [roles/dependency-platform-gate.md](roles/dependency-platform-gate.md) |
+| `presentation-integration` | Theme, resources, navigation | Prep fan-out before UI | [roles/presentation-integration.md](roles/presentation-integration.md) |
+| `state-data-prep` | State/model/API contract prep | Prep fan-out before logic | [roles/state-data-prep.md](roles/state-data-prep.md) |
+| `ui-implementation` | UI-first migrated surface | After prep approval | [roles/ui-implementation.md](roles/ui-implementation.md) |
+| `logic-implementation` | Data/API/business logic | After UI approval | [roles/logic-implementation.md](roles/logic-implementation.md) |
+| `module-node-review-fix` | Read-only review or scoped fix by mode | After file-changing slices | [roles/module-node-review-fix.md](roles/module-node-review-fix.md) |
+| `migration-verification` | Source-set/API/UI/build checks | After implementation approval | [roles/migration-verification.md](roles/migration-verification.md) |
+| `completion-report` | Readiness and final report by mode | Module/global completion | [roles/completion-report.md](roles/completion-report.md) |
 
 ## Files
 
-| File | What it contains | When to read |
-|---|---|---|
-| [workflow.md](workflow.md) | Mermaid C+B topology, staged protocol with gates, review→fix loop, failure routing, Final Report format | Before first dispatch — the complete playbook |
-| [bind.md](bind.md) | Resource limits, team behavioral constraints, dependency-gate/single-project invariants, failure & degraded modes | When hitting limits, handling failures, or scoping a large migration |
-| [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`, `curl`) 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, old-to-new map, dispatch order, mode boundaries |
+| [workflow.md](workflow.md) | Mermaid topology, staged protocol, gates, final report format |
+| [bind.md](bind.md) | Resource limits, behavioral constraints, failure handling, path contract |
+| [roles/](roles/) | Active reduced role specs |
+| [dependencies.yaml](dependencies.yaml) | Optional CLI tools checked at startup |
+
+## Strict Output Schedule
+
+```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
+```
 
-## Shared Return Shape
+Required artifacts:
+
+- `<output_root>/run_manifest.json`
+- `<module_index_dir>/migration_module_inventory.json`
+- `<module_index_dir>/migration_module_inventory.md`
+- `<module_root>/module_brief.json`
+- `<node_result_dir>/<node-specific>.json`
+- `<node_result_dir>/<node-specific>.md`
+- `<module_representation_dir>/module_migration_representation.json`
+- `<module_representation_dir>/module_migration_representation.md`
+- `<global_dir>/global_migration_representation.json`
+- `<global_dir>/global_migration_representation.md`
+- `<report_dir>/migration_report.json`
+- `<report_dir>/migration_report.md`
 
-Every node return payload includes, in addition to node-specific fields:
+## Shared Return Shape
 
 ```json
 {
   "status": "completed | passed | ready_for_implementation | ready_for_validation | needs_rerun | failed | blocked",
   "node": "<node-name>",
+  "mode": "<mode when role has modes>",
+  "migration_module_id": "<module id or global>",
+  "module_scope": "<module/screen/feature/resource/API scope or global>",
+  "output_dir": "<exact node_result_dir>",
   "output_files": ["<paths>"],
   "changed_files": ["<paths or empty>"],
   "stale_upstream_inputs": ["<paths or empty>"],
-  "rerun_requests": [ { "node": "<responsible-node>", "reason": "", "required_inputs": [], "expected_output": "" } ],
+  "rerun_requests": [{ "node": "<responsible-node>", "reason": "", "required_inputs": [], "expected_output": "" }],
   "blocking_gaps": ["<gaps or empty>"]
 }
 ```
 
-Controller handling: missing/empty `output_files` → rerun the same node; non-empty `stale_upstream_inputs` → refresh those upstream artifacts then rerun; non-empty `rerun_requests` → dispatch the responsible node first; `blocking_gaps` with no resolving rerun → stop with a user-visible blocker.
-
-## Optional Android Studio MCP Context
-
-When the `jetbrains` MCP server is available, the controller may pass indexed IDE context to nodes: project structure/dependencies (`get_project_modules`, `get_project_dependencies`, `get_repositories`), code intelligence (`find_files_by_glob`, `search_in_files_by_regex`, `get_symbol_info`), diagnostics after code changes (`get_file_problems`), IDE build diagnostics (`build_project`), run configs (`get_run_configurations`, `execute_run_configuration`), and IDE-safe edits (`rename_refactoring`, `reformat_file`). Always pass `projectPath: <kmp_target_project_path>`. MCP is advisory — Gradle build/check gates, module review, completion check, and KMP validation remain required; record MCP gaps in the workspace ledger.
+Controller handling: missing/empty `output_files` -> rerun the same node; non-empty `stale_upstream_inputs` -> refresh upstream artifacts then rerun; non-empty `rerun_requests` -> dispatch the responsible node first; unresolved `blocking_gaps` -> stop with a user-visible blocker.
 
 ## Shared Rules
 
 - Each node must read its own role file before work and stay inside its responsibility boundary.
-- Every important claim must include evidence from source paths, SPEC sections, or upstream node outputs; unknowns are marked explicitly, never guessed.
-- The controller must not substitute itself for node implementation; no migration leaves TODO placeholders as completion output.
-- Target conventions and reusable modules/components take priority over new abstractions; target build config is read-only except via `dependency-resolution`.
-- Migrated code stays inside one KMP target project; SPEC guides migration, but raw Legacy Android source wins when evidence conflicts.
+- Consolidated roles must respect `mode`; do not combine review and fix in one invocation.
+- Every important claim must include evidence from source paths, SPEC sections, upstream node outputs, or module/global representations.
+- The controller must not substitute itself for node implementation.
+- Target conventions and reusable modules/components take priority over new abstractions.
+- Target build config is read-only except through `dependency-platform-gate`.
+- Migrated code stays inside one KMP target project; raw Legacy Android source wins when SPEC conflicts.

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

@@ -4,10 +4,10 @@
 
 | Item | Limit | Reason |
 |---|---|---|
-| `max_parallel_teammates` | 5 | Matches the largest parallel fan-out (Stage Prep: theme/resource/navigation/platform/state). Stage Verify runs ≤4 in parallel; the analysis chain and review→fix loops are serial. |
-| `total_wall_clock_budget` | 90 min | Upper bound for one full migration run including the analysis chain, prep, UI, logic, review→fix loops, and verification on a feature-scoped migration. Whole-project scope should be split per § (b). |
-| `total_token_budget` | 1.5M tokens | Budget across all 20 nodes + Leader integration + review→fix iterations; prevents one node or loop from exhausting context. |
-| `per_node_token_budget` | 120k tokens | Per node soft cap; implementation nodes (`ui-mockup-implementation`, `dataflow-logic-implementation`) and `prd-completion-check` may use the upper end. |
+| `max_parallel_teammates` | 2 | Matches the reduced per-module fan-out (`presentation-integration` + `state-data-prep`). Other stages are serial or mode-gated. |
+| `total_wall_clock_budget` | 90 min per feature module batch | Upper bound for one module-first migration batch including inventory, per-module planning, prep, UI, logic, review/fix, verification, representations, and report. |
+| `total_token_budget` | 1.2M tokens per batch | Budget across 10 reduced roles + Leader integration + review/fix iterations + representation synthesis. |
+| `per_node_token_budget` | 140k tokens | Consolidated roles carry broader context; implementation and completion/report modes may use the upper end. |
 | `max_review_fix_cycles` | 3 per slice | Max `review → fix → re-review` iterations for one module/node scope before escalating the slice as `blocked` to the controller/user. |
 | `incremental_build_runs` | 1 per Verify pass | One smallest-trustworthy build/check per verification pass; reruns only after a routed fix. |
 
@@ -15,15 +15,19 @@
 
 Team-level rules — distinct from each role's own `## Boundary`.
 
-- **Leader-as-orchestrator only**: the Leader (`android-to-kmp-migrator` controller) verifies the trigger, builds the shared brief, dispatches nodes in dependency order, verifies outputs, routes reruns, and invokes `kmp-test-validator`. The Leader does NOT implement migration code, fix findings, or substitute any node's work.
-- **Hard dependency order (C-pattern)**: the analysis chain (delta-review → target-understand → alignment) precedes the dependency gate, which precedes implementation. UI implementation precedes dataflow/logic implementation. A downstream node references upstream node outputs by path and must NOT rebuild or overwrite an upstream node's artifact; on missing/stale upstream input it returns `needs_rerun`/`blocked`.
-- **Mandatory review→fix→re-review loop**: after any node changes files, `module-node-migration-review` runs; on `needs_fix`, `module-node-migration-fix` applies only assigned `must_fix` findings inside `allowed_files`, then a re-review is mandatory. No downstream gate consumes a slice whose latest review is not `approved`.
-- **Dependency gate authority**: only `dependency-resolution` may justify a build-config change; target build configuration is read-only to every other node. No node adds dependencies, root Gradle/settings files, or wrappers.
+- **Leader-as-orchestrator only**: the Leader (`android-to-kmp-migrator` controller) verifies the trigger, builds the shared brief, dispatches reduced roles in dependency order, verifies outputs, routes reruns, and invokes `kmp-test-validator`. The Leader does NOT implement migration code, fix findings, or substitute any node's work.
+- **Strict output root**: the Leader must lock `output_root = <output_dir or ~/.a2c_agents/migration>/android-to-kmp-migrator` before any migration node dispatch. All node outputs, module representations, global representation, report artifacts, logs, and ledgers must be under this root.
+- **Module-first schedule**: the Leader must write `module-index/migration_module_inventory.*`, then process each `migration_module_id` through planning, dependency/platform, prep, review/fix, UI, review/fix, logic, review/fix, verification, readiness, and module representation before global aggregation.
+- **Per-node exact paths**: module-scoped nodes receive `output_dir = <output_root>/modules/<migration_module_id>/node-results/<node_id>`. Global-only outputs use `<output_root>/global/...`; final reports use `<output_root>/report/...`.
+- **Hard dependency order (C-pattern)**: `migration-analysis-planning` precedes `dependency-platform-gate`, which precedes prep and implementation. `ui-implementation` precedes `logic-implementation`. A downstream node references upstream node outputs by path and must NOT rebuild or overwrite upstream artifacts.
+- **Mandatory review→fix→re-review loop**: after any node changes files, `module-node-review-fix` runs in `mode: review`; on `needs_fix`, it runs in `mode: fix` inside `allowed_files`, then a fresh `mode: review` invocation is mandatory. No downstream gate consumes a slice whose latest review is not `approved`.
+- **Dependency gate authority**: only `dependency-platform-gate` may justify a build-config change; target build configuration is read-only to every other role. No role adds dependencies, root Gradle/settings files, or wrappers.
 - **Single-project invariant**: migrated code stays inside one KMP target project; no migrated sub-module becomes a standalone project. Android-only APIs never enter `commonMain`.
 - **No placeholder completion**: no implementation node may return `completed` with TODO/FIXME/stub/sample-only-data in production paths as its deliverable.
 - **Failure routing, not mediation**: when a verification node fails or nodes disagree, the Leader routes the failure verbatim to the responsible node (recorded in the workspace-state ledger and `prd_completion_check`); it does not silently reconcile or average.
 - **Stale-artifact discipline**: `migration-workspace-state` is refreshed after major node completions; any output whose upstream changed afterward is marked stale and must be re-run before consumption.
-- **Validation boundary**: only `prd-completion-check` issues `ready_for_validation` readiness, only `migration-report` assembles the validation handoff, and only `kmp-test-validator` (invoked by the Leader afterward) validates. SPEC guides migration, but raw Legacy Android source wins when evidence conflicts.
+- **Validation boundary**: only `completion-report` in `mode: readiness` issues readiness, only `completion-report` in `mode: report` assembles the validation handoff, and only `kmp-test-validator` validates. SPEC guides migration, but raw Legacy Android source wins when evidence conflicts.
+- **Representation gate**: every scheduled module must have `module_migration_representation.json` and `.md`. `migration-report` cannot return `ready_for_validation` until every scheduled module representation plus `global_migration_representation.json` and `.md` exists and is non-empty.
 
 ## Failure Handling
 
@@ -35,14 +39,14 @@ Team-level rules — distinct from each role's own `## Boundary`.
 | Malformed output (does not match role `## Output Schema` / shared return, or files missing/empty) | Re-dispatch once with the schema inlined and a "previous output was malformed/missing" preamble. On 2nd failure, mark `[ROLE MISSING — malformed output]`. |
 | Node returns `needs_rerun` / `blocked` (missing or stale upstream input) | Refresh/re-run the named upstream node first, then re-dispatch this node. If unresolvable, record the `blocking_gap` and set readiness accordingly. |
 | Review→fix loop does not converge in `max_review_fix_cycles` | Escalate the slice as `blocked` with the unresolved `must_fix` findings to the controller/user; do not force-approve. |
-| Verification node (`source-set-placement-guard` / `api-contract-parity` / `ui-render-fidelity-check` / `incremental-build-check`) returns `failed` | Route each failure to its `route_to_node`, re-run that node, re-enter the review→fix loop, then re-run the verification node. |
+| `migration-verification` returns `failed` for any check ID | Route each failure to its reduced `route_to_node`, re-run that node, re-enter the review/fix loop, then re-run the failed check IDs. |
 | Node attempts to rebuild another node's artifact or edit outside scope | Reject as out-of-scope; re-dispatch with the role `## Boundary > Forbidden` restated. |
 
 ### (b) Input over-scale degradation
 
 | Trigger condition | Degraded mode |
 |---|---|
-| Whole-project migration on a large monorepo (e.g., > ~30 feature modules or > ~3000 in-scope source files) | Warn the user; split into module/feature-scoped migration passes and record the reduced scope in the workspace ledger before dispatching Stage Prep. |
+| Whole-project migration on a large monorepo (e.g., > ~30 feature modules or > ~3000 in-scope source files) | Warn the user; split into `migration_module_id` batches in `migration_module_inventory.*`; process batches without changing `output_root`. |
 | `total_token_budget` projected to overflow before verification | Complete the analysis chain + dependency gate + current slice, checkpoint via `migration-workspace-state`, and continue in a follow-up run; mark uncovered scope explicitly. |
 | No trustworthy incremental build command from `target-project-understand` | `incremental-build-check` returns `blocked`; rely on source-set guard + parity + render static checks and surface the build gap to `prd-completion-check` (does not auto-pass). |
 | `jetbrains` MCP unavailable or pointing at the wrong project | Continue on file-system evidence and the target Gradle wrapper; record the MCP gap in the workspace ledger and affected node outputs. |
@@ -52,3 +56,21 @@ Team-level rules — distinct from each role's own `## Boundary`.
 - If 50%+ of dispatched nodes in a stage return `[ROLE MISSING]`, the run is **FAILED** — emit a partial migration report with a `FAILED: insufficient node coverage` header, readiness `blocked`, and the missing-evidence list.
 - If `total_wall_clock_budget` is exceeded, halt in-flight nodes, checkpoint via `migration-workspace-state`, emit whatever verified outputs exist, and tag the report `INCOMPLETE: budget exceeded`.
 - If `total_token_budget` is exceeded mid-run, halt new dispatches, let in-flight nodes finish, checkpoint, and emit a partial report tagged `INCOMPLETE: token budget exceeded`.
+
+## Required Path Contract
+
+The controller must pass these values to nodes and reject any output outside the declared path:
+
+```json
+{
+  "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"
+}
+```
+
+Each reduced role boundary is justified in `ROLE_REDUCTION.md`. Do not dispatch superseded old role IDs, alias old paths, or write compatibility copies outside this schedule.

package/skills/android-to-kmp-migrator/roles/completion-report.md

@@ -0,0 +1,72 @@
+# Role: Completion Report
+
+## Identity
+
+> "I either decide readiness or write the validation handoff report. I never skip module/global representation gates."
+
+You are the `completion-report` node subagent. You consolidate PRD completion and final migration report duties with strict modes.
+
+## Modes
+
+- `mode: readiness`: verify module or global readiness; emit rerun/blocker decisions.
+- `mode: report`: write final migration report and validation inputs after readiness passes.
+
+## Success Criteria
+
+- Readiness mode writes `completion_readiness.json` and `completion_readiness.md`.
+- Report mode writes `migration_report.json` and `migration_report.md`.
+- Readiness checks raw task, PRD/DESIGN/PLAN, module outputs, reviews, verification, invariants, and incomplete markers.
+- Report mode consumes module representations and global representation.
+
+## Boundary
+
+Forbidden:
+- Do not fix implementation gaps.
+- Do not mark validation passed.
+- Do not run report mode when module/global representations are missing.
+
+Mandatory:
+- Validate `mode`, `migration_module_id`, module/global representation paths, workspace state, and exact `output_dir`.
+- Readiness output path is `<module_root>/node-results/completion-report/readiness` or `<global_dir>/node-results/completion-report/readiness`.
+- Report output path is `<output_root>/report`.
+
+## Output Schema
+
+```json
+{
+  "status": "ready_for_validation | needs_rerun | blocked",
+  "node": "completion-report",
+  "mode": "readiness | report",
+  "migration_module_id": "global | <migration_module_id>",
+  "module_scope": {},
+  "output_root": "",
+  "output_dir": "",
+  "requirement_coverage": [],
+  "migration_invariants": {},
+  "module_representations": [],
+  "global_migration_representation": "",
+  "validation_inputs": [],
+  "rerun_requests": [],
+  "blocking_gaps": []
+}
+```
+
+Shared return shape applies.
+
+## Inline Persona for Teammate
+
+```text
+ROLE: completion-report node.
+
+Respect mode strictly.
+Readiness mode: check requirements, invariants, reviews, verification, incomplete markers, and rerun needs.
+Report mode: consume module/global representations and write migration_report.json/md for kmp-test-validator.
+
+INPUTS: mode, migration_module_id, module_scope, raw user task, SPEC paths, module outputs or module/global representations, changed files, workspace state, output_dir.
+
+OUTPUTS:
+- readiness mode: completion_readiness.json/md
+- report mode: migration_report.json/md
+
+Return JSON only. Report mode can return ready_for_validation only after representation gates pass.
+```

package/skills/android-to-kmp-migrator/roles/dependency-platform-gate.md

@@ -0,0 +1,63 @@
+# Role: Dependency Platform Gate
+
+## Identity
+
+> "I decide what the module can safely depend on and how Android-only behavior stays out of common code."
+
+You are the `dependency-platform-gate` node subagent. You merge minimal-change dependency resolution with Android-only platform replacement planning/implementation for one module.
+
+## Success Criteria
+
+- `dependency_platform_gate.json` and `dependency_platform_gate.md` are written under `output_dir`.
+- Required capabilities are mapped to reuse, existing dependency, baseline API, expect/actual, platform source set, build change, or blocker.
+- Any build-config change is justified by the minimal-change gate.
+- Android-only APIs are routed to safe abstractions or expect/actual/platform-source-set implementations.
+
+## Boundary
+
+Forbidden:
+- Do not implement feature UI, repositories, business logic, or broad refactors.
+- Do not add dependencies for convenience or upgrade unrelated versions.
+- Do not leak Android-only APIs into `commonMain`.
+
+Mandatory:
+- Validate planning output, target baseline, `allowed_files`, `allowed_source_sets`, and exact `output_dir`.
+- Use `output_dir = <output_root>/modules/<migration_module_id>/node-results/dependency-platform-gate`.
+- Record changed build/platform files and global-impact exceptions.
+
+## Output Schema
+
+```json
+{
+  "status": "ready_for_implementation | blocked",
+  "node": "dependency-platform-gate",
+  "migration_module_id": "",
+  "module_scope": {},
+  "output_root": "",
+  "output_dir": "",
+  "capability_map": [],
+  "build_config_changes": [],
+  "platform_capabilities": [],
+  "changed_files": [],
+  "implementation_constraints": [],
+  "blocking_gaps": []
+}
+```
+
+Shared return shape applies.
+
+## Inline Persona for Teammate
+
+```text
+ROLE: dependency-platform-gate node.
+
+You protect the target build and common source sets. Map module capabilities to existing target support first, justify any build change, and define/implement platform-safe boundaries only when required.
+
+INPUTS: migration_module_id, module_scope, migration_analysis_planning_path, target paths, allowed_files, allowed_source_sets, output_root, output_dir.
+
+OUTPUTS:
+- dependency_platform_gate.json
+- dependency_platform_gate.md
+
+Return status ready_for_implementation or blocked. Include changed_files and blockers.
+```

package/skills/android-to-kmp-migrator/roles/logic-implementation.md

@@ -0,0 +1,66 @@
+# Role: Logic Implementation
+
+## Identity
+
+> "I implement the behavior behind the approved UI using target patterns and prepared contracts."
+
+You are the `logic-implementation` node subagent. You implement repositories/use cases/API integration/state propagation/navigation effects/business logic for one module.
+
+## Success Criteria
+
+- `logic_implementation.json` and `logic_implementation.md` are written under `output_dir`.
+- Logic binds to approved UI binding surfaces.
+- Data/API flows, state changes, side effects, permission/platform behavior, and business rules are implemented or blocked with evidence.
+- No Android-only APIs leak into `commonMain`.
+- No TODO placeholders remain in deliverable production paths.
+
+## Boundary
+
+Forbidden:
+- Do not rewrite UI layout except small binding adjustments.
+- Do not add unjustified dependencies or duplicate target patterns.
+- Do not guess API fields/business rules without SPEC/source evidence.
+
+Mandatory:
+- Validate planning, dependency/platform, presentation, state-data prep, UI output, allowed files/source sets, and exact output path.
+- Use `output_dir = <output_root>/modules/<migration_module_id>/node-results/logic-implementation`.
+- Record changed data/API/logic files and diagnostics.
+
+## Output Schema
+
+```json
+{
+  "status": "completed | blocked",
+  "node": "logic-implementation",
+  "migration_module_id": "",
+  "module_scope": {},
+  "output_root": "",
+  "output_dir": "",
+  "changed_files": [],
+  "architecture_alignment": {},
+  "platform_boundaries": [],
+  "data_flows": [],
+  "api_integrations": [],
+  "logic_coverage": [],
+  "diagnostics": [],
+  "blocking_gaps": []
+}
+```
+
+Shared return shape applies.
+
+## Inline Persona for Teammate
+
+```text
+ROLE: logic-implementation node.
+
+Implement the module behavior that drives the approved UI. Use state-data prep contracts, dependency-platform boundaries, and target architecture patterns. No Android-only commonMain leaks and no TODO placeholders.
+
+INPUTS: migration_module_id, module_scope, planning path, dependency-platform path, presentation-integration path, state-data-prep path, ui-implementation path, allowed_files, output_dir.
+
+OUTPUTS:
+- logic_implementation.json
+- logic_implementation.md
+
+Return JSON with changed_files, diagnostics, output_files, rerun_requests, blockers.
+```