@code-migration/wow-migrator 0.1.2 → 0.1.3

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

@@ -49,6 +49,11 @@ Mandatory:
 
 Shared return shape applies.
 
+## Output Files And Contents
+
+- `logic_implementation.json`: machine-routable logic implementation artifact containing changed logic/data/API files, architecture alignment, platform boundaries, data flows, API integrations, logic coverage, diagnostics, and blockers.
+- `logic_implementation.md`: agent-readable logic handoff containing implemented behavior, UI binding integration, state/data/API flow summary, platform-boundary notes, changed-file list, diagnostics, and blockers.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -59,8 +64,8 @@ Implement the module behavior that drives the approved UI. Use state-data prep c
 INPUTS: migration_module_id, module_scope, planning path, dependency-platform path, presentation-integration path, state-data-prep path, ui-implementation path, allowed_files, output_dir.
 
 OUTPUTS:
-- logic_implementation.json
-- logic_implementation.md
+- logic_implementation.json (machine implementation: changed files, architecture alignment, platform boundaries, data/API flows, logic coverage)
+- logic_implementation.md (agent handoff: implemented behavior, binding integration, changed files, diagnostics, blockers)
 
 Return JSON with changed_files, diagnostics, output_files, rerun_requests, blockers.
 ```

package/skills/android-to-kmp-migrator/roles/migration-analysis-planning.md

@@ -48,6 +48,11 @@ Mandatory:
 
 Shared return shape: `status`, `node`, `migration_module_id`, `module_scope`, `output_dir`, `output_files`, `changed_files`, `stale_upstream_inputs`, `rerun_requests`, `blocking_gaps`.
 
+## Output Files And Contents
+
+- `migration_analysis_planning.json`: machine-routable planning artifact containing SPEC/raw-source deltas, target KMP evidence, reuse inventory, source-to-target map, resource project map, integration scaffold, ordered implementation tasks, blockers, and exact module/output metadata.
+- `migration_analysis_planning.md`: agent-readable planning handoff containing delta summary, target evidence, reuse decisions, source-to-target tables, resource placement notes, integration scaffold, task order, assumptions, and blockers.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -58,8 +63,8 @@ You produce the module migration plan: SPEC/raw-source deltas, target KMP unders
 INPUTS: legacy_android_project_path, kmp_target_project_path, migration_scope, migration_module_id, module_scope, module_brief_path, prd/design/plan/verification paths, output_root, output_dir.
 
 OUTPUTS under output_dir:
-- migration_analysis_planning.json
-- migration_analysis_planning.md
+- migration_analysis_planning.json (machine plan: SPEC/source deltas, target evidence, reuse inventory, source-to-target map, ordered tasks)
+- migration_analysis_planning.md (agent handoff: planning tables, scaffold, assumptions, blockers)
 
 Return JSON only. Include migration_module_id, module_scope, output_dir, output_files, changed_files: [], stale_upstream_inputs, rerun_requests, blocking_gaps.
 ```

package/skills/android-to-kmp-migrator/roles/migration-verification.md

@@ -59,6 +59,12 @@ Mandatory:
 
 Shared return shape applies.
 
+## Output Files And Contents
+
+- `migration_verification.json`: machine-routable verification artifact containing requested `check_ids`, per-check status, evidence, failures, routed owner node, command/log references, blocking gaps, and overall `passed | failed | blocked` status.
+- `migration_verification.md`: agent-readable verification handoff containing source-set, API contract, UI render/fidelity, and incremental build results, command/log paths, failure routing, skipped/blocked reasons, and rerun requirements.
+- Log files: optional command/render/build logs written under `output_dir` when a check runs a command. Every log path must appear in `log_files`.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -69,9 +75,9 @@ Run read-only verification for explicit check_ids: source_set, api_contract, ui_
 INPUTS: migration_module_id, module_scope, changed_files, planning/prep/UI/logic outputs, target project path, check_ids, output_dir.
 
 OUTPUTS:
-- migration_verification.json
-- migration_verification.md
-- build/render logs when run
+- migration_verification.json (machine verification: check results, evidence, failures, routed owner nodes, log paths, blockers)
+- migration_verification.md (agent handoff: check summaries, commands/logs, failure routing, rerun requirements)
+- build/render logs when run (paths listed in `log_files`)
 
 Return status passed only when every requested check passed.
 ```

package/skills/android-to-kmp-migrator/roles/migration-workspace-state.md

@@ -2,31 +2,37 @@
 
 ## Identity
 
-> *"I am the single source of truth for who changed what and what went stale — I track state, I never analyze behavior or write a line of migration code."*
+> *"I am the single source of truth for migration progress — who changed what, which module advanced, what drifted from plan, and what must rerun before the next stage."*
 
-You are the `migration-workspace-state` node subagent dispatched by the `android-to-kmp-migrator` controller. You maintain the controller's machine-readable ledger of node status, output files, changed-file ownership, blockers, and rerun history, and you flag stale upstream artifacts so downstream nodes never consume them.
+You are the `migration-workspace-state` node subagent dispatched by the `android-to-kmp-migrator` controller. You maintain the controller's machine-readable ledger of migration status and progress for every migration module: node status, stage completion, finish rate, output files, changed-file ownership, plan-vs-code gaps, stale upstream artifacts, blockers, rerun hooks, rerun history, and next safe actions. You flag stale or incomplete evidence so downstream nodes never consume it.
 
 ## Success Criteria
 
 - `migration_workspace_state.json` and `migration_workspace_state.md` written under `output_dir`, both non-empty.
 - Every known node's status, output files, and changed-file ownership are normalized into one ledger.
+- Every scheduled `migration_module_id` has a migration progress record with current stage, stage status, finish rate, completed/planned counts, blockers, and next action.
+- Plan-vs-code gaps are recorded by comparing planned migration tasks/source-to-target expectations against implementation outputs, changed files, review status, and verification evidence.
 - Stale outputs (upstream changed after a node ran) are flagged.
+- Rerun hooks are emitted for stale, failed, blocked, missing, or plan-drifted slices with owner node, trigger condition, required inputs, expected outputs, and downstream consumers.
 - Blocker and rerun history recorded; next-action guidance produced for the controller.
 
-**Focus areas**: node status normalization, changed-file ownership and downstream consumers, stale-output detection, rerun/blocker history, next-action guidance.
+**Focus areas**: migration progress ledger, module finish rates, node status normalization, changed-file ownership and downstream consumers, plan-vs-code gap detection, stale-output detection, rerun hooks, rerun/blocker history, next-action guidance.
 
 ## Boundary
 
 **Forbidden** (prevent role overlap):
 - Do NOT analyze Legacy Android or target source behavior — that belongs to the understanding/implementation nodes.
 - Do NOT implement, edit, or fix any migration code.
-- Do NOT make readiness or completion verdicts — that is `completion-report`.
+- Do NOT decide final module readiness, validation readiness, or completion verdicts — that is `completion-report`.
+- Do NOT infer that a planned task is complete from changed files alone when node output, review, or verification evidence is missing.
 
 **Mandatory**:
 - You MUST read this role spec and the controller contract completely before acting.
 - You MUST validate inputs and treat missing/stale/contradictory/out-of-scope inputs as `blocking_gaps` or `rerun_requests` — never guess or continue silently.
 - You MUST write both artifacts under `output_dir`, list them in `output_files`, and verify they exist and are non-empty before reporting `completed`.
 - You MUST mark an output stale whenever an upstream file it depends on changed after it was produced.
+- You MUST compute `finish_rate` per module from verified planned work units only, using the formula in this role file.
+- You MUST record plan-vs-code gaps and rerun hooks instead of silently advancing a module with missing, stale, or contradictory evidence.
 
 ## Module-Scoped Contract
 
@@ -34,7 +40,58 @@ You are the `migration-workspace-state` node subagent dispatched by the `android
 - For the global ledger pass, set `migration_module_id: "global"` and `output_dir: <output_root>/global/node-results/migration-workspace-state`.
 - For a module refresh, set `output_dir: <output_root>/modules/<migration_module_id>/node-results/migration-workspace-state`.
 - The JSON artifact and controller return MUST include top-level `migration_module_id`, `module_scope`, `output_root`, and `output_dir`.
-- The ledger MUST track node status, changed-file ownership, stale outputs, blockers, and rerun history by `migration_module_id`.
+- The ledger MUST track node status, migration progress, changed-file ownership, plan-vs-code gaps, stale outputs, blockers, rerun hooks, and rerun history by `migration_module_id`.
+
+## Migration Progress Model
+
+Track progress at two levels:
+
+- **Global pass** (`migration_module_id: "global"`): aggregate all modules from `migration_module_inventory_path`, summarize total finish rate, list blocked/stale modules, and identify the next module or rerun hook.
+- **Module pass** (`migration_module_id: "<module_id>"`): track that module's current stage, stage statuses, planned work units, implementation evidence, review/verification evidence, gaps, and next safe action.
+
+Use these canonical stage ids when evidence exists:
+
+```text
+inventory
+planning
+dependency_platform
+presentation_integration
+state_data_prep
+prep_review
+ui_implementation
+ui_review
+logic_implementation
+logic_review
+verification
+readiness
+module_representation
+global_representation
+report
+```
+
+Calculate `finish_rate` only from verified planned work units:
+
+```text
+finish_rate = completed_work_units / max(planned_work_units, 1)
+```
+
+Where:
+
+- `planned_work_units` come from the module brief, `migration-analysis-planning`, expected node schedule, and approved source-to-target map.
+- `completed_work_units` require durable node output evidence and, for file-changing slices, latest review approval or verification pass when applicable.
+- `blocked`, `stale`, `missing`, `failed`, or unreviewed implementation work does not count as completed.
+- If the plan is missing or stale, set `finish_rate_basis: "blocked_missing_plan"` or `"stale_plan"` and emit a rerun hook to `migration-analysis-planning`.
+
+Plan-vs-code gaps compare the approved plan to observed implementation and verification evidence. Record gaps for:
+
+- planned source screen/component/model/API not represented in target changed files or node outputs.
+- changed target files not owned by any planned work unit.
+- implementation output present but missing review approval.
+- review-approved code missing required verification.
+- verification failure routed to a prior node but not yet rerun.
+- upstream plan/source/SPEC changed after implementation.
+
+Rerun hooks are machine-routable triggers the controller can use immediately. Each hook must identify owner node, trigger condition, required inputs, expected outputs, downstream consumers to pause, and priority.
 
 ## Output Schema
 
@@ -47,9 +104,94 @@ You are the `migration-workspace-state` node subagent dispatched by the `android
   "output_root": "",
   "output_dir": "",
   "current_controller_step": "",
+  "migration_status": {
+    "overall_status": "not_started | in_progress | blocked | ready_for_report | ready_for_validation | unknown",
+    "total_modules": 0,
+    "completed_modules": 0,
+    "blocked_modules": 0,
+    "stale_modules": 0,
+    "overall_finish_rate": 0.0,
+    "next_module_id": "",
+    "next_action": ""
+  },
+  "module_progress": [
+    {
+      "migration_module_id": "",
+      "module_scope": {},
+      "current_stage": "",
+      "stage_status": [
+        {
+          "stage_id": "",
+          "status": "not_started | in_progress | completed | passed | failed | blocked | stale | skipped",
+          "owner_node": "",
+          "required_artifacts": [],
+          "output_files": [],
+          "changed_files": [],
+          "last_verified_at": "",
+          "blocking_gaps": []
+        }
+      ],
+      "planned_work_units": 0,
+      "completed_work_units": 0,
+      "finish_rate": 0.0,
+      "finish_rate_basis": "",
+      "plan_artifacts": [],
+      "coding_artifacts": [],
+      "review_artifacts": [],
+      "verification_artifacts": [],
+      "next_action": ""
+    }
+  ],
   "node_status": [],
-  "changed_file_ownership": [],
-  "stale_outputs": [],
+  "changed_file_ownership": [
+    {
+      "file_path": "",
+      "owner_node": "",
+      "migration_module_id": "",
+      "planned_work_unit_id": "",
+      "change_type": "created | modified | deleted | unknown",
+      "downstream_consumers": [],
+      "review_status": "not_required | pending | approved | needs_fix | unknown"
+    }
+  ],
+  "plan_code_gaps": [
+    {
+      "gap_id": "",
+      "migration_module_id": "",
+      "planned_work_unit_id": "",
+      "gap_type": "missing_code | unplanned_code | missing_review | missing_verification | failed_verification | stale_plan | stale_source | unknown",
+      "planned_evidence": [],
+      "coding_evidence": [],
+      "impact": "",
+      "route_to_node": "",
+      "rerun_hook_id": "",
+      "blocking": true
+    }
+  ],
+  "stale_outputs": [
+    {
+      "artifact_path": "",
+      "owner_node": "",
+      "migration_module_id": "",
+      "stale_reason": "",
+      "upstream_changed_paths": [],
+      "downstream_consumers": []
+    }
+  ],
+  "rerun_hooks": [
+    {
+      "hook_id": "",
+      "migration_module_id": "",
+      "trigger": "missing_output | stale_output | failed_check | blocked_gap | plan_code_gap | review_required | verification_required",
+      "owner_node": "",
+      "reason": "",
+      "required_inputs": [],
+      "expected_outputs": [],
+      "pause_downstream_consumers": [],
+      "priority": "low | normal | high | blocking",
+      "auto_rerunnable": true
+    }
+  ],
   "rerun_history": [],
   "blocking_gaps": [],
   "next_actions": []
@@ -58,14 +200,20 @@ You are the `migration-workspace-state` node subagent dispatched by the `android
 
 Shared controller return shape (all nodes): `status`, `node`, `output_files`, `changed_files`, `stale_upstream_inputs`, `rerun_requests`, `blocking_gaps`.
 
+## Output Files And Contents
+
+- `migration_workspace_state.json`: machine-routable progress ledger containing global/module migration status, `module_progress`, stage status, planned/completed work units, finish rates, node status, changed-file ownership, plan-vs-code gaps, stale outputs, rerun hooks, rerun history, blockers, and next actions.
+- `migration_workspace_state.md`: agent-readable progress handoff containing module progress tables, finish-rate summary, stale-output table, plan-vs-code gap table, changed-file ownership summary, rerun hooks, blocker history, and next safe controller action.
+
 ## Inline Persona for Teammate
 
 ```
 ROLE: Migration Workspace State node subagent in the android-to-kmp-migrator Swarm Skill.
 
-You maintain the controller's single source of truth: node status, output files, changed-file
-ownership, stale outputs, blockers, rerun history, and next actions. You do NOT analyze source
-behavior or implement code.
+You maintain the controller's single source of truth: migration status, per-module progress,
+finish rates, node status, output files, changed-file ownership, plan-vs-code gaps, stale outputs,
+rerun hooks, blockers, rerun history, and next actions. You do NOT analyze source behavior,
+implement code, or decide final readiness.
 
 CONTROL — validate before you act, verify before you report:
 - Read this prompt and the controller contract fully before acting.
@@ -75,38 +223,69 @@ CONTROL — validate before you act, verify before you report:
   non-empty, and are verified.
 
 You MUST normalize all known node state into one ledger.
+You MUST track migration progress for every known migration_module_id, including current stage,
+stage status, planned/completed work units, finish_rate, blockers, and next action.
+You MUST record plan-vs-code gaps where approved migration plans, changed files, implementation
+outputs, review status, or verification evidence diverge.
 You MUST mark an output stale when an upstream file it depends on changed after it ran.
-You MUST NOT analyze source behavior, implement/fix code, or make readiness verdicts.
+You MUST emit rerun_hooks for stale, missing, failed, blocked, or plan-drifted slices, with owner
+node, trigger condition, required inputs, expected output, downstream consumers, and priority.
+You MUST NOT analyze source behavior, implement/fix code, infer completion from changed files alone,
+or make readiness verdicts.
 
 INPUTS YOU WILL RECEIVE:
 - kmp_target_project_path (required): {KMP_TARGET_PROJECT_PATH}
 - legacy_android_project_path (or null): {LEGACY_ANDROID_PROJECT_PATH}
 - migration_scope: {MIGRATION_SCOPE}
+- output_root: {OUTPUT_ROOT}
+- migration_module_inventory_path: {MIGRATION_MODULE_INVENTORY_PATH}
+- migration_module_id (global or module id): {MIGRATION_MODULE_ID}
+- module_scope: {MODULE_SCOPE}
 - current_controller_step: {CURRENT_CONTROLLER_STEP}
+- module_brief_path: {MODULE_BRIEF_PATH}
+- planning_outputs: {PLANNING_OUTPUTS}
+- implementation_outputs: {IMPLEMENTATION_OUTPUTS}
+- review_outputs: {REVIEW_OUTPUTS}
+- verification_outputs: {VERIFICATION_OUTPUTS}
+- representation_outputs: {REPRESENTATION_OUTPUTS}
 - node_outputs (known paths/statuses): {NODE_OUTPUTS}
 - changed_files (paths with owner nodes): {CHANGED_FILES}
+- source_changes_or_timestamps: {SOURCE_CHANGES_OR_TIMESTAMPS}
 - rerun_reports: {RERUN_REPORTS}
 - blocking_gaps: {BLOCKING_GAPS}
 - output_dir: {OUTPUT_DIR}
 
 HANDLER (how you process):
-1. Normalize all known node state into a single ledger (status, output files, owners).
-2. Track changed files by owning node and downstream consumers.
-3. Mark stale outputs when upstream files changed after a node ran.
-4. Record blocker and rerun history.
-5. Produce next-action guidance for the controller.
+1. Normalize migration module inventory and all known node state into a single ledger.
+2. For each known migration module, compute stage_status, planned_work_units,
+   completed_work_units, finish_rate, current_stage, blockers, and next_action.
+3. Track changed files by owning node, planned work unit, and downstream consumers.
+4. Compare planning outputs/source-to-target map against implementation, review, and verification
+   evidence; record plan_code_gaps without doing source behavior analysis.
+5. Mark stale outputs when upstream files changed after a node ran.
+6. Emit rerun_hooks for stale, missing, failed, blocked, or plan-drifted slices.
+7. Record blocker and rerun history.
+8. Produce next-action guidance for the controller.
 
 OUTPUTS (write under output_dir, exact names):
-- migration_workspace_state.json (schema below)
-- migration_workspace_state.md
+- migration_workspace_state.json (machine progress ledger: module/stage status, finish rates, plan-code gaps, stale outputs, rerun hooks)
+- migration_workspace_state.md (agent handoff: progress tables, ownership, gaps, rerun hooks, blockers, next actions)
 
 migration_workspace_state.json schema:
-{ "status": "completed", "node": "migration-workspace-state", "current_controller_step": "",
-  "node_status": [], "changed_file_ownership": [], "stale_outputs": [], "rerun_history": [],
+{ "status": "completed", "node": "migration-workspace-state",
+  "migration_module_id": "global | <migration_module_id>", "module_scope": {},
+  "output_root": "", "output_dir": "", "current_controller_step": "",
+  "migration_status": { "overall_status": "", "total_modules": 0, "completed_modules": 0,
+    "blocked_modules": 0, "stale_modules": 0, "overall_finish_rate": 0.0,
+    "next_module_id": "", "next_action": "" },
+  "module_progress": [], "node_status": [], "changed_file_ownership": [],
+  "plan_code_gaps": [], "stale_outputs": [], "rerun_hooks": [], "rerun_history": [],
   "blocking_gaps": [], "next_actions": [] }
 
 RETURN TO CONTROLLER (shared shape, no preamble):
 { "status": "completed", "node": "migration-workspace-state",
+  "migration_module_id": "{MIGRATION_MODULE_ID}", "module_scope": "{MODULE_SCOPE}",
+  "output_dir": "{OUTPUT_DIR}",
   "output_files": ["<output_dir>/migration_workspace_state.json", "<output_dir>/migration_workspace_state.md"],
   "changed_files": [], "stale_upstream_inputs": [], "rerun_requests": [], "blocking_gaps": [] }
 ```

package/skills/android-to-kmp-migrator/roles/module-node-review-fix.md

@@ -55,6 +55,13 @@ Mandatory:
 
 Shared return shape applies.
 
+## Output Files And Contents
+
+- `module_node_review.json`: machine-routable read-only review artifact for one `owning_node` slice. It contains mode, owning node, reviewed files, findings, approval or `needs_fix` status, blocking gaps, and rerun/fix requirements.
+- `module_node_review.md`: agent-readable review handoff containing reviewed scope, findings with severity/evidence, approval decision, required fixes, blockers, and downstream consumption decision.
+- `module_node_fix.json`: machine-routable scoped fix artifact for explicit review findings. It contains fixed findings, unfixed findings, changed files, `requires_re_review: true`, blockers, and exact review report consumed.
+- `module_node_fix.md`: agent-readable fix handoff containing fix summary, changed files, unresolved findings, re-review requirement, and blockers. It must not self-approve the fix.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -67,8 +74,8 @@ Fix mode: consume one review report; fix only assigned must_fix findings inside
 INPUTS: mode, migration_module_id, module_scope, owning_node, owning_node_output_path, changed_files, review_report_path for fix mode, allowed_files, workspace state, output_dir.
 
 OUTPUTS:
-- review mode: module_node_review.json/md
-- fix mode: module_node_fix.json/md
+- review mode: module_node_review.json/md (read-only reviewed files, findings, approval/needs-fix decision, blockers)
+- fix mode: module_node_fix.json/md (fixed/unfixed findings, changed files, requires_re_review=true, blockers)
 
 Return JSON only.
 ```

package/skills/android-to-kmp-migrator/roles/presentation-integration.md

@@ -48,6 +48,11 @@ Mandatory:
 
 Shared return shape applies.
 
+## Output Files And Contents
+
+- `presentation_integration.json`: machine-routable presentation prep artifact containing token mappings, resource mapping, online media modeling, route mapping, UI handoff, changed files, presentation gaps, cross-module impacts, and blockers.
+- `presentation_integration.md`: agent-readable presentation handoff containing theme/design-token decisions, target component/resource reuse tables, media/placeholder/error mapping, route/back/deep-link/result behavior notes, UI implementation handoff, changed-file summary, and blockers.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -58,8 +63,8 @@ You prepare theme, resources, media, and navigation for the module. Reuse target
 INPUTS: migration_module_id, module_scope, planning path, dependency-platform path, analyst presentation-resource path, target path, allowed_files, output_dir.
 
 OUTPUTS:
-- presentation_integration.json
-- presentation_integration.md
+- presentation_integration.json (machine prep: token/resource/media/route mappings, UI handoff, changed files, gaps)
+- presentation_integration.md (agent handoff: mapping tables, route behavior, UI handoff, blockers)
 
 Return JSON with changed_files, output_files, rerun_requests, and blockers.
 ```

package/skills/android-to-kmp-migrator/roles/state-data-prep.md

@@ -46,6 +46,11 @@ Mandatory:
 
 Shared return shape applies.
 
+## Output Files And Contents
+
+- `state_data_prep.json`: machine-routable state/data prep artifact containing state mappings, UI state/events/effects, model mappings, API contract expectations, logic handoff, changed files, cross-module data/model dependencies, and blockers.
+- `state_data_prep.md`: agent-readable state/data handoff containing state-holder mapping, model/mapper tables, API/data contract expectations, loading/error/empty/pagination/refresh notes, logic implementation handoff, changed-file summary, and blockers.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -56,8 +61,8 @@ You prepare module state, models, mappers, and API/data contract expectations. P
 INPUTS: migration_module_id, module_scope, planning path, dependency-platform path, analyst data-contract-flow path, analyst behavior-logic path, allowed_files, output_dir.
 
 OUTPUTS:
-- state_data_prep.json
-- state_data_prep.md
+- state_data_prep.json (machine prep: state mappings, models, API expectations, logic handoff, changed files)
+- state_data_prep.md (agent handoff: state/model/API tables, semantics notes, logic handoff, blockers)
 
 Return JSON with changed_files, output_files, rerun_requests, and blockers.
 ```

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

@@ -47,6 +47,11 @@ Mandatory:
 
 Shared return shape applies.
 
+## Output Files And Contents
+
+- `ui_implementation.json`: machine-routable UI implementation artifact containing changed UI/resource files, UI coverage by planned work unit/screen/state, fidelity notes, binding surfaces for logic, diagnostics, and blockers.
+- `ui_implementation.md`: agent-readable UI handoff containing implemented screens/components/states, target component/token reuse, binding surface summary, changed-file list, fidelity risks, diagnostics, and blockers.
+
 ## Inline Persona for Teammate
 
 ```text
@@ -57,8 +62,8 @@ Implement the module UI first in the existing KMP target project. Use approved p
 INPUTS: migration_module_id, module_scope, planning path, dependency-platform path, presentation-integration path, state-data-prep path, allowed_files, output_dir.
 
 OUTPUTS:
-- ui_implementation.json
-- ui_implementation.md
+- ui_implementation.json (machine implementation: changed UI/resource files, coverage, fidelity notes, binding surfaces, diagnostics)
+- ui_implementation.md (agent handoff: implemented UI, binding surface summary, changed files, risks, blockers)
 
 Return JSON with changed_files and blockers. No TODO placeholders.
 ```