@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/codex/skills/funpixel-store/references/money.md

@@ -0,0 +1,66 @@
+# Choosing the money model
+
+A decision guide, not a market report: which way a game makes money, what the evidence says about each, and which
+fits a platform and a feel. The model and every price are the owner's decision (step 0 of the work); this page
+gives them the numbers to decide with, and the GDD records the choice in its Scope (skill `funpixel-gdd`).
+
+Numbers as of Oct 2026, from one racer's study (design/research/monetisation.md in that game's repository,
+researched 9 Oct 2026). Each figure keeps its source and date; **(snippet)** means it was seen only in a
+search-result summary, not on the page itself. Revenue from AppMagic, Sensor Tower and Steam trackers is a
+third-party estimate, not a company report. Read a source again before a price or a forecast is final.
+
+## The rule that decides most of it
+
+**The genre's big money comes from selling power.** In mobile racing that is CSR Racing 2 ($859.3M gross
+lifetime, AppMagic, (snippet) [PocketGamer.biz, 30 Jun 2026](https://www.pocketgamer.biz/zyngas-csr-2-celebrates-10th-anniversary-with-530m-cars-collected/)),
+Hill Climb Racing 2 ($88.3M net lifetime IAP, AppMagic, [WN Hub, 19 Dec 2024](https://wnhub.io/news/other/item-46592))
+and Asphalt (past $100M in about 3 years, (snippet) [GameDev Reports, 2021](https://gamedevreports.substack.com/p/app-annie-asphalt-9-legends-surpassed)).
+Sports and racing earn 71% from IAP and 29% from ads (Sensor Tower State of Gaming 2026, quoted second-hand by
+[Game Growth Advisor, 16 Apr 2026](https://gamegrowthadvisor.com/blog/2026-04-16-hybrid-casual-game-design-strategy-2026/)).
+Selling power is also where the backlash sits: Asphalt 9's multiplayer "biased towards people who have paid
+more" ((snippet) [Metacritic, 2018](https://legacy.prod.metacritic.com/game/ios/asphalt-9-legends)).
+
+A game that sells no power (upgrades earned by play, a fair race) gives most of that up. Plan for much lower
+revenue per player than those games, and choose ads, cosmetics or premium on purpose, in writing.
+
+## The models, and what the evidence says
+
+| Model | Evidence (dated, sourced) | Fits when |
+|---|---|---|
+| **Premium** (Steam, console; a one-time price on mobile) | Star Wars: Galactic Racer, $59.99, Deluxe $79.99 of mostly cosmetic extras with "no direct advantage" ([Insider Gaming, 21 Sep 2026](https://insider-gaming.com/star-wars-galactic-racer-editions-pre-order-bonuses/)), sold as "complete at launch". Geometry Dash, $3.99 on iOS ([App Store, 9 Oct 2026](https://apps.apple.com/us/app/geometry-dash/id625334537)): $21M+ gross from 242M mobile downloads ([Sensor Tower, Sep 2018](https://sensortower.com/blog/geometry-dash-revenue)), modest next to its reach | The game is finished at launch, the feel is premium, the platform is PC or console; on mobile it sells steadily but small |
+| **Ads first, plus remove-ads** | Alto's Odyssey: 96% of its 4.5M downloads were on free Android, against $4.99 premium on iOS ([Sensor Tower, Oct 2018](https://sensortower.com/blog/altos-odyssey-revenue)); on free Android Alto, IAPs were "less than 1%" of revenue and opt-in video the main driver ((snippet) [Android Authority, c. 2016](https://www.androidauthority.com/games-make-money-interview-noodlecake-studios-publishers-altos-adventure-723910/)). Subway Surfers: 100M+ monthly users and only ~$882k of store revenue in two months of 2026 ([PocketGamer.biz, 27 Apr 2026](https://www.pocketgamer.biz/subway-surfers-city-runs-towards-2m-in-player-spending-in-two-months/)): ads pay at scale. Remove-ads $1.99 bundled with gems ([Beach Buggy Racing 2, App Store, 9 Oct 2026](https://apps.apple.com/us/app/beach-buggy-racing-2/id1399253988)) | A free mobile game with wide reach; rewarded ads at a natural moment (a revive, a retry), interstitials capped and never on a retry |
+| **Cosmetics and a season or realm pass** | Passes at $4.99 ([Hill Climb Racing 2, App Store, 9 Oct 2026](https://apps.apple.com/us/app/hill-climb-racing-2/id1146465836)) to $9.99–14.99 ([Asphalt Legends, App Store, 9 Oct 2026](https://apps.apple.com/us/app/asphalt-legends/id805603214)). Rocket League's pass can earn its 1,000 Credits back ((snippet) [Epic help](https://www.epicgames.com/help/en-US/rocket-league-c5719357623323/gameplay-c7262179951387/what-are-credits-in-rocket-league-a5720133436827)). In 2025's hybrid-casual top 10, a new battle pass was 5–7% of IAP ([GameDev Reports, 15 Sep 2025](https://gamedevreports.substack.com/p/appmagic-top-10-hybrid-casual-games)) | A content cadence (a new place every 6–8 weeks) and live operations every season; looks, never speed |
+| **VIP subscription** | $4.99 a month (Mario Kart Tour's Gold Pass, [Sensor Tower, Apr 2021](https://sensortower.com/blog/mario-kart-tour-200-million-downloads)) to $9.99 (Hill Climb Racing 2 VIP, App Store above). Hot Wheels Unlimited's free tier of 3 challenges a day was called "little more than a cash-grab" ([PocketGamer.biz, 26 Oct 2020](https://www.pocketgamer.biz/the-iap-inspector/74774/how-does-hot-wheels-unlimited-monetise/)) | Only with a daily loop deep enough to justify it; never by starving the free game |
+| **First act free, then one unlock** | Super Mario Run, $9.99: about 3% of ~90M downloads paid (Newzoo, [9to5Mac, 3 Jan 2017](https://9to5mac.com/2017/01/03/super-mario-run-revenue-conversion/)); 4M of 78M (~5%), which "did not meet our expectations" ((snippet) [Nintendo Wire, 24 Mar 2017](https://nintendowire.com/news/2017/03/24/super-mario-run-not-meet-nintendos-expectations-terms-sales/)). Monument Valley 3: two chapters free, then €5.99 ((snippet) [App Store](https://apps.apple.com/me/app/monument-valley-3/id6443563379)) | A finished story told in chapters, a premium feel on iOS; plan on 3–5% converting as the optimistic case, even Mario's |
+| **Gacha (random draws)** | Mario Kart Tour: $268.5M lifetime IAP from 276M+ downloads, and removing its gacha (Oct 2022) "hastened the IAP revenue decline" because the revenue had been built on it ([Mobilegamer.biz, 30 Sep 2026](https://mobilegamer.biz/mario-kart-tour-closes-after-seven-years-and-nearly-270m-in-revenue/)); its pipes kept it out of Belgium ((snippet) [iMore, 2019](https://www.imore.com/mario-kart-tour-not-available-belgium-due-loot-boxes)) | Not as a plan: loot-box law, and a revenue that cannot survive taking the draws out |
+
+## Benchmarks to plan with
+
+- **Payers:** the top 15% of games convert 0.8–1.2% of players ((snippet) GameAnalytics 2019, [WN Hub](https://wnhub.io/news/analytics/item-2261)). Plan on 1–2% payers for a free game; 3–5% for a one-time unlock is the optimistic case.
+- **Revenue per daily user (ARPDAU):** top 15% $0.10–0.14, median $0.02 (same (snippet) source).
+- **Ads against IAP:** racing 71/29; lifestyle and puzzle 59/41; action and strategy 82/18 (Game Growth Advisor, above).
+- **Prices:** remove-ads $1.99–3.99; passes $4.99–14.99 on mobile, $29.99 for a console content pass ([Sonic Racing: CrossWorlds, Steam EU, 9 Oct 2026](https://store.steampowered.com/app/2486820/Sonic_Racing_CrossWorlds/)); cosmetics $0.99–2.99.
+- **Content keeps the money:** Mario Kart Tour was at ~$2M a month when new content ended ((snippet) [VGC, Sep 2023](https://www.videogameschronicle.com/news/4-years-after-launch-nintendo-is-ending-mario-kart-tour-content)) and ~$650k when its closure was announced (Mobilegamer.biz, above).
+
+## Platform × feel
+
+| Platform | Premium feel (a finished, ad-free game) | Free-to-play feel (a free install, many sessions) |
+|---|---|---|
+| Steam, console | Premium, a cosmetic deluxe tier, free updates | Free with cosmetics and a pass works at Rocket League's scale; below it, stay premium |
+| iOS | First act free then one unlock, or premium at $3.99–4.99 | Rewarded ads, remove-ads with a visible bonus, cosmetics; a pass once there is live content |
+| Android | Free with rewarded ads (Alto's team found premium there "even harder", (snippet) [Engadget, 17 Jul 2018](https://engadget.com/2018/07/17/altos-odyssey-android-release-date-free-ios-interview)) | Same, with remove-ads and cosmetics |
+
+What players resent, whatever the model: paying to win races, grind tuned to sell currency, random draws, price
+shocks and things taken away, and too little free game.
+
+## Worked example: a racer that sells no power
+
+A racer (Unity, iOS and Android first; modules unlock by play, never bought) chose, on 9 Oct 2026:
+- **Mobile launch:** free with rewarded ads first; interstitials capped, never on a retry and removed by any
+  purchase; remove-ads at $2.99–3.99 bundled with a starter trail so the buyer sees something; cosmetics at
+  $0.99–2.99.
+- **From the first post-launch realm:** a $4.99 cosmetic-only realm pass with a free track for everyone, paying
+  back part of its price in cosmetic currency. Nothing that changes speed, heat or modules is for sale.
+- **Steam and console:** premium, with free realm updates.
+- **Tested, not assumed:** "first act free, then unlock" as a soft-launch test cell against the above, chosen on
+  revenue per install, not on conversion. No $9.99 VIP until a daily loop justifies one.

package/plugins/codex/skills/funpixel-store/references/purchases-and-review.md

@@ -0,0 +1,74 @@
+# Purchases, ads and review: what the nine games found
+
+From the Unity field report, sections 12 (monetisation, ads, analytics) and 13 (stores and live
+operations). The skill's steps are the rules; this page holds the record behind them. Which model to
+sell by in the first place: [readiness](readiness.md), `references/money.md`.
+
+## If review rejects anyway
+
+| Guideline | Cause | Fix |
+|---|---|---|
+| 2.1(b) | Purchase behind gameplay; reviewer on iPad could not find it | Step 2 |
+| 2.3.3 | Screenshots hid the real HUD and controls | Step 9 |
+| 2.3.7 | "free" in the subtitle | Step 11 |
+
+After a metadata-only rejection, new screenshots uploaded through the API do not clear it; a person
+edits and saves the version, then resubmits. Messages to App Review stay short.
+
+## What 1.0 sold
+
+| Kind | Sells | Examples |
+|---|---|---|
+| Casual | Coins, hints, boosters | four games |
+| Premium | Free first chapter and one non-consumable, Family Sharing on | three games, at $2.99 and $4.99 |
+
+Unity IAP 5.4.3 (StoreKit 2) through one shared purchase service, one-off products only, no server
+receipt validation, no ads in premium games. Restore runs only from a tap (a launch-time restore shows
+an Apple sign-in prompt); prices come only from the store's localised string; failure text is plain
+and a cancel says nothing.
+
+## What the starter wires, switched off
+
+`IAdService` with no release implementation (test ads in development builds
+only) and the pacing rules; the purchase service with Restore in Settings and the purchase screen from the
+first launch; a `.storekit` file for Xcode runs; one purchase gate at the first line of `StartLevel`;
+telemetry muted by every dev flag; a store interface even when 1.0 sells nothing.
+
+## Ads
+
+None were live at 1.0; every game shipped purchases only. As of the report (October 2026): AppLovin MAX
+was closed to new sign-ups (August to September), AdMob was open but its sign-up phone check was never
+completed, ironSource direct demand ended on 30 April 2026, and the legacy `com.unity.ads`
+monetisation is unsupported since 31 January 2026. The plan: Unity LevelPlay 9.5.1 behind `IAdService`
+in a package of its own, with Mintegral, Liftoff, Moloco and Pangle bidding, initialised after the
+consent step and the tracking prompt (consent first, then the prompt, then the network).
+
+Pacing, coded and off:
+
+| Kind | Interstitial | Rewarded |
+|---|---|---|
+| Puzzle | from level 15, every third level | +3 balls |
+| Idle | only after big unlocks, never in the first 5 minutes, at most one per 3 minutes | 2× cash and offline 2× |
+| Versus | every third match after day one | double chest, timer skip with a daily cap |
+
+Never ads in a premium game, and never a No Ads purchase while no network ships. The only retention
+evidence is a teardown of Head Ball 2 from the owner's recording: ads took 44% of a session against
+33% football, and a 105 s ad paid 2,500 coins.
+
+## Privacy and analytics
+
+Firebase Analytics and Crashlytics in every game through one telemetry boundary; events `level_start`,
+`level_end`, `tutorial_complete`, `shop_open`, `unlock_card_view`, `unlock_tap`, plus each game's own.
+No advertising identifier, no tracking prompt, ad personalisation pinned off (the shared Firebase
+setup does all three). App Privacy (website only) declares Device ID, Purchase History, Coarse Location,
+Product Interaction and Crash Data: not linked, no tracking; Purchase History only where there is a
+purchase. The docs said "Data Not Collected" until Firebase shipped, and one draft missed Purchase
+History. No age gate and no Kids category; the ratings came out 9+ and 12+ (fantasy violence). No
+dashboard review is recorded in any session.
+
+## After launch
+
+What the first week watched was App Review's state: three games sat in "Waiting for Review" for over a
+week after a resubmit. No content ships without a store release (no remote bundles or remote config;
+one game's Addressables are built into the app, with no remote catalog), and a server's minimum-version check must compare the build number: the version string
+is 1.0.0 on every TestFlight build.

package/plugins/codex/skills/funpixel-store/references/readiness-page.md

@@ -0,0 +1,24 @@
+# The readiness page
+
+One page per store, in the game's own look (or the studio's, for several games), written to
+`design/pages/<store>-readiness.html`. The shape that worked (a Google Play readiness page for four games):
+
+1. **Header:** the studio, the store, the date checked; the games by name; one line of what the page
+   is based on (the repository at a named commit, the toolchain, the store's pages read that day, a
+   runbook).
+2. **The verdict in a sentence**, then two short paragraphs: what is ready, what is missing, and
+   whether anything is fundamentally blocked.
+3. **At a glance:** a card per game with its id, type and orientation, what it sells, its current
+   size, what to watch, and the effort.
+4. **The matrix:** every area by game, each cell a state (Ready, Partial, Missing, Check, To do, Fix)
+   and one line of evidence. On a phone it scrolls sideways with the area column pinned.
+5. **The rules that apply now:** each with its date, what it means, and whether the games have it,
+   need it, or must verify it.
+6. **The work, in order:** numbered phases, each saying who does it (the owner, an agent, both) and
+   how long, each item tagged with its area (build, firebase, runtime, iap, tools).
+7. **Rough effort** per phase and game, saying when it was estimated.
+8. **Risks** by level (high, medium, low), each with what lowers it.
+9. **Questions for the owner.**
+10. **Sources**, each with the date it was read.
+
+Every "Ready" is something read or measured; every estimate says it is one.

package/plugins/codex/skills/funpixel-store/references/readiness.md

@@ -0,0 +1,107 @@
+# Store readiness
+
+"Can it go on the store?" is answered by an audit, not a guess. The model that worked (a
+Google Play readiness audit, 8 Oct 2026, four games) reads the repository and the toolchain, reads the
+store's current policy pages, and writes one page: a verdict in a sentence, each game at a glance,
+a matrix of every area by game, the store's rules that apply now, the work in order with who does
+each part, the effort, the risks and the questions only the owner can answer.
+
+Use it before store work starts and again before the first upload. It submits nothing: accounts,
+consoles, forms and the submit button are the person's.
+
+## The audit, for any store
+
+Read, never assume. For each game, each of these is **Ready**, **Partial**, **Missing** or **Check**
+(not known until a build runs), with the evidence in one line:
+
+1. **The build the store takes.** Its format and wrapper (an AAB, an IPA, a desktop depot, a zip of
+   `index.html`), target SDK or OS floor, architecture, signing, a version number that only rises.
+   A web game is wrapped for a store; the wrapper is part of the build (references per store).
+2. **Identity.** Package or bundle id, permanent once the app exists: the owner confirms it.
+3. **Payments.** The store's own billing for digital goods, the products' ids and prices, restore,
+   pending and refunded purchases. Never a payment path around the store.
+4. **Privacy.** Every SDK that collects anything (analytics, crash reports, ads ids) named and
+   declared truthfully. A listing that says "no analytics" while one ships is the most common first
+   rejection: fix the source text before anyone fills a form.
+5. **Rating and audience.** The questionnaire, and an audience that keeps the game out of a
+   children's programme unless it is built for one.
+6. **Input and system behaviour.** Back or Escape on every screen, pause on focus loss, haptics,
+   controllers where the store expects them, the platform's edge-to-edge and safe areas.
+7. **Screens and performance.** Every aspect ratio the store's devices have; the low end of its
+   hardware, measured on a real device, not the developer's phone.
+8. **Platform services.** Achievements, leaderboards, cloud saves: in 1.0 or later is the owner's
+   call; whatever the other platform's version shows must not dangle.
+9. **Words.** No other store's name in the game or listing ("App Store" on Android, "Apple ID" on
+   Steam).
+10. **Store art and listing.** Each store's own sizes (they differ and are checked at upload), real
+    gameplay in every screenshot, the listing's length limits.
+11. **Size.** The download against the store's limit and its warning thresholds.
+12. **Branch.** Store builds come only from a clean main; anything unmerged is a blocker.
+
+## The page
+
+Write it as `design/pages/<store>-readiness.html`, in the game's own look, linked from the GDD's
+`## Linked pages` (skill funpixel-gdd, references/pages.md); a host lists and opens it. The shape is
+in [readiness-page.md](readiness-page.md). Every policy fact carries the day it
+was read and its source; a fact not read today says so.
+
+## The rules of each store
+
+- Google Play: [google-play.md](google-play.md)
+- Apple App Store: [app-store.md](app-store.md) (a Unity game also has
+  [ios-release.md](ios-release.md) and [unity-store.md](unity-store.md))
+- Steam: [steam.md](steam.md)
+- itch.io, Poki, CrazyGames, Newgrounds and Funpixel: [web-portals.md](web-portals.md)
+  (pushing a build to itch.io is in funpixel-publish, references/other-hosts.md)
+
+Stores change their rules every few months. The numbers in these references were true on the date
+they carry; before the page is final, read each store's current page and correct what moved.
+
+## The work, in order
+
+0. **The owner's decisions:** ids, what ships in 1.0, the order and timing of releases, the money model and
+   prices ([money.md](money.md): each model's dated evidence, platform × feel).
+1. **A shared foundation** before any one game: the build for that store, signing, the wrapper,
+   one back handler, the store's billing, the privacy manifest or declarations.
+2. **Per-game fixes**, each one named with its file.
+3. **Device test:** emulators and at least one real low-to-mid device; purchases with the store's
+   test accounts (buy, reinstall, refund, a slow payment).
+4. **Store art:** a bake-off per asset type against the competitors' listings.
+5. **The console**, by the person: the app record, the forms, the products, the listing.
+6. **Release**, by the person: one game at a time, a staged rollout where the store has one, the
+   crash and stability numbers watched.
+
+## Tools
+
+- `probe` and `screenshot`: the build played and captured at a phone viewport.
+- `store_shots`: store-size screenshots from the newest real capture run.
+- `npx @funpixel/tools check`, `verify` and `capture --all`: the build each store takes, measured.
+- The store's own checks: `zipalign -P 16` for an Android bundle, Xcode's validation for an iOS
+  archive, SteamPipe's preview build for Steam.
+- `npx @funpixel/tools store init | doctor | lint | plan [--store play|ios|steam]`, read-only and
+  offline: `store/answers.json` (no secrets; unknowns are TODO; both privacy forms come from one
+  `sdks` list), what this Mac has for each store, the answers against each store's rules, and the
+  steps marked Script / Console / You as the references' tables say, with a plan hash. `store push`
+  and `store release` are not built yet: they wait for the owner's decisions on production rights.
+
+## Worked example
+
+Four Unity games for Google Play (8 Oct 2026): no Android build ever made, Unity IAP already
+on Play Billing 9 (Play requires 8+), analytics in all four while two listings said "no analytics".
+Verdict: none can upload today, none is blocked. A shared Android foundation first (an AAB pinned to
+API 36, one upload key, the AD_ID permission removed, one back handler), then 2–8 days per game; the
+screenshots re-composed (iOS sets were 2.17:1, Play allows 2:1); five questions for the owner.
+
+## Common mistakes
+
+- Calling a game ready because the code compiles: a store rejects on forms, art and words.
+- A privacy form filled from a listing that is wrong about the SDKs.
+- Another store's name left in the game or the listing.
+- Screenshots resized from another store's set instead of re-composed from real play.
+- A policy number from memory: every rule carries the day it was read.
+- An agent pressing submit, or deciding an id, a price or a release date.
+
+## Honesty
+
+Effort says when it was estimated; "Ready" is read or measured, never "should be"; risks name the
+store's own reasons for rejection and what lowers each; the owner's questions end the page.

package/plugins/codex/skills/funpixel-store/references/steam.md

@@ -0,0 +1,38 @@
+# Steam
+
+What a readiness page checks for Steam. Read Steamworks documentation on the day and date each fact;
+Valve revises its graphics and review rules from time to time.
+
+## Rules to read and date
+
+- **Steam Direct.** A fee per app (recoupable once the game earns enough, per Valve's current
+  terms); the store page and the build are each reviewed before release, and a "Coming Soon" page is
+  visible for a minimum time before release. Read the current fee, threshold and waiting time.
+- **The content survey**, including Valve's disclosure of AI-generated content in the game and its
+  store page.
+- **Pricing and regions** set in Steamworks; Valve's suggested regional prices.
+
+## The build
+
+- A web game is wrapped as a desktop app (Electron, Tauri or NW.js) with its `dist/` inside, for
+  each operating system it lists; Steam's overlay and achievements through a Steamworks binding
+  (such as steamworks.js).
+- A Unity game builds for each desktop platform; the Steamworks SDK through a binding such as
+  Steamworks.NET.
+- Uploaded with SteamPipe (depots and branches); a beta branch first.
+- **Steam Deck:** controller input for every action, text legible at 1280×800, no launcher that
+  needs a mouse, and Valve's compatibility review.
+
+## Store art
+
+Steam asks for a family of capsules at fixed sizes (header, small, main and vertical capsules, the
+page background, the library capsule, hero and logo), at least five screenshots of real gameplay
+(16:9, 1920×1080 or larger) and a trailer. Read the current sizes from Steamworks' graphical assets
+page; each is checked at upload. The logo for the library is a transparent PNG.
+
+## Matrix rows
+
+Steamworks account and payment · app fee · wrapper and builds per OS · SteamPipe depots · controller
+support and Steam Deck · achievements, cloud saves · content survey and AI disclosure · capsules at
+each size · screenshots and trailer · Coming Soon page and its waiting time · price · other stores'
+words · branch.

package/plugins/codex/skills/funpixel-store/references/unity-store.md

@@ -0,0 +1,55 @@
+# Store listing, purchases and review
+
+Four of eight first submissions were rejected (guideline 2.1(b) twice, 2.3.3, 2.3.7). Each fix was cheap; each resubmitted game then sat over a week in "Waiting for Review". This skill moves those findings in front of the submission.
+
+## Tools
+
+- `npx @funpixel/tools store init --store ios` writes `store/answers.json` (listing, products, the
+  SDK list, review notes); `npx @funpixel/tools store lint --store ios` checks lengths, price words and
+  the privacy answers against the SDKs. App Store Connect (web or API) takes the listing.
+- Screenshots: `funtools sim shot <udid>` on your own `funtools sim lease` (upright for a landscape game) at the game-state markers in the log, framed by
+  moving and scaling pixels, never redrawing them; `sips` reads sizes and alpha.
+- Previews: `xcrun simctl io <udid> recordVideo` on the lease, then `ffprobe` for duration, fps, codec, colour
+  tags, pixel aspect and audio bitrate; `ffmpeg` re-encodes.
+- An icon sheet of your own: candidates masked at 100/60/40 px in a mock search row beside competitors' icons.
+- A fake store behind a dev-only flag (`-fakestore ok|cancel|fail|pending|offline`) or a `.storekit`
+  configuration.
+- Not in the kit: the studio's listing, screenshot and preview scripts, and the checks named below
+  (`iap_pending_once`, `restore_real`, `iap_reach`, `iap_truth`, `store_shots`, `recording_check`,
+  `preview_validate`); each step says what it measures.
+
+## Who does what
+
+| An agent may | Only a person |
+|---|---|
+| Push listings, with approval | App Privacy answers (website only, no API) |
+| Compose screenshots, validate previews | Picking the icon and name; deciding prices |
+| Run the lint and bake-off sheets | The first IAP tick; Submit |
+
+## Procedure
+
+1. Sell only what the binary holds (`iap_truth`). Every IAP id needs an App Store Connect product and an entry point, and copy names nothing unbuilt. Store copy promised modes that existed only as data, and a Supporter IAP had nothing to buy (guideline 3.1.1). No ad network is live, so hide No Ads (four such IAPs had to be held): while no ad network is available, every ad button is hidden. Put one purchase gate at the first line of `StartLevel`, and a store interface even when 1.0 sells nothing (report §12).
+2. Put Buy within two taps of the title on a fresh install (`iap_reach`): an Unlock row in Settings next to Restore, plus a title-screen entry. Name the path in the review notes.
+3. Make Restore real (`restore_real`). It calls `RestoreTransactions` only from a tap, because a launch-time restore shows an Apple sign-in prompt, and it ends in "restored" or "nothing to restore". App Review always taps Restore; one game's only fetched purchases and spun for 45 s.
+4. Show prices only from the store's localised string. Failure text is plain; a cancel says nothing.
+5. Grant a pending order exactly once (`iap_pending_once`). Unity IAP 5 routes pending orders to `OnPurchasePending`; a shared purchase service granted them again from the fetch too, until the fix of 7 Oct (it now grants once per transaction). A game built before it needs a new build.
+6. Buy end to end before review. Products never load on the Simulator without a StoreKit configuration, and no game bought an IAP end to end before submitting; a person checks IAP and Restore on a device.
+7. Derive App Privacy from the SDKs linked (`store lint`: declared ⊇ collected). With Firebase Analytics and Crashlytics the games declare Device ID, Coarse Location, Product Interaction and Crash Data, plus Purchase History where there is an IAP: not linked, no tracking, no tracking prompt (with the advertising identifier turned off). A person enters them.
+8. Pick the icon small. 1024×1024 RGB, no alpha (check with `sips`); one big idea, judged at 60 and 40 px against competitors. Make candidates with `npx @funpixel/tools gen image "<the idea>" --size 1024x1024 --out design/icons/` (metered, after `npx @funpixel/tools login`; a generator's default may be 9:16); the pick goes to `Assets/_Game/Art/Icon/app_icon.png`.
+9. Compose 5–8 screenshots at 6.9": 1320×2868 portrait or 2868×1320 landscape, from real captures taken at game-state markers in the log. `store_shots` passes when sizes are exact, the real HUD is visible, no tutorial UI shows and each caption is true of its frame. How capture bursts are taken: not in the report.
+10. Validate any video before it is shared or uploaded. `recording_check`: 0 frame gaps over 34 ms, audio ≥ 44.1 kHz. `preview_validate`: 15–30 s, ≤ 30 fps, bt709 tags, square pixels, AAC ≤ 256 kb/s; after upload, `previewImage.width > 0`.
+11. Run `store lint --store ios` (lengths; "free" or any price word in name, subtitle, keywords and captions), then push the listing to App Store Connect.
+
+Rejections by guideline, what 1.0 sold and the ad plan: `purchases-and-review.md`.
+
+## Worked example
+
+One game's App Preview: 25 s, 1920×886, cuts about every 1.5 s. App Store Connect showed a red "!" on it twice. The causes were an sRGB colour tag where bt709 is required, non-square pixels, and audio at 263 kb/s against the 256 cap. Setting the poster time through the API then made the preview image 0×0. What held: validate with `ffprobe`, upload, read back `previewImage.width > 0`, leave the poster frame alone.
+
+## Common mistakes
+
+- Resubmitting fast instead of linting first: three games each went back to "Waiting for Review" for over a week.
+- Icons by prompt alone: one game spent $21.46 over 7 rounds before a pick, round one at 720×1280 from the 9:16 default, no competitor benchmark until round 4. Another's bake-off cost $5.95.
+- A Restore label whose hit area covers the shop card: taps on products showed "Restoring purchases" in four games.
+- "Data Not Collected" left in the docs after Firebase shipped in all games.
+- A Simulator recording shown before it was measured: one game's `simctl recordVideo` clip had 19 gaps up to 0.85 s and 24 kHz audio.

package/plugins/codex/skills/funpixel-store/references/web-portals.md

@@ -0,0 +1,43 @@
+# itch.io, Poki, CrazyGames, Newgrounds and Funpixel
+
+Web portals take the built `dist/` (an `index.html` at the top of a zip) and play it in a frame.
+What decides acceptance is the portal's own SDK, its load-time expectations and its rules on ads and
+links. Read each portal's current developer page on the day and date it.
+
+## Funpixel
+
+`funtools publish` with a fresh `verify.json` on the files sent (skill funpixel-publish). The
+readiness rows: verify passes on the build, the leak scan is clean, the store shots and the trailer
+exist.
+
+## itch.io
+
+An HTML5 project: the build as a zip, "played in the browser" ticked, the embed size set, the
+fullscreen button on. Limits from itch.io's HTML5 guide: at most 1,000 files, 500 MB extracted,
+200 MB for any one file, 240 characters for a path, case-sensitive paths. A cover image, screenshots
+and tags. Pushing with butler: funpixel-publish, references/other-hosts.md.
+
+## Poki
+
+An application through Poki for Developers; the Poki SDK in the game (game loading finished,
+gameplay start and stop, ad breaks only where Poki's SDK puts them); no ads or links of the game's
+own; works on mobile and desktop in Poki's frame; a fast first load. Read Poki's current technical
+requirements for its size and load expectations.
+
+## CrazyGames
+
+The CrazyGames SDK (its current major version) for ads, the game's start and stop, and its account
+features; no external links or ads of the game's own; an initial download inside CrazyGames' current
+limits for desktop and mobile; a QA review before release. Read its developer documentation for the
+numbers.
+
+## Newgrounds
+
+An HTML5 zip upload; medals and scoreboards through the Newgrounds.io API; a rating and the portal's
+content guidelines.
+
+## Matrix rows
+
+The portal's SDK in the game · ads only through it · no external links · first-load size and time ·
+works in the portal's frame (focus, fullscreen, audio after the first tap) · mobile and desktop
+input · the portal's art (cover, thumbnails, screenshots) · description and tags · rating.

package/plugins/codex/skills/funpixel-unity-game/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: funpixel-unity-game
+description: Use when making a game in Unity (new from the starter, a port of a web game, a clone of a sibling), measuring or improving its frame time, memory, battery, load time or size, or running several agents on Unity projects on one Mac. Covers rules in C# tested outside the Editor, settings by script, launch flags, parity, player-side probes and Simulator leases.
+---
+
+# Making a game in Unity
+
+Games rebuilt from web builds played end to end 2 hours after kickoff. What goes wrong is silent:
+all four first games reached TestFlight with no sound, cloned projects inherited a sibling's
+settings, and Simulator timings measured the host. This skill makes each of these a failed check
+at scaffold, and routes the measuring and the shared Mac to their references.
+
+## Tools
+
+- `funtools gen <kind> "…" --unity .` (after `funtools login`): pictures, sounds, music and models
+  into `Assets/_Game/Generated/` with import settings, metered; never a provider call with a `.env` key.
+- `funtools unity run -- -nographics -executeMethod Setup.Configure`: your editor script, queued
+  (live: `funtools unity editor compile|console|play|shot`);
+  `dotnet test` on `CoreTests~`: the rules, without Unity.
+- `funtools doctor`: the pre-flight at start and before each build; `funtools serve Builds/WebGL`.
+- `funtools unity probe`: frame time, draws, memory in the player; `funtools sim lease`: your own Simulator.
+- Not in the kit: the starter, its `check`, the studio's scripts (`references/traps.md`).
+
+## Route by the job
+
+| The job | Read |
+|---|---|
+| A new game, or a clone of a sibling | the procedure below; settings come from step 6, never a copied ProjectSettings |
+| A game first made for the web (Pixi, three.js) | below, then `references/from-a-web-game.md`: shipped code, goldens, `parity.md` |
+| Frame time, memory, battery, load time, app size | `references/performance.md`: budgets, the probe in the player, fixes |
+| Several agents or sessions on one Mac | `references/agent-ops.md`: worktree, Simulator lease, the queue, disk |
+| Traps found only at runtime | `references/traps.md` |
+| TestFlight, App Review, the App Store listing | skill `funpixel-store` |
+
+## Procedure
+
+1. Pick the start from the table above.
+
+2. Fix the design facts before the project exists: orientation (puzzle and idle portrait, action
+   landscape), devices (a phone game: iPhone only for 1.0, oldest iPhone 11 at a locked
+   60 fps), the business model (skill `funpixel-store`, `references/money.md`), a content
+   minimum, which visual elements carry rules, and the name on the App Store. Targets: iOS
+   first, Android; WebGL without Firebase, whose C++ SDK has no web build; Mac and Windows by the
+   game's own build methods.
+3. Add what the game uses: Input System 1.20.0, uGUI 2.6.0, URP 17.6.0
+   unless it stays built-in, glTFast 6.20.0 for 3D ("latest" was an
+   experimental 7.0). Remove collab-proxy, learn and visual scripting. Import TMP Essential
+   Resources.
+4. Lay out `Assets/_Game/` as `Scripts/Core`, `Scripts/Game`, `Editor`, `Tests/Editor` (or
+   `Tests/EditMode`), `Art`, `Fonts`, `Scenes`, plus `design/`, `store/` and a README. The rules go
+   in `Scripts/Core`, an asmdef with `noEngineReferences: true`; the rest stays in Assembly-CSharp
+   (the monorepo games) or splits into Game, View and World asmdefs. Add `CoreTests~`
+   for `dotnet test` and un-ignore its project (`!**/CoreTests~/*.csproj`): the root `.gitignore`
+   drops every `*.csproj`. Play Mode tests get an asmdef of their own (`Tests/Play`).
+5. Generate the one scene from code: a camera and one `GameDriver` (input, sim, each event to every
+   presenter once, render), so agents rebuild it headless and never conflict on a scene. Add the
+   AudioListener a code-made camera lacks; hold `audio_runtime`: 1
+   listener, 48 kHz, music within 3 s (of the splash's end, if one plays).
+6. Set every setting in `Setup.Configure`: company name, bundle id, version, IL2CPP, a fixed
+   orientation, Unity splash off, the Android API levels and ARM64, then colour
+   space, 48 kHz audio, render scale 1, ProMotion, accelerometer off, physics auto-simulation off with
+   your own sim, and LZ4HC compression. Build through it. Keep a per-game manifest
+   (orientation, bundle id, colour space, a unique productGUID, audio on, render scale) to diff against.
+7. Register the bundle id, the profile and (with Firebase) one Firebase project per game at scaffold; agents may,
+   with approval (who does what: funpixel-store).
+8. Add dev-only launch flags for every screen and state, `-tour`, `-smoke` (plays to an ending, writes
+   `smoke.txt`) and the probe (`unity probe install`), read through one wrapper that returns nothing
+   unless `Debug.isDebugBuild`, with analytics muted
+   while a flag is on. Keep flag names apart from save keys: `-coins` shadows the PlayerPrefs key
+   `coins`. Judged frames: `references/traps.md`.
+9. Wire purchases and ads switched off: the catalog with Buy and Restore in
+   Settings from the first build, no ads in release, a `.storekit` file for Xcode runs.
+10. Never make a splash or a "Funpixel presents" card.
+11. Plug content in through a registry, so parallel agents add files: one game's branches
+    without one cost 43 hand-resolved merge hunks.
+12. Give each agent its own worktree and Simulator; one Editor per project, closed by its
+    opener (`references/agent-ops.md`).
+13. Before the scaffold is done: `funtools doctor`, `dotnet test`, the Edit Mode tests, a Simulator build, one launch with no flags.
+
+Other day-one rules:
+
+| Rule | Skill |
+|---|---|
+| No flags, second level of a session | funpixel-verify, its Unity page |
+| Bots set the floor, a person the bar | funpixel-game-logic, its Unity page |
+| Audit UI against the parent panel and the art | funpixel-mobile-ui, its Unity page |
+| Pre-flight before every upload; a purchase within two taps | funpixel-store |
+
+## Worked example
+
+A new 2D puzzle game (URP 2D, Linear, portrait):
+Playable on the Simulator in about 1.5 hours; 600 levels by reverse removal, solvable by
+construction, 29 tests. The first TestFlight on day 1 was silent (no AudioListener), and its `-setcoins` flag worked in release builds (no dev gate, step 8).
+
+## Common mistakes
+
+- Cloning a sibling: two games launched in portrait, one inherited
+  `m_DisableAudio: 1`, and one still carries a sibling's `.gitattributes` paths.
+- URP `m_RenderScale: 0.8`: one game drew soft.
+- Patching one game's copy of shared code instead of the shared package.
+- Ungated debug flags: an unlock flag granted paid floors in one game's release build.
+- Rebuilding a web game from its design doc instead of its shipped code: one port's improvised
+  fixes were torn out (`references/from-a-web-game.md`).

package/plugins/codex/skills/funpixel-unity-game/agents/openai.yaml

@@ -0,0 +1,12 @@
+interface:
+  display_name: "funpixel-unity-game"
+  short_description: "making a game in Unity (new from the starter, a port of a web game, a clone of a sibling), measuring or improving its fr"
+policy:
+  allow_implicit_invocation: true
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "funpixel"
+      description: "Funpixel MCP (generation, build, probe, publish)"
+      transport: "streamable_http"
+      url: "https://api.funpixel.ai/mcp"

package/plugins/codex/skills/funpixel-unity-game/references/agent-ops.md

@@ -0,0 +1,54 @@
+# Several agents on one Mac
+
+Unity allows one Editor per project and every game here was built on one Mac with no CI, so parallel agents share a lock, the Simulators and the host's load. When they also shared a Simulator or scratch folder, runs were invalidated. When liveness meant "the process exists", a performance agent on one game sat idle about 8 hours overnight. This skill gives each agent its own resources and makes progress measurable.
+
+## Tools
+
+- `funtools unity run -- -nographics -executeMethod …`: every Unity batch run, through one queue
+  per project path shared by all sessions and repos, two Unity runs on the Mac at most;
+  `funtools unity jobs` lists it. Write no lock of your own: no repo's lock saw another's.
+- `funtools sim lease`: a fresh Simulator of your own. Use its udid in every `xcrun simctl` call,
+  never `booted`, and `funtools sim release <udid>` at the end; `funtools sim shot` and `sim tap`
+  see and press a landscape game upright.
+- `funtools unity editor console|compile|play|stop|shot|menu|call|hierarchy`: about 1 s through an open
+  Editor's bridge (`unity bridge install`), else queued.
+- `funtools unity gc ~/Documents/github`: idle Unity folders and their sizes (`--yes` deletes).
+- `funtools unity gc --disk`: free space and what is safe to reclaim (worktrees, target/, DerivedData, scratch); a report, `--apply --only <kind>` deletes.
+- How these behave, the bridge included: `shared-mac.md`.
+- `npx @funpixel/tools feedback log` for the dev log, and `npx @funpixel/tools progress card` at milestones.
+- Not in the kit: the studio's upload scripts (they hard-code `/Applications/Unity/Hub/Editor/6000.6.0f1/`),
+  and the checks `sim_isolation`, `agent_hygiene`, `agent_liveness`, `lfs_audit`.
+
+## Procedure
+
+What to hand an agent and what never alone, where agents go wrong first, and what earns trust in a
+build: `handing-off.md`.
+
+1. Claim four things before the first build: a worktree, a leased Simulator, a remote-play port and a scratch folder. `sim_isolation` passes when the Simulator id, port and folder are unique per agent.
+2. Send every batch run through `funtools unity run`, and run the engine-free tests between them. One batch run (1–2 min) per project serialised parallel agents, and a half-written file broke other agents' compiles until each had its own build folder.
+3. One Editor per project, opened by the agent that needs it (`--open`, with the bridge) and closed by it (`funtools unity editor close`), never by another. With none open, batch through the queue. MCP for Unity got 0 calls in 29 sessions under a no-Editor rule: no `.mcp.json`, `settings.local.json` disables it, only one game lists `com.coplaydev.unity-mcp` (unpinned, `#main`).
+4. Run anything over a minute in the background. Background agents stalled on the 600 s stream watchdog during foreground Unity and Xcode steps. Read the whole output; `| tail` hid a failing compile check and a commit went through.
+5. Judge a running agent by progress (`agent_liveness`): files under the game changed in the last 30 minutes, or a Unity or `xcodebuild` process at work.
+6. Expect host load to change results. Parallel sessions caused a Burst timeout in one export and slowed another session's 363-test suite from 10–15 to about 27 minutes, so read export logs before trusting a build made under load.
+7. Stage by path. A broad commit glob staged another session's 18 files. Keep `git stash pop` and pattern `pkill` out of agent scripts; both hit work that was not the agent's (see Common mistakes).
+8. Commit and push as work lands, and keep nothing in scratch or /tmp. `lfs_audit` passes at 0 tracked binaries over 500 KB outside LFS, 0 untracked paid art and 0 unpushed LFS objects; about 840 MB of paid generations lived on one Mac.
+9. Publish status at milestones, merged, with the session id on every entry: a network drop killed three sessions and nobody knew which was which. The owner asked "where we are? what's left? how long?" every 20–60 minutes in long sessions; answer from a tracker updated by tools (step, status, who, clock time), not memory.
+10. Sync before saying it is synced. The owner asked "did you sync to remote?" on three games. Push after green checks, rewrite status sections from repo state, and run a docs-freshness check at the end of each task.
+11. Show nothing unverified: `ffprobe` gaps = 0 before sharing a video, and read a published page back. After a change, show the real draw path with the real HUD at full resolution, the player log's exception count, before and after numbers, and the all-screens sheet for UI work; never the Scene view.
+12. After each change, sweep for leftovers: a workaround, a dead flag, a comment that says `(was …`, a date or "the owner". The owner: "no workarounds, remove all leftovers". Never delete an "unused" asset unasked: an agent deleted 20 files the game loads by name.
+13. End a report with at most 3 numbered decisions, each with options, a default, and a picture when it is visual. The owner: "What actually you're asking me now?"
+14. At hand-back, stop what you started (`agent_hygiene`): `funtools sim release` each lease, then your Unity batch processes, child processes and monitors, and only your own. Never quit Simulator.app or run `xcrun simctl shutdown all`.
+
+## Worked example
+
+One game's performance pass, overnight. The agent stalled twice on the stream watchdog and then sat about 8 hours idle; its login had expired. The heartbeat only checked that the agent existed. The probe that would have caught it is `find -mmin -30` under the game folder plus `pgrep Unity|xcodebuild`: no changed file and no build process for 30 minutes means stalled.
+
+## Common mistakes
+
+- Sharing a Simulator or scratch folder: invalidated runs, a tap in another agent's app, an install that killed the coordinator's remote-play session; quitting Simulator.app or `shutdown all` killed other agents' runs three times.
+- A repo-wide status Stop hook (studio-wide): it forced a publish on every turn, fired on other sessions' files, hit the 200/day publish cap; the agent could not edit its own settings.
+- `git stash pop` in a script (a seam fix, 30 Sep): an unquoted zsh `$FILES` stashed nothing, and the pop applied and dropped a stash that was not the agent's.
+- `pkill -f` by pattern (Atlas session, 4 Oct): it killed other agents' runs.
+- Uncommitted work: one port lived 11+ hours uncommitted, and 79 files of a size pass were nearly lost.
+- Infrastructure in /tmp: a restart wiped a Caddy config and build 22 shipped pointing at a dead tunnel.
+- Simulators left running: 5 at about 200% CPU, and a stale app ran 8.8 hours.