reis-mobile 0.10.1 → 1.0.1

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "AI agents for mobile engineering",
-    "version": "0.10.1"
+    "version": "1.0.1"
   },
   "plugins": [
     {
       "name": "reis-mobile",
       "source": "./",
       "description": "AI agents, skills and workflows for Flutter, Android, iOS and React Native development.",
-      "version": "0.10.1",
+      "version": "1.0.1",
       "author": {
         "name": "Warleson Reis"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "reis-mobile",
-  "version": "0.10.1",
+  "version": "1.0.1",
   "description": "AI agents, skills and workflows for Flutter, Android, iOS and React Native development. Use /reis-mobile:doctor, /reis-mobile:review and /reis-mobile:test.",
   "author": {
     "name": "Warleson Reis"

package/CHANGELOG.md

@@ -4,6 +4,28 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). The pr
 
 ## [Unreleased]
 
+## [1.0.1] - 2026-11-11
+
+### Fixed
+
+- Review instructions now prioritize applicable analyzer, linter and test results, separate confirmed tool diagnostics from additional findings, and disclose missing checks. Recurring defects with precise conditions should become regression tests or lint rules.
+- README positioning now explains how AI review complements deterministic checks, replaces the lint-covered opening example, and distinguishes illustrative investigation targets from demonstrated detections.
+
+## [1.0.0] - 2026-11-04
+
+### Added
+
+- `reis-mobile mcp`, a stdio MCP server for editors that cannot load the Claude Code plugin, such as Cursor. Seven tools (`reis_mobile_route`, `reis_mobile_review`, `reis_mobile_debug`, `reis_mobile_test`, `reis_mobile_release`, `reis_mobile_detect` and `reis_mobile_doctor`) return the same JSON as the matching `--json` command, and `reis_mobile_read_instructions` serves the agent, skill and reference files a route points to.
+- Both MCP eras on one process: per-request `_meta` and `server/discover` from the 2026-07-28 revision, and the `initialize` handshake from 2025-11-25 back to 2024-11-05. Validated end to end with Claude Code 2.1.267; the Cursor and Codex configurations in the README follow each client's documented format.
+- `--dir` on `reis-mobile mcp` sets the app directory for tool calls that pass none, so a client can pass its workspace folder.
+- Every MCP tool is read-only and offline. `consult` and the commands that write are not exposed, and the instruction reader resolves symlinks and serves only `agents/`, `skills/` and `docs/agent-context.md`, up to 512 KB.
+- iOS Keychain token storage guide in `mobile-security` (`references/ios/keychain.md`): accessibility classes and backups, biometric access control, access groups, reinstall persistence, migration out of `UserDefaults`, and a Swift token store with `OSStatus` handling. Contributed by @jay23606 in #21.
+
+### Changed
+
+- 1.0.0 is the first stable release for Flutter, native Android, native iOS and React Native, as planned in the roadmap, and ships the MCP server previously planned for v0.11.0.
+- The read-only commands build their `--json` output in `core/commands/payloads.mjs`, shared by the CLI and the MCP server. The output itself is unchanged.
+
 ## [0.10.1] - 2026-11-04
 
 ### Added

package/README.md

@@ -1,9 +1,17 @@
 # 📱 reis-mobile
 
-A mobile app is not a generic project. A code review that does not know about `BuildContext` after `await`, `android:exported`, `NSAllowsArbitraryLoads` or `Podfile.lock` lets through exactly the bugs that only show up on the device. **reis-mobile** detects your project's stack, picks the right specialist and loads only the skills that apply to Flutter, Android, iOS, React Native or Kotlin Multiplatform.
+**reis-mobile** gives AI assistants mobile-specific context and workflows for code review, debugging, tests and architecture. It detects your project's stack, picks the right specialist and loads only the skills that apply to Flutter, Android, iOS, React Native or Kotlin Multiplatform.
 
 **AI agents and skills for mobile development — Flutter, Android, iOS, React Native and Kotlin Multiplatform.** A plugin for Claude Code and Codex with specialist agents and skills for code review, debugging, tests, architecture, security and Firebase.
 
+### How review fits with linters and tests
+
+Use configured analyzers, linters and tests first. For example, Dart's [`use_build_context_synchronously`](https://dart.dev/tools/linter-rules/use_build_context_synchronously) checks `BuildContext` use across asynchronous gaps; detecting that pattern is not a reason to spend tokens on a review.
+
+The review instructions ask the assistant to reuse available check results, distinguish tool diagnostics from additional findings, and trace behavior across files and lifecycle transitions. Investigation targets include a pending request repopulating user data after logout, an older search response replacing newer results, or retries conflicting with an API's idempotency contract. These are illustrative targets, not demonstrated detections or guarantees: each finding needs a concrete trigger and code evidence. The CLI gathers context; it does not automatically run the app's analyzers or tests, and missing check results must be disclosed.
+
+When a recurring defect has a precise, enforceable condition, capture it in a regression test or lint rule. AI can help write that check. A passing analyzer does not prove an app correct, and an AI review does not replace deterministic checks. This project does not yet provide a reproducible benchmark demonstrating additional defect detection beyond those checks.
+
 <p align="center">
   <a href="https://github.com/wrsilva/reis-mobile/actions/workflows/ci.yml"><img src="https://github.com/wrsilva/reis-mobile/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <img src="https://img.shields.io/npm/v/reis-mobile" alt="Latest npm version">
@@ -37,6 +45,8 @@ A mobile app is not a generic project. A code review that does not know about `B
 
 🔒 **Secrets never reach the model.** The diff sent for review goes through a layer that masks API keys, tokens, JWTs, private keys and keystore passwords.
 
+🔌 **Works in any MCP client.** `reis-mobile mcp` serves stack detection, routing and the review, debug, test and release context to Cursor and other editors, with the agent and skill instructions behind them. See [MCP server](#mcp-server).
+
 🪶 **Two commands to install.** `npm install -g reis-mobile` and `reis-mobile init eng` set it up in Claude Code and Codex, with zero npm dependencies and no external provider.
 
 ---
@@ -44,22 +54,12 @@ A mobile app is not a generic project. A code review that does not know about `B
 ## What's new
 
 <!-- reis-mobile:latest-release:start -->
-### v0.10.1
-
-#### Added
-
-- `mobile-ui-ux-designer` agent and `mobile-ui-ux` topic skill for mobile journeys, wireframes, design tokens, component states and evidence-based interface reviews across all five stacks.
-- English and Portuguese `design` routing with platform skill selection and regression coverage for architecture, accessibility, tests and unrelated terms.
-- Apple design reading workflow linked to `dickwu/apple-design-skill` at a recorded revision and to official HIG topics. Upstream content is linked, not vendored, because the inspected revision declares no redistribution license.
-
-#### Changed
-
-- The debate now invokes `lead-mobile` for participant selection before the rounds and again for final synthesis. The candidate table includes every specialist, including UI/UX, accessibility and release, with explicit participant validation and a persisted selection rationale.
-- All five platform skills now route design work and link the UI/UX workflow and Apple-target reference.
+### v1.0.1
 
 #### Fixed
 
-- `lead-mobile` now includes the UI/UX designer in its delegation table. A registry test requires every other registered agent, including manual specialists, to appear and rejects unknown agents or self-delegation.
+- Review instructions now prioritize applicable analyzer, linter and test results, separate confirmed tool diagnostics from additional findings, and disclose missing checks. Recurring defects with precise conditions should become regression tests or lint rules.
+- README positioning now explains how AI review complements deterministic checks, replaces the lint-covered opening example, and distinguishes illustrative investigation targets from demonstrated detections.
 
 <!-- reis-mobile:latest-release:end -->
 
@@ -197,7 +197,7 @@ reis-mobile route "review architecture" --json
 reis-mobile review --json
 ```
 
-You can also ask Codex: *"Run `reis-mobile review --json`, read the instructions in the returned files and review the changes using that context."* The CLI selects the instructions and gathers the context; Codex does the analysis.
+You can also ask Codex: *"Run `reis-mobile review --json`, read the instructions in the returned files and review the changes using that context."* The CLI selects the instructions and gathers the context; Codex does the analysis. To let Codex call these commands as tools instead, register the [MCP server](#mcp-server).
 </details>
 
 <details>
@@ -366,6 +366,46 @@ The router never invents a specialist: if no agent serves the intent, it warns y
 
 ---
 
+## MCP server
+
+Editors that cannot load the Claude Code plugin, such as Cursor, can use reis-mobile through MCP. `reis-mobile mcp` is a stdio server shipped in the npm package, so install it with `npm install -g reis-mobile` first.
+
+| Client | Register the server |
+|---|---|
+| Cursor | `.cursor/mcp.json` in the project, or `~/.cursor/mcp.json` for every project, as below |
+| Claude Code | `claude mcp add reis-mobile -- reis-mobile mcp` |
+| Codex | `codex mcp add reis-mobile -- reis-mobile mcp` |
+
+```json
+{
+  "mcpServers": {
+    "reis-mobile": {
+      "command": "reis-mobile",
+      "args": ["mcp", "--dir", "${workspaceFolder}"]
+    }
+  }
+}
+```
+
+`--dir` is the app directory a tool uses when the call does not pass `dir`; Cursor replaces `${workspaceFolder}` with the project folder. In Claude Code the plugin already provides the agents and commands, so the server matters most in the other clients.
+
+| Tool | Returns |
+|---|---|
+| `reis_mobile_route` | Intent, stack, agent and skill paths for a request |
+| `reis_mobile_review` | The review route and the git diff, lock files out and secrets masked |
+| `reis_mobile_debug` | The debug route and the installed toolchain versions |
+| `reis_mobile_test` | The test route, the diff and the toolchain checks; runs no tests |
+| `reis_mobile_release` | Candidate release targets and references; builds and uploads nothing |
+| `reis_mobile_detect` | Stack, languages, platforms and the evidence for each |
+| `reis_mobile_doctor` | SDK and project file checks for the detected stack |
+| `reis_mobile_read_instructions` | The agent, skill or reference file a route points to |
+
+The model calls a routing tool, reads the instructions it returns and follows them, the same flow the slash commands use. Each tool returns the same JSON as its `--json` command. Every tool is read-only and offline, so `consult`, which sends context to a third party, is not exposed. The server speaks both MCP eras: the 2026-07-28 revision with per-request metadata, and the `initialize` handshake of 2025-11-25 back to 2024-11-05.
+
+Validated end to end with Claude Code 2.1.267. The Cursor and Codex entries follow each client's documented configuration but have not been run against those clients yet; if you try one, tell us in an issue.
+
+---
+
 ## Choose by goal
 
 | I want to... | Use | Status |
@@ -400,7 +440,7 @@ The router never invents a specialist: if no agent serves the intent, it warns y
 |---|---|---|
 | **Domain** | Generic | Flutter, Android, iOS, React Native, KMP |
 | **Project context** | You explain the stack | Deterministic detection of stack, platform and variant |
-| **Review** | Generic | Mobile checklists: lifecycle, `BuildContext`, MASVS, manifest, ATS |
+| **Review** | General review instructions | Mobile workflows: existing check results, lifecycle and cross-file behavior, findings with code evidence |
 | **Secrets in the diff** | Sent as they are | Masked before reaching the model |
 | **Specialists** | None | 22 agents and 27 mobile skills |
 | **Context cost** | Zero | ~5,500 fixed tokens (agent and skill descriptions), no hooks |
@@ -491,7 +531,7 @@ Every skill starts with `mobile-`. **Topic** skills cover every stack with one r
 | `mobile-code-review` | Review process and checklists | review, performance | Flutter (PR review, widgets, project audit, static analysis), Android, iOS, React Native, KMP |
 | `mobile-debug` | Failing builds and runtime errors | debug, build, dependency, migration | Flutter (build, runtime, layout, packages), Android (Gradle, crashes, ANRs, memory leaks), iOS (Xcode, CocoaPods, crash logs), React Native (Metro, native modules), KMP, deep links |
 | `mobile-test` | Unit, UI, integration and end-to-end tests | test | Flutter (widget, integration, Patrol, mocks, coverage), Android, iOS, React Native, KMP |
-| `mobile-security` | OWASP MASVS security checks | review, security, release | Flutter (token storage), Android (intents), iOS, React Native, KMP, OAuth/OIDC and PKCE |
+| `mobile-security` | OWASP MASVS security checks | review, security, release | Flutter (token storage), Android (intents), iOS (Keychain token storage), React Native, KMP, OAuth/OIDC and PKCE |
 | `mobile-ui-ux` | Journeys, wireframes, visual hierarchy, tokens, component states and Apple HIG reference workflow | design | Flutter, Android, iOS, React Native, KMP and external Apple design reading |
 | `mobile-accessibility` | Screen readers, touch targets, text scaling, contrast, localization | accessibility | Flutter (Semantics), Android (Compose and Views), iOS (SwiftUI and UIKit), React Native, KMP, localization and RTL |
 | `mobile-release` | Release readiness, store copy, billing and CI/CD | release, deployment | Flutter, Android, iOS, React Native, KMP, release notes and store listing, in-app purchases, CI/CD |
@@ -539,11 +579,11 @@ About 85 guides come from [flutter/skills](https://github.com/flutter/skills), [
 
 ## Trust, security and limits
 
-**Read-only CLI context.** `doctor`, `detect`, `route`, `review`, `test`, `release`, `providers` and `consult` do not modify your project. `/reis-mobile:release` inspects existing release evidence and remains read-only unless execution is explicitly requested. The `/reis-mobile:test` slash command can write or fix tests and execute runners when requested. `/reis-mobile:project` writes only the optional project profile. The `/reis-mobile:review` and `/reis-mobile:debate` commands instruct the model not to edit app code; the debate writes its rounds to `.reis-mobile/debates/` and a consult its briefing to `.reis-mobile/consults/`.
+**Read-only CLI context.** `doctor`, `detect`, `route`, `review`, `test`, `release`, `providers`, `consult` and the `mcp` server's tools do not modify your project. `/reis-mobile:release` inspects existing release evidence and remains read-only unless execution is explicitly requested. The `/reis-mobile:test` slash command can write or fix tests and execute runners when requested. `/reis-mobile:project` writes only the optional project profile. The `/reis-mobile:review` and `/reis-mobile:debate` commands instruct the model not to edit app code; the debate writes its rounds to `.reis-mobile/debates/` and a consult its briefing to `.reis-mobile/consults/`.
 
 **Secrets masked.** The diff goes through [`core/security/redact.mjs`](core/security/redact.mjs) before reaching the model. Lock files and generated code (`*.g.dart`, `*.freezed.dart`, `*.pbxproj`) stay out of the diff. Redaction is a protection layer, not a guarantee. See [SECURITY.md](SECURITY.md).
 
-**No telemetry.** `detect`, `doctor`, `route`, `review`, `debug`, `test` and `providers` make no network calls (`providers --models` and `consult` do, by request). The update hook and `update-check` request the public npm package metadata; they send no project files or identifiers. Installation downloads the package and registers the plugin. The Google Play policy guide in `mobile-android` runs Python scripts that download your app's public Google Play listing when the model uses it. The AI analysis uses the model of the session you are working in, such as Claude Code or Codex.
+**No telemetry.** `detect`, `doctor`, `route`, `review`, `debug`, `test`, `providers` and the `mcp` server make no network calls (`providers --models` and `consult` do, by request). The update hook and `update-check` request the public npm package metadata; they send no project files or identifiers. Installation downloads the package and registers the plugin. The Google Play policy guide in `mobile-android` runs Python scripts that download your app's public Google Play listing when the model uses it. The AI analysis uses the model of the session you are working in, such as Claude Code or Codex.
 
 **Exception: external providers.** Two workflows, and only these two, send project context to a third party: `/reis-mobile:debate --external` and `/reis-mobile:consult`. Both state which providers receive it, and both are opt-in — no other command calls a provider. What leaves is the briefing, including the code excerpts you include; each provider has its own data policy. The question and every answer pass through `redact.mjs`, which is a protection layer and not a guarantee: read the briefing before sending it. API keys are read from the environment by the CLI and never enter the conversation, and `providers:` in `.reis-mobile/config.yaml` lets a team restrict which providers a repository allows. CLI providers (`codex`, `gemini-cli`) are asked for an opinion, not for work: they run in read-only mode (`codex exec --sandbox read-only`, `gemini --approval-mode plan`) inside a temporary directory, never in your repository.
 
@@ -578,8 +618,7 @@ About 85 guides come from [flutter/skills](https://github.com/flutter/skills), [
 | v0.8.0 | `mobile-performance`, `mobile-offline-sync` and `mobile-observability` topic skills with a reference per stack, plus background execution, OAuth/PKCE, billing lifecycle and localization references | ✅ |
 | v0.9.0 | Multi-provider layer (OpenAI, Gemini, OpenRouter, Ollama and the Codex/Gemini CLIs), `reis-mobile providers`, `reis-mobile consult` and `/reis-mobile:consult` — previously planned for v0.10.0 | ✅ |
 | v0.10.0 | `mobile-privacy`, `mobile-networking`, `mobile-auth` and `mobile-notifications` topic skills with a reference per stack, plus the `privacy`, `networking`, `auth` and `notifications` intents | ✅ |
-| v0.11.0 | MCP server | ⏳ |
-| v1.0.0 | First stable version: Flutter, Android, iOS and React Native | ⏳ |
+| v1.0.0 | First stable version: Flutter, Android, iOS and React Native, with the MCP server previously planned for v0.11.0 | ✅ |
 
 ---
 
@@ -607,10 +646,10 @@ Yes. Native Android, native iOS and React Native each have architect, performanc
 The plugin's skills live in the `reis-mobile:` namespace and do not conflict, but Claude Code loads both descriptions. To save context, remove the global copies the plugin already covers.
 
 **Does it work in Codex?**
-Yes: `reis-mobile init eng` installs the plugin in Codex too. See [installation](#install). Installation does not confirm parity with the Claude Code agents and commands; the `reis-mobile` CLI can also be run by Codex to get diagnostics and context.
+Yes: `reis-mobile init eng` installs the plugin in Codex too. See [installation](#install). Installation does not confirm parity with the Claude Code agents and commands; the `reis-mobile` CLI can also be run by Codex to get diagnostics and context, and the [MCP server](#mcp-server) exposes the same commands as tools.
 
 **Does it work in Cursor?**
-The Cursor integration has not been validated yet. The MCP server remains on the roadmap for v0.11.0.
+Through the [MCP server](#mcp-server): register `reis-mobile mcp` in `.cursor/mcp.json`. The configuration follows Cursor's documented format but has not been run against Cursor yet. Cursor gets the tools and the instructions, not the Claude Code agents, slash commands or hooks.
 
 **What does reis-mobile send outside my machine?**
 The project analysis commands do not make network requests. The update hook and `reis-mobile update-check` request the public npm package metadata without sending project files or identifiers. What the model reads during `/reis-mobile:review` follows the same rules as any Claude Code session.

package/agents/mobile-code-reviewer.md

@@ -18,6 +18,8 @@ Resolve the requested base/head or working-tree scope, including staged, unstage
 
 ## Prove a finding
 
+Start with configured analyzer, linter and test results for the reviewed revision and scope. Reuse applicable results or run existing checks when available and permitted; disclose missing or stale evidence. Summarize confirmed tool diagnostics separately from additional review findings, including correctness and security diagnostics. A potentially applicable rule alone is not evidence that a defect is covered. Focus additional analysis on behavior across files, lifecycle transitions and API contracts.
+
 1. Read the complete changed function/type and its callers, tests and platform configuration. Identify the input, lifecycle transition or configuration that activates the suspected defect.
 2. Trace the consequence across the changed boundary: lost data, crash, stale state, permission failure, exposed secret or broken platform behavior. For async changes, identify who owns and cancels the work and whether a late result can still reach the UI.
 3. Compare with the base behavior and surrounding conventions. Separate newly introduced regressions from pre-existing issues, and check whether a wrapper, validation layer or existing test already handles the case.

package/bin/reis-mobile.mjs

@@ -3,19 +3,25 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseArgs } from 'node:util';
 
+import {
+  debugPayload,
+  detectPayload,
+  doctorPayload,
+  releasePayload,
+  reviewPayload,
+  routePayload,
+  testPayload,
+} from '../core/commands/payloads.mjs';
 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 { runInit } from '../core/install/init.mjs';
+import { serveStdio } from '../core/mcp/server.mjs';
 import { PLUGIN_ROOT } from '../core/paths.mjs';
 import { DEFAULT_TIMEOUT_MS, consult, listProviderModels } from '../core/providers/consult.mjs';
 import { parseProviderList, providerAllowlist, resolveProviders, selectProviders } from '../core/providers/providers.mjs';
 import { loadRegistry, validateRegistry } from '../core/registry/registry.mjs';
-import { releaseContext } from '../core/release/context.mjs';
 import { INTENT_IDS } from '../core/router/intents.mjs';
-import { route } from '../core/router/router.mjs';
 import { checkForUpdate, clearUpdateCache } from '../core/update/check.mjs';
 
 const USAGE = `reis-mobile — AI agents for mobile engineering
@@ -34,12 +40,13 @@ Commands:
   release [request...]       Prepare release evidence context (does not build or publish)
   providers                  List the external model providers and what each one needs
   consult [question...]      Ask the configured external providers the same question
+  mcp                        Serve the read-only commands to MCP clients over stdio (Cursor, Claude Code, Codex...)
   agents | skills | stacks   List registered components
   validate                   Validate the plugin's agents, skills and stacks
   update-check               Check npm for a newer reis-mobile release
 
 Options:
-  --dir <path>      Project directory (default: current directory, or "app" in .reis-mobile/config.yaml)
+  --dir <path>      Project directory (default: current directory, or "app" in .reis-mobile/config.yaml); mcp: default for tool calls
   --intent <id>     Force an intent (${INTENT_IDS.join(', ')})
   --base <ref>      review/test: compare <ref>...HEAD instead of the working tree
   --all             doctor: check every tool, not only the relevant ones
@@ -91,6 +98,7 @@ const COMMANDS = {
   release: commandRelease,
   providers: commandProviders,
   consult: commandConsult,
+  mcp: commandMcp,
   agents: (options) => commandList('agents', options),
   skills: (options) => commandList('skills', options),
   stacks: (options) => commandList('stacks', options),
@@ -182,10 +190,9 @@ async function commandLang({ prompt, json }) {
   return 0;
 }
 
-async function commandDetect({ dir, project, json, lang }) {
-  const detection = await detectStack(dir);
-  const language = await resolveLanguage({ flag: lang });
-  if (json) return print({ ...detection, language, projectConfig: project.config?.path ?? null });
+async function commandDetect({ project, json, lang }) {
+  const detection = await detectPayload({ project, lang });
+  if (json) return print(detection);
 
   printProject(project);
 
@@ -195,21 +202,20 @@ async function commandDetect({ dir, project, json, lang }) {
   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);
+  printLanguage(detection.language);
   return detection.stack === 'unknown' ? 2 : 0;
 }
 
-async function commandDoctor({ dir, project, all, strict, json, lang }) {
-  const report = await runDoctor({ projectDir: dir, all });
-  const language = await resolveLanguage({ flag: lang });
+async function commandDoctor({ project, all, strict, json, lang }) {
+  const report = await doctorPayload({ project, all, lang });
   if (json) {
-    print({ ...report, language, projectConfig: project.config?.path ?? null });
+    print(report);
   } else {
     console.log('reis-mobile doctor\n');
     printProject(project);
     printDoctorChecks(report);
     console.log(report.warnings ? `${report.warnings} warning(s)` : 'No issues found');
-    printLanguage(language);
+    printLanguage(report.language);
   }
   return strict && report.warnings ? 1 : 0;
 }
@@ -226,30 +232,27 @@ function printDoctorChecks(report) {
 
 const SYMBOLS = { ok: '✓', warning: '✗', info: '-', skipped: '-' };
 
-async function commandRoute({ dir, project, intent, prompt, json, lang }) {
+async function commandRoute({ 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, projectConfig: project.config?.path ?? null });
+  const result = await routePayload({ project, prompt, intent, lang });
+  if (json) return print(result);
   printProject(project);
   printRoute(result);
-  printLanguage(language);
+  printLanguage(result.language);
   return 0;
 }
 
-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, projectConfig: project.config?.path ?? null, context });
+async function commandReview({ project, base, prompt, json, lang }) {
+  const result = await reviewPayload({ project, base, prompt, lang });
+  if (json) return print(result);
 
   printProject(project);
   printRoute(result);
-  printLanguage(language);
-  printContext(context);
+  printLanguage(result.language);
+  printContext(result.context);
   return 0;
 }
 
@@ -264,55 +267,57 @@ function printContext(context) {
  * 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 });
+async function commandDebug({ project, prompt, json, lang }) {
+  const result = await debugPayload({ project, prompt, lang });
+  if (json) return print(result);
 
   printProject(project);
   printRoute(result);
-  printLanguage(language);
+  printLanguage(result.language);
   console.log('');
-  printDoctorChecks(doctor);
+  printDoctorChecks(result.doctor);
   return 0;
 }
 
 /** Prepare evidence for the test agent; running the selected suite is the agent's job. */
-async function commandTest({ dir, project, base, prompt, json, lang }) {
-  const result = await route({ prompt, intent: 'test', projectDir: dir });
-  const context = collectReviewContext({ projectDir: dir, base });
-  const doctor = await runDoctor({ projectDir: dir });
-  const language = await resolveLanguage({ flag: lang });
-  if (json) return print({ ...summarizeRoute(result), language, projectConfig: project.config?.path ?? null, context, doctor });
+async function commandTest({ project, base, prompt, json, lang }) {
+  const result = await testPayload({ project, base, prompt, lang });
+  if (json) return print(result);
 
   // A test runner needs an explicit working directory even without a monorepo config.
   printProject(project, true);
   printRoute(result);
-  printLanguage(language);
-  printContext(context);
+  printLanguage(result.language);
+  printContext(result.context);
   console.log('\nTest context prepared; no test suites were executed.\n');
-  printDoctorChecks(doctor);
+  printDoctorChecks(result.doctor);
   return 0;
 }
 
 /** Prepare release evidence; the specialist audits it before assigning a verdict. */
-async function commandRelease({ dir, project, prompt, json, lang }) {
-  const result = await route({ prompt, intent: 'release', projectDir: dir });
-  const context = collectReviewContext({ projectDir: dir });
-  const doctor = await runDoctor({ projectDir: dir });
-  const language = await resolveLanguage({ flag: lang });
-  const release = releaseContext(result.detection);
-  if (json) return print({ ...summarizeRoute(result), language, projectConfig: project.config?.path ?? null, context, doctor, release });
+async function commandRelease({ project, prompt, json, lang }) {
+  const result = await releasePayload({ project, prompt, lang });
+  if (json) return print(result);
 
+  const { release } = result;
   printProject(project, true);
   printRoute(result);
-  printLanguage(language);
-  printContext(context);
+  printLanguage(result.language);
+  printContext(result.context);
   console.log(`\nRelease platforms (verify) ${release.platforms.join(', ') || 'unknown'}`);
   for (const reference of release.references) console.log(`  Reference ${reference}`);
   console.log('\nRelease context prepared; readiness has not been evaluated. No builds, tests or uploads were executed.\n');
-  printDoctorChecks(doctor);
+  printDoctorChecks(result.doctor);
+  return 0;
+}
+
+/**
+ * Serves the read-only commands to MCP clients over stdio. Nothing but protocol messages may
+ * reach stdout, so this command prints nothing itself; `--dir` is the default for tool calls.
+ */
+async function commandMcp({ dir }) {
+  const pkg = JSON.parse(await readFile(join(PLUGIN_ROOT, 'package.json'), 'utf8'));
+  await serveStdio({ version: pkg.version, defaultDir: dir });
   return 0;
 }
 
@@ -450,11 +455,6 @@ async function commandValidate({ json }) {
   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}` : ''}`);

package/commands/review.md

@@ -41,6 +41,8 @@ Read with the Read tool, in this order:
 
 Follow the agent's process, applying the skills' checklists:
 
+- First inspect available analyzer, linter and test results for this revision and scope. Run existing checks only when available and permitted; otherwise state what was not checked. The CLI gathers context and does not execute these checks automatically. Summarize confirmed tool diagnostics separately from additional review findings.
+
 - **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.
 

package/core/commands/payloads.mjs

@@ -0,0 +1,63 @@
+import { resolveLanguage } from '../config/language.mjs';
+import { collectReviewContext } from '../context/context-engine.mjs';
+import { detectStack } from '../detection/stack-detector.mjs';
+import { runDoctor } from '../diagnostics/doctor.mjs';
+import { releaseContext } from '../release/context.mjs';
+import { route } from '../router/router.mjs';
+
+// The `--json` output of the read-only commands. The CLI prints it and the MCP server returns
+// it, so both surfaces describe a project the same way. `project` is resolveProjectDir's result.
+
+export async function detectPayload({ project, lang }) {
+  const detection = await detectStack(project.projectDir);
+  return { ...detection, ...(await common(project, lang)) };
+}
+
+export async function doctorPayload({ project, all, lang }) {
+  const report = await runDoctor({ projectDir: project.projectDir, all });
+  return { ...report, ...(await common(project, lang)) };
+}
+
+export async function routePayload({ project, prompt, intent, lang }) {
+  const result = await route({ prompt, intent, projectDir: project.projectDir });
+  return { ...summarizeRoute(result), ...(await common(project, lang)) };
+}
+
+export async function reviewPayload({ project, base, prompt, lang }) {
+  const result = await route({ prompt, intent: 'review', projectDir: project.projectDir });
+  const context = collectReviewContext({ projectDir: project.projectDir, base });
+  return { ...summarizeRoute(result), ...(await common(project, lang)), context };
+}
+
+/** Most build failures are toolchain mismatches, so the doctor report travels with the route. */
+export async function debugPayload({ project, prompt, lang }) {
+  const result = await route({ prompt, intent: 'debug', projectDir: project.projectDir });
+  const doctor = await runDoctor({ projectDir: project.projectDir });
+  return { ...summarizeRoute(result), ...(await common(project, lang)), doctor };
+}
+
+/** Evidence for the test agent; running the selected suite is the agent's job. */
+export async function testPayload({ project, base, prompt, lang }) {
+  const result = await route({ prompt, intent: 'test', projectDir: project.projectDir });
+  const context = collectReviewContext({ projectDir: project.projectDir, base });
+  const doctor = await runDoctor({ projectDir: project.projectDir });
+  return { ...summarizeRoute(result), ...(await common(project, lang)), context, doctor };
+}
+
+/** Release evidence; the specialist audits it before assigning a verdict. */
+export async function releasePayload({ project, prompt, lang }) {
+  const result = await route({ prompt, intent: 'release', projectDir: project.projectDir });
+  const context = collectReviewContext({ projectDir: project.projectDir });
+  const doctor = await runDoctor({ projectDir: project.projectDir });
+  const release = releaseContext(result.detection);
+  return { ...summarizeRoute(result), ...(await common(project, lang)), context, doctor, release };
+}
+
+async function common(project, lang) {
+  return { language: await resolveLanguage({ flag: lang }), projectConfig: project.config?.path ?? null };
+}
+
+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) };
+}

package/core/mcp/server.mjs

@@ -0,0 +1,188 @@
+import { once } from 'node:events';
+import { createInterface } from 'node:readline';
+
+import { callTool, hasTool, listTools } from './tools.mjs';
+
+// A dual-era MCP server. Modern clients (2026-07-28) send the protocol version and their
+// capabilities in every request's `_meta` and may probe with `server/discover`; legacy clients
+// (2025-11-25 and earlier) open with an `initialize` handshake. Both are served on one process.
+export const MODERN_VERSIONS = ['2026-07-28'];
+export const LEGACY_VERSIONS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
+const SUPPORTED_VERSIONS = [...MODERN_VERSIONS, ...LEGACY_VERSIONS];
+
+const META_VERSION = 'io.modelcontextprotocol/protocolVersion';
+const META_CAPABILITIES = 'io.modelcontextprotocol/clientCapabilities';
+const META_SERVER_INFO = 'io.modelcontextprotocol/serverInfo';
+
+export const ERROR_CODES = {
+  parse: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internal: -32603,
+  unsupportedVersion: -32022,
+};
+
+const CAPABILITIES = { tools: {} };
+
+const INSTRUCTIONS =
+  'reis-mobile prepares context for Flutter, native Android, native iOS, React Native/Expo and Kotlin Multiplatform apps. ' +
+  'Call reis_mobile_route, or reis_mobile_review, reis_mobile_debug, reis_mobile_test or reis_mobile_release for those tasks, ' +
+  'with the app directory as "dir". Then read the returned agent and skill files with reis_mobile_read_instructions and follow them; ' +
+  'open only the references that match the stack and the task. Every tool is read-only and offline: none edits the project, ' +
+  'builds, runs tests or calls a network service.';
+
+class RpcError extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+}
+
+/**
+ * Handles one decoded JSON-RPC message and resolves to the response, or to null for a
+ * notification. It never rejects: every failure becomes a JSON-RPC error or a tool error.
+ */
+export function createMcpServer({ version, defaultDir = process.cwd() }) {
+  const serverInfo = { name: 'reis-mobile', title: 'reis-mobile', version };
+  // Set by `initialize`: from then on, requests without `_meta` follow that legacy revision.
+  let legacyVersion = null;
+
+  async function handle(message) {
+    if (typeof message !== 'object' || message === null || Array.isArray(message)) {
+      return failure(null, new RpcError(ERROR_CODES.invalidRequest, 'Expected one JSON-RPC 2.0 message object; batches are not supported.'));
+    }
+    const isRequest = Object.hasOwn(message, 'id');
+    if (message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+      return isRequest ? failure(requestId(message.id), new RpcError(ERROR_CODES.invalidRequest, 'Expected a JSON-RPC 2.0 request with a method.')) : null;
+    }
+    // notifications/initialized needs no reply; cancellation is handled by the transport.
+    if (!isRequest) return null;
+
+    const { id, method, params } = message;
+    if (requestId(id) === null) return failure(null, new RpcError(ERROR_CODES.invalidRequest, 'The request id must be a string or a number.'));
+    try {
+      if (params !== undefined && (typeof params !== 'object' || params === null || Array.isArray(params))) {
+        throw new RpcError(ERROR_CODES.invalidParams, 'params must be an object.');
+      }
+      if (method === 'initialize') return success(id, initialize(params ?? {}));
+
+      const modern = isModernRequest(method, params);
+      const result = await dispatch(method, params ?? {}, modern);
+      return success(id, modern ? { resultType: 'complete', ...result, _meta: { [META_SERVER_INFO]: serverInfo } } : result);
+    } catch (error) {
+      return failure(id, error instanceof RpcError ? error : new RpcError(ERROR_CODES.internal, `Internal error: ${error.message}`));
+    }
+  }
+
+  function initialize(params) {
+    const requested = params.protocolVersion;
+    legacyVersion = LEGACY_VERSIONS.includes(requested) ? requested : LEGACY_VERSIONS[0];
+    return { protocolVersion: legacyVersion, capabilities: CAPABILITIES, serverInfo, instructions: INSTRUCTIONS };
+  }
+
+  /** A request is modern when it carries a protocol version in `_meta`; legacy once initialized. */
+  function isModernRequest(method, params) {
+    const meta = params?._meta;
+    const requested = meta?.[META_VERSION];
+    if (requested !== undefined) {
+      if (!MODERN_VERSIONS.includes(requested)) {
+        throw new RpcError(ERROR_CODES.unsupportedVersion, 'Unsupported protocol version', { supported: SUPPORTED_VERSIONS, requested });
+      }
+      const capabilities = meta[META_CAPABILITIES];
+      if (typeof capabilities !== 'object' || capabilities === null || Array.isArray(capabilities)) {
+        throw new RpcError(ERROR_CODES.invalidParams, `Missing _meta["${META_CAPABILITIES}"]: every ${requested} request carries the client capabilities.`);
+      }
+      return true;
+    }
+    if (legacyVersion || method === 'ping') return false;
+    throw new RpcError(
+      ERROR_CODES.invalidParams,
+      `Missing _meta["${META_VERSION}"]. Send initialize first (protocol ${LEGACY_VERSIONS[0]} and earlier) or include the per-request _meta of ${MODERN_VERSIONS[0]}.`,
+      { supported: SUPPORTED_VERSIONS },
+    );
+  }
+
+  async function dispatch(method, params, modern) {
+    switch (method) {
+      case 'server/discover':
+        if (!modern) break;
+        return { supportedVersions: MODERN_VERSIONS, capabilities: CAPABILITIES, instructions: INSTRUCTIONS };
+      case 'ping':
+        return {};
+      case 'tools/list':
+        return { tools: listTools() };
+      case 'tools/call': {
+        const { name, arguments: args } = params;
+        if (typeof name !== 'string' || !hasTool(name)) throw new RpcError(ERROR_CODES.invalidParams, `Unknown tool: ${name}`);
+        if (args !== undefined && (typeof args !== 'object' || args === null || Array.isArray(args))) {
+          throw new RpcError(ERROR_CODES.invalidParams, 'tools/call arguments must be an object.');
+        }
+        return callTool(name, args ?? {}, { defaultDir });
+      }
+    }
+    throw new RpcError(ERROR_CODES.methodNotFound, `Method not found: ${method}`);
+  }
+
+  return { handle };
+}
+
+/**
+ * Serves newline-delimited JSON-RPC over stdio until the input closes. Only protocol messages
+ * are written to `output`; a cancelled request gets no reply, as the transport requires.
+ */
+export async function serveStdio({ version, defaultDir, input = process.stdin, output = process.stdout }) {
+  const server = createMcpServer({ version, defaultDir });
+  const inFlight = new Set();
+  const cancelled = new Set();
+  const pending = new Set();
+  const lines = createInterface({ input, crlfDelay: Infinity });
+
+  const write = (message) => {
+    if (!output.writableEnded && !output.destroyed) output.write(`${JSON.stringify(message)}\n`);
+  };
+  // The client closing its end mid-reply is a shutdown, not a crash.
+  output.on('error', () => lines.close());
+
+  lines.on('line', (line) => {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      write(failure(null, new RpcError(ERROR_CODES.parse, 'Parse error: each line must be one JSON-RPC message.')));
+      return;
+    }
+    if (message?.method === 'notifications/cancelled') {
+      const target = message.params?.requestId;
+      if (inFlight.has(target)) cancelled.add(target);
+      return;
+    }
+
+    const id = Object.hasOwn(message ?? {}, 'id') ? message.id : undefined;
+    if (id !== undefined) inFlight.add(id);
+    const task = server.handle(message).then((response) => {
+      inFlight.delete(id);
+      if (cancelled.delete(id) || !response) return;
+      write(response);
+    });
+    pending.add(task);
+    task.finally(() => pending.delete(task));
+  });
+
+  await once(lines, 'close');
+  await Promise.allSettled([...pending]);
+}
+
+function requestId(id) {
+  return typeof id === 'string' || typeof id === 'number' ? id : null;
+}
+
+function success(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function failure(id, error) {
+  return { jsonrpc: '2.0', id, error: { code: error.code, message: error.message, ...(error.data !== undefined && { data: error.data }) } };
+}

package/core/mcp/tools.mjs

@@ -0,0 +1,226 @@
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+import {
+  debugPayload,
+  detectPayload,
+  doctorPayload,
+  releasePayload,
+  reviewPayload,
+  routePayload,
+  testPayload,
+} from '../commands/payloads.mjs';
+import { resolveProjectDir } from '../config/project.mjs';
+import { PLUGIN_ROOT } from '../paths.mjs';
+import { INTENT_IDS } from '../router/intents.mjs';
+
+/** Agents, skills and the brief contract the agents link to; nothing else in the package. */
+const READABLE = ['agents', 'skills', join('docs', 'agent-context.md')];
+const MAX_READ_BYTES = 512 * 1024;
+
+const DIR = {
+  type: 'string',
+  description:
+    'Absolute path of the mobile app, or of a repository whose .reis-mobile/config.yaml points at it. ' +
+    'Defaults to the --dir given to `reis-mobile mcp`, then to the server working directory.',
+};
+const BASE = { type: 'string', description: 'Git ref to compare as <base>...HEAD, such as main. Omit to use uncommitted changes.' };
+
+// Every tool reads the project or the package and runs only local, read-only commands (git,
+// toolchain --version). None edits files, builds, runs tests or calls a network service.
+const READ_ONLY = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+
+const TOOLS = [
+  {
+    name: 'reis_mobile_route',
+    title: 'Route a mobile request',
+    description:
+      'Resolve a request to the reis-mobile specialist agent and skills for the detected stack. ' +
+      'Returns the intent, agent and skill instruction paths: read them with reis_mobile_read_instructions and follow them. ' +
+      'Pass a prompt, an intent, or both.',
+    properties: {
+      prompt: { type: 'string', description: 'The request in English or Portuguese, such as "the Android build of my Flutter app broke".' },
+      intent: { type: 'string', enum: INTENT_IDS, description: 'Force an intent instead of detecting it from the prompt.' },
+      dir: DIR,
+    },
+    run: ({ project, prompt, intent }) => {
+      if (!prompt && !intent) throw new ToolInputError('Pass a prompt, an intent, or both.');
+      return routePayload({ project, prompt, intent });
+    },
+  },
+  {
+    name: 'reis_mobile_review',
+    title: 'Prepare a mobile code review',
+    description:
+      'Route a code review to the review agent and skills and collect the git diff to review: uncommitted changes, ' +
+      'or <base>...HEAD. Lock files and generated code are excluded and secrets are masked. Does not review by itself.',
+    properties: {
+      prompt: { type: 'string', description: 'Optional focus, such as "focus on security".' },
+      base: BASE,
+      dir: DIR,
+    },
+    run: ({ project, prompt, base }) => reviewPayload({ project, prompt, base }),
+  },
+  {
+    name: 'reis_mobile_debug',
+    title: 'Prepare a build or runtime debug',
+    description:
+      'Route a build or runtime failure (Gradle, Xcode, CocoaPods, Metro, pub, crashes) to the debug agent and skills, ' +
+      'with the doctor report of the installed toolchain versions. Does not change the project or its caches.',
+    properties: {
+      problem: { type: 'string', description: 'The error, failing command or symptom, such as "pod install fails on CI".' },
+      dir: DIR,
+    },
+    run: ({ project, problem }) => debugPayload({ project, prompt: problem }),
+  },
+  {
+    name: 'reis_mobile_test',
+    title: 'Prepare mobile test work',
+    description:
+      'Route a test request to the test agent and skills for the stack, with the git diff and toolchain checks. ' +
+      'Does not run tests: the agent runs, writes or audits them after reading the instructions.',
+    properties: {
+      request: { type: 'string', description: 'What to test, such as "write regression tests for the checkout cubit".' },
+      base: BASE,
+      dir: DIR,
+    },
+    run: ({ project, request, base }) => testPayload({ project, prompt: request, base }),
+  },
+  {
+    name: 'reis_mobile_release',
+    title: 'Prepare release readiness evidence',
+    description:
+      'Route a release readiness audit to the release engineer with the candidate platforms, reference paths, ' +
+      'git context and toolchain checks. Does not build, sign, upload or evaluate readiness: the verdict is null.',
+    properties: {
+      request: { type: 'string', description: 'What to audit, such as "Android production and iOS App Store".' },
+      dir: DIR,
+    },
+    run: ({ project, request }) => releasePayload({ project, prompt: request }),
+  },
+  {
+    name: 'reis_mobile_detect',
+    title: 'Detect the mobile stack',
+    description:
+      'Detect the stack of a project from its build files: Flutter, React Native or Expo, Kotlin Multiplatform, ' +
+      'native Android or native iOS, with languages, target platforms and the evidence for each.',
+    properties: { dir: DIR },
+    run: ({ project }) => detectPayload({ project }),
+  },
+  {
+    name: 'reis_mobile_doctor',
+    title: 'Diagnose the mobile environment',
+    description:
+      'Check the SDKs and project files that matter for the detected stack: Flutter, Dart, Java, Android SDK, Xcode, ' +
+      'CocoaPods, the Gradle wrapper and lock files. Reads versions only; installs nothing.',
+    properties: {
+      all: { type: 'boolean', description: 'Check every tool, not only those for the detected stack.' },
+      dir: DIR,
+    },
+    run: ({ project, all }) => doctorPayload({ project, all }),
+  },
+  {
+    name: 'reis_mobile_read_instructions',
+    title: 'Read reis-mobile instructions',
+    description:
+      'Read an agent, skill or reference file shipped with reis-mobile: the agent and skill paths the other tools ' +
+      'return, or a link inside one of those files resolved against that file\'s own path. Accepts an absolute path ' +
+      'inside the package or a path relative to it, such as skills/mobile-debug/SKILL.md.',
+    properties: {
+      path: { type: 'string', description: 'The file to read, such as skills/mobile-debug/references/ios.md.' },
+    },
+    required: ['path'],
+    readsProject: false,
+    run: ({ path }) => readInstructions(path),
+  },
+];
+
+const BY_NAME = new Map(TOOLS.map((tool) => [tool.name, tool]));
+
+/** Thrown for arguments a model can correct; reported as a tool result with isError. */
+class ToolInputError extends Error {}
+
+export function listTools() {
+  return TOOLS.map(({ name, title, description, properties, required }) => ({
+    name,
+    title,
+    description,
+    inputSchema: { type: 'object', properties, ...(required && { required }), additionalProperties: false },
+    annotations: { title, ...READ_ONLY },
+  }));
+}
+
+export function hasTool(name) {
+  return BY_NAME.has(name);
+}
+
+/**
+ * Runs a tool and returns its MCP result. Mistakes the model can fix (wrong arguments, a missing
+ * directory) and failures inside the core come back with isError, so the model sees them.
+ */
+export async function callTool(name, args = {}, { defaultDir = process.cwd() } = {}) {
+  const tool = BY_NAME.get(name);
+  if (!tool) return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  try {
+    validateArguments(tool, args);
+    if (tool.readsProject === false) return { content: [{ type: 'text', text: await tool.run(args) }] };
+
+    const project = resolveToolProject(args.dir, defaultDir);
+    const payload = await tool.run({ ...args, project });
+    const warnings = project.warnings.map((warning) => ({ type: 'text', text: `! ${warning}` }));
+    return {
+      content: [...warnings, { type: 'text', text: JSON.stringify(payload, null, 2) }],
+      structuredContent: payload,
+    };
+  } catch (error) {
+    return { content: [{ type: 'text', text: error.message }], isError: true };
+  }
+}
+
+function validateArguments(tool, args) {
+  if (typeof args !== 'object' || args === null || Array.isArray(args)) {
+    throw new ToolInputError(`${tool.name} takes an object of arguments.`);
+  }
+  const allowed = Object.keys(tool.properties);
+  for (const [key, value] of Object.entries(args)) {
+    const schema = tool.properties[key];
+    if (!schema) throw new ToolInputError(`Unknown argument "${key}" for ${tool.name}. Allowed: ${allowed.join(', ')}.`);
+    if (value === undefined || value === null) continue;
+    if (typeof value !== schema.type) throw new ToolInputError(`"${key}" must be a ${schema.type}, got ${typeof value}.`);
+    if (schema.enum && !schema.enum.includes(value)) {
+      throw new ToolInputError(`"${key}" must be one of: ${schema.enum.join(', ')}. Got "${value}".`);
+    }
+  }
+  for (const key of tool.required ?? []) {
+    if (typeof args[key] !== 'string' || !args[key].trim()) throw new ToolInputError(`"${key}" is required.`);
+  }
+}
+
+function resolveToolProject(dir, defaultDir) {
+  const requested = resolve(defaultDir, dir ?? '.');
+  if (!existsSync(requested) || !statSync(requested).isDirectory()) {
+    throw new ToolInputError(`Directory not found: ${requested}. Pass the absolute path of the mobile app as "dir".`);
+  }
+  return resolveProjectDir(requested);
+}
+
+/** Resolves symlinks before the containment check, so a link cannot point outside the package. */
+async function readInstructions(path) {
+  const requested = isAbsolute(path) ? path : join(PLUGIN_ROOT, path);
+  if (!existsSync(requested) || !statSync(requested).isFile()) {
+    throw new ToolInputError(`No file at ${requested}. Use a path returned by another reis-mobile tool, or one relative to ${PLUGIN_ROOT}.`);
+  }
+  const root = realpathSync(PLUGIN_ROOT);
+  const real = realpathSync(requested);
+  const inside = relative(root, real);
+  const readable = READABLE.some((entry) => inside === entry || inside.startsWith(`${entry}${sep}`));
+  if (!readable || inside.startsWith('..') || isAbsolute(inside)) {
+    throw new ToolInputError(`${path} is outside the readable instructions: ${READABLE.join(', ')} in ${root}.`);
+  }
+  const { size } = statSync(real);
+  if (size > MAX_READ_BYTES) throw new ToolInputError(`${inside} is ${size} bytes, above the ${MAX_READ_BYTES}-byte limit.`);
+
+  // Commands and skills written for Claude Code refer to the package as ${CLAUDE_PLUGIN_ROOT}.
+  return `File: ${real}\nPackage root (\${CLAUDE_PLUGIN_ROOT}): ${root}\n\n${await readFile(real, 'utf8')}`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reis-mobile",
-  "version": "0.10.1",
-  "description": "AI agents and skills for Flutter, Android, iOS, React Native and Kotlin Multiplatform — a Claude Code and Codex plugin for reviews, debugging, tests, architecture, security and Firebase.",
+  "version": "1.0.1",
+  "description": "AI agents and skills for Flutter, Android, iOS, React Native and Kotlin Multiplatform — a Claude Code and Codex plugin and an MCP server for reviews, debugging, tests, architecture, security and Firebase.",
   "type": "module",
   "license": "MIT",
   "author": "Warleson Reis",
@@ -55,6 +55,10 @@
     "agent-skills",
     "skills",
     "ai-agents",
-    "code-review"
+    "code-review",
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "cursor"
   ]
 }

package/skills/mobile-code-review/SKILL.md

@@ -32,7 +32,9 @@ In a cross-platform app, native code in `android/`, `ios/` or native modules get
 
 - Open the code and confirm every suspicion. A finding without evidence at `file:line` does not go in the report.
 - Do not invent APIs, versions or lint rules. Check the lock files and build files (`pubspec.lock`, version catalog, `Package.resolved`, `package.json`) before claiming something is missing, deprecated or unavailable.
-- Do not report style that a configured linter already enforces.
+- Start with the project's configured analyzers, linters and relevant tests. Reuse results that match the reviewed revision and scope; run existing checks when available and permitted. If results are unavailable, stale or checks cannot run, disclose that limitation instead of assuming they passed.
+- Keep confirmed tool diagnostics (including correctness and security diagnostics, not just style) in the checks summary; do not present them again as independent AI findings. Do not suppress a concrete defect merely because a rule might cover it: verify the rule is enabled and its output applies to the reviewed code. Trace any additional consequence beyond a diagnostic before claiming added value.
+- Spend review effort on concrete behavior across files, lifecycle transitions and API contracts. Require a trigger and code evidence; illustrative scenarios are not findings. When a recurring defect has a precise condition, recommend a regression test or lint rule to enforce it.
 - When the project deliberately does something differently and it is coherent, say so instead of flagging it.
 
 ## 4. What always matters, on any stack
@@ -69,3 +71,5 @@ Prioritized list. For each item: file:line, problem, why it matters, fix.
 ```
 
 Write "No findings." in a section with nothing to report.
+
+Include checks executed or reused, their revision/scope and results, confirmed tool diagnostics, and checks not run in the Summary. Keep additional review findings separate from those diagnostics; never imply that a clean review guarantees correctness.

package/skills/mobile-security/references/ios/keychain.md

@@ -0,0 +1,105 @@
+# Store tokens in the iOS Keychain
+
+Use Keychain Services for small secrets such as access and refresh tokens. Choose access and sharing rules from the app's actual lifecycle and threat model; a token in the Keychain is still a bearer credential and must be handled carefully after reading it.
+
+## Review checklist
+
+1. **Remove plaintext token copies.** Do not store tokens in `UserDefaults`, property lists, logs, analytics, crash reports or URLs. Find and delete the old copy after a successful migration.
+2. **Choose the accessibility class.** Use `kSecAttrAccessibleWhenUnlockedThisDeviceOnly` for foreground-only secrets that should not migrate to a different device. If background work needs the token after the first unlock, consider `kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly`. Select a class based on when the app needs access; avoid the deprecated `kSecAttrAccessibleAlways*` classes. Verify current behavior in Apple's documentation.
+3. **Decide backup and device migration behavior.** A `ThisDeviceOnly` class prevents migration when restoring a backup to another device; it can still be restored to the device that created the backup. Non-`ThisDeviceOnly` classes may migrate with encrypted backups. Do not assume this is equivalent to deleting an item during backup or restore.
+4. **Gate access with biometrics only when required.** A biometric prompt that returns a Boolean does not protect the stored token. When the product requires biometric gating, attach a `SecAccessControl` created with an appropriate flag such as `.biometryCurrentSet` to the item. Handle authentication cancellation and enrollment changes by requiring reauthentication. Do not add a prompt to every token read unless that is the intended user experience.
+5. **Share only with intended targets.** Use a Keychain access group only when an app extension or companion target must read the item. Configure the entitlement for each target and use the same explicit access-group identifier in the query. Keep unrelated targets out of the group.
+6. **Handle reinstall and logout deliberately.** Keychain credentials can remain available after an app is removed and reinstalled, so do not treat reinstall as logout. On logout, revoke the server-side session as appropriate and delete the item's Keychain entry. On launch, validate any recovered session with the server and provide an explicit sign-out path.
+
+## Basic token store
+
+This example stores one generic-password item per service and account. It updates an existing item, returns `nil` when no token exists, treats deleting a missing item as success, and surfaces other `OSStatus` failures to the caller.
+
+```swift
+import Foundation
+import Security
+
+enum TokenStoreError: Error {
+    case keychain(OSStatus)
+    case invalidData
+}
+
+struct TokenStore {
+    private let service = "com.example.app.auth"
+    private let account = "refresh-token"
+
+    private var identity: [String: Any] {
+        [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account
+        ]
+    }
+
+    func save(_ token: String) throws {
+        guard let data = token.data(using: .utf8) else {
+            throw TokenStoreError.invalidData
+        }
+
+        let query = identity
+        let update: [String: Any] = [kSecValueData as String: data]
+        let updateStatus = SecItemUpdate(query as CFDictionary, update as CFDictionary)
+
+        if updateStatus == errSecItemNotFound {
+            var item = query
+            item[kSecValueData as String] = data
+            item[kSecAttrAccessible as String] = kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+            let addStatus = SecItemAdd(item as CFDictionary, nil)
+            guard addStatus == errSecSuccess else {
+                throw TokenStoreError.keychain(addStatus)
+            }
+        } else if updateStatus != errSecSuccess {
+            throw TokenStoreError.keychain(updateStatus)
+        }
+    }
+
+    func read() throws -> String? {
+        var query = identity
+        query[kSecReturnData as String] = true
+        query[kSecMatchLimit as String] = kSecMatchLimitOne
+
+        var result: CFTypeRef?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecItemNotFound {
+            return nil
+        }
+        guard status == errSecSuccess else {
+            throw TokenStoreError.keychain(status)
+        }
+        guard let data = result as? Data,
+              let token = String(data: data, encoding: .utf8) else {
+            throw TokenStoreError.invalidData
+        }
+        return token
+    }
+
+    func delete() throws {
+        let status = SecItemDelete(identity as CFDictionary)
+        guard status == errSecSuccess || status == errSecItemNotFound else {
+            throw TokenStoreError.keychain(status)
+        }
+    }
+}
+```
+
+When biometrics are required, create a `SecAccessControl` with the chosen accessibility and flags, then provide it as `kSecAttrAccessControl` when adding the item. Do not combine it with `kSecAttrAccessible`; the access-control object carries the protection class.
+
+## Migrate from `UserDefaults`
+
+1. Read the legacy value only if present.
+2. Save it to the Keychain and confirm the Keychain operation succeeded.
+3. Remove the legacy value and persist that removal.
+4. Keep the migration idempotent: if the Keychain already has a token, prefer it and remove any stale legacy copy. If migration fails, do not silently discard the only credential; prompt for sign-in if recovery is not safe.
+
+## Apple documentation
+
+- [Restricting Keychain item accessibility](https://developer.apple.com/documentation/security/restricting-keychain-item-accessibility)
+- [Sharing Keychain items among a collection of apps](https://developer.apple.com/documentation/security/sharing-access-to-keychain-items-among-a-collection-of-apps)
+- [SecAccessControlCreateWithFlags](https://developer.apple.com/documentation/security/secaccesscontrolcreatewithflags(_:_:_:_:))
+- [Updating and deleting Keychain items](https://developer.apple.com/documentation/security/updating-and-deleting-keychain-items)
+- [Using the Keychain to manage user secrets](https://developer.apple.com/documentation/security/using-the-keychain-to-manage-user-secrets)

package/skills/mobile-security/references/ios.md

@@ -9,7 +9,7 @@ Apply after the general checks in `SKILL.md`, to native iOS apps and to the `ios
 
 ## Storage and credentials
 
-- [ ] Tokens in `UserDefaults`, property lists or files instead of the Keychain.
+- [ ] Tokens in `UserDefaults`, property lists or files instead of the Keychain. Store and migrate them as in [ios/keychain.md](ios/keychain.md).
 - [ ] Keychain items with permissive accessibility (`kSecAttrAccessibleAlways*`, deprecated) instead of `...WhenUnlocked` or `...AfterFirstUnlock`; `ThisDeviceOnly` variants for secrets that must not migrate to other devices through backups.
 - [ ] Files with sensitive data written without an appropriate Data Protection class.
 - [ ] Biometrics checked with `LAContext.evaluatePolicy` only as a boolean when they guard credentials; protect the Keychain item with `SecAccessControl` and biometry instead.