@mmerterden/multi-agent-pipeline 20.36.0 → 20.37.1

package/pipeline/commands/multi-agent/stack/SKILL.md

@@ -15,46 +15,11 @@ allowed-tools: Bash, Read, Edit, Write, AskUserQuestion
 
 Stack skills ship as plugins in the `{owner}/multi-agent-plugins` marketplace. Selecting a stack = **enabling the matching plugin(s)** in the current repo's `.claude/settings.json` `enabledPlugins`. Two toolkits are stack-independent and always enabled alongside the stack plugin(s): `ai-common-toolkit` (accessibility audit, humanizer, Firebase) and `ai-analyst-toolkit` (GitHub and package-registry evidence, community signal for analysis work).
 
-On Claude Code the marketplace plugins are the ONLY source of stack skills - nothing is copied into `~/.claude/skills` anymore. A stack that is not enabled here is simply absent from the session. Copilot CLI and Codex CLI have no plugin loader; they receive a local copy filtered to the enabled stacks at install time, which is why step 5 below offers to refresh those copies after a change.
+Claude Code reads stack skills only from the enabled plugins; Copilot CLI and Codex CLI get a local copy filtered at install time (step 5). Host details, usage examples, a preview snippet and why the map is derived: `$HOME/.claude/multi-agent-refs/stack/background.md`. Read it when the user asks what an argument enables or how selection works.
 
-This replaces the old `stack-swap.sh` mechanic that physically moved skill directories in `~/.claude/skills/`. There is no SessionStart hook and no directory shuffling - enablement is declarative, per-repo, and versioned.
+## Stack -> plugin map
 
-## Usage
-
-```bash
-/multi-agent:stack                 # no arg → native multi-select picker (current state pre-noted)
-/multi-agent:stack ios             # SwiftUI toolkit + common
-/multi-agent:stack ios backend     # any combination, space-separated
-/multi-agent:stack android         # Compose toolkit + common
-/multi-agent:stack mobile          # alias: ios + android + common
-/multi-agent:stack backend         # Python / Node spec-driven toolkit + common
-/multi-agent:stack web        # React / TSX toolkit + common (alias: frontend)
-/multi-agent:stack fullstack       # alias: web + backend + common
-/multi-agent:stack all             # all four stack toolkits + common
-```
-
-## Stack → plugin map
-
-Derived, not listed. `pluginsForStacks()` in `scripts/_stack-routing.mjs` owns
-it, and this file deliberately carries no copy: the mapping was written out by
-hand in four places, and every copy is a chance to get the one asymmetry wrong -
-the detector says `web`, the marketplace ships `ai-frontend-toolkit`.
-
-```bash
-node -e 'import(process.env.HOME+"/.claude/scripts/_stack-routing.mjs").then(m=>{
-  const st=process.argv.slice(1).flatMap(a=>m.expandStackArg(a));
-  if(!st.length){console.error("Unknown stack. One of: "+m.KNOWN_STACKS.join(" ")+" mobile fullstack all");process.exit(1);}
-  const r=m.pluginsForStacks(st);
-  if(r.dropped.length) console.error("not in the marketplace, dropped: "+r.dropped.join(" "));
-  console.log(r.plugins.join(" "));
-})' "$@"
-```
-
-`ai-common-toolkit` and `ai-analyst-toolkit` are in every answer, including the
-empty one: neither is stack-specific. Multiple args union their sets, and the
-aliases (`frontend`, `mobile`, `fullstack`, `all`) expand in the module so
-`/multi-agent:stack mobile` cannot mean one thing here and another in the
-installer.
+Derived, not listed: `pluginsForStacks()` in `scripts/_stack-routing.mjs` owns it (aliases `frontend`, `mobile`, `fullstack`, `all` expand there too). Never write the map out by hand. `ai-common-toolkit` and `ai-analyst-toolkit` are in every answer.
 
 ## Behaviour
 
@@ -70,8 +35,8 @@ installer.
    - every stack toolkit **not** in the union is set to `false` (leave non-`@multi-agent-plugins` entries untouched)
    - `ai-common-toolkit@multi-agent-plugins` and `ai-analyst-toolkit@multi-agent-plugins` are always `true`
    - **legacy-key cleanup**: delete any `ai-*-engineering-toolkit@multi-agent-plugins` keys - those plugin names were retired by the `ai-<stack>-toolkit` rename and a stale `true` there enables a plugin that no longer exists in the marketplace
-   - **Apple's Xcode skills**: when `~/.claude/xcode-apple-marketplace` exists (the installer linked this Mac's Xcode 27.1+ plugin), set `xcode-integration@xcode-apple` to `true` if `ios` is in the selection and `false` otherwise. Apple's skills are the reference for iPhone Duo and window resizing, SwiftUI, App Intents and the accessibility audits, and they are the first route for those iOS tasks. Without that directory there is nothing to enable; leave the key absent
-4. **Unknown arg** → show the table above; do not guess.
+   - **Apple's Xcode skills**: when `~/.claude/xcode-apple-marketplace` exists, set `xcode-integration@xcode-apple` to `true` if `ios` is in the selection and `false` otherwise. Without that directory leave the key absent
+4. **Unknown arg** → show the known stacks; do not guess.
 5. **Copilot/Codex refresh offer.** Their local skill copies are filtered to the enabled stacks at install time, so after a change ask (single `AskUserQuestion`, not silent): "Refresh Copilot/Codex local copies now?" - Yes runs `node <pipelineRepo>/install.js --copilot --codex`, No leaves them stale with a one-line warning naming the command to run later. Skip this question entirely when neither `~/.copilot` nor `~/.codex` exists.
 
 ## Implementation
@@ -92,10 +57,7 @@ if [ "$#" -eq 0 ]; then
   exit 0
 fi
 
-# resolve every arg and derive the ON set - one owner, see the map above.
-# The marketplace suffix is appended INSIDE node: `$ON` is a single string, and
-# re-splitting it in the shell to suffix each name is the zsh word-splitting trap
-# (`printf %s@x $ON` suffixes the whole string, not each word).
+# resolve every arg and derive the ON set; the suffix is appended inside node
 ON=$(MP="$MP" node -e 'import(process.env.HOME+"/.claude/scripts/_stack-routing.mjs").then(m=>{
   const st=process.argv.slice(1).flatMap(a=>m.expandStackArg(a));
   if(!st.length){console.error("Unknown stack. One of: "+m.KNOWN_STACKS.join(" ")+" mobile fullstack all");process.exit(1);}
@@ -105,19 +67,14 @@ ON=$(MP="$MP" node -e 'import(process.env.HOME+"/.claude/scripts/_stack-routing.
 })' "$@") || exit 1
 ```
 
-Then write it with the one writer of these rules (the office panel's
-`POST /v1/stack` calls the same script):
+Then write it with the one writer of these rules:
 
 ```bash
 node "$HOME/.claude/scripts/stack-toggle.mjs" set --repo "$PWD" "$@" --json
 ```
 
-`stack-toggle.mjs` applies the write rules above (selection `true`, every other
-stack toolkit `false`, `ai-common-toolkit` and `ai-analyst-toolkit` always
-`true`, retired `ai-*-engineering-toolkit` keys deleted, `xcode-integration@xcode-apple`
-following `ios` when the Apple marketplace is linked, every other key kept),
-writes the file atomically and prints the resulting `enabledPlugins`. It refuses
-an empty selection and an unknown stack (exit 1) and never hand-edits the JSON.
+`stack-toggle.mjs` applies the write rules above atomically and refuses an
+empty selection and an unknown stack (exit 1). Never hand-edit the JSON.
 `stack-toggle.mjs status --repo "$PWD" --json` is the read for status mode.
 Then print the resulting `enabledPlugins` block and run step 5 (Copilot/Codex refresh offer).
 
@@ -126,4 +83,3 @@ Then print the resulting `enabledPlugins` block and run step 5 (Copilot/Codex re
 - Enablement is per-repo and declarative - commit `.claude/settings.json` so teammates get the same stack.
 - Restart the conversation (or reload the window) for Claude Code to pick up newly enabled plugins.
 - Pipeline Phase 1 stack detection is independent (it reads project files); `stack` only sets which plugin skill set is active.
-- The old `stack-swap.sh` skill-dir swap has been removed; stack selection is entirely plugin enablement.

package/pipeline/commands/multi-agent/status/SKILL.md

@@ -19,10 +19,20 @@ Show every active and completed task as a table.
    question:
 
    ```bash
-   node "$HOME/.claude/scripts/runs-index.mjs"          # grouped table
-   node "$HOME/.claude/scripts/runs-index.mjs" --json   # the same records
+   node "$HOME/.claude/scripts/status-overview.mjs"          # live sessions, tokens, accounts, runs
+   node "$HOME/.claude/scripts/status-overview.mjs" --json   # the same document
+   node "$HOME/.claude/scripts/runs-index.mjs" [--all]       # the full run table
    ```
 
+   `status-overview.mjs` answers "what is happening right now": each live
+   Claude Code session with the run it drives and its token spend (subagents
+   included), the tokens of the last 24 hours, the github.com accounts gh holds
+   with the active one marked, the git author, and which logical credentials
+   from `keychainMapping` are registered. It reads credential names only and
+   never a value; never run `credential-store.sh get` to "check" one. Show its
+   sections as they come, then the run table below. Token figures are list-price
+   estimates, not a bill.
+
    `runs-index.mjs` resolves through `lib/run-paths.sh` / `scripts/_run-paths.mjs`,
    so it sees both directory layouts (`<project>/<id>/` and the flat `<id>/`),
    the salvaged `artifacts/` copy Phase 4 leaves behind, and every spelling of a
@@ -49,6 +59,7 @@ Show every active and completed task as a table.
    | `stopped` - Stopped mid-development | anything else past phase 0 | `resume #N` or `kill #N` |
    | `question` - Left at a question | phase 0, nothing pending | `garbage-collect --abandoned` - nothing was built |
    | `unknown` - Status not recorded | no `status` field | say so; offer nothing |
+   | `done` - Finished | `status` is `complete`, `completed`, `done`, `abandoned` or `cancelled`, checked first | nothing; the table folds it into a count unless `--all` |
 
    A run with no `status` is **not** placed in an actionable group. Unknown is
    not a finding, and calling it dead is the same false claim in the other

package/pipeline/commands/multi-agent/store-ready/SKILL.md

@@ -11,17 +11,7 @@ allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdat
 
 # /multi-agent:store-ready  -  pre-submission validation, iOS + Android
 
-Catch, before you upload, what App Store Connect or the Play Console would send
-back after you do.
-
-**Local-only.** No commits, no push, no PR, no channels unless you ask at the end.
-A worktree, when needed, only archives without touching your working tree.
-
-**It never ships.** iOS runs `--validate-app`, never `--upload-app`. Android
-never commits a Play edit: when Google Play is onboarded, Gate 2 uploads the
-bundle into a throwaway edit that is validated and deleted, and only after the
-user approves that plan. A validation run must not be able to ship a build by
-accident.
+**Local-only**: no commits, push, PR or channels unless asked at the end; a worktree only archives. **It never ships**: iOS runs `--validate-app`, never `--upload-app`; Android uploads only into a throwaway Play edit, after approval, and never commits it.
 
 **Input**: $ARGUMENTS
 
@@ -31,252 +21,63 @@ accident.
 - The Play throwaway edit is deleted whether validation passes or fails.
 - Gate 3 reads source, not the binary: a policy finding cites `file:line` in the repo the package was built from.
 
-## Why three gates, and why the same three on both platforms
-
-Each gate sees what the others cannot, so no single one is "the check". The
-failure modes are the same on both platforms: a malformed package, a package the
-store refuses, a policy a human enforces.
-
-| Gate | Sees | Blind to |
-|---|---|---|
-| **1. Static** | package structure, manifests, signing, declared APIs and SDKs | anything depending on the store account |
-| **2. Authoritative** | what the store's own validator says about this exact binary | written policy  -  no validator reads it |
-| **3. Policy** | consent flows, deletion paths, purchase routing, disclosures | anything not visible in source |
-
-### Gate matrix
-
-| Gate | iOS | Android |
-|---|---|---|
-| 1 Static | `ios_app_store_audit({archive_path, rules: "all"})`  -  18 rules with real ITMS codes. Needs an `.xcarchive`. Reference: `apple-archive-compliance` skill | `android_apk_audit` plus the `google-play-compliance` skill's 21 rules: `bundletool validate` + manifest dump, `aapt2 dump badging`, `apksigner verify`, ABI / native scan. Needs an `.aab` (an `.apk` narrows it, see Step 3) |
-| 2 Authoritative | `ios_testflight_validate({ipa_path, platform: "ios", <credentials>})` → `xcrun altool --validate-app`, plus `store_asc_next_build_number` for whether the build number is already used. Needs an `.ipa` + credentials | With `google_play` onboarded: `store_play_validate_bundle({package_name, bundle_path})`  -  Google validates the `.aab` in a throwaway Publishing API edit that is then deleted, never committed. Without it, Play's check exists only server-side and nothing local reproduces it, so this gate reports `SKIPPED (no local Play validator)` with the reason `Google Play not onboarded`. Do not substitute `bundletool validate`  -  that is Gate 1 |
-| 3 Policy | `ai-ios-toolkit:app-store-review` skill vs repo source | `ai-android-toolkit:play-store-review` skill vs repo source |
-
-Gate 2's asymmetry is reported, not smoothed over. On iOS it is the only gate that
-catches a version+build pair already used. On Android it runs only with Google Play
-onboarded and the throwaway-edit upload approved; without both, an Android run
-clears at most 2 of 3 gates and never prints `passed`.
+## Three gates per platform
 
-The `store_*` tools need `@mmerterden/multi-agent-toolkit-mcp` ≥ v3.17.0. On an
-older server they are absent, and each branch below that uses one falls back to
-the behaviour it has without the credential.
+1 Static, 2 Authoritative (the store's validator), 3 Policy (repo source). Read `$HOME/.claude/multi-agent-refs/store-ready/gates.md` before Step 0: the gate matrix, Gate 2's asymmetry, input flags, the `store_*` toolkit version.
 
 ## Step 0  -  parse input, detect platform
 
-| Input | Meaning |
-|---|---|
-| (empty) | ask which repo (Step 1) |
-| `my-app` or a path | that repo |
-| `--archive=<path>` | iOS, build supplied; all three gates can run |
-| `--ipa=<path>` | iOS, build supplied; Gate 1 reports `SKIPPED (needs .xcarchive)` |
-| `--aab=<path>` | Android, build supplied; Gate 1 + 3 run |
-| `--apk=<path>` | Android; Gate 1 runs the subset that does not need a bundle, and says which rules it could not apply |
-| `--skip-sweep` | skip Step A, when no simulator / emulator is available or only the package matters |
-| `--resume` | continue the last run from its state file |
-
-Platform detection when no build flag is given:
-
-```
-cwd or repo contains .xcodeproj / .xcworkspace / Package.swift   -> iOS
-cwd or repo contains build.gradle / build.gradle.kts             -> Android
-both                                                            -> ask which
-neither -> halt: "store-ready needs an iOS or Android project"
-```
-
-State lives at `$HOME/.claude/logs/multi-agent/<task_id>/agent-state.json` with
-`taskId = SR-<repo>-<yyyymmddHHMM>`. Register phases with the tracker
-(`$HOME/.claude/multi-agent-refs/tracker-contract.md`) so `:resume` and `:status`
-work like any other run.
+Flags: `gates.md` "Input". Without a build flag: `.xcodeproj` / `.xcworkspace` / `Package.swift` -> iOS; `build.gradle` / `build.gradle.kts` -> Android; both -> ask; neither -> halt with "store-ready needs an iOS or Android project".
 
-## Step 1  -  pickers (native, always)
-
-Use `AskUserQuestion` for every step  -  never a numbered text menu. Questions and
-descriptions render in `prefs.global.outputLanguage`; `label` and `header` stay
-English, per `$HOME/.claude/multi-agent-refs/picker-contract.md`. Print the
-`Step <i>/<n>: <what this decides>` breadcrumb for each.
-
-1. **Repo**  -  from `prefs.projects` matching the detected platform. A single match
-   auto-resolves (say so in the breadcrumb, do not silently skip the step).
-2. **Branch**  -  the branch to validate. Run `git fetch --prune` first, capturing
-   **stderr**. **If the fetch fails, do not silently fall back to a cached ref**, and
-   **classify before naming a cause** (credential / network / wrong remote), printing
-   the observed stderr line next to the classification. A credential failure never
-   gets the cached-ref fallback. Then offer the current branch, the default branch,
-   and any `release/*` / `tkdevelop/*` heads.
-   Full procedure: `$HOME/.claude/multi-agent-refs/store-ready/preflight.md`. Read it for the fetch-failure table.
-3. **Mode**  -  how the build is obtained:
-   - `Supply a build` (Mode B, default)  -  fastest, no signing needed in-run.
-   - `Build from this branch` (Mode A)  -  iOS needs a distribution certificate and
-     profile in the keychain; Android needs the release signing config. Takes as
-     long as a real release build.
-
-## Step 2  -  pre-flight, before anything expensive
-
-Report every line; a missing prerequisite is a halt, not a warning.
+State `$HOME/.claude/logs/multi-agent/<task_id>/agent-state.json`, `taskId = SR-<repo>-<yyyymmddHHMM>`, tracker per `$HOME/.claude/multi-agent-refs/tracker-contract.md`.
 
-**iOS**: `altool` and `xcodebuild` must resolve. Then resolve credentials and
-**state which tier is active in the report**: tier 1 ASC API key (`store_status`
-reports `appStoreConnect.configured`), tier 2 Apple ID + app-specific password,
-tier 3 neither, where **Gate 2 reports `SKIPPED`, and the run says so in the verdict
-line**. Multi-provider accounts need `--provider-public-id`; ask when it is not in prefs.
+## Step 1  -  pickers (native, always)
 
-**Android**: `bundletool`, `aapt2` and `apksigner` must resolve.
+`AskUserQuestion` for every step, never a numbered text menu, per `$HOME/.claude/multi-agent-refs/picker-contract.md`.
 
-Full procedure: `$HOME/.claude/multi-agent-refs/store-ready/preflight.md`. Read it for Step 2 (commands, tier table, provider lookup).
+1. **Repo** from `prefs.projects` matching the detected platform; a single match auto-resolves and the breadcrumb says so.
+2. **Branch.** `git fetch --prune`, capturing stderr. **If the fetch fails, do not silently fall back to a cached ref**; **classify before naming a cause** (credential / network / wrong remote) beside the stderr line; a credential failure never gets the cached ref. Fetch-failure table: `$HOME/.claude/multi-agent-refs/store-ready/preflight.md`.
+3. **Mode**: `Supply a build` (Mode B, default) or `Build from this branch` (Mode A, needs release signing).
 
-Then resolve whether Android Gate 2 can run. Call `store_status` (no probe) and read
-`googlePlay.configured`:
+## Step 2  -  pre-flight, before anything expensive
 
-| State | Gate 2 |
-|---|---|
-| `googlePlay.configured: true` and `MULTI_AGENT_UNATTENDED` unset | runs `store_play_validate_bundle`, after the user approves the upload (Step 5) |
-| `googlePlay.configured: true` and `MULTI_AGENT_UNATTENDED=1` | `SKIPPED (no local Play validator)`, reason: the toolkit refuses the upload in an unattended run |
-| not configured, or no `store_status` tool | `SKIPPED (no local Play validator)`, reason: `Google Play not onboarded` (`/multi-agent:setup` Step 3d) |
+Report every line; a missing prerequisite is a halt, not a warning. iOS: `altool` + `xcodebuild`, then credentials, **stating which tier is active**; tier 3 means **Gate 2 reports `SKIPPED`** and the verdict line says so. Android: `bundletool`, `aapt2`, `apksigner`. Read `store-ready/preflight.md` for Step 2.
 
-Say which one it is.
+Android Gate 2 from `store_status` (`googlePlay.configured`), and say which:
+- configured, attended: runs `store_play_validate_bundle` after approval (Step 5);
+- configured, `MULTI_AGENT_UNATTENDED=1`: `SKIPPED (no local Play validator)`, the toolkit refuses the upload unattended;
+- not configured or no tool: `SKIPPED (no local Play validator)`, reason `Google Play not onboarded`.
 
-Credentials come from `/multi-agent:setup`; never prompt for a secret value in
-chat.
+Credentials come from `/multi-agent:setup`; never prompt for a secret value in chat.
 
 ## Step A  -  running-app sweep (unless `--skip-sweep`)
 
-The gates read a package; this reads the app. A build can be structurally perfect
-and still ship an unreadable screen, so the sweep stays part of store readiness
-rather than being a separate errand.
-
-Requires a booted simulator / emulator. When none is available, report
-`Sweep: SKIPPED (no booted device)` and continue to the gates  -  never halt the
-package validation for it, and never silently omit the line.
-
-Delegate to the UI Bug Hunter flow (`$HOME/.claude/commands/sim-test.md`) for the
-mechanics, running the light + dark + large-text passes over every screen. Merge
-its findings into the single report at Step 7, severity-grouped alongside the gate
-findings.
+No booted device: `Sweep: SKIPPED (no booted device)`, continue, never omit the line. Else run `$HOME/.claude/commands/sim-test.md` light + dark + large-text over every screen; findings go into Step 7.
 
 ## Step 3  -  obtain the build
 
-Mode B (supply a build) and Mode A (build from the branch). Full procedure:
-`$HOME/.claude/multi-agent-refs/store-ready/build.md`. Read it for Step 3. Rules that hold either way:
-
-- **iOS `.ipa` only** → **Gate 1 is `SKIPPED (needs .xcarchive)`**; never present a
-  two-gate run as a full pass. An Android `.apk` **lists the rules it could not apply**.
-- Never validate an artifact whose provenance you did not state; print which one you picked.
-- Mode A worktree at `{projectRoot}/.worktrees/{taskId}`, **never under `$HOME`**, never
-  a direct checkout of the main working tree.
-- iOS archives with `destination: "generic/platform=iOS"`. Android with no release
-  signing config halts; never audit a debug artifact.
-- Leave `allow_provisioning_updates` off unless the user asks.
-- A failed build or export halts with the parsed errors.
+Read `$HOME/.claude/multi-agent-refs/store-ready/build.md` for Step 3. Always: an `.ipa` alone makes **Gate 1 `SKIPPED (needs .xcarchive)`**; an `.apk` **lists the rules it could not apply**; state provenance; Mode A worktree **never under `$HOME`**; never audit a debug artifact; a failed build halts.
 
 ## Step 4  -  Gate 1, static package audit
 
-- **iOS**: `ios_app_store_audit({archive_path, rules: "all"})`, per the
-  `apple-archive-compliance` skill. The direct-package fallback runs only when the
-  tool is genuinely absent, and the report says which path ran. An archive with no
-  dSYM (`<archive>/dSYMs/*.dSYM` count zero) is a blocking `[SYMBOLS]` finding.
-- **Android**: `android_apk_audit` plus the `google-play-compliance` skill's 21 rules.
-  A `minifyEnabled true` module whose build produced no `mapping.txt` is a blocking
-  `[SYMBOLS]` finding.
-
-Full procedure: `$HOME/.claude/multi-agent-refs/store-ready/gate-1-static.md`. Read it for Gate 1.
-
-`error` findings are blocking; `warning` is advisory. Group by severity and keep
-each finding's ITMS / Play policy code  -  Gate 2 may return the same code on iOS,
-and seeing it in both places tells the user it is real rather than a heuristic.
+iOS `ios_app_store_audit({archive_path, rules: "all"})` per `apple-archive-compliance`; no dSYM is a blocking `[SYMBOLS]` finding. Android `android_apk_audit` plus the `google-play-compliance` 21 rules; a minified module with no `mapping.txt` is blocking `[SYMBOLS]`. Read `store-ready/gate-1-static.md` for Gate 1. `error` blocks, `warning` advises; keep every ITMS / Play code.
 
 ## Step 5  -  Gate 2, the store's own validation
 
-**iOS**: `ios_testflight_validate({ipa_path, platform: "ios", <credential args>})`.
-Render the verdict exactly as returned:
-
-- `PASS`  -  Apple accepted the binary for delivery.
-- `FAIL`  -  list each issue with its ITMS code, the mapped guideline, and the hint.
-- `SKIPPED`  -  print the reason. **Never render this as a pass.**
-
-Gate 2 is the only gate that catches a build number already used  -  so when it
-fails on that, say so plainly and name the next free build number.
-
-**Build number** (App Store Connect onboarded, `store_status` reports
-`appStoreConnect.configured`): find the app with `store_asc_apps` by the archive's
-bundle id, then `store_asc_next_build_number({app_id, version: <CFBundleShortVersionString>})`.
-Report the archive's `CFBundleVersion` as `already used` (not above the highest
-uploaded one, with the suggested next) or `free`. Read-only; it never changes the
-project. Without the credential, skip this line and say why.
-
-**Android**, by the state resolved in Step 2:
-
-- **Google Play onboarded, attended run.** Call
-  `store_play_validate_bundle({package_name: <applicationId>, bundle_path: <.aab>})`
-  without `confirm`. It returns the plan only: it would open an edit, upload the
-  bundle, validate the edit, then delete it, committing nothing and changing no
-  track. Show that plan to the user and ask (picker, `question` / `description` in
-  `outputLanguage`, `header` `Play check`, labels `Validate on Play` / `Skip`).
-  Only on **Validate on Play**, call it again with `confirm: true`. Render the
-  verdict from `valid`: `true` → `PASS`, `false` → `FAIL` with the returned
-  `error`. On **Skip**, report `SKIPPED (no local Play validator)` with the reason
-  `user declined the upload`.
-- **Otherwise** (unattended, or not onboarded) do not call the tool: report
-  `SKIPPED (no local Play validator)` with the reason from the Step 2 table.
-
-`bundletool validate` is Gate 1 in every case; reporting it here would fake a
-cleared gate.
-
-Google does not document whether an upload into a discarded edit reserves its
-`versionCode`; fastlane's `validate_only` runs the same sequence as a pre-release
-check. If the real upload is later refused as "already used", raise `versionCode`.
+iOS: `ios_testflight_validate({ipa_path, platform: "ios", <credential args>})`, verdict exactly as returned; `SKIPPED` is **never rendered as a pass**. With App Store Connect onboarded, check the build number via `store_asc_apps` + `store_asc_next_build_number` (read-only).
 
-## Step 6  -  Gate 3, policy review
-
-Load the platform's review skill and review the repo against it. This is the gate
-that catches what a human reviewer rejects, so it reads source, not the binary.
+Android, attended and onboarded: call `store_play_validate_bundle` without `confirm` for the plan, show it, ask (`header` `Play check`, labels `Validate on Play` / `Skip`); only on **Validate on Play** call again with `confirm: true`. Skip reports `SKIPPED (no local Play validator)`, reason `user declined the upload`. Otherwise do not call it. `bundletool validate` is Gate 1, never reported here. Verdict rendering and build-number detail: `gates.md` "Gate 2".
 
-**iOS**  -  `ai-ios-toolkit:app-store-review`; **Android**  -  `ai-android-toolkit:play-store-review`.
-Both cover a `Crash symbolication` row (dSYM upload step / `mapping.txt` upload).
-Full procedure: `$HOME/.claude/multi-agent-refs/store-ready/gate-3-policy.md`. Read it for Gate 3 (the per-platform area tables).
+## Step 6  -  Gate 3, policy review
 
-For each: `pass` / `fail` / `not-applicable` with the evidence path that justifies
-it. `not-applicable` needs a reason  -  an unexamined area is not a pass.
+iOS `ai-ios-toolkit:app-store-review`, Android `ai-android-toolkit:play-store-review`, against repo source, `Crash symbolication` row included (`store-ready/gate-3-policy.md`). Each area is `pass` / `fail` / `not-applicable` with evidence; `not-applicable` needs a reason.
 
 ## Step 7  -  report
 
-Write to `~/StoreChecks/<platform>-<repo>-<branch>-<timestamp>/report.md` and print
-a summary: verdict line, per-gate status, Blocking / Advisory / Not run / Open
-questions, and the `Before rollout` block (phased rollout, `Halt thresholds`,
-rollback / forward-fix owner, forward-fix plan).
-Full procedure: `$HOME/.claude/multi-agent-refs/store-ready/report.md`. Read it for Step 7 (the report layout).
-
-Rules for the report:
-
-- A skipped gate is never folded into the pass count. The verdict line states the
-  skip. An Android run whose Gate 2 did not run therefore reads
-  `2 of 3 gates cleared, 1 skipped` at best.
-- Every blocking finding carries a file path or a store code. A finding the user
-  cannot act on is noise.
-- The `Before rollout` block is filled by a human, never inferred. When it is
-  left unfilled the verdict line gains the suffix `, rollout plan missing`.
-- Humanize via `--lang en` by default (`promptLanguage` is locked to `"en"`); pass
-  `--lang=tr` explicitly to opt into Turkish.
-- No AI or assistant attribution anywhere, per
-  `$HOME/.claude/rules/git-conventions.md`.
-- Real newlines, no HTML entities, per
-  `$HOME/.claude/multi-agent-refs/rules.md "External System Outputs"`.
+Write `~/StoreChecks/<platform>-<repo>-<branch>-<timestamp>/report.md`; read `store-ready/report.md` for the layout and rules. A skipped gate is never in the pass count (`2 of 3 gates cleared, 1 skipped` at best); `Before rollout` (`Halt thresholds`, rollback / forward-fix owner) is human-filled, never inferred; no AI attribution.
 
 ## Step 8  -  offer the next action, do not take it
 
-Print, and stop:
-
-- the exact upload command for when the gates are clear, so uploading stays an
-  explicit human act:
-  - iOS: `xcrun altool --upload-app ...`
-  - Android: the Play Console upload, or the `gradle publish` task the project
-    declares  -  never run it
-- `/multi-agent:store-ready --resume` to re-run after fixes
-- `/multi-agent:channels` to land the findings in Jira / Confluence / Wiki / PR
-- the enabled stack plugin's `fix-bug` skill (`ai-ios-toolkit:fix-bug` or the stack equivalent) when Gate 3 produced code-level findings
-
-Never upload a build for release, never commit a Play edit, never bump the build number, never commit.
-
-## Related surfaces
+Print and stop the `store-ready/report.md` "Next actions" (upload stays a human act). Never upload a build for release, never commit a Play edit, never bump the build number, never commit.
 
-`/multi-agent:testflight-validation` is a thin alias onto this command, kept so the
-iOS-only name keeps working; it resolves here with the platform pinned to iOS.
-`/multi-agent:test "store-ready"` also resolves here. There is one implementation.
+`/multi-agent:testflight-validation` (iOS-pinned) and `/multi-agent:test "store-ready"` resolve here.