@code-migration/wow-migrator 0.1.0

package/README.md

@@ -0,0 +1,113 @@
+# KMP Skills Installer
+
+Install the KMP migration skills into common AI coding tools through `npm install`.
+
+## Install From This Repo
+
+The package is not published to the npm registry yet. Install it from the local package directory:
+
+```bash
+npm install -g /Users/winson/CodeBase/Online/cli-plugins/npx_skills
+```
+
+Or, from the repository root:
+
+```bash
+npm install -g ./npx_skills
+```
+
+To install from a tarball:
+
+```bash
+cd /Users/winson/CodeBase/Online/cli-plugins/npx_skills
+npm pack
+npm install -g ./code-migration-wow-migrator-0.1.0.tgz
+```
+
+After publishing this package to npm, the registry install command will be:
+
+```bash
+npm install -g @code-migration/wow-migrator
+```
+
+The package runs `postinstall` and installs bundled skills into detected tools.
+Set `KMP_SKILLS_SKIP_POSTINSTALL=1` to skip the automatic install.
+
+## Commands
+
+```bash
+kmp-skills install --yes
+kmp-skills install --target "Claude Code,Codex"
+kmp-skills uninstall --target all --yes
+kmp-skills list
+kmp-skills config
+```
+
+## Supported Targets
+
+| 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` |
+
+## Configuration
+
+The installer creates:
+
+```text
+~/.kmp-skills/config.json
+```
+
+Edit it to add custom tools or paths. The shape is:
+
+```json
+{
+  "tools": [
+    {
+      "name": "Claude Code",
+      "markerDir": "~/.claude",
+      "commands": ["claude"],
+      "skillsDir": "~/.claude/skills"
+    }
+  ]
+}
+```
+
+## Publishing From This Repo
+
+Before packing or publishing, sync the current plugin skills into this package:
+
+```bash
+cd npx_skills
+npm run sync:skills
+npm pack
+```
+
+`prepare` and `prepack` also run the sync script when the monorepo source is available.
+
+Publish with the existing `code-migration` npm org scope:
+
+```bash
+npm publish --access public
+```
+
+If npm returns `E404 Scope not found`, confirm that the npm org exists and the
+current npm user has publish access:
+
+```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
+```

package/bin/kmp-skills.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+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_PATH = path.join(CONFIG_DIR, 'config.json');
+const isWindows = process.platform === 'win32';
+
+function expandHome(input) {
+  if (!input) return input;
+  if (input === '~') return os.homedir();
+  if (input.startsWith('~/') || input.startsWith('~\\')) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+
+function prettyPath(input) {
+  const home = os.homedir();
+  const normalized = input.replace(/\\/g, '/');
+  const normalizedHome = home.replace(/\\/g, '/');
+  return normalized.startsWith(normalizedHome)
+    ? `~${normalized.slice(normalizedHome.length)}`
+    : normalized;
+}
+
+async function pathExists(input) {
+  try {
+    await fs.access(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function dirExists(input) {
+  try {
+    return (await fs.stat(input)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function execFileAsync(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, options, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+async function commandExists(command) {
+  if (!command) return false;
+  const hasPathSeparator = command.includes('/') || command.includes('\\');
+  if (hasPathSeparator) return pathExists(command);
+
+  try {
+    if (isWindows) {
+      await execFileAsync('where', [command], { windowsHide: true });
+    } else {
+      await execFileAsync('sh', ['-c', `command -v ${shellQuote(command)}`]);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function defaultJiuwenCommands() {
+  const home = os.homedir();
+  const bin = isWindows ? 'Scripts' : 'bin';
+  const exe = isWindows ? '.exe' : '';
+  const venv = process.env.VIRTUAL_ENV
+    ? [
+        path.join(process.env.VIRTUAL_ENV, bin, `jiuwenswarm-start${exe}`),
+        path.join(process.env.VIRTUAL_ENV, bin, `jiuwenswarm-acp${exe}`),
+        path.join(process.env.VIRTUAL_ENV, bin, `jiuwenswarm-tui${exe}`)
+      ]
+    : [];
+
+  return [
+    ...venv,
+    'jiuwenswarm-start',
+    'jiuwenswarm-acp',
+    'jiuwenswarm-tui',
+    path.join(home, 'jiuwenclaw', 'bin', `jiuwenswarm-start${exe}`),
+    path.join(home, 'jiuwenclaw', 'bin', `jiuwenswarm-acp${exe}`),
+    path.join(home, 'jiuwenclaw', 'bin', `jiuwenswarm-tui${exe}`)
+  ];
+}
+
+function defaultTools() {
+  return [
+    {
+      name: 'OpenClaw',
+      markerDir: '~/.openclaw',
+      commands: ['openclaw'],
+      skillsDir: '~/.openclaw/skills'
+    },
+    {
+      name: 'Claude Code',
+      markerDir: '~/.claude',
+      commands: ['claude'],
+      skillsDir: '~/.claude/skills'
+    },
+    {
+      name: 'OpenCode',
+      markerDir: '~/.config/opencode',
+      commands: ['opencode'],
+      skillsDir: '~/.config/opencode/skills'
+    },
+    {
+      name: 'Codex',
+      markerDir: '~/.codex',
+      commands: ['codex'],
+      skillsDir: '~/.codex/skills'
+    },
+    {
+      name: 'Cursor',
+      markerDir: '~/.cursor',
+      commands: ['cursor'],
+      skillsDir: '~/.cursor/skills'
+    },
+    {
+      name: 'Gemini',
+      markerDir: '~/.gemini',
+      commands: ['gemini'],
+      skillsDir: '~/.gemini/skills'
+    },
+    {
+      name: 'JiuwenSwarm',
+      markerDir: '~/.jiuwenswarm',
+      commands: defaultJiuwenCommands(),
+      skillsDir: '~/.jiuwenswarm/agent/workspace/skills'
+    }
+  ];
+}
+
+function normalizeTool(raw) {
+  if (!raw || typeof raw !== 'object' || !raw.name) return null;
+  const skillsDir = raw.skillsDir ?? raw.targets?.skillsDir;
+  if (!skillsDir) return null;
+  return {
+    name: String(raw.name),
+    markerDir: raw.markerDir ? String(raw.markerDir) : '',
+    commands: Array.isArray(raw.commands) ? raw.commands.map(String).filter(Boolean) : [],
+    skillsDir: String(skillsDir)
+  };
+}
+
+async function loadConfig(options = {}) {
+  if (!(await pathExists(CONFIG_PATH))) {
+    const config = { tools: defaultTools() };
+    if (options.writeDefault) {
+      await fs.mkdir(CONFIG_DIR, { recursive: true });
+      await fs.writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    }
+    return config;
+  }
+
+  const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+  const parsed = JSON.parse(raw);
+  const sourceTools = Array.isArray(parsed.tools)
+    ? parsed.tools
+    : Array.isArray(parsed.editors)
+      ? parsed.editors
+      : [];
+  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);
+  return { tools: [...merged.values()] };
+}
+
+async function detectTool(tool) {
+  const markerFound = tool.markerDir ? await dirExists(expandHome(tool.markerDir)) : false;
+  const commandFound = (await Promise.all(tool.commands.map(commandExists))).some(Boolean);
+  return {
+    installed: markerFound || commandFound,
+    markerFound,
+    commandFound
+  };
+}
+
+async function findSkillsRoot() {
+  const candidates = [
+    path.join(ROOT, 'skills'),
+    path.join(process.env.INIT_CWD ?? '', 'claude-code-plugins', 'kmp-migration', 'skills'),
+    path.join(ROOT, '..', 'claude-code-plugins', 'kmp-migration', 'skills'),
+    path.join(ROOT, '..', '..', 'claude-code-plugins', 'kmp-migration', 'skills')
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const names = await listSkillNames(candidate);
+    if (names.length > 0) return candidate;
+  }
+  return null;
+}
+
+async function listSkillNames(skillsRoot) {
+  try {
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    const names = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = path.join(skillsRoot, entry.name);
+      if (await pathExists(path.join(skillPath, 'SKILL.md'))) names.push(entry.name);
+    }
+    return names.sort();
+  } catch {
+    return [];
+  }
+}
+
+async function copySkill(skillName, skillsRoot, targetRoot, dryRun) {
+  const source = path.join(skillsRoot, skillName);
+  const target = path.join(targetRoot, skillName);
+  if (dryRun) return;
+  await fs.mkdir(targetRoot, { recursive: true });
+  await fs.rm(target, { recursive: true, force: true });
+  await fs.cp(source, target, { recursive: true });
+}
+
+async function installToTool(tool, skillsRoot, skillNames, dryRun) {
+  const targetRoot = expandHome(tool.skillsDir);
+  for (const skillName of skillNames) {
+    await copySkill(skillName, skillsRoot, targetRoot, dryRun);
+  }
+  return targetRoot;
+}
+
+async function uninstallFromTool(tool, skillNames, dryRun) {
+  const targetRoot = expandHome(tool.skillsDir);
+  let removed = 0;
+  for (const skillName of skillNames) {
+    const target = path.join(targetRoot, skillName);
+    if (await dirExists(target)) {
+      removed++;
+      if (!dryRun) await fs.rm(target, { recursive: true, force: true });
+    }
+  }
+  return removed;
+}
+
+function parseArgs(argv) {
+  const flags = {
+    yes: false,
+    postinstall: false,
+    dryRun: false,
+    targets: null
+  };
+  const positional = [];
+
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    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') {
+      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 {
+      positional.push(arg);
+    }
+  }
+  return { command: positional[0] ?? 'install', flags };
+}
+
+function selectTools(tools, detections, flags) {
+  if (flags.targets?.length) {
+    const wanted = new Set(flags.targets.map((target) => target.toLowerCase()));
+    if (wanted.has('all')) return tools;
+    return tools.filter((tool) => wanted.has(tool.name.toLowerCase()));
+  }
+  if (flags.yes || flags.postinstall) {
+    return tools.filter((tool) => detections.get(tool.name)?.installed);
+  }
+  return tools;
+}
+
+async function confirm(message) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+async function installCommand(flags) {
+  if (process.env.KMP_SKILLS_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}`);
+      return;
+    }
+    throw new Error(message);
+  }
+
+  const skillNames = await listSkillNames(skillsRoot);
+  const { tools } = await loadConfig();
+  const detections = new Map();
+  for (const tool of tools) detections.set(tool.name, await detectTool(tool));
+
+  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`.');
+    return;
+  }
+
+  if (!flags.yes && !flags.postinstall && !flags.dryRun) {
+    const toolList = selectedTools.map((tool) => tool.name).join(', ');
+    const ok = await confirm(`Install ${skillNames.length} KMP skills to: ${toolList}?`);
+    if (!ok) return;
+  }
+
+  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)}`);
+  }
+}
+
+async function uninstallCommand(flags) {
+  const skillsRoot = await findSkillsRoot();
+  const skillNames = skillsRoot ? await listSkillNames(skillsRoot) : [];
+  if (skillNames.length === 0) throw new Error('No bundled skill names found; cannot uninstall safely.');
+
+  const { tools } = await loadConfig();
+  const detections = new Map();
+  for (const tool of tools) detections.set(tool.name, await detectTool(tool));
+  const selectedTools = selectTools(tools, detections, flags);
+
+  if (!flags.yes && !flags.dryRun) {
+    const ok = await confirm(`Remove bundled KMP skills from ${selectedTools.length} target(s)?`);
+    if (!ok) return;
+  }
+
+  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}`);
+  }
+}
+
+async function listCommand() {
+  const skillsRoot = await findSkillsRoot();
+  const skillNames = skillsRoot ? await listSkillNames(skillsRoot) : [];
+  console.log(`Skills root: ${skillsRoot ? prettyPath(skillsRoot) : '(not found)'}`);
+  for (const skillName of skillNames) console.log(`- ${skillName}`);
+}
+
+async function configCommand() {
+  const config = await loadConfig({ writeDefault: true });
+  console.log(`Config path: ${CONFIG_PATH}`);
+  console.log(JSON.stringify(config, null, 2));
+}
+
+function printHelp() {
+  console.log(`kmp-skills
+
+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
+
+Environment:
+  KMP_SKILLS_SKIP_POSTINSTALL=1  Skip npm postinstall auto-install.
+`);
+}
+
+async function main() {
+  const { command, flags } = parseArgs(process.argv.slice(2));
+  if (command === 'help' || command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+  if (command === 'install' || command === 'init') return installCommand(flags);
+  if (command === 'uninstall' || command === 'remove') return uninstallCommand(flags);
+  if (command === 'list') return listCommand();
+  if (command === 'config') return configCommand();
+  throw new Error(`Unknown command: ${command}`);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[kmp-skills] ${message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@code-migration/wow-migrator",
+  "version": "0.1.0",
+  "description": "Install KMP migration skills into Claude Code, Codex, Cursor, Gemini, OpenCode, OpenClaw, and JiuwenSwarm via npm install.",
+  "keywords": [
+    "android",
+    "kmp",
+    "kotlin-multiplatform",
+    "skills",
+    "claude-code",
+    "codex",
+    "cursor",
+    "gemini",
+    "opencode"
+  ],
+  "license": "MIT",
+  "author": "winson-AI",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/winson-AI/cli-plugins.git"
+  },
+  "bin": {
+    "kmp-skills": "bin/kmp-skills.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "skills",
+    "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",
+    "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"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/sync-skills.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ifPresent = process.argv.includes('--if-present');
+
+async function pathExists(input) {
+  try {
+    await fs.access(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listSkillNames(skillsRoot) {
+  try {
+    const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    const names = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (await pathExists(path.join(skillsRoot, entry.name, 'SKILL.md'))) {
+        names.push(entry.name);
+      }
+    }
+    return names.sort();
+  } catch {
+    return [];
+  }
+}
+
+async function findSourceSkillsRoot() {
+  const candidates = [
+    path.join(ROOT, '..', 'claude-code-plugins', 'kmp-migration', 'skills'),
+    path.join(ROOT, '..', '..', 'claude-code-plugins', 'kmp-migration', 'skills'),
+    path.join(process.env.INIT_CWD ?? '', 'claude-code-plugins', 'kmp-migration', 'skills')
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if ((await listSkillNames(candidate)).length > 0) return candidate;
+  }
+  return null;
+}
+
+async function main() {
+  const source = await findSourceSkillsRoot();
+  const target = path.join(ROOT, 'skills');
+
+  if (!source) {
+    if (ifPresent) {
+      console.log('[sync-skills] source skills not found; skipping.');
+      return;
+    }
+    throw new Error('Unable to find claude-code-plugins/kmp-migration/skills.');
+  }
+
+  await fs.rm(target, { recursive: true, force: true });
+  await fs.mkdir(target, { recursive: true });
+
+  const skillNames = await listSkillNames(source);
+  for (const skillName of skillNames) {
+    await fs.cp(path.join(source, skillName), path.join(target, skillName), { recursive: true });
+  }
+
+  console.log(`[sync-skills] synced ${skillNames.length} skills from ${source} -> ${target}`);
+}
+
+main().catch((error) => {
+  console.error(`[sync-skills] ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+});

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

@@ -0,0 +1,37 @@
+# Conversion Note: `android-project-analyst` → 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.
+
+## Source structure (before)
+
+- `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.
+
+## What was lost in the pre-swarm form
+
+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
+
+- **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.
+
+## Content port map
+
+| Source node-spec content | Ported to |
+|---|---|
+| `## Role` first paragraph | role `## Identity` (rewritten as a 1-line motto + context) |
+| `## Specific Task` numbered steps | role `## Inline Persona for Teammate` HANDLER |
+| `## Mandatory Input Validation And Output Storage` | role `## Boundary > Mandatory` + Inline Persona CONTROL block |
+| `Do not:` lists + sibling routing | role `## Boundary > Forbidden` |
+| `## Required Outputs` JSON/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) |
+| 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`.