@mmerterden/multi-agent-pipeline 14.1.1 → 14.2.2

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

@@ -0,0 +1,340 @@
+---
+description: "Pre-submission store readiness for a built package, iOS and Android, local-only. Three symmetric gates per platform: a static package audit, the store's own authoritative validation, and a policy review against repo source. Separate verdict per gate, a skipped gate never counted as a pass. Validates only, never uploads. Use when a build is about to go to TestFlight or a Play track, or when a submission was rejected and the reason is not obvious."
+description-tr: "Üretilmiş paketin yükleme öncesi store hazırlığı, iOS + Android, yalnızca lokal. Platform başına üç simetrik kapı: statik paket denetimi, store'un kendi doğrulayıcısı, ve kaynağa karşı politika incelemesi. Kapı başına ayrı verdict, atlanan kapı asla pass sayılmaz. Sadece doğrular, asla yüklemez."
+argument-hint: "[repo]  -  empty = pick; repo name or path; --ipa= | --archive= | --aab= | --apk=; --skip-sweep; --resume"
+allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, AskUserQuestion, Skill, mcp__dev-toolkit__ios_app_store_audit, mcp__dev-toolkit__ios_export_ipa, mcp__dev-toolkit__ios_testflight_validate, mcp__dev-toolkit__ios_xcodebuild, mcp__dev-toolkit__ios_xcresult, mcp__dev-toolkit__android_apk_audit, mcp__dev-toolkit__ios_screenshot, mcp__dev-toolkit__ios_get_ui_tree, mcp__dev-toolkit__ios_set_appearance, mcp__dev-toolkit__ios_set_content_size, mcp__dev-toolkit__android_screenshot, mcp__dev-toolkit__android_get_ui_tree, mcp__dev-toolkit__android_set_dark_mode, mcp__dev-toolkit__android_set_font_scale
+---
+
+# /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 one is needed, exists only to archive without touching your
+working tree.
+
+**It never uploads.** iOS runs `--validate-app`, never `--upload-app`. Android
+never commits a Play edit. A validation run must not be able to ship a build by
+accident.
+
+**Input**: $ARGUMENTS
+
+## Why three gates, and why the same three on both platforms
+
+Each gate sees something the others structurally cannot, and reporting one of them
+as "the check" is how a build passes locally and gets rejected anyway. The shapes
+are the same on iOS and Android because the failure modes are: a malformed package,
+a package the store itself refuses, and 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`. Needs an `.ipa` + credentials | **No client shipped.** Play's authoritative check exists only server-side, through a Publishing API draft edit that is validated and then abandoned. The pipeline has no tool for it, so this gate reports `SKIPPED (no local Play validator)` and the report says so. Do not substitute `bundletool validate`  -  that is Gate 1 |
+| 3 Policy | `app-store-review` skill vs repo source | `play-store-review` skill vs repo source |
+
+Gate 2's asymmetry is real and is reported as an asymmetry, not smoothed over. On
+iOS it is the only gate that catches a version+build pair already used  -  the most
+common wasted upload. On Android nothing local reproduces it, so an Android run
+clears at most 2 of 3 gates and must never print `passed`.
+
+## 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.
+
+## 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. Resolution order:
+   - `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**  -
+     the same rule as the `/multi-agent:dev` remote gate:
+
+     | stderr contains | Cause | Remedy |
+     |---|---|---|
+     | `could not read Password`, `Authentication failed`, `403` | credential | store the PAT in the credential helper or switch the remote to SSH. **A VPN cannot fix this**, and the base ref being stale is unrelated to what broke  -  do not offer the cached-ref fallback. |
+     | `Could not resolve host`, `Operation timed out`, `Connection refused` | network | retry / continue on the cached ref with an explicit warning / switch remote / abort, per `$HOME/.claude/multi-agent-refs/rules.md` |
+     | `Repository not found`, `404` | wrong remote | show `git remote -v` and ask |
+
+     Always print the observed stderr line next to the classification. Asserting
+     `unreachable (VPN/DNS)` for a missing-credential error that returns in under a
+     second sends the user to fix something that was never broken.
+   - Offer the current branch, the default branch, and any `release/*` /
+     `tkdevelop/*` heads.
+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.
+
+**iOS:**
+
+```bash
+xcrun --find altool >/dev/null 2>&1 || echo "MISSING: altool (install Xcode)"
+xcodebuild -version | head -1
+```
+
+Then resolve credentials, and **state which tier is active in the report**:
+
+| Tier | Source | Effect |
+|---|---|---|
+| 1 | ASC API key  -  key id + issuer id from the keychain via `prefs.global.keychainMapping`, `.p8` at `~/.appstoreconnect/private_keys/AuthKey_<keyId>.p8` | Gate 2 runs |
+| 2 | Apple ID + app-specific password, referenced as a keychain item | Gate 2 runs |
+| 3 | neither | **Gate 2 reports `SKIPPED`, and the run says so in the verdict line** |
+
+Multi-provider accounts need `--provider-public-id`. When it is not in prefs, run
+`ios_testflight_validate({list_providers: true})` once and ask which provider.
+
+**Android:**
+
+```bash
+command -v bundletool >/dev/null || echo "MISSING: bundletool"
+command -v aapt2      >/dev/null || echo "MISSING: aapt2 (Android SDK build-tools)"
+command -v apksigner  >/dev/null || echo "MISSING: apksigner (Android SDK build-tools)"
+```
+
+There is no credential tier to resolve: Gate 2 has no local client, so it is
+`SKIPPED` by construction rather than by configuration. Say which of the two it is
+ -  a user who thinks a credential would unlock it will go looking for one.
+
+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.
+
+## Step 3  -  obtain the build
+
+### Mode B  -  a build you supply
+
+- **iOS `.xcarchive`** → Gate 1 runs on it. To reach Gate 2 the archive must be
+  exported, so run `ios_export_ipa` (see Mode A for the signing inputs).
+- **iOS `.ipa` only** → **Gate 1 is `SKIPPED (needs .xcarchive)`.** The static audit
+  reads archive structure an `.ipa` does not carry. Do not present a two-gate run as
+  a full pass; say which gate did not run and why, and offer to re-run with the
+  archive.
+- **Android `.aab`** → Gate 1 runs in full.
+- **Android `.apk` only** → Gate 1 runs the rules that do not need a bundle and
+  **lists the rules it could not apply**. An `.apk` cannot answer bundle-level
+  questions (per-ABI splits, dynamic features, Play App Signing expectations).
+
+When no path is given, pick the newest artifact and print which one you picked:
+
+```
+iOS:     newest .xcarchive under ~/Library/Developer/Xcode/Archives/**
+Android: newest .aab under **/build/outputs/bundle/**/*.aab
+```
+
+Never validate an artifact whose provenance you did not state. "The newest archive"
+is a guess the user must be able to correct.
+
+### Mode A  -  build from the branch
+
+1. Worktree at `{projectRoot}/{worktreeBasePath}/{taskId}` on the chosen branch.
+   **Never under `$HOME`**, never a direct checkout of the main working tree.
+2. Resolve the scheme / module and workspace / project from prefs; ask if ambiguous.
+3. Build:
+   - **iOS**: `ios_xcodebuild({workspace|project, scheme, action: "archive", configuration: "Release", destination: "generic/platform=iOS"})`.
+     Note the destination: the simulator default would produce an archive that
+     cannot be exported for distribution.
+   - **Android**: `./gradlew bundleRelease` (or the release variant the module
+     declares). A debug-signed bundle fails Gate 1 signing rules for the wrong
+     reason  -  if no release signing config resolves, halt and say so rather than
+     auditing a debug artifact.
+4. **iOS export**:
+   `ios_export_ipa({archive_path, output_dir, method: "app-store-connect", team_id, provisioning_profiles?, signing_style?})`.
+   Leave `allow_provisioning_updates` off unless the user asks: it lets xcodebuild
+   create or modify profiles in the developer account, which a validation run has no
+   business doing.
+5. A failed build or export halts with the parsed errors. The usual iOS causes are a
+   missing distribution certificate, a profile that does not match the bundle ID, or
+   `signing_style: "manual"` with no `provisioning_profiles` map.
+
+## Step 4  -  Gate 1, static package audit
+
+- **iOS**: `ios_app_store_audit({archive_path, rules: "all"})`. Consult the
+  `apple-archive-compliance` skill for what each rule means.
+
+  Needs `@mmerterden/dev-toolkit-mcp` ≥ v2.9.0, which provides the tool. When the
+  MCP server is not registered, the same 18 rules run directly from the package:
+
+  ```bash
+  node -e "import('@mmerterden/dev-toolkit-mcp/tools/ios-app-store-audit/index.js').then(m => m.runAudit({ archivePath: '<path>', rules: 'all' }).then(r => console.log(JSON.stringify(r))))"
+  ```
+
+  Use the fallback only when the tool is genuinely absent, and say in the report
+  which path ran  -  a rule set that silently differed between two invocations is
+  worse than a missing gate.
+- **Android**: `android_apk_audit` on the artifact, plus the
+  `google-play-compliance` skill's 21 rules  -  `bundletool validate` and manifest
+  dump, `aapt2 dump badging`, `apksigner verify`, ABI / native scan.
+
+`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.
+
+## 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.
+
+**Android**: report `SKIPPED (no local Play validator)` with one line on why: the
+authoritative check is a Play Publishing API draft edit, the pipeline ships no
+client for it, and no local tool substitutes. `bundletool validate` is Gate 1 and
+reporting it here would fake a cleared gate.
+
+## 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.
+
+**iOS**  -  `app-store-review`:
+
+| Area | Evidence to gather |
+|---|---|
+| Purpose strings | every `NS*UsageDescription` in Info.plist  -  present, specific, user-facing, and matching what the code actually does with the data |
+| Privacy manifest | `PrivacyInfo.xcprivacy` exists, declares required-reason APIs, and matches the SDKs actually linked |
+| Tracking | if any tracking API or SDK is present, an ATT prompt exists and runs before collection |
+| Account deletion | if the app creates accounts, an in-app deletion path exists (guideline 5.1.1(v)) |
+| Privacy policy | reachable in-app and in the metadata |
+| IAP | anything unlocking features goes through StoreKit, with no external purchase path |
+| Sign in with Apple | present when a third-party social login is offered |
+
+**Android**  -  `play-store-review`:
+
+| Area | Evidence to gather |
+|---|---|
+| Permissions | every `uses-permission` justified by a feature, no sensitive permission without its declaration form |
+| Data safety | the declared data-safety answers match what the code collects and transmits |
+| Target API level | meets the current Play requirement for new releases |
+| Privacy policy | reachable in-app and in the listing |
+| Billing | anything unlocking features goes through Play Billing, with no external purchase path |
+| Account deletion | if the app creates accounts, an in-app deletion path exists, plus the web deletion URL Play requires |
+| Content rating | the questionnaire answers match the app's actual content |
+| Signing | Play App Signing configured, upload key distinct from the app signing key |
+
+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.
+
+## Step 7  -  report
+
+Write to `~/StoreChecks/<platform>-<repo>-<branch>-<timestamp>/report.md` and print
+a summary.
+
+```
+Verdict: <N> of 3 gates cleared[, <M> skipped]
+Platform:<ios|android>
+Build:   <artifact path>  ·  <bundle id / applicationId> <version> (<build>)
+Auth:    tier <1|2|none>  ·  <method>          (iOS only)
+Sweep:   <n> findings | SKIPPED (<reason>)
+
+Gate 1  static audit        PASS | FAIL (<n> blocking, <n> advisory) | SKIPPED (<reason>)
+Gate 2  store validation    PASS | FAIL (<n> issues) | SKIPPED (<reason>)
+Gate 3  policy review       PASS | FAIL (<n> findings) | <n> not-applicable
+
+Blocking  -  fix before uploading
+  [ITMS-90683] Info.plist: NSCameraUsageDescription missing
+      guideline 5.1.1 Data Collection and Storage
+      <hint>
+      <file:line>
+
+Advisory
+  ...
+
+Not run
+  Gate 2: no local Play validator  -  authoritative check is server-side only
+```
+
+Rules for the report:
+
+- A skipped gate is never folded into the pass count. The verdict line states the
+  skip. An Android 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.
+- 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"`.
+
+## 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
+- `/multi-agent:fix-bug` when Gate 3 produced code-level findings
+
+Never upload, never commit a Play edit, never bump the build number, never commit.
+
+## Related surfaces
+
+`/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.

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

@@ -59,8 +59,8 @@ Run every step automatically:
 ```
 Step 1: PLATFORM    Detect macOS / Linux / Windows (Git Bash / WSL); export PLATFORM env
 Step 1.5: DETECT    Compare timestamps, find stale targets
-Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 44 sub-command skills)
-Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 44 specs as refs + 8 agent TOML)
+Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 49 sub-command skills)
+Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 49 specs as refs + 8 agent TOML)
 Step 3: REPO        Claude Code -> pipeline repo (genericized, personal data scrub, bash -n on all sh)
 Step 3c: PLUGINS    pipeline shared/external -> multi-agent-plugins marketplace (rebuild knowledge/,
                      bump changed plugins' patch version, commit + push the plugins repo)
@@ -176,7 +176,7 @@ If nothing is stale → report "All targets up to date" and stop.
 Unlike the Copilot step, this one does **not** hand-copy files. The Codex tree is a
 *transform* of the Claude tree, not a mirror of it, and the transform is real work:
 
-- the 43 sub-command specs become reference files, because Codex silently truncates
+- the 49 sub-command specs become reference files, because Codex silently truncates
   its skills block (see `cross-cli-contract.md` 2.6 for the measurement)
 - every `$HOME/.claude/...` reference to a CLI-owned tree is retargeted, with
   `agents/<persona>.md` becoming `.toml` and the dispatcher becoming the router skill
@@ -484,21 +484,22 @@ When invoked with the `release` argument:
 > Codex takes the Step 2b path instead; see that section.
 
 This runs on the Claude <-> Copilot axis. Codex is NOT synced here: it receives the
-same 43 specs as reference files rather than as peer skills, via Step 2b -  see
+same 49 specs as reference files rather than as peer skills, via Step 2b -  see
 `cross-cli-contract.md` 2.6 for why the parity axis differs per host.
 
 | Claude Code | Copilot CLI |
 |-------------|-------------|
 | `~/.claude/commands/multi-agent/{cmd}/SKILL.md` | `~/.copilot/skills/multi-agent-{cmd}/SKILL.md` |
 
-**44 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
+**49 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels, create-jira, design-check, dev,
 dev-autopilot, dev-local, dev-local-autopilot, diff-explain, forget, garbage-collect,
 help, ios-coding-standard, issue, jira, kill, language, local,
 local-autopilot, log, manual-test, prune-logs, purge, refactor, resume, review, review-issue, review-jira,
-routines, save, scan, search, setup, ship, stack, status, sync, test, testflight-validation, uninstall, update
+routines, save, scan, search, setup, ship, stack, status, store-ready, sync, test, test-accessibility,
+test-dark-mode, test-dynamic-type, test-screenshots, testflight-validation, uninstall, update
 ```
 
 **NOT synced**: `$HOME/.claude/multi-agent-refs/*`  -  lazy-load references, Claude Code specific

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

@@ -22,14 +22,24 @@ Pass `$ARGUMENTS` through verbatim  -  sim-test.md decides which test matrix to
 
 ## Quick reference
 
-| Invocation | What it does |
-|---|---|
-| `/multi-agent:test` | Walk every screen, collect screenshots + UI tree, produce a general report |
-| `/multi-agent:test "dark mode"` | Light vs dark comparison, contrast + colour bugs |
-| `/multi-agent:test "accessibility"` | VoiceOver label + tap-target + contrast audit |
-| `/multi-agent:test "dynamic type"` | Layout check at XL-XXXL text sizes |
-| `/multi-agent:test "screenshot tr"` | App Store screenshot set (Turkish locale) |
-| `/multi-agent:test "store-ready"` | App Store guideline pre-flight check |
+| Invocation | Fixed-scenario alias | What it does |
+|---|---|---|
+| `/multi-agent:test` | - | Walk every screen, collect screenshots + UI tree, produce a general report |
+| `/multi-agent:test "dark mode"` | `/multi-agent:test-dark-mode` | Light vs dark comparison, contrast + colour bugs |
+| `/multi-agent:test "accessibility"` | `/multi-agent:test-accessibility` | VoiceOver label + tap-target + contrast audit |
+| `/multi-agent:test "dynamic type"` | `/multi-agent:test-dynamic-type` | Layout check at XL-XXXL text sizes |
+| `/multi-agent:test "screenshot <lang>"` | `/multi-agent:test-screenshots [locale]` | App Store screenshot set in a locale (alias defaults to tr) |
+| `/multi-agent:test "store-ready" [path]` | hands off to `/multi-agent:store-ready` | package validation, not a UI test |
+
+Both columns are supported and neither is deprecated; the aliases exist so the
+scenario list autocompletes off `test-` instead of having to be remembered.
+
+`store-ready` is the odd one out: it validates a built **package** rather than a
+running app, so it is not implemented here at all. `/multi-agent:store-ready` owns
+it on both platforms  -  three gates per platform, plus this file's sweep as its
+Step A. `/multi-agent:testflight-validation` is the iOS-pinned alias of that
+command. The quoted tag is kept as a hand-off so an existing invocation still lands
+somewhere correct.
 
 ## Requirements
 

package/pipeline/commands/multi-agent/test-accessibility/SKILL.md

@@ -0,0 +1,33 @@
+---
+description: "Accessibility audit on a booted simulator / emulator: VoiceOver labels, sub-44pt tap targets, contrast, traits. Alias pinning the accessibility scenario. Use when auditing a screen for assistive-technology support."
+description-tr: "Booted simulator / emulator üzerinde erişilebilirlik denetimi: VoiceOver label'ları, 44x44pt altı tap target'lar, kontrast oranları ve trait'ler; her ekranda canlı UI tree'ye karşı denetlenir. /multi-agent:test \"accessibility\" için sabit-senaryo alias'ı."
+argument-hint: "(argümansız  -  senaryo sabit)"
+---
+
+# /multi-agent:test-accessibility  -  Accessibility audit
+
+Fixed-scenario alias. The implementation is the UI Bug Hunter flow; this command
+only pins the scenario so the tag does not have to be typed or quoted.
+
+## Dispatcher
+
+Read this file and apply its instructions:
+
+```
+$HOME/.claude/commands/sim-test.md
+```
+
+Run it with **scenario = `accessibility`**. Ignore `$ARGUMENTS`; the scenario is
+fixed by the command name. Anything the user adds is context for the report, never
+a scenario override  -  to run a different matrix they invoke that command.
+
+## Equivalent
+
+`/multi-agent:test "accessibility"`  -  identical behaviour. Both forms are
+supported; neither is deprecated.
+
+## Requirements
+
+- **iOS**: Xcode + a booted Simulator (`xcrun simctl list | grep Booted`)
+- **Android**: Android SDK + a running emulator or USB device (`adb devices`)
+- **MCP**: the `dev-toolkit` MCP server must be installed (tool names start with `mcp__dev-toolkit__`)

package/pipeline/commands/multi-agent/test-dark-mode/SKILL.md

@@ -0,0 +1,33 @@
+---
+description: "Dark mode UI test on a booted simulator / emulator: walk every screen light then dark, report contrast + colour bugs. Alias pinning the dark-mode scenario. Use when a dark-mode rendering bug is suspected."
+description-tr: "Booted simulator / emulator üzerinde dark mode UI testi. Her ekranı light'ta gezer, görünümü değiştirir, tekrar gezer; farktan kontrast + renk + sabit-palet buglarını raporlar. /multi-agent:test \"dark mode\" için sabit-senaryo alias'ı."
+argument-hint: "(argümansız  -  senaryo sabit)"
+---
+
+# /multi-agent:test-dark-mode  -  Dark mode UI test
+
+Fixed-scenario alias. The implementation is the UI Bug Hunter flow; this command
+only pins the scenario so the tag does not have to be typed or quoted.
+
+## Dispatcher
+
+Read this file and apply its instructions:
+
+```
+$HOME/.claude/commands/sim-test.md
+```
+
+Run it with **scenario = `dark mode`**. Ignore `$ARGUMENTS`; the scenario is fixed
+by the command name. Anything the user adds is context for the report, never a
+scenario override  -  to run a different matrix they invoke that command.
+
+## Equivalent
+
+`/multi-agent:test "dark mode"`  -  identical behaviour. Both forms are supported;
+neither is deprecated.
+
+## Requirements
+
+- **iOS**: Xcode + a booted Simulator (`xcrun simctl list | grep Booted`)
+- **Android**: Android SDK + a running emulator or USB device (`adb devices`)
+- **MCP**: the `dev-toolkit` MCP server must be installed (tool names start with `mcp__dev-toolkit__`)

package/pipeline/commands/multi-agent/test-dynamic-type/SKILL.md

@@ -0,0 +1,33 @@
+---
+description: "Dynamic Type layout test on a booted simulator / emulator: re-walk every screen at XL through accessibility-extra-large, report truncation and clipping. Alias pinning the dynamic-type scenario. Use when checking a layout survives large text."
+description-tr: "Booted simulator / emulator üzerinde Dynamic Type layout testi. Her ekranı XL'den accessibility-extra-large'a kadar yeniden gezer; kırpılma, taşma, üst üste binme ve ölçeklenmeyi bırakan sabit yükseklikli container'ları raporlar. /multi-agent:test \"dynamic type\" için sabit-senaryo alias'ı."
+argument-hint: "(argümansız  -  senaryo sabit)"
+---
+
+# /multi-agent:test-dynamic-type  -  Dynamic Type layout test
+
+Fixed-scenario alias. The implementation is the UI Bug Hunter flow; this command
+only pins the scenario so the tag does not have to be typed or quoted.
+
+## Dispatcher
+
+Read this file and apply its instructions:
+
+```
+$HOME/.claude/commands/sim-test.md
+```
+
+Run it with **scenario = `dynamic type`**. Ignore `$ARGUMENTS`; the scenario is
+fixed by the command name. Anything the user adds is context for the report, never
+a scenario override  -  to run a different matrix they invoke that command.
+
+## Equivalent
+
+`/multi-agent:test "dynamic type"`  -  identical behaviour. Both forms are
+supported; neither is deprecated.
+
+## Requirements
+
+- **iOS**: Xcode + a booted Simulator (`xcrun simctl list | grep Booted`)
+- **Android**: Android SDK + a running emulator or USB device (`adb devices`)
+- **MCP**: the `dev-toolkit` MCP server must be installed (tool names start with `mcp__dev-toolkit__`)

package/pipeline/commands/multi-agent/test-screenshots/SKILL.md

@@ -0,0 +1,41 @@
+---
+description: "App Store screenshot set from a booted simulator / emulator in a given locale, taken as an argument and defaulting to tr. Alias pinning the screenshot scenario. Use when generating store screenshots or checking a localised build renders."
+description-tr: "Booted simulator / emulator'dan belirtilen dilde App Store screenshot seti: temiz status bar, her ekran gezilip yakalanır. Dili isim içine gömmek yerine argüman olarak alır (default tr). /multi-agent:test \"screenshot <lang>\" için sabit-senaryo alias'ı."
+argument-hint: "[locale]  -  boş = tr; örn. tr | en | de | ar"
+---
+
+# /multi-agent:test-screenshots  -  Locale screenshot set
+
+Fixed-scenario alias, **parameterised by locale**. The scenario is pinned; the
+language is not, because one command per language would put a parameter in a name.
+
+## Locale resolution
+
+1. `$ARGUMENTS` names a locale (`tr`, `en`, `de`, `ar`, ...) → use it.
+2. `$ARGUMENTS` empty → `tr`.
+3. `$ARGUMENTS` is something other than a locale → do not guess a language and do
+   not silently fall back. Ask which locale with `AskUserQuestion`, rendered in
+   `outputLanguage`.
+
+## Dispatcher
+
+Read this file and apply its instructions:
+
+```
+$HOME/.claude/commands/sim-test.md
+```
+
+Run it with **scenario = `screenshot <locale>`**, substituting the locale resolved
+above. That is the tag sim-test.md matches; passing a bare `screenshot` leaves the
+language unset.
+
+## Equivalent
+
+`/multi-agent:test "screenshot tr"`  -  identical behaviour. Both forms are
+supported; neither is deprecated.
+
+## Requirements
+
+- **iOS**: Xcode + a booted Simulator (`xcrun simctl list | grep Booted`)
+- **Android**: Android SDK + a running emulator or USB device (`adb devices`)
+- **MCP**: the `dev-toolkit` MCP server must be installed (tool names start with `mcp__dev-toolkit__`)