@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,2917 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { verify, EXIT } from "./commands/verify.js";
+import { init } from "./commands/init.js";
+import { publish, TARGETS } from "./commands/publish.js";
+import { store, STORE_SUBCOMMANDS } from "./commands/store.js";
+import { doctor, doctorHost } from "./commands/doctor.js";
+import { HOSTS } from "./doctor/host.js";
+import { check } from "./commands/check.js";
+import { discardOffers, upgrade, upgradeSelf } from "./commands/upgrade.js";
+import { dev } from "./commands/dev.js";
+import { parseBots } from "./relay/bots.js";
+import { pack } from "./commands/pack.js";
+import { exportCmd } from "./commands/export.js";
+import { smoke } from "./commands/smoke.js";
+import { test } from "./commands/test.js";
+import { sim } from "./commands/sim.js";
+import { isSimVerb, simulator } from "./commands/simulator.js";
+import { unity } from "./commands/unity.js";
+import { unityPlayer } from "./commands/unity-player.js";
+import { unityBridge, unityEditor } from "./commands/unity-editor.js";
+import { depth } from "./commands/depth.js";
+import { reach } from "./commands/reach.js";
+import { world, WORLD_ACTIONS } from "./commands/world.js";
+import { life } from "./commands/life.js";
+import { walk } from "./commands/walk.js";
+import { compareTakes } from "./commands/compare-takes.js";
+import { printFixes, score } from "./commands/score.js";
+import { wow } from "./commands/wow.js";
+import { framing } from "./commands/framing.js";
+import { boxes } from "./commands/boxes.js";
+import { places } from "./commands/places.js";
+import { hook } from "./commands/hook.js";
+import { feel } from "./commands/feel.js";
+import { lookSheet } from "./commands/look-sheet.js";
+import { gdd } from "./commands/gdd.js";
+import { greenlight, GREENLIGHT_SUBCOMMANDS } from "./commands/greenlight.js";
+import { browserLogin, login, logout, whoami } from "./commands/login.js";
+import { budget, usage } from "./commands/account.js";
+import { estimateCommand, gen } from "./commands/gen.js";
+import { models, MODELS_SUBCOMMANDS } from "./commands/models.js";
+import { assets, SUBCOMMANDS as ASSETS_SUBCOMMANDS } from "./commands/assets.js";
+import { cast, CAST_SUBCOMMANDS } from "./commands/cast.js";
+import { character } from "./commands/character.js";
+import { job } from "./commands/job.js";
+import { jobs } from "./commands/jobs.js";
+import { optimize } from "./commands/optimize.js";
+import { playable } from "./commands/playable.js";
+import { reel, REEL_LIMITS } from "./commands/reel.js";
+import { trailer, TRAILER_LIMITS } from "./commands/trailer.js";
+import { formatsFor, SAFE } from "./trailer/placement.js";
+import { model } from "./commands/model.js";
+import { fidelity } from "./commands/fidelity.js";
+import { auditScreens, BURST, capture, scene } from "./commands/look.js";
+import { captureAll } from "./commands/capture-all.js";
+import { compare } from "./commands/compare.js";
+import { compareTarget, pairTargets } from "./commands/compare-target.js";
+import { parts, parseGrid, parseKey } from "./commands/parts.js";
+import { cutDefaults } from "./commands/cut.js";
+import { lookRead } from "./commands/look-read.js";
+import { look3d } from "./commands/look-3d.js";
+import { HUD_SAMPLING, lookHud } from "./commands/look-hud.js";
+import { lookTheme, THEME_SUBCOMMANDS } from "./commands/look-theme.js";
+import { playtest, PLAYTEST_SUBCOMMANDS } from "./commands/playtest.js";
+import { playtestHosted } from "./playtest/hosted.js";
+import { mobileQa } from "./commands/mobile-qa.js";
+import { lookFit } from "./commands/look-fit.js";
+import { journey, JOURNEY_SUBCOMMANDS } from "./commands/journey.js";
+import { profile, PROFILE_LIMITS } from "./commands/profile.js";
+import { inspect } from "./commands/inspect.js";
+import { phone } from "./commands/phone.js";
+import { clip } from "./commands/clip.js";
+import { judge, JUDGE_SUBCOMMANDS } from "./commands/judge.js";
+import { lessons } from "./commands/lessons.js";
+import { variety } from "./commands/variety.js";
+import { pitch, PITCH_SUBCOMMANDS } from "./commands/pitch.js";
+import { widen } from "./commands/widen.js";
+import { loudness } from "./commands/loudness.js";
+import { zero } from "./commands/zero.js";
+import { review } from "./commands/review.js";
+import { motion, MOTION_SUBCOMMANDS } from "./commands/motion.js";
+import { compose, COMPOSE_SUBCOMMANDS } from "./commands/compose.js";
+import { boardRun } from "./status/board.js";
+import { beats } from "./commands/beats.js";
+import { schema } from "./commands/schema.js";
+import { loop, LOOP_LIMITS } from "./commands/loop.js";
+import { directions } from "./commands/directions.js";
+import { board, BOARD_SUBCOMMANDS } from "./commands/board.js";
+import { feedback } from "./commands/feedback.js";
+import { note, NOTE_SUBCOMMANDS } from "./commands/note.js";
+import { owner, OWNER_SUBCOMMANDS } from "./commands/owner.js";
+import { firstlook, FIRSTLOOK_SUBCOMMANDS } from "./commands/firstlook.js";
+import { flow, FLOW_SUBCOMMANDS } from "./commands/flow.js";
+import { spec, SPEC_SUBCOMMANDS } from "./commands/spec.js";
+import { roomsCommand } from "./commands/rooms.js";
+import { lanes, LANES_SUBCOMMANDS } from "./commands/lanes.js";
+import { pick, PICK_SUBCOMMANDS } from "./commands/pick.js";
+import { progress, PROGRESS_SUBCOMMANDS } from "./commands/progress.js";
+import { journal } from "./commands/journal.js";
+import { decide } from "./commands/decide.js";
+import { DEFAULTS as PLAY_DEFAULTS, play, PLAY_SUBCOMMANDS } from "./commands/play.js";
+import { STEP_LIMITS as PLAY_STEP_LIMITS } from "./play/steps.js";
+import { FRONT_DOOR } from "./look/look.js";
+import { GEN_FLAGS } from "./gen/kinds.js";
+import { ENGINES, VIEWPORT_CHOICES } from "./verify/browser.js";
+import { ui } from "./ui.js";
+import { versionLine } from "./update.js";
+export const USAGE = `usage:
+  funtools init [dir] [--framework pixi|three-world|three] [--name "Title"] [--idea "one line"] [--bare] [--offline] [--no-git]
+  funtools init "<one line: the game you want>" [--framework pixi|three-world|three] [--name "Title"] [--offline] [--no-git]
+  funtools dev [dir] [--no-devtools] [--relay [--bots 1-15] [--no-hold]] [--phone [--host address]] [--open]
+  funtools serve [dir] [--port 5794] [--host address] [--no-compress]
+  funtools open <url|file>
+  funtools find "<what you want to do>" [--json]
+  funtools mcp
+  funtools setup [--host claude|cursor|codex|kiro|robin|all] [--dry-run] [--json]
+  funtools doctor [dir] [--add-hooks]
+  funtools doctor --host [claude|codex|cursor|kiro] [dir] [--json]
+  funtools upgrade [dir] [--discard] | upgrade --self
+  funtools smoke [dir] [--json]
+  funtools smoke-build <fresh-folder> --plan <folder with design/> [--json]
+  funtools test [dir] [--node] [--goals] [--json]
+  funtools check [dir] [--viewport desktop|phone|both] [--phone] [--front-door | --click selector] [--no-test] [--no-idle] [--world | --no-world] [--json]
+  funtools sim [dir] [--script test/probes.ts] [--timeout 300] [--json]
+  funtools sim lease [--device "iPhone 17 Pro"] [--runtime "iOS 26.5"] [--no-boot] [--owner pid] [--json] | sim release <udid> [--force]
+                 | sim list [--json] | sim gc [--dry-run] [--json]
+                 | sim shot <udid> [--orientation portrait|landscape|landscape-left|landscape-right] [--app bundle-id] [--out file] [--json]
+                 | sim tap <udid> x y [--points] [--orientation …] [--app bundle-id] [--tool baguette|idb] [--json]
+  funtools unity run [--project dir] [--unity bin] [--log file] [--no-quit] [--max 2] [--stale-minutes 20] [--max-wait minutes] -- <unity args>
+                 | unity jobs [--json] | unity gc [roots…] [--days 14] [--yes] [--json]
+                 | unity gc --disk [roots…] [--below 20] [--days 2] [--only worktrees,target,derived-data,unity,scratch,context] [--apply] [--strict] [--json]
+                 | unity probe [--project dir] [--target mac|sim] [--path script.json] [--seconds N] [--tier phone|tablet|mac] [--budget file|json]
+                     [--player App.app] [--rebuild] [--no-build] [--port N] [--udid U] [--device name] [--visible] [--sound] [--out file] [--json]
+                     [--player-args file] [-- <the game's own launch arguments>]   (probe, play and capture alike)
+                     [--strict]   (the kit's starting points judge as budgets: a release gate; without it only --budget's numbers fail)
+                 | unity probe install [--project dir] [--from folder | --git url --ref ref] [--absolute] [--tests] [--force] [--dry-run] | unity probe uninstall
+                 | unity play start|end|status | play tap x y|<name> | drag x1 y1 x2 y2 [ms] | key <name> | pad <button> | state | ui | views
+                     | view <name> | scene <name> | shot [--out f.png] | record [--seconds 5] [--out dir] | act "<step>" … | send '<json>' [--points] [--mouse]
+                 | unity capture --all [--project dir] [--target mac|sim] [--out dir] [--settle-ms 1000] [--dev] [--json]
+                 | unity bridge status|install|remove [--project dir]
+                 | unity editor console|compile|play|stop|shot|menu|call|hierarchy|add|save|open|close [--project dir] [--open]
+  funtools spec [lint] [dir] [--spec design/spec] [--tier mid|deep] [--json] | spec init [dir] [--tier mid|deep] [--json]
+  funtools rooms [dir] [--script test/rooms.ts] [--timeout 300] [--json] | rooms open <room> [dir] [--by owner] ["words"] [--json]
+                 | rooms plan [dir] [--by owner] [--json]
+  funtools depth [dir] [--out dir] [--place field] [--tension field] [--progress field] [--fill] [--json]
+  funtools reach [dir] [--level file,…] [--json]
+  funtools world forge [--seed N] [--rooms N] [--kind 2d|3d] [--from GDD.md|brief.json] [--variety N] [--force]
+                 [--dir game] [--json] | world check [--dir game] [--json]
+  funtools feel [dir] [--script test/feel.json | --journey name] [--no-sweep] [--engine chromium|webkit] [--json]
+  funtools gdd [lint] [dir|file.md] [--sources] [--strict] [--json] | gdd page [dir] [--json]
+  funtools greenlight [dir] | greenlight page
+                      | greenlight lock --version v1.0 [--override "why"]   [--dir game] [--json]
+                      | greenlight worth [dir] [--target <min> --by owner] | greenlight worth choose <option> --why "…"
+  funtools verify [dir|url] [--viewport desktop|phone|both] [--watch] [--checks file.json]
+                  [--manifest funpixel.json] [--no-sweep] [--front-door | --click selector]
+                  [--engine chromium|webkit] [--json | --report]
+  funtools verify [dir] --players 2 [--json]
+  funtools capture [dir|url] [--view name | --all] [--verbs a,b] [--hold ms] [--burst frames]
+                   [--viewport desktop|phone [--orientation portrait|landscape] [--safari]]
+                   [--front-door | --click selector] [--out file.png] [--engine chromium|webkit]
+                   [--seed n | --free-running] [--json]
+  funtools compare [dir] [--baseline] [--json]
+  funtools compare [dir|url] --target picture[,picture…] [--view name[,name…]] [--viewport phone|desktop|both]
+                   [--fit contain|cover] [--verbs a,b] [--hold ms] [--front-door | --click selector] [--out dir|file.png]
+                   [--seed n | --free-running] [--json]
+  funtools parts <sheet.png|jpg|webp> [--grid CxR | --boxes boxes.json] [--names a,b,c] [--key auto|none|paper|#rrggbb]
+                 [--pivot bottom|top|center] [--pad 2] [--merge 6] [--clean [--keep-shadows]] [--webp] [--out dir] [--json]
+  funtools cut <sheet.png|jpg|webp> [--grid CxR | --boxes boxes.json] [--names a,b,c] [--keep-shadows]
+               [--pivot bottom|top|center] [--pad 2] [--merge 6] [--webp] [--out dir] [--json]
+  funtools audit-screens [dir|url] [--views a,b] [--viewport desktop|phone [--orientation portrait|landscape]]
+                         [--front-door | --click selector] [--json]
+  funtools scene [dir|url] [--view name] [--verbs a,b] [--hold ms] [--viewport desktop|phone [--orientation portrait|landscape]]
+                 [--motion] [--front-door | --click selector] [--json]
+  funtools hook [dir|url] [--seconds n] [--verbs a,b | --idle] [--viewport desktop|phone [--orientation portrait|landscape]]
+  funtools life [dir|url] [--view name] [--moment name] [--viewport desktop|phone [--orientation portrait|landscape]]
+                [--front-door | --click selector] [--json]
+  funtools walk [dir|url] [--route name,… | --chain a,b] [--seconds n] [--no-film] [--viewport desktop|phone [--orientation portrait|landscape]]
+                [--json]
+  funtools score [dir|url] [--target picture --view name [--hero id] [--hero-share 0.2] [--capture shot.png]]
+                 [--viewport desktop|phone] [--no-judge] [--seed n | --free-running] [--json]
+  funtools score [dir] --fixes [--json]
+  funtools framing [dir|url] [--actors id,…] [--view name] [--viewport desktop|phone] [--json]
+  funtools boxes [dir|url] [--view name,…] [--viewport desktop|phone [--orientation portrait|landscape]]
+                 [--front-door | --click selector] [--json]
+  funtools places [dir|url] [--view name,…] [--viewport desktop|phone] [--json]
+  funtools compare-takes <takeA> <takeB> [--names A,B] [--route name,…] [--viewport desktop|phone]
+                         [--seconds n] [--no-score] [--out dir] [--json]
+  funtools profile [dir|url] [--views a,b] [--viewport desktop|phone] [--seed n] [--frames 120]
+                   [--settle ms] [--software] [--throttle 4] [--repeat 3] [--against profile.json]
+                   [--compare [--budget 18]] [--front-door | --click selector] [--json]
+  funtools inspect [dir] [--at x,y | --name label] [--tree] [--url http://localhost:5317] [--view name]
+                   [--verbs a,b] [--settle ms] [--viewport desktop|phone [--orientation portrait|landscape]]
+                   [--front-door | --click selector] [--json]
+  funtools clip [dir] [--frames dir] [--fps 12] [--seats player,animator] [--json] | clip report [--dir game] [--json]
+  funtools judge structure <picture|folder…> [--prompt "what it should be"] [--dir game] [--json]
+  funtools judge identity <model.glb | view pictures|folder…> [--concept concept.png] [--medium model|sprites]
+                 [--dir game] [--json] | judge report [n] [--dir game] [--json]
+  funtools phone [dir|url] [--sim "iPhone 17 Pro"|udid] [--orientation portrait|landscape] [--seconds 6]
+                 [--taps "25%,80% 75%,80%"] [--swipes "right up"] [--keep] [--out dir] [--json]
+  funtools look [dir|url|capture.png] --read [--view name] [--viewport desktop|phone] [--hold ms]
+                [--player regex] [--threats regex] [--colours player=#hex,threat=#hex]
+                [--front-door | --click selector] [--json]
+  funtools look [dir|url] --hud [--view name] [--verbs a,b] [--samples 8] [--every ms]
+                [--viewport desktop|phone [--orientation portrait|landscape]] [--front-door | --click selector] [--json]
+  funtools look [dir|url] --fit [--view name] [--front-door | --click selector] [--json]
+  funtools look [dir] --sheet [--sprites dir,file…] [--sizes 24,48,96] [--ground #hex] [--out file.png] [--json]
+  funtools look set <token=value …> [--dir game] [--json] | look patch <file.json> [--dir game] [--json] | look report [dir] [--json]
+  funtools play [dir|url] [--viewport desktop|phone [--orientation portrait|landscape]] [--rounds 3] [--long minutes] [--engine chromium|webkit] [--json]
+  funtools play act [--look] "<step>" … | play look | play note "<what you saw>" | play check <file.json|-> | play report <file.json|->
+                | play end | play status   (each takes [--round N] [--dir game]: the round play printed;
+                  needed when two rounds are open in one folder, e.g. a blind pair)
+                play report --round N --refile <file>   file a corrected report into a closed round (ended or filed); the earlier one is kept
+                [--dir game] [--json]
+  funtools journey [--dir game] | journey record <name> [--viewport desktop|phone [--orientation portrait|landscape]]
+                   [--seed n] [--seconds 120] [--force] | journey from-play <round|last> <name> [--seed n] [--force]
+  funtools journey replay <name> [--repeat 1-3] [--against run] [--dir game] [--engine chromium|webkit] [--json] | journey diff <name> [a] [b] [--json]
+  funtools playtest [dir] [--quick] [--versus <evidence dir>|none] [--no-build] [--long minutes] [--phone [--sim name]] [--hosted [--yes]] [--json]
+  funtools playtest experience | report | status [--dir game] [--cost-usd n] [--min-score 6.5] [--json]
+  funtools playtest keep [--dir game] [--drop K<n> --by owner "<their words>"] [--json]
+  funtools mobile-qa [dir] [--phone [--sim name|udid]] [--no-build] [--json] | mobile-qa report [--dir game] [--json]
+  funtools lessons [--genre g] [--dir game] [--json]
+  funtools lessons add "<finding>" --fix "<what fixed it>" [--source panel|player|verify|look]
+                   [--delta 0.4] [--share] [--dir game] [--json]
+  funtools lessons motif [--dir game] [--json]
+  funtools variety [dir] [--within] [--json]
+  funtools wow [dir] [--genre card] [--json] | wow pick <move-id> [--signature] [--expression "…"] [--why "…"] [--check "event name"|"frame view"] [--dir d] | wow check [dir]
+  funtools pitch [show|propose|pick|ask|lock] [<choice> <option[,option]>] [--why "…"] [--label "…"] [--picture path]
+                [--cost "…"] [--note "the person's words"] [--dir game] [--json]
+  funtools pitch widen [--seed N] [--dial tight|open|wide] [--brief "…"] | widen score [--text "…"] | widen keep <card>
+                [--dir game] [--json]
+  funtools loudness [files or folders…] [--dir game] [--json]
+  funtools beats [tracks or folders…] [--meter 4] [--dir game] [--json]
+  funtools schema [dir] [--strict] [--json]
+  funtools loop <video|frames folder> [--fps 12] [--min 6] [--max 24] [--size 256] [--key auto|none|#rrggbb]
+                [--name walk] [--out file.png] [--dir game] [--json]
+  funtools directions <render folder> [--dirs 8|4] [--size 128] [--key auto|none|#rrggbb] [--reverse]
+                      [--name hero] [--out file.png] [--dir game] [--json]
+  funtools board [show|search "<words>"|wander <ref>|add <link|file>] [--keep 1,3] [--lends palette,light]
+                 [--note "…"] [--licence "…"] [--by name] [--title "…"] [--limit 12] [--any-licence]
+                 [--dir game] [--json]
+  funtools journal ["<what you changed>" [--why "<why>"] [--by name] [--files a,b] [--values k=v,k=v]]
+                  [--dir game] [--json]
+  funtools decide ["<choice>" --because "<reason>" [--over "<alternative>"] [--supersedes D3]]
+                 | decide --from N<n> ["<the decision>"] [--touches look,src/hud.tsx] [--dir game] [--json]
+  funtools lanes [status] | lanes plan [--stage s] [--lanes play,look,audio|room-2|rooms] [--cap usd] [--timebox min]
+                | lanes brief|start|done|gate|sync|merge <id> | lanes start --all [--by name]
+                | lanes checkpoint <id> --line "…" [--shot png] [--cost usd] [--minutes n] [--final]
+                | lanes verdict <id> pass|fail --by <seat> ["words"] | lanes report | lanes cap <id> <usd> --by owner
+                | lanes drop <id> --by owner   [--dir game] [--json]
+  funtools pick [list] | pick <topic> <a.png> <b.png> [c.png] [--lane id] [--question "…"]
+               | pick choose <topic|Q> <option> --by owner ["words"]   [--dir game] [--json]
+  funtools status [dir] [--json]   (flow's status: where the run is and the one next step)
+  funtools zero [dir] [--json]   (the zero board: errors, overlaps, seams, frame time, round by round)
+  funtools review [file|folder…] [--dir project] [--loop] [--still] [--freeze s] [--triangles n]
+                  [--size WxH] [--alpha] [--lufs n] [--json]   (the zero board for any trade's media)
+  funtools flow [dir] | flow start [dir] --idea "<the game in a line>" [--autonomy plan-then-go|ask|go] [--budget <credits>|open|free|code-drawn] [--rounds n]
+               [--framework f] [--name t] [--bare] [--offline] [--no-git] | flow ask [dir]
+               | flow agree [dir] --by owner ["words"] | flow round [dir] | flow look [dir] | flow drop [dir] --by owner "<the owner's words>"   [--json]
+  funtools note [list] | note ["<the owner's words>"] | note add "<words>" [--stage <stage>] [--screenshot path] [--by owner|agent] [--hold]
+                | note close <N> --evidence <path|sha|test> | note close <N> --by owner --force ["words"] | note verdict <N|stage> accept|reject ["words"]
+                [--dir game] [--json]
+  funtools owner [list] [dir] | owner add "<line>" [--repo dir] | owner remove <n|id> [--repo dir] | owner seed
+                | owner apply <n|id> [--dir game] | owner skip <n|id> ["why"] [--dir game]   [--json]
+  funtools firstlook [dir] | firstlook skip <item> --by owner "<their words>" | firstlook need <item>
+                    | firstlook render [dir] [--page design/first-look/draw.html]   [--dir game] [--json]
+  funtools progress [status] | progress card --line "<what changed>" [--stage s] [--shot path|last] [--clip path]
+                   [--next "…"] [--spent n] [--evidence verify.json|file] [--decision "a; b"] [--out "a; b"] [--standin "a; b"]
+                   | progress heartbeat --tried "…" [--shot path|last] [--stage s]
+                   | progress ask "<question>" --kind taste|spend|scope --options a,b [--default a] [--timeout 10m]
+                   | progress answer <Q> <option> ["words"] | progress wait [Q] [--for 15m] | progress report
+                   [--dir game] [--json]
+  funtools feedback collect <folder…> [--out report.md] [--propose] [--html page.html] [--json]
+  funtools feedback log "<what happened>" [--kind step|test|dead-end|lesson|decision|worked|didnt|owner]
+                   [--metric name --before n --after n --unit u] [--evidence path] [--film path] [--sha commit]
+                   [--test name] [--cost-usd n] [--minutes n] [--minutes-lost n] [--tool name] [--stage s]
+                   [--verdict pick|reject|note] [--screenshot path] [--dir game] [--json]
+  funtools feedback ab "<game>" --routes a,b [--overall 7.0,8.0] [--axes "story=7.0/8.7,…"] [--winner b]
+                   [--judges "3 blind seats"] [--what "…"] [--evidence path] [--dir game] [--json]
+  funtools feedback merged [--sha ref] [--dir game] [--json]
+  funtools pack [dir] [--dry-run] [--no-build] [--json] [--out file.tar.gz]
+  funtools export <dest> [--dir game] [--check] [--no-browser] [--strip-metadata] [--json]
+  funtools gen <image|texture|strip|sprite|edit|sheet|sound|music|model3d|skybox|find-material|material|video|
+                inspect|optimize-model|fracture|lod|rig|render|finalize|level|skin|retexture|motion|retarget>
+                ["prompt"] [options]
+                [--out path | --unity <project>]
+               [--cast <id>] [--no-wait] [--yes] [--strip-title] [--json]
+  funtools character list [--medium 2d|3d] [--body biped|quadruped|flyer] [--json]
+  funtools character get <id> [--files a,b] [--out dir] [--json]
+  funtools character restyle <id> "the new look" [--game-id id] [--animations idle,walk]
+                    [--palette #hex,…] [--quality low|medium|high] [--yes] [--json]
+  funtools estimate <kind> ["prompt"] [options] [--json]
+  funtools models list [--json] | models install <local id> [--force] [--json]
+  funtools assets status [--dir game] [--json]
+  funtools assets gen [--only a,b] [--family f] [--stale] [--max-credits n] [--batch n] [--dry-run] [--yes]
+                      [--dir game] [--json]
+  funtools assets regen <name> --because "what was wrong" [--dry-run] [--yes] [--dir game] [--json]
+  funtools assets process [--only a,b] [--dir game] [--json]
+  funtools assets pixels [file.png…] [--snap] [--dir game] [--json]
+  funtools assets script [--write] [--from design/GDD.md] [--dir game] [--json]
+  funtools assets budget [<credits>] [--by owner] [--dir game] [--json]
+  funtools cast add <id> --master <png> --pins "the design in words" [--turnaround <png>] [--name N]
+                [--kind character|creature|structure|vehicle|prop] [--features "a;b"] [--may-change "…"]
+                [--moves] [--by owner] [--dir game] [--json]
+  funtools cast list [--dir game] [--json]
+  funtools cast check <id> <picture…> [--mode same|pose] [--dir game] [--json]
+  funtools job <id> [--wait] [--out path] [--json]
+  funtools jobs [--tool name] [--status queued|running|succeeded|failed|cancelled] [--limit 1-100]
+                [--cursor c] [--refusals] [--json]
+  funtools optimize [dir] [--check] [--json]
+  funtools optimize <compress|pack-atlas|unpack-atlas|pack-strip|optimize-mesh> <path…>
+                    [--dir game] [--max-size px] [--format keep|png|jpeg] [--quantize]
+                    [--padding px] [--pot] [--no-trim] [--frame-size px] [--out path]
+                    [--out-dir dir] [--levels phone,desktop,high] [--class character|prop|set_piece|…]
+                    [--write] [--json]
+  funtools playable [dir] --network applovin|unity|ironsource|mintegral|google|meta|tiktok
+                    [--no-play] [--json]
+  funtools trailer [dir|url] [--seconds 30] [--fps 15] [--formats 16x9,9x16,1x1,4x5 | --for tiktok,feed,store]
+                   [--viewport desktop|phone]
+                   [--music file | --no-music] [--no-sfx] [--title "Name"] [--key-art file] [--logo file]
+                   [--cta "Play free"] [--intro clip.mp4] [--outro clip.mp4] [--out dir] [--json]
+  funtools reel [dir|url] [--seconds 12] [--fps 12] [--viewport desktop|phone]
+                [--frames-only] [--out file.mp4] [--json]
+  funtools motion render <scene.html|folder> [--fps 30|60] [--seconds n | --frames n]
+                  [--size 1080x1920 | --aspect 9:16|16:9|1:1|4:5] [--out dir] [--webm] [--audio file]
+                  [--prove] [--seed n] [--json]
+              | motion check <render folder|scene> [--prove] [--json] | motion new <name> [--aspect 9:16] [--dir folder]
+  funtools compose new <trailer|post|endcard> [dir] [--name n] [--aspect 16:9|9:16|1:1] [--seconds n] [--force] [--json]
+  funtools compose <check|render> <composition.html> [--dir game] [--aspect 16:9|9:16|1:1] [--seconds n] [--fps 30]
+                   [--quality draft|standard|high] [--software] [--out file.mp4] [--json]
+  funtools compose variations [design/compose/ads.json] [--dir game] [--max 12] [--dry-run] [--fps 30]
+                   [--quality draft|standard|high] [--software] [--out dir] [--json]
+  funtools model <inspect|render|finalize|skin> <asset-id|model file gen saved> [--frames 1-12]
+                 [--size px] [--keep-clips Idle,Walk] [--tone #rrggbb] [--out path] [--json]
+  funtools model retexture <asset-id|model file> "new look" [--palette #a,#b] [--game-id id]
+                 [--quality low|medium|high] [--roughness] [--normal] [--out path] [--json]
+  funtools model level <spec.json> [--size 256-1024] [--out path] [--json]
+  funtools model --local <inspect|normalize|decimate|render|finalize> <model.glb|gltf|fbx>
+                 [--out path] [--target-triangles n] [--height-m m] [--frames 1-12]
+                 [--size px] [--keep-clips Idle,Walk] [--json]
+  funtools model --local level <spec.json> [--out file.glb] [--size 256-1024] [--json]
+  funtools model clips <model.glb|gltf> [--json]
+  funtools fidelity <model.glb> name=ref.png [name=ref.png …] [--renders dir] [--out dir] [--size px]
+                    [--own-axes] [--roll] [--outline] [--quarter-turns] [--same-scale] [--min pct] [--json]
+  funtools login [--key fp_live_…|-] [--api <url>] [--scope a,b]
+  funtools whoami
+  funtools --version | -v | version
+  funtools usage [--days 1-92] [--this-key] [--json]
+  funtools budget [--json]
+  funtools logout
+  funtools publish [dir] [--target funpixel|itch|pages|folder] [--yes] [--json]
+                   funpixel: [--name "Title"] [--game-id id]
+                   itch: --itch user/game[:channel]   pages: [--project name]   folder: --out dir
+  funtools store init|doctor|lint [dir] [--store play|ios|steam] [--json] | store plan [dir] [--store play|ios] [--json]
+
+  init     write a new game the platform builds as-is, with its agent files; with an
+           API key it also mints the game's id on the server (--offline skips that).
+           One line (--idea, or a first argument with spaces) picks the closest starter,
+           each pick with its reason: the engine (3D words → Three), the genre recipe
+           (the GDK's cards), how a phone holds it, a folder and a working title; it seeds
+           design/GDD.md with the line as the pitch. Flags and your edits override all of it.
+           Into a folder with an owner's design/plan.md: the plan sizes the tier, the planning
+           stages it answers start done, nothing in design/ is overwritten. --bare writes the
+           spine only (hooks, safe band, platform, save, sound, store, look, probes) and a
+           game.ts that opens the engine: no demo round to move aside. The new game is its own
+           git repository with a first commit (skipped inside an existing repository;
+           --no-git skips it): push it to a remote so it survives this machine
+  setup    the kit into your agent in one command: the package's plugin builds copied to
+           ~/.funpixel/plugins/<version>, then installed into each host found (or the one named): Claude Code
+           (its plugin marketplace and install), Cursor (its local plugins folder), Kiro (the installer), and
+           the one step Codex and Robin take in their apps. --dry-run says every step and runs none. Never
+           writes a key: funtools login is next
+           exit 0 set up · 1 a step failed or no host found · 3 error
+  mcp      funtools as a local MCP server over stdio, for a host with no shell (Robin, a desktop chat app): the
+           path as tools (flow, find, flow_start, flow_ask, flow_agree, flow_round, flow_look, check, verify, test, sim, capture,
+           compare, score, the asset steps, gen, notes, progress_card, reel, compose_video, ad_variations), dev (starts the preview, returns its
+           address), image (a picture into the chat) and run (the rest of the toolbox). Never publish, login or
+           logout: the person runs those. Started by the host: command funtools, arguments mcp
+  find     search the kit for an ask in plain words: the three skills to read and the five commands that fit
+           best, each with the words that matched. Read-only and offline
+           exit 0 found · 2 nothing matched · 3 error
+  serve    a Unity WebGL build (a folder with index.html, or a Unity project's Builds/WebGL) on this Mac
+           and on a phone on the same Wi-Fi, with its LAN address and a QR code: Brotli files go as
+           Brotli only to a browser that accepts it on localhost or https, and as gzip made from the
+           same bytes to anything else (a phone on http://<LAN address> refuses Brotli:
+           ERR_CONTENT_DECODING_FAILED); .gz as gzip; .wasm as application/wasm, .data as
+           application/octet-stream. Plain compressible files (Addressables bundles, .wasm/.json/.data
+           with no .br/.gz twin, .js, .css, .html, .svg, .txt, everything in StreamingAssets/aa but
+           media) are compressed on the fly as a CDN would, Brotli or gzip by the same rule, so what a
+           page fetches here weighs what it would live; never images, audio or video; a Range request
+           gets the bytes as stored. --no-compress sends files as stored (the raw weight). Binds every
+           interface (--host 127.0.0.1 keeps it on this Mac); runs until Ctrl-C, then says what it sent
+           exit 0 stopped · 3 no build there, or the port is taken
+  open     open a URL or a file (a target frame, a clip) on the owner's screen with the system's opener; a host with
+           its own browser (Cursor, Codex) shows it there instead. Nothing opens in CI or with FUNPIXEL_NO_OPEN
+           exit 0 opened · 2 nothing opens here · 3 error
+  dev      the game's Vite dev server, with the platform's inspector and profiler; --open opens the preview
+           in the owner's browser, in its own tab, once it is up;
+           --relay also runs a local relay: open /__funpixel/play in two tabs to play
+           the game's dev room (needs the funpixel-relay binary and a Redis);
+           --bots N seats N headless bot players there first, each playing through the
+           game's __FPX_VERBS__ (else its __FPX_KEYS__, else taps) until you stop dev;
+           a full reload is held while two or more pages are in the room, so a save never
+           ends the match being tested (--no-hold sends each at once);
+           --phone serves it on this Mac's local-network address and prints a QR code: the
+           game on your real phone, rebuilt live (off by default: it exposes the dev server
+           to the network; --host 0.0.0.0 binds every interface)
+  doctor   static checks: will the platform build it, can verify measure it;
+           a Unity project gets the Unity pre-flight instead (run it at project start and before
+           every build; it reads files, never starts Unity): Git LFS pointer files where binaries
+           belong (Assets, Packages, every local file: package, Library/PackageCache) with the
+           repository to run \`git lfs pull\` in; activeInputHandler against an iOS or Android
+           target; TextMeshPro's Essential Resources; a camera with no AudioListener; banned APIs
+           (one table: Shader.WarmupAllShaders on URP, UnityEngine.Input on the Input System
+           only, -quit with -runTests…); a Shader.Find nothing references; GLBs glTFast cannot
+           decode (meshopt, Basis, WebP); ProjectSettings drifted from the project's own setup
+           method; the fixes past builds repeated (48 kHz, Unity audio switched off,
+           mipmapped NPOT and uncompressed textures with their MB, .meta files an import rule
+           rewrites, a productGUID, metroPackageName or .gitattributes cloned from another project
+           on this Mac, which branch and commit each file: shared package compiles, Firebase on the
+           Simulator, ungated launch flags, EditorApplication.Exit outside batch mode, the
+           netstandard guard, IL2CPP numbers, Simulator UDIDs typed into scripts), each a warn or
+           a note with its fix but a build that plays no sound; then this Mac: the Editor and the
+           build modules each target needs, with the
+           Unity Hub line, and for iOS the distribution certificate, Xcode account and App Store
+           Connect key, each present or missing (names only, never a secret);
+           --add-hooks writes src/fpx-hooks.ts into a game that has no __FPX_* hooks;
+           --host reads the host agent's own permission settings (Claude Code, Codex, Cursor
+           CLI, Kiro CLI; detected when no name is given): which commands the kit runs it lets
+           through, which shapes (chains, heredocs, loops, python) it may refuse and a plain
+           call for each, and the allowlist lines you could add. Reads, never writes; exit 0
+  upgrade  update the files funtools wrote; never overwrites your changes. --discard: say no to
+           the waiting <file>.funtools-new copies (deleted, and not offered again until the kit
+           changes that file again). --self: the
+           newest funtools on npm and the command that installs it. Once a day funtools
+           looks for one in the background and says so after a command (never in CI, with
+           --json or off a terminal; FUNTOOLS_NO_UPDATE_CHECK=1 turns it off)
+  smoke    static checks of what ships (exit 1 = a player will see it)
+  smoke-build  the 10-minute build before any full build: init --bare, the plan's locked sheets pinned, one
+           picture and one 3D model through the hosted tools, placed, captured, the world read, the target
+           scored, one card. Pass/fail on a model in the world, the locked look, no primitives, a real card.
+           Needs a key and Chromium; costs one picture and one model (.funtools/smoke-build.json)
+  test     run the game's npm test and record its exit with the build fingerprint
+           (.funtools/tests.json); exit 0 pass · 1 fail · 3 no test script. --node runs
+           test/**/*.test.ts with this Node directly (no npm, nothing on PATH; imports without
+           an extension resolve to .ts), and an npm test that cannot start (exit 126/127) falls
+           back to it on its own
+           --goals: one bounded player per goal the GDD's behaviour tests state (test/goals/<id>.json,
+           written for each goal sentence with none: observe = how met is seen in __FPX_STATE__,
+           route = journey steps, caps = steps/seconds/loop): the route replayed in a real browser
+           and a seat prompt for a fresh agent (.funtools/goals/<id>/seat.md, its answer read back);
+           each goal met · not met · blocked (could not act, or stuck) · not observed, in
+           .funtools/goals.json. Never changes the exit code
+  check    build, the rules suite and verify in one call (the loop's chain, for hosts that
+           refuse \`&&\`): a red build stops there; exit 3 a step could not run · 1 one failed ·
+           2 verify observed nothing · 0 all passed. Then notes and warnings that never change
+           the exit: the production mirror; the frame contract (needs → systems: a starter part
+           you replaced is measured for the basic it carried, e.g. the safe HUD band, a save that
+           survives a reload); the look (src/look.json: tokens the game would drop, contrast with
+           inks proposed, the page's "[frame] look fallback" lines); the idle run (no input after
+           Play for 20 s: time alive, deaths, how it ended, warned under the genre's floor;
+           .funtools/idle.json; --no-idle skips it). --phone also verifies on a phone and
+           measures the band there (pieces under the notch or home bar, HUD cover of the play).
+           The world, for a 3D game or one with __FPX_ACTORS__ (--world forces, --no-world
+           skips): boxes (flat boxes near the camera, grounding) and life (animated vs a picture
+           slid or bobbed, travel, crowd, flyers), read as the slice gate and its card read them.
+           Each step lands in .funtools/check.json as it finishes: a run stopped partway (a
+           signal, or killed under load with exit 137) keeps what it measured and says it was
+           cut short (at once, or at the next check)
+  sim      the rules played by bots over seeds (the game's test/probes.ts on src/probe-kit.ts,
+           engine-free, free): standing still wins, no skill ceiling (a naive steer-to-target
+           player does as well as a sharp one), the taught line loses, the novice floor, a
+           never-happens check, play length (a skilled run under 3 min on one screen, 5 with
+           levels, or under the design doc's play-length line), a sharp bot that stalls (bot
+           broken), the best staged moment, music that follows play. Spread and per-level
+           splits, the probe's stderr printed; --timeout stops the probe (default 300 s). A
+           mirror: warnings never fail it; records .funtools/sim.json
+           exit 0 measured · 2 nothing measured (no probe script) · 3 error
+           sim lease|release|list|gc|shot|tap: an iOS Simulator of the agent's own. \`lease\`
+           creates a fresh one named ft-lease-<id>, records its owner (the agent's process:
+           --owner, FUNTOOLS_OWNER_PID or the host's), boots it headless and prints its udid;
+           \`release <udid>\` shuts down and deletes that lease and only a lease (another live
+           owner's needs --force); \`list\` shows leases, owners and states; \`gc\` deletes leases
+           whose owner is gone (--dry-run lists them), and only ever ft-lease-* devices. \`shot\`
+           saves the screen upright in the game's orientation (--orientation, else the app's
+           Info.plist: --app or the one app running, else what the lease last used); \`tap\`
+           presses (x, y) of that upright picture (pixels; --points), mapped onto the portrait
+           digitizer, through baguette or else idb (--tool; simctl cannot tap; on the home
+           screen a baguette tap reads as a long press), on a lease only. Never
+           quits Simulator.app, never \`simctl shutdown all\`, never touches a device it did not
+           create. Records in ~/Library/Caches/funtools/sim-leases
+           exit 0 done · 2 not observed (no tap tool) · 3 refused or error
+  unity    Unity on a Mac several agents share. \`unity run -- <unity args>\`: one batch job through
+           the machine-wide queue — one job per Unity project path across every session and
+           repo, at most --max Unity batch runs on the Mac (default 2, FUNTOOLS_UNITY_MAX;
+           Unity runs no funtools job owns count too). While it waits it prints who holds the
+           lock (session, pid, command, since). Liveness is progress: the holder's log grows or
+           its processes use CPU; a holder that is gone or makes no progress for
+           --stale-minutes (default 20, FUNTOOLS_UNITY_STALE_MINUTES) is reclaimed with a
+           message. An Editor with the project open refuses the run (it is never quit for you).
+           Adds -batchmode, -quit (not with -runTests or --no-quit), -projectPath (the cwd or
+           --project) and a per-job -logFile (Logs/funtools-unity-<when>-<id>.log, or --log);
+           the Editor is the project's ProjectVersion.txt one from Unity Hub (--unity,
+           UNITY_PATH). Prints the log's errors and passes Unity's exit code through.
+           \`unity jobs\`: holders, waiters, slots and outside Unity runs. \`unity gc [roots…]\`:
+           Library/, Builds/, Temp/ and Logs/ untouched for --days (default 14) under the roots
+           (default the cwd), with sizes; a dry run unless --yes; a project Unity has open, whose
+           lock is held or a job waits for, is skipped. Locks in ~/Library/Caches/funtools/unity-locks.
+           \`unity gc --disk\`: the whole disk, advice first. Free space against --below GB (default 20),
+           then what is safe to reclaim, largest first, each with its size, why and the one command:
+           this repo's worktrees already in the current branch, clean, with nobody in them (git
+           worktree remove, never --force); cargo target/ (sized by listings and stat, never du;
+           reclaim with scripts/target-gc.sh; not measured while cargo runs); Xcode DerivedData and
+           agents' *-dd temp folders untouched --days (default 2) with no xcodebuild on them; idle
+           Unity folders; .funtools/unity scratch older than --days. ~/Library/Caches, the Trash and
+           Docker are sized, never touched. Walks are bounded (≥ means at least) and never follow a
+           symlink. A report; --apply deletes only the kinds named with --only (worktrees,
+           derived-data, unity, scratch), each re-checked first. Exit 0 above the threshold, 1 below
+           (advice; --strict marks it FAIL), 125 refused
+           exit Unity's own code · 125 nothing ran (refused, gave up waiting)
+           \`unity probe\`: the real player measured (com.funpixel.probe in a development build; add it
+           with \`unity probe install\`, which prints the one manifest line). Builds the player through the
+           queue or reuses a current one (Builds/FunpixelProbe/), launches it — a Mac player hidden and
+           muted (--visible, --sound), a Simulator on a lease of its own (--udid one you leased) — plays
+           --path's steps (taps, drags, keys, waits, scenes, segments, shots, expects), measures --seconds,
+           and reads frame/main/render/work time p50 p95 p99 max, hitches by frame, draws, SetPass,
+           triangles, GC per frame and memory, warm-up/capture/load frames left out. Judged against the
+           tier's budgets (--tier phone|tablet|mac, --budget); a hitch whose own work stayed small is
+           flagged as the host's. Writes .funtools/unity/probe.json. \`unity play\`: a remote-play
+           session (start, then tap/drag/key/pad/state/ui/shot/record, end), in the game's own upright
+           pixels (--points). \`unity capture --all\`: one still of each registered view, else each scene,
+           from a capture build with no development watermark (--dev: the development player)
+           exit probe 0 pass · 1 over budget or a step failed · 2 not observed · 3 error
+           \`unity bridge status|install|remove\`: MCP for Unity (CoplayDev/unity-mcp, MIT) in a
+           project, pinned to v10.3.0. status reads the manifest, the Editor on the project, whether
+           its bridge answers, the queue and uv. install adds com.coplaydev.unity-mcp#v10.3.0 to
+           Packages/manifest.json — one line, nothing else, printed — and remove takes it out; both
+           refuse while the queue holds the project or a Unity has it open.
+           \`unity editor <action>\`: console [--since n|last] [--count 50], compile, play, stop, shot
+           [--game|--scene] [--out file], menu "<path>", call <Namespace.Class.Method>, hierarchy
+           [--depth 3], add <cube|sphere|capsule|cylinder|plane|quad> [--name] [--at x,y,z], save,
+           open, close [--force]. With an Editor on the project whose bridge answers, it goes through
+           the pinned server over stdio (uvx), routed by set_active_instance to that Editor's exact
+           instance id and checked by its project root before any call — never another Editor. With
+           none: compile, call and menu (a [MenuItem] in the project's own scripts) run as a queued
+           batch job, console reads the newest funtools log, each said as a fallback; play, stop,
+           shot, hierarchy, add and save need an Editor: --open opens one with the bridge on stdio
+           for that session (through the queue; pid recorded), --wait seconds for its bridge (300).
+           close ends only an Editor funtools opened (its recorded pid, checked as that Editor).
+           An Editor someone else opened is never quit, relaunched or closed.
+           exit (editor) 0 done · 1 failed · 2 not observed (needs an Editor) · 3 refused or error
+  spec     the big tier of the plan, as a folder the game loads (design/spec/). \`spec init\` (a game
+           past the small tier, or --tier mid|deep; a Unity game gets the folder alone, shaped for
+           its Unity project to load, and never the web files) writes the README build contract,
+           tunables.json with every named number the code holds (src/tune.ts loads it:
+           tune('group.name'), typed, a missing id throws, hot in dev), rules, rooms and chapters
+           as data (rooms.json, two
+           chapters of three rooms of the starter's round), screens and tutorial, difficulty, and at
+           deep the rooms in words, cast, story, audio and juice; scaffold files still as written
+           are rewired to read the numbers. \`spec lint\` holds it against itself and the code:
+           sections the tier needs, unknown and unused ids, a tunable's number typed into src/,
+           rooms without a par or an exit, the pars against the play floor, a room changed before
+           it was opened; records .funtools/spec.json (the GDD stage's gate past the small tier)
+           exit 0 written / clean · 1 lint warnings · 2 nothing to do · 3 error
+  rooms    every room of design/spec/rooms.json played in order by bots over 5 seeds (test/rooms.ts
+           on src/probe-rooms.ts; a lost round retries from the room's door): a careful player at
+           a human rate clears each on every seed within 50% of its par, the sharp bot too, the
+           naive and novice players' falls room by room, the pars against the play floor; records
+           .funtools/rooms.json (the expand stage's gate). \`rooms open <room>\` is slice first: it
+           opens a room for building only once every room before it is open and the one before
+           passes (the slice's core test and slice stage too); the owner alone releases one early
+           (--by owner, their words kept). \`rooms plan\` records the rooms as planned now (a room
+           changed before it was opened was built early): free until the owner agrees the plan
+           exit 0 every room passes / opened · 1 a room fails / refused · 2 nothing to play · 3 error
+  depth    the experience evidence stills cannot give, free: the content inventory (what the
+           design declares, what the game ships, what real play reached), the pacing timeline of
+           the longest real sessions (blind rounds and journeys on game time: beats, places and
+           firsts a minute, the longest flat stretch, tension peaks and releases when the state
+           names one), the blind player's come-back answer, the design's experience dimensions,
+           the bots' skill spread. Facts X1… for the experience seats, text.md (every sentence a
+           player can read), a beat strip; in .funtools/depth/ (--out elsewhere). The story's
+           ## Story beats against the beats real play showed (__FPX_STATE__.beat; "Story:
+           declined" is a choice) and each content-list row against what play reached; --fill
+           writes them into the design document's Reached in play / Seen in play cells. A mirror
+           exit 0 measured · 3 error
+  reach    can the player get there, free and local, no browser: each level kept as data (a tile
+           grid, side or top view, or the build_level 3D spec; funpixel.json "reach" names them,
+           else design/level.json and design/levels/) is filled from its spawn, and every exit,
+           pickup, checkpoint or room nothing reaches is named with the gap in the way: wider or
+           higher than the game's own jump (reach.movement: numbers or rule constants), or a wall
+           with no way through. Sealed pockets are warned. Records .funtools/reach.json
+           exit 0 all reached · 1 one cannot be · 2 not observed (no level data, no spawn, a side
+           view with no movement declared) · 3 error
+  world    a seeded world as data the game loads, free and local: \`forge\` writes
+           design/world/world.json — chapters of rooms joined by doors, a critical path from the
+           arrival room to the goal room, side rooms, loops and a secret; each room a top-down tile
+           grid (2D: wall, floor, hazard, arrival, goal, pickup, door) or a heightfield in its own
+           file plus placed props (3D), named places (arrival, goal, reward, vista, landmark), a light
+           and fog of its own over the world's, and a budget estimate. Props are the game's own kinds
+           (GDD **Kit:** line, or "props" in a JSON brief) or neutral roles (cover, landmark, light,
+           dressing, marker); chapter names and landmarks come from ## Places. The same seed and
+           brief give the same bytes; the grammar itself is drawn per seed. A file changed by hand is
+           kept unless --force. --variety N forges N seeds in memory and scores how far apart they
+           are (shapes, layouts, grammar, light, graph), naming near-twins. \`check\` validates it:
+           ids, every door on both sides, each room's doors, goal and places reached from its
+           arrival (3D: a rise of at most movement.step between cells, solid props closed), every
+           room reached through the graph, budgets. The loader: src/world.ts
+           exit forge 0 written · 3 error; check 0 pass (warnings too) · 1 fail · 2 no world.json · 3 error
+  feel     the verbs, tells, deaths and poses as a player meets them: a script plays the real
+           controls on the built game (test/feel.json: journey steps plus \`until field=value\` and
+           \`retry <step>\`; or --journey <name>) while every frame's __FPX_STATE__ is traced. Reads
+           the design's numbers (design/GDD.md "## The numbers", the script's "expect") back with
+           the gap: jump height, time in the air, apex hang, top speed and time to it, dash
+           distance and time, invulnerable window, cooldown; tell to strike and the defensive
+           verb's safe window; the death beat and death to control again; each actor's look in
+           each of its states. With "sweeps" in the script, coyote time and the jump buffer from
+           timed attempts across runs (a fresh load each; --no-sweep skips). Times are on the
+           game's clock when __FPX_STATE__ gives t (seconds), else the page's. A mirror: notes
+           never fail it; records .funtools/feel.json
+           exit 0 measured · 2 nothing measured (no script, no state) · 3 error
+  gdd      the GDD lint and design reads for design/GDD.md (else design/README.md), no score
+           (completeness is not quality): the invention's six answers (answered or generic; an
+           answer is its label's line and the sub-bullets under it), hits per axis with sources,
+           named behaviour tests (and how many the test files hold), the studio pitch's locked core, then the sections missing or thin; records
+           .funtools/gdd.json with the document's sha256 and lists the live decisions of
+           design/decisions.md; \`gdd page\` writes design/GDD.html (the document as a page to read and rate; the
+           open questions as owner-decision rows under the board) and design/first-look/index.html.
+           Then the design measures, advice with a number and why each, "not given" when the GDD has no
+           field for one: elements per hour of first playthrough (warns above about 4; peers 1.4–3), the
+           spine (a system serving no clause), sources (a marked claim with no source line; --sources
+           lists every one), peers (length and elements per hour, else unknown), length totals (the
+           parts' minutes against the stated length) and the Steam two-hour check (the hook inside the
+           refund window). --strict makes a measure's warn exit 1 (a CI's choice)
+           exit 0 read · 1 a measure warns under --strict · 2 no document (or no first-look folder) · 3 error
+  greenlight  the plan's lock and its worth read: \`lock --version v1.0\` pins the design, the bible and
+           the target frames (\`flow agree --by owner\` runs it); \`page\` writes design/greenlight.html (pitches, bible, decisions, lock); \`worth\`
+           sets the plan's own minutes against the owner's target and the genre's best, one verdict, a
+           scope question to the owner when it does not fit; .funtools/worth.json
+           exit 0 locked or met · 1 held · 2 not observed · 3 error
+  verify   run the game probe locally and write verify.json
+           exit 0 pass · 1 fail · 2 not observed · 3 error
+           --front-door presses the title's real start control ([data-fpx-start], or
+           --click's selector) instead of entering play through the hooks; a missing or
+           dead button fails
+           --players 2: two tabs in one room on a local relay — the host acts and the
+           guest must see it, a late joiner gets the state, the room survives the host
+           leaving (needs the funpixel-relay binary and a Redis)
+           --engine webkit (also capture, play, journey, feel) runs Playwright's WebKit,
+           Safari's engine without Safari's UI, for a bug only Safari shows; recorded in
+           .funtools/verify/webkit.json, never verify.json (publish reads Chromium's).
+           Optional: npx playwright install webkit (doctor says so)
+  capture  one PNG of a named view: entered through __FPX_VIEWS__, --verbs pressed in
+           order, held --hold ms (600) and frozen for the shot (default
+           .funtools/capture/<view>-<viewport>.png); no --view shoots the page as loaded.
+           A signature moment (a view declared moment: true) plays instead: a burst of
+           --burst frames (12, ~1.8 s) into <out>.burst/, and the frame showing its
+           __FPX_MOMENT__ mark is the shot. A phone is touch, with the Studio's touch
+           emulation (?funpixel_touch=1); --safari shrinks it to the page Mobile Safari's bars
+           leave (390x684 upright, 724x283 sideways; <view>-phone-safari.png), where a
+           height-sized play is narrower than the 390x844 frame shows. --all shoots every declared view at both sizes,
+           each to its default path: the set the critic panel and the GDK's Stop gate read.
+           Repeatable (8 Oct): the page's clock is held from before the game's first line and
+           moved in fixed 1/60 s frames from seed 1 (--seed n; window.__FPX_SEED__, Math.random),
+           with no game time passing while the page waits on the network, a decode or a resize,
+           so two captures of a view are the same frame. Each shot says how it was framed (held
+           clock, seed, frames, the named camera from __FPX_CAMERA__) or that it ran free
+           (--free-running: the wall clock, as before), in --json and .funtools/capture/index.json
+           exit 0 shot · 2 the view was not entered · 3 error
+  compare  before and after on the same views: --baseline keeps the current captures (capture
+           --all) as the before; after the change and a fresh capture --all, compare writes
+           each view's before | after sheet to .funtools/compare/ and names the views that
+           did not change, and each pair not framed alike (free-running, another seed, game time
+           or camera) as not comparable frame for frame; exit 0 compared · 2 nothing to compare · 3 error
+           --target: the game today beside the frame it aims at, at fixed framings (a phone held
+           sideways 852x393, desktop 1280x720; --viewport, default both), one strip per view and
+           size, "today | target", to design/look/<view>-<viewport>.png (--out: a folder, or one
+           file for one strip). One picture serves every --view; or one picture per view, in
+           order. The target is shown whole (--fit cover fills and crops). Read the strip for
+           mood, light, the hero's size and life. Today's frame is held like capture's (--seed,
+           --free-running); exit 0 made · 2 a view not entered · 3 error
+  parts    cut a generated sheet into pieces: a character into parts or poses, an item sheet
+           into items. Background keyed (--key auto: the sheet's alpha, else its flat corner
+           colour flooded in from the edges), each piece trimmed with --pad px, written as a
+           transparent <name>.png (--webp adds lossless WebP) plus parts.json (box on the sheet,
+           size, pivot: bottom-centre for poses, --pivot top for limbs). Pieces: --grid CxR, a
+           --boxes file ([{name, x, y, w, h}]), or every separate figure (bits within --merge px
+           join); --names in reading order. Default out: <sheet>-parts/ beside the sheet.
+           Warns on a background that will not key, a piece cut by the edge, names that do
+           not match; exit 0 written · 2 nothing found · 3 error. --key paper keys a painted
+           sheet's paper (colour and grain from the whole border, patches between legs too);
+           --clean runs cut's clean pass on every piece
+  cut      parts with a painted sheet's defaults: figures off a cream or plain reference sheet
+           (or a generated --transparent image) as clean sprites, local and free. The paper is
+           keyed; then per piece: painted ground shadows under the feet go (--keep-shadows keeps
+           them), the soft halo goes (alpha thresholded, a 1 px soft rim), the rim takes its
+           colour from the inside (no paper bleed), stray islands go, and lines ruled across the
+           sheet (a generator's cell grid) go first. Each piece says what was removed; parts.json
+           carries the counts. Default out: <sheet>-cut/ beside the sheet. Exit as parts
+  audit-screens  layout on every declared view (or --views): text under 12 px, hit areas
+           under 44 px, HUD pieces over each other, anything cut by the screen edge or
+           inside a phone's safe area; developer copy on screen ("will be here", TODO,
+           lorem, NaN) is a warning beside the verdict
+           exit 0 pass · 1 fail · 2 not observed · 3 error
+           A phone is held the way funpixel.json's orientation says; --orientation turns it
+           (the other way a player can hold it; export audits both) for capture,
+           audit-screens, scene and play: a portrait game held sideways is 844x390,
+           shot to <view>-phone-landscape.png, never counted as the game's phone shot
+  scene    the engine's scene graph (Three, Pixi, Phaser) read in the page: nodes, depth,
+           what is switched off or outside the view, textures and a draw-call estimate
+           exit 0 read · 2 no scene graph found · 3 error
+           --motion samples ~1 s of play: each actor (funpixel.json "actors" player, threats,
+           pickups, else the usual names), judged against the Motion column of the design
+           note's ## Actors table (moves · animates · still); recorded in .funtools/scene/motion.json
+           exit 0 every declared mover moved · 1 one stood still or never changed · 2 not observed
+  hook     the hook moment: the title, the real Play, then the first minutes of play (--seconds,
+           default 180) read at checkpoints: what moves besides the player, how much of each frame
+           is flat colour (empty), whether the picture changes, stand-ins the game still names
+           (__FPX_STATE__().art.placeholders). A light player taps the middle every 3 s (cards
+           between Play and the world are passed); --verbs presses verbs in turn instead, --idle none.
+           Frames in .funtools/hook/, record .funtools/hook.json. Warns, never fails
+           exit 0 measured · 2 not observed · 3 error
+  life     is the world alive around the player? ~3 s of the play view (--view, else the view
+           marked motion): the pieces that move or change besides the player (crowds of
+           instances, particles, lights), whether a looping sound bed started, and for each big
+           moment (views marked moment, or --moment) whether anything answered its __FPX_MOMENT__
+           mark (a sting, a crowd, pieces or lights) against play before it. The front door
+           ([data-fpx-start]) is pressed first, since sound starts on a gesture. Warns, never fails;
+           records .funtools/life.json (funpixel-world-and-story, references/atmosphere.md).
+           Motion is not animation: people and creatures are judged animated (frames, bones,
+           morphs or parts change), SLIDES LIKE A STONE (travel with nothing inside changing),
+           RIGID (bob or turn as one picture) or STILL; no idle and reactions near the player
+           are counted (@funpixel/verify life_anim.js). Travel is watched ~10 s and labelled so;
+           walk.json, when walk ran, decides it. A moment that fires every cue at once (a jump
+           through the payoff) is flagged, not counted as an answer
+           exit 0 measured · 2 not observed (no scene graph and no sound log) · 3 error
+  walk     verify the world by playing it: every route in funpixel.json walk.routes (else one
+           explore walk) from the TITLE with real keys and clicks, held and steered in real time
+           (no view jumps, no verbs), filmed from the play camera (.funtools/walk/<route>.webm,
+           MediaRecorder on the canvas). Each tick reads the actors contract (__FPX_ACTORS__,
+           HOOKS.md "Actors") and warns on CLIPPING (bodies through props, walls, each other),
+           PLACEMENT, FLOATING, SCALE (funpixel.json "scale" in metres; "framing" share of the
+           frame), STALLS (presses that change nothing: blocked or a dead end), NO CHALLENGE (no
+           stumble, detection, timer or failure fired) and life (slides like a stone, no idle,
+           no reaction; a crowd that never travels; the hero's face on a crowd; flyers without a
+           flap), LOSS (a run that ends failed, then the game's retry; penalties alone are not a
+           loss). A route's "then" (or --chain a,b) walks legs in one page and one film from the
+           title (a prologue, then Run 01; a chained leg skips its start steps and plays its
+           "continue" steps); framing warns when over 15% of the time is outside the band;
+           steer.waypoints (or a path in the state) steers by position when there is no
+           lateral field; a leg that arrives in under 3 s is not observed. CROWD: clumps
+           (people within 1.5 m with no shared scene: tagged, or inferred when they face each
+           other or move together), empty stretches of the path, the count against
+           walk.crowd.people. Every 4 s the world itself: BOXES (big meshes that read unfinished,
+           the worst frame kept as <route>-boxes.png; BOX FIGURES) and OFF THE GROUND (big props
+           and vehicles hovering, over a drop or sunk), as funtools boxes reads one view. The
+           contract: skill funpixel-verify,
+           references/actors.md. Records .funtools/walk.json. Warns, never fails
+           exit 0 walked · 2 not observed (no route reached play, or nothing to read) · 3 error
+  score    how close a moment is to its target picture, 0-100 on six axes (composition, hero,
+           identity, palette and light, density, life) at compare --target's framing: measured
+           numbers (palette ΔE, layout and edge similarity, detail share, the hero's height share
+           from the actors contract against the target's hero_share, motion over 3 s) plus a blind
+           vision judge when OPENROUTER_API_KEY is set (else "not observed"). A loading or splash
+           frame is never counted. Every moment in funpixel.json "moments" without --target; the bar
+           is "accuracy_min" (default 75, the owner's; "accuracy_stretch" 90 kept). Every moment
+           also gets its FIX LIST: the camera the game runs (read in the page: __FPX_CAMERA__, the
+           three.js camera or the pixi world) and the numbers that would lay the capture over the
+           target ("SHOTS.play.height 4.4 → 6.1, fov 50 → 41"), the light (exposure ×k), colours
+           by hex and bare regions to dress. Writes design/look/scores.json and one line per run
+           to design/look/score-history.jsonl; \`--fixes\` prints the last run's list without a
+           browser. The flow's rounds work down it. The moment is shot on capture's held clock
+           (--seed, --free-running), so a round's score before and after a change reads one frame
+           and says how it was framed. Warns below the bar. Beside the axes, EYE COMFORT (never in
+           the score): each frame's busyness (the mean brightness step between neighbouring pixels,
+           on a grey copy 360 px on its short side) and clipped share (luma <= 2 or >= 253) against
+           its targets'; a frame over 14, over 1.25x its targets' busiest, or over 6% clipped warns
+           (match the targets' quality, not their density) and is stamped on zero's comfort counter
+           exit 0 scored · 2 nothing scored · 3 error
+  framing  where each actor lands on screen at the target framing: its box, its height share
+           and whether it is in view, against funpixel.json "framing" ({ "ren": [0.16, 0.22] }),
+           so a camera is tuned without rebuild-and-shoot rounds
+           exit 0 read · 2 none of the actors found · 3 error
+  boxes    is the world made, or boxes? Each play view (or --view a,b) is held and its frame
+           rastered from the play camera beside a screenshot (@funpixel/verify surfaces.js): big
+           meshes that read as unfinished (flat colour on big triangles, few vertices for their
+           size, no texture) are named, ranked by area and nearness, beside the most detailed
+           structure in the frame (terrain and rock in a faceted style lock are the look, not
+           boxes); people and creatures built of a handful of boxes are named at any size (BOX
+           FIGURES); the big props and vehicles are read against the nearest surface under where
+           they touch down, terrain or a support (a deck, a pad, what people stand on; grounding.js:
+           hovering, over a drop, sunk). walk does both along its
+           routes. The dressing round the player is counted per 100 m² against the place's
+           target (state.world.dressing.target), the road kept clear, the phone's frame budget
+           (DRESSING: BARE, ROAD CLUTTERED, OVER THE PHONE BUDGET; dressing.js).
+           Writes .funtools/boxes.json and .funtools/boxes/<view>.png. Warns, never fails
+           exit 0 read · 2 not observed (no Three scene) · 3 error
+  places   are the places distinct in play (the Silt bar's S8: ≥ 3)? Each place-<id> view (or
+           --view a,b) is entered and shot; each pair compared in colour (ΔE over a 4 × 4 grid)
+           and layout (variety's limits) and in the light the game says it runs there
+           (state.world.light: preset, exposure, key, fill). Alike in colour and light = one
+           place repainted. Writes .funtools/places.json and .funtools/places/<view>.png. Warns
+           exit 0 read · 2 not observed (under two place views) · 3 error
+  compare-takes  two takes of one game (two parallel builds of the same plan), each played from
+           the title with walk (its routes, filmed) and scored against its targets with score
+           when funpixel.json names moments; a best-of-both table per area (environment,
+           dynamics, challenge, accuracy, each moment: which take is ahead and what the mix
+           keeps) and a contact sheet (walk frames, frames from the films with ffmpeg, each
+           moment beside its target). Writes <out>/takes.json, takes.md, sheet.png (default
+           .funtools/takes). A mirror for choosing, never a verdict
+           exit 0 compared · 2 nothing measured · 3 error
+  profile  the numbers behind a frame, per view (default: the gameplay views): frame time
+           p50/p95/p99/max and long frames after a warm-up, draw calls and triangles counted at
+           the WebGL calls, the scene by kind (Three meshes/instances/lights/shadows, Pixi
+           sprites/graphics/text/particles/filters), texture memory estimated, JS heap, what
+           the page fetched, dist/ size by kind. Saved to .funtools/profile/<view>-<viewport>.json;
+           the next run of the same view and viewport prints the change (--against another
+           file). --seed sets window.__FPX_SEED__ before the game runs. --software renders on
+           the CPU (SwiftShader), where fill costs a desktop GPU hides behind vsync show as frame
+           time; --throttle N slows the page's CPU N times, a stand-in for a phone's JS speed.
+           --repeat N samples each view N times and reports the median and the p95 range (a busy
+           machine moves single runs a lot). Reports, never judges: neither is a phone, so
+           compare runs made the same way. --compare reads the run the way the Studio's profiler
+           reads a build against the last one (its percentiles, frame-time buckets, burn rate
+           and neutral band): every frame kept, frames over the budget (--budget, default the
+           profiler's 18 ms) as a burn rate against a 1% allowance, GPU time a frame when the
+           browser offers the timer query (else said, never guessed), stored per view in
+           .funtools/profile/history/ and compared only with the last run made the same way
+           (seed, viewport, throttle, renderer, frames, budget) — "frame p95 16.9 → 20.9 ms (+4.0
+           ms, +24%) regression · draw calls 12 → 72 (+60) regression · burn 0.4× → 5.2×"
+           exit 0 measured · 2 nothing measured · 3 error
+  inspect  what is on screen, asked the way a person clicks in the Studio: the platform's
+           inspector in the game's own dev server (as \`dev\` mounts it; --url looks at a running
+           \`funtools dev\` instead). --at x,y (CSS px, or 50%,80%) names what is there, HUD first,
+           then engine objects topmost first; --name finds objects by label or name; --tree prints
+           the scene. Each comes with its state (position, scale, alpha, shown or hidden, its box on
+           screen, Three userData) and the source file:line that created it, through the source
+           maps. Every runtime error so far is listed at its source line, with __FPX_STATE__().
+           Never pauses or selects; reports, never judges
+           exit 0 answered · 2 not observed (no inspector, no scene, nothing there) · 3 error
+  clip     clip critics: how the game FEELS, from strips of consecutive frames of play (what
+           stills cannot show). Cuts 12-frame 4 × 3 strips from a reel's frames (default
+           .funtools/reel/frames: \`reel --frames-only\` first; its payoff marks centre a strip each)
+           into .funtools/clip/<n>/ and writes one prompt per seat (player, animator: feel, juice,
+           motion, clarity) for your own agent to run; funtools calls no model. \`clip report\`
+           reads the answers back. Separate words (panel/clip.md) from the calibrated still panel
+           exit 0 ready or reported · 2 no frames or nothing filed · 3 error
+  judge    two checks on generated art that an aesthetic score cannot make, each one seat for your
+           own agent (funtools calls no model; one seat reads the pictures once). structure: fixed
+           yes/no questions with evidence (matched pairs, part counts, attachment, lettering, the
+           frame); any no fails, never averaged into a score. identity: a model's rendered views
+           (.funtools/renders/<name>/ from \`model render\`; nothing is rendered here) or a sprite set
+           against the concept it came from (--concept, else the asset manifest's \`from\`), per
+           trait (silhouette, palette, features, proportions) with the worst view; major drift
+           fails, minor warns. \`judge report\` reads the answer back; an answer about a picture
+           that changed since is not counted
+           exit (prepare) 0 ready · 2 no picture/concept/views · 3 error;
+           (report) 0 pass · 1 fail · 2 not observed (nothing filed, unanswered, stale) · 3 error
+  phone    the game in real iPhone Safari (WebKit) through baguette's headless iOS Simulator
+           (optional: Apple Silicon + Xcode 26 + \`brew install baguette\`; never installed for you):
+           boots an iPhone (--sim), opens the built game in Mobile Safari, closes Safari's first-run
+           tip, finds the controls through the accessibility tree (sizes; under 44 pt said), taps the
+           start control by name, plays --seconds (--taps presses points, --swipes swipes the play in portrait
+           and says which __FPX_STATE__ fields each changed), screenshots each step to
+           .funtools/phone/<time>/, and reads the page's own frame intervals, errors, __FPX_STATE__
+           and safe-area insets (a folder is served with a reporter; a URL is only looked at). Shuts
+           the simulator down after (--keep leaves one it booted running). --orientation landscape
+           plays too (taps mapped; screenshots turned upright). WebKit's pacing on the Mac,
+           not the phone's speed; one simulator at a time
+           exit 0 observed · 2 not observed (no baguette, not a Mac, no iPhone simulator) · 3 error
+  look     --read: can a player tell themselves and the threats from the ground? The play
+           view (\`playing\` when declared) frozen, the player and threat boxes read from
+           the engine's scene (names matched by funpixel.json "actors", or --player and
+           --threats), each measured against the ring of ground around it: ΔE of the
+           figure to its ground, the bar the three bar games all pass. With no boxes, the
+           style file's role colours (assets/style.json roles hero, harm) or --colours;
+           a PNG on disk is read by colour only
+           exit 0 pass · 1 an actor merges with its ground · 2 nothing measured · 3 error
+           --hud: the HUD while the game plays (default phone): the play view and each
+           moment view sampled --samples times, --every ms apart; cover of the play area,
+           text size, contrast against the pixels behind each text, HUD over the player
+           or a threat, transient pieces piling up; warnings for a worded message over
+           the middle of the play, a text gone before it can be read (0.8 s, ~0.3 s a
+           word) and developer copy on screen ("will be here", TODO, NaN). The worst
+           sample is saved with the HUD outlined (.funtools/look/hud-<view>-<viewport>.png)
+           exit 0 nothing found · 1 a finding · 2 nothing measured · 3 error
+           --fit: does it fill the windows people give it? 1700x800, 1280x600, 1024x1024 and
+           the phone sideways and upright, each opened fresh: how long it stays one flat
+           colour (over 3 s is a finding), then the play view's share of the window, flat
+           bars at the edges, content bunched in a corner (.funtools/look/fit-<window>.png)
+           exit 0 every window filled · 1 a finding · 2 nothing observed · 3 error
+           --sheet: the roster at play size before the game exists: every PNG sprite
+           (public/assets/sprites, or --sprites) trimmed, at each --sizes height on a
+           neutral band and on the ground (--ground, else assets/style.json roles.ground),
+           each measured by --read's ΔE; no build needed (.funtools/look/sheet.png).
+           An animation sheet (sheet.json names animations) has each cycle measured:
+           distinct poses, and a loop's seam (last → first) against its median step
+           exit 0 every sprite reads, no cycle pops or freezes · 1 one merges, pops or
+           freezes · 2 no sprite · 3 error
+           --3d: what a Three.js game's hero objects are made of. The source the entry
+           point reaches: files that build the player, rivals and enemies (primitive
+           constructors by kind, hand-built buffers, a model loaded) and the models under
+           public/. With a build and a browser (not --static), the running play view adds
+           each hero node's meshes, triangles and screen share. Code-built heroes pass only
+           as a declared style: funpixel.json "art3d" { "heroes": "procedural", "why",
+           "proof": "<frame>" }; stand-ins are named in "art3d.stand_ins"
+           (.funtools/look/3d.json)
+           exit 0 models, or a declared and proven style · 1 heroes are code · 2 not
+           observed · 3 error
+           set|patch|report: the HUD and screen look as one value, src/look.json (the UI role
+           tokens styles.css reads: bg, ink, plate, plate-ink, accent, font-display …; the
+           starter's src/look.ts applies it at load). set token=value and patch file.json
+           (a merge patch: null removes a token) validate the merged whole and refuse to write
+           on a problem, with the closest token names; every write and report prints the
+           contrast of each text/background pair and, for one that fails, the ink that passes
+           (a proposal: run the printed \`look set\`). report reads the file as the game does
+           (.funtools/look/report.json)
+           exit 0 written / clean · 1 refused, or tokens the game would drop · 2 no look · 3 error
+  play     the blind player's hands and eyes: a round keeps one page of the built game open;
+           \`act\` plays a batch of steps (up to 20) as a person would and saves the screen once,
+           after the batch (tap X Y · drag X1 Y1 X2 Y2 [ms] · hold X Y ms · hold KEY ms · press
+           KEY [n] · wait ms · look DX DY [ms] · view NAME · verb NAME · shot; 0.5 is a fraction of
+           the screen, 200 a pixel; up/down/left/right are the arrows; a phone takes touch only;
+           "A & B" is one gesture, two thumbs at once). \`hold KEY|X Y until COND [max N]\` and
+           \`wait until COND [max N]\` let the game run in real time until a field of
+           __FPX_STATE__ says so (screen!=playing, x>120, score>=3) or the screen (\`change\`, or
+           \`change X1 Y1 X2 Y2\` for a box) visibly changes, 10 s by default, 30 s at most; the act
+           says whether and when, and the log keeps how long it ran. \`look DX DY\` moves the
+           mouse with no button down (camera look, under pointer lock too, which play grants as a
+           browser does; a drag clicks). \`play look\` (or \`act --look\`) hands back a small frame
+           (NNN-look.jpg) and the state as one line, no game time passing, no step spent. A
+           helper script the player writes belongs in its round's folder: a command run from one
+           elsewhere under the game, or in a temp folder, is refused. The
+           game's clock is held between acts; \`report\` files the player's report (start,
+           goal, act, end, confusions, each funpixel.json criterion, top 3 defects) with each
+           defect's exact repro from the round's log, and closes the round; \`check\` names
+           each field a draft gets wrong (defects[0].step: got "9a"; expected …) without
+           filing; a refused report is kept as written in round-N/report-unfiled.json, and a
+           round that went idle still takes its report. Each round has its own session in
+           .funtools/play/round-N/ (two may be open at once, a blind pair in one folder or
+           two): later commands find it in --dir, else the game folder at or above the
+           current one, and --round N (printed at open) names it when two are open there.
+           The player never reads the source. At most --rounds (3) rounds, then the panel.
+           --long N: a long session of about N minutes of game time (a bigger step budget),
+           ending with the come-back question: "would you come back tomorrow, and why?"
+           exit: report 0 a new player gets through · 1 blocked · 3 error; check 0 would file · 3 not
+  journey  a player's path from the visible start through the real controls, kept as a script
+           (test/journeys/<name>.json: play's steps without view/verb jumps, plus
+           \`mark NAME field=value score>0 …\` checkpoints) and replayed on the same seed
+           (window.__FPX_SEED__) and viewport: at each mark the clock is held, the frame kept
+           and __FPX_STATE__ read into counters and judged. \`record\` opens a window you
+           play in (your taps, drags and keys become the steps; each screen reached becomes a
+           mark); \`from-play\` takes a blind player's round; \`replay\` sets the run beside the
+           last one (--repeat 2: two runs of one build, the noise); \`diff\` any two runs.
+           Kept apart from __FPX_VIEWS__, the diagnostic scenes: a scene reproduces a state, a
+           journey shows a player can reach it. Runs in .funtools/journeys/<name>/<n>/
+           replay exit 0 every expectation held · 1 a step or one failed · 2 nothing judged · 3 error
+  playtest the creator's mirror between rounds: builds, verifies, captures every view at both
+           sizes (moments as strips), audits the phone screens, judges the HUD in play and
+           profiles, all free; then writes one prompt per seat for your own agent (the
+           calibrated critic panel, 3 seats or 2 with --quick, each re-reading its axes on the
+           phone captures; a blind phone player round; a
+           head to head against the genre hit when its evidence is on this machine, never
+           shipped: --versus <dir> or FUNPIXEL_HITS_DIR/<slug>/). \`report\` ranks 3–4 next
+           steps, each with a quote, a frame and a number, and sets this playtest beside the
+           last (.funtools/playtest/<n>/report.md). --hosted runs the seats as Tools API jobs
+           (review, play) for credits, quoted first. Beside the craft panel: a plan-fidelity seat
+           (the GDD's target frames beside the game's frames of the same moments) and, after the
+           blind round (a long session, --long 10 by default, 0 for a short one), \`experience\`
+           measures depth and writes the experience seats (depth, content, replay, story, world,
+           arc, originality). A Mobile QA seat judges whether it is native to a phone (--phone
+           runs \`phone\` first, so it sees real Mobile Safari). Nothing is ever applied to the game
+           The panel informs and never gates: \`report --min-score 6.5\` exits 1 under the number
+           you ask for, and funpixel.json owner_gates.panel_min makes it the owner's hold.
+           \`report\` also keeps the do-not-regress list (.funtools/keep.json): up to eight things
+           the panel named as working; the next ledger seat judges each held, lost or not
+           observed, and a lost one is a regression: the report leads with it and exits 1, and
+           the panel stage fails. \`keep\` lists it; only the owner drops an item (--drop K<n> --by owner)
+  mobile-qa is the game native to a phone? One seat for your own agent, judged from phone
+           evidence: real Mobile Safari (the latest \`phone\` runs; --phone makes them), a WebKit
+           phone shot, the Chromium phone frames, audit-screens and look --hud at phone size, key
+           parity at phone size and the blind phone round. It judges touch-native controls (a
+           button that repeats the play area's gesture, never needed controls), the play area's
+           share of the screen, thumb reach, tap targets, chrome during play, safe areas,
+           orientation, readability and first touch; high/medium/low with a frame and a number.
+           \`report\` ranks the answer. Runs in .funtools/mobile-qa/<n>/; playtest runs the same
+           seat. Declare "platform": "phone" in funpixel.json metadata when the phone is primary
+           (a key with no touch route is then high); "desktop" opts out. Advisory
+           exit 0 prepared/reported · 1 build failed · 2 not a phone game · 3 error
+           exit 0 prepared or reported · 1 the build failed · 3 error
+  lessons  settled findings by genre: after a fix round, \`add\` records what the panel or the
+           player named and what fixed it (in .funtools/lessons.jsonl; --share also in
+           ~/.funpixel/lessons/ for the next game of the genre on this machine); with no
+           \`add\`, the best for the game's genre (the GDK's session start shows the top three)
+           and the motifs of the last five other games. \`motif\` records this game's
+           look (title, palette roles, motif nouns of the design note) in
+           ~/.funpixel/lessons/motifs.jsonl, so the next game avoids it
+  variety  is this game too close to the other games on this machine (the ones in
+           ~/.funpixel/lessons/motifs.jsonl)? Five signals, each three-state: palette distance
+           (ΔE), the same core verb family in the same genre, a near-identical title screen
+           (edge layout of the latest title capture, so one template in new colours still
+           counts), shared motif nouns, a shared title word, the same signature wow expressed
+           alike (the GDD's ## Wow). Other folders of this same game
+           are skipped. Records this game's verb and title layout for the next one. A mirror:
+           the creator decides what to change. --within compares this game's own place
+           pictures (design/first-look/place-*, or those ## Places names) with each other:
+           colour and shape per pair, so six places that read as one room repainted warn
+           exit 0 nothing too close · 1 something is · 2 nothing to compare · 3 error
+           (--within: 0 compared · 2 under two pictures)
+  wow      the genre card's wow catalogue: hit-proven moves in four families (signature, juice,
+           feel, presentation), each with the hit, what to build (numbers where a source gives
+           them) and its check (a probe event the game marks with __FPX_MOMENT__, or a frame of
+           a view). \`wow pick\` records the game's choice in the GDD's ## Wow (one signature, up
+           to three more, each with its expression: what this game makes of the move) and flags
+           a signature another game on this machine already used, expressed alike. \`wow check\`
+           reads each pick's evidence: the event in the last hook read, the view's score
+           exit 0 listed / picked / all seen · 1 a pick's evidence missing · 2 not observed · 3 error
+  pitch    the studio pitch: pitch → pick → lock → go hard. Cards (genre and fidelity, depth, the
+           core that burns, story standard, extras with their cost) in design/studio.json;
+           \`propose\` sets the agent's pick with its reason for this game (a new option joins the
+           card with --label/--picture/--cost), \`ask\` puts each card the owner has not settled to
+           them (a taste, spend or scope question in the chat), \`pick\` records a pick (--by owner
+           is the owner's), \`lock\` writes the picks to funpixel.json "studio" (and
+           production.tier from the depth) and the GDD's ## The studio pitch, and exits 1 while a
+           card waits for the owner (unless the owner set autonomy go); \`gdd\` and the
+           session start then read the locked core. Autonomy is never a card: the owner's
+           funpixel.json flow.autonomy. No subcommand: the cards and what the
+           locked layer still asks of the GDD. \`widen\`, before the pick: a seeded, replayable
+           spread (operators × domains × facets, near/middle/far, one labelled wildcard; the seed is
+           printed, --seed replays it) into design/widen.json for the agent to answer; \`widen score\`
+           measures each answer against the generic answer for the brief and what the wow ledgers
+           kept; \`widen keep W2\` records the kept card so the next widen of this brief steers away
+           exit 0 shown or written · 2 no game folder · 3 error
+  loudness every cue against its loudness target with the local ffmpeg (EBU R128): one-shot
+           −16, bed −22, music and voice −18 LUFS ±3, true peak ≤ −1 dBTP, silent takes named.
+           Measures, never changes a file. No paths: the game's sound folders. A bed or
+           music track (what a game loops) also has its join measured: a gap (silence at the
+           ends) or a click (the last sample jumping into the first) warns, and is the zero
+           board's audio seams
+           exit 0 measured · 2 nothing measured (no ffmpeg, no audio) · 3 error
+  beats    each music track's beat map written beside it as <track>.beats.json: tempo,
+           first beat, downbeat, every beat time and how clear the pulse is, from the
+           track itself (WAV read directly, others through ffmpeg); a track with no clear
+           pulse says so instead of inventing one. The starter's src/beat.ts reads it
+           (loadBeats, beatAt, nearestBeat, nextBeat) against sound.ts musicTime()
+           exit 0 written · 2 nothing read · 3 error
+  schema   the whole game held to one shape: funpixel.json (every key a kit command
+           reads, its type and values) and the plan files beside it (src/look.json,
+           assets/assets.json, design/pipeline.json, design/spec/tunables.json, the
+           forged world), each alone and against the others; an unknown key is a
+           warning with the closest name (--strict: an error, what a writer refuses on)
+           exit 0 no errors · 1 errors · 3 error
+  loop     a generated video (gen video, from the accepted sprite) or a folder of frames
+           made into a seamless sprite cycle: sampled at --fps, the --min..--max frame
+           window whose last frame leads back into its first as smoothly as an ordinary
+           step, keyed, every frame cut to one shared box (no jitter), packed as a sheet
+           PNG + spritesheet JSON with the cycle as an animation. Free (ffmpeg for video)
+           exit 0 written (a visible seam warns) · 2 too few frames or no ffmpeg · 3 error
+  directions a model's orbit views (gen render: turn_00.png …) made into an 8-way or 4-way
+           sprite set: angle 0 faces the viewer (S), the rest named going round
+           (--reverse for the other way), keyed off the stage, one shared box, a sheet
+           PNG + JSON with an animation per direction. Repainting each view in the
+           game's style is a paid edit per view: printed, never run
+           exit 0 written · 2 too few views · 3 error
+  board    the first look's reference board (design/board/): search open-licence
+           collections (Openverse, free, no key), wander from a kept picture to related
+           ones, or add your own files and links; every kept picture names the one or
+           two things it lends (palette, shape, light, composition, material, motion,
+           mood, type) and its licence. \`show\` writes board.html and fails when a board
+           picture is copied into public/ or assets/: a reference informs, never ships
+           exit 0 · 1 a board picture would ship · 2 nothing found · 3 error
+  zero     the zero board (design/status.json \`board\`): the loop's counters as the commands
+           that measured them left them, each with its trend over the last runs and what it
+           is made of — errors (verify's failing gates + distinct page errors, verify and
+           capture --all), overlaps (controls cut or covered, HUD over HUD, under the notch:
+           audit-screens per surface, which check runs), seams (looping sprite cycles that pop,
+           look --sheet; looping music and beds that click or gap at the wrap, loudness) and
+           frame time (profile's worst p95 per viewport, against its budget, 18 ms unless
+           --budget); and comfort (score: moments whose frame is too busy or clipped), which
+           warns and never fails. A counter nothing measured is not observed, never 0. Draw, render,
+           check, fix, repeat until it reads zero. Measures nothing itself. Each counter's parts
+           are shown by trade (the game's own; review's video, audio, model, picture)
+           exit 0 every observed counter zero (frame time within budget) · 1 not · 2 nothing observed · 3 error
+  review   the zero board for every trade, not only games: measures media (a film spot, a
+           music single, a podcast, a 3D model, a picture series, a game's assets) with the local
+           ffmpeg and the kit's own readers, stamps each trade's part of errors, overlaps and
+           seams in the project's design/status.json (one with no status gets one holding the
+           board), and prints it. Video: a stream that does not decode, black frames outside the
+           first and last 0.5 s, frozen spans over --freeze (2 s) on a moving cut (--still: a
+           still cut), captions outside the 9:16 / 16:9 / 1:1 safe zone when a .vtt/.srt/
+           .captions.json beside it says where they sit, a loop's last frame into its first
+           (named loop, or --loop), loudness as a note (−14 LUFS web, −23 broadcast). Audio:
+           clipping (true peak over −1 dBTP), silence (a dud, a dropout of 2 s+ inside it), a
+           loop's or bed's join (gap or click), loudness as a note (a game's cue classes, else
+           −14 music, −16 speech; --lufs sets it). 3D (glb/gltf, read here, never the hosted
+           bench): missing or broken textures, open or non-manifold edges (welded by position),
+           NaN positions, triangles over a budget (--triangles, funpixel.json review.triangles,
+           design/specs); Draco/meshopt geometry is not decoded (its edges not observed).
+           Pictures: does not decode, a sprite or cut-out with no alpha (by its name, the asset
+           manifest, a spec, --alpha), a size off its spec (design/specs, --size), off the
+           project's palette (only when it has one), a tile whose edges do not meet. Every
+           counter is three-state: one a file cannot answer is not observed, with why, never
+           0. The project is the nearest folder with design/ or funpixel.json at or above the
+           path (--dir names it); review keeps .funtools/review.json so one file's re-review
+           replaces only its own counts. Folders skip node_modules, dist, build and raw
+           exit 0 every observed counter zero · 1 one is not · 2 nothing observed (no media, no ffmpeg) · 3 error
+  journal  the creator's journal: one line per change a PERSON made (by hand, in the editor, a
+           tuned number), with who and why, in .funtools/journal.jsonl (never ships). The GDK's
+           session start shows the recent ones so the agent keeps them; it also records files
+           that changed while no agent turn ran, marked detected (who and why unknown). Run in
+           an agent's shell the line says via the agent. No text: the entries
+           exit 0 recorded or listed · 2 nothing recorded · 3 error
+  decide   the decisions log: one choice against its alternative, with the reason, as D<n> in
+           design/decisions.md (never ships). --supersedes D3 replaces one and keeps both on
+           the record. The GDK's session start lists the live ones; \`gdd\` reads them. No
+           text: the decisions, live first. --from N3: the owner's note becomes a decision citing
+           their words and screenshot, open until a lane builds it (the briefs that touch it carry it)
+           exit 0 recorded or listed · 2 none yet · 3 error
+  lanes    a stage split into lanes that run at once, each in its own git checkout (branch lane/<id>):
+           \`plan\` proposes them (play, look, feel, audio, env, room-<id>) and writes each brief (scope,
+           what it owns and stays out of, the owner's open decisions that touch it, the evidence that
+           closes it, a $ cap, a time-box, 45-min checkpoints, how to hand back and report); \`start\`
+           makes the checkout and prints the host call (Claude Code: one Agent call per lane). Paid
+           funtools calls in a lane's checkout are logged against it and refused past its cap. \`done\`
+           runs the gate on the lane's commit (synced, owns, tests, sim, the look floor 75 on its
+           frames, funpixel.json lanes.gates commands such as a spec lint, a checkpoint); a seat that
+           did not build it records \`verdict\`; \`merge\` is refused until the gate, the verifier and
+           the owner's picks pass, then merges --no-ff and writes design/MAKING.md
+           exit 0 done · 1 refused · 2 no lanes · 3 error
+  pick     the owner picks by eye between two to four candidate frames, shown in the chat; the choice is recorded
+           with each frame above its button; it never defaults, the lane it names cannot merge until
+           the owner answers, and the choice becomes a decision in design/decisions.md
+           exit 0 done · 1 not the owner's word · 2 no picks · 3 error
+  flow     one entry for the whole run: where it is (planning, the plan put to the owner, round N on a
+           stage), the ONE next step with the exact command, and why, recorded in .funtools/flow.json.
+           \`flow start\` makes the game (init) from the brief (its title, kind and size read from the
+           sentence) and asks nothing. The plan is made with the owner in the chat (the GDD skill);
+           \`flow ask\` puts it to them once with its price (the asset script at list price) and what it
+           still owes, as warnings, never a refusal; \`flow agree --by owner "<their words>"\` locks it and
+           the approved price becomes the budget. Then round after round on the build: the look-dev loop
+           (capture, compare --target, fix the biggest difference, play), a card with a frame of the
+           build, the owner's notes picked up; \`flow round\` closes a round only on that evidence. The
+           GDK's Stop keeps the rounds going up to funpixel.json flow.rounds_per_session (default 3), then
+           hands back ("resume with /fp:flow"). \`flow ask\` and the cards carry the kit's own read (score,
+           panel, blind player, world, first look): "Below the bar: …" first, "Not judged yet" when
+           nothing ran. \`flow drop --by owner\` ends the game: notes close as dropped, \`flow\` names no step.
+           After the first playable and every few rounds (funpixel.json flow.look_every, default 3; 0
+           is off) the step is the whole-game look: \`flow look\` writes its brief for a fresh agent
+           (would you ship this today? each defect a severity and an owner) and, once filed, routes
+           each defect to the lane of its kind, the owner or the round. It never vetoes
+           exit 0 a step · 1 the round lacks evidence (or agree without --by owner) · 2 not a game folder · 3 error
+  owner    the owner's standing bar, carried to every new game: short lines in ~/.funpixel/owner.md (the
+           person's) and an optional <repo>/.funpixel/owner.md (the team's). \`flow start\` (and each
+           \`flow\`) matches it to the game, never blindly: a line that applies becomes an owner note,
+           open until evidence closes it; one that does not is skipped with a reason the owner reads
+           ("creatures: a one-screen word puzzle has no world"); one the kit cannot tell is kept as
+           applying, with why. design/owner-bar.json keeps the match; apply/skip flip a line.
+           seed writes the owner's requests of 4 Oct
+           exit 0 done · 1 nothing matched · 2 no bar yet · 3 error
+  firstlook the first look's required set, the whole game: key art; every screen (title as the play
+           world, pause, the end; past small settings, results, a level select); the HUD on the phone
+           and the desktop; a frame per place tied to a story beat and a living-world sheet (a world
+           game only); an animation board, a juice board, the sound list, the fun page. Scaled by tier
+           and by the game; the first-look gate and \`flow ask\` wait on it; the owner drops an item with
+           skip --by owner. Shown in the chat, grouped. render: the code-drawn route, the studies the
+           game's own draw code composes on design/first-look/draw.html (window.__FPX_FIRSTLOOK__ resolves
+           to { name: PNG data URL }), served by the game's Vite and written to design/first-look/<name>.png
+           exit 0 complete · 1 items missing · 2 not a game folder · 3 error (render: 0 written · 1 none or
+           a refused one · 2 no headless browser · 3 error)
+  note     the owner's notes on the stage they affect, in design/pipeline.json: add (the owner's words,
+           --screenshot as the named before-frame), close with evidence that exists (a file in the
+           game, a commit, a test name in test/; a design note: a commit that changes design/) or
+           on the owner's word (--by owner --force),
+           verdict accept|reject (the owner's: outranks any agent claim; a reject reopens a closed note; on a stage it is that stage's owner gate)
+           exit 0 done · 1 the evidence does not exist · 2 no notes · 3 error
+  progress the run's record, in .funtools/progress.jsonl (read by the next session and the hand-back): a
+           card at each stage move with a frame from the built game (--shot last = the newest capture; a
+           card with no frame or evidence is kept and marked not observed, a design/ picture is marked "a
+           picture, not the build"); a heartbeat when a stage runs long (the third on one gate becomes a
+           stuck card asking skip / cut / keep going); questions only at forks (taste, spend, scope), asked
+           in the chat and answered with \`progress answer\` in the owner's words, with a default that lands
+           after its timeout under autonomy go ("decided without you; reply to reverse"); --spent past the
+           approved budget makes a pause card. Each card picks up the owner's new notes and answers.
+           report is the hand-back from the cards. FUNPIXEL_NOTIFY_URL (ntfy, Slack, Discord) hears only
+           "needs you" and "done"
+           exit 0 done · 2 nothing yet / still open · 3 error
+  feedback what creators said about the kit: \`collect\` reads every .funtools/devlog.jsonl and
+           .funtools/kit-feedback.jsonl under the folders (eval copies of one game count once) and
+           ranks what worked, what hurt and what was missing, by tool, with counts, the games
+           and quotes; lines about the game only are counted, not ranked. Reads, never uploads
+           exit 0 reported · 2 no feedback found · 3 error. \`log\` appends one dev-log line,
+           stamped, to the game's .funtools/devlog.jsonl (no heredoc or >> needed). Beside the kit tools,
+           collect ranks the GAME's practice: the owner first (owner lines and each game's pipeline
+           notes outrank any agent claim), what worked by its measured change (--before/--after, or
+           "34 -> 25.5 ms" in the words; a lesson that says it fixed something counts), each entry's
+           evidence checked to exist (a file, a commit, a test; else unverified), dead ends by the
+           hours they burned, cost and time per game, and A/B records (.funtools/ab.jsonl) as "GDK
+           lost level design by 1.8 in 1 of 2". --propose drafts one kit edit per top recurring lesson;
+           --html writes one page with filters. \`ab\` records an A/B; \`merged\` writes the merge
+           commit as a worked entry with the numbers the tools logged since its merge base (sim,
+           play, hook, life, profile and playtest log theirs as measure lines on their own)
+  character the character library: characters animated already. list shows the shelf
+           (2D sheets with idle, walk, run, jump, attack, hit, death and blink; 3D rigged GLBs
+           with every clip by name on one humanoid rig); get copies one into
+           public/assets/characters/<id>/ for free; restyle gives it your look (--game-id:
+           your style lock) and keeps every motion, priced per frame (--animations: fewer)
+  pack     exactly what an upload carries, a leak scan, the server's limits and a
+           build from the staged copy; never uploads (exit 1 = must not be uploaded)
+  export   the game as a clean folder of build inputs for another repo: index.html, src/,
+           public/, package.json + lock, tsconfig, vite.config, funpixel.json cut to name,
+           splash, metadata, checks and hooks, a two-line .harnessignore; notes, design,
+           evidence, agent files, tests, scripts and the Funpixel splash card (unless
+           "splash": "funpixel") stay behind. Every source comment is removed (the
+           game's TypeScript parser and printer; CSS too), then the dev folder and the clean
+           folder are both built and the bundles must be byte-identical. Reports leaks
+           (secrets, home paths, tool and provider names), absolute /public URLs in code, a
+           dev .harnessignore that excluded a build input, then runs the clean build: verify
+           at both sizes, audit-screens phone portrait and landscape, and every request the
+           page makes on every view (a 404 = a file the folder lost). Mobile findings (viewport
+           meta, safe area, hover-only UI, keys with no touch route, small text and targets)
+           are the game's to fix and never block. --check reports and writes nothing.
+           --strip-metadata removes text chunks and C2PA content credentials from public
+           PNGs, where a generator writes its own name (the owner's call: off by default)
+           exit 0 clean (written) · 1 a problem, nothing written · 3 error
+  gen      generate an asset with the Tools API, follow the job and save the files into
+           the game (default public/assets/images|sprites|sfx|music|models/, the folders
+           the scaffold reads); --cast <id> makes it from that cast member's master (reference 1
+           of a picture with its keep-line, the source of an edit or sheet, the image of a model)
+           and holds the result to it by numbers when it lands (cast check); inspect
+           measures a model you made, optimize-model decimates it to a budget, fracture
+           breaks it into shards, lod makes its
+           levels of detail, rig authors clips onto a bare biped rig (or fits a
+           donor's rig onto a bare mesh) after a free rig check, render photographs it
+           (views round it, a front view, a contact sheet), finalize repairs broken
+           materials, drops clips not kept and renders the proof; pictures go to
+           .funtools/renders/<name>/, never shipped; texture is a seamless tile and strip
+           a scrolling layer (refused, uncharged, if it shows a seam); skybox is a 360°
+           equirect sky; find-material searches Poly Haven's free CC0 library and
+           material copies one asset (HDRI, texture set, glTF model) into
+           public/assets/materials/<name>/, its licence and source recorded; video makes
+           a 5 or 10 s clip (generated, never gameplay: for trailer cards) into .funtools/video/;
+           --camera-move static|pan_left|pan_right|tilt_up|tilt_down|dolly_in|dolly_out|orbit_left|orbit_right|
+           crane_up|handheld, --lens wide|normal|tele|macro, --aperture deep|shallow, --camera-speed slow|normal|fast:
+           camera words the model takes (its own control or a fixed phrase; one it does not take is refused);
+           lipsync --image-asset <portrait> --audio-asset <line.mp3> [--duration <s>] [--resolution 480p|720p] makes
+           the portrait speak the line (up to 60 s, priced per second; the portrait must be your own face or a
+           character you made, never a real person who has not agreed) into .funtools/video/;
+           dialogue <scene.json> speaks a scene (an array of {speaker, text, voice?, tags?, pause_after_ms?,
+           track?}, or {lines, cast?, gap_ms?}; a voice is a preset or a cast voice.json; --gap ms, default 250)
+           into public/assets/voice/<scene>/: dialogue.mp3 (one mixed file), line-NN.mp3, dialogue.json (the
+           timeline: tracks by speaker, each clip's start and length); priced as its lines
+           --model <id> on image, sprite, sound, music, voice, line, dialogue, video, edit-video, lipsync and model3d: a model
+           from the registry (the ids: GET /v1/tools/models, or an unknown one's refusal, which lists
+           them); omitted, our recommended pick runs, with its fallback; named, it runs alone, never swapped.
+           voice, line and dialogue also take --model kokoro-82m: Kokoro on this Mac (Apple Silicon, free, offline, slower,
+           not checked by us; set up once with funtools models install kokoro-82m, else exit 2 naming it)
+           options: image/texture/strip/sprite --size WxH, snapped to the nearest of 1:1 3:2 2:3 4:3 3:4
+           16:9 9:16 21:9 (1024x1024, 1536x1024 → 3:2, 1024x1536 → 2:3, 1792x1024 → 16:9, 1024x1792 → 9:16;
+           the model picks the pixels for the shape); --quality low|medium|high: an image is
+           2 · 4 · 12 credits (low · medium, the default · high; a square, the dearest shape;
+           funtools estimate image prints the exact figure before you spend)
+           --target-size px (the file's longest side: the size the game shows it at; scaled down on
+           the server after drawing, never up, so a 60 px sprite does not ship at 1024²),
+           image/strip --transparent; skybox --negative "what not to show";
+           find-material --type hdri|texture|model --limit 1-20;
+           material --type hdri|texture|model (--id id | "keywords") --resolution 1k|2k;
+           sound --duration secs --loop; music --length clip|full --instrumental;
+           model3d --image-url https://… | --image-asset <file|id> [--back-asset --left-asset
+           --right-asset <file|id>: more sides of the subject, so its back is drawn, not invented],
+           --style standard|hero|lowpoly (standard ≈30K triangles; hero is static only: 300K triangles
+           on Meshy 7.1 at 4K geometry, 500K faces on Hunyuan 3.1), --model meshy-7.1|hunyuan-3.1|rodin-2.5
+           (or --engine meshy|hunyuan|rodin, the older name: that engine alone, no fallback; Meshy ships
+           2048 px maps, Hunyuan 4096 px PNG; rodin, only when named, is Rodin 2.5: static only,
+           hard-surface props, every view in one job, 50K triangles and 2048 px PBR maps, hero 500K with
+           4096 px maps, lowpoly 8K untextured; its prices are the rodin rows of funtools estimate), --raw (the
+           engine's GLB byte for byte: every triangle, full maps, no optimizer pass, same price),
+           --score name=ref.png,name=ref.png (when it lands: funtools fidelity on it, free; with
+           --unity the engine's GLB is scored before it is split for glTFast),
+           --animations walk,run; inspect --asset id; optimize-model --asset id
+           --budget food|prop|thin_walled|set_piece|character [--device phone|desktop]
+           [--height metres]; fracture --asset id [--pieces 2-32] [--seed n];
+           lod --asset id [--levels 1-4] [--ratio 0.05-0.95] [--min-triangles n];
+           rig --asset id [--clips idle,walk,attack,death | --donor id];
+           render --asset id [--frames 1-12] [--size 64-1024]; finalize --asset id
+           [--keep-clips Idle,Walk]; motion --asset id --motions '[{"kind":"wave"}]' (wave nod hop strike
+           flinch celebrate, dials in tuned ranges) [--base-clip idle]; retarget --asset id
+           (--donor id | --character robot-3d) [--only walk,run]; video --duration 5|10 [--aspect 16:9|9:16|1:1]
+           [--image-asset id | --image-url https://…] (a still to animate)
+           edit "the one change" --asset <file|id> [--mode edit|restyle|pose] [--game-id id]: the
+           same picture changed, a cut-out kept a cut-out (a blink, a hurt face, a second step);
+           sheet ["the character"] [--asset <sprite file|id>] --cycles idle:4,walk:6[@fps]
+           [--view side|front, never from above: edit --mode pose] [--body biped|quadruped|flyer]
+           [--frame-size 64-512] [--game-id id]
+           (blink:1 is the eyes-shut swap; a flyer's walk and run fly): every frame an edit of one
+           base, checked for drift, packed into public/assets/sprites/<name>/sheet.png + sheet.json
+           (Pixi AnimatedSprite: sheet.animations.walk); priced per frame (look --sheet
+           measures its loops). A picture prompt that names the game (funpixel.json name)
+           is warned about: image models letter the name and garble it; --strip-title
+           sends it without the name
+           --unity <project> (a Unity project, or the folder holding its unity/): the files go into
+           its Assets/_Game/Generated/<Images|Sprites|Textures|Materials|Skyboxes|Models|Sfx|Loops|
+           Music|Voice>/ with an import rule (Generated/Editor/FunpixelGenImport.cs) that sets each
+           kind's settings when Unity first imports it: sprites as Sprite, normal maps as NormalMap,
+           ASTC by role, audio by length (SFX mono ADPCM, loops PCM, music Vorbis streaming); no
+           .meta is written (Unity mints its GUID). A model is the engine's own GLB (--raw) split
+           into .gltf + .bin + model__basecolor/__normal/__mr PNGs for glTFast; audio is 48 kHz WAV
+           (ffmpeg). Takes image, sprite, strip, edit, sheet, texture, material, skybox, model3d,
+           sound, music, line
+           exit 2 also covers a key the server refused (unauthorized, insufficient_scope)
+           exit 0 done · 1 the job failed · 2 refused before it ran (confirm with --yes,
+           credits, the key's budget, the plan, rate limits) · 3 error
+  estimate what a gen would cost, in credits, without running it
+  models   the generation models gen --model takes, from the registry: per kind our pick first (recommended,
+           what runs when --model is left out), the other hosted models, then any that run on this Mac with
+           whether they are set up here. install sets up a local one: kokoro-82m (a voice, Apple Silicon only)
+           gets its runner with uv tool install (mlx-audio) and its weights into ~/.funpixel/models/ with a
+           progress line. A local model is free and offline, slower and not checked by us; it runs only when
+           named (gen voice|line|dialogue --model kokoro-82m), never in place of ours, and its files are recorded
+           generated_by local:<id>. funtools doctor shows the same in its Local models block
+           exit list 0; install 0 set up · 1 the install failed · 2 refused (a hosted id, needs Apple Silicon,
+           no uv) · 3 error
+  assets   an optional pipeline for a game that makes many assets from text: items in
+           assets/assets.json (name, kind image|sprite|sheet|texture|strip|sound|music|model3d,
+           subject, family, role size, draws, atlas, anchors, depth, variants, from, params),
+           each subject composed with assets/style.json (medium, the family's clause, never);
+           .funtools/assets.lock.json records what made each file (request hash, job, asset,
+           credits, sha256, the gate's verdict, the kept draw, earlier versions). status says
+           fresh | stale | missing | rejected | edited per item, orphans and credits spent (free,
+           offline). gen makes only missing and stale items in one generate_batch (--only,
+           --family, --stale narrow it; the server keys each item by its content, so a rerun
+           never pays twice), shows the estimate first, asks above 50 credits (--yes), stops
+           at --max-credits; --dry-run shows every prompt and the estimate and sends nothing.
+           draws: N keeps the first the gate accepts, all in .funtools/assets/draws/<name>/.
+           regen re-makes one item and records --because in the lock and style.json failures.
+           process keys (free key_sprite) and trims cut-outs, shrinks each to its role size,
+           desaturates depth planes, packs atlas groups with the local optimizer and writes
+           src/art/assets.json: relative URLs, anchors, a brightness tint per piece.
+           A game declaring "pixelArt": { "scale": 4, "palette": ["#hex", …] } in funpixel.json
+           has process (and gen) snap each picture to that grid and palette instead (hard
+           alpha, one ink per art pixel, originals kept); pixels measures every PNG under
+           public/assets/ (or the files named) for grid blocks that are not one colour, soft
+           edges and inks off the palette, each three-state; --snap snaps the named files first
+           exit 0 done · 1 something stale, missing or failed · 2 refused (confirm, cap) · 3 error;
+           pixels: 0 on the lane · 1 off it · 2 not observed (no lane declared, nothing drawn)
+           More kinds: pose (an edit of the cast master in the pose its subject names), rig (rig_model →
+           author_motion "motions" → retarget_clips "retarget" on a made model3d, "from"), parts (cut
+           from a "sheet" locally, free); a model3d's draws are a bake-off judged against its master
+           (rendered with your Blender, free); "optimize": {device} runs optimize_model after.
+           A picture of a cast member (its "cast", or a name that starts with the id) is drawn with
+           the master attached first and the card's words in its prompt, then held to the master: a
+           drift gets one targeted edit, then one redraw, then is kept as the best and named
+           (lock: identity); the masters ride the first batch as the game's locked sheets ref-<id>.
+           gen goes in batches of --batch (24), each priced before it is sent, and keeps to the
+           owner's asset budget (assets budget) unless --max-credits says otherwise.
+           script turns the plan's "## Asset script" rows (ID | What | Kind | Count | Cast) into
+           manifest items (--write); budget records the owner's credits for them.
+  cast     the cast library: design/cast/<id>/ (master.png, turnaround.png, palette.json, card.json/md).
+           add accepts a master; list names them; check holds pictures to a master by numbers
+           (silhouette, colour, lost main colours): exit 0 on model · 1 drift · 2 not observed · 3 error
+  job      a job's status; --wait follows it to the end and saves its files (exit as gen)
+  jobs     your account's jobs, newest first, a page at a time; --tool takes a tool
+           or a gen kind; a page with more prints the command for the next
+           page; --refusals tallies, per tool, how often your own jobs were refused and by
+           what (policy, a gate, bad input) over the latest 500: our routes measured, not a ranking
+  optimize the Studio's asset optimizer on local files, offline and free. With no op: what
+           the agent's optimization rule would flag (images of 400 KB or more, 4+ loose
+           sprites); --check exits 1 on that (CI). With an op: a dry run unless --write,
+           which also prints the brief your agent needs to change the loading code.
+           optimize-mesh --levels phone,desktop,high cuts one GLB per device class beside
+           the source (never replacing it) plus name.levels.json for the SDK's loadLevel;
+           --class sets the triangle budget (skinned = character, else prop), --out-dir
+           puts the levels elsewhere (a source kept outside public/). Output is
+           Draco (static) or meshopt (rigged) with KTX2 textures; FUNPIXEL_GLB_KTX2=off
+           keeps PNG/JPEG textures, FUNPIXEL_GLB_COMPRESS=draco|meshopt forces one codec
+           (no uncompressed output yet: a page that cannot run the decoders needs a decode)
+  playable the game as one ad network's playable: one HTML file in dist-playable/ (from
+           playable.html when there is one), weighed against the network's ceiling, searched
+           for anything it would fetch, then played offline on a phone with the network's
+           call to action stubbed — it must fire on the end card, after the reward
+           exit 0 pass · 1 fail · 2 not observed · 3 error
+  trailer  a store/social trailer from REAL play: the game filmed as reel films it,
+           cut on the beat of its own music (the bed it loops, public/assets/music/, or
+           --music) with its OWN sound effects where they played in the kept shots
+           (--no-sfx leaves them out; synthesised sounds are listed, never faked), mixed
+           to -16 LUFS / -1.5 dBTP, shots on its __FPX_MOMENT__ payoffs, a title card from its key art
+           (design/key-art.png, or --key-art) and an end card; 16:9 and 9:16 MP4s and
+           trailer.json (every segment's source) in .funtools/trailer/, never shipped.
+           1:1 and 4:5 too; --for names where it is posted (tiktok, reels, shorts,
+           stories, feed, square, youtube, store, site) and picks the formats; every
+           card and label sits inside that format's clear area (the platform's own
+           header, side rail and caption block never cover it: src/trailer/placement.ts).
+           --intro/--outro add generated clips (gen video) as cards only, each labelled
+           on screen as not gameplay. Needs ffmpeg. exit 0 written · 3 error
+  reel     a vertical share video of the game being played: the built game toured
+           through its __FPX_VIEWS__ (title, play, ending) and driven by its own
+           __FPX_VERBS__ (else its __FPX_KEYS__), filmed and cut to a 1080x1920 MP4
+           with ffmpeg (default .funtools/reel/reel.mp4, never shipped); with no
+           ffmpeg on PATH, or --frames-only, the PNG frames are the output
+  motion   the Motion bench: title cards, trailer shots, UI motion, logo stings and social loops for
+           any trade (a single's visualiser, a podcast's audiogram, a film's titles, a game's trailer).
+           A scene is a page that draws frame f (CSS, canvas, SVG or GSAP), which may say
+           window.__MOTION__ = { seconds, fps, size, loop } and may draw any frame on demand with
+           window.__MOTION_SEEK__(frame); flags beat it. render serves the scene (its folder as files,
+           or its project's own Vite), opens it headless on the held clock (one frame = 1000/fps ms,
+           Math.random seeded) and shoots every frame to <out>/frames/000001.png…, then encodes
+           motion.mp4 (H.264, yuv420p, faststart; --webm adds VP9; --audio is muxed and fitted to the
+           length) and checks it: safe zone (text and controls inside the format's clear area, uncut)
+           and overlaps (text over text), both by layout.js at the first frame, every 0.5 s and the
+           last; loop seam (a loop's wrap frame against its first); blank frames (nearly one colour,
+           outside the first and last 0.5 s); repeatable (--prove renders twice, every frame's bytes
+           compared). motion.json holds the plan, every frame's hash and the checks; a project's
+           design/status.json gets a motion part on the zero board (errors, overlaps, seams).
+           Default out .funtools/motion/<scene>/ (never shipped). check judges a render folder again
+           (or renders a scene without encoding); new writes <name>/index.html, a starter that passes
+           exit 0 pass · 1 a check failed · 2 not observed (no browser) · 3 error
+  compose  HTML-composition video: a trailer, a 9:16 post or a playable ad's end card written as a
+           HyperFrames composition (HTML, timed clips on tracks, GSAP titles, <audio>) with the game itself
+           as a live clip (<iframe data-fpx-game="game/index.html">) that the composition's clock drives on the
+           held clock (inputs on their frames; a game the clock cannot hold is filmed), rendered locally and
+           deterministically by HyperFrames (Apache-2.0, run at its pinned version: headless Chrome seeks each
+           frame, FFmpeg encodes). new writes design/compose/<name>.html from the game's build, key art,
+           captures and sound; check runs the contract, the tools, the game probe and HyperFrames' lint; render
+           writes .funtools/compose/<name>.mp4, <name>.sheet.jpg (12 frames to look at) and <name>.json.
+           variations makes ad cuts from one brief (hooks, each with the capture or view it opens on, calls to
+           action, lengths, aspects, an end card, max): at most max of the cross product, every value in a cut
+           before any pair repeats, each its own composition (design/compose/ads/<id>.html) rendered on one stage;
+           .funtools/compose/ads/<id>/ (mp4, contact sheet, record), index.json and sheet.png (a labelled frame
+           per cut: the person picks which to publish). An end card unlike the playable's own words is a warn
+           line; --dry-run prints the plan and renders nothing.
+           Needs Node 22+, ffmpeg and Playwright's headless Chromium (each missing one is named with its fix).
+           exit 0 pass · 1 the composition or a check failed · 2 not observed · 3 error
+  model    the hosted Blender bench on a model a job of yours made, by asset id or by the
+           file gen saved it as — nothing is uploaded; a file you changed since, or one no
+           job made, is for --local. inspect measures it (free); render photographs it
+           (--frames, --size: views round it, a front view, a contact sheet); finalize
+           repairs broken materials, drops clips not in --keep-clips and renders the proof;
+           skin has a vision pass mark the exposed skin and paints it one --tone (reuse the
+           tone across a cast); retexture repaints the model's four sides with the new look
+           (your game's style lock with --game-id) and projects them back onto its textures;
+           level builds a spec (rooms, walls, ramps, props, markers; TOOLS_API.md) into a GLB
+           with colliders and named markers, plus a plan and a corner view.
+           Pictures go to .funtools/renders/<name>/ (never shipped). Exit as gen.
+           --local: the bench's verbs on your own Blender 4.2+ (found in Applications,
+           Program Files or PATH, or FUNPIXEL_BLENDER_BIN): free, nothing is uploaded.
+           inspect describes it; normalize (--height-m) and decimate (--target-triangles,
+           never welds) write <name>.<verb>.glb or --out; render writes its PNGs to
+           .funtools/renders/<name>/ or --out; finalize writes <name>.finalize.glb and
+           its proof pictures; level builds a spec on your Blender, free, into
+           public/assets/models/<name>.glb and .funtools/renders/<name>/. The bench scripts ship with
+           funtools under their own GPL-3.0-or-later licence (FUNPIXEL_BENCH_DIR overrides)
+           exit 0 done · 1 Blender refused the model · 3 setup error
+           clips: the animation clip names in a GLB/glTF, read locally (no Blender, free),
+           and any name inside another (run / run_fast, idle / idle_long, walk / walkback),
+           repeated or missing: a lookup by name can play the wrong clip
+           exit 0 every name apart · 1 a collision · 2 no clips (not observed) · 3 error
+  fidelity how closely a 3D model matches its reference views, 0-100 each (the owner's
+           scorer): silhouette 35%, palette 30% (ΔE), tonal structure 20%, ink lines 15%, each view
+           against its best of the bench's 48 fixed cameras (8 yaws × 3 heights × both ways up),
+           rendered on your own Blender 4.2+ (free) at the references' own size, or --renders <dir>.
+           --own-axes for a model built square to its axes (no PCA), --roll for a deep model squared
+           onto its side, --outline for inked references, --quarter-turns for a figure standing
+           taller than long. It also names references no one object can match (proportions, parts,
+           and --same-scale sizes on one sheet). scores.json + sheets in .funtools/fidelity/<model>/
+           exit 0 scored (all ≥ --min) · 1 a view under --min · 2 nothing scored · 3 error
+  login    sign in in a browser (device code) and keep a new API key in the OS credential
+           store; --key stores a key you made in Settings › Developers (--key - reads stdin)
+           --api <url> signs in to another API (a local stack) and remembers it for later runs
+           --scope names the new key's scopes instead of the default set (every scope but
+           community:read and community:write, which a key holds only when asked for), e.g.
+           --scope community:read,community:write for a key that reads and acts in Community
+  whoami   the account and key funtools is using
+  usage    credits charged by tool and by day, this UTC month or the last --days;
+           --this-key counts only the key funtools is using
+  budget   this key's monthly credit cap, what it spent this month, the spend alerts it
+           crossed (50, 80, 100%) and what the wallet holds; the cap is set in
+           Settings › Developers
+  logout   remove the stored key
+  publish  funpixel (default): upload the staged game as a draft you own (needs a fresh
+           verify.json and an API key). itch / pages / folder: ship dist/ elsewhere — the
+           command is shown, and runs only with --yes or your confirm; logged to
+           .funtools/publish.jsonl
+  store    the read-only half of store publishing (Google Play, the App Store, Steam), offline: \`init\` writes
+           store/answers.json from what the game says (funpixel.json's name, the GDD's pitch), every other answer an
+           explicit TODO (ids, prices, the SDK list, ages: the owner's); one SDK list gives both stores' privacy
+           answers. \`doctor\`: what this Mac has for each store (asc and its version, DO_NOT_TRACK, the Play service
+           account key's path in .env — only that the file exists, never its contents —, steamcmd), each line with
+           its next step; never signs in, never calls a network API. \`lint\`: the answers against each store's rules
+           (lengths, other stores' names, art sizes read from the files, the privacy URL, the privacy forms against
+           the SDKs). \`plan\`: the ordered steps, each Script / Console / You as the store-readiness references
+           mark them, what is already true, and a plan hash (answers + art bytes + store); .funtools/store-plan.json.
+           store push and store release are not built yet
+           exit init 0 written · 2 already there; doctor/lint 0 clean · 1 a line failed; lint/plan 2 no answers · 3 error`;
+export function commandHelp(command) {
+    const [synopsis, described] = USAGE.split('\n\n');
+    const pick = (lines, starts, more) => {
+        const out = [];
+        let on = false;
+        for (const l of lines) {
+            if (starts(l))
+                on = true;
+            else if (!more(l))
+                on = false;
+            if (on)
+                out.push(l);
+        }
+        return out;
+    };
+    const syn = pick(synopsis.split('\n').slice(1), (l) => l.startsWith(`  funtools ${command} `) || l === `  funtools ${command}`, (l) => /^ {4,}\S/.test(l) && !l.startsWith('  funtools'));
+    const desc = pick(described.split('\n'), (l) => new RegExp(`^  ${command} +\\S`).test(l), (l) => /^ {11,}\S/.test(l));
+    return ['usage:', ...syn, '', ...desc].join('\n');
+}
+const message = (e) => (e instanceof Error ? e.message : String(e));
+export function parse(rest, spec) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (!a.startsWith('--') || a === '-') {
+            positionals.push(a);
+            continue;
+        }
+        if (!Object.hasOwn(spec, a))
+            return `unknown flag: ${a}`;
+        if (!spec[a]) {
+            flags[a] = true;
+            continue;
+        }
+        const v = rest[i + 1];
+        if (v === undefined || (v.startsWith('--') && v !== '-'))
+            return `${a} needs a value`;
+        flags[a] = v;
+        i++;
+    }
+    return { positionals, flags };
+}
+const str = (v) => (typeof v === 'string' ? v : undefined);
+const frontDoorOf = (flags) => str(flags['--click']) ?? (flags['--front-door'] ? FRONT_DOOR : null);
+function heldOf(flags, u) {
+    const raw = str(flags['--seed']);
+    if (raw !== undefined && !/^-?\d+$/.test(raw)) {
+        u.error(`--seed ${raw}`, '--seed is a whole number (window.__FPX_SEED__ and Math.random play from it)');
+        return null;
+    }
+    if (raw !== undefined && flags['--free-running']) {
+        u.error('--seed goes with the held clock', 'drop --free-running, or --seed');
+        return null;
+    }
+    return { ...(raw !== undefined ? { seed: Number(raw) } : {}), ...(flags['--free-running'] ? { freeRunning: true } : {}) };
+}
+function orientationOf(flags, vp, u) {
+    const o = str(flags['--orientation']);
+    if (o === undefined || (vp === 'phone' && (o === 'portrait' || o === 'landscape')))
+        return o;
+    if (o !== 'portrait' && o !== 'landscape')
+        u.error(`unknown orientation: ${o}`, '--orientation is portrait or landscape');
+    else
+        u.error(`--orientation ${o} turns the phone`, 'add --viewport phone');
+    return null;
+}
+const GEN_COMMANDS = new Set(['gen', 'character', 'estimate']);
+const GEN_SPEC = { ...Object.fromEntries(Object.entries(GEN_FLAGS).map(([f, d]) => [f, d.value])), '--json': false, '--score': true };
+const LOOK_SPEC = { '--viewport': true, '--front-door': false, '--click': true, '--json': false };
+export const SPECS = {
+    init: { '--framework': true, '--name': true, '--offline': false, '--idea': true, '--bare': false, '--no-git': false },
+    dev: { '--no-devtools': false, '--relay': false, '--bots': true, '--no-hold': false, '--phone': false, '--host': true, '--open': false },
+    open: {},
+    serve: { '--port': true, '--host': true, '--no-compress': false },
+    find: { '--json': false },
+    mcp: {},
+    setup: { '--host': true, '--dry-run': false, '--json': false },
+    doctor: { '--add-hooks': false, '--host': false, '--json': false },
+    upgrade: { '--self': false, '--discard': false },
+    smoke: { '--json': false },
+    'smoke-build': { '--plan': true, '--json': false },
+    test: { '--node': false, '--goals': false, '--json': false },
+    check: { '--viewport': true, '--phone': false, '--front-door': false, '--click': true, '--no-test': false, '--no-idle': false, '--world': false, '--no-world': false, '--json': false },
+    sim: {
+        '--script': true, '--timeout': true, '--json': false,
+        '--device': true, '--runtime': true, '--no-boot': false, '--owner': true, '--force': false, '--dry-run': false,
+        '--orientation': true, '--app': true, '--out': true, '--points': false, '--tool': true,
+    },
+    unity: {
+        '--project': true, '--unity': true, '--log': true, '--no-quit': false, '--max': true, '--stale-minutes': true, '--max-wait': true,
+        '--days': true, '--yes': false, '--json': false, '--disk': false, '--below': true, '--only': true, '--apply': false,
+        '--target': true, '--path': true, '--seconds': true, '--tier': true, '--budget': true, '--player': true, '--player-args': true, '--strict': false, '--rebuild': false, '--no-build': false,
+        '--keep-target': false, '--port': true, '--udid': true, '--device': true, '--keep-sim': false, '--visible': false, '--sound': false,
+        '--all': false, '--dev': false, '--settle-ms': true, '--points': false, '--mouse': false, '--from': true, '--git': true, '--ref': true, '--absolute': false,
+        '--tests': false, '--dry-run': false,
+        '--since': true, '--count': true, '--scene': false, '--game': false, '--out': true, '--open': false, '--wait': true,
+        '--name': true, '--at': true, '--depth': true, '--force': false,
+    },
+    spec: { '--spec': true, '--tier': true, '--dir': true, '--json': false },
+    rooms: { '--script': true, '--timeout': true, '--by': true, '--dir': true, '--json': false },
+    depth: { '--out': true, '--place': true, '--tension': true, '--progress': true, '--fill': false, '--json': false },
+    reach: { '--level': true, '--json': false },
+    world: { '--dir': true, '--seed': true, '--rooms': true, '--kind': true, '--from': true, '--variety': true, '--force': false, '--json': false },
+    feel: { '--script': true, '--engine': true, '--journey': true, '--no-sweep': false, '--json': false },
+    gdd: { '--sources': false, '--strict': false, '--json': false },
+    greenlight: { '--dir': true, '--version': true, '--override': true, '--target': true, '--by': true, '--from': true, '--why': true, '--json': false },
+    verify: {
+        '--engine': true,
+        '--players': true, '--checks': true, '--manifest': true, '--no-sweep': false, '--watch': false, '--json': false,
+        '--report': false, '--viewport': true, '--front-door': false, '--click': true,
+    },
+    capture: { ...LOOK_SPEC, '--engine': true, '--view': true, '--all': false, '--verbs': true, '--hold': true, '--burst': true, '--out': true, '--orientation': true, '--safari': false, '--seed': true, '--free-running': false },
+    'audit-screens': { ...LOOK_SPEC, '--engine': true, '--views': true, '--orientation': true },
+    compare: { '--baseline': false, '--json': false, '--target': true, '--view': true, '--viewport': true, '--fit': true, '--verbs': true, '--hold': true, '--front-door': false, '--click': true, '--out': true, '--engine': true, '--seed': true, '--free-running': false },
+    parts: { '--grid': true, '--boxes': true, '--names': true, '--key': true, '--pivot': true, '--pad': true, '--merge': true, '--webp': false, '--out': true, '--json': false, '--clean': false, '--keep-shadows': false },
+    cut: { '--grid': true, '--boxes': true, '--names': true, '--pivot': true, '--pad': true, '--merge': true, '--webp': false, '--out': true, '--json': false, '--keep-shadows': false },
+    scene: { ...LOOK_SPEC, '--engine': true, '--orientation': true, '--view': true, '--verbs': true, '--hold': true, '--motion': false },
+    hook: { ...LOOK_SPEC, '--engine': true, '--orientation': true, '--seconds': true, '--verbs': true, '--idle': false },
+    life: { ...LOOK_SPEC, '--engine': true, '--orientation': true, '--view': true, '--moment': true },
+    walk: { ...LOOK_SPEC, '--engine': true, '--orientation': true, '--route': true, '--chain': true, '--seconds': true, '--no-film': false },
+    score: { '--viewport': true, '--json': false, '--engine': true, '--target': true, '--view': true, '--hero': true, '--hero-share': true, '--capture': true, '--no-judge': false, '--fixes': false, '--seed': true, '--free-running': false },
+    framing: { ...LOOK_SPEC, '--engine': true, '--actors': true, '--view': true },
+    places: { ...LOOK_SPEC, '--engine': true, '--view': true },
+    boxes: { ...LOOK_SPEC, '--engine': true, '--orientation': true, '--view': true },
+    'compare-takes': { '--names': true, '--route': true, '--viewport': true, '--seconds': true, '--no-score': false, '--out': true, '--json': false, '--engine': true },
+    profile: { ...LOOK_SPEC, '--views': true, '--seed': true, '--frames': true, '--settle': true, '--against': true, '--software': false, '--throttle': true, '--repeat': true, '--compare': false, '--budget': true },
+    clip: { '--frames': true, '--fps': true, '--seats': true, '--dir': true, '--json': false },
+    judge: { '--prompt': true, '--concept': true, '--medium': true, '--dir': true, '--json': false },
+    phone: { '--sim': true, '--orientation': true, '--seconds': true, '--taps': true, '--swipes': true, '--keep': false, '--out': true, '--json': false },
+    inspect: { ...LOOK_SPEC, '--orientation': true, '--at': true, '--name': true, '--tree': false, '--url': true, '--view': true, '--verbs': true, '--settle': true },
+    look: { ...LOOK_SPEC, '--dir': true, '--read': false, '--hud': false, '--fit': false, '--samples': true, '--every': true, '--verbs': true, '--orientation': true, '--view': true, '--hold': true, '--player': true, '--threats': true, '--colours': true, '--sheet': false, '--3d': false, '--static': false, '--sprites': true, '--sizes': true, '--ground': true, '--out': true },
+    play: { '--viewport': true, '--engine': true, '--orientation': true, '--rounds': true, '--long': true, '--dir': true, '--round': true, '--refile': false, '--look': false, '--json': false },
+    journey: { '--viewport': true, '--engine': true, '--orientation': true, '--seed': true, '--seconds': true, '--repeat': true, '--against': true, '--force': false, '--dir': true, '--json': false },
+    playtest: { '--quick': false, '--versus': true, '--no-build': false, '--long': true, '--phone': false, '--sim': true, '--dir': true, '--cost-usd': true, '--hosted': false, '--yes': false, '--min-score': true, '--drop': true, '--by': true, '--json': false },
+    'mobile-qa': { '--phone': false, '--sim': true, '--no-build': false, '--dir': true, '--json': false },
+    flow: { '--idea': true, '--budget': true, '--autonomy': true, '--rounds': true, '--by': true, '--framework': true, '--name': true, '--bare': false, '--offline': false, '--no-git': false, '--dir': true, '--json': false },
+    note: { '--stage': true, '--screenshot': true, '--by': true, '--evidence': true, '--force': false, '--hold': false, '--dir': true, '--json': false },
+    owner: { '--repo': true, '--dir': true, '--json': false },
+    firstlook: { '--by': true, '--dir': true, '--no-browser': false, '--page': true, '--json': false },
+    progress: {
+        '--stage': true, '--shot': true, '--clip': true, '--line': true, '--next': true, '--spent': true, '--evidence': true, '--decision': true,
+        '--out': true, '--standin': true, '--tried': true, '--kind': true, '--options': true, '--default': true, '--timeout': true, '--for': true,
+        '--dir': true, '--json': false,
+    },
+    feedback: {
+        '--out': true, '--json': false, '--kind': true, '--cost-usd': true, '--minutes': true, '--evidence': true, '--dir': true,
+        '--metric': true, '--before': true, '--after': true, '--unit': true, '--sha': true, '--film': true, '--test': true, '--minutes-lost': true,
+        '--tool': true, '--stage': true, '--verdict': true, '--screenshot': true, '--propose': false, '--html': true,
+        '--what': true, '--routes': true, '--overall': true, '--axes': true, '--winner': true, '--judges': true,
+    },
+    journal: { '--why': true, '--by': true, '--files': true, '--values': true, '--dir': true, '--json': false },
+    decide: { '--because': true, '--over': true, '--supersedes': true, '--from': true, '--touches': true, '--dir': true, '--json': false },
+    lanes: { '--stage': true, '--lanes': true, '--cap': true, '--timebox': true, '--by': true, '--line': true, '--shot': true, '--cost': true, '--minutes': true, '--final': false, '--all': false, '--dir': true, '--json': false },
+    pick: { '--lane': true, '--question': true, '--by': true, '--dir': true, '--json': false },
+    lessons: { '--fix': true, '--source': true, '--delta': true, '--genre': true, '--share': false, '--dir': true, '--json': false },
+    pack: { '--dry-run': false, '--no-build': false, '--json': false, '--out': true },
+    export: { '--dir': true, '--check': false, '--no-browser': false, '--strip-metadata': false, '--json': false },
+    gen: { ...GEN_SPEC, '--out': true, '--unity': true, '--no-wait': false, '--yes': false, '--strip-title': false, '--cast': true },
+    character: { ...GEN_SPEC, '--out': true, '--no-wait': false, '--yes': false },
+    estimate: GEN_SPEC,
+    assets: { '--only': true, '--family': true, '--stale': false, '--max-credits': true, '--batch': true, '--dry-run': false, '--yes': false, '--because': true, '--snap': false, '--write': false, '--from': true, '--by': true, '--dir': true, '--json': false },
+    cast: { '--master': true, '--turnaround': true, '--pins': true, '--name': true, '--kind': true, '--features': true, '--may-change': true, '--moves': false, '--by': true, '--mode': true, '--dir': true, '--json': false },
+    variety: { '--within': false, '--json': false },
+    wow: { '--genre': true, '--json': false, '--signature': false, '--expression': true, '--why': true, '--check': true, '--dir': true },
+    pitch: { '--why': true, '--label': true, '--picture': true, '--cost': true, '--note': true, '--dir': true, '--json': false, '--seed': true, '--dial': true, '--brief': true, '--text': true },
+    loudness: { '--dir': true, '--json': false },
+    zero: { '--json': false },
+    review: { '--dir': true, '--json': false, '--loop': false, '--still': false, '--freeze': true, '--triangles': true, '--size': true, '--alpha': false, '--lufs': true },
+    motion: {
+        '--fps': true, '--seconds': true, '--frames': true, '--size': true, '--aspect': true, '--out': true, '--webm': false,
+        '--audio': true, '--prove': false, '--seed': true, '--dir': true, '--json': false,
+    },
+    compose: {
+        '--dir': true, '--name': true, '--aspect': true, '--seconds': true, '--fps': true, '--quality': true, '--software': false,
+        '--force': false, '--out': true, '--max': true, '--dry-run': false, '--json': false,
+    },
+    beats: { '--dir': true, '--meter': true, '--json': false },
+    schema: { '--strict': false, '--json': false },
+    loop: { '--fps': true, '--min': true, '--max': true, '--size': true, '--key': true, '--name': true, '--out': true, '--dir': true, '--json': false },
+    directions: { '--dirs': true, '--size': true, '--key': true, '--reverse': false, '--name': true, '--out': true, '--dir': true, '--json': false },
+    board: { '--keep': true, '--lends': true, '--note': true, '--licence': true, '--by': true, '--title': true, '--limit': true, '--any-licence': false, '--dir': true, '--json': false },
+    job: { '--wait': false, '--out': true, '--json': false },
+    jobs: { '--tool': true, '--status': true, '--limit': true, '--cursor': true, '--refusals': false, '--json': false },
+    optimize: {
+        '--check': false, '--json': false, '--write': false, '--dir': true, '--max-size': true, '--format': true,
+        '--quantize': false, '--padding': true, '--pot': false, '--no-trim': false, '--frame-size': true,
+        '--out': true, '--out-dir': true, '--levels': true, '--class': true,
+    },
+    playable: { '--network': true, '--no-play': false, '--json': false },
+    reel: { '--seconds': true, '--fps': true, '--viewport': true, '--frames-only': false, '--out': true, '--json': false },
+    trailer: {
+        '--seconds': true, '--fps': true, '--viewport': true, '--formats': true, '--for': true, '--music': true, '--no-music': false, '--no-sfx': false,
+        '--title': true, '--key-art': true, '--logo': true, '--cta': true, '--intro': true, '--outro': true, '--out': true, '--json': false,
+    },
+    fidelity: {
+        '--renders': true, '--out': true, '--size': true, '--own-axes': false, '--roll': false, '--outline': false,
+        '--quarter-turns': false, '--same-scale': false, '--min': true, '--json': false,
+    },
+    model: {
+        '--local': false, '--out': true, '--target-triangles': true, '--height-m': true, '--frames': true, '--size': true,
+        '--keep-clips': true, '--tone': true, '--palette': true, '--game-id': true, '--quality': true,
+        '--roughness': false, '--normal': false, '--json': false,
+    },
+    login: { '--key': true, '--api': true, '--scope': true }, logout: {}, whoami: {},
+    usage: { '--days': true, '--this-key': false, '--json': false }, budget: { '--json': false },
+    publish: {
+        '--target': true, '--yes': false, '--name': true, '--game-id': true, '--json': false,
+        '--update': false,
+        '--itch': true, '--project': true, '--out': true,
+    },
+    store: { '--store': true, '--dir': true, '--json': false },
+    models: { '--force': false, '--json': false },
+};
+export const ALIASES = { status: ['flow', 'status'] };
+export const VERSION_WORDS = ['--version', '-v', 'version'];
+export async function main(argv, io = console) {
+    if (argv[0] !== undefined && Object.hasOwn(ALIASES, argv[0]))
+        return main([...ALIASES[argv[0]], ...argv.slice(1)], io);
+    const [command, ...rest] = argv;
+    if (!command || command === '--help' || command === '-h') {
+        io.log(USAGE);
+        return command ? 0 : EXIT.error;
+    }
+    if (VERSION_WORDS.includes(command)) {
+        io.log(versionLine());
+        return 0;
+    }
+    const u = ui(io, command);
+    const help = 'run `funtools --help` for the usage';
+    if (!Object.hasOwn(SPECS, command)) {
+        u.error('unknown command', help);
+        return EXIT.error;
+    }
+    const dashes = command === 'unity' ? rest.indexOf('--') : -1;
+    const passthrough = dashes >= 0 ? rest.slice(dashes + 1) : [];
+    const own = dashes >= 0 ? rest.slice(0, dashes) : rest;
+    if (own.includes('--help') || own.includes('-h')) {
+        io.log(commandHelp(command));
+        return 0;
+    }
+    const parsed = parse(own, SPECS[command]);
+    if (typeof parsed === 'string') {
+        u.error(parsed, help);
+        return EXIT.error;
+    }
+    const { positionals, flags } = parsed;
+    const target = positionals[0];
+    const engineFlag = GEN_COMMANDS.has(command) ? undefined : str(flags['--engine']);
+    if (engineFlag !== undefined) {
+        if (!ENGINES.includes(engineFlag)) {
+            u.error(`--engine ${engineFlag}: chromium or webkit`, help);
+            return EXIT.error;
+        }
+        process.env.FUNTOOLS_ENGINE = engineFlag;
+    }
+    const json = !!flags['--json'];
+    boardRun(command);
+    try {
+        switch (command) {
+            case 'init': {
+                const spoken = target !== undefined && /\s/.test(target.trim()) && !existsSync(target) && flags['--idea'] === undefined;
+                if (positionals.length > (spoken ? 2 : 1)) {
+                    u.error('init takes one folder', 'funtools init <folder> --idea "one line", or funtools init "one line"');
+                    return EXIT.error;
+                }
+                const idea = spoken ? target : str(flags['--idea']);
+                return await init({ target: spoken ? positionals[1] : target, framework: str(flags['--framework']), name: str(flags['--name']), offline: !!flags['--offline'], idea, bare: !!flags['--bare'], noGit: !!flags['--no-git'] }, io);
+            }
+            case 'dev': {
+                const raw = str(flags['--bots']);
+                const bots = raw === undefined ? undefined : parseBots(raw);
+                if (typeof bots === 'string') {
+                    u.error(bots, help);
+                    return EXIT.error;
+                }
+                if (bots && !flags['--relay']) {
+                    u.error('--bots needs --relay', 'bots meet you in the local relay\'s dev room: funtools dev --relay --bots 3');
+                    return EXIT.error;
+                }
+                if (flags['--host'] && !flags['--phone']) {
+                    u.error('--host goes with --phone', 'funtools dev --phone [--host 0.0.0.0]');
+                    return EXIT.error;
+                }
+                if (flags['--no-hold'] && !flags['--relay']) {
+                    u.error('--no-hold goes with --relay', 'reloads are held only while a dev room is live');
+                    return EXIT.error;
+                }
+                return await dev({ target, devtools: !flags['--no-devtools'], relay: !!flags['--relay'], bots, phone: !!flags['--phone'], host: str(flags['--host']), holdReloads: !flags['--no-hold'], open: !!flags['--open'] }, io);
+            }
+            case 'serve': return await (await import("./commands/serve.js")).serve({ target, port: str(flags['--port']), host: str(flags['--host']), noCompress: !!flags['--no-compress'] }, io);
+            case 'doctor': {
+                if (!flags['--host'])
+                    return await doctor({ target, addHooks: !!flags['--add-hooks'] }, io);
+                const named = target !== undefined && HOSTS.includes(target) && !existsSync(target);
+                const other = !named && target !== undefined && /^[a-z]+$/.test(target) && !existsSync(target);
+                return await doctorHost({ host: named || other ? target : undefined, target: named || other ? positionals[1] : target, json }, io);
+            }
+            case 'check': {
+                const viewport = str(flags['--viewport']) ?? 'desktop';
+                if (!VIEWPORT_CHOICES.includes(viewport)) {
+                    u.error(`unknown viewport: ${viewport}`, '--viewport is desktop, phone or both');
+                    return EXIT.error;
+                }
+                return await check({ target, viewport: viewport, frontDoor: frontDoorOf(flags), noTest: !!flags['--no-test'], noIdle: !!flags['--no-idle'], phone: !!flags['--phone'], ...(flags['--world'] ? { world: true } : flags['--no-world'] ? { world: false } : {}), json }, io);
+            }
+            case 'upgrade': return flags['--self'] ? await upgradeSelf(io) : flags['--discard'] ? await discardOffers({ target }, io) : await upgrade({ target }, io);
+            case 'smoke': return await smoke({ target, json }, io);
+            case 'smoke-build': {
+                const plan = str(flags['--plan']);
+                if (!plan) {
+                    u.error('smoke-build needs the plan', 'funtools smoke-build <fresh-folder> --plan <folder with design/plan.md and design/first-look/ref-*.png>');
+                    return EXIT.error;
+                }
+                const { smokeBuild } = await import("./commands/smoke-build.js");
+                return await smokeBuild({ dir: positionals[0] ?? '.', plan, json, store: (await import("./keys/store.js")).osStore() }, io);
+            }
+            case 'compare': {
+                const commas = (f) => (str(flags[f]) ?? '').split(',').map((v) => v.trim()).filter(Boolean);
+                if (flags['--target'] === undefined) {
+                    const extra = ['--view', '--viewport', '--fit', '--verbs', '--hold', '--front-door', '--click', '--out', '--seed', '--free-running'].find((f) => flags[f] !== undefined);
+                    if (extra) {
+                        u.error(`${extra} goes with --target`, 'funtools compare --target design/first-look/walk.png --view playing');
+                        return EXIT.error;
+                    }
+                    return await compare({ target: target ?? '.', baseline: !!flags['--baseline'], json }, io);
+                }
+                if (flags['--baseline']) {
+                    u.error('--baseline and --target are two different compares', 'before | after: --baseline; today | target: --target');
+                    return EXIT.error;
+                }
+                const pairs = pairTargets(commas('--target'), commas('--view'));
+                if (typeof pairs === 'string') {
+                    u.error(pairs, help);
+                    return EXIT.error;
+                }
+                const vp = str(flags['--viewport']) ?? 'both';
+                if (!VIEWPORT_CHOICES.includes(vp)) {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is phone, desktop or both');
+                    return EXIT.error;
+                }
+                const fit = str(flags['--fit']) ?? 'contain';
+                if (fit !== 'contain' && fit !== 'cover') {
+                    u.error(`--fit ${fit}`, '--fit is contain (the whole target) or cover (fill and crop)');
+                    return EXIT.error;
+                }
+                const hold = str(flags['--hold']) === undefined ? undefined : Number(str(flags['--hold']));
+                if (hold !== undefined && (!Number.isFinite(hold) || hold < 0 || hold > 10_000)) {
+                    u.error('--hold is milliseconds from 0 to 10000', help);
+                    return EXIT.error;
+                }
+                const viewports = vp === 'both' ? ['phone', 'desktop'] : [vp];
+                const framed = heldOf(flags, u);
+                if (framed === null)
+                    return EXIT.error;
+                return await compareTarget({ target: target ?? '.', pairs, viewports: [...viewports], fit, out: str(flags['--out']), click: frontDoorOf(flags), verbs: commas('--verbs'), holdMs: hold, json, ...framed }, io);
+            }
+            case 'parts':
+            case 'cut': {
+                if (!target) {
+                    u.error(`${command} needs a sheet`, command === 'cut' ? 'funtools cut design/first-look/fauna.jpg --names fox,jelly,crab,goat,whale' : 'funtools parts design/gen/ren-sheet.png --names head,torso,arm-l,arm-r,leg-l,leg-r');
+                    return EXIT.error;
+                }
+                if (flags['--grid'] !== undefined && flags['--boxes'] !== undefined) {
+                    u.error('--grid or --boxes, not both', help);
+                    return EXIT.error;
+                }
+                const grid = str(flags['--grid']) === undefined ? undefined : parseGrid(str(flags['--grid']));
+                if (grid === null) {
+                    u.error(`--grid ${str(flags['--grid'])}`, '--grid is columns x rows, e.g. --grid 4x2');
+                    return EXIT.error;
+                }
+                const key = parseKey(str(flags['--key']) ?? 'auto');
+                if (!key) {
+                    u.error(`--key ${str(flags['--key'])}`, '--key is auto, none, paper or a colour like #ffffff');
+                    return EXIT.error;
+                }
+                const pivot = str(flags['--pivot']) ?? 'bottom';
+                if (pivot !== 'bottom' && pivot !== 'top' && pivot !== 'center') {
+                    u.error(`--pivot ${pivot}`, '--pivot is bottom (poses), top (limbs) or center');
+                    return EXIT.error;
+                }
+                const int = (f, d, hi) => {
+                    const raw = str(flags[f]);
+                    if (raw === undefined)
+                        return d;
+                    const n = Number(raw);
+                    if (Number.isInteger(n) && n >= 0 && n <= hi)
+                        return n;
+                    u.error(`${f} is a whole number of pixels from 0 to ${hi}`, help);
+                    return null;
+                };
+                const pad = int('--pad', 2, 64), merge = int('--merge', 6, 256);
+                if (pad === null || merge === null)
+                    return EXIT.error;
+                const names = (str(flags['--names']) ?? '').split(',').map((v) => v.trim()).filter(Boolean);
+                if (command === 'cut')
+                    return await parts(cutDefaults({ sheet: target, grid, boxes: str(flags['--boxes']), names, out: str(flags['--out']), pivot, pad, merge, webp: !!flags['--webp'], json, keepShadows: !!flags['--keep-shadows'] }), io);
+                return await parts({ sheet: target, grid, boxes: str(flags['--boxes']), names, out: str(flags['--out']), key, pivot, pad, merge, webp: !!flags['--webp'], json, clean: !!flags['--clean'], keepShadows: !!flags['--keep-shadows'] }, io);
+            }
+            case 'test': return await test({ target, node: !!flags['--node'], goals: !!flags['--goals'], json }, io);
+            case 'sim': {
+                if (isSimVerb(positionals[0])) {
+                    const verb = positionals[0];
+                    const owner = str(flags['--owner']);
+                    if (owner !== undefined && !/^\d+$/.test(owner)) {
+                        u.error(`--owner ${owner}`, 'the pid of the process that owns the lease');
+                        return EXIT.error;
+                    }
+                    const tool = str(flags['--tool']);
+                    if (tool !== undefined && tool !== 'baguette' && tool !== 'idb') {
+                        u.error(`--tool ${tool}`, 'baguette or idb');
+                        return EXIT.error;
+                    }
+                    return await simulator({
+                        verb, args: positionals.slice(1), device: str(flags['--device']), runtime: str(flags['--runtime']), boot: !flags['--no-boot'],
+                        owner: owner === undefined ? undefined : Number(owner), force: !!flags['--force'], dryRun: !!flags['--dry-run'],
+                        orientation: str(flags['--orientation']), app: str(flags['--app']), out: str(flags['--out']), points: !!flags['--points'], json,
+                        tool: tool,
+                    }, io);
+                }
+                const timeout = str(flags['--timeout']);
+                if (timeout !== undefined && !(Number(timeout) > 0)) {
+                    u.error(`--timeout ${timeout}`, 'seconds before the probe is stopped, e.g. --timeout 600');
+                    return EXIT.error;
+                }
+                return await sim({ target, script: str(flags['--script']), timeout: timeout === undefined ? undefined : Number(timeout), json }, io);
+            }
+            case 'spec': {
+                const known = SPEC_SUBCOMMANDS.includes(positionals[0] ?? '');
+                const sub = (known ? positionals[0] : 'lint');
+                const rest = known ? positionals.slice(1) : positionals;
+                if (rest.length > 1) {
+                    u.error(`spec ${sub} takes one folder`, 'funtools spec lint [dir] | spec init [dir] --tier mid|deep');
+                    return EXIT.error;
+                }
+                return await spec({ sub, dir: str(flags['--dir']) ?? rest[0], spec: str(flags['--spec']), tier: str(flags['--tier']), json }, io);
+            }
+            case 'rooms': {
+                const sub = (positionals[0] === 'open' || positionals[0] === 'plan' ? positionals[0] : 'run');
+                const rest = sub === 'run' ? positionals : positionals.slice(1);
+                const timeout = str(flags['--timeout']);
+                if (timeout !== undefined && !(Number(timeout) > 0)) {
+                    u.error(`--timeout ${timeout}`, 'seconds before the probe is stopped, e.g. --timeout 600');
+                    return EXIT.error;
+                }
+                if (sub === 'open') {
+                    const [room, ...more] = rest;
+                    const isDir = (x) => !!x && existsSync(x) && !/\s/.test(x);
+                    const dir = str(flags['--dir']) ?? (isDir(more[0]) ? more[0] : undefined);
+                    const words = (isDir(more[0]) && !flags['--dir'] ? more.slice(1) : more).join(' ').trim() || undefined;
+                    return await roomsCommand({ sub, room, dir, by: str(flags['--by']), words, json }, io);
+                }
+                if (sub === 'plan')
+                    return await roomsCommand({ sub, dir: str(flags['--dir']) ?? rest[0], by: str(flags['--by']), json }, io);
+                return await roomsCommand({ sub, dir: str(flags['--dir']) ?? rest[0], script: str(flags['--script']), timeout: timeout === undefined ? undefined : Number(timeout), json }, io);
+            }
+            case 'depth': return await depth({ target, out: str(flags['--out']), place: str(flags['--place']), tension: str(flags['--tension']), progress: str(flags['--progress']), fill: !!flags['--fill'], json }, io);
+            case 'world': {
+                const action = positionals[0];
+                if (!WORLD_ACTIONS.includes(action ?? '')) {
+                    u.error(action ? `unknown world action: ${action}` : 'world needs an action', 'funtools world forge --seed 7, or funtools world check');
+                    return EXIT.error;
+                }
+                if (action === 'check') {
+                    const extra = ['--seed', '--rooms', '--kind', '--from', '--variety', '--force'].find((f) => flags[f] !== undefined);
+                    if (extra) {
+                        u.error(`${extra} goes with world forge`, 'world check [--dir game] [--json]');
+                        return EXIT.error;
+                    }
+                }
+                return await world({
+                    action: action, dir: str(flags['--dir']) ?? positionals[1], seed: str(flags['--seed']), rooms: str(flags['--rooms']),
+                    kind: str(flags['--kind']), from: str(flags['--from']), variety: str(flags['--variety']), force: !!flags['--force'], json,
+                }, io);
+            }
+            case 'reach': return await reach({ target, levels: str(flags['--level'])?.split(',').map((l) => l.trim()).filter(Boolean), json }, io);
+            case 'feel': return await feel({ target, script: str(flags['--script']), journey: str(flags['--journey']), sweep: !flags['--no-sweep'], json }, io);
+            case 'greenlight': {
+                const known = GREENLIGHT_SUBCOMMANDS.includes(positionals[0] ?? '');
+                const sub = known ? positionals[0] : 'status';
+                const choose = sub === 'worth' && positionals[1] === 'choose';
+                const dir = str(flags['--dir']) ?? (choose ? undefined : known ? positionals[1] : positionals[0]) ?? '.';
+                return await greenlight({ sub, dir, version: str(flags['--version']), override: str(flags['--override']), json, args: choose ? positionals.slice(1) : [], target: str(flags['--target']), by: str(flags['--by']), from: str(flags['--from']), why: str(flags['--why']) }, io);
+            }
+            case 'gdd': {
+                const advice = { sources: !!flags['--sources'], strict: !!flags['--strict'] };
+                return await gdd(positionals[0] === 'page' ? { sub: 'page', target: positionals[1], json } : positionals[0] === 'lint' ? { target: positionals[1], json, ...advice } : { target, json, ...advice }, io);
+            }
+            case 'export': return await exportCmd({ dest: target, dir: str(flags['--dir']), check: !!flags['--check'], browser: !flags['--no-browser'], stripMetadata: !!flags['--strip-metadata'], json }, io);
+            case 'pack': return await pack({ target, build: !flags['--no-build'], json, out: str(flags['--out']) }, io);
+            case 'gen': return await gen({ positionals, flags, json, out: str(flags['--out']), unity: str(flags['--unity']), wait: !flags['--no-wait'], yes: !!flags['--yes'], stripTitle: !!flags['--strip-title'], score: str(flags['--score']) }, io);
+            case 'estimate': return await estimateCommand({ positionals, flags, json }, io);
+            case 'assets': {
+                const sub = positionals[0] ?? 'status';
+                if (!ASSETS_SUBCOMMANDS.includes(sub)) {
+                    u.error(`unknown: assets ${sub}`, `use one of ${ASSETS_SUBCOMMANDS.join(', ')}`);
+                    return EXIT.error;
+                }
+                return await assets({
+                    sub, args: positionals.slice(1), dir: str(flags['--dir']), only: str(flags['--only']), family: str(flags['--family']),
+                    stale: !!flags['--stale'], maxCredits: str(flags['--max-credits']), dryRun: !!flags['--dry-run'], yes: !!flags['--yes'],
+                    because: str(flags['--because']), snap: !!flags['--snap'], batch: str(flags['--batch']), write: !!flags['--write'],
+                    from: str(flags['--from']), by: str(flags['--by']), json,
+                }, io);
+            }
+            case 'cast': {
+                const sub = positionals[0] ?? 'list';
+                if (!CAST_SUBCOMMANDS.includes(sub)) {
+                    u.error(`unknown: cast ${sub}`, `use one of ${CAST_SUBCOMMANDS.join(', ')}`);
+                    return EXIT.error;
+                }
+                return await cast({
+                    sub, args: positionals.slice(1), dir: str(flags['--dir']), master: str(flags['--master']), turnaround: str(flags['--turnaround']),
+                    pins: str(flags['--pins']), name: str(flags['--name']), kind: str(flags['--kind']), features: str(flags['--features']),
+                    mayChange: str(flags['--may-change']), moves: !!flags['--moves'], by: str(flags['--by']), mode: str(flags['--mode']), json,
+                }, io);
+            }
+            case 'character': return await character({ positionals, flags, json, out: str(flags['--out']), wait: !flags['--no-wait'], yes: !!flags['--yes'] }, io);
+            case 'playable': return await playable({ target, network: str(flags['--network']), play: !flags['--no-play'], json }, io);
+            case 'reel': {
+                const num = (f, d, [lo, hi]) => {
+                    const v = str(flags[f]);
+                    const n = v === undefined ? d : Number(v);
+                    return Number.isFinite(n) && n >= lo && n <= hi ? n : `${f} is a number from ${lo} to ${hi}`;
+                };
+                const seconds = num('--seconds', 12, REEL_LIMITS.seconds), fps = num('--fps', 12, REEL_LIMITS.fps);
+                if (typeof seconds === 'string' || typeof fps === 'string') {
+                    u.error(String(typeof seconds === 'string' ? seconds : fps), help);
+                    return EXIT.error;
+                }
+                const vp = str(flags['--viewport']);
+                if (vp !== undefined && vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                return await reel({ target, seconds, fps: Math.round(fps), viewport: vp, framesOnly: !!flags['--frames-only'], out: str(flags['--out']), json }, io);
+            }
+            case 'trailer': {
+                const n = (f, d, [lo, hi]) => {
+                    const v = Number(str(flags[f]) ?? d);
+                    return Number.isFinite(v) && v >= lo && v <= hi ? Math.round(v) : null;
+                };
+                const seconds = n('--seconds', 30, TRAILER_LIMITS.seconds), fps = n('--fps', 15, TRAILER_LIMITS.fps);
+                if (seconds === null) {
+                    u.error(`--seconds is a number from ${TRAILER_LIMITS.seconds.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                if (fps === null) {
+                    u.error(`--fps is a number from ${TRAILER_LIMITS.fps.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                const vp = str(flags['--viewport']);
+                if (vp !== undefined && vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                if (flags['--formats'] !== undefined && flags['--for'] !== undefined) {
+                    u.error('--formats or --for, not both', help);
+                    return EXIT.error;
+                }
+                const places = str(flags['--for']) === undefined ? null : formatsFor(str(flags['--for']).split(',').map((s) => s.trim()).filter(Boolean));
+                if (typeof places === 'string') {
+                    u.error(places, help);
+                    return EXIT.error;
+                }
+                const formats = places ?? (str(flags['--formats']) ?? '16x9,9x16').split(',').map((s) => s.trim().replace(':', 'x')).filter(Boolean);
+                if (!formats.length || formats.some((f) => !Object.hasOwn(SAFE, f))) {
+                    u.error(`--formats is any of ${Object.keys(SAFE).join(', ')}`, help);
+                    return EXIT.error;
+                }
+                if (flags['--music'] !== undefined && flags['--no-music']) {
+                    u.error('--music and --no-music together', help);
+                    return EXIT.error;
+                }
+                return await trailer({
+                    target, seconds, fps, viewport: vp, formats: [...new Set(formats)],
+                    music: str(flags['--music']), noMusic: !!flags['--no-music'], noSfx: !!flags['--no-sfx'], title: str(flags['--title']),
+                    keyArt: str(flags['--key-art']), logo: str(flags['--logo']), cta: str(flags['--cta']),
+                    intro: str(flags['--intro']), outro: str(flags['--outro']), out: str(flags['--out']), json,
+                }, io);
+            }
+            case 'hook': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                const seconds = Number(str(flags['--seconds']) ?? 180);
+                if (!(seconds > 0 && seconds <= 900)) {
+                    u.error('--seconds must be between 1 and 900', help);
+                    return EXIT.error;
+                }
+                return await hook({ target, viewport: vp, orientation, json, click: frontDoorOf(flags) ?? FRONT_DOOR, seconds, idle: !!flags['--idle'], verbs: (str(flags['--verbs']) ?? '').split(',').map((v) => v.trim()).filter(Boolean) }, io);
+            }
+            case 'life': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                return await life({ target, viewport: vp, orientation, json, click: frontDoorOf(flags) ?? FRONT_DOOR, view: str(flags['--view']) ?? null, moment: str(flags['--moment']) ?? null }, io);
+            }
+            case 'walk': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                const secs = str(flags['--seconds']);
+                const seconds = secs === undefined ? undefined : Number(secs);
+                if (seconds !== undefined && !(seconds > 0 && seconds <= 900)) {
+                    u.error('--seconds must be between 1 and 900', help);
+                    return EXIT.error;
+                }
+                return await walk({ target, viewport: vp, orientation, json, click: null, routes: (str(flags['--route']) ?? '').split(',').map((v) => v.trim()).filter(Boolean), chain: (str(flags['--chain']) ?? '').split(',').map((v) => v.trim()).filter(Boolean), seconds, film: !flags['--no-film'] }, io);
+            }
+            case 'score': {
+                if (flags['--fixes'])
+                    return printFixes(target ?? '.', json, io);
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const pic = str(flags['--target']);
+                const share = str(flags['--hero-share']);
+                if (share !== undefined && !(Number(share) > 0 && Number(share) <= 1)) {
+                    u.error('--hero-share is the hero\'s height over the frame\'s, 0 to 1', help);
+                    return EXIT.error;
+                }
+                if (!pic && (flags['--view'] || flags['--hero'] || flags['--capture'] || share !== undefined)) {
+                    u.error('--view, --hero, --hero-share and --capture go with --target', 'funtools score --target design/first-look/walk.jpg --view walk');
+                    return EXIT.error;
+                }
+                const moments = pic ? [{ name: str(flags['--view']) ?? 'as-loaded', view: str(flags['--view']) ?? null, target: pic, hero: str(flags['--hero']) ?? null, heroShare: share === undefined ? null : Number(share), ...(str(flags['--capture']) ? { capture: str(flags['--capture']) } : {}) }] : [];
+                const framed = heldOf(flags, u);
+                if (framed === null)
+                    return EXIT.error;
+                return await score({ target: target ?? '.', moments, viewport: vp, json, noJudge: !!flags['--no-judge'], ...framed }, io);
+            }
+            case 'compare-takes': {
+                if (positionals.length !== 2) {
+                    u.error('compare-takes takes two game folders', 'funtools compare-takes builds/take-a builds/take-b [--names A,B]');
+                    return EXIT.error;
+                }
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const nm = (str(flags['--names']) ?? '').split(',').map((v) => v.trim()).filter(Boolean);
+                if (nm.length && nm.length !== 2) {
+                    u.error('--names takes two names, A,B', help);
+                    return EXIT.error;
+                }
+                const secs = str(flags['--seconds']);
+                const seconds = secs === undefined ? undefined : Number(secs);
+                if (seconds !== undefined && !(seconds > 0 && seconds <= 900)) {
+                    u.error('--seconds must be between 1 and 900', help);
+                    return EXIT.error;
+                }
+                return await compareTakes({ takes: [positionals[0], positionals[1]], ...(nm.length ? { names: [nm[0], nm[1]] } : {}), routes: (str(flags['--route']) ?? '').split(',').map((v) => v.trim()).filter(Boolean), viewport: vp, seconds, score: !flags['--no-score'], out: str(flags['--out']), json }, io);
+            }
+            case 'boxes': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                return await boxes({ target, viewport: vp, orientation, json, click: frontDoorOf(flags) ?? FRONT_DOOR, views: (str(flags['--view']) ?? '').split(',').map((v) => v.trim()).filter(Boolean) }, io);
+            }
+            case 'places': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                return await places({ target, viewport: vp, json, click: null, views: (str(flags['--view']) ?? '').split(',').map((v) => v.trim()).filter(Boolean) }, io);
+            }
+            case 'framing': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                return await framing({ target, viewport: vp, json, click: null, actors: (str(flags['--actors']) ?? '').split(',').map((v) => v.trim()).filter(Boolean), view: str(flags['--view']) ?? null }, io);
+            }
+            case 'capture':
+            case 'audit-screens':
+            case 'scene': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                const turned = /^phone-(portrait|landscape)$/.exec(vp);
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, turned ? `--viewport phone --orientation ${turned[1]}` : '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                const hold = str(flags['--hold']) === undefined ? undefined : Number(str(flags['--hold']));
+                if (hold !== undefined && (!Number.isFinite(hold) || hold < 0 || hold > 10_000)) {
+                    u.error('--hold is milliseconds from 0 to 10000', help);
+                    return EXIT.error;
+                }
+                const burst = str(flags['--burst']) === undefined ? undefined : Number(str(flags['--burst']));
+                if (burst !== undefined && (!Number.isInteger(burst) || burst < 0 || burst > BURST.max)) {
+                    u.error(`--burst is a frame count from 0 to ${BURST.max}`, help);
+                    return EXIT.error;
+                }
+                const list = (f) => (str(flags[f]) ?? '').split(',').map((v) => v.trim()).filter(Boolean);
+                const base = { target, viewport: vp, orientation, json, click: frontDoorOf(flags) };
+                const framed = heldOf(flags, u);
+                if (framed === null)
+                    return EXIT.error;
+                if (command === 'audit-screens')
+                    return await auditScreens({ ...base, views: list('--views') }, io);
+                if (flags['--safari'] && vp !== 'phone') {
+                    u.error('--safari is a phone in Mobile Safari', '--viewport phone --safari');
+                    return EXIT.error;
+                }
+                const look = { ...base, ...framed, safari: !!flags['--safari'], view: str(flags['--view']) ?? null, verbs: list('--verbs'), holdMs: hold, burst, out: str(flags['--out']), motion: !!flags['--motion'] };
+                if (command === 'capture' && flags['--all']) {
+                    if (look.view !== null || look.out !== undefined || str(flags['--viewport']) !== undefined || orientation !== undefined) {
+                        u.error('--all shoots every view at both sizes: drop --view, --out, --viewport and --orientation', help);
+                        return EXIT.error;
+                    }
+                    return await captureAll({ target, json, click: base.click, verbs: look.verbs, holdMs: hold, burst, ...framed }, io);
+                }
+                return command === 'capture' ? await capture(look, io) : await scene(look, io);
+            }
+            case 'play': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const rounds = Number(str(flags['--rounds']) ?? PLAY_DEFAULTS.rounds);
+                if (!Number.isInteger(rounds) || rounds < 1 || rounds > 10) {
+                    u.error('--rounds is 1 to 10', help);
+                    return EXIT.error;
+                }
+                const sub = PLAY_SUBCOMMANDS.includes(positionals[0] ?? '') ? positionals[0] : 'open';
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                const long = str(flags['--long']) === undefined ? undefined : Number(str(flags['--long']));
+                if (long !== undefined && !(Number.isInteger(long) && long >= 1 && long <= PLAY_STEP_LIMITS.maxLongMinutes)) {
+                    u.error(`--long is whole minutes of game time, 1 to ${PLAY_STEP_LIMITS.maxLongMinutes}`, help);
+                    return EXIT.error;
+                }
+                const roundRaw = str(flags['--round']);
+                const round = roundRaw === undefined ? undefined : Number(roundRaw);
+                if (round !== undefined && !(Number.isInteger(round) && round >= 1)) {
+                    u.error('--round is the round number play printed when it opened (1, 2, …)', help);
+                    return EXIT.error;
+                }
+                return await play({ sub, args: sub === 'open' ? positionals : positionals.slice(1), dir: str(flags['--dir']), round, refile: !!flags['--refile'], look: !!flags['--look'], viewport: vp, orientation, rounds, long, json }, io);
+            }
+            case 'journey': {
+                const vp = str(flags['--viewport']);
+                if (vp !== undefined && vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp ?? 'desktop', u);
+                if (orientation === null)
+                    return EXIT.error;
+                const int = (f, lo, hi) => {
+                    const raw = str(flags[f]);
+                    if (raw === undefined)
+                        return undefined;
+                    const n = Number(raw);
+                    if (Number.isInteger(n) && n >= lo && n <= hi)
+                        return n;
+                    u.error(`${f} is a whole number from ${lo} to ${hi}`, help);
+                    return null;
+                };
+                const seed = int('--seed', -2147483648, 2147483647), seconds = int('--seconds', 5, 1800), repeat = int('--repeat', 1, 3), against = int('--against', 1, 1_000_000);
+                if (seed === null || seconds === null || repeat === null || against === null)
+                    return EXIT.error;
+                const sub = JOURNEY_SUBCOMMANDS.includes(positionals[0] ?? '') ? positionals[0] : 'list';
+                if (sub === 'list' && positionals.length) {
+                    u.error(`unknown: journey ${positionals[0]}`, 'journey, journey record|from-play|replay|diff');
+                    return EXIT.error;
+                }
+                return await journey({ sub, args: positionals.slice(1), dir: str(flags['--dir']) ?? '.', viewport: vp, orientation, seed, seconds, repeat, against, force: !!flags['--force'], json }, io);
+            }
+            case 'playtest': {
+                const sub = PLAYTEST_SUBCOMMANDS.includes(positionals[0] ?? '') ? positionals[0] : 'run';
+                const cost = str(flags['--cost-usd']);
+                if (cost !== undefined && !(Number(cost) >= 0)) {
+                    u.error('--cost-usd is a number of dollars', help);
+                    return EXIT.error;
+                }
+                const dir = str(flags['--dir']) ?? (sub === 'run' ? positionals[0] : undefined) ?? '.';
+                const longRaw = str(flags['--long']);
+                const long = longRaw === undefined ? undefined : Number(longRaw);
+                if (long !== undefined && !(Number.isInteger(long) && long >= 0 && long <= PLAY_STEP_LIMITS.maxLongMinutes)) {
+                    u.error(`--long is whole minutes of game time for the blind round, 0 (a short round) to ${PLAY_STEP_LIMITS.maxLongMinutes}`, help);
+                    return EXIT.error;
+                }
+                const minRaw = str(flags['--min-score']);
+                const minScore = minRaw === undefined ? undefined : Number(minRaw);
+                if (minScore !== undefined && !(minScore >= 0 && minScore <= 10)) {
+                    u.error('--min-score is the panel\'s overall mean to require, 0 to 10', help);
+                    return EXIT.error;
+                }
+                if (minScore !== undefined && sub !== 'report') {
+                    u.error('--min-score goes with `playtest report`', 'the panel informs; only a report you ask to can fail on its number');
+                    return EXIT.error;
+                }
+                const common = { dir, quick: !!flags['--quick'], build: !flags['--no-build'], versus: str(flags['--versus']) ?? null, costUsd: cost === undefined ? null : Number(cost), long, phone: !!flags['--phone'], sim: str(flags['--sim']), json, minScore };
+                if (flags['--hosted'])
+                    return await playtestHosted({ ...common, yes: !!flags['--yes'] }, io);
+                if ((flags['--drop'] || flags['--by']) && sub !== 'keep') {
+                    u.error('--drop goes with `playtest keep`', 'playtest keep --drop K<n> --by owner "<their words>"');
+                    return EXIT.error;
+                }
+                return await playtest({ sub, ...common, ...(sub === 'keep' ? { drop: str(flags['--drop']), by: str(flags['--by']), words: positionals.slice(1).join(' ') } : {}) }, io);
+            }
+            case 'mobile-qa': {
+                const sub = positionals[0] === 'report' ? 'report' : 'run';
+                const dir = str(flags['--dir']) ?? (sub === 'run' ? positionals[0] : undefined) ?? '.';
+                return await mobileQa({ sub, dir, build: !flags['--no-build'], phone: !!flags['--phone'], sim: str(flags['--sim']), json }, io);
+            }
+            case 'flow': {
+                const known = FLOW_SUBCOMMANDS.includes(positionals[0] ?? '');
+                const sub = (known ? positionals[0] : 'status');
+                const rest = known ? positionals.slice(1) : positionals;
+                const isDir = (x) => !!x && existsSync(x) && !/\s/.test(x);
+                const worded = sub === 'agree' || sub === 'drop';
+                const dir = str(flags['--dir']) ?? (worded ? (isDir(rest[0]) ? rest[0] : undefined) : rest[0]) ?? '.';
+                const args = worded ? rest.slice(isDir(rest[0]) && !flags['--dir'] ? 1 : 0) : [];
+                return await flow({ sub, dir, args, idea: str(flags['--idea']), budget: str(flags['--budget']), autonomy: str(flags['--autonomy']), rounds: str(flags['--rounds']), by: str(flags['--by']), framework: str(flags['--framework']), name: str(flags['--name']), bare: !!flags['--bare'], offline: !!flags['--offline'], noGit: !!flags['--no-git'], json }, io);
+            }
+            case 'progress': {
+                const known = PROGRESS_SUBCOMMANDS.includes(positionals[0] ?? '');
+                if (!known && positionals.length) {
+                    u.error(`unknown: progress ${positionals[0]}`, `funtools progress ${PROGRESS_SUBCOMMANDS.join('|')}`);
+                    return EXIT.error;
+                }
+                const sub = (known ? positionals[0] : 'status');
+                const port = str(flags['--port']);
+                return await progress({
+                    sub, args: positionals.slice(1), dir: str(flags['--dir']), stage: str(flags['--stage']), shot: str(flags['--shot']), clip: str(flags['--clip']),
+                    line: str(flags['--line']), next: str(flags['--next']), spent: str(flags['--spent']), evidence: str(flags['--evidence']), decision: str(flags['--decision']),
+                    out: str(flags['--out']), standin: str(flags['--standin']), tried: str(flags['--tried']), kind: str(flags['--kind']), options: str(flags['--options']),
+                    default: str(flags['--default']), timeout: str(flags['--timeout']), for: str(flags['--for']), ...(port ? { port: Number(port) } : {}), phone: !!flags['--phone'], background: !!flags['--background'], json,
+                    store: (await import("./keys/store.js")).osStore(),
+                }, io);
+            }
+            case 'note': {
+                const known = NOTE_SUBCOMMANDS.includes(positionals[0] ?? '');
+                const sub = known ? positionals[0] : positionals.length ? 'add' : 'list';
+                return await note({ sub, args: known ? positionals.slice(1) : positionals, stage: str(flags['--stage']), screenshot: str(flags['--screenshot']), by: str(flags['--by']), evidence: str(flags['--evidence']), force: !!flags['--force'], hold: !!flags['--hold'], dir: str(flags['--dir']), json }, io);
+            }
+            case 'owner': {
+                const known = OWNER_SUBCOMMANDS.includes(positionals[0] ?? '');
+                if (!known && positionals.length && !existsSync(positionals[0])) {
+                    u.error(`unknown: owner ${positionals[0]}`, `funtools owner ${OWNER_SUBCOMMANDS.join('|')}`);
+                    return EXIT.error;
+                }
+                return await owner({ sub: (known ? positionals[0] : 'list'), args: known ? positionals.slice(1) : positionals, dir: str(flags['--dir']), repo: str(flags['--repo']), json }, io);
+            }
+            case 'firstlook': {
+                const known = FIRSTLOOK_SUBCOMMANDS.includes(positionals[0] ?? '');
+                return await firstlook({ sub: known ? positionals[0] : 'list', args: known ? positionals.slice(1) : positionals, dir: str(flags['--dir']), by: str(flags['--by']), noBrowser: !!flags['--no-browser'], page: str(flags['--page']), json }, io);
+            }
+            case 'feedback': return await feedback({
+                sub: positionals[0], dirs: positionals.slice(1), out: str(flags['--out']), json,
+                text: positionals.slice(1).join(' '), kind: str(flags['--kind']), costUsd: str(flags['--cost-usd']),
+                minutes: str(flags['--minutes']), evidence: str(flags['--evidence']), dir: str(flags['--dir']),
+                metric: str(flags['--metric']), before: str(flags['--before']), after: str(flags['--after']), unit: str(flags['--unit']),
+                sha: str(flags['--sha']), film: str(flags['--film']), test: str(flags['--test']), minutesLost: str(flags['--minutes-lost']),
+                tool: str(flags['--tool']), stage: str(flags['--stage']), verdict: str(flags['--verdict']), screenshot: str(flags['--screenshot']),
+                propose: !!flags['--propose'], html: str(flags['--html']),
+                what: str(flags['--what']), routes: str(flags['--routes']), overall: str(flags['--overall']), axes: str(flags['--axes']),
+                winner: str(flags['--winner']), judges: str(flags['--judges']),
+            }, io);
+            case 'journal': return await journal({
+                text: positionals.join(' '), why: str(flags['--why']), by: str(flags['--by']), files: str(flags['--files']),
+                values: str(flags['--values']), dir: str(flags['--dir']), json,
+            }, io);
+            case 'decide': return await decide({
+                text: positionals.join(' '), because: str(flags['--because']), over: str(flags['--over']),
+                supersedes: str(flags['--supersedes']), from: str(flags['--from']), touches: str(flags['--touches']), dir: str(flags['--dir']), json,
+            }, io);
+            case 'lanes': {
+                const known = LANES_SUBCOMMANDS.includes(positionals[0] ?? '');
+                if (!known && positionals.length) {
+                    u.error(`unknown: lanes ${positionals[0]}`, `funtools lanes ${LANES_SUBCOMMANDS.join('|')}`);
+                    return EXIT.error;
+                }
+                return await lanes({
+                    sub: (known ? positionals[0] : 'status'), args: positionals.slice(1), dir: str(flags['--dir']), stage: str(flags['--stage']), lanes: str(flags['--lanes']),
+                    cap: str(flags['--cap']), timebox: str(flags['--timebox']), by: str(flags['--by']), line: str(flags['--line']), shot: str(flags['--shot']), cost: str(flags['--cost']),
+                    minutes: str(flags['--minutes']), final: !!flags['--final'], all: !!flags['--all'], json, has: (c) => c in SPECS,
+                }, io);
+            }
+            case 'pick': {
+                const known = PICK_SUBCOMMANDS.includes(positionals[0] ?? '');
+                const sub = known ? positionals[0] : positionals.length ? 'propose' : 'list';
+                return await pick({ sub, args: known ? positionals.slice(1) : positionals, lane: str(flags['--lane']), question: str(flags['--question']), by: str(flags['--by']), dir: str(flags['--dir']), json }, io);
+            }
+            case 'variety': return await variety({ target, json, within: !!flags['--within'] }, io);
+            case 'wow': {
+                const sub = positionals[0] === 'pick' || positionals[0] === 'check' ? positionals[0] : 'list';
+                const dir = sub === 'pick' ? str(flags['--dir']) ?? '.' : (sub === 'check' ? positionals[1] : positionals[0]) ?? str(flags['--dir']) ?? '.';
+                return await wow({ sub, dir, genre: str(flags['--genre']), id: sub === 'pick' ? positionals[1] : undefined, signature: !!flags['--signature'], expression: str(flags['--expression']), why: str(flags['--why']), check: str(flags['--check']), json }, io);
+            }
+            case 'pitch': {
+                if (positionals[0] === 'widen') {
+                    const act = positionals[1] === 'score' || positionals[1] === 'keep' ? positionals[1] : 'draw';
+                    const after = positionals.slice(act === 'draw' ? 1 : 2);
+                    return await widen({
+                        action: act, card: act === 'keep' ? after[0] : undefined, dir: str(flags['--dir']) ?? (act === 'keep' ? after[1] : after[0]),
+                        seed: str(flags['--seed']), dial: str(flags['--dial']), brief: str(flags['--brief']), text: str(flags['--text']), json,
+                    }, io);
+                }
+                const known = PITCH_SUBCOMMANDS.includes(positionals[0] ?? '');
+                const sub = known ? positionals[0] : 'show';
+                const rest = known ? positionals.slice(1) : positionals;
+                const takes = sub === 'propose' || sub === 'pick';
+                return await pitch({
+                    sub, dir: str(flags['--dir']) ?? (takes ? undefined : rest[0]), choice: takes ? rest[0] : undefined, option: takes ? rest[1] : undefined,
+                    why: str(flags['--why']), label: str(flags['--label']), picture: str(flags['--picture']), cost: str(flags['--cost']), note: str(flags['--note']), json,
+                }, io);
+            }
+            case 'loudness': return await loudness({ paths: positionals, dir: str(flags['--dir']), json }, io);
+            case 'zero': return await zero({ target, json }, io);
+            case 'review': {
+                const n = (f, ok) => {
+                    const v = str(flags[f]);
+                    if (v === undefined)
+                        return undefined;
+                    const x = Number(v);
+                    return Number.isFinite(x) && ok(x) ? x : null;
+                };
+                const freezeS = n('--freeze', (x) => x > 0 && x <= 600), triangles = n('--triangles', (x) => Number.isInteger(x) && x > 0), lufs = n('--lufs', (x) => x < 0 && x > -70);
+                if (freezeS === null) {
+                    u.error('--freeze is seconds (more than 0)', help);
+                    return EXIT.error;
+                }
+                if (triangles === null) {
+                    u.error('--triangles is a whole number', help);
+                    return EXIT.error;
+                }
+                if (lufs === null) {
+                    u.error('--lufs is a loudness target below 0 (e.g. -14)', help);
+                    return EXIT.error;
+                }
+                const sz = str(flags['--size']);
+                const m = sz === undefined ? null : /^(\d+)[x×](\d+)$/i.exec(sz);
+                if (sz !== undefined && !m) {
+                    u.error('--size is WxH in pixels (e.g. 512x512)', help);
+                    return EXIT.error;
+                }
+                return await review({
+                    paths: positionals, dir: str(flags['--dir']), json, loop: !!flags['--loop'], still: !!flags['--still'], alpha: !!flags['--alpha'] || undefined,
+                    freezeS, triangles, lufs, ...(m ? { size: { w: Number(m[1]), h: Number(m[2]) } } : {}),
+                }, io);
+            }
+            case 'motion': {
+                const sub = MOTION_SUBCOMMANDS.includes(target ?? '') ? target : undefined;
+                if (target !== undefined && !sub) {
+                    u.error(`motion ${target}: ${MOTION_SUBCOMMANDS.join(', ')}`, help);
+                    return EXIT.error;
+                }
+                return await motion({
+                    sub, args: positionals.slice(1), fps: str(flags['--fps']), seconds: str(flags['--seconds']), frames: str(flags['--frames']),
+                    size: str(flags['--size']), aspect: str(flags['--aspect']), out: str(flags['--out']), webm: !!flags['--webm'], audio: str(flags['--audio']),
+                    prove: !!flags['--prove'], seed: str(flags['--seed']), dir: str(flags['--dir']), json,
+                }, io);
+            }
+            case 'compose': {
+                const sub = COMPOSE_SUBCOMMANDS.includes(target ?? '') ? target : undefined;
+                if (target !== undefined && !sub) {
+                    u.error(`compose ${target}: ${COMPOSE_SUBCOMMANDS.join(', ')}`, help);
+                    return EXIT.error;
+                }
+                return await compose({
+                    sub, args: positionals.slice(1), dir: str(flags['--dir']), name: str(flags['--name']), aspect: str(flags['--aspect']), seconds: str(flags['--seconds']),
+                    fps: str(flags['--fps']), quality: str(flags['--quality']), software: !!flags['--software'], force: !!flags['--force'], out: str(flags['--out']),
+                    max: str(flags['--max']), dryRun: !!flags['--dry-run'], json,
+                }, io);
+            }
+            case 'beats': {
+                const m = str(flags['--meter']);
+                return await beats({ paths: positionals, dir: str(flags['--dir']), meter: m === undefined ? undefined : Number(m), json }, io);
+            }
+            case 'schema': return await schema({ target, strict: !!flags['--strict'], json }, io);
+            case 'loop':
+            case 'directions': {
+                const num = (f) => {
+                    const v = str(flags[f]);
+                    if (v === undefined)
+                        return undefined;
+                    const n = Number(v);
+                    return Number.isInteger(n) && n > 0 ? n : null;
+                };
+                const bad = ['--fps', '--min', '--max', '--size', '--dirs'].find((f) => num(f) === null);
+                if (bad) {
+                    u.error(`${bad} is a whole number`, help);
+                    return EXIT.error;
+                }
+                const size = num('--size');
+                if (size !== undefined && (size < LOOP_LIMITS.size[0] || size > LOOP_LIMITS.size[1])) {
+                    u.error(`--size is ${LOOP_LIMITS.size.join(' to ')} pixels`, help);
+                    return EXIT.error;
+                }
+                if (command === 'directions')
+                    return await directions({ source: target, dirs: num('--dirs'), size, key: str(flags['--key']), reverse: !!flags['--reverse'], name: str(flags['--name']), out: str(flags['--out']), dir: str(flags['--dir']), json }, io);
+                const fps = num('--fps'), min = num('--min'), max = num('--max');
+                if (fps !== undefined && (fps < LOOP_LIMITS.fps[0] || fps > LOOP_LIMITS.fps[1])) {
+                    u.error(`--fps is ${LOOP_LIMITS.fps.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                if ([min, max].some((v) => v !== undefined && (v < LOOP_LIMITS.frames[0] || v > LOOP_LIMITS.frames[1]))) {
+                    u.error(`--min and --max are ${LOOP_LIMITS.frames.join(' to ')} frames`, help);
+                    return EXIT.error;
+                }
+                return await loop({ source: target, fps, min, max, size, key: str(flags['--key']), name: str(flags['--name']), out: str(flags['--out']), dir: str(flags['--dir']), json }, io);
+            }
+            case 'board': {
+                const known = BOARD_SUBCOMMANDS.includes(positionals[0] ?? '');
+                if (!known && positionals.length) {
+                    u.error(`unknown: board ${positionals[0]}`, `use one of ${BOARD_SUBCOMMANDS.join(', ')}`);
+                    return EXIT.error;
+                }
+                const sub = known ? positionals[0] : 'show';
+                const lim = str(flags['--limit']);
+                if (lim !== undefined && !(Number.isInteger(Number(lim)) && Number(lim) >= 1 && Number(lim) <= 20)) {
+                    u.error('--limit is 1 to 20', help);
+                    return EXIT.error;
+                }
+                return await board({
+                    sub, arg: positionals.slice(1).join(' ') || undefined, dir: str(flags['--dir']), limit: lim === undefined ? undefined : Number(lim),
+                    anyLicence: !!flags['--any-licence'], keep: str(flags['--keep']), lends: str(flags['--lends']), note: str(flags['--note']),
+                    licence: str(flags['--licence']), by: str(flags['--by']), title: str(flags['--title']), json,
+                }, io);
+            }
+            case 'lessons': {
+                const add = positionals[0] === 'add', motif = positionals[0] === 'motif';
+                if (!add && !motif && positionals.length) {
+                    u.error(`unknown: lessons ${positionals[0]}`, 'funtools lessons, or lessons add "<finding>" --fix "<fix>"');
+                    return EXIT.error;
+                }
+                return await lessons({
+                    add, motif, finding: positionals.slice(1).join(' '), fix: str(flags['--fix']), source: str(flags['--source']), delta: str(flags['--delta']),
+                    genre: str(flags['--genre']), share: !!flags['--share'], dir: str(flags['--dir']), json,
+                }, io);
+            }
+            case 'profile': {
+                const vp = str(flags['--viewport']) ?? 'phone';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const int = (f, d, [lo, hi]) => {
+                    const n = Number(str(flags[f]) ?? d);
+                    return Number.isInteger(n) && n >= lo && n <= hi ? n : null;
+                };
+                const frames = int('--frames', 120, PROFILE_LIMITS.frames), settleMs = int('--settle', 1500, PROFILE_LIMITS.settleMs);
+                if (frames === null) {
+                    u.error(`--frames is a whole number from ${PROFILE_LIMITS.frames.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                if (settleMs === null) {
+                    u.error(`--settle is milliseconds from ${PROFILE_LIMITS.settleMs.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                const seedRaw = str(flags['--seed']);
+                const seed = seedRaw === undefined ? null : Number(seedRaw);
+                if (seed !== null && !Number.isInteger(seed)) {
+                    u.error('--seed is a whole number', help);
+                    return EXIT.error;
+                }
+                const throttle = int('--throttle', 1, PROFILE_LIMITS.throttle);
+                if (throttle === null) {
+                    u.error(`--throttle is a whole number from ${PROFILE_LIMITS.throttle.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                const repeat = int('--repeat', 1, PROFILE_LIMITS.repeat);
+                if (repeat === null) {
+                    u.error(`--repeat is a whole number from ${PROFILE_LIMITS.repeat.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                const views = (str(flags['--views']) ?? '').split(',').map((v) => v.trim()).filter(Boolean);
+                const budgetRaw = str(flags['--budget']);
+                const budgetMs = budgetRaw === undefined ? undefined : Number(budgetRaw);
+                if (budgetMs !== undefined && !(budgetMs >= PROFILE_LIMITS.budgetMs[0] && budgetMs <= PROFILE_LIMITS.budgetMs[1])) {
+                    u.error(`--budget is a frame budget in ms from ${PROFILE_LIMITS.budgetMs.join(' to ')}`, help);
+                    return EXIT.error;
+                }
+                if (budgetMs !== undefined && !flags['--compare']) {
+                    u.error('--budget is the burn rate\'s frame budget', 'add --compare');
+                    return EXIT.error;
+                }
+                return await profile({
+                    target, viewport: vp, views, seed, frames, settleMs, against: str(flags['--against']) ?? null, click: frontDoorOf(flags), json,
+                    software: !!flags['--software'], throttle, repeat, compare: !!flags['--compare'], budgetMs,
+                }, io);
+            }
+            case 'clip': {
+                const isReport = positionals[0] === 'report';
+                const fpsRaw = str(flags['--fps']);
+                const fps = fpsRaw === undefined ? undefined : Number(fpsRaw);
+                if (fps !== undefined && !(fps >= 1 && fps <= 60)) {
+                    u.error('--fps is 1 to 60', help);
+                    return EXIT.error;
+                }
+                const seats = (str(flags['--seats']) ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+                return await clip({ sub: isReport ? 'report' : 'prepare', dir: str(flags['--dir']) ?? (isReport ? positionals[1] : positionals[0]) ?? '.', frames: str(flags['--frames']), fps, seats, json }, io);
+            }
+            case 'judge': {
+                const sub = positionals[0];
+                if (!JUDGE_SUBCOMMANDS.includes(sub)) {
+                    u.error(`judge ${sub ?? ''}: structure, identity or report`.replace(/ +:/, ':'), help);
+                    return EXIT.error;
+                }
+                const medium = str(flags['--medium']);
+                if (medium !== undefined && medium !== 'model' && medium !== 'sprites') {
+                    u.error('--medium is model or sprites', help);
+                    return EXIT.error;
+                }
+                if (sub !== 'structure' && flags['--prompt'] !== undefined) {
+                    u.error('--prompt is for judge structure', help);
+                    return EXIT.error;
+                }
+                if (sub !== 'identity' && (flags['--concept'] !== undefined || medium)) {
+                    u.error('--concept and --medium are for judge identity', help);
+                    return EXIT.error;
+                }
+                return await judge({ sub, positionals: positionals.slice(1), dir: str(flags['--dir']) ?? '.', prompt: str(flags['--prompt']), concept: str(flags['--concept']), medium, json }, io);
+            }
+            case 'unity': {
+                const num = (f) => { const v = str(flags[f]); return v === undefined ? undefined : Number(v); };
+                for (const f of ['--max', '--stale-minutes', '--max-wait', '--days', '--below']) {
+                    const v = num(f);
+                    if (v !== undefined && !(v >= 0)) {
+                        u.error(`${f} ${str(flags[f])}`, 'a number');
+                        return 125;
+                    }
+                }
+                const sub = positionals[0];
+                if (sub !== 'run' && sub !== 'probe' && sub !== 'play' && sub !== 'capture' && passthrough.length) {
+                    u.error('arguments after -- go with unity run (Unity\'s) or probe, play and capture (the player\'s)', 'funtools unity run -- <unity args>');
+                    return 125;
+                }
+                if (sub === 'probe' || sub === 'play' || sub === 'capture') {
+                    for (const f of ['--seconds', '--port', '--settle-ms']) {
+                        const v = num(f);
+                        if (v !== undefined && !(v > 0)) {
+                            u.error(`${f} ${str(flags[f])}`, 'a number above 0');
+                            return 3;
+                        }
+                    }
+                    const staleMinutes = num('--stale-minutes') ?? 20, maxRuns = num('--max') ?? 2, maxWait = num('--max-wait');
+                    return await unityPlayer({
+                        sub, args: positionals.slice(1), project: str(flags['--project']), target: str(flags['--target']), path: str(flags['--path']), seconds: num('--seconds'),
+                        tier: str(flags['--tier']), budget: str(flags['--budget']), player: str(flags['--player']), rebuild: !!flags['--rebuild'], noBuild: !!flags['--no-build'],
+                        keepTarget: !!flags['--keep-target'], port: num('--port'), udid: str(flags['--udid']), device: str(flags['--device']), keepSim: !!flags['--keep-sim'],
+                        visible: !!flags['--visible'], sound: !!flags['--sound'], out: str(flags['--out']), all: !!flags['--all'], dev: !!flags['--dev'], settleMs: num('--settle-ms'),
+                        playerArgs: passthrough, playerArgsFile: str(flags['--player-args']), strict: !!flags['--strict'],
+                        points: !!flags['--points'], mouse: !!flags['--mouse'], from: str(flags['--from']), git: str(flags['--git']), ref: str(flags['--ref']),
+                        absolute: !!flags['--absolute'], tests: !!flags['--tests'], force: !!flags['--force'], dryRun: !!flags['--dry-run'], json,
+                        queue: { staleMs: staleMinutes * 60_000, max: maxRuns, pollMs: 5000, maxWaitMs: maxWait === undefined ? null : maxWait * 60_000 },
+                    }, io);
+                }
+                if (sub === 'bridge')
+                    return await unityBridge({ action: positionals[1], project: str(flags['--project']), json }, io);
+                if (sub === 'editor') {
+                    for (const f of ['--count', '--wait', '--depth']) {
+                        const v = num(f);
+                        if (v !== undefined && !(Number.isInteger(v) && v >= 1)) {
+                            u.error(`${f} ${str(flags[f])}`, 'a whole number, 1 or more');
+                            return 3;
+                        }
+                    }
+                    return await unityEditor({
+                        action: positionals[1], args: positionals.slice(2), project: str(flags['--project']), unity: str(flags['--unity']),
+                        since: str(flags['--since']), count: num('--count'), scene: !!flags['--scene'], game: !!flags['--game'], out: str(flags['--out']),
+                        open: !!flags['--open'], wait: num('--wait'), name: str(flags['--name']), at: str(flags['--at']), depth: num('--depth'),
+                        force: !!flags['--force'], json,
+                    }, io);
+                }
+                return await unity({
+                    sub, unityArgs: passthrough, project: str(flags['--project']), unity: str(flags['--unity']), log: str(flags['--log']), noQuit: !!flags['--no-quit'],
+                    max: num('--max'), staleMinutes: num('--stale-minutes'), maxWaitMinutes: num('--max-wait'),
+                    roots: sub === 'gc' ? positionals.slice(1) : [], days: num('--days'), yes: !!flags['--yes'], json,
+                    disk: !!flags['--disk'], below: num('--below'), only: str(flags['--only']), apply: !!flags['--apply'], strict: !!flags['--strict'],
+                }, io);
+            }
+            case 'phone': {
+                const o = str(flags['--orientation']);
+                if (o !== undefined && o !== 'portrait' && o !== 'landscape') {
+                    u.error(`unknown orientation: ${o}`, '--orientation is portrait or landscape');
+                    return EXIT.error;
+                }
+                const seconds = Number(str(flags['--seconds']) ?? 6);
+                if (!Number.isFinite(seconds) || seconds < 1 || seconds > 60) {
+                    u.error('--seconds is 1 to 60', help);
+                    return EXIT.error;
+                }
+                const taps = (str(flags['--taps']) ?? '').split(/\s+/).map((t) => t.trim()).filter(Boolean);
+                const swipes = (str(flags['--swipes']) ?? '').split(/[\s,]+/).map((t) => t.trim()).filter(Boolean);
+                return await phone({ target, sim: str(flags['--sim']), orientation: o, seconds, taps, swipes, keep: !!flags['--keep'], out: str(flags['--out']), json }, io);
+            }
+            case 'inspect': {
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const orientation = orientationOf(flags, vp, u);
+                if (orientation === null)
+                    return EXIT.error;
+                const settle = Number(str(flags['--settle']) ?? 1500);
+                if (!Number.isFinite(settle) || settle < 0 || settle > 20_000) {
+                    u.error('--settle is milliseconds from 0 to 20000', help);
+                    return EXIT.error;
+                }
+                const url = str(flags['--url']);
+                if (url !== undefined && !/^https?:\/\//.test(url)) {
+                    u.error(`--url ${url} is not a web address`, 'the address `funtools dev` printed, e.g. http://localhost:5173');
+                    return EXIT.error;
+                }
+                return await inspect({
+                    target, url, at: str(flags['--at']), name: str(flags['--name']), tree: !!flags['--tree'], viewport: vp, orientation,
+                    view: str(flags['--view']) ?? null, verbs: (str(flags['--verbs']) ?? '').split(',').map((v) => v.trim()).filter(Boolean),
+                    settleMs: settle, click: frontDoorOf(flags), json,
+                }, io);
+            }
+            case 'look': {
+                if (THEME_SUBCOMMANDS.includes(positionals[0] ?? '')) {
+                    const sub = positionals[0];
+                    const dir = str(flags['--dir']) ?? (sub === 'report' ? positionals[1] : undefined) ?? '.';
+                    return await lookTheme({ sub, dir, pairs: sub === 'set' ? positionals.slice(1) : undefined, file: sub === 'patch' ? positionals[1] : undefined, json }, io);
+                }
+                if (flags['--hud']) {
+                    const vp = str(flags['--viewport']) ?? 'phone', orientation = str(flags['--orientation']);
+                    const samples = Number(str(flags['--samples']) ?? HUD_SAMPLING.samples), every = Number(str(flags['--every']) ?? HUD_SAMPLING.everyMs);
+                    if (vp !== 'desktop' && vp !== 'phone') {
+                        u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                        return EXIT.error;
+                    }
+                    if (orientation !== undefined && orientation !== 'portrait' && orientation !== 'landscape') {
+                        u.error('--orientation is portrait or landscape', help);
+                        return EXIT.error;
+                    }
+                    if (!Number.isInteger(samples) || samples < 1 || samples > HUD_SAMPLING.max) {
+                        u.error(`--samples is a whole number from 1 to ${HUD_SAMPLING.max}`, help);
+                        return EXIT.error;
+                    }
+                    if (!Number.isFinite(every) || every < 100 || every > 5_000) {
+                        u.error('--every is milliseconds from 100 to 5000', help);
+                        return EXIT.error;
+                    }
+                    return await lookHud({ target, viewport: vp, orientation, view: str(flags['--view']) ?? null, verbs: (str(flags['--verbs']) ?? '').split(',').map((v) => v.trim()).filter(Boolean), samples, everyMs: every, click: frontDoorOf(flags), json }, io);
+                }
+                if (flags['--3d'])
+                    return await look3d({ target, static: !!flags['--static'], view: str(flags['--view']) ?? null, click: frontDoorOf(flags), json }, io);
+                if (flags['--fit'])
+                    return await lookFit({ target, view: str(flags['--view']) ?? null, click: frontDoorOf(flags), json }, io);
+                if (flags['--sheet'])
+                    return await lookSheet({ target, sprites: str(flags['--sprites']), sizes: str(flags['--sizes']), ground: str(flags['--ground']), out: str(flags['--out']), json }, io);
+                if (!flags['--read']) {
+                    u.error('look measures --read, --hud, --fit, --sheet or --3d, or sets the look (set, patch, report)', 'funtools look --read [dir] · funtools look --hud [dir] · funtools look --fit [dir] · funtools look --sheet [dir] · funtools look --3d [dir] · funtools look set plate-ink=#3a2618 · funtools look report');
+                    return EXIT.error;
+                }
+                const vp = str(flags['--viewport']) ?? 'desktop';
+                if (vp !== 'desktop' && vp !== 'phone') {
+                    u.error(`unknown viewport: ${vp}`, '--viewport is desktop or phone');
+                    return EXIT.error;
+                }
+                const hold = Number(str(flags['--hold']) ?? 1500);
+                if (!Number.isFinite(hold) || hold < 0 || hold > 10_000) {
+                    u.error('--hold is milliseconds from 0 to 10000', help);
+                    return EXIT.error;
+                }
+                return await lookRead({
+                    target, viewport: vp, view: str(flags['--view']) ?? null, holdMs: hold, click: frontDoorOf(flags),
+                    player: str(flags['--player']), threats: str(flags['--threats']), colours: str(flags['--colours']), json,
+                }, io);
+            }
+            case 'optimize': return await optimize({ positionals, flags, json }, io);
+            case 'fidelity': return await fidelity({
+                positionals, renders: str(flags['--renders']), out: str(flags['--out']), size: str(flags['--size']), min: str(flags['--min']),
+                ownAxes: !!flags['--own-axes'], roll: !!flags['--roll'], outline: !!flags['--outline'],
+                quarterTurns: !!flags['--quarter-turns'], sameScale: !!flags['--same-scale'], json,
+            }, io);
+            case 'model': return await model({
+                local: !!flags['--local'], positionals, out: str(flags['--out']), json,
+                targetTriangles: str(flags['--target-triangles']), heightM: str(flags['--height-m']),
+                frames: str(flags['--frames']), size: str(flags['--size']), keepClips: str(flags['--keep-clips']),
+                tone: str(flags['--tone']), palette: str(flags['--palette']), gameId: str(flags['--game-id']),
+                quality: str(flags['--quality']), roughness: !!flags['--roughness'] || undefined, normal: !!flags['--normal'] || undefined,
+            }, io);
+            case 'job': return await job({ id: target, wait: !!flags['--wait'], out: str(flags['--out']), json }, io);
+            case 'jobs': return await jobs({ tool: str(flags['--tool']), status: str(flags['--status']), limit: str(flags['--limit']), cursor: str(flags['--cursor']), refusals: !!flags['--refusals'], json }, io);
+            case 'login': {
+                const asked = str(flags['--scope']);
+                const scopes = asked === undefined ? undefined : asked.split(/[\s,]+/).filter(Boolean);
+                if (scopes !== undefined && scopes.length === 0) {
+                    u.error('--scope needs at least one scope', 'funtools login --scope community:read,community:write');
+                    return EXIT.error;
+                }
+                if (scopes !== undefined && flags['--key']) {
+                    u.error('--scope goes with the browser sign-in', 'a key you paste keeps the scopes it was made with (Settings › Developers)');
+                    return EXIT.error;
+                }
+                if (!flags['--key'])
+                    return await browserLogin(io, undefined, undefined, undefined, scopes);
+                return await login({ key: str(flags['--key']), api: str(flags['--api']) }, io);
+            }
+            case 'whoami': return await whoami(io);
+            case 'setup': return await (await import("./commands/setup.js")).setup({ host: str(flags['--host']), dryRun: !!flags['--dry-run'], json }, io);
+            case 'mcp': {
+                const { serveStdio } = await import("./mcp/server.js");
+                await serveStdio({ cwd: process.cwd(), bin: [process.execPath, ...process.execArgv, process.argv[1]] });
+                return EXIT.pass;
+            }
+            case 'find': return await (await import("./commands/find.js")).find({ ask: positionals.join(' '), usage: USAGE, names: Object.keys(SPECS), json }, io);
+            case 'open': {
+                const what = positionals[0];
+                if (!what) {
+                    u.error('open needs a URL or a file', 'funtools open http://localhost:5317/  |  funtools open design/first-look/target-key-art.png');
+                    return EXIT.error;
+                }
+                const target = /^[a-z]+:\/\//i.test(what) ? what : (await import('node:path')).resolve(what);
+                if (!/^[a-z]+:\/\//i.test(what) && !(await import('node:fs')).existsSync(target)) {
+                    u.error(`no such file: ${what}`, 'give a URL or a path that exists');
+                    return EXIT.error;
+                }
+                const { openTarget } = await import("./dev/open.js");
+                if (openTarget(target)) {
+                    u.summary('pass', `opened ${what}`);
+                    return EXIT.pass;
+                }
+                u.summary('note', `nothing opens here (CI, FUNPIXEL_NO_OPEN, or no display): ${what}`);
+                return EXIT.not_observed;
+            }
+            case 'usage': return await usage({ days: str(flags['--days']), thisKey: !!flags['--this-key'], json }, io);
+            case 'budget': return await budget({ json }, io);
+            case 'logout': return await logout(io);
+            case 'publish': {
+                const to = str(flags['--target']) ?? 'funpixel';
+                if (!TARGETS.includes(to)) {
+                    u.error(`unknown target: ${to}`, `use one of ${TARGETS.join(', ')}`);
+                    return EXIT.error;
+                }
+                return await publish({
+                    target, to: to, yes: !!flags['--yes'], json,
+                    name: str(flags['--name']), gameId: str(flags['--game-id']),
+                    itch: str(flags['--itch']), project: str(flags['--project']), out: str(flags['--out']),
+                }, io);
+            }
+            case 'models': {
+                const sub = positionals[0];
+                if (!sub || !MODELS_SUBCOMMANDS.includes(sub)) {
+                    u.error(sub ? `unknown models step: ${sub}` : 'models needs a step', 'funtools models list | models install <local id>');
+                    return EXIT.error;
+                }
+                if (positionals.length > (sub === 'install' ? 2 : 1)) {
+                    u.error(`models ${sub} takes ${sub === 'install' ? 'one model id' : 'no argument'}`, 'funtools models list | models install kokoro-82m');
+                    return EXIT.error;
+                }
+                return await models({ sub, id: positionals[1], force: !!flags['--force'], json }, io);
+            }
+            case 'store': {
+                const sub = positionals[0];
+                if (!sub || !STORE_SUBCOMMANDS.includes(sub)) {
+                    u.error(sub ? `unknown store step: ${sub}` : 'store needs a step', 'funtools store init|doctor|lint|plan [dir] [--store play|ios|steam]');
+                    return EXIT.error;
+                }
+                if (positionals.length > 2) {
+                    u.error(`store ${sub} takes one folder`, `funtools store ${sub} [dir]`);
+                    return EXIT.error;
+                }
+                return await store({ sub, dir: str(flags['--dir']) ?? positionals[1], store: str(flags['--store']), json }, io);
+            }
+            default: {
+                const viewport = str(flags['--viewport']) ?? 'desktop';
+                if (!VIEWPORT_CHOICES.includes(viewport)) {
+                    u.error(`unknown viewport: ${viewport}`, '--viewport is desktop, phone or both');
+                    return EXIT.error;
+                }
+                const players = str(flags['--players']);
+                if (players !== undefined && players !== '2') {
+                    u.error(`--players ${players}`, 'two players is what verify measures: --players 2');
+                    return EXIT.error;
+                }
+                return await verify({
+                    players: players ? 2 : undefined,
+                    target, checks: str(flags['--checks']), manifest: str(flags['--manifest']), sweep: !flags['--no-sweep'], watch: !!flags['--watch'],
+                    json, report: !!flags['--report'], viewport: viewport, frontDoor: frontDoorOf(flags),
+                }, io);
+            }
+        }
+    }
+    catch (e) {
+        const m = message(e), dash = m.indexOf(' — ');
+        u.error(dash < 0 ? m : m.slice(0, dash), dash < 0 ? 'run `funtools doctor` to check the setup; if it repeats, report it with the command you ran' : m.slice(dash + 3));
+        return EXIT.error;
+    }
+}
+const invokedDirectly = () => { try {
+    return !!process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+}
+catch {
+    return false;
+} };
+if (invokedDirectly())
+    process.exitCode = await main(process.argv.slice(2));