reis-mobile 0.7.2 → 0.7.3

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "reis-mobile",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "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,13 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). The pr
 
 ## [Unreleased]
 
+## [0.7.3] - 2026-09-21
+
+### Added
+
+- `/reis-mobile:release [request]` and entry-command forwarding audit mobile store readiness with per-target identity, pass/fail/unknown evidence gates and GO/GO WITH RISKS/NO-GO verdicts. A packaged helper rejects incomplete evidence; audits remain read-only by default.
+- `reis-mobile release` prepares routing, redacted git context, diagnostics and release references for all five stacks, including both native artifacts in cross-platform apps. A public Flutter sample audit demonstrates the report and external verification limits.
+
 ## [0.7.2] - 2026-09-18
 
 ### Added

package/README.md

@@ -44,20 +44,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.7.2
+### v0.7.3
 
 #### Added
 
-- Kotlin Multiplatform architect, test and performance specialists, a `mobile-kmp` platform skill and focused KMP references in the eight cross-stack topic skills. Routing and coverage tests guard the new paths.
-- `/reis-mobile:project [feature]` creates or refreshes a verified app object map in `.reis-mobile/project.md` while preserving team-authored product context.
-
-#### Changed
-
-- Specialist guidance distinguishes configured shared source sets, Android/iOS host behavior and target-specific validation; the shared brief verifies profile paths and separates team knowledge from code evidence.
-
-#### Fixed
-
-- Release automation opens a pull request for synchronized files instead of pushing directly to a protected `main` branch, and waits for those changes to merge before tagging and publishing.
+- `/reis-mobile:release [request]` and entry-command forwarding audit mobile store readiness with per-target identity, pass/fail/unknown evidence gates and GO/GO WITH RISKS/NO-GO verdicts. A packaged helper rejects incomplete evidence; audits remain read-only by default.
+- `reis-mobile release` prepares routing, redacted git context, diagnostics and release references for all five stacks, including both native artifacts in cross-platform apps. A public Flutter sample audit demonstrates the report and external verification limits.
 
 <!-- reis-mobile:latest-release:end -->
 
@@ -230,7 +222,7 @@ After editing agents, skills or commands, restart Claude Code or Codex.
 ## Commands
 
 ```bash
-/reis-mobile                                      # Lists the commands (also accepts doctor, project, review, debug, test, debate or a free-form request)
+/reis-mobile                                      # Lists the commands (also accepts doctor, project, review, debug, test, release, debate or a free-form request)
 /reis-mobile my android build fails on gradle     # Free-form request: detects the stack and applies the right agent and skills
 /reis-mobile:doctor                               # Environment and project: SDKs, Xcode, CocoaPods, Gradle wrapper, lock files
 /reis-mobile:doctor --all                         # Checks every tool, not only those for the detected stack
@@ -242,6 +234,7 @@ After editing agents, skills or commands, restart Claude Code or Codex.
 /reis-mobile:test run the checkout unit tests    # Uses the existing runner, module or scheme
 /reis-mobile:test add XCTest coverage for cancellation # Tests the actual Swift type and its dependency seams
 /reis-mobile:test audit Espresso checkout tests  # Reviews assertions and synchronization without editing
+/reis-mobile:release audit both stores for the production variant # Evidence-backed readiness, read-only
 /reis-mobile:debate Riverpod or BLoC in this app? # Debate between the specialists, with a decision by lead-mobile
 /reis-mobile:debate --rounds 3 --external ...     # More rounds; --external adds Codex and Gemini, if installed
 ```
@@ -267,6 +260,22 @@ reis-mobile test --base main -- "write regression tests for these changes"
 
 Its output includes the resolved project directory, explicit `test` intent, selected specialist and skills, redacted change context, toolchain diagnostics and answer language. `/reis-mobile test ...` forwards to the same slash-command workflow.
 
+### Release readiness
+
+`/reis-mobile:release [request]` audits the actual app artifacts for Flutter, native Android/iOS, React Native/Expo and Kotlin Multiplatform. `/reis-mobile release [request]` forwards to the same workflow. It resolves the app ID, flavor/scheme, environment, version/build, source revision, store/track and binary before evaluating readiness. Apps targeting both stores receive separate Android and iOS checks.
+
+The report lists each required gate as **pass**, **fail** or **unknown**, with evidence and next actions: identity, build, tests, analysis, version, signing, symbols, current store requirements, privacy, listing/localization and rollout/recovery. Any failed or unknown required gate means **NO-GO**. All gates passing means **GO**, or **GO WITH RISKS** when documented non-blocking risks remain. A packaged verdict helper enforces this decision rule; the specialist must still verify the evidence itself.
+
+The audit inspects existing files, artifacts and accessible CI/store records. It does not build, run tests, bump versions, tag, upload or change store settings by default. Missing CI results, upload history or portal confirmations remain unknown; local configuration is not proof that a check passed. Explicit execution requests retain their requested scope and prior authorization.
+
+```bash
+reis-mobile release --dir apps/mobile --json -- "audit Android production and iOS App Store"
+```
+
+The CLI only prepares routing, redacted git context, diagnostics and release reference paths. Its JSON includes `release.platforms` (candidate targets), `release.references`, `release.evidenceStatus: "unverified"` and `release.verdict: null`. Exit 0 does not approve a release. In Codex, ask it to run the CLI, read the returned instructions and follow `mobile-release`'s readiness contract; slash-command parity is not assumed.
+
+See the [readiness contract](skills/mobile-release/references/readiness.md) and [public Flutter sample audit](docs/examples/release-readiness.md) for the report format and evidence limits.
+
 ### Project context
 
 `/reis-mobile:project [feature]` resolves the mobile app, traces real entry points, state owners, data or native boundaries and nearby tests, then creates or refreshes `.reis-mobile/project.md`. In a monorepo it writes beside `.reis-mobile/config.yaml`; otherwise it writes in the app root. The generated section contains only facts tied to code or configuration and identifies unknown product rules. Team-authored sections remain intact on refresh. Agents check its paths and commands against the current checkout before using them.
@@ -320,7 +329,7 @@ The router never invents a specialist: if no agent serves the intent, it warns y
 | Full audit with several specialists | agent `lead-mobile` | ✅ |
 | Decide between two architectures with a real trade-off | `/reis-mobile:debate` | ✅ |
 | Dedicated test command (including XCTest and Espresso) | `/reis-mobile:test` | ✅ |
-| Check whether the app is ready for the store | `/reis-mobile:release` | 🔜 v0.8 |
+| Check whether the app is ready for the store with evidence per target | `/reis-mobile:release` | ✅ |
 | Consolidated decision by consensus between agents | `/reis-mobile:council` | 🔜 v0.10 |
 
 <details>
@@ -428,7 +437,7 @@ About 85 guides come from [flutter/skills](https://github.com/flutter/skills), [
 
 ## Trust, security and limits
 
-**Read-only CLI context.** `doctor`, `detect`, `route`, `review` and `test` do not modify your project. 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/`.
+**Read-only CLI context.** `doctor`, `detect`, `route`, `review`, `test` and `release` 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/`.
 
 **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).
 
@@ -463,7 +472,7 @@ About 85 guides come from [flutter/skills](https://github.com/flutter/skills), [
 | v0.6.0 | Accessibility auditor and release engineer agents, `mobile-accessibility` and `mobile-release` skills, ANR, memory leak and deep link debugging guides | ✅ |
 | v0.7.0 | `/reis-mobile:test`, native tests (XCTest, Espresso) and project-specific specialist contracts | ✅ |
 | v0.7.1 | Update notices, single-source version and release automation | ✅ |
-| v0.8.0 | `/reis-mobile:release` with quality gates | ⏳ |
+| Unreleased | `/reis-mobile:release` with per-target evidence, required gates and deterministic readiness verdicts (previously planned for v0.8.0) | ✅ |
 | v0.9.0 | MCP server | ⏳ |
 | v0.10.0 | Multi-provider (OpenAI, Gemini, OpenRouter, Ollama) beyond the debate's `--external` | ⏳ |
 | v1.0.0 | First stable version: Flutter, Android, iOS and React Native | ⏳ |

package/agents/mobile-release-engineer.md

@@ -21,7 +21,7 @@ Use the [project brief](../docs/agent-context.md) once or reuse the supplied bri
 
 ## Produce the requested artifact
 
-- **Readiness:** apply the skill checklist to this release identity. Each gate is pass/fail/unknown with evidence and the responsible owner or next check. Verify current store requirements from official sources; local code cannot prove console approval or highest uploaded build number.
+- **Readiness:** apply the [readiness contract](../skills/mobile-release/references/readiness.md) and its verdict helper to this release identity. Unknown or failed required gates block readiness; evaluate each intended native artifact separately. Each gate is pass/fail/unknown with evidence and the responsible owner or next check. Verify current store requirements from official sources; local code cannot prove console approval or highest uploaded build number.
 - **Release notes:** establish the actual prior/current commit range. Map each user-facing change to commits/PRs, group by the app's feature names, preserve listing locales and check store limits from the reference. Unsupported claims stay out of the notes.
 - **Pipeline:** trace the existing jobs and artifact flow before proposing changes. Specify inputs, output artifact paths, secret names, build matrix and the dependency that prevents upload after failed checks. Keep build, signing and publishing steps independently identifiable.
 - **Rollout incident:** tie crash/ANR or adoption evidence to the affected build/cohort. Name the available halt, server flag or higher-build hotfix path from this app's deployment model, and state who remains exposed after a halt.

package/bin/reis-mobile.mjs

@@ -11,6 +11,7 @@ import { runDoctor } from '../core/diagnostics/doctor.mjs';
 import { runInit } from '../core/install/init.mjs';
 import { PLUGIN_ROOT } from '../core/paths.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';
@@ -28,6 +29,7 @@ Commands:
   review [prompt...]         Route a code review and collect the git context for it
   debug [problem...]         Route a build or runtime failure and report the toolchain it runs on
   test [request...]          Prepare test routing, git context and toolchain checks (does not run tests)
+  release [request...]       Prepare release evidence context (does not build or publish)
   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
@@ -72,6 +74,7 @@ const COMMANDS = {
   review: commandReview,
   debug: commandDebug,
   test: commandTest,
+  release: commandRelease,
   agents: (options) => commandList('agents', options),
   skills: (options) => commandList('skills', options),
   stacks: (options) => commandList('stacks', options),
@@ -106,7 +109,7 @@ async function main(argv) {
   return (await command({ ...options, dir: project.projectDir, project, prompt: rest.join(' ') })) ?? 0;
 }
 
-const PROJECT_COMMANDS = new Set(['detect', 'doctor', 'route', 'review', 'debug', 'test']);
+const PROJECT_COMMANDS = new Set(['detect', 'doctor', 'route', 'review', 'debug', 'test', 'release']);
 
 async function commandUpdateCheck({ force, json }) {
   const result = await checkForUpdate({ force });
@@ -277,6 +280,26 @@ async function commandTest({ dir, project, base, prompt, json, lang }) {
   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 });
+
+  printProject(project, true);
+  printRoute(result);
+  printLanguage(language);
+  printContext(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);
+  return 0;
+}
+
 async function commandList(kind, { json }) {
   const registry = await loadRegistry();
   const items = registry[kind];

package/commands/reis-mobile.md

@@ -1,6 +1,6 @@
 ---
-description: reis-mobile entry point — lists the commands or forwards to doctor, project, review, debug, test, debate or the right agent from a free-form request
-argument-hint: "[doctor | project | review | debug | test | debate | free-form request]"
+description: reis-mobile entry point — lists the commands or forwards to doctor, project, review, debug, test, release, debate or the right agent from a free-form request
+argument-hint: "[doctor | project | review | debug | test | release | debate | free-form request]"
 allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Read", "Grep", "Glob", "Edit", "Write"]
 ---
 
@@ -24,6 +24,7 @@ Reply only with this list. The only thing to run is `node "${CLAUDE_PLUGIN_ROOT}
 /reis-mobile:review [--base <ref>]   Code review of the changes (or the whole project)
 /reis-mobile:debug <problem>         Finds the cause of a build or runtime failure and proposes the fix
 /reis-mobile:test [request]          Runs, writes, audits or fixes tests using the project's test setup
+/reis-mobile:release [request]       Audits store readiness with evidence and a go/no-go verdict
 /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
 ```
@@ -55,6 +56,10 @@ Read `${CLAUDE_PLUGIN_ROOT}/commands/debate.md` and follow all of it, treating t
 
 Read `${CLAUDE_PLUGIN_ROOT}/commands/test.md` and follow all of it, treating the rest of the arguments (without the word `test`) as `$ARGUMENTS`. This entry point has the same behavior as `/reis-mobile:test`.
 
+## `release [request]`
+
+Read `${CLAUDE_PLUGIN_ROOT}/commands/release.md` and follow all of it, treating the rest of the arguments (without the word `release`) as `$ARGUMENTS`. This entry point has the same behavior as `/reis-mobile:release`.
+
 ## Any other text
 
 It is a free-form request, in English or Portuguese.

package/commands/release.md

@@ -0,0 +1,46 @@
+---
+description: Audit mobile release readiness with per-target evidence, store quality gates and a GO/GO WITH RISKS/NO-GO verdict
+argument-hint: "[request, version, variant or target store/track]"
+allowed-tools: ["Bash(node:*)", "Bash(git:*)", "Read", "Grep", "Glob", "WebFetch", "WebSearch"]
+---
+
+# reis-mobile release
+
+Arguments received: `$ARGUMENTS`
+
+## 1. Prepare context
+
+Run:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/bin/reis-mobile.mjs" release --dir "$PWD" -- "<request>"
+```
+
+Pass the request as a single literal argument after `--`, or omit it when empty. Use proper shell escaping: double quotes alone do not protect `$()`, backticks or embedded quotes. Never evaluate the request as shell code. The CLI forces `release` intent even if the request mentions a build failure. Stop and show the error if context preparation fails. Exit 0 means context preparation succeeded, not that a release is ready.
+
+Use `Project` (`detection.projectDir` in JSON) as the app root and `context.repoRoot` for git-relative paths. The CLI lists candidate release platforms and reference paths (`release.platforms` and `release.references`); they are unverified inventory, not a verdict. Inspect untracked files and required files omitted by diff truncation. The git diff alone is not release evidence.
+
+If the resolved directory does not exist or `detection.stack` is `unknown`, report NO-GO with unresolved identity/targets and the exact app path needed. Do not use a stack inferred from the prompt as evidence of an app on disk. Feed an empty `targets` array to the verdict helper rather than inventing artifacts.
+
+## 2. Bind the release to the app
+
+Read in order:
+
+1. `${CLAUDE_PLUGIN_ROOT}/docs/agent-context.md`; build or reuse the Project brief from the resolved app root.
+2. `${CLAUDE_PLUGIN_ROOT}/agents/<Agent>.md`, normally `mobile-release-engineer`.
+3. `${CLAUDE_PLUGIN_ROOT}/skills/<skill>/SKILL.md` for each routed skill, including `mobile-release`.
+4. `${CLAUDE_PLUGIN_ROOT}/skills/mobile-release/references/readiness.md` and each relevant release reference from the CLI output.
+
+Apply the selected role directly, or pass the existing brief to that specialist when delegation is available and appropriate. Do not repeat project discovery. Resolve the actual app ID, flavor/scheme/environment, version/build, source revision, store/track and built artifact for each target. For every field, record its source and distinguish configured values from values verified in the built artifact. Without an explicit request, inventory configured mobile targets and existing artifacts; leave ambiguous destinations and missing artifacts unknown.
+
+Flutter, React Native/Expo and Kotlin Multiplatform shipping to Android and iOS require both native release references and separate artifact checks. Confirm hosts/targets in the build configuration; a KMP framework build is not an iOS archive. Honor an explicitly limited store scope and name exclusions. Native folders generated by Expo need configuration inspection, not prebuild during the audit.
+
+## 3. Audit, evaluate and report
+
+Follow the required gates, evidence rules, verdict helper and report format in `readiness.md`. Reconcile local facts with existing artifact metadata, actual CI results and current official store requirements. Do not claim a store or CI check passed from local configuration alone. If external information is unavailable, identify the exact confirmation needed.
+
+Run `${CLAUDE_PLUGIN_ROOT}/skills/mobile-release/scripts/verdict.mjs` with the actual per-target gates on stdin as described in the reference. Missing evidence must remain unknown. Report its GO, GO WITH RISKS or NO-GO verdict with release identity, gate evidence, blockers, risks, unknowns, next actions and rollout/rollback. Its exit status is not a readiness verdict.
+
+The audit is read-only by default: no builds/tests, version bump, tag, upload, signing change or store-setting change. An explicit release execution request follows the selected agent's scope rules and prior authorization; never execute a publishing lane just because it exists. Distinguish commands inspected/prepared from those actually executed.
+
+Write user-facing prose in the CLI's `Language`: `en` is English, `pt` is Brazilian Portuguese; with `-` or `null`, follow the user's language. Keep paths, gate IDs, verdicts and quoted output unchanged.

package/core/release/context.mjs

@@ -0,0 +1,11 @@
+import { join } from 'node:path';
+
+import { PLUGIN_ROOT } from '../paths.mjs';
+
+/** Detection suggests references, never proves store targets or release readiness. */
+export function releaseContext(detection) {
+  const platforms = detection.platforms.filter((platform) => ['android', 'ios'].includes(platform));
+  const references = detection.stack === 'unknown' ? [] : [...new Set([detection.stack, ...platforms])]
+    .map((stack) => join(PLUGIN_ROOT, 'skills/mobile-release/references', `${stack}.md`));
+  return { platforms, references, evidenceStatus: 'unverified', verdict: null };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reis-mobile",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "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.",
   "type": "module",
   "license": "MIT",

package/skills/mobile-release/SKILL.md

@@ -13,6 +13,7 @@ One release process for every mobile stack. This file holds the process and what
 
 | Need | Read |
 |---|---|
+| Evidence-backed readiness audit, verdict and report | [references/readiness.md](references/readiness.md) |
 | Flutter app | [references/flutter.md](references/flutter.md) |
 | Native Android, or the Android build of any app | [references/android.md](references/android.md) |
 | Native iOS, or the iOS build of any app | [references/ios.md](references/ios.md) |
@@ -25,11 +26,13 @@ Flutter and React Native apps also need the Android and iOS references for signi
 
 ## 2. Readiness checklist
 
-Check each item against the project, not against memory. Mark each one **pass**, **fail** (with `file:line` or the missing artifact) or **unknown** (needs information only the team has, such as the store console state).
+For readiness audits, first follow [the readiness contract](references/readiness.md): resolve each artifact identity, collect per-target evidence and apply its required gates and deterministic verdict helper.
+
+Check each item against the project, not against memory. For the readiness verdict, a missing artifact or unavailable check is **unknown**; use **fail** only for an observed failure with evidence. Record a source reference and next action for every gate.
 
 **Version**
-- [ ] The version name follows the project's scheme and changed since the last release tag (`git describe --tags --abbrev=0`).
-- [ ] The build number is higher than any build already uploaded. Both stores reject a build number they have seen.
+- [ ] The version name follows the app's actual versioning scheme and is verified in the artifact and applicable CI overrides.
+- [ ] The build number satisfies the destination store’s numbering scope, verified against upload history: Android versionCode increases across tracks; iOS build numbers must be unused within the applicable version train. See the native references.
 - [ ] Android, iOS and any cross-platform manifest (`pubspec.yaml`, `app.json`) agree on the version.
 
 **Build quality**
@@ -47,25 +50,10 @@ Check each item against the project, not against memory. Mark each one **pass**,
 **Rollout**
 - [ ] Staged rollout (Play) or phased release (App Store) planned for updates, with the crash-free and ANR metrics to watch and the threshold that halts it.
 - [ ] Rollback plan: stores do not roll back a binary. Halting a rollout stops new installs; users who updated need a new build with a higher build number, a server-side kill switch or a remote config flag. Know which one applies before shipping.
-- [ ] The release commit is tagged and the tag matches the version.
+- [ ] The release commit is tagged and the tag matches the version, when this is the project's release convention.
 
 ## 3. Report
 
-```markdown
-## Release readiness — <app> <version> (<build>)
-Verdict: GO | GO WITH RISKS | NO-GO
-
-### Blockers
-- item — evidence (file:line or missing artifact) — fix
-
-### Risks
-- item — why it matters — mitigation
-
-### Unknown
-- item — who or what can confirm it
-
-### Rollout plan
-Stages, metrics to watch, halt threshold, rollback path.
-```
+Use the [readiness report and decision rules](references/readiness.md#report). Any failed or unknown required gate means **NO-GO**. **GO WITH RISKS** requires all gates to pass with explicitly documented non-blocking risks; **GO** requires no outstanding risks.
 
-A single blocker makes the verdict NO-GO. Do not bump versions, create tags, upload builds or change store settings unless the user asks; propose the exact commands instead.
+Readiness audits inspect existing evidence without running builds/tests or modifying the app. Version bumps, tags, uploads and store changes follow the user's explicit execution scope and existing authorization.

package/skills/mobile-release/references/readiness.md

@@ -0,0 +1,88 @@
+# Evidence-backed readiness audit
+
+Use this contract for `/reis-mobile:release` and any readiness request. Other release tasks (store copy, pipeline implementation, deployment) retain their requested scope.
+
+## Release identity and target coverage
+
+For every intended artifact, record **app/package or bundle ID → flavor/scheme/environment → version/build → source revision → store/track → built artifact** with evidence. Inspect build overrides, CI parameters and artifact metadata; distinguish configured values from values verified in the binary. A directory or configured KMP target does not prove a shippable host exists. A shared framework is not an iOS app archive.
+
+Use detection as an inventory, then confirm actual Android/iOS hosts and requested destinations. Flutter, React Native/Expo and KMP shipping to both stores need separate gate rows for both artifacts. A prompt focusing on Android does not silently approve the iOS artifact. If the user explicitly limits the audit to one store, state the exclusion and do not issue a combined verdict. Expo can generate native folders: inspect app configuration and EAS profiles without running prebuild. Unknown targets or missing binaries stay unknown.
+
+Read the stack reference plus [android.md](android.md) and/or [ios.md](ios.md) for the actual destinations. KMP also needs [kotlin-multiplatform.md](kotlin-multiplatform.md). Do not substitute a shared-code test for a native host test.
+
+## Required gates
+
+Each target has these gate IDs. Every gate is **pass**, **fail**, or **unknown**, with a source reference and an exact next action/owner when unresolved. A failed check needs observed failure evidence; unavailable evidence is unknown. A local config file proves configuration only, not an executed check, successful upload, current console state or store approval.
+
+| ID | Evidence required |
+|---|---|
+| `identity` | All identity fields above, including artifact provenance and agreement with the intended source revision. Record dirty/untracked source and unknown CI overrides. |
+| `build` | Successful release build log/CI job for this revision and artifact, with the actual variant and production environment. A workflow YAML or debug build is insufficient. |
+| `tests` | Actual results for applicable unit/integration/device checks on this revision, with counts and skipped/failed checks. Resolve required suites from project policy and the changed behavior. |
+| `analysis` | Actual lint/static-analysis results for the release revision and applicable targets. Missing tools or logs are unknown, not pass. |
+| `version` | Artifact version/build matched to source/CI inputs and store upload history, applying the platform's numbering scope. Verify the previous release using the project's convention, not merely the closest tag. See [Android versioning](https://developer.android.com/studio/publish/versioning) and [Apple's build identification](https://developer.apple.com/help/app-store-connect/reference/app-information/app-information). |
+| `signing` | Signed artifact verification, intended distribution identity, and applicable entitlements/profile or upload-key setup. Never read or print private keys, passwords or tokens. |
+| `symbols` | Matching R8/native symbols, dSYMs, Dart debug info and/or JS source maps, with archive/upload evidence as required by the app. Verify build IDs/UUIDs or provenance. |
+| `store` | Current official requirement URL and access date, target SDK/toolchain evidence, and any account/track eligibility or review state needed for the intended action. Unavailable portal confirmation stays unknown. |
+| `privacy` | Permissions/data collection and third-party SDK inventory reconciled with manifests, usage descriptions, privacy policy and store disclosures. Local declarations alone do not prove console forms agree. |
+| `listing` | Required locales, release notes/screenshots/metadata, and reviewer access where applicable. Account secrets never enter the report. |
+| `rollout` | Owner, stages, monitoring signals and halt thresholds, plus a verified halt/kill-switch/higher-build hotfix path. Mark proposed thresholds as proposals until accepted. A halt does not revert installed binaries. See [Play staged rollouts](https://support.google.com/googleplay/android-developer/answer/6346149) and [Apple phased releases](https://developer.apple.com/help/app-store-connect/update-your-app/release-a-version-update-in-phases); confirm their current behavior before planning recovery. |
+
+If a requirement within a gate does not apply (for example no R8 mapping when R8 is disabled), cite evidence and the reason; do not omit the gate. A gate can pass with a justified non-applicability statement only after verifying all of its applicable requirements. No gate is waived simply to obtain GO.
+
+Current store rules must be checked against official sources, such as [Google Play target API requirements](https://support.google.com/googleplay/android-developer/answer/11926878) and [Apple's upcoming requirements](https://developer.apple.com/news/upcoming-requirements/). State the exact unresolved confirmation if browsing or store access is unavailable. Do not reuse a date or minimum SDK from memory.
+
+## Decision rule
+
+- **NO-GO:** any required gate fails, is unknown, is missing, or has no supporting evidence. Missing targets also block. Distinguish observed failures from missing verification.
+- **GO WITH RISKS:** every required gate passes and explicitly documented non-blocking risks remain. A risk cannot waive an unresolved required gate.
+- **GO:** every required gate passes and there are no outstanding risks.
+
+The combined verdict covers every included target; one platform passing cannot approve another.
+
+Use [the verdict helper](../scripts/verdict.mjs) to check the report's decision. It validates completeness and consistency, **not the truth of the evidence or whether a risk is truly non-blocking**. Supply JSON on stdin using a quoted heredoc delimiter (no shell expansion):
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/skills/mobile-release/scripts/verdict.mjs" <<'REIS_RELEASE_EVIDENCE'
+{"targets":[{"target":"android:production","gates":[{"id":"build","status":"unknown","evidence":[],"nextAction":"Release owner: provide the release CI job and artifact for the requested revision."}]}],"risks":[]}
+REIS_RELEASE_EVIDENCE
+```
+
+This intentionally incomplete example returns NO-GO. Replace it with the actual targets and all 11 gates; use one target name per artifact/store/track combination. `evidence` is an array of non-empty references (`file:line`, command plus result/log, artifact metadata, CI URL or dated portal confirmation). `nextAction` explains what resolves each fail/unknown. `risks` is an optional array of objects with `id`, `description`, evidence references, `mitigation` and `owner`; include only evidenced issues whose impact truly does not block the release. The auditor is responsible for that classification. Do not place secrets in JSON. Choose a heredoc delimiter absent from the payload. The helper writes only stdout; exit 0 means evaluation succeeded, **not** GO. Malformed input exits 1 and must be corrected before reporting a verdict. Preserve returned unknowns and blockers; do not manually upgrade the result.
+
+## Report
+
+Write in the requested language; keep gate IDs and verdict identifiers stable.
+
+```markdown
+## Release readiness — <app> <version/build>
+Verdict: GO | GO WITH RISKS | NO-GO
+Scope: <included artifacts/stores/tracks and explicit exclusions>
+
+### Release identity
+| Target | App ID | Variant/environment | Version/build | Revision | Store/track | Artifact | Evidence |
+|---|---|---|---|---|---|---|---|
+
+### Gates
+| Target | Gate | Status | Evidence / missing confirmation | Next action / owner |
+|---|---|---|---|---|
+
+### Blockers
+Observed failures and unverified required gates, separately identified.
+
+### Risks
+Non-blocking risks, mitigation and owner.
+
+### Unknowns
+Missing evidence and the exact external confirmation needed.
+
+### Next actions
+Ordered resolution steps; commands prepared versus commands actually executed.
+
+### Rollout and rollback
+Stages, signals, thresholds, owner and recovery for users already updated.
+```
+
+## Read-only boundary
+
+A readiness audit inspects files, existing artifacts/logs and accessible CI/store records. Do not build, run tests, install dependencies, execute Fastlane lanes, prebuild, bump versions, tag, upload, change signing or store settings by default. Inspect scripts before considering execution. Prepare exact commands for missing checks and label them **not executed**. An explicit request to execute a release authorizes only that requested scope; reuse existing authorization, and complete reviewable preparation before any additional approval that is actually needed. Never change an app merely to make the audit green.

package/skills/mobile-release/scripts/verdict.mjs

@@ -0,0 +1,59 @@
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+const REQUIRED_GATES = ['identity', 'build', 'tests', 'analysis', 'version', 'signing', 'symbols', 'store', 'privacy', 'listing', 'rollout'];
+const text = (value) => typeof value === 'string' && value.trim().length > 0;
+
+/** Validate decision consistency. Evidence truth and applicability remain the auditor's job. */
+export function evaluateReadiness(report) {
+  if (!report || !Array.isArray(report.targets)) throw new Error('targets must be an array');
+  const risks = report.risks ?? [];
+  if (!Array.isArray(risks) || !risks.every((risk) => risk && text(risk.id) && text(risk.description)
+    && Array.isArray(risk.evidence) && risk.evidence.length > 0 && risk.evidence.every(text)
+    && text(risk.mitigation) && text(risk.owner))) {
+    throw new Error('risks must include id, description, evidence, mitigation and owner');
+  }
+  const targets = new Set();
+  const gates = [];
+  for (const item of report.targets) {
+    if (!item || !text(item.target) || !Array.isArray(item.gates)) throw new Error('each target needs a name and gates array');
+    if (targets.has(item.target)) throw new Error(`duplicate target: ${item.target}`);
+    targets.add(item.target);
+    const byId = new Map();
+    for (const gate of item.gates) {
+      if (!gate || !REQUIRED_GATES.includes(gate.id)) throw new Error('unknown gate id');
+      if (byId.has(gate.id)) throw new Error(`duplicate gate: ${gate.id}`);
+      if (!['pass', 'fail', 'unknown'].includes(gate.status)) throw new Error(`invalid status for ${gate.id}`);
+      if (gate.evidence !== undefined && (!Array.isArray(gate.evidence) || !gate.evidence.every((value) => typeof value === 'string'))) {
+        throw new Error(`evidence for ${gate.id} must be a string array`);
+      }
+      byId.set(gate.id, gate);
+    }
+    for (const id of REQUIRED_GATES) {
+      const supplied = byId.get(id);
+      const evidence = (supplied?.evidence ?? []).filter(text);
+      const status = !supplied || (supplied.status !== 'unknown' && !evidence.length) ? 'unknown' : supplied.status;
+      gates.push({
+        target: item.target, id, status, evidence,
+        nextAction: status === 'pass' ? 'None.' : (text(supplied?.nextAction) && supplied.nextAction !== 'None.'
+          ? supplied.nextAction : `Provide and verify ${id} evidence for ${item.target}.`),
+      });
+    }
+  }
+  if (!targets.size) gates.push({ target: 'unresolved', id: 'targets', status: 'unknown', evidence: [], nextAction: 'Identify the app artifacts and intended store targets.' });
+  const blockers = gates.filter((gate) => gate.status !== 'pass');
+  const unknowns = gates.filter((gate) => gate.status === 'unknown');
+  return { verdict: blockers.length ? 'NO-GO' : risks.length ? 'GO WITH RISKS' : 'GO', gates, blockers, risks, unknowns };
+}
+
+// stdin avoids creating an audit file in the inspected project. Exit zero means evaluated, not GO.
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+  try {
+    let input = '';
+    for await (const chunk of process.stdin) input += chunk;
+    console.log(JSON.stringify(evaluateReadiness(JSON.parse(input)), null, 2));
+  } catch (error) {
+    console.error(`readiness: ${error.message}`);
+    process.exitCode = 1;
+  }
+}