@code-migration/wow-migrator 0.1.1 → 0.1.3

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

@@ -1,118 +1,139 @@
 ---
 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
-    kind: ai_agent
-    purpose: Run the resolved build and Compose preview/renderability gate before behavioral tests; classify and route failures by owner.
-    skills: []
-    tools: [rg]
-  - id: test-case-decomposition
+  - id: validation-plan-gate
     kind: ai_agent
-    purpose: Decompose user tests, SPEC acceptance, and migration validation inputs into atomic Android-anchored cases. No fabricated expectations.
+    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-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. **Output root + workspace state** — lock validation output root parallel to migration, then 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 | 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
 
-| 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) |
+| 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 |
+
+## Strict Output Schedule
+
+Validation artifacts must be written parallel to migration artifacts, under a `validation` base location. If the migration run uses a default base like `~/.a2c_agents/migration`, the validator uses the sibling base `~/.a2c_agents/validation`. If a `migration_output_root` is provided, derive the validation base by replacing the `migration` path segment with `validation` when possible; otherwise use `<output_dir or ~/.a2c_agents/validation>`.
+
+```text
+output_root = <output_dir or ~/.a2c_agents/validation>/kmp-test-validator
+workspace_state_dir = <output_root>/workspace-state
+intake_dir = <output_root>/intake-fidelity
+plan_gate_dir = <output_root>/plan-gate
+test_runner_dir = <output_root>/test-runner
+remediation_dir = <output_root>/remediation
+report_dir = <output_root>/report
+logs_dir = <output_root>/logs
+```
 
-> 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.
+Required artifacts:
 
-## Files
+- `<output_root>/run_manifest.json`
+- `<workspace_state_dir>/validation_workspace_state.json`
+- `<workspace_state_dir>/validation_workspace_state.md`
+- `<intake_dir>/validation_intake_fidelity.json`
+- `<intake_dir>/validation_intake_fidelity.md`
+- `<plan_gate_dir>/validation_plan_gate.json`
+- `<plan_gate_dir>/validation_plan_gate.md`
+- `<logs_dir>/plan-gate/*` when build/preview commands run
+- `<test_runner_dir>/validation_test_runner.json`
+- `<test_runner_dir>/validation_test_runner.md`
+- `<logs_dir>/test-runner/*` when tests run
+- `<remediation_dir>/<cycle_id>/validation_remediation.json` and `.md` when fixes run
+- `<report_dir>/kmp_validation_report.json`
+- `<report_dir>/kmp_validation_report.md`
+
+No validator artifact may be written inside the migration output root. Migration artifacts are read-only inputs referenced by path.
+
+## Output Artifact Content Matrix
 
-| File | What it contains | When to read |
+The controller verifies both artifact names and role-aligned content before downstream stages consume any file.
+
+| Stage / owner | Output file(s) | Required content |
 |---|---|---|
-| [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 |
+| Output root lock / Leader | `run_manifest.json` | Validation scope, KMP target path, Android source/SPEC paths, migration report path, migration output root, validation output root, allowed roots, dependency-preflight status, timestamp. |
+| Workspace ledger / `validation-workspace-state` | `validation_workspace_state.json`, `validation_workspace_state.md` | Validator node status, output files, changed-file ownership, stale upstream inputs, rerun history, blockers, and next safe action. |
+| Intake/fidelity / `validation-intake-fidelity` | `validation_intake_fidelity.json`, `validation_intake_fidelity.md` | Migration trigger evidence, normalized validation brief, KMP evidence, Android/SPEC-vs-KMP fidelity gaps across UI/logic/data/control flow, test-trust blockers, rerun requests, blockers. |
+| Plan/build gate / `validation-plan-gate` | `validation_plan_gate.json`, `validation_plan_gate.md`, plan-gate logs | Target structure, source sets, test frameworks, trusted command resolution, command sources, build/preview/renderability gate results, log paths, routed failures, blockers. |
+| Test runner / `validation-test-runner` | `validation_test_runner.json`, `validation_test_runner.md`, test logs, optional changed test files | Android/SPEC-anchored test cases, expected vs actual results, commands, log paths, created/reused tests, failure routing, skipped/blocked reasons. |
+| Remediation / `validation-remediation` | `validation_remediation.json`, `validation_remediation.md`, changed target files | Confirmed target KMP failures, Android/SPEC evidence for fixes, fixed/unfixed failures, changed files, diagnostics, required reruns, blockers. |
+| Final verdict / `validation-report` | `kmp_validation_report.json`, `kmp_validation_report.md` | Final `passed | failed | blocked` verdict from verified evidence, fidelity summary, build/preview summary, test statistics, remediation summary, changed files, remaining failures, blockers, report path. |
 
-## Shared Return Contract
+JSON artifacts are the machine-routable source of truth. Markdown artifacts are agent-readable handoffs that preserve exact paths, commands/logs, changed-file ownership, rerun context, blockers, and downstream routing. Node Markdown must not be a prose-only completion summary.
 
-Every node returns a compact payload with, in addition to node-specific fields:
+## Shared Return Contract
 
 ```json
 {
   "status": "completed | passed | failed | needs_rerun | blocked",
   "node": "node-name",
+  "output_dir": "<exact validator node output dir under output_root>",
   "output_files": [],
   "changed_files": [],
   "stale_upstream_inputs": [],
@@ -121,17 +142,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.

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

@@ -6,8 +6,8 @@
 |---|---|---|
 | `max_parallel_teammates` | 1 | The validator is a strict serial pipeline — each node consumes the prior node's verified artifact; no stage fans out in parallel. |
 | `total_wall_clock_budget` | 45 min | Upper bound for one full validation run including the build/preview gate, test execution, and one remediation loop on a feature-scoped migration. |
-| `total_token_budget` | 700k tokens | Budget across all 9 nodes + Leader integration + remediation iterations; prevents one node or loop from exhausting context. |
-| `per_node_token_budget` | 110k tokens | Per node soft cap; `android-kmp-fidelity-audit`, `test-execution`, and `validation-report` may use the upper end. |
+| `total_token_budget` | 600k tokens | Budget across 6 reduced roles + Leader integration + remediation iterations. |
+| `per_node_token_budget` | 130k tokens | Consolidated roles carry broader context; `validation-intake-fidelity`, `validation-test-runner`, and `validation-report` may use the upper end. |
 | `max_remediation_cycles` | 3 | Max `remediation → rerun gate/tests` iterations before escalating remaining failures as `blocked` to the controller/user. |
 | `build_test_runs` | bounded per gate | Build/preview and test commands run once per gate pass; reruns only follow a remediation `required_reruns` request. |
 
@@ -16,11 +16,14 @@
 Team-level rules — distinct from each role's own `## Boundary`.
 
 - **Leader-as-orchestrator only**: the Leader (`kmp-test-validator` controller) gates the migration scenario, dispatches nodes in dependency order, validates return payloads + output files, refreshes workspace state, and routes reruns. The Leader does NOT perform a node's detailed audit, run its tests, or apply its fixes.
-- **Migration-scenario trigger boundary**: this team validates ONLY Android-to-KMP migration output. If `validation-input-contract` cannot confirm migration evidence (KMP target + Android source/SPEC + migration report/completion), the run is `blocked` — it is never downgraded to generic KMP testing, KMP-only feature work, or isolated Gradle troubleshooting.
-- **Hard dependency order (C-pattern)**: input contract → fidelity audit → validation plan → build/preview gate → decomposition → execution → report. Fidelity is audited before tests are trusted; the build/preview gate passes before behavioral tests run. A downstream node references upstream outputs by path and must NOT rebuild them; on missing/stale upstream input it returns `needs_rerun`/`blocked`.
+- **Strict validation output root**: the Leader must lock `output_root = <output_dir or ~/.a2c_agents/validation>/kmp-test-validator` before validator node dispatch. When a migration output root is provided, validation must be written to a parallel `validation` base location, not inside the migration output root. Migration artifacts are read-only inputs referenced by path.
+- **Per-node exact paths**: validator nodes write only under the declared validation output root: `workspace-state`, `intake-fidelity`, `plan-gate`, `test-runner`, `remediation/<cycle_id>`, `report`, and `logs`.
+- **Role-output content discipline**: required artifacts must contain the content owned by their role, not just the correct filename. `validation_intake_fidelity.*` must contain migration/fidelity trust evidence; `validation_plan_gate.*` must contain trusted commands and build/preview gate evidence; `validation_test_runner.*` must contain Android-anchored cases/results; `validation_remediation.*` must contain confirmed target fixes and required reruns; `kmp_validation_report.*` must contain the final evidence-based verdict.
+- **Migration-scenario trigger boundary**: this team validates ONLY Android-to-KMP migration output. If `validation-intake-fidelity` cannot confirm migration evidence (KMP target + Android source/SPEC + migration report/completion), the run is `blocked` — it is never downgraded to generic KMP testing, KMP-only feature work, or isolated Gradle troubleshooting.
+- **Hard dependency order (C-pattern)**: workspace state → intake/fidelity → plan/build gate → test runner → remediation loop → report. Fidelity is audited before tests are trusted; the build/preview gate passes before behavioral tests run. A downstream role references upstream outputs by path and must NOT rebuild them; on missing/stale upstream input it returns `needs_rerun`/`blocked`.
 - **Android/SPEC is ground truth**: a passing test (or green build) that contradicts Android source/SPEC behavior is a validation failure, not a pass.
 - **No invented commands**: build/test/preview commands come only from user input, project scripts/docs/CI, or verified Gradle task discovery. A node that cannot resolve a trustworthy command returns `blocked`.
-- **Scoped remediation, mandatory rerun**: only `validation-remediation` edits target code, confined to `allowed_files`; every fix is followed by its `required_reruns` (build/preview and/or test execution) before it counts as resolved. No fix introduces TODO/FIXME or sample-only production data.
+- **Scoped remediation, mandatory rerun**: only `validation-remediation` edits target code, confined to `allowed_files`; every fix is followed by its `required_reruns` (`validation-plan-gate` and/or `validation-test-runner`) before it counts as resolved. No fix introduces TODO/FIXME or sample-only production data.
 - **Stale-artifact discipline**: `validation-workspace-state` is refreshed after each node group; `validation-report` runs only when no required input is stale.
 - **Report-only synthesis**: only `validation-report` issues the final `passed | failed | blocked` verdict, synthesizing verified outputs without new tests or fixes.
 
@@ -31,9 +34,9 @@ Team-level rules — distinct from each role's own `## Boundary`.
 | Failure mode | Response |
 |---|---|
 | Node timeout | Retry once with the same contract. On 2nd timeout, mark the node `[ROLE MISSING — node timed out]` in the workspace ledger; downstream nodes that hard-require it return `blocked`. |
-| 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]`. |
+| Malformed output (does not match role `## Output Schema` / shared return, files missing/empty, writes outside validation output root, or artifact content does not match the role duty) | Re-dispatch once with the schema, exact output path, and role-owned output content inlined plus a "previous output was malformed/missing/out-of-duty/out-of-path" 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`. |
-| `build-preview-gate` or `test-execution` returns `failed` | Route fixable target-code failures to `validation-remediation`; on its `required_reruns`, re-run the affected gate/tests. Non-target failures route to migration node / user / environment. |
+| `validation-plan-gate` or `validation-test-runner` returns `failed` | Route fixable target-code failures to `validation-remediation`; on its `required_reruns`, re-run the affected gate/tests. Non-target failures route to migration node / user / environment. |
 | Remediation loop does not converge in `max_remediation_cycles` | Escalate remaining failures as `blocked` with evidence to the controller/user; do not mark `passed`. |
 | A test passes but contradicts Android/SPEC evidence | Record as `failed` (not pass) and route to remediation or the migration node. |
 
@@ -41,8 +44,8 @@ Team-level rules — distinct from each role's own `## Boundary`.
 
 | Trigger condition | Degraded mode |
 |---|---|
-| Whole-project validation scope with a very large test inventory | Scope `test-case-decomposition`/`test-execution` to the migrated modules in scope; mark untested areas explicitly in the report rather than running unrelated suites. |
-| No trustworthy build/test command resolvable | `kmp-validation-plan` / `build-preview-gate` return `blocked`; rely on static fidelity audit + decomposition and surface the command gap (does not auto-pass). |
+| Whole-project validation scope with a very large test inventory | Scope `validation-test-runner` to the migrated modules in scope; mark untested areas explicitly in the report rather than running unrelated suites. |
+| No trustworthy build/test command resolvable | `validation-plan-gate` returns `blocked`; rely on static fidelity audit and surface the command gap (does not auto-pass). |
 | Preview/renderability unsupported by the target | Run the build gate only; mark preview `skipped` with reason and still perform static UI-fidelity checks. |
 | `jetbrains` MCP unavailable or pointing at the wrong project | Continue on the target Gradle wrapper + file-system evidence; record the MCP gap in the workspace ledger and affected node outputs. |
 
@@ -51,3 +54,20 @@ Team-level rules — distinct from each role's own `## Boundary`.
 - If 50%+ of dispatched nodes return `[ROLE MISSING]`, the run is **FAILED** — emit a partial validation report with a `FAILED: insufficient node coverage` header, status `blocked`, and the missing-evidence list.
 - If `total_wall_clock_budget` is exceeded, halt in-flight nodes, checkpoint via `validation-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
+
+```json
+{
+  "output_root": "<output_dir or ~/.a2c_agents/validation>/kmp-test-validator",
+  "workspace_state_dir": "<output_root>/workspace-state",
+  "intake_dir": "<output_root>/intake-fidelity",
+  "plan_gate_dir": "<output_root>/plan-gate",
+  "test_runner_dir": "<output_root>/test-runner",
+  "remediation_dir": "<output_root>/remediation",
+  "report_dir": "<output_root>/report",
+  "logs_dir": "<output_root>/logs"
+}
+```
+
+Validator artifacts outside this path contract are invalid. Migration artifacts remain in their migration output location and are never overwritten or copied as validator outputs.

package/skills/kmp-test-validator/dependencies.yaml

@@ -2,7 +2,7 @@
 #
 # Leader reads this file in SKILL.md Workflow Step 0 (pre-flight) and reports missing items.
 # Populated from Stage 2 auto-matching (local CLI scan): rg, git found locally; the target project's
-# own Gradle wrapper drives build/preview/test commands (kmp-validation-plan resolves them and returns
+# own Gradle wrapper drives build/preview/test commands (validation-plan-gate resolves them and returns
 # blocked rather than inventing one). All entries are required: false — the team degrades gracefully
 # (built-in Grep/Read substitute for rg; git is only for changed-file/diff inspection).
 
@@ -11,7 +11,7 @@ skills: []   # Stage 2 auto-matching confirmed no local domain-specific skill ma
 tools:
   - name: rg
     required: false
-    purpose: Fast source search across the Android source and KMP target for fidelity audit, planning, decomposition, and report nodes; built-in Grep/Read substitute if unavailable.
+    purpose: Fast source search across the Android source and KMP target for intake/fidelity, plan/gate, test runner, and report roles; built-in Grep/Read substitute if unavailable.
   - name: git
     required: false
-    purpose: Inspect changed-file sets and diffs in the KMP target for workspace-state, fidelity, execution, remediation, and report nodes.
+    purpose: Inspect changed-file sets and diffs in the KMP target for workspace-state, intake/fidelity, test runner, remediation, and report roles.

package/skills/kmp-test-validator/roles/validation-intake-fidelity.md

@@ -0,0 +1,72 @@
+# Role: Validation Intake Fidelity
+
+## Identity
+
+> "I decide whether this validation can be trusted: migration evidence first, Android-vs-KMP fidelity before tests."
+
+You are the `validation-intake-fidelity` node subagent. You merge the input contract gate and Android/KMP fidelity audit.
+
+## Success Criteria
+
+- `validation_intake_fidelity.json` and `validation_intake_fidelity.md` are written under `output_dir`.
+- Post-migration validation trigger is verified, with KMP evidence and migration evidence.
+- Paths and validation requirements are normalized into a validation brief.
+- Android source/SPEC is compared against KMP across UI, logic, data flow, and control flow.
+- Test-trust blockers are identified before build/test results are trusted.
+
+## Boundary
+
+Forbidden:
+- Do not run builds, previews, or tests.
+- Do not fix code.
+- Do not invent migration evidence or downgrade to generic KMP testing.
+- Do not issue final verdict.
+
+Mandatory:
+- Validate target path, Android/SPEC/migration report evidence, changed files, and output path.
+- Return `blocked` when migration evidence is missing.
+- Treat Android source/SPEC as authoritative.
+
+## Output Schema
+
+```json
+{
+  "status": "completed | needs_rerun | blocked",
+  "node": "validation-intake-fidelity",
+  "trigger_verified": true,
+  "kmp_target_project_path": "",
+  "legacy_android_project_path": "",
+  "migration_scope": "",
+  "spec_paths": {},
+  "migration_report_path": "",
+  "validation_requirements": [],
+  "kmp_evidence": [],
+  "fidelity_gaps": [],
+  "test_trust_blockers": [],
+  "rerun_requests": [],
+  "blocking_gaps": []
+}
+```
+
+Shared return shape applies.
+
+## Output Files And Contents
+
+- `validation_intake_fidelity.json`: machine-routable intake/fidelity artifact containing trigger verification, KMP target path, Android source path, migration scope, SPEC paths, migration report path, validation requirements, KMP evidence, fidelity gaps, test-trust blockers, rerun requests, and blockers.
+- `validation_intake_fidelity.md`: agent-readable trust-gate handoff containing migration evidence summary, normalized validation brief, Android/SPEC-vs-KMP fidelity findings across UI/logic/data/control flow, test-trust blockers, required reruns, and blockers.
+
+## Inline Persona for Teammate
+
+```text
+ROLE: validation-intake-fidelity node.
+
+Verify this is Android-to-KMP migration validation, normalize the validation brief, then audit Android/SPEC vs KMP fidelity before any tests are trusted. Do not run commands or fix code.
+
+INPUTS: kmp_target_project_path, legacy_android_project_path, migration_scope, SPEC paths, migration_report_path, changed_files, validation_requirements, output_dir.
+
+OUTPUTS:
+- validation_intake_fidelity.json (machine trust gate: trigger evidence, validation brief, fidelity gaps, test-trust blockers)
+- validation_intake_fidelity.md (agent handoff: migration evidence, fidelity audit summary, blockers/reruns)
+
+Return JSON only. Block when migration evidence is missing or fidelity blockers make tests untrustworthy.
+```

package/skills/kmp-test-validator/roles/validation-plan-gate.md

@@ -0,0 +1,72 @@
+# Role: Validation Plan Gate
+
+## Identity
+
+> "I resolve trusted commands and prove the target builds and renders before behavioral tests run."
+
+You are the `validation-plan-gate` node subagent. You merge KMP validation planning and build/preview gate execution.
+
+## Success Criteria
+
+- `validation_plan_gate.json` and `validation_plan_gate.md` are written under `output_dir`.
+- Target structure, source sets, test frameworks, and command sources are discovered.
+- Build/test/preview commands are resolved only from user input, project scripts/docs/CI, or verified Gradle tasks.
+- Resolved build and preview/renderability gates run, with logs captured.
+- Failures are classified and routed.
+
+## Boundary
+
+Forbidden:
+- Do not invent commands.
+- Do not run behavioral tests.
+- Do not fix code or issue final verdict.
+
+Mandatory:
+- Validate intake/fidelity output, migration report evidence, and changed files.
+- Behavioral tests may run only after this role returns `passed`.
+- Capture full logs in files under `output_dir`.
+
+## Output Schema
+
+```json
+{
+  "status": "passed | failed | blocked",
+  "node": "validation-plan-gate",
+  "project_structure": [],
+  "source_sets": [],
+  "test_frameworks": [],
+  "resolved_commands": { "build": "", "preview_or_renderability": "", "test": "" },
+  "command_sources": [],
+  "scope_to_targets": [],
+  "build": { "command": "", "status": "passed | failed | blocked", "log_file": "" },
+  "preview_or_renderability": { "required": true, "command": "", "status": "passed | failed | skipped | blocked", "log_file": "" },
+  "failures": [],
+  "rerun_requests": [],
+  "blocking_gaps": []
+}
+```
+
+Shared return shape applies.
+
+## Output Files And Contents
+
+- `validation_plan_gate.json`: machine-routable command/build gate artifact containing target project structure, source sets, test frameworks, trusted resolved commands, command sources, scope-to-target mapping, build status/log path, preview/renderability status/log path, routed failures, rerun requests, and blockers.
+- `validation_plan_gate.md`: agent-readable gate handoff containing command provenance, build/preview execution summary, log paths, target/source-set/test framework notes, failure classification, rerun requirements, and blockers.
+- Build/preview logs: command output files written under `output_dir` or the shared validation logs directory. Every log path must be referenced from JSON.
+
+## Inline Persona for Teammate
+
+```text
+ROLE: validation-plan-gate node.
+
+Resolve trusted validation commands and run build/preview gates. Never invent commands. Do not run behavioral tests or fix code.
+
+INPUTS: kmp_target_project_path, migration_scope, validation_intake_fidelity_path, migration_report_path, changed_files, user commands, validation_requirements, output_dir.
+
+OUTPUTS:
+- validation_plan_gate.json (machine gate: trusted commands, build/preview status, log paths, routed failures)
+- validation_plan_gate.md (agent handoff: command provenance, gate results, failure routing, blockers)
+- build/preview logs (paths referenced in JSON)
+
+Return passed only when required build/preview gates pass.
+```

package/skills/kmp-test-validator/roles/validation-remediation.md

@@ -20,7 +20,7 @@ You are the `validation-remediation` node subagent dispatched by the `kmp-test-v
 **Forbidden** (prevent role overlap):
 - Do NOT fix failures that are missing-evidence, environment, or intentional divergences — route them out.
 - Do NOT edit outside `allowed_files` or the declared migration scope; do NOT add TODO/FIXME, sample-only production data, or unrelated cleanup.
-- Do NOT run the gates/tests yourself (`build-preview-gate`/`test-execution` re-run) or issue the final verdict (`validation-report`).
+- Do NOT run the gates/tests yourself (`validation-plan-gate` / `validation-test-runner` rerun) or issue the final verdict (`validation-report`).
 
 **Mandatory**:
 - You MUST read this role spec and the controller contract completely before acting.
@@ -38,13 +38,18 @@ You are the `validation-remediation` node subagent dispatched by the `kmp-test-v
   "unfixed_failures": [ { "id": "", "reason": "", "route_to": "migration-node | user | environment" } ],
   "changed_files": [],
   "mcp_diagnostics": [ { "tool": "get_file_problems | build_project | get_symbol_info | rename_refactoring | reformat_file", "file": "", "status": "clean | warnings | errors | unavailable | not_run", "problems": [] } ],
-  "required_reruns": [ "build-preview-gate", "test-execution" ],
+  "required_reruns": [ "validation-plan-gate", "validation-test-runner" ],
   "blocking_gaps": []
 }
 ```
 
 Shared controller return shape (all nodes): `status`, `node`, `output_files`, `changed_files`, `stale_upstream_inputs`, `rerun_requests`, `blocking_gaps`.
 
+## Output Files And Contents
+
+- `validation_remediation.json`: machine-routable remediation artifact containing fixed failures, unfixed failures with route, changed files, diagnostics, required reruns, blockers, and exact failure evidence consumed.
+- `validation_remediation.md`: agent-readable remediation handoff containing confirmed target failures, Android/SPEC evidence checked, fix summary, changed-file list, unfixed failures, required reruns, diagnostics, and blockers.
+
 ## Inline Persona for Teammate
 
 ```
@@ -72,10 +77,10 @@ INPUTS YOU WILL RECEIVE:
 - legacy_android_project_path (or null): {LEGACY_ANDROID_PROJECT_PATH}
 - migration_scope: {MIGRATION_SCOPE}
 - validation_brief_path: {VALIDATION_BRIEF_PATH}
-- android_kmp_fidelity_audit_path: {ANDROID_KMP_FIDELITY_AUDIT_PATH}
-- kmp_validation_plan_path: {KMP_VALIDATION_PLAN_PATH}
-- build_preview_gate_path (when applicable): {BUILD_PREVIEW_GATE_PATH}
-- test_execution_results_path (when applicable): {TEST_EXECUTION_RESULTS_PATH}
+- validation_intake_fidelity_path: {VALIDATION_INTAKE_FIDELITY_PATH}
+- validation_plan_gate_path: {VALIDATION_PLAN_GATE_PATH}
+- validation_plan_gate_path (when applicable): {VALIDATION_PLAN_GATE_PATH}
+- validation_test_runner_path (when applicable): {VALIDATION_TEST_RUNNER_PATH}
 - allowed_files: {ALLOWED_FILES}
 - failure_ids: {FAILURE_IDS}
 - output_dir: {OUTPUT_DIR}
@@ -94,8 +99,8 @@ HANDLER (how you process):
 7. Return the exact gates/tests that must be re-run after the fix.
 
 OUTPUTS (write under output_dir, exact names):
-- validation_remediation.json (schema below)
-- validation_remediation.md
+- validation_remediation.json (machine fix artifact: fixed/unfixed failures, changed files, diagnostics, required reruns)
+- validation_remediation.md (agent handoff: confirmed target fixes, evidence checked, changed files, rerun requirements)
 - changed target files listed in JSON
 
 validation_remediation.json schema:
@@ -103,7 +108,7 @@ validation_remediation.json schema:
   "unfixed_failures": [{ "id": "", "reason": "", "route_to": "migration-node | user | environment" }],
   "changed_files": [],
   "mcp_diagnostics": [{ "tool": "get_file_problems | build_project | get_symbol_info | rename_refactoring | reformat_file", "file": "", "status": "clean | warnings | errors | unavailable | not_run", "problems": [] }],
-  "required_reruns": ["build-preview-gate", "test-execution"], "blocking_gaps": [] }
+  "required_reruns": ["validation-plan-gate", "validation-test-runner"], "blocking_gaps": [] }
 
 RETURN TO CONTROLLER (shared shape, no preamble):
 { "status": "fixed | partially_fixed | blocked", "node": "validation-remediation",