@code-migration/wow-migrator 0.1.3 → 0.1.4

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

@@ -1,87 +1,77 @@
 ---
 name: migration-task-adapter
 description: |
-  4-role task adapter Swarm Skill that classifies an incoming Android/KMP migration request, routes only-understand tasks for UI, logic, architecture, or overview to android-project-analyst, routes migration tasks through android-project-analyst and android-to-kmp-migrator, and records stage inspections plus intermediate asset records before final reporting.
-  Use when a controller must decide whether the user is asking for focused understanding, overview analysis, migration, or post-migration validation handoff before invoking analyst/migrator/validator workflows.
+  Front-door Swarm Skill that classifies Android/KMP migration requests, routes understand/migration/validation tasks to analyst, migrator, and validator workflows, and records stage gates plus asset ledgers before the final adapter report.
+  Use when a controller must decide task intent and invoke the correct downstream workflow before detailed analysis, migration, or validation runs.
   Do NOT use for direct source lookup, single-file edits, generic KMP testing without migration context, or standalone implementation work.
-version: "0.1"
+version: "0.2"
 kind: swarm-skill
 disable-model-invocation: true
 roles:
-  - id: task-understanding-router
+  - id: task-route-orchestrator
     kind: ai_agent
-    purpose: Task intake and route decision owner - normalize the user request, classify only-understand vs migration, choose UI/logic/architecture/overview focus, identify required source/target paths, and emit route contracts.
-    skills: []
-    tools: [rg]
-  - id: workflow-orchestrator
-    kind: ai_agent
-    purpose: Workflow orchestration owner - consume the route decision, build downstream analyst/migrator/validator dispatch contracts, record observed workflow results, and request reruns without doing downstream role work.
+    purpose: Task route and orchestration — mode route (classify intent, paths, downstream sequence) or orchestrate (dispatch contracts, observed downstream outputs). No downstream role work.
     skills: []
     tools: [rg, git]
-  - id: workspace-state-discipline-inspector
+  - id: adapter-workspace-state
     kind: ai_agent
-    purpose: Discipline inspector - verify workspace-state freshness, stage inspection records, intermediate asset records, output path compliance, stale inputs, and rerun/blocker routing.
+    purpose: Workspace ledger — stage inspections, intermediate asset records, path compliance, freshness, reruns. No routing, orchestration, or final verdict.
     skills: []
     tools: [git]
-  - id: task-reporter
+  - id: adapter-report
     kind: ai_agent
-    purpose: Final task report owner - synthesize verified adapter and downstream workflow evidence into a machine-routable task report without new analysis, migration, validation, or fixes.
+    purpose: Final adapter report from verified route, orchestration, workspace, stage, and downstream evidence. No new routing or workflow execution.
     skills: []
     tools: [git]
 ---
 
 # Migration Task Adapter Swarm Skill
 
-This is the agent-facing registry and team definition for a front-door adapter in the KMP Migration Toolkit. It does not replace `android-project-analyst`, `android-to-kmp-migrator`, or `kmp-test-validator`. It understands the user's task first, selects the right downstream workflow, enforces stage inspections, records intermediate assets, and produces a final routing/report artifact.
+Front-door adapter for the KMP Migration Toolkit. It does not replace `android-project-analyst`, `android-to-kmp-migrator`, or `kmp-test-validator`. It classifies the user task, invokes the right downstream workflow, enforces stage gates, records consumed artifacts, and produces a final adapter report.
 
-Supported task targets:
+## Task Routes
 
-- `only_understand_ui`: focused UI/presentation/resource understanding through `android-project-analyst`, with emphasis on `presentation-resource` outputs.
-- `only_understand_logic`: focused behavior/control-flow understanding through `android-project-analyst`, with emphasis on `behavior-logic` outputs and verified Stage A inputs.
-- `only_understand_architecture`: focused project architecture/ecosystem understanding through `android-project-analyst`, with emphasis on `project-architecture` outputs.
-- `only_understand_overview`: overview understanding through the full analyst representation and SPEC verification path.
-- `migration`: Android-to-KMP migration through analyst completion, migrator execution, and validator handoff when migration output is ready.
-- `validation_handoff`: post-migration validation through `kmp-test-validator` only when migration evidence exists.
+| Route | Downstream |
+|---|---|
+| `only_understand_ui` | `android-project-analyst` — UI/presentation focus |
+| `only_understand_logic` | `android-project-analyst` — behavior/control-flow focus |
+| `only_understand_architecture` | `android-project-analyst` — architecture/ecosystem focus |
+| `only_understand_overview` | `android-project-analyst` — full representation + SPEC |
+| `migration` | analyst (if SPEC stale) → `android-to-kmp-migrator` → optional `kmp-test-validator` |
+| `validation_handoff` | `kmp-test-validator` when migration evidence exists |
 
 ## Protocol Summary
 
-0. **Pre-flight** - read [dependencies.yaml](dependencies.yaml), report missing optional tools, and lock adapter output root.
-1. **Task understanding and route** - dispatch `task-understanding-router`; write task classification, route decision, required evidence, and downstream workflow contract.
-2. **Workspace discipline init** - dispatch `workspace-state-discipline-inspector` to initialize stage inspection and intermediate asset ledgers.
-3. **Workflow orchestration** - dispatch `workflow-orchestrator` to prepare and record downstream workflow execution:
-   - only-understand routes to `android-project-analyst`.
-   - migration routes to `android-project-analyst` first when SPEC evidence is missing or stale, then `android-to-kmp-migrator`, then validation handoff when ready.
-   - validation handoff routes to `kmp-test-validator` only after migration report evidence exists.
-4. **Stage inspections** - after every route boundary and downstream workflow boundary, refresh `workspace-state-discipline-inspector`.
-5. **Task report** - dispatch `task-reporter` only after latest discipline inspection marks required inputs fresh and intermediate asset records complete.
+0. **Pre-flight** — [dependencies.yaml](dependencies.yaml); lock adapter `output_root`.
+1. **Route** — `task-route-orchestrator` mode `route` → `task_route.*`.
+2. **Workspace init** — `adapter-workspace-state` → ledger, first stage inspection, asset records.
+3. **Orchestrate** — `task-route-orchestrator` mode `orchestrate` → downstream dispatch contracts and observed outputs.
+4. **Stage gates** — refresh `adapter-workspace-state` after each route and downstream boundary.
+5. **Report** — `adapter-report` when `pre_report` stage passes and assets are complete.
 
 ## Roles
 
-Each role is dispatched as a subagent that must read its role file (`skill_spec_path`) and execute only that bounded slice.
-
-| id | Purpose | When dispatched | Role file |
-|---|---|---|---|
-| `task-understanding-router` | Classify request, normalize paths/scope, select route and downstream workflow contracts | First stage after output root lock | [roles/task-understanding-router.md](roles/task-understanding-router.md) |
-| `workflow-orchestrator` | Build dispatch contracts, track downstream workflow observations, route reruns/blockers | After route decision and before/after downstream workflow execution | [roles/workflow-orchestrator.md](roles/workflow-orchestrator.md) |
-| `workspace-state-discipline-inspector` | Inspect stage records, intermediate assets, output paths, workspace freshness, reruns | Initialized early and refreshed after every stage boundary | [roles/workspace-state-discipline-inspector.md](roles/workspace-state-discipline-inspector.md) |
-| `task-reporter` | Final machine-routable report from verified adapter/downstream artifacts | Last stage only | [roles/task-reporter.md](roles/task-reporter.md) |
+| id | Modes | Role file |
+|---|---|---|
+| `task-route-orchestrator` | `route \| orchestrate` | [roles/task-route-orchestrator.md](roles/task-route-orchestrator.md) |
+| `adapter-workspace-state` | — | [roles/adapter-workspace-state.md](roles/adapter-workspace-state.md) |
+| `adapter-report` | — | [roles/adapter-report.md](roles/adapter-report.md) |
 
 ## Files
 
-| File | What it contains |
+| File | Contents |
 |---|---|
-| [workflow.md](workflow.md) | Adapter topology, route matrix, stage inspection gates, intermediate asset records, final report contract |
-| [bind.md](bind.md) | Guardrails, failure handling, path discipline, stage inspection requirements |
-| [dependencies.yaml](dependencies.yaml) | Optional CLI tools checked at startup |
-| [roles/](roles/) | Active role specs |
+| [workflow.md](workflow.md) | Topology, route matrix, stage gates, report shape |
+| [bind.md](bind.md) | Guardrails, path contract, failure handling |
+| [dependencies.yaml](dependencies.yaml) | Downstream skills and optional tools |
+| [roles/](roles/) | Role specs |
 
-## Strict Output Schedule
+## Output Layout
 
 ```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
@@ -89,64 +79,47 @@ report_dir = <output_root>/report
 
 Required artifacts:
 
-- `<output_root>/run_manifest.json`
-- `<task_dir>/task_understanding_router.json`
-- `<task_dir>/task_understanding_router.md`
-- `<workspace_state_dir>/workspace_state_discipline.json`
-- `<workspace_state_dir>/workspace_state_discipline.md`
-- `<stage_inspection_dir>/<stage_id>/stage_inspection.json`
-- `<stage_inspection_dir>/<stage_id>/stage_inspection.md`
-- `<intermediate_asset_dir>/intermediate_asset_records.json`
-- `<intermediate_asset_dir>/intermediate_asset_records.md`
-- `<orchestration_dir>/workflow_orchestration.json`
-- `<orchestration_dir>/workflow_orchestration.md`
-- `<report_dir>/task_adapter_report.json`
-- `<report_dir>/task_adapter_report.md`
-
-## Output Artifact Content Matrix
-
-The adapter verifies both artifact names and role-aligned content before any downstream stage consumes an artifact.
-
-| Stage / owner | Output file(s) | Required content |
-|---|---|---|
-| Output root lock / Leader | `run_manifest.json` | Task id, raw task summary, requested scope, source/target paths when provided, adapter output root, allowed roots, downstream workflow candidates, dependency-preflight status, schedule version, timestamp. |
-| Task route / `task-understanding-router` | `task_understanding_router.json`, `task_understanding_router.md` | Normalized task, route, task kind, understand focus, source/target/scope fields, existing artifact evidence, required/missing inputs, downstream workflow sequence, stage inspection requirements, intermediate asset requirements, blockers. |
-| Orchestration / `workflow-orchestrator` | `workflow_orchestration.json`, `workflow_orchestration.md` | Downstream workflow sequence, dispatch contracts, expected output roots/artifacts, route constraints, stage inspection requests, observed downstream outputs, intermediate asset updates, rerun requests, blockers. |
-| Workspace discipline / `workspace-state-discipline-inspector` | `workspace_state_discipline.json`, `workspace_state_discipline.md` | Adapter artifact inventory, stage status, path compliance, freshness checks, intermediate asset coverage, rerun history, blockers, next safe actions. No task routing or downstream analysis. |
-| Stage inspections / `workspace-state-discipline-inspector` | `<stage_inspection_dir>/<stage_id>/stage_inspection.json`, `.md` | Checked inputs/outputs, path compliance, freshness checks, intermediate asset coverage, downstream contract checks, stage status, rerun requests, blockers, next allowed stage. |
-| Intermediate assets / `workspace-state-discipline-inspector` | `intermediate_asset_records.json`, `intermediate_asset_records.md` | Stable records for every consumed adapter/downstream artifact: asset id/type, producer, path, status, freshness basis, consumers, source evidence, coverage gaps, blockers. |
-| Final task report / `task-reporter` | `task_adapter_report.json`, `task_adapter_report.md` | Final route/status/readiness, source/target paths, downstream workflow summaries, stage inspection summary, intermediate asset summary, verified outputs, rerun requests, blockers, report path. |
+- `run_manifest.json`
+- `route-orchestration/route/task_route.json`, `.md`
+- `workspace-state/adapter_workspace_state.json`, `.md`
+- `route-orchestration/orchestrate/workflow_orchestration.json`, `.md`
+- `stage-inspections/<stage_id>/stage_inspection.json`, `.md`
+- `intermediate-assets/intermediate_asset_records.json`, `.md`
+- `report/adapter_report.json`, `.md`
+
+Downstream workflows write only to their own output roots; the adapter records paths in asset records.
 
-Downstream output roots are external asset paths. The adapter records them but does not write into them: `android-project-analyst` writes to its understand output root, `android-to-kmp-migrator` writes to its migration output root, and `kmp-test-validator` writes to its parallel validation output root.
+## Artifact Owners
 
-JSON artifacts are the machine-routable source of truth. Markdown artifacts are agent-readable handoffs that preserve exact paths, route decisions, stage evidence, asset records, rerun context, blockers, and downstream routing. Adapter Markdown must not be prose-only summaries.
+| Owner | Artifacts |
+|---|---|
+| Leader | `run_manifest.json` |
+| `task-route-orchestrator` | `task_route.*`, `workflow_orchestration.*` |
+| `adapter-workspace-state` | `adapter_workspace_state.*`, `stage_inspection.*`, `intermediate_asset_records.*` |
+| `adapter-report` | `adapter_report.*` |
 
 ## Shared Return Contract
 
 ```json
 {
   "status": "completed | routed | passed | ready_for_report | needs_rerun | failed | blocked",
-  "node": "<node-id>",
-  "task_id": "<stable task id>",
-  "route": "<only_understand_ui | only_understand_logic | only_understand_architecture | only_understand_overview | migration | validation_handoff | unknown>",
-  "output_dir": "<exact role output dir>",
-  "output_files": ["<paths>"],
+  "node": "node-id",
+  "mode": "route | orchestrate",
+  "task_id": "",
+  "route": "",
+  "output_dir": "",
+  "output_files": [],
   "changed_files": [],
   "stale_upstream_inputs": [],
-  "rerun_requests": [
-    { "node": "<adapter or downstream node/workflow>", "reason": "", "required_inputs": [], "expected_output": "" }
-  ],
+  "rerun_requests": [],
   "blocking_gaps": []
 }
 ```
 
-Controller handling: missing or empty output files cause rerun of the same role. Stale upstream inputs cause a discipline refresh and rerun of the owning role or downstream workflow. Non-empty `blocking_gaps` stop the adapter unless the user supplies the missing evidence.
-
 ## Shared Rules
 
-- The adapter is an orchestrator only. It does not perform detailed Android analysis, migration implementation, validation testing, or code fixes.
-- Task classification must happen before selecting any downstream workflow.
-- Stage inspections are required after route decision, before downstream dispatch, after every downstream workflow boundary, before final report, and after final report.
-- Every durable artifact consumed by another stage must be recorded in `intermediate_asset_records.*`.
-- Downstream workflow outputs are consumed by path and status only; the adapter never invents missing downstream evidence.
-- User-facing completion happens only after `task-reporter` writes verified report artifacts.
+- Adapter roles orchestrate only — no Android analysis, migration implementation, validation testing, or code fixes.
+- Route classification happens before downstream workflow selection.
+- Every consumed durable artifact must appear in `intermediate_asset_records.*`.
+- Downstream evidence is consumed by path and status only — never invented.
+- Final user-facing completion requires `adapter_report.*`.

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

@@ -4,113 +4,46 @@
 
 | Item | Limit | Reason |
 |---|---|---|
-| `max_parallel_teammates` | 1 | The adapter is a control plane. Stage inspections must be serialized around downstream workflow boundaries. |
-| `total_wall_clock_budget` | 20 min adapter overhead | Downstream analyst/migrator/validator workflows keep their own budgets. |
-| `total_token_budget` | 300k adapter overhead | The adapter records contracts, inspections, and asset ledgers; it must not duplicate downstream analysis. |
-| `per_node_token_budget` | 80k | Roles are narrow and should cite downstream artifacts by path rather than paste large outputs. |
-| `max_route_retries` | 2 | Repeated route ambiguity should be surfaced to the user as a blocker. |
-| `max_stage_inspection_repairs` | 2 per stage | Missing or malformed inspection records are repaired by rerunning the discipline inspector, not by bypassing the gate. |
+| `max_parallel_teammates` | 1 | Serial control plane; stage gates around downstream boundaries |
+| `total_wall_clock_budget` | 20 min | Adapter overhead only; downstream workflows keep own budgets |
+| `total_token_budget` | 300k | Record contracts and ledgers; do not duplicate downstream analysis |
+| `per_node_token_budget` | 90k | Narrow roles cite paths, not full downstream outputs |
+| `max_route_retries` | 2 | Persistent ambiguity → user blocker |
+| `max_stage_repairs` | 2 per stage | Rerun `adapter-workspace-state`; do not bypass gates |
 
 ## Behavioral Constraints
 
-- **Adapter-as-orchestrator only**: the Leader and adapter roles classify, route, inspect, record, and report. They do not perform detailed Android analysis, implement migration code, run validation tests, or fix target source.
-- **Task-first routing**: `task-understanding-router` must complete before any downstream workflow is selected. A guessed route is invalid.
-- **Strict output root**: the Leader must lock `output_root = <output_dir or ~/.a2c_agents/task-adapter>/migration-task-adapter` before role dispatch. Adapter roles write only under this root.
-- **Downstream boundary**: analyst, migrator, and validator artifacts stay under their own declared output roots. The adapter records their paths and statuses in intermediate asset records.
-- **Downstream output-root alignment**: validator outputs must be recorded under the validator's parallel `validation` output root, not under the migration output root. The adapter may route to `kmp-test-validator`, but it must record validator artifacts as external downstream assets.
-- **Role-output content discipline**: required adapter artifacts must contain the content owned by their role, not just the correct filename. `task_understanding_router.*` must contain route/evidence requirements, `workflow_orchestration.*` must contain downstream contracts/observations, `workspace_state_discipline.*` and `stage_inspection.*` must contain inspection evidence, `intermediate_asset_records.*` must contain asset records, and `task_adapter_report.*` must contain the final verified report.
-- **Stage inspection discipline**: every route boundary and downstream workflow boundary must have a `stage_inspection.json` and `.md`. A stage inspection must say whether the next stage is `pass`, `needs_rerun`, or `blocked`.
-- **Intermediate asset discipline**: every durable artifact consumed by another stage must have one asset record with producer, path, status, freshness basis, consumers, and gaps.
-- **Workspace-state freshness**: the adapter must refresh `workspace-state-discipline-inspector` after task routing, after downstream workflow completion, before report, and after report.
-- **No hidden fallbacks**: if analyst/migrator/validator evidence is missing or stale, route a rerun request to that workflow. Do not synthesize missing SPEC, migration report, validation report, module representation, or node output.
-- **Only-understand focus is a route constraint, not a license to skip evidence gates**: focused UI, logic, architecture, and overview understanding still require analyst artifacts and verification. The focus determines priority and reporting emphasis.
-- **Migration readiness**: migration may not start from raw source alone when the migrator requires analyst completion. If fresh SPEC evidence is missing, route analyst in migration mode first.
-- **Report-only finalization**: only `task-reporter` issues the adapter final task status, and only from verified adapter and downstream artifacts.
-
-## Stage Inspection Contract
-
-Each stage inspection artifact must include:
-
-```json
-{
-  "stage_id": "",
-  "status": "pass | needs_rerun | blocked",
-  "checked_inputs": [],
-  "checked_outputs": [],
-  "path_compliance": [],
-  "freshness_checks": [],
-  "intermediate_asset_coverage": [],
-  "downstream_contract_checks": [],
-  "rerun_requests": [],
-  "blocking_gaps": [],
-  "next_allowed_stage": ""
-}
-```
-
-Inspection rules:
-
-- `pass` requires all required inputs and outputs to exist, be non-empty, be under allowed roots, and be recorded in intermediate assets when consumed.
-- `needs_rerun` requires a concrete owner and expected output.
-- `blocked` requires a user/actionable gap or unavailable environment/tool/evidence.
-
-## Intermediate Asset Record Contract
-
-Every asset record must be stable and machine-routable:
-
-```json
-{
-  "asset_id": "",
-  "asset_type": "run_manifest | route_decision | stage_inspection | workspace_state | downstream_output | representation | spec | migration_report | validation_report | final_report | log | other",
-  "producer": "",
-  "path": "",
-  "status": "exists | missing | stale | blocked | not_applicable",
-  "created_or_observed_at": "",
-  "freshness_basis": "",
-  "consumers": [],
-  "source_evidence": [],
-  "blocking_gaps": []
-}
-```
-
-No downstream stage may consume a durable artifact whose record is `missing`, `stale`, or `blocked`.
+- **Orchestrator only** — classify, route, inspect, record, report. No analysis, migration, validation, or code edits.
+- **Route before downstream** — `task-route-orchestrator` mode `route` completes before workflow invoke.
+- **Strict output root** — `output_root = <output_dir or ~/.a2c_agents/task-adapter>/migration-task-adapter`.
+- **Downstream boundary** — analyst/migrator/validator artifacts stay in their output roots; adapter records paths in asset ledger.
+- **Validator root** — validation artifacts under parallel `validation` root, not migration root.
+- **Stage gates** — every route and downstream boundary gets `stage_inspection.*` with `pass | needs_rerun | blocked`.
+- **Asset ledger** — every consumed durable artifact has one record with producer, path, status, freshness.
+- **No hidden fallbacks** — missing/stale evidence → rerun request to owning workflow.
+- **Migration readiness** — migrator requires fresh analyst SPEC; route analyst first when missing.
+- **Final verdict** — only `adapter-report` issues adapter final status.
 
 ## Failure Handling
 
-### Teammate failure
-
-| Failure mode | Response |
+| Failure | Response |
 |---|---|
-| Node timeout | Retry once with the same contract. On second timeout, record `[ROLE MISSING - node timed out]` in workspace discipline and block any stage that hard-requires it. |
-| Malformed output or missing JSON/MD artifacts | Rerun the same role once with the expected schema, output paths, and role-owned output content inlined. On second failure, record `[ROLE MISSING - malformed output]` and block downstream consumption. |
-| Adapter output written outside `output_root` or downstream validator output recorded under migration root | Reject the output as out-of-path; rerun the owning adapter role with the path contract and downstream output-root rules inlined. |
-| Route is ambiguous | Rerun `task-understanding-router` with the ambiguity. If still ambiguous, ask the user for source path, target path, task target, or scope. |
-| Stage inspection missing or malformed | Rerun `workspace-state-discipline-inspector` for that `stage_id`. Do not proceed past the stage. |
-| Intermediate asset record missing for consumed artifact | Rerun `workspace-state-discipline-inspector` to repair the asset ledger before downstream consumption. |
-| Downstream workflow output missing/empty | Route rerun to the owning downstream workflow or role; do not create adapter-side replacement artifacts. |
-| Downstream output stale | Refresh the owning downstream workspace-state workflow if available, then rerun the owning workflow/role before consumption. |
-| Downstream workflow returns blocked | Preserve its blocker in adapter stage inspection and final report. Do not downgrade to a partial pass. |
-
-### Input over-scale degradation
+| Node timeout | Retry once; then `[ROLE MISSING]` and block dependent stages |
+| Malformed or out-of-path output | Rerun owning role with path contract |
+| Ambiguous route | Rerun mode `route`; then ask user for path/scope |
+| Missing stage inspection | Rerun `adapter-workspace-state` for `stage_id` |
+| Missing asset record | Rerun workspace state before consumption |
+| Downstream missing/stale | Rerun owning downstream workflow |
 
-| Trigger condition | Degraded mode |
-|---|---|
-| User asks for whole-project overview without a scope on a very large Android project | Route to `only_understand_overview` with a scope-narrowing blocker or ask for feature/module priority. |
-| User asks for migration without a KMP target path | Route classification may complete, but orchestration blocks before migrator dispatch. |
-| User asks for validation without migration report/SPEC evidence | Route to `validation_handoff` only as blocked, listing required migration evidence. |
-| Existing downstream artifacts are too large to inspect inline | Record paths and status only; require downstream report/verification artifacts instead of pasting node contents. |
-
-## Required Path Contract
+## Path Contract
 
 ```json
 {
   "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"
 }
 ```
-
-Reject adapter artifacts outside this path contract. For downstream workflows, record their own output roots as external asset paths with producer workflow metadata.

package/skills/migration-task-adapter/dependencies.yaml

@@ -1,26 +1,37 @@
-# dependencies.yaml - Migration Task Adapter startup dependency check
-#
-# All tools are optional. The adapter can still route and report with file-system
-# evidence, but degraded checks must be recorded in stage inspections.
+# dependencies.yaml — migration-task-adapter startup check
 
 skills:
   - name: android-project-analyst
     required: false
-    purpose: Downstream workflow for only-understand UI, logic, architecture, overview, and pre-migration SPEC generation.
+    used_by:
+      - task-route-orchestrator
+    purpose: Downstream for understand routes and pre-migration SPEC.
   - name: android-to-kmp-migrator
     required: false
-    purpose: Downstream workflow for Android-to-KMP migration after analyst evidence is fresh.
+    used_by:
+      - task-route-orchestrator
+    purpose: Downstream for migration after analyst evidence is fresh.
   - name: kmp-test-validator
     required: false
-    purpose: Downstream workflow for post-migration validation when migration report evidence is ready; outputs must be recorded under the validator's parallel validation root.
+    used_by:
+      - task-route-orchestrator
+    purpose: Downstream for validation when migration report exists; validation root is parallel to migration.
 
 tools:
   - name: rg
     required: false
-    purpose: Optional path and evidence discovery for task routing; built-in search/read tools may substitute.
+    used_by:
+      - task-route-orchestrator
+    purpose: Optional evidence discovery for routing.
   - name: git
     required: false
-    purpose: Optional changed-file and freshness detection for workspace-state discipline inspections.
+    used_by:
+      - task-route-orchestrator
+      - adapter-workspace-state
+      - adapter-report
+    purpose: Changed-file and freshness checks for ledger and report.
   - name: curl
     required: false
-    purpose: Optional availability check because downstream presentation/resource workflows may need safe media downloads.
+    used_by:
+      - task-route-orchestrator
+    purpose: Optional; downstream analyst presentation workflows may fetch remote media.

package/skills/migration-task-adapter/roles/adapter-report.md

@@ -0,0 +1,71 @@
+# Role: Adapter Report
+
+## Identity
+
+> "I issue the final adapter verdict from verified route, orchestration, workspace, stage, and downstream evidence only."
+
+You are the `adapter-report` node subagent. You synthesize verified adapter and downstream artifacts into the final task report. You do not reclassify routes, orchestrate workflows, analyze source, migrate, validate, or fix code.
+
+## Success Criteria
+
+- `adapter_report.json` and `adapter_report.md` under `report_dir`.
+- Final status from verified evidence: `completed`, `ready_for_validation`, `needs_rerun`, `failed`, or `blocked`.
+- Every claim cites an adapter artifact, stage inspection, asset record, or downstream report path.
+- Missing `pre_report` inspection or stale required inputs → `needs_rerun` or `blocked`.
+
+## Status Rules
+
+- `completed` — understand route satisfied; inspections pass; assets recorded.
+- `ready_for_validation` — migration report ready; validation not run in this adapter pass.
+- `needs_rerun` — concrete owner can resolve missing/stale evidence.
+- `failed` — downstream workflow failed with verified evidence.
+- `blocked` — missing path, evidence, or user decision.
+
+## Boundary
+
+**Forbidden**:
+
+- Do not repair stage inspections or alter orchestration contracts.
+- Do not claim downstream pass without report artifacts and latest stage inspection support.
+
+**Mandatory**:
+
+- Validate all required input paths; use latest `pre_report` stage inspection before reporting.
+
+## Output Schema
+
+```json
+{
+  "status": "completed | ready_for_validation | needs_rerun | failed | blocked",
+  "node": "adapter-report",
+  "task_id": "",
+  "route": "",
+  "understand_focus": "ui | logic | architecture | overview | mixed | none",
+  "source_project_path": "",
+  "target_project_path": "",
+  "downstream_workflows": [],
+  "stage_inspection_summary": [],
+  "intermediate_asset_summary": {},
+  "verified_outputs": [],
+  "readiness": "ready | ready_with_assumptions | ready_for_validation | blocked",
+  "rerun_requests": [],
+  "blocking_gaps": [],
+  "report_path": ""
+}
+```
+
+## Output Files
+
+- `adapter_report.json`, `adapter_report.md`
+
+## Inline Persona
+
+```text
+ROLE: adapter-report.
+
+Synthesize final adapter status from task_route, workflow_orchestration, adapter_workspace_state, stage inspections, asset records, and downstream reports.
+
+INPUTS: task_id, route, task_route_path, workflow_orchestration_path, adapter_workspace_state_path, pre_report_stage_inspection_path, intermediate_asset_records_path, downstream_report_paths, report_dir.
+
+Do not reclassify, orchestrate, analyze, migrate, validate, or fix.
+```

package/skills/migration-task-adapter/roles/adapter-workspace-state.md

@@ -0,0 +1,71 @@
+# Role: Adapter Workspace State
+
+## Identity
+
+> "I keep the adapter ledger honest — stage gates, asset records, path compliance, and stale inputs."
+
+You are the `adapter-workspace-state` node subagent. You maintain the workspace ledger, stage inspection records, and intermediate asset records. You do not route tasks, orchestrate downstream workflows, analyze source, migrate, validate, fix code, or issue the final report.
+
+## Success Criteria
+
+- `adapter_workspace_state.json` and `.md` under `workspace_state_dir`.
+- Per requested `stage_id`: `stage_inspection.json` and `.md` under `stage_inspection_dir/<stage_id>/`.
+- `intermediate_asset_records.json` and `.md` under `intermediate_asset_dir`.
+- Every consumed artifact has one asset record; every stage declares `pass`, `needs_rerun`, or `blocked`.
+
+## Boundary
+
+**Forbidden**:
+
+- Do not classify routes or build dispatch contracts (`task-route-orchestrator`).
+- Do not issue final adapter status (`adapter-report`).
+- Do not move or rewrite downstream workflow artifacts.
+
+**Mandatory**:
+
+- Validate `output_root`, stage and asset dirs, and known artifact paths.
+- Treat missing/stale/out-of-path artifacts as `needs_rerun` or `blocked`.
+
+## Output Schema
+
+```json
+{
+  "status": "passed | needs_rerun | blocked",
+  "node": "adapter-workspace-state",
+  "task_id": "",
+  "route": "",
+  "current_stage_id": "",
+  "stage_status": [],
+  "artifact_inventory": [],
+  "path_compliance": [],
+  "freshness_checks": [],
+  "rerun_history": [],
+  "blocking_gaps": [],
+  "next_actions": []
+}
+```
+
+## Stage IDs
+
+- `route_decision` — after task-route-orchestrator mode `route`
+- `pre_downstream_dispatch` — before downstream invoke
+- `post_analyst` | `post_migrator` | `post_validator` — after applicable workflow
+- `pre_report` | `post_report` — around adapter-report
+
+## Output Files
+
+- `adapter_workspace_state.json`, `adapter_workspace_state.md`
+- `<stage_inspection_dir>/<stage_id>/stage_inspection.json`, `.md`
+- `<intermediate_asset_dir>/intermediate_asset_records.json`, `.md`
+
+## Inline Persona
+
+```text
+ROLE: adapter-workspace-state.
+
+Inspect stage gates, record intermediate assets, track freshness and path compliance. Route stale or missing artifacts to the owning role or downstream workflow.
+
+INPUTS: task_id, route, current_stage_id, output_root, known_artifacts, consumed_artifacts, downstream_observations, output_dir, stage_inspection_dir, intermediate_asset_dir.
+
+Do not route, orchestrate, analyze, migrate, validate, or report final status.
+```