@code-migration/wow-migrator 0.1.0 → 0.1.2

package/README.md

@@ -1,75 +1,89 @@
-# KMP Skills Installer
+# WOW Migrator
 
-Install the KMP migration skills into common AI coding tools through `npm install`.
+Install Android to Kotlin Multiplatform migration skills into AI coding tools through npm.
 
-## Install From This Repo
-
-The package is not published to the npm registry yet. Install it from the local package directory:
+## Install
 
 ```bash
-npm install -g /Users/winson/CodeBase/Online/cli-plugins/npx_skills
+npm install -g @code-migration/wow-migrator
 ```
 
-Or, from the repository root:
+During `npm install`, the package runs `postinstall` and installs the bundled skills into every supported tool it detects on the machine.
+
+To install the CLI but skip automatic skill installation:
 
 ```bash
-npm install -g ./npx_skills
+WOW_MIGRATOR_SKIP_POSTINSTALL=1 npm install -g @code-migration/wow-migrator
 ```
 
-To install from a tarball:
+## What Gets Installed
 
-```bash
-cd /Users/winson/CodeBase/Online/cli-plugins/npx_skills
-npm pack
-npm install -g ./code-migration-wow-migrator-0.1.0.tgz
-```
+The package bundles these skills:
 
-After publishing this package to npm, the registry install command will be:
+- `android-project-analyst`
+- `android-to-kmp-migrator`
+- `kmp-test-validator`
+
+They are copied into each target tool's `skills` directory. Re-running install is idempotent: the bundled skill directories are replaced with the package version.
+
+## CLI Commands
+
+The primary CLI command is `wow-migrator`.
 
 ```bash
-npm install -g @code-migration/wow-migrator
+wow-migrator install --yes
+wow-migrator install --platform claude --yes
+wow-migrator install --platform cursor,codex --yes
+wow-migrator install --target "Claude Code,Codex"
+wow-migrator uninstall --target all --yes
+wow-migrator list
+wow-migrator config
 ```
 
-The package runs `postinstall` and installs bundled skills into detected tools.
-Set `KMP_SKILLS_SKIP_POSTINSTALL=1` to skip the automatic install.
+## Install By Platform
 
-## Commands
+Use `--platform`, `--target`, or `--tool`. They are aliases and accept a single platform, a comma-separated list, or `all`.
 
 ```bash
-kmp-skills install --yes
-kmp-skills install --target "Claude Code,Codex"
-kmp-skills uninstall --target all --yes
-kmp-skills list
-kmp-skills config
+wow-migrator install --platform claude --yes
+wow-migrator install --platform cursor,codex --yes
+wow-migrator install --platform all --yes
 ```
 
-## Supported Targets
+Supported platforms:
 
-| Tool | Detection | Skills directory |
-| --- | --- | --- |
-| OpenClaw | `~/.openclaw` or `openclaw` | `~/.openclaw/skills` |
-| Claude Code | `~/.claude` or `claude` | `~/.claude/skills` |
-| OpenCode | `~/.config/opencode` or `opencode` | `~/.config/opencode/skills` |
-| Codex | `~/.codex` or `codex` | `~/.codex/skills` |
-| Cursor | `~/.cursor` or `cursor` | `~/.cursor/skills` |
-| Gemini | `~/.gemini` or `gemini` | `~/.gemini/skills` |
-| JiuwenSwarm | `~/.jiuwenswarm` or Jiuwen CLI commands | `~/.jiuwenswarm/agent/workspace/skills` |
+| Platform | Aliases | Detection | Skills directory |
+| --- | --- | --- | --- |
+| OpenClaw | `openclaw`, `open-claw` | `~/.openclaw` or `openclaw` | `~/.openclaw/skills` |
+| Claude Code | `claude`, `claude-code`, `claudecode` | `~/.claude` or `claude` | `~/.claude/skills` |
+| OpenCode | `opencode`, `open-code` | `~/.config/opencode` or `opencode` | `~/.config/opencode/skills` |
+| Codex | `codex`, `openai-codex` | `~/.codex` or `codex` | `~/.codex/skills` |
+| Cursor | `cursor` | `~/.cursor` or `cursor` | `~/.cursor/skills` |
+| Gemini | `gemini`, `gemini-cli` | `~/.gemini` or `gemini` | `~/.gemini/skills` |
+| JiuwenSwarm | `jiuwen`, `jiuwenswarm`, `jiuwen-swarm`, `jiuwenclaw` | `~/.jiuwenswarm` or Jiuwen CLI commands | `~/.jiuwenswarm/agent/workspace/skills` |
 
 ## Configuration
 
-The installer creates:
+View or create the config file:
+
+```bash
+wow-migrator config
+```
+
+The config file is stored at:
 
 ```text
-~/.kmp-skills/config.json
+~/.wow-migrator/config.json
 ```
 
-Edit it to add custom tools or paths. The shape is:
+Edit it to add custom tools, aliases, commands, or skills directories:
 
 ```json
 {
   "tools": [
     {
       "name": "Claude Code",
+      "aliases": ["claude", "claude-code"],
       "markerDir": "~/.claude",
       "commands": ["claude"],
       "skillsDir": "~/.claude/skills"
@@ -78,36 +92,23 @@ Edit it to add custom tools or paths. The shape is:
 }
 ```
 
-## Publishing From This Repo
+## Other Functions
 
-Before packing or publishing, sync the current plugin skills into this package:
+List bundled skills:
 
 ```bash
-cd npx_skills
-npm run sync:skills
-npm pack
+wow-migrator list
 ```
 
-`prepare` and `prepack` also run the sync script when the monorepo source is available.
-
-Publish with the existing `code-migration` npm org scope:
+Remove bundled skills from selected platforms:
 
 ```bash
-npm publish --access public
+wow-migrator uninstall --platform claude,cursor --yes
+wow-migrator uninstall --platform all --yes
 ```
 
-If npm returns `E404 Scope not found`, confirm that the npm org exists and the
-current npm user has publish access:
+Preview an install without writing files:
 
 ```bash
-npm whoami
-npm org ls code-migration
-```
-
-For this package, `npm org ls code-migration` should list your user with owner
-or publish-capable access. After that, publish and install with:
-
-```bash
-npm publish --access public
-npm install -g @code-migration/wow-migrator
+wow-migrator install --platform all --dry-run --yes
 ```

package/bin/{kmp-skills.js → wow-migrator.js}

@@ -8,9 +8,10 @@ import { fileURLToPath } from 'node:url';
 import readline from 'node:readline/promises';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const CONFIG_DIR = path.join(os.homedir(), '.kmp-skills');
+const CONFIG_DIR = path.join(os.homedir(), '.wow-migrator');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
 const isWindows = process.platform === 'win32';
+const CLI_NAME = path.basename(process.argv[1] ?? 'wow-migrator').replace(/\.js$/, '') || 'wow-migrator';
 
 function expandHome(input) {
   if (!input) return input;
@@ -107,42 +108,49 @@ function defaultTools() {
   return [
     {
       name: 'OpenClaw',
+      aliases: ['openclaw', 'open-claw'],
       markerDir: '~/.openclaw',
       commands: ['openclaw'],
       skillsDir: '~/.openclaw/skills'
     },
     {
       name: 'Claude Code',
+      aliases: ['claude', 'claude-code', 'claudecode'],
       markerDir: '~/.claude',
       commands: ['claude'],
       skillsDir: '~/.claude/skills'
     },
     {
       name: 'OpenCode',
+      aliases: ['opencode', 'open-code'],
       markerDir: '~/.config/opencode',
       commands: ['opencode'],
       skillsDir: '~/.config/opencode/skills'
     },
     {
       name: 'Codex',
+      aliases: ['codex', 'openai-codex'],
       markerDir: '~/.codex',
       commands: ['codex'],
       skillsDir: '~/.codex/skills'
     },
     {
       name: 'Cursor',
+      aliases: ['cursor'],
       markerDir: '~/.cursor',
       commands: ['cursor'],
       skillsDir: '~/.cursor/skills'
     },
     {
       name: 'Gemini',
+      aliases: ['gemini', 'gemini-cli'],
       markerDir: '~/.gemini',
       commands: ['gemini'],
       skillsDir: '~/.gemini/skills'
     },
     {
       name: 'JiuwenSwarm',
+      aliases: ['jiuwen', 'jiuwenswarm', 'jiuwen-swarm', 'jiuwenclaw'],
       markerDir: '~/.jiuwenswarm',
       commands: defaultJiuwenCommands(),
       skillsDir: '~/.jiuwenswarm/agent/workspace/skills'
@@ -156,6 +164,7 @@ function normalizeTool(raw) {
   if (!skillsDir) return null;
   return {
     name: String(raw.name),
+    aliases: Array.isArray(raw.aliases) ? raw.aliases.map(String).filter(Boolean) : [],
     markerDir: raw.markerDir ? String(raw.markerDir) : '',
     commands: Array.isArray(raw.commands) ? raw.commands.map(String).filter(Boolean) : [],
     skillsDir: String(skillsDir)
@@ -181,7 +190,11 @@ async function loadConfig(options = {}) {
       : [];
   const userTools = sourceTools.map(normalizeTool).filter(Boolean);
   const merged = new Map(defaultTools().map((tool) => [tool.name, tool]));
-  for (const tool of userTools) merged.set(tool.name, tool);
+  for (const tool of userTools) {
+    const existing = merged.get(tool.name);
+    const aliases = [...new Set([...(existing?.aliases ?? []), ...(tool.aliases ?? [])])];
+    merged.set(tool.name, existing ? { ...existing, ...tool, aliases } : tool);
+  }
   return { tools: [...merged.values()] };
 }
 
@@ -269,10 +282,21 @@ function parseArgs(argv) {
     if (arg === '--yes' || arg === '-y') flags.yes = true;
     else if (arg === '--postinstall') flags.postinstall = true;
     else if (arg === '--dry-run') flags.dryRun = true;
-    else if (arg === '--target' || arg === '--targets') {
+    else if (
+      arg === '--target' ||
+      arg === '--targets' ||
+      arg === '--platform' ||
+      arg === '--platforms' ||
+      arg === '--tool' ||
+      arg === '--tools'
+    ) {
       flags.targets = argv[++index]?.split(',').map((item) => item.trim()).filter(Boolean) ?? [];
     } else if (arg.startsWith('--target=')) {
       flags.targets = arg.slice('--target='.length).split(',').map((item) => item.trim()).filter(Boolean);
+    } else if (arg.startsWith('--platform=')) {
+      flags.targets = arg.slice('--platform='.length).split(',').map((item) => item.trim()).filter(Boolean);
+    } else if (arg.startsWith('--tool=')) {
+      flags.targets = arg.slice('--tool='.length).split(',').map((item) => item.trim()).filter(Boolean);
     } else {
       positional.push(arg);
     }
@@ -280,11 +304,31 @@ function parseArgs(argv) {
   return { command: positional[0] ?? 'install', flags };
 }
 
+function normalizeTargetId(value) {
+  return String(value).toLowerCase().replace(/[\s_-]+/g, '');
+}
+
+function targetIdsForTool(tool) {
+  return [tool.name, ...(tool.aliases ?? []), ...(tool.commands ?? [])]
+    .map(normalizeTargetId)
+    .filter(Boolean);
+}
+
 function selectTools(tools, detections, flags) {
   if (flags.targets?.length) {
-    const wanted = new Set(flags.targets.map((target) => target.toLowerCase()));
+    const wanted = new Set(flags.targets.map(normalizeTargetId));
     if (wanted.has('all')) return tools;
-    return tools.filter((tool) => wanted.has(tool.name.toLowerCase()));
+    const selected = tools.filter((tool) => targetIdsForTool(tool).some((id) => wanted.has(id)));
+    const matched = new Set(selected.flatMap(targetIdsForTool));
+    const unknown = [...wanted].filter((id) => !matched.has(id));
+    if (unknown.length > 0) {
+      const supported = tools
+        .map((tool) => `${tool.name} (${(tool.aliases ?? []).join(', ')})`)
+        .join('; ');
+      console.warn(`[wow-migrator] Unknown platform target(s): ${unknown.join(', ')}`);
+      console.warn(`[wow-migrator] Supported platforms: ${supported}`);
+    }
+    return selected;
   }
   if (flags.yes || flags.postinstall) {
     return tools.filter((tool) => detections.get(tool.name)?.installed);
@@ -303,13 +347,13 @@ async function confirm(message) {
 }
 
 async function installCommand(flags) {
-  if (process.env.KMP_SKILLS_SKIP_POSTINSTALL === '1' && flags.postinstall) return;
+  if (process.env.WOW_MIGRATOR_SKIP_POSTINSTALL === '1' && flags.postinstall) return;
 
   const skillsRoot = await findSkillsRoot();
   if (!skillsRoot) {
     const message = 'No bundled KMP skills found. Run `npm run sync:skills` before publishing this package.';
     if (flags.postinstall) {
-      console.warn(`[kmp-skills] ${message}`);
+      console.warn(`[wow-migrator] ${message}`);
       return;
     }
     throw new Error(message);
@@ -322,7 +366,7 @@ async function installCommand(flags) {
 
   const selectedTools = selectTools(tools, detections, flags);
   if (selectedTools.length === 0) {
-    console.log('[kmp-skills] No supported AI tools detected. Edit config with `kmp-skills config`.');
+    console.log('[wow-migrator] No supported AI tools detected. Edit config with `wow-migrator config`.');
     return;
   }
 
@@ -335,7 +379,7 @@ async function installCommand(flags) {
   for (const tool of selectedTools) {
     const targetRoot = await installToTool(tool, skillsRoot, skillNames, flags.dryRun);
     const detected = detections.get(tool.name)?.installed ? 'detected' : 'custom';
-    console.log(`[kmp-skills] ${flags.dryRun ? 'Would install' : 'Installed'} ${skillNames.length} skills -> ${tool.name} (${detected}) ${prettyPath(targetRoot)}`);
+    console.log(`[wow-migrator] ${flags.dryRun ? 'Would install' : 'Installed'} ${skillNames.length} skills -> ${tool.name} (${detected}) ${prettyPath(targetRoot)}`);
   }
 }
 
@@ -356,7 +400,7 @@ async function uninstallCommand(flags) {
 
   for (const tool of selectedTools) {
     const removed = await uninstallFromTool(tool, skillNames, flags.dryRun);
-    console.log(`[kmp-skills] ${flags.dryRun ? 'Would remove' : 'Removed'} ${removed} skills from ${tool.name}`);
+    console.log(`[wow-migrator] ${flags.dryRun ? 'Would remove' : 'Removed'} ${removed} skills from ${tool.name}`);
   }
 }
 
@@ -374,16 +418,20 @@ async function configCommand() {
 }
 
 function printHelp() {
-  console.log(`kmp-skills
+  console.log(`${CLI_NAME}
 
 Usage:
-  kmp-skills install [--yes] [--target Claude Code,Codex] [--dry-run]
-  kmp-skills uninstall [--yes] [--target all] [--dry-run]
-  kmp-skills list
-  kmp-skills config
+  ${CLI_NAME} install [--yes] [--platform claude,cursor] [--dry-run]
+  ${CLI_NAME} install [--yes] [--target "Claude Code,Codex"] [--dry-run]
+  ${CLI_NAME} uninstall [--yes] [--platform all] [--dry-run]
+  ${CLI_NAME} list
+  ${CLI_NAME} config
+
+Platforms:
+  openclaw, claude, opencode, codex, cursor, gemini, jiuwen, all
 
 Environment:
-  KMP_SKILLS_SKIP_POSTINSTALL=1  Skip npm postinstall auto-install.
+  WOW_MIGRATOR_SKIP_POSTINSTALL=1  Skip npm postinstall auto-install.
 `);
 }
 
@@ -402,6 +450,6 @@ async function main() {
 
 main().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
-  console.error(`[kmp-skills] ${message}`);
+  console.error(`[wow-migrator] ${message}`);
   process.exitCode = 1;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-migration/wow-migrator",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Install KMP migration skills into Claude Code, Codex, Cursor, Gemini, OpenCode, OpenClaw, and JiuwenSwarm via npm install.",
   "keywords": [
     "android",
@@ -18,10 +18,10 @@
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/winson-AI/cli-plugins.git"
+    "url": "git+https://github.com/winson-AI/cli-plugins.git"
   },
   "bin": {
-    "kmp-skills": "bin/kmp-skills.js"
+    "wow-migrator": "bin/wow-migrator.js"
   },
   "files": [
     "bin",
@@ -30,14 +30,22 @@
     "README.md"
   ],
   "scripts": {
-    "install:skills": "node ./bin/kmp-skills.js install",
-    "uninstall:skills": "node ./bin/kmp-skills.js uninstall",
-    "config": "node ./bin/kmp-skills.js config",
-    "list": "node ./bin/kmp-skills.js list",
+    "install:skills": "node ./bin/wow-migrator.js install",
+    "install:all": "node ./bin/wow-migrator.js install --target all --yes",
+    "install:openclaw": "node ./bin/wow-migrator.js install --platform openclaw --yes",
+    "install:claude": "node ./bin/wow-migrator.js install --platform claude --yes",
+    "install:opencode": "node ./bin/wow-migrator.js install --platform opencode --yes",
+    "install:codex": "node ./bin/wow-migrator.js install --platform codex --yes",
+    "install:cursor": "node ./bin/wow-migrator.js install --platform cursor --yes",
+    "install:gemini": "node ./bin/wow-migrator.js install --platform gemini --yes",
+    "install:jiuwen": "node ./bin/wow-migrator.js install --platform jiuwen --yes",
+    "uninstall:skills": "node ./bin/wow-migrator.js uninstall",
+    "config": "node ./bin/wow-migrator.js config",
+    "list": "node ./bin/wow-migrator.js list",
     "sync:skills": "node ./scripts/sync-skills.js",
     "prepare": "node ./scripts/sync-skills.js --if-present",
     "prepack": "node ./scripts/sync-skills.js",
-    "postinstall": "node ./bin/kmp-skills.js install --yes --postinstall"
+    "postinstall": "node ./bin/wow-migrator.js install --yes --postinstall"
   },
   "engines": {
     "node": ">=18.0.0"

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

@@ -1,37 +1,53 @@
-# Conversion Note: `android-project-analyst` → Swarm Skill
+# Conversion Note: `android-project-analyst` → clustered Swarm Skill
 
-This skill was converted from a single controller-support skill (a flat SKILL.md registry plus 7 sibling node-spec files) into a compliant **Swarm Skill** using `swarmskill-creator` convert mode.
+This file records the role-shape history for the `android-project-analyst` skill folder. It is not an active dispatch contract; active node contracts live in [SKILL.md](SKILL.md), [workflow.md](workflow.md), and the files under [roles](roles/).
 
-## Source structure (before)
+## Phase 1 — Controller support skill to Swarm Skill
+
+The skill was first converted from a single controller-support skill (a flat `SKILL.md` registry plus seven sibling node-spec files) into a compliant **Swarm Skill** using `swarmskill-creator` convert mode.
+
+### Source structure before Phase 1
 
 - `SKILL.md` — controller registry describing convert mode, node contracts, dispatch order, and the SPEC output contract.
-- 7 flat node specs at the skill root: `ui-understand.md`, `architecture-pattern.md`, `android-ecosystem.md`, `api-list.md`, `resource-understand.md`, `data-flow.md`, `logic-understand.md`. Each contained Role / Inputs / Mandatory Input Validation & Output Storage / Specific Task / Required Outputs / Return Format / Self-Check.
+- Seven flat node specs at the skill root: `ui-understand.md`, `architecture-pattern.md`, `android-ecosystem.md`, `api-list.md`, `resource-understand.md`, `data-flow.md`, `logic-understand.md`. Each contained Role / Inputs / Mandatory Input Validation & Output Storage / Specific Task / Required Outputs / Return Format / Self-Check.
 
-## What was lost in the pre-swarm form
+### What Phase 1 added
 
 The registry already separated controller from nodes, but it did not encode the team as a first-class artifact: there were no per-role anti-convergence mottos, no `Forbidden`/`Mandatory` boundary blocks the validator could check, no pasteable `Inline Persona` (so each dispatch re-derived the contract by hand), no Mermaid topology making the parallel-then-pipeline shape explicit, and no resource/behavioral guardrails (`max_parallel_teammates`, token/wall-clock budgets, degraded modes). The handoff gates between stages lived only in prose.
 
-## Decomposition
+The seven-role Swarm Skill preserved the source contracts while adding explicit topology, per-role boundaries, self-contained pasteable personas, budgets, and degraded modes.
+
+## Phase 2 — Seven roles to four clustered roles
+
+The second pass analyzed each role's function and duty, found repeated cataloging across adjacent personas, and reduced active dispatch from seven roles to four clustered personas. The full analysis is in [ROLE_CLUSTERING.md](ROLE_CLUSTERING.md).
+
+## Phase 3 — Add workspace-state ledger role
+
+The third pass adds `analysis-workspace-state`, following the ledger pattern used by `android-to-kmp-migrator` and `kmp-test-validator`. This role does not change the four clustered analysis personas. It tracks module/node artifact status, stale upstream inputs, rerun/blocker history, and next safe controller actions so global representations and SPEC files are not built from stale evidence.
 
-- **Pattern: Mixed B + C.** Stage A (`ui-understand`, `architecture-pattern`, `android-ecosystem`, `api-list`) is parallel decomposition (B) over disjoint slices. Stage B (`resource-understand`, `data-flow`) and Stage C (`logic-understand`) form a specialization pipeline (C) with hard handoff gates — each consumes verified upstream outputs and must not rebuild them.
-- **Disjointness check: PASS.** No node's deliverable can substitute for another's — UI surface vs. architecture style vs. platform ecosystem vs. API contracts vs. resources vs. data movement vs. control-flow behavior are mutually exclusive ownership domains, enforced by each role's `## Boundary > Forbidden` naming its siblings.
+## Old-to-new role map
 
-## Content port map
+| Old role(s) | New clustered role | Reason |
+|---|---|---|
+| `ui-understand` + `resource-understand` | `presentation-resource` | Resource usage and migration risk are meaningful only when tied to screens, components, navigation, and UI technology. |
+| `architecture-pattern` + `android-ecosystem` | `project-architecture` | Module topology, architecture style, dependency ecosystem, DI scopes, generated tooling, and Android-only constraints form one project-structure reality check. |
+| `api-list` + `data-flow` | `data-contract-flow` | APIs, local data sources, models, repositories, streams, cache/error behavior, transformations, and write-back paths are one data path. |
+| `logic-understand` | `behavior-logic` | Behavior remains last because user/lifecycle/control-flow analysis requires verified upstream presentation, project, and data evidence. |
+| none (new ledger role) | `analysis-workspace-state` | Workspace-state tracking is cross-cutting and read-only; it prevents stale module/node artifacts from being consumed downstream. |
 
-| Source node-spec content | Ported to |
+## Current decomposition
+
+- **Pattern: Workspace-state + Mixed B + C.** `analysis-workspace-state` is initialized after output-root lock and refreshed after each major artifact group. Stage A (`presentation-resource`, `project-architecture`, `data-contract-flow`) is parallel decomposition (B) over clustered slices. Stage B (`behavior-logic`) is a gated specialization step (C) that consumes verified, non-stale upstream outputs and must not rebuild them.
+- **Boundary check: PASS.** Clustered roles remove the most common duplicate cataloging while preserving distinct ownership: workspace ledger vs. presentation/resource evidence vs. project architecture/ecosystem evidence vs. data contract/flow evidence vs. behavior/control evidence.
+
+## Current content port map
+
+| Contract content | Current location |
 |---|---|
-| `## Role` first paragraph | role `## Identity` (rewritten as a 1-line motto + context) |
-| `## Specific Task` numbered steps | role `## Inline Persona for Teammate` HANDLER |
-| `## Mandatory Input Validation And Output Storage` | role `## Boundary > Mandatory` + Inline Persona CONTROL block |
-| `Do not:` lists + sibling routing | role `## Boundary > Forbidden` |
-| `## Required Outputs` JSON/MD | role `## Output Schema` + Inline Persona OUTPUTS |
-| `## Return Format` | role Inline Persona RETURN TO CONTROLLER |
-| `## Self-Check` | role `## Success Criteria` |
-| Controller dispatch order + verification | `workflow.md` (staged steps + gates) |
+| Active role registry | `SKILL.md` frontmatter |
+| Staged dispatch order + verification | `workflow.md` |
 | Mandatory contract enforcement + agent-only rules | `bind.md` § Behavioral Constraints |
 | Node failure / rerun handling | `bind.md` § Failure Handling |
-| SPEC output contract + MCP context | `SKILL.md` body (preserved) |
-
-## Team-vs-single delta
-
-The conversion preserves every source contract while adding: explicit parallel/pipeline topology with verifiable gates, per-role anti-overlap boundaries that name siblings, self-contained pasteable personas (no re-derivation per dispatch), resource/token/wall-clock budgets, and concrete degraded modes for large monorepos and missing tooling. The same-name controller subagent in `kmp-migration/agents/android-project-analyst.md` is unchanged in behavior; its `Control Nodes` table now points at `roles/<id>.md`.
+| Function/duty analysis and old-to-new map | `ROLE_CLUSTERING.md` |
+| Per-role identity, boundary, schema, and teammate persona | `roles/<clustered-role>.md` |
+| SPEC output contract + MCP context | `SKILL.md` body |