@code-migration/wow-migrator 0.1.3 → 0.1.4

package/skills/migration-task-adapter/roles/task-route-orchestrator.md

@@ -0,0 +1,103 @@
+# Role: Task Route Orchestrator
+
+## Identity
+
+> "I classify the task, then turn the route into downstream dispatch contracts and record what happened."
+
+You are the `task-route-orchestrator` node subagent. The controller dispatches you with `mode: route | orchestrate`.
+
+| Mode | When | Output |
+|---|---|---|
+| `route` | First after output root lock | `task_route.json` — classification, paths, downstream sequence |
+| `orchestrate` | After route and workspace init | `workflow_orchestration.json` — dispatch contracts, observed downstream outputs |
+
+You do not run analyst, migrator, validator, analysis, migration, validation, or final reporting.
+
+## Success Criteria — mode `route`
+
+- `task_route.json` and `task_route.md` under `output_dir/route/`.
+- Stable `task_id`, route, focus, required paths, missing inputs, downstream workflow sequence.
+- Only-understand tasks map to `ui`, `logic`, `architecture`, or `overview`.
+- Migration tasks state whether analyst SPEC is fresh or analyst must run first.
+- Validation handoff tasks state migration report/SPEC requirements.
+
+## Success Criteria — mode `orchestrate`
+
+- `workflow_orchestration.json` and `workflow_orchestration.md` under `output_dir/orchestrate/`.
+- Exact downstream dispatch contracts, expected output roots/artifacts, observed outputs, rerun/blocker routing.
+- Validator dispatch only when migration report evidence is fresh.
+- Downstream artifacts mirrored in `intermediate_asset_record_updates`.
+
+## Route Values
+
+- `only_understand_ui` | `only_understand_logic` | `only_understand_architecture` | `only_understand_overview`
+- `migration` | `validation_handoff` | `unknown` (returns `blocked`)
+
+## Boundary
+
+**Forbidden**:
+
+- Do not analyze Android source, migrate code, run tests/builds, or fix code.
+- `route` mode must not write orchestration or workspace artifacts.
+- `orchestrate` mode must not reclassify the route or issue final adapter status.
+- Do not invent missing downstream evidence.
+
+**Mandatory**:
+
+- Validate inputs; return `blocked` with `blocking_gaps` when required evidence is missing.
+- Write mode-specific artifacts under `output_dir`; verify non-empty before reporting status.
+
+## Output Schema — mode `route`
+
+```json
+{
+  "status": "routed | blocked",
+  "node": "task-route-orchestrator",
+  "mode": "route",
+  "task_id": "",
+  "route": "",
+  "task_kind": "only_understand | migration | validation_handoff | unknown",
+  "understand_focus": "ui | logic | architecture | overview | mixed | none",
+  "source_project_path": "",
+  "target_project_path": "",
+  "downstream_workflow_sequence": [],
+  "blocking_gaps": []
+}
+```
+
+## Output Schema — mode `orchestrate`
+
+```json
+{
+  "status": "completed | needs_rerun | blocked",
+  "node": "task-route-orchestrator",
+  "mode": "orchestrate",
+  "task_id": "",
+  "route": "",
+  "downstream_sequence": [],
+  "stage_inspection_requests": [],
+  "intermediate_asset_record_updates": [],
+  "rerun_requests": [],
+  "blocking_gaps": []
+}
+```
+
+Shared return shape applies.
+
+## Output Files
+
+- `route/task_route.json`, `route/task_route.md`
+- `orchestrate/workflow_orchestration.json`, `orchestrate/workflow_orchestration.md`
+
+## Inline Persona
+
+```text
+ROLE: task-route-orchestrator (mode: route | orchestrate).
+
+route: normalize task, classify route and focus, declare downstream sequence and blockers.
+orchestrate: build analyst/migrator/validator dispatch contracts; record expected and observed outputs.
+
+INPUTS: mode, raw_user_task, paths, task_route_path (orchestrate), adapter_workspace_state_path (orchestrate), output_dir.
+
+Do not analyze source, migrate, validate, or write final report.
+```

package/skills/migration-task-adapter/workflow.md

@@ -1,155 +1,86 @@
-# Workflow: input task -> route decision -> downstream workflow -> inspected task report
+# Workflow: task → route → downstream workflow → adapter report
 
-This adapter is a small orchestration swarm in front of the Android analyst, KMP migrator, and KMP validator. Its output is not the migration itself; its output is a verified task route, a downstream workflow record, stage inspection records, intermediate asset records, and a final task report.
+The adapter classifies intent, records contracts and stage gates, and emits a verified report. It does not perform analysis, migration, or validation itself.
 
 ## Overview
 
 ```mermaid
 graph TD
-  L0[Leader pre-flight] --> ROOT[Lock output_root<br/>run_manifest.json]
-  ROOT --> TUR[task-understanding-router]
-  TUR --> G0{Route classified?}
-  G0 -- No --> STOP[blocked: ask for missing task/path/scope]
-  G0 -- Yes --> WSI0[workspace-state-discipline-inspector<br/>init ledgers]
-  WSI0 --> ST1[stage-inspection: route_decision]
-  ST1 --> WO[workflow-orchestrator<br/>dispatch contract]
-  WO --> G1{Route target}
-  G1 -- only_understand_ui --> APA_UI[android-project-analyst<br/>focus: UI/presentation-resource]
-  G1 -- only_understand_logic --> APA_LOGIC[android-project-analyst<br/>focus: behavior-logic]
-  G1 -- only_understand_architecture --> APA_ARCH[android-project-analyst<br/>focus: project-architecture]
-  G1 -- only_understand_overview --> APA_OV[android-project-analyst<br/>focus: overview/global SPEC]
-  G1 -- migration --> MIG_PREP{Analyst SPEC fresh?}
-  MIG_PREP -- No --> APA_MIG[android-project-analyst<br/>mode: migration]
-  MIG_PREP -- Yes --> ATM[android-to-kmp-migrator]
-  APA_MIG --> WSI_A[workspace-state-discipline-inspector]
-  WSI_A --> ATM
-  ATM --> KV{kmp-test-validator needed?}
-  KV -- ready_for_validation --> KTV[kmp-test-validator]
-  KV -- blocked --> WSI_M[workspace-state-discipline-inspector]
-  KTV --> WSI_V[workspace-state-discipline-inspector]
-  APA_UI --> WSI_D[workspace-state-discipline-inspector]
-  APA_LOGIC --> WSI_D
-  APA_ARCH --> WSI_D
-  APA_OV --> WSI_D
-  WSI_M --> TR[task-reporter]
-  WSI_V --> TR
-  WSI_D --> TR
-  TR --> WSI_FINAL[workspace-state-discipline-inspector<br/>final check]
+  L0[Pre-flight] --> ROOT[run_manifest.json]
+  ROOT --> TRO_R[task-route-orchestrator route]
+  TRO_R --> G0{Route ok?}
+  G0 -- No --> STOP[blocked]
+  G0 -- Yes --> WS0[adapter-workspace-state init]
+  WS0 --> TRO_O[task-route-orchestrator orchestrate]
+  TRO_O --> G1{Route}
+  G1 --> APA[android-project-analyst variants]
+  G1 --> MIG[migration: analyst then migrator]
+  MIG --> KV[kmp-test-validator optional]
+  APA --> WS1[adapter-workspace-state]
+  KV --> WS1
+  MIG --> WS1
+  WS1 --> AR[adapter-report]
+  AR --> WS2[adapter-workspace-state post_report]
 ```
 
-## Strict Output Paths
-
-The Leader must lock one adapter `output_root` before dispatch:
+## Output Paths
 
 ```text
 output_root = <output_dir or ~/.a2c_agents/task-adapter>/migration-task-adapter
-task_dir = <output_root>/task
 workspace_state_dir = <output_root>/workspace-state
-orchestration_dir = <output_root>/orchestration
+route_orchestration_dir = <output_root>/route-orchestration
 stage_inspection_dir = <output_root>/stage-inspections
 intermediate_asset_dir = <output_root>/intermediate-assets
 report_dir = <output_root>/report
 ```
 
-Required durable artifacts:
-
-| Schedule point | Required artifacts |
-|---|---|
-| Output root lock | `<output_root>/run_manifest.json` - task id, raw task, paths/scope, output roots, dependency status, schedule version |
-| Task understanding | `<task_dir>/task_understanding_router.json`, `<task_dir>/task_understanding_router.md` - route decision, focus, evidence, required/missing inputs, downstream sequence |
-| Workspace discipline | `<workspace_state_dir>/workspace_state_discipline.json`, `<workspace_state_dir>/workspace_state_discipline.md` - artifact inventory, path/freshness checks, rerun/blocker history, next actions |
-| Stage inspection | `<stage_inspection_dir>/<stage_id>/stage_inspection.json`, `<stage_inspection_dir>/<stage_id>/stage_inspection.md` - checked inputs/outputs, path/freshness/asset coverage, rerun/blocker routing |
-| Intermediate assets | `<intermediate_asset_dir>/intermediate_asset_records.json`, `<intermediate_asset_dir>/intermediate_asset_records.md` - stable records for every adapter/downstream artifact consumed later |
-| Orchestration | `<orchestration_dir>/workflow_orchestration.json`, `<orchestration_dir>/workflow_orchestration.md` - downstream contracts, expected/observed outputs, stage requests, rerun/blocker routing |
-| Final report | `<report_dir>/task_adapter_report.json`, `<report_dir>/task_adapter_report.md` - final route/status/readiness, verified outputs, stage/asset summaries, blockers |
-
-No adapter role may write inside downstream workflow output roots except by invoking the downstream controller with its own declared `output_dir`. Downstream artifacts are referenced by path in intermediate asset records. The validator output root must be the downstream validator's parallel `validation` location, not the migration output root.
+Validator artifacts are recorded under the validator's parallel `validation` root, not the migration root.
 
 ## Route Matrix
 
-| Route | Required inputs | Downstream workflow | Required downstream evidence |
+| Route | Required inputs | Downstream | Key evidence |
 |---|---|---|---|
-| `only_understand_ui` | Android source path, UI/screen/feature scope when available | `android-project-analyst` in exploration mode with `analysis_focus: ui` | `presentation_resource.*`, module/global representation, `SPEC/design.md`, `SPEC/verification.md` |
-| `only_understand_logic` | Android source path, logic/feature/use-case scope when available | `android-project-analyst` in exploration mode with `analysis_focus: logic` | verified Stage A outputs plus `behavior_logic.*`, module/global representation, `SPEC/verification.md` |
-| `only_understand_architecture` | Android source path, module/project scope | `android-project-analyst` in exploration mode with `analysis_focus: architecture` | `project_architecture.*`, module/global representation, `SPEC/design.md`, `SPEC/verification.md` |
-| `only_understand_overview` | Android source path, overview/full or feature scope | `android-project-analyst` in exploration mode | module inventory, all node outputs in scope, module/global representation, SPEC |
-| `migration` | Android source or fresh analyst SPEC, KMP target path, migration scope | `android-project-analyst` if needed, then `android-to-kmp-migrator`, then optional `kmp-test-validator` | analyst SPEC, migration module inventory, module/global migration representation, `migration_report.*`, validation report when run |
-| `validation_handoff` | KMP target path, Android source/SPEC, migration report | `kmp-test-validator` | validation intake, plan/build gate, test runner/remediation as applicable, validation report |
-
-## Detailed Steps
-
-### Step 0 - Pre-flight
-
-- **Executor**: Leader.
-- **Input**: [dependencies.yaml](dependencies.yaml), user task, optional source/target/output paths.
-- **Action**: verify optional tools and lock `output_root`. Write `run_manifest.json` with task id, raw task summary, timestamp, requested scope, source/target paths, allowed roots, downstream workflow candidates, dependency status, and schedule version.
-- **Gate**: `run_manifest.json` exists and is non-empty before any role runs.
-
-### Step 1 - Task Understanding And Router
-
-- **Executor**: `task-understanding-router`.
-- **Input**: raw user task, paths, current workspace hints, optional existing analyst/migrator/validator artifact paths.
-- **Action**: normalize request, classify route, select focus, identify missing evidence, create downstream route contract.
-- **Output**: `task_understanding_router.json`, `task_understanding_router.md`. Artifacts must contain normalized task summary, route, task kind, focus, source/target/scope fields, existing artifact evidence, required/missing inputs, downstream workflow sequence, stage inspection requirements, intermediate asset requirements, and blockers.
-- **Gate**: route must be one of the route matrix values or `blocked` with missing inputs. No downstream workflow starts on `unknown`.
-
-### Step 2 - Workspace State Discipline Init
-
-- **Executor**: `workspace-state-discipline-inspector`.
-- **Action**: initialize or refresh workspace discipline ledger, stage inspection index, intermediate asset records, rerun/blocker history.
-- **Output**: `workspace_state_discipline.json`, `.md`, first `stage_inspection.json`, `.md`, and `intermediate_asset_records.json`, `.md`. Artifacts must record adapter artifact inventory, path compliance, freshness, consumed assets, rerun history, blockers, and next safe action.
-- **Gate**: task understanding artifacts and run manifest are recorded as intermediate assets before orchestration.
-
-### Step 3 - Workflow Orchestration
-
-- **Executor**: `workflow-orchestrator`.
-- **Action**:
-  - Build exact downstream dispatch contracts from the route decision.
-  - Record downstream output roots and expected artifacts.
-  - After downstream workflow completion, record observed outputs, statuses, blockers, and required reruns.
-  - Route stale or missing downstream outputs back to the owning workflow.
-- **Output**: `workflow_orchestration.json`, `workflow_orchestration.md`. Artifacts must contain downstream dispatch contracts, expected output roots/artifacts, observed downstream outputs, stage inspection requests, intermediate asset updates, rerun requests, and blockers.
-- **Gate**: orchestration cannot claim `completed` until downstream workflow status and required artifact paths are recorded or blockers are explicit.
-
-### Step 4 - Stage Inspections
-
-- **Executor**: `workspace-state-discipline-inspector`.
-- **Required inspection points**:
-  - `route_decision`
-  - `pre_downstream_dispatch`
-  - `post_analyst`
-  - `post_migrator`
-  - `post_validator`
-  - `pre_report`
-  - `post_report`
-- **Action**: for each applicable point, verify current stage inputs, outputs, freshness, path compliance, intermediate asset coverage, and rerun/blocker routing.
-- **Output**: one `stage_inspection.json` and `.md` per stage id plus refreshed workspace discipline and asset ledgers. Stage inspection artifacts must list checked inputs/outputs, path compliance, freshness checks, intermediate asset coverage, downstream contract checks, rerun requests, blockers, and next allowed stage.
-- **Gate**: final report cannot run unless `pre_report` stage inspection passes or explicitly reports `blocked`.
-
-### Step 5 - Intermediate Asset Records
-
-- **Executor**: `workspace-state-discipline-inspector` with updates from `workflow-orchestrator`.
-- **Action**: record every durable adapter and downstream artifact consumed across stages.
-- **Required fields**:
-  - `asset_id`
-  - `asset_type`
-  - `producer`
-  - `path`
-  - `status`
-  - `created_or_observed_at`
-  - `freshness_basis`
-  - `consumers`
-  - `source_evidence`
-  - `blocking_gaps`
-- **Gate**: every `output_files[]` item returned by an adapter role or downstream workflow must appear in `intermediate_asset_records.*` before a downstream consumer uses it.
-
-### Step 6 - Task Report
-
-- **Executor**: `task-reporter`.
-- **Input**: run manifest, task understanding, workflow orchestration, latest workspace discipline, stage inspections, intermediate asset records, downstream reports.
-- **Action**: synthesize a final machine-routable task report. Do not run new analysis, migration, validation, tests, or fixes.
-- **Output**: `task_adapter_report.json`, `task_adapter_report.md`. Artifacts must summarize final status, route, focus, source/target paths, downstream workflow results, stage inspections, intermediate assets, verified outputs, readiness, rerun requests, blockers, and report path.
-- **Gate**: report status is `completed`, `ready_for_validation`, `failed`, or `blocked` only from verified evidence.
+| `only_understand_ui` | Android source, UI scope | analyst exploration, focus `ui` | `presentation_resource.*`, SPEC |
+| `only_understand_logic` | Android source, logic scope | analyst exploration, focus `logic` | Stage A + `behavior_logic.*`, SPEC |
+| `only_understand_architecture` | Android source | analyst exploration, focus `architecture` | `project_architecture.*`, SPEC |
+| `only_understand_overview` | Android source | analyst exploration | module inventory, representations, SPEC |
+| `migration` | source or SPEC, KMP target | analyst → migrator → validator optional | SPEC, `migration_report.*` |
+| `validation_handoff` | KMP target, migration report | validator | `kmp_validation_report.*` |
+
+## Steps
+
+### Step 0 — Pre-flight
+
+Lock `output_root`; write `run_manifest.json` with task id, paths, scope, dependency preflight.
+
+### Step 1 — Route
+
+- **Executor**: `task-route-orchestrator` mode `route`
+- **Output**: `route-orchestration/route/task_route.*`
+- **Gate**: route is known or `blocked` with `blocking_gaps`
+
+### Step 2 — Workspace init
+
+- **Executor**: `adapter-workspace-state`
+- **Output**: `adapter_workspace_state.*`, first `stage_inspection.*`, `intermediate_asset_records.*`
+- **Gate**: route artifacts recorded as assets before orchestrate
+
+### Step 3 — Orchestrate
+
+- **Executor**: `task-route-orchestrator` mode `orchestrate`
+- **Output**: `route-orchestration/orchestrate/workflow_orchestration.*`
+- **Gate**: downstream contracts and observed outputs recorded or blockers explicit
+
+### Step 4 — Stage gates
+
+- **Executor**: `adapter-workspace-state`
+- **Stages**: `route_decision`, `pre_downstream_dispatch`, `post_analyst`, `post_migrator`, `post_validator`, `pre_report`, `post_report` (as applicable)
+- **Gate**: `pre_report` must pass before adapter-report
+
+### Step 5 — Adapter report
+
+- **Executor**: `adapter-report`
+- **Output**: `report/adapter_report.*`
 
 ## Final Report Shape
 
@@ -158,16 +89,14 @@ No adapter role may write inside downstream workflow output roots except by invo
   "status": "completed | ready_for_validation | failed | blocked",
   "task_id": "",
   "route": "",
-  "understand_focus": "ui | logic | architecture | overview | mixed | none",
+  "understand_focus": "",
   "source_project_path": "",
   "target_project_path": "",
-  "output_root": "",
   "downstream_workflows": [],
   "stage_inspection_summary": [],
-  "intermediate_asset_summary": [],
-  "downstream_outputs": [],
-  "readiness": "ready | ready_with_assumptions | ready_for_validation | blocked",
-  "rerun_requests": [],
+  "intermediate_asset_summary": {},
+  "verified_outputs": [],
+  "readiness": "",
   "blocking_gaps": [],
   "report_path": ""
 }
@@ -175,9 +104,8 @@ No adapter role may write inside downstream workflow output roots except by invo
 
 ## Acceptance Criteria
 
-- Task route is classified before any downstream workflow is invoked.
-- Only-understand UI/logic/architecture/overview routes go through `android-project-analyst`; migration routes go through analyst completion before migrator when SPEC is missing or stale.
-- Stage inspection records exist for every applicable route boundary and downstream workflow boundary.
-- Intermediate asset records include every durable adapter and downstream artifact consumed by a later stage.
-- Latest workspace discipline inspection has no stale required inputs before `task-reporter` runs.
-- Final task report cites paths to verified downstream artifacts and lists unresolved gaps instead of filling them in.
+- Route classified before downstream invoke.
+- Stage inspections at each applicable boundary.
+- Every consumed artifact in `intermediate_asset_records.*`.
+- `adapter-report` runs only after fresh `pre_report` gate.
+- Final report cites verified paths; gaps listed, not filled in.

package/skills/android-project-analyst/MIGRATION.md

@@ -1,67 +0,0 @@
-# Conversion Note: `android-project-analyst` → clustered Swarm Skill
-
-This file records the role-shape history for the `android-project-analyst` skill folder. It is not an active dispatch contract; active node contracts live in [SKILL.md](SKILL.md), [workflow.md](workflow.md), and the files under [roles](roles/).
-
-## Phase 1 — Controller support skill to Swarm Skill
-
-The skill was first converted from a single controller-support skill (a flat `SKILL.md` registry plus seven sibling node-spec files) into a compliant **Swarm Skill** using `swarmskill-creator` convert mode.
-
-### Source structure before Phase 1
-
-- `SKILL.md` — controller registry describing convert mode, node contracts, dispatch order, and the SPEC output contract.
-- Seven flat node specs at the skill root: `ui-understand.md`, `architecture-pattern.md`, `android-ecosystem.md`, `api-list.md`, `resource-understand.md`, `data-flow.md`, `logic-understand.md`. Each contained Role / Inputs / Mandatory Input Validation & Output Storage / Specific Task / Required Outputs / Return Format / Self-Check.
-
-### What Phase 1 added
-
-The registry already separated controller from nodes, but it did not encode the team as a first-class artifact: there were no per-role anti-convergence mottos, no `Forbidden`/`Mandatory` boundary blocks the validator could check, no pasteable `Inline Persona` (so each dispatch re-derived the contract by hand), no Mermaid topology making the parallel-then-pipeline shape explicit, and no resource/behavioral guardrails (`max_parallel_teammates`, token/wall-clock budgets, degraded modes). The handoff gates between stages lived only in prose.
-
-The seven-role Swarm Skill preserved the source contracts while adding explicit topology, per-role boundaries, self-contained pasteable personas, budgets, and degraded modes.
-
-## Phase 2 — Seven roles to four clustered roles
-
-The second pass analyzed each role's function and duty, found repeated cataloging across adjacent personas, and reduced active dispatch from seven roles to four clustered personas. The full analysis is in [ROLE_CLUSTERING.md](ROLE_CLUSTERING.md).
-
-## Phase 3 — Add workspace-state ledger role
-
-The third pass adds `analysis-workspace-state`, following the ledger pattern used by `android-to-kmp-migrator` and `kmp-test-validator`. This role does not change the four clustered analysis personas. It tracks module/node artifact status, stale upstream inputs, rerun/blocker history, and next safe controller actions so global representations and SPEC files are not built from stale evidence.
-
-## Old-to-new role map
-
-| Old role(s) | New clustered role | Reason |
-|---|---|---|
-| `ui-understand` + `resource-understand` | `presentation-resource` | Resource usage and migration risk are meaningful only when tied to screens, components, navigation, and UI technology. |
-| `architecture-pattern` + `android-ecosystem` | `project-architecture` | Module topology, architecture style, dependency ecosystem, DI scopes, generated tooling, and Android-only constraints form one project-structure reality check. |
-| `api-list` + `data-flow` | `data-contract-flow` | APIs, local data sources, models, repositories, streams, cache/error behavior, transformations, and write-back paths are one data path. |
-| `logic-understand` | `behavior-logic` | Behavior remains last because user/lifecycle/control-flow analysis requires verified upstream presentation, project, and data evidence. |
-| none (new ledger role) | `analysis-workspace-state` | Workspace-state tracking is cross-cutting and read-only; it prevents stale module/node artifacts from being consumed downstream. |
-
-## Current decomposition
-
-- **Pattern: Workspace-state + Mixed B + C.** `analysis-workspace-state` is initialized after output-root lock and refreshed after each major artifact group. Stage A (`presentation-resource`, `project-architecture`, `data-contract-flow`) is parallel decomposition (B) over clustered slices. Stage B (`behavior-logic`) is a gated specialization step (C) that consumes verified, non-stale upstream outputs and must not rebuild them.
-- **Boundary check: PASS.** Clustered roles remove the most common duplicate cataloging while preserving distinct ownership: workspace ledger vs. presentation/resource evidence vs. project architecture/ecosystem evidence vs. data contract/flow evidence vs. behavior/control evidence.
-
-## Current content port map
-
-| Contract content | Current location |
-|---|---|
-| Active role registry | `SKILL.md` frontmatter |
-| Staged dispatch order + verification | `workflow.md` |
-| Mandatory contract enforcement + agent-only rules | `bind.md` § Behavioral Constraints |
-| Node failure / rerun handling | `bind.md` § Failure Handling |
-| Function/duty analysis and old-to-new map | `ROLE_CLUSTERING.md` |
-| Per-role identity, boundary, schema, and teammate persona | `roles/<clustered-role>.md` |
-| SPEC output contract + MCP context | `SKILL.md` body |
-
-## Output Contract Refinement
-
-The active skill docs now distinguish output file names from output content responsibilities. `SKILL.md` and `workflow.md` define the full artifact schedule and content matrix, while each role file states the exact JSON/Markdown filenames and the evidence each artifact must contain.
-
-This refinement keeps role ownership explicit:
-
-- `analysis-workspace-state.*` records ledger state only.
-- `presentation_resource.*` records screens, checked UI trees, navigation, presentation modules, and resources.
-- `project_architecture.*` records build/module topology, architecture patterns, dependencies, platform services, and migration constraints.
-- `data_contract_flow.*` records APIs, models, data sources, mappings, streams, and end-to-end data flows.
-- `behavior_logic.*` records user actions, lifecycle behavior, state holders, rules, side effects, state machines, and upstream alignment.
-
-The Leader must reject artifacts that have the correct filename but contain another role's work or prose-only summaries without machine-routable evidence.

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

@@ -1,129 +0,0 @@
-# Conversion Note: `android-to-kmp-migrator` → Swarm Skill
-
-Converted from a single controller-support skill (a flat SKILL.md node registry plus 20 sibling node-spec files) into a compliant **Swarm Skill** using `swarmskill-creator` convert mode.
-
-## Source structure (before)
-
-- `SKILL.md` — node registry: node table, required dispatch order (13 controller steps), shared input contract, shared return shape, and shared rules.
-- 20 flat node specs at the skill root, each with Role / Inputs / Mandatory Input Validation & Output Storage / Specific Task / Do-not list / Required Outputs (JSON schema) / Shared Return Shape / Return Shape.
-
-## What was lost in the pre-swarm form
-
-The registry separated controller from nodes and even encoded the staged 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 20 dispatches re-derived its contract by hand), no Mermaid topology making the pipeline + parallel fan-outs + review→fix loops explicit, and no resource/behavioral guardrails (parallel cap, token/wall-clock budgets, `max_review_fix_cycles`, degraded modes). Stage gates and the single-project / dependency-gate invariants lived only in prose.
-
-## Decomposition
-
-- **Pattern: C (specialization pipeline) + embedded B (parallel fan-outs) + review→fix loops.**
-  - Serial analysis chain: `legacy-spec-delta-review` → `target-project-understand` → `migration-alignment`.
-  - Hard gate: `dependency-resolution` (minimal-change) before any implementation.
-  - Parallel prep (B): `theme-design-system-mapping`, `resource-migration`, `navigation-migration`, `platform-api-replacement`, `state-model-mapping`.
-  - Sequential implementation: `ui-mockup-implementation` before `dataflow-logic-implementation`.
-  - Review→fix loop after any file-changing node: `module-node-migration-review` ↔ `module-node-migration-fix`.
-  - Parallel verify (B): `source-set-placement-guard`, `api-contract-parity`, `ui-render-fidelity-check`, `incremental-build-check`.
-  - Completion + report: `prd-completion-check` → `migration-report` → `kmp-test-validator` handoff.
-  - Cross-cutting: `migration-workspace-state` progress ledger refreshed after every major stage, tracking per-module finish rate, plan-vs-code gaps, stale outputs, and rerun hooks.
-- **Disjointness check: PASS.** Each node owns a distinct slice (state ledger vs SPEC delta vs target understanding vs alignment vs dependency gate vs theme vs resource vs navigation vs platform vs state/model vs UI vs logic vs review vs fix vs source-set guard vs API parity vs render vs build vs completion vs report). `module-node-migration-review` and `-fix` are intentionally complementary (read-only judge vs scoped editor) and gated as a loop, not overlapping.
-
-## Content port map
-
-| Source node-spec content | Ported to |
-|---|---|
-| `## Role` first paragraph | role `## Identity` (rewritten as a 1-line motto + context) |
-| `## Specific Task` numbered steps | role `## Inline Persona for Teammate` HANDLER |
-| `## Mandatory Input Validation And Output Storage` | role `## Boundary > Mandatory` + Inline Persona CONTROL block |
-| `Do not:` lists + sibling routing | role `## Boundary > Forbidden` |
-| `## Required Outputs` JSON schema | role `## Output Schema` + Inline Persona OUTPUTS |
-| `## Return Shape` + shared return | role Inline Persona RETURN TO CONTROLLER + SKILL.md § Shared Return Shape |
-| Required dispatch order (13 steps) | `workflow.md` staged steps + Mermaid + gates |
-| Mandatory node contract enforcement + shared rules | `bind.md` § Behavioral Constraints + SKILL.md § Shared Rules |
-| Shared return status semantics + controller handling | SKILL.md § Shared Return Shape |
-| Optional Android Studio MCP context | SKILL.md § Optional Android Studio MCP Context + per-role Inline Persona MCP inputs |
-
-## Team-vs-single delta
-
-The conversion preserves every source contract while adding: explicit pipeline + parallel + loop topology with verifiable gates, per-role anti-overlap boundaries that name siblings, self-contained pasteable personas (no re-derivation per dispatch across 20 nodes), resource/token/wall-clock budgets plus a `max_review_fix_cycles` bound, failure-routing rules, and concrete degraded modes for large monorepos and missing tooling. The same-name controller subagent in `kmp-migration/agents/android-to-kmp-migrator.md` was later updated to enforce the module-first schedule and strict output roots.
-
-## Module-First Refactor (0.3)
-
-The second refactor added a module-first migration schedule and strict output paths. It initially kept the 20-role shape, then Phase 0.4 superseded that result with the reduced 10-role set recorded in `ROLE_REDUCTION.md`.
-
-### New schedule
-
-1. Lock `output_root = <output_dir or ~/.a2c_agents/migration>/android-to-kmp-migrator`.
-2. Write `<output_root>/run_manifest.json`.
-3. Write `<output_root>/module-index/migration_module_inventory.json` and `.md`.
-4. For each `migration_module_id`, write `<output_root>/modules/<migration_module_id>/module_brief.json`.
-5. Run module-scoped node outputs under `<output_root>/modules/<migration_module_id>/node-results/<node_id>/`.
-6. Run review/fix loops per module and owning node slice.
-7. Write `<output_root>/modules/<migration_module_id>/representation/module_migration_representation.json` and `.md`.
-8. Combine all module representations into `<output_root>/global/global_migration_representation.json` and `.md`.
-9. Write final `<output_root>/report/migration_report.json` and `.md`.
-10. Hand the final report to `kmp-test-validator`.
-
-### Contract changes
-
-- Every module-scoped node now receives `migration_module_id`, `module_scope`, exact `output_dir`, and allowed target files/source sets when it may change files.
-- Review mode remains read-only. Fix mode consumes explicit findings, `allowed_files`, `owning_node`, and `migration_module_id`; re-review is a fresh read-only invocation.
-- Verification runs per module first. Global aggregation consumes module representations rather than loose node output lists.
-- `completion-report` report mode may return `ready_for_validation` only when every scheduled module representation and the global representation exists and is non-empty.
-
-### Path compatibility
-
-The old default `~/.a2c_agents/migration/` is now only the base directory. The effective output root is always:
-
-```text
-<output_dir or ~/.a2c_agents/migration>/android-to-kmp-migrator
-```
-
-No controller or node should write durable migration artifacts directly under the base directory.
-
-## Role Reduction Refactor (0.4)
-
-The third refactor reduces active migrator role definitions from 20 to 10. The full analysis lives in [ROLE_REDUCTION.md](ROLE_REDUCTION.md).
-
-### Old-to-new map
-
-| Old role(s) | Active role |
-|---|---|
-| `migration-workspace-state` | `migration-workspace-state` |
-| `legacy-spec-delta-review`, `target-project-understand`, `migration-alignment` | `migration-analysis-planning` |
-| `dependency-resolution`, `platform-api-replacement` | `dependency-platform-gate` |
-| `theme-design-system-mapping`, `resource-migration`, `navigation-migration` | `presentation-integration` |
-| `state-model-mapping` plus API/data preparation expectations | `state-data-prep` |
-| `ui-mockup-implementation` | `ui-implementation` |
-| `dataflow-logic-implementation` | `logic-implementation` |
-| `module-node-migration-review`, `module-node-migration-fix` | `module-node-review-fix` with `mode: review | fix` |
-| `source-set-placement-guard`, `api-contract-parity`, `ui-render-fidelity-check`, `incremental-build-check` | `migration-verification` with stable `check_ids` |
-| `prd-completion-check`, `migration-report` | `completion-report` with `mode: readiness | report` |
-
-### Safety preserved by modes
-
-- Review and fix are in one role file but must run as separate invocations.
-- Verification is consolidated but still read-only for source changes and uses explicit check IDs.
-- Completion and report are consolidated but report mode is blocked until readiness mode and module/global representation gates pass.
-- Build-config changes remain owned only by `dependency-platform-gate`.
-
-## Workspace Progress Ledger Refinement
-
-The `migration-workspace-state` role was refined from basic node/stale-output tracking into the controller's progress ledger. It now records per-module migration status, current stage, planned/completed work units, `finish_rate`, changed-file ownership, plan-vs-code gaps, stale outputs, rerun hooks, blocker history, and next safe action.
-
-This preserves the role boundary: `migration-workspace-state` still does not analyze source behavior, implement code, fix code, or issue readiness verdicts. It only compares controller-visible plan artifacts, implementation outputs, review outputs, verification outputs, changed-file ownership, and freshness evidence so the Leader can rerun the correct owner before downstream consumption.
-
-## Output Contract Refinement
-
-The active skill docs now distinguish output filenames from output content responsibilities. `SKILL.md` and `workflow.md` define the full artifact schedule and content matrix, while each role file states the exact JSON/Markdown filenames and the evidence each artifact must contain.
-
-This keeps the reduced-role boundaries explicit:
-
-- `migration_workspace_state.*` records progress ledger state only.
-- `migration_analysis_planning.*` records SPEC/raw-source deltas, target evidence, source-to-target mapping, and ordered tasks.
-- `dependency_platform_gate.*` records dependency, build, platform, and source-set decisions.
-- `presentation_integration.*` records theme/token/resource/media/navigation prep and UI handoff.
-- `state_data_prep.*` records state/model/API contract prep and logic handoff.
-- `ui_implementation.*` records visible UI implementation evidence and binding surfaces.
-- `logic_implementation.*` records behavior/data/API/state implementation evidence.
-- `module_node_review.*` and `module_node_fix.*` record review/fix evidence by mode.
-- `migration_verification.*` records stable check results and routed failures.
-- `completion_readiness.*` and `migration_report.*` record readiness and validation handoff evidence.
-
-The Leader must reject artifacts that have the correct filename but contain another role's work or prose-only summaries without machine-routable evidence.

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

@@ -1,68 +0,0 @@
-# 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.
-
-## Output Files And Contents
-
-- `dependency_platform_gate.json`: machine-routable gate artifact containing capability map, minimal-change dependency decisions, build-config changes, platform capabilities, Android-only API replacement strategy, expect/actual/source-set placement, changed files, implementation constraints, and blockers.
-- `dependency_platform_gate.md`: agent-readable gate handoff containing dependency/platform decisions, build-change rationale, source-set/platform-boundary notes, changed-file summary, downstream constraints, and blockers.
-
-## 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 (machine gate: capabilities, dependency/build decisions, platform boundaries, changed files, constraints)
-- dependency_platform_gate.md (agent handoff: rationale, source-set/platform notes, downstream constraints, blockers)
-
-Return status ready_for_implementation or blocked. Include changed_files and blockers.
-```