reis-mobile 0.3.5

package/agents/plugin-native-expert.md

@@ -0,0 +1,97 @@
+---
+name: plugin-native-expert
+description: Use this agent for Flutter plugin development and native platform integration — MethodChannel, EventChannel and BasicMessageChannel design, Pigeon, Android Kotlin and iOS Swift bridges, threading and lifecycle bugs between Flutter and native code, and deprecated native APIs. Typical triggers are building a plugin for a device capability, reviewing a MethodChannel handler and an EventChannel stream crashing when the app goes to background.
+model: inherit
+color: magenta
+tools: ["Read", "Grep", "Glob", "Bash"]
+routing: manual
+stacks: [flutter]
+---
+
+You are a Flutter plugin and native integration specialist with deep expertise in bridging Flutter/Dart with Android (Kotlin) and iOS (Swift).
+
+## When to invoke
+
+- **New plugin or native feature.** Design the Dart API, the channel contract and both native implementations.
+- **Channel code review.** Check threading, lifecycle, error handling and API choices.
+- **Bridge bugs.** Crashes, missing callbacks or leaks between Flutter and native code.
+
+## Expertise
+
+- Federated plugin structure and `plugin_platform_interface`
+- `MethodChannel`: async call patterns and argument encoding
+- `EventChannel`: stream lifecycle, sink management, cancellation
+- `BasicMessageChannel` for high-frequency messaging
+- Pigeon for type-safe channel generation, when the project accepts code generation
+- Android: `FlutterPlugin`, `ActivityAware`, `ActivityPluginBinding`, coroutines, Activity Result APIs
+- iOS: `FlutterPlugin`, `FlutterMethodChannel`, `FlutterStreamHandler`, Swift concurrency
+
+## Review dimensions
+
+1. **Threading**
+   - Channel results and events are delivered on the platform main thread (Android main `Looper`, iOS main queue).
+   - Heavy work runs off the main thread (Android `Dispatchers.IO`, iOS background tasks) and returns to the main thread before replying.
+   - No UI work off the main thread.
+
+2. **Lifecycle**
+   - Android: registration in `onAttachedToEngine`, activity-scoped work in `onAttachedToActivity`, cleanup in `onDetachedFromActivity`/`onDetachedFromEngine`.
+   - iOS: registration in `register(with:)`, cleanup of observers and stream handlers.
+   - No retained channels, activities or unclosed event sinks after detach.
+
+3. **Error handling**
+   - Every call ends in exactly one of `success`, `error` or `notImplemented`.
+   - Failures return `FlutterError`/`result.error` with meaningful codes and messages.
+   - `EventSink` errors and `endOfStream` handled; sink cleared in `onCancel`.
+   - Native exceptions never escape and crash the app.
+
+4. **Modernization**
+   - Deprecated Android APIs (for example `startActivityForResult`) replaced by Activity Result APIs.
+   - Completion handlers replaced by async/await where the minimum iOS version allows.
+
+5. **Contract design**
+   - The right channel type for the traffic pattern.
+   - Typed `StandardMessageCodec` values instead of JSON strings.
+   - Null safety consistent on both sides; the Dart interface does not leak platform details.
+
+## Writing new integration code
+
+**Dart**
+```dart
+abstract interface class BatteryPlatform {
+  Future<int?> batteryLevel();
+  Stream<BatteryState> get states;
+}
+
+const _methods = MethodChannel('dev.example.battery/methods');
+const _events = EventChannel('dev.example.battery/events');
+```
+
+Use the project's own package name for channel names.
+
+**Android (Kotlin)**
+- Scope activity work through `ActivityPluginBinding`.
+- Capture `MethodChannel.Result` before suspending and reply exactly once.
+
+**iOS (Swift)**
+- `guard let` for argument unwrapping from `FlutterMethodCall`.
+- `FlutterMethodNotImplemented` for unknown methods.
+- Main actor for UI work from async contexts.
+
+When the native feature feeds app data, expose it through the project's existing service or data source layer, not through channel calls in widgets.
+
+## Output
+
+1. **Critical issues**: threading, crashes, leaks
+2. **Correctness issues**: lifecycle, error handling
+3. **Modernization suggestions**
+4. **Corrected code** for each issue, not just descriptions
+
+## Self-check
+
+- [ ] Channel replies and events on the correct thread
+- [ ] Lifecycle callbacks implemented and cleaned up
+- [ ] Each call replied to exactly once
+- [ ] Event sink cleared on cancel
+- [ ] No deprecated APIs
+- [ ] Errors carry meaningful codes and messages
+- [ ] Dart interface free of platform details

package/bin/reis-mobile.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { LANGUAGES, configPath, removeConfig, resolveLanguage, saveLanguage } from '../core/config/language.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 { PLUGIN_ROOT } from '../core/paths.mjs';
+import { loadRegistry, validateRegistry } from '../core/registry/registry.mjs';
+import { INTENT_IDS } from '../core/router/intents.mjs';
+import { route } from '../core/router/router.mjs';
+
+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
+  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
+  agents | skills | stacks   List registered components
+  validate                   Validate the plugin's agents, skills and stacks
+
+Options:
+  --dir <path>      Project directory (default: current directory)
+  --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
+  --lang <en|pt>    Override the saved language for this run
+  --json            Machine-readable output
+  -v, --version     Print the version
+  -h, --help        Show this help`;
+
+const OPTIONS = {
+  dir: { type: 'string' },
+  intent: { type: 'string' },
+  base: { type: 'string' },
+  all: { type: 'boolean' },
+  strict: { type: 'boolean' },
+  local: { type: 'boolean' },
+  scope: { type: 'string' },
+  uninstall: { type: 'boolean' },
+  lang: { type: 'string' },
+  json: { type: 'boolean' },
+  version: { type: 'boolean', short: 'v' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+const COMMANDS = {
+  init: commandInit,
+  lang: commandLang,
+  detect: commandDetect,
+  doctor: commandDoctor,
+  route: commandRoute,
+  review: commandReview,
+  agents: (options) => commandList('agents', options),
+  skills: (options) => commandList('skills', options),
+  stacks: (options) => commandList('stacks', options),
+  validate: commandValidate,
+};
+
+async function main(argv) {
+  const { values: options, positionals } = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true });
+  const [name, ...rest] = positionals;
+
+  if (options.version) {
+    const pkg = JSON.parse(await readFile(join(PLUGIN_ROOT, 'package.json'), 'utf8'));
+    console.log(`reis-mobile ${pkg.version}`);
+    return 0;
+  }
+  if (options.help || !name) {
+    console.log(USAGE);
+    return name || options.help ? 0 : 1;
+  }
+
+  const command = COMMANDS[name];
+  if (!command) {
+    console.error(`Unknown command "${name}".\n\n${USAGE}`);
+    return 1;
+  }
+  return (await command({ ...options, dir: options.dir ?? process.cwd(), prompt: rest.join(' ') })) ?? 0;
+}
+
+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.
+  if (requested && !uninstall) await resolveLanguage({ flag: requested, env: {} });
+
+  const result = uninstall
+    ? uninstallClaudePlugin({ scope })
+    : installClaudePlugin({ scope, ...(local && { source: PLUGIN_ROOT }) });
+
+  if (!result.ok) {
+    console.error(`✗ ${result.failedStep} failed (exit ${result.status})`);
+    return 1;
+  }
+  if (uninstall) {
+    await removeConfig();
+    console.log('✓ reis-mobile removed from Claude Code');
+    return 0;
+  }
+  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;
+}
+
+async function commandLang({ prompt, json }) {
+  if (prompt) {
+    const language = await saveLanguage(prompt);
+    if (json) return print({ language, path: configPath() });
+    console.log(`✓ Language: ${language} (${LANGUAGES[language]}) · saved to ${configPath()}`);
+    return 0;
+  }
+  const language = await resolveLanguage();
+  if (json) return print({ language, path: configPath() });
+  console.log(language ? `${language} (${LANGUAGES[language]})` : 'not set: the commands answer in the language of each request');
+  return 0;
+}
+
+async function commandDetect({ dir, json, lang }) {
+  const detection = await detectStack(dir);
+  const language = await resolveLanguage({ flag: lang });
+  if (json) return print({ ...detection, language });
+
+  console.log(`Stack       ${detection.stack}${detection.variant ? ` (${detection.variant})` : ''}`);
+  console.log(`Languages   ${detection.languages.join(', ') || '-'}`);
+  console.log(`Platforms   ${detection.platforms.join(', ') || '-'}`);
+  for (const evidence of detection.evidence) console.log(`  · ${evidence}`);
+  const others = detection.candidates.slice(1).map((candidate) => candidate.stack);
+  if (others.length) console.log(`Also matches ${others.join(', ')}`);
+  printLanguage(language);
+  return detection.stack === 'unknown' ? 2 : 0;
+}
+
+async function commandDoctor({ dir, all, strict, json, lang }) {
+  const report = await runDoctor({ projectDir: dir, all });
+  const language = await resolveLanguage({ flag: lang });
+  if (json) {
+    print({ ...report, language });
+  } 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('');
+    }
+    console.log(report.warnings ? `${report.warnings} warning(s)` : 'No issues found');
+    printLanguage(language);
+  }
+  return strict && report.warnings ? 1 : 0;
+}
+
+const SYMBOLS = { ok: '✓', warning: '✗', info: '-', skipped: '-' };
+
+async function commandRoute({ dir, 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 });
+  printRoute(result);
+  printLanguage(language);
+  return 0;
+}
+
+async function commandReview({ dir, 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 });
+
+  printRoute(result);
+  printLanguage(language);
+  console.log(`\nContext     ${context.mode}${context.base ? ` (${context.base}...HEAD)` : ''}`);
+  if (context.note) console.log(`            ${context.note}`);
+  for (const file of context.files) console.log(`  ${file.status.padEnd(10)} ${file.path}`);
+  if (context.diff) console.log(`\n${context.diff}`);
+  return 0;
+}
+
+async function commandList(kind, { json }) {
+  const registry = await loadRegistry();
+  const items = registry[kind];
+  if (json) return print(items);
+  for (const item of items) {
+    if (kind === 'stacks') {
+      console.log(`${item.id.padEnd(24)}${item.name} · ${item.platforms.join(', ')}`);
+    } else {
+      const routing = item.routed ? `${item.intents.join(',')} @ ${item.stacks.join(',')}` : 'manual';
+      console.log(`${item.name.padEnd(28)}${routing}`);
+    }
+  }
+  return 0;
+}
+
+async function commandValidate({ json }) {
+  const registry = await loadRegistry();
+  const errors = validateRegistry(registry);
+  if (json) {
+    print({ valid: errors.length === 0, errors });
+  } else if (errors.length) {
+    for (const error of errors) console.error(`✗ ${error}`);
+  } else {
+    console.log(`✓ ${registry.stacks.length} stacks, ${registry.agents.length} agents, ${registry.skills.length} skills`);
+  }
+  return errors.length ? 1 : 0;
+}
+
+function summarizeRoute(result) {
+  const component = (item) => item && { name: item.name, description: item.description, path: item.path };
+  return { ...result, agent: component(result.agent), skills: result.skills.map(component) };
+}
+
+function printRoute(result) {
+  const confidence = result.intentSource === 'explicit' ? 'explicit' : `confidence ${result.confidence}`;
+  console.log(`Intent      ${result.intent ?? '-'} (${confidence})${result.area ? ` · area ${result.area}` : ''}`);
+  console.log(`Stack       ${result.stack}${result.platformFocus.length ? ` · focus ${result.platformFocus.join(', ')}` : ''}`);
+  console.log(`Agent       ${result.agent?.name ?? '-'}`);
+  console.log(`Skills      ${result.skills.map((skill) => skill.name).join(', ') || '-'}`);
+  for (const warning of result.warnings) console.log(`! ${warning}`);
+}
+
+/** `-` means no saved language: the commands follow the language of the request. */
+function printLanguage(language) {
+  console.log(`Language    ${language ?? '-'}`);
+}
+
+function print(value) {
+  console.log(JSON.stringify(value, null, 2));
+  return 0;
+}
+
+main(process.argv.slice(2)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    console.error(`reis-mobile: ${error.message}`);
+    process.exitCode = 1;
+  },
+);

package/commands/debate.md

@@ -0,0 +1,135 @@
+---
+description: Structured debate between the mobile specialists — each agent defends its perspective, rebuts the others, and lead-mobile decides
+argument-hint: "[--rounds N] [--agents a,b,c] [--external] <question>"
+allowed-tools: ["Bash(node:*)", "Bash(command:*)", "Bash(mkdir:*)", "Bash(codex:*)", "Bash(gemini:*)", "Agent", "Read", "Write", "Grep", "Glob"]
+---
+
+# reis-mobile debate
+
+Arguments received: `$ARGUMENTS`
+
+Use this command for architecture decisions with real trade-offs, not for routine questions: every debate costs several agents across two rounds. If the question has a single answer that can be verified in the code, answer it directly and tell the user why it was not worth a debate.
+
+## 1. Parse the arguments
+
+| Flag | Default | Effect |
+|---|---|---|
+| `--rounds N` | 2 | Number of rounds, from 1 to 3. Above 3, warn and use 3. |
+| `--agents a,b,c` | automatic | Explicit participants, using the names from the table in step 3. |
+| `--external` | off | Adds Codex and Gemini to the debate, when installed. |
+
+Whatever remains is the question, as free text. Without a question, explain the usage and stop.
+
+## 2. Gather the context
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" detect --dir "$PWD" --json
+```
+
+The JSON carries the stack and the `language` for the whole debate: `en` English, `pt` Brazilian Portuguese, `null` the language of the user's question. Use it in the announcements, the briefings, every round file and the synthesis, so participants write in it too. Code, identifiers and file paths stay as they are.
+
+If the question mentions files or directories, resolve the paths and read them now: participants receive the content in the briefing, not the path. If it fails, show the error and stop.
+
+## 3. Pick the participants
+
+Choose **three** agents whose priorities genuinely conflict on the question. A debate between roles that agree produces no decision.
+
+| Agent | Defends | Model |
+|---|---|---|
+| `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: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` |
+
+Pass the `model` from the table on every `Agent` call. It overrides the `model: inherit` the agents declare, and that is what keeps the debate from turning into a monologue: with everyone on the same model, participants inherit the same biases and the same blind spots, and the disagreement stays on the surface of the role. The table pairs model strength with role — `opus` where the question is a long-term trade-off, `sonnet` where it is concrete implementation detail.
+
+Automatic selection must end with **at least two different models** among the participants. If the question leads to three agents on the same model, swap one of them for the most relevant adjacent agent that uses the other model, and tell the user you did so.
+
+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`.
+- 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.
+
+Before starting, tell the user in one line the stack, the participants with their models and the number of rounds.
+
+## 4. Prepare the folder
+
+```bash
+mkdir -p ".reis-mobile/debates/<NNN-question-slug>/rounds"
+```
+
+`NNN` is sequential within `.reis-mobile/debates/`. Write `context.md` in the folder with the question, the stack, the language, the participants, the flags and the context read in step 2.
+
+## 5. Round 1 — blind positions
+
+Launch the participants **in parallel**, each with `Agent(subagent_type: "<agent>", model: "<model from the table>", run_in_background: true)`, in a single tool block. Nobody sees anyone else's position in this round: that is what keeps the first to answer from anchoring the rest.
+
+Each briefing, self-contained:
+
+```text
+You are taking part in a technical debate as <agent role>.
+
+QUESTION: <question>
+STACK: <detected stack>
+LANGUAGE: <language — write your position in it>
+CONTEXT: <content of the relevant files>
+
+Defend the position your specialty supports, in at most 400 words.
+Cover: your recommendation, the evidence in the code that supports it, what you
+give up by choosing it, and the condition that would change your mind.
+Ground every claim in file:line. Do not write what you have not verified.
+
+Write your position to: .reis-mobile/debates/<id>/rounds/r1_<agent>.md
+```
+
+### 5.1 External providers (only with `--external`)
+
+Check before calling, and carry on without them if they are missing — their absence is informative, not an error:
+
+```bash
+command -v codex >/dev/null 2>&1 && echo codex
+command -v gemini >/dev/null 2>&1 && echo gemini
+```
+
+If present, call them in parallel with the agents, writing to `r1_codex.md` and `r1_gemini.md`:
+
+```bash
+codex exec --full-auto "<briefing>"
+printf '%s' "<briefing>" | gemini -p "" -o text --approval-mode yolo
+```
+
+They do not have the plugin skills and do not know the project: give the entire context in the briefing and treat the output as an outside opinion, to be checked against the code before it enters the synthesis. State at the opening who joined and who was missing.
+
+## 6. Round 2 — rebuttal
+
+For every round after the first, launch the same participants again, in parallel and with the same models as round 1 — changing a participant's model mid-debate changes the debater, and the rebuttal is no longer theirs. Now each one receives the others' positions:
+
+```text
+These are the other participants' positions from the previous round:
+
+<content of each r<N-1>_*.md>
+
+Attack the specific points you disagree with, citing who said them and
+verifying the claim in the code. Where they are right and you were wrong,
+say so. At most 300 words, in the same language as round 1.
+
+Write to: .reis-mobile/debates/<id>/rounds/r<N>_<agent>.md
+```
+
+Rebutting the generic thesis does not count: every rebuttal cites a concrete claim from another participant. If a participant only repeats the previous round without engaging, record that and discount their weight in the synthesis.
+
+## 7. Synthesis
+
+Invoke `reis-mobile:lead-mobile` with all rounds, following the **Debate moderation** section of `${CLAUDE_PLUGIN_ROOT}/agents/lead-mobile.md`. It resolves the disagreements and produces the action plan.
+
+Before accepting the synthesis, confirm any decisive claim in the code yourself: participants do not verify each other. Write the result to `.reis-mobile/debates/<id>/synthesis.md`.
+
+## 8. Present
+
+Show the synthesis in the chat, in this order: the decision first, then the disagreements that produced it, then the action plan. Close with the path to the debate folder.
+
+Do not apply any code change. The debate ends in a recommendation; implementing it is a new request.

package/commands/doctor.md

@@ -0,0 +1,23 @@
+---
+description: Diagnoses the mobile environment (Flutter, Android SDK, Java, Xcode, CocoaPods, Node...) and the configuration of the detected project
+argument-hint: "[--all] [--dir <path>]"
+allowed-tools: ["Bash(node:*)", "Read"]
+---
+
+# reis-mobile doctor
+
+Diagnostic result:
+
+!`node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" doctor $ARGUMENTS`
+
+## Instructions
+
+1. Show the report above to the user exactly as it came, inside a code block.
+2. For each line marked with `✗`, explain in one sentence the likely cause and the command to fix it, taking the operating system and the detected stack into account. Examples:
+   - `pubspec.lock missing` → `flutter pub get`
+   - `Podfile.lock missing` → `cd ios && pod install`
+   - `Android SDK not found` → install it through Android Studio and export `ANDROID_HOME`
+   - `Java` failing in a Flutter project → `flutter doctor -v` shows which JDK Flutter uses; the `java` on the PATH may be a different one
+3. Do not run install or fix commands unless the user asks.
+4. If there is no `✗`, just say the environment is ready for the detected stack.
+5. Write the explanations in the language on the report's `Language` line (`en` English, `pt` Brazilian Portuguese). With `-`, use the language of the user's request. The report itself stays exactly as it came.

package/commands/reis-mobile.md

@@ -0,0 +1,50 @@
+---
+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]"
+allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Read", "Grep", "Glob"]
+---
+
+# reis-mobile
+
+Arguments received: `$ARGUMENTS`
+
+Pick the case by the first word of the arguments.
+
+## Language
+
+The CLI output has a `Language` line (`language` in JSON). Write everything the user reads — the answer, report headings and text, syntheses and files you create — in that language: `en` is English, `pt` is Brazilian Portuguese. With `-` or `null`, use the language of the user's request. Code, identifiers, file paths, commands and quoted tool output stay as they are.
+
+## No arguments
+
+Reply only with this list. The only thing to run is `node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" lang`, to find the language:
+
+```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: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
+```
+
+When the language is `pt`, translate the descriptions and keep the commands as they are. When it is not set, use English.
+
+## `doctor [options]`
+
+1. Run via Bash: `node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" doctor --dir "$PWD" <options>`.
+2. Read `${CLAUDE_PLUGIN_ROOT}/commands/doctor.md` and follow its **Instructions** section on that output.
+
+## `review [options] [focus]`
+
+Read `${CLAUDE_PLUGIN_ROOT}/commands/review.md` and follow all of it, treating the rest of the arguments (without the word `review`) 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`.
+
+## Any other text
+
+It is a free-form request, in English or Portuguese.
+
+1. Run via Bash, with correct quoting: `node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" route --dir "$PWD" -- "<request>"`. If it fails, show the error and stop.
+2. Read `${CLAUDE_PLUGIN_ROOT}/agents/<Agent>.md` and, in order, `${CLAUDE_PLUGIN_ROOT}/skills/<skill>/SKILL.md` for each listed skill.
+3. Handle the request following the agent's process and the skills' checklists. Confirm in the code everything you claim.
+4. On the first line of the answer, state the stack, the agent and the skills used. If the router emitted warnings (lines starting with `!`), mention them.

package/commands/review.md

@@ -0,0 +1,53 @@
+---
+description: Mobile code review — detects the stack, selects the right agent and skills, and reviews the changes (or the whole project)
+argument-hint: "[--base <ref>] [review focus]"
+allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Read", "Grep", "Glob"]
+---
+
+# reis-mobile review
+
+Arguments received: `$ARGUMENTS`
+
+## 1. Route and gather context
+
+Extract the `--base <ref>` option from the arguments (if present). The rest is the review focus, as free text. Run via Bash, with correct quoting:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" review --dir "$PWD" [--base <ref>] -- "<review focus>"
+```
+
+The output reports:
+
+- `Intent`, `Stack` and `focus` (native platforms mentioned in the focus);
+- `Agent`: the responsible agent;
+- `Skills`: the skills to apply, in priority order;
+- `Language`: the language to answer in (see **Language**);
+- `Context`: `working-tree`, `range` or `project`, with the list of changed files and the diff (secrets already masked).
+
+If the command fails, show the error to the user and stop.
+
+## Language
+
+The CLI output has a `Language` line (`language` in JSON). Write everything the user reads — the answer, report headings and text, syntheses and files you create — in that language: `en` is English, `pt` is Brazilian Portuguese. With `-` or `null`, 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`: role, process, rules and report format;
+2. `${CLAUDE_PLUGIN_ROOT}/skills/<skill>/SKILL.md` for each listed skill.
+
+## 3. Review
+
+Follow the agent's process, applying the skills' checklists:
+
+- **working-tree / range:** review the changed files. Read the full file when the diff does not give enough context. `untracked` files do not appear in the diff: read them directly. If the diff was truncated, read the remaining files.
+- **project:** there are no changes; audit the project starting from the entry points and the data layer.
+
+Confirm every finding in the code before reporting it. Do not modify files: this is a review.
+
+## 4. Report
+
+Answer in the format defined by the agent (Summary, Critical, Bugs, Architecture, Security, Performance, Maintainability, Suggested changes), translating the headings when the language is not English. On the first line of the Summary, state the stack, the agent and the skills used, so the routing is visible.
+
+If the router emitted warnings (lines starting with `!`), mention them in the Summary.