reis-mobile 0.3.5 → 0.4.0

package/bin/reis-mobile.mjs

@@ -4,10 +4,11 @@ import { join } from 'node:path';
 import { parseArgs } from 'node:util';
 
 import { LANGUAGES, configPath, removeConfig, resolveLanguage, saveLanguage } from '../core/config/language.mjs';
+import { resolveProjectDir } from '../core/config/project.mjs';
 import { collectReviewContext } from '../core/context/context-engine.mjs';
 import { detectStack } from '../core/detection/stack-detector.mjs';
 import { runDoctor } from '../core/diagnostics/doctor.mjs';
-import { installClaudePlugin, uninstallClaudePlugin } from '../core/install/claude-plugin.mjs';
+import { runInit } from '../core/install/init.mjs';
 import { PLUGIN_ROOT } from '../core/paths.mjs';
 import { loadRegistry, validateRegistry } from '../core/registry/registry.mjs';
 import { INTENT_IDS } from '../core/router/intents.mjs';
@@ -18,24 +19,25 @@ const USAGE = `reis-mobile — AI agents for mobile engineering
 Usage: reis-mobile <command> [options]
 
 Commands:
-  init [en|pt]               Install the reis-mobile plugin into Claude Code, optionally setting the language
+  init [en|pt]               Install the reis-mobile plugin into Claude Code and Codex, optionally setting the language
   lang [en|pt]               Show or set the language the /reis-mobile commands answer in
   detect                     Detect the mobile stack of a project
   doctor                     Diagnose the environment for the detected stack
   route <prompt...>          Show which intent, agent and skills a prompt resolves to
   review [prompt...]         Route a code review and collect the git context for it
+  debug [problem...]         Route a build or runtime failure and report the toolchain it runs on
   agents | skills | stacks   List registered components
   validate                   Validate the plugin's agents, skills and stacks
 
 Options:
-  --dir <path>      Project directory (default: current directory)
+  --dir <path>      Project directory (default: current directory, or "app" in .reis-mobile/config.yaml)
   --intent <id>     Force an intent (${INTENT_IDS.join(', ')})
   --base <ref>      review: compare <ref>...HEAD instead of the working tree
   --all             doctor: check every tool, not only the relevant ones
   --strict          doctor: exit with code 1 when there are warnings
   --local           init: install the plugin from this installation instead of GitHub
-  --scope <scope>   init: user (default), project or local
-  --uninstall       init: remove the plugin, its marketplace and the saved language
+  --scope <scope>   init: Claude Code scope, user (default), project or local
+  --uninstall       init: remove the plugin and its marketplace from Claude Code and Codex, and the saved language
   --lang <en|pt>    Override the saved language for this run
   --json            Machine-readable output
   -v, --version     Print the version
@@ -63,6 +65,7 @@ const COMMANDS = {
   doctor: commandDoctor,
   route: commandRoute,
   review: commandReview,
+  debug: commandDebug,
   agents: (options) => commandList('agents', options),
   skills: (options) => commandList('skills', options),
   stacks: (options) => commandList('stacks', options),
@@ -88,31 +91,46 @@ async function main(argv) {
     console.error(`Unknown command "${name}".\n\n${USAGE}`);
     return 1;
   }
-  return (await command({ ...options, dir: options.dir ?? process.cwd(), prompt: rest.join(' ') })) ?? 0;
+  const dir = options.dir ?? process.cwd();
+  // Commands that analyze a project honor `app:` from .reis-mobile/config.yaml.
+  const project = PROJECT_COMMANDS.has(name) ? resolveProjectDir(dir) : { projectDir: dir, config: null, warnings: [] };
+  for (const warning of project.warnings) console.error(`! ${warning}`);
+
+  return (await command({ ...options, dir: project.projectDir, project, prompt: rest.join(' ') })) ?? 0;
 }
 
+const PROJECT_COMMANDS = new Set(['detect', 'doctor', 'route', 'review', 'debug']);
+
 async function commandInit({ local, scope, uninstall, lang, prompt }) {
-  // The installers pass the language through REIS_MOBILE_LANG.
   const requested = lang ?? (prompt || process.env.REIS_MOBILE_LANG || undefined);
-  // Validate before touching Claude Code, so a typo does not leave a half-done install.
+  // Validate before touching Claude Code or Codex, so a typo does not leave a half-done install.
   if (requested && !uninstall) await resolveLanguage({ flag: requested, env: {} });
 
-  const result = uninstall
-    ? uninstallClaudePlugin({ scope })
-    : installClaudePlugin({ scope, ...(local && { source: PLUGIN_ROOT }) });
+  const { ok, results } = runInit({ uninstall, scope, ...(local && { source: PLUGIN_ROOT }) });
+
+  console.log('');
+  for (const result of results) {
+    if (result.skipped) console.log(`- ${result.name.padEnd(12)}not found, skipped`);
+    else if (result.ok) console.log(`✓ ${result.name.padEnd(12)}${uninstall ? 'removed' : 'installed'}`);
+    else console.error(`✗ ${result.name.padEnd(12)}${result.failedStep} failed (exit ${result.status})`);
+  }
 
-  if (!result.ok) {
-    console.error(`✗ ${result.failedStep} failed (exit ${result.status})`);
+  if (!results.some((result) => !result.skipped)) {
+    console.error('\nNeither Claude Code nor Codex was found in PATH. Install one of them and run `reis-mobile init` again.');
     return 1;
   }
   if (uninstall) {
     await removeConfig();
-    console.log('✓ reis-mobile removed from Claude Code');
-    return 0;
+    console.log(`✓ ${'Language'.padEnd(12)}saved setting removed`);
+    return ok ? 0 : 1;
   }
-  if (requested) console.log(`✓ Language: ${await saveLanguage(requested)} (${configPath()})`);
-  console.log('✓ reis-mobile installed in Claude Code. Restart Claude Code, then run /reis-mobile:doctor');
-  return 0;
+  if (requested && results.some((result) => result.ok)) {
+    console.log(`✓ ${'Language'.padEnd(12)}${await saveLanguage(requested)} (${configPath()})`);
+  }
+  if (results.some((result) => result.ok)) {
+    console.log('\nRestart Claude Code or Codex. In Claude Code, run /reis-mobile:doctor.');
+  }
+  return ok ? 0 : 1;
 }
 
 async function commandLang({ prompt, json }) {
@@ -128,10 +146,12 @@ async function commandLang({ prompt, json }) {
   return 0;
 }
 
-async function commandDetect({ dir, json, lang }) {
+async function commandDetect({ dir, project, json, lang }) {
   const detection = await detectStack(dir);
   const language = await resolveLanguage({ flag: lang });
-  if (json) return print({ ...detection, language });
+  if (json) return print({ ...detection, language, projectConfig: project.config?.path ?? null });
+
+  printProject(project);
 
   console.log(`Stack       ${detection.stack}${detection.variant ? ` (${detection.variant})` : ''}`);
   console.log(`Languages   ${detection.languages.join(', ') || '-'}`);
@@ -143,47 +163,54 @@ async function commandDetect({ dir, json, lang }) {
   return detection.stack === 'unknown' ? 2 : 0;
 }
 
-async function commandDoctor({ dir, all, strict, json, lang }) {
+async function commandDoctor({ dir, project, all, strict, json, lang }) {
   const report = await runDoctor({ projectDir: dir, all });
   const language = await resolveLanguage({ flag: lang });
   if (json) {
-    print({ ...report, language });
+    print({ ...report, language, projectConfig: project.config?.path ?? null });
   } else {
     console.log('reis-mobile doctor\n');
-    for (const [section, title] of [['environment', 'Environment'], ['project', 'Project'], ['integrations', 'Integrations']]) {
-      const checks = report.checks.filter((check) => check.section === section);
-      if (!checks.length) continue;
-      console.log(`${title}\n${'-'.repeat(title.length)}`);
-      for (const check of checks) console.log(`${check.label.padEnd(16)}${SYMBOLS[check.status]} ${check.detail ?? ''}`.trimEnd());
-      console.log('');
-    }
+    printProject(project);
+    printDoctorChecks(report);
     console.log(report.warnings ? `${report.warnings} warning(s)` : 'No issues found');
     printLanguage(language);
   }
   return strict && report.warnings ? 1 : 0;
 }
 
+function printDoctorChecks(report) {
+  for (const [section, title] of [['environment', 'Environment'], ['project', 'Project'], ['integrations', 'Integrations']]) {
+    const checks = report.checks.filter((check) => check.section === section);
+    if (!checks.length) continue;
+    console.log(`${title}\n${'-'.repeat(title.length)}`);
+    for (const check of checks) console.log(`${check.label.padEnd(16)}${SYMBOLS[check.status]} ${check.detail ?? ''}`.trimEnd());
+    console.log('');
+  }
+}
+
 const SYMBOLS = { ok: '✓', warning: '✗', info: '-', skipped: '-' };
 
-async function commandRoute({ dir, intent, prompt, json, lang }) {
+async function commandRoute({ dir, project, intent, prompt, json, lang }) {
   if (!prompt && !intent) {
     console.error('route needs a prompt or --intent.');
     return 1;
   }
   const result = await route({ prompt, intent, projectDir: dir });
   const language = await resolveLanguage({ flag: lang });
-  if (json) return print({ ...summarizeRoute(result), language });
+  if (json) return print({ ...summarizeRoute(result), language, projectConfig: project.config?.path ?? null });
+  printProject(project);
   printRoute(result);
   printLanguage(language);
   return 0;
 }
 
-async function commandReview({ dir, base, prompt, json, lang }) {
+async function commandReview({ dir, project, base, prompt, json, lang }) {
   const result = await route({ prompt, intent: 'review', projectDir: dir });
   const context = collectReviewContext({ projectDir: dir, base });
   const language = await resolveLanguage({ flag: lang });
-  if (json) return print({ ...summarizeRoute(result), language, context });
+  if (json) return print({ ...summarizeRoute(result), language, projectConfig: project.config?.path ?? null, context });
 
+  printProject(project);
   printRoute(result);
   printLanguage(language);
   console.log(`\nContext     ${context.mode}${context.base ? ` (${context.base}...HEAD)` : ''}`);
@@ -193,6 +220,24 @@ async function commandReview({ dir, base, prompt, json, lang }) {
   return 0;
 }
 
+/**
+ * Routes a failure to the debug agent and skills, and adds the doctor report: most build
+ * failures are toolchain mismatches (JDK, Gradle, Xcode, CocoaPods), which the report shows.
+ */
+async function commandDebug({ dir, project, prompt, json, lang }) {
+  const result = await route({ prompt, intent: 'debug', projectDir: dir });
+  const doctor = await runDoctor({ projectDir: dir });
+  const language = await resolveLanguage({ flag: lang });
+  if (json) return print({ ...summarizeRoute(result), language, projectConfig: project.config?.path ?? null, doctor });
+
+  printProject(project);
+  printRoute(result);
+  printLanguage(language);
+  console.log('');
+  printDoctorChecks(doctor);
+  return 0;
+}
+
 async function commandList(kind, { json }) {
   const registry = await loadRegistry();
   const items = registry[kind];
@@ -235,6 +280,11 @@ function printRoute(result) {
   for (const warning of result.warnings) console.log(`! ${warning}`);
 }
 
+/** Only printed when .reis-mobile/config.yaml moved the command to another folder. */
+function printProject({ projectDir, config }) {
+  if (config?.data.app !== undefined) console.log(`Project     ${projectDir} (app from ${config.path})`);
+}
+
 /** `-` means no saved language: the commands follow the language of the request. */
 function printLanguage(language) {
   console.log(`Language    ${language ?? '-'}`);

package/commands/debate.md

@@ -39,6 +39,15 @@ Choose **three** agents whose priorities genuinely conflict on the question. A d
 | `reis-mobile:flutter-architect` | Layer boundaries, modularization, long-term maintenance cost | `opus` |
 | `reis-mobile:flutter-performance-engineer` | Frames, rebuilds, memory, startup time — hostile to indirection | `sonnet` |
 | `reis-mobile:flutter-test-engineer` | Testability, injection seams, coverage cost | `sonnet` |
+| `reis-mobile:android-architect` | Native Android layers, Gradle modularization, long-term maintenance cost | `opus` |
+| `reis-mobile:android-performance-engineer` | Recomposition, ANRs, startup, memory — hostile to indirection | `sonnet` |
+| `reis-mobile:android-test-engineer` | Testability, injected dispatchers and fakes, coverage cost | `sonnet` |
+| `reis-mobile:ios-architect` | Native iOS structure, packages, concurrency isolation | `opus` |
+| `reis-mobile:ios-performance-engineer` | Hangs, view updates, launch time, retain cycles | `sonnet` |
+| `reis-mobile:ios-test-engineer` | Testability, protocol seams, coverage cost | `sonnet` |
+| `reis-mobile:rn-architect` | Feature boundaries, server vs client state, native module isolation | `opus` |
+| `reis-mobile:rn-performance-engineer` | Re-renders, lists, JavaScript thread, startup | `sonnet` |
+| `reis-mobile:rn-test-engineer` | Testability through the UI, mocks at boundaries, coverage cost | `sonnet` |
 | `reis-mobile:plugin-native-expert` | Flutter–native boundary, platform channels, lifecycle | `opus` |
 | `reis-mobile:mobile-staff-engineer` | Build, release, migration, cross-platform trade-offs | `opus` |
 | `reis-mobile:mobile-code-reviewer` | Concrete risk in the code that already exists | `sonnet` |
@@ -49,7 +58,7 @@ Automatic selection must end with **at least two different models** among the pa
 
 Selection rules:
 
-- The detected stack rules. The `flutter-*` agents only join Flutter projects; in native Android or iOS, use `mobile-staff-engineer` and `mobile-code-reviewer`.
+- The detected stack rules. The `flutter-*` agents only join Flutter projects, `android-*` native Android, `ios-*` native iOS and `rn-*` React Native. Pick the architect, performance and test specialists of the detected stack first; `mobile-staff-engineer` and `mobile-code-reviewer` fit any stack.
 - Without native code in the project, do not call `plugin-native-expert`.
 - `--agents` overrides the automatic choice, but not the models: each agent keeps the one from the table. Unknown name: warn and stop.
 - `reis-mobile:lead-mobile` never debates — it moderates in step 7, always on `opus`, because synthesizing conflicting positions is the heaviest work in the flow.

package/commands/debug.md

@@ -0,0 +1,60 @@
+---
+description: Mobile debugging — routes a build or runtime failure (Gradle, Xcode, CocoaPods, Flutter) to the right agent and skills, finds the cause with evidence and proposes the fix
+argument-hint: "<error message, failing command or description of the problem>"
+allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Bash(flutter:*)", "Bash(dart:*)", "Bash(./gradlew:*)", "Bash(xcodebuild:*)", "Bash(pod:*)", "Bash(java:*)", "Read", "Grep", "Glob"]
+---
+
+# reis-mobile debug
+
+Arguments received: `$ARGUMENTS`
+
+The arguments are the problem: an error message, the command that fails, or a description. Without them, ask the user for the failing command and its full output, and stop. A debug session without the actual error guesses; one with it verifies.
+
+## 1. Route and gather the toolchain
+
+Run via Bash, with correct quoting:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" debug --dir "$PWD" -- "<problem>"
+```
+
+The output reports:
+
+- `Project`, when `.reis-mobile/config.yaml` points the command at an app folder;
+- `Intent`, `Stack`, `focus` and `area` (`gradle`, `xcode`, `cocoapods`, `signing`, `pub`...);
+- `Agent` and `Skills`, in priority order;
+- `Language`, the language to answer in (see **Language**);
+- the doctor checks: installed tools and their versions, lock files, Gradle wrapper, iOS deployment target.
+
+If the command fails, show the error to the user and stop.
+
+## Language
+
+The CLI output has a `Language` line. Write everything the user reads in that language: `en` is English, `pt` is Brazilian Portuguese. With `-`, use the language of the user's request. Code, identifiers, file paths, commands and quoted tool output stay as they are.
+
+## 2. Load the instructions
+
+Read with the Read tool, in this order:
+
+1. `${CLAUDE_PLUGIN_ROOT}/agents/<Agent>.md`;
+2. `${CLAUDE_PLUGIN_ROOT}/skills/<skill>/SKILL.md` for each listed skill. The first skills are the most specific to the stack and area; read them all, since a failure often crosses layers (a Flutter build that fails inside Gradle).
+
+## 3. Diagnose
+
+Follow the agent's process and the skills' checklists:
+
+1. **Find the first real error.** Build logs bury it under cascading failures. Quote the line that starts the failure, not the last `BUILD FAILED`.
+2. **Read the files that decide the behavior** before forming a theory: build scripts, wrapper and lock files, manifests, `Info.plist`, `Podfile`, project settings. Compare versions against the doctor output — a mismatch between the JDK, Gradle, AGP, Kotlin, Xcode or CocoaPods is the most common cause.
+3. **Reproduce when it is safe.** Read-only commands can run: `./gradlew --version`, `flutter --version`, `pod --version`, `xcodebuild -version`, `./gradlew :app:dependencies`. A build that only compiles (`./gradlew assembleDebug`, `flutter build apk --debug`) can run if the user already ran it or agrees, since it takes time and writes build outputs.
+4. **Confirm the cause** with evidence at `file:line` or in the log. If two causes are plausible, say which evidence would separate them instead of picking one.
+
+## 4. Propose, then wait
+
+Answer with:
+
+- **Cause:** one or two sentences, with the evidence.
+- **Fix:** the minimal change, as a diff or the exact commands, in the order to apply them.
+- **Why it works**, and what it changes beyond the error (a Gradle or Kotlin upgrade, a new minimum iOS version).
+- **How to verify:** the command that failed, run again.
+
+Do not edit files or run commands that change the project or the machine — `flutter clean`, `pod install`, `pod repo update`, deleting `DerivedData` or `~/.gradle` caches, dependency upgrades — until the user asks you to apply the fix. Once they do, apply it, run the verification command and report the result.

package/commands/reis-mobile.md

@@ -1,6 +1,6 @@
 ---
-description: reis-mobile entry point — lists the commands or forwards to doctor, review, debate or the right agent from a free-form request
-argument-hint: "[doctor | review | debate | free-form request]"
+description: reis-mobile entry point — lists the commands or forwards to doctor, review, debug, debate or the right agent from a free-form request
+argument-hint: "[doctor | review | debug | debate | free-form request]"
 allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Read", "Grep", "Glob"]
 ---
 
@@ -21,6 +21,7 @@ Reply only with this list. The only thing to run is `node "${CLAUDE_PLUGIN_ROOT}
 ```text
 /reis-mobile:doctor                  Environment and project: SDKs, Xcode, CocoaPods, Gradle wrapper, lock files
 /reis-mobile:review [--base <ref>]   Code review of the changes (or the whole project)
+/reis-mobile:debug <problem>         Finds the cause of a build or runtime failure and proposes the fix
 /reis-mobile:debate <question>       Debate between the specialists, with a decision by lead-mobile
 /reis-mobile <free-form request>     Forwards the request to the agent and skills for the detected stack
 ```
@@ -36,6 +37,10 @@ When the language is `pt`, translate the descriptions and keep the commands as t
 
 Read `${CLAUDE_PLUGIN_ROOT}/commands/review.md` and follow all of it, treating the rest of the arguments (without the word `review`) as `$ARGUMENTS`.
 
+## `debug <problem>`
+
+Read `${CLAUDE_PLUGIN_ROOT}/commands/debug.md` and follow all of it, treating the rest of the arguments (without the word `debug`) as `$ARGUMENTS`.
+
 ## `debate [options] <question>`
 
 Read `${CLAUDE_PLUGIN_ROOT}/commands/debate.md` and follow all of it, treating the rest of the arguments (without the word `debate`) as `$ARGUMENTS`.

package/core/config/project.mjs

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+
+import { parseYamlSubset } from '../registry/frontmatter.mjs';
+
+export const PROJECT_CONFIG = join('.reis-mobile', 'config.yaml');
+
+const KNOWN_KEYS = new Set(['app']);
+
+/**
+ * Finds the nearest `.reis-mobile/config.yaml`, starting at `dir` and walking up, so a
+ * command run anywhere inside a monorepo sees the same settings.
+ *
+ * @returns {{ path: string, root: string, data: object } | null}
+ */
+export function findProjectConfig(dir) {
+  let current = resolve(dir);
+  for (;;) {
+    const path = join(current, PROJECT_CONFIG);
+    if (existsSync(path)) return { path, root: current, data: parseYamlSubset(readFileSync(path, 'utf8')) };
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+/**
+ * The directory commands should analyze. `app: apps/mobile` points a monorepo at its
+ * mobile app, relative to the folder that holds `.reis-mobile/`. A `dir` already inside
+ * the app is kept, so running from `apps/mobile/lib` still works.
+ *
+ * @returns {{ projectDir: string, config: object|null, warnings: string[] }}
+ */
+export function resolveProjectDir(dir) {
+  const requested = resolve(dir);
+  const config = findProjectConfig(requested);
+  if (!config) return { projectDir: requested, config: null, warnings: [] };
+
+  const warnings = Object.keys(config.data)
+    .filter((key) => !KNOWN_KEYS.has(key))
+    .map((key) => `${config.path}: unknown key "${key}" ignored`);
+
+  const { app } = config.data;
+  if (app === undefined) return { projectDir: requested, config, warnings };
+  if (typeof app !== 'string' || !app.trim() || isAbsolute(app)) {
+    throw new Error(`${config.path}: "app" must be a folder relative to ${config.root}, such as "apps/mobile"`);
+  }
+
+  const appDir = resolve(config.root, app);
+  if (!existsSync(appDir) || !statSync(appDir).isDirectory()) {
+    throw new Error(`${config.path}: app folder "${app}" does not exist`);
+  }
+  return { projectDir: isInside(requested, appDir) ? requested : appDir, config, warnings };
+}
+
+function isInside(child, parent) {
+  const path = relative(parent, child);
+  return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+}

package/core/install/codex-plugin.mjs

@@ -0,0 +1,66 @@
+import { spawnSync } from 'node:child_process';
+
+import { LEGACY_PLUGIN_IDS, MARKETPLACE_NAME, MARKETPLACE_URL, PLUGIN_ID } from './claude-plugin.mjs';
+
+/**
+ * Registers the reis-mobile marketplace and installs the plugin through the `codex` CLI.
+ *
+ * `marketplace add` and `plugin add` are idempotent in Codex. `marketplace upgrade` only
+ * accepts Git marketplaces, so it is skipped for a local `source`; it refreshes a snapshot
+ * that predates the latest release, which otherwise fails with "not found in marketplace".
+ */
+export function installCodexPlugin({ source = MARKETPLACE_URL, run = runCodex, list = listCodexPlugins } = {}) {
+  const result = runSteps(run, [
+    ['plugin', 'marketplace', 'add', source],
+    ...(isGitSource(source) ? [['plugin', 'marketplace', 'upgrade', MARKETPLACE_NAME]] : []),
+    ['plugin', 'add', PLUGIN_ID],
+  ]);
+  if (!result.ok) return result;
+  const installed = list().plugins;
+  return runSteps(run, LEGACY_PLUGIN_IDS.filter((id) => installed.includes(id)).map((id) => ['plugin', 'remove', id]));
+}
+
+/** `marketplace remove` fails when the marketplace is not configured, so it only runs when it is. */
+export function uninstallCodexPlugin({ run = runCodex, list = listCodexPlugins } = {}) {
+  const { plugins, marketplaces } = list();
+  return runSteps(run, [
+    ...[PLUGIN_ID, ...LEGACY_PLUGIN_IDS].filter((id) => plugins.includes(id)).map((id) => ['plugin', 'remove', id]),
+    ...(marketplaces.includes(MARKETPLACE_NAME) ? [['plugin', 'marketplace', 'remove', MARKETPLACE_NAME]] : []),
+  ]);
+}
+
+function isGitSource(source) {
+  return /^(https?:\/\/|git@|ssh:\/\/)/.test(source);
+}
+
+function runSteps(run, steps) {
+  for (const args of steps) {
+    const status = run(args);
+    if (status !== 0) return { ok: false, failedStep: `codex ${args.join(' ')}`, status };
+  }
+  return { ok: true };
+}
+
+function runCodex(args) {
+  const result = spawnSync('codex', args, { stdio: 'inherit', shell: process.platform === 'win32' });
+  if (result.error) throw result.error;
+  return result.status ?? 1;
+}
+
+/** Installed plugin ids and configured marketplace names. Unreadable output means neither. */
+function listCodexPlugins() {
+  return {
+    plugins: readJson(['plugin', 'list', '--json'], (data) => data.installed.map((plugin) => plugin.pluginId)),
+    marketplaces: readJson(['plugin', 'marketplace', 'list', '--json'], (data) => data.marketplaces.map((marketplace) => marketplace.name)),
+  };
+}
+
+function readJson(args, pick) {
+  const result = spawnSync('codex', args, { encoding: 'utf8', shell: process.platform === 'win32' });
+  if (result.status !== 0) return [];
+  try {
+    return pick(JSON.parse(result.stdout));
+  } catch {
+    return [];
+  }
+}

package/core/install/init.mjs

@@ -0,0 +1,46 @@
+import { spawnSync } from 'node:child_process';
+
+import { installClaudePlugin, uninstallClaudePlugin } from './claude-plugin.mjs';
+import { installCodexPlugin, uninstallCodexPlugin } from './codex-plugin.mjs';
+
+/** Every tool `reis-mobile init` registers the plugin in, when its CLI is on the PATH. */
+export const TARGETS = [
+  {
+    id: 'claude',
+    name: 'Claude Code',
+    bin: 'claude',
+    install: ({ source, scope }) => installClaudePlugin({ source, scope }),
+    uninstall: ({ scope }) => uninstallClaudePlugin({ scope }),
+  },
+  {
+    id: 'codex',
+    name: 'Codex',
+    bin: 'codex',
+    install: ({ source }) => installCodexPlugin({ source }),
+    uninstall: () => uninstallCodexPlugin(),
+  },
+];
+
+/**
+ * Installs (or removes) the plugin in each tool that is available, and never stops at the
+ * first failure: one broken tool must not keep the plugin out of the other.
+ *
+ * Returns one entry per target: `skipped` when its CLI is missing, otherwise `ok` plus the
+ * failing step. `ok` is false overall when a tool failed or none was found.
+ */
+export function runInit({ uninstall = false, source, scope = 'user', targets = TARGETS, exists = commandExists } = {}) {
+  const results = targets.map((target) => {
+    if (!exists(target.bin)) return { id: target.id, name: target.name, skipped: true };
+    const options = { scope, ...(source && { source }) };
+    const result = uninstall ? target.uninstall(options) : target.install(options);
+    return { id: target.id, name: target.name, ...result };
+  });
+  const ran = results.filter((result) => !result.skipped);
+  return { ok: ran.length > 0 && ran.every((result) => result.ok), results };
+}
+
+export function commandExists(bin) {
+  const result = spawnSync(bin, ['--version'], { stdio: 'ignore', shell: process.platform === 'win32' });
+  // Through a Windows shell a missing command is exit code 1 (cmd) instead of ENOENT.
+  return !result.error && !(process.platform === 'win32' && result.status !== 0);
+}

package/core/registry/frontmatter.mjs

@@ -1,9 +1,10 @@
 // Minimal YAML frontmatter parser, dependency-free on purpose: the plugin must run
 // straight from the Claude Code plugin cache without `npm install`.
 //
-// Supported subset: `key: scalar`, `key: [a, b]`, block lists (`key:` followed by
-// `  - item` lines) and block scalars (`key: |`, `|-`, `>`, `>-`). Nested maps, such as
-// the `metadata:` block of upstream skills, are skipped.
+// Supported subset: `key: scalar` (continued on indented lines, as YAML folds plain
+// scalars), `key: [a, b]`, block lists (`key:` followed by `  - item` lines) and block
+// scalars (`key: |`, `|-`, `>`, `>-`). Nested maps, such as the `metadata:` block of
+// upstream skills, are skipped.
 
 const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)([\s\S]*)$/;
 const BLOCK_SCALAR = /^([|>])([+-]?)$/;
@@ -14,10 +15,12 @@ export function parseFrontmatter(source) {
   return { data: parseYamlSubset(match[1]), body: match[2] };
 }
 
-function parseYamlSubset(text) {
+/** Parses the same YAML subset outside frontmatter, for `.reis-mobile/config.yaml`. */
+export function parseYamlSubset(text) {
   const data = {};
   const lines = text.split(/\r?\n/);
   let listKey = null;
+  let plainKey = null;
 
   for (let index = 0; index < lines.length; index++) {
     const line = lines[index];
@@ -29,11 +32,17 @@ function parseYamlSubset(text) {
       continue;
     }
 
+    if (plainKey && /^\s+\S/.test(line)) {
+      data[plainKey] = `${data[plainKey]} ${line.trim()}`;
+      continue;
+    }
+
     const pair = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
     if (!pair) continue;
 
     const [, key, value] = pair;
     listKey = null;
+    plainKey = null;
     const block = BLOCK_SCALAR.exec(value);
 
     if (block) {
@@ -47,6 +56,8 @@ function parseYamlSubset(text) {
       listKey = key;
     } else {
       data[key] = parseValue(value);
+      // Only an unquoted scalar can continue on the next lines.
+      if (typeof data[key] === 'string' && !/^["'[]/.test(value)) plainKey = key;
     }
   }
   return data;

package/core/registry/registry.mjs

@@ -3,11 +3,21 @@ import { basename, join } from 'node:path';
 
 import { DETECTABLE_STACKS } from '../detection/stack-detector.mjs';
 import { PLUGIN_ROOT } from '../paths.mjs';
-import { INTENT_IDS } from '../router/intents.mjs';
+import { AREA_IDS, INTENT_IDS } from '../router/intents.mjs';
 import { parseFrontmatter } from './frontmatter.mjs';
 
 export const ANY_STACK = '*';
 
+/** Every skill name starts with the prefix of the first stack it declares. */
+export const SKILL_PREFIXES = {
+  [ANY_STACK]: ['mobile-'],
+  flutter: ['flutter-'],
+  android: ['android-'],
+  ios: ['ios-'],
+  'react-native': ['rn-'],
+  'kotlin-multiplatform': ['kmp-'],
+};
+
 /**
  * Loads stacks (`stacks/<id>/stack.json`), agents (`agents/<name>.md`) and skills
  * (`skills/<name>/SKILL.md`). Routing metadata lives in the same frontmatter Claude Code
@@ -68,6 +78,8 @@ function toComponent(kind, path, fileName, source) {
     description: data.description,
     intents: asList(data.intents),
     stacks: asList(data.stacks),
+    // Optional: the build areas (gradle, xcode, cocoapods...) a skill is specific to.
+    areas: asList(data.areas),
     // `routing: manual` marks helpers that Claude invokes by description only.
     routed: data.routing !== 'manual',
     // Third-party components declare where they came from (see THIRD_PARTY_NOTICES.md).
@@ -107,9 +119,17 @@ export function validateRegistry({ stacks, agents, skills }) {
 
     if (component.source && !component.license) errors.push(`${label}: "source" requires "license"`);
 
+    const prefixes = component.kind === 'skill' ? SKILL_PREFIXES[component.stacks[0]] : undefined;
+    if (prefixes && component.name && !prefixes.some((prefix) => component.name.startsWith(prefix))) {
+      errors.push(`${label}: skill name must start with "${prefixes.join('" or "')}" for stack "${component.stacks[0]}"`);
+    }
+
     for (const intent of component.intents) {
       if (!INTENT_IDS.includes(intent)) errors.push(`${label}: unknown intent "${intent}"`);
     }
+    for (const area of component.areas) {
+      if (!AREA_IDS.includes(area)) errors.push(`${label}: unknown area "${area}"`);
+    }
     for (const stack of component.stacks) {
       if (stack !== ANY_STACK && !stackIds.has(stack)) errors.push(`${label}: unknown stack "${stack}"`);
     }

package/core/router/intents.mjs

@@ -80,6 +80,8 @@ export const AREAS = [
   ['pub', ['pub get', 'pubspec', 'version solving']],
 ];
 
+export const AREA_IDS = AREAS.map(([id]) => id);
+
 // Areas that only exist on one native platform, used to focus cross-platform projects.
 export const AREA_PLATFORM = {
   gradle: 'android',