@funpixel/tools 0.1.0 → 0.1.1

package/plugins/cursor/skills/funpixel-unity-game/references/handing-off.md

@@ -18,8 +18,8 @@ From the Unity field report, section 14 (agents making Unity games) and the owne
 On what looks fine in its own captures: no sound (captures are silent), settings inherited from a
 cloned project, UI that overflows only at the owner's phone shape, keyboard wording, a level that
 breaks only when reached from the one before, and art that passes every gameplay gate while looking
-like grey blockout (Pocket Crew's Worlds 3 and 4). Then on taste: it adds decoration the owner
-removes (5 reverts in 24 hours on Dawg Ball) and grades its own art favourably. The answer to both is
+like grey blockout (one game's Worlds 3 and 4). Then on taste: it adds decoration the owner
+removes (5 reverts in 24 hours on one game) and grades its own art favourably. The answer to both is
 evidence a person can judge: the real frame at full size against the target and the competitors.
 
 ## What the owner asked for again and again
@@ -28,7 +28,7 @@ evidence a person can judge: the real frame at full size against the target and
 |---|---|
 | "where we are? what's left? how long?" | a tracker updated by tools (step, status, who, clock time), with the session id on every entry |
 | "did you sync to remote?" | push after green checks; rewrite status sections from repo state; a docs-freshness check at the end of each task |
-| "add joydle splash to dawg ball as we did for other games" | carry every studio standard from the start (the studio's packages, `funpixel-unity-game`) and check parity with the sibling games: splash, store fields, Restore placement |
+| "…as we did for other games" | carry every studio standard from the start and check parity with the sibling games: store fields, Restore placement |
 | "no workarounds, remove all leftovers" | a leftover sweep and a comment lint after each change |
 | "What actually you're asking me now?" | a report that ends with at most 3 numbered decisions, each with options, a default and a picture when it is visual |
 | "go do it by yourself" (website, Firebase) | the list of what an agent may do (bundle id, profile, Firebase, an upload with approval) against what only a person does (app record, App Privacy, agreements, the first purchase tick, Submit) |
@@ -36,7 +36,7 @@ evidence a person can judge: the real frame at full size against the target and
 ## What earns trust in a build an agent made
 
 The checks green, the launch with no flags clean, the smoke run reaching an ending on a stripped
-build, the archive pre-flight passed, and the owner's own 15-minute session on a phone. Pocket Crew's
+build, the archive pre-flight passed, and the owner's own 15-minute session on a phone. One game's
 build 1 was "mostly liked" and still unshippable: a production gate (fresh install, every level
 through the real flows, 7 kill-and-relaunch cycles, every setting persisted) found 4 more bugs behind
 1,377 green tests. A hand-off with a dirty worktree is refused: commit by path first.

package/plugins/cursor/skills/funpixel-unity-game/references/performance.md

@@ -4,10 +4,6 @@ This skill turns a performance worry into a number measured in the player, befor
 
 ## Tools
 
-- The studio's `com.joydle.core` (`funpixel-unity-game`, `studio-packages.md`): every
-  `BuildTools` build applies the size settings (stripping High, engine stripping, IL2CPP OptimizeSize);
-  `ProjectSettings/JoydleLz4hc.txt` turns on LZ4HC; `JoydleSplash` holds on black until the first
-  scene has loaded and 10 smooth frames pass.
 - `npx @funpixel/tools unity probe --target mac|sim --path path.json`: the kit's in-player probe
   (`com.funpixel.probe`, added by `unity probe install`; development builds only). It builds or reuses
   the player through the Unity queue, plays the path, reads `ProfilerRecorder` per frame (frame, main,
@@ -29,10 +25,10 @@ This skill turns a performance worry into a number measured in the player, befor
 | Frame rate | 60 fps locked on iPhone 11 (A13); 120 Hz on ProMotion only when cool; menus 30 fps | |
 | Frames | first entry to a screen or level under 34 ms; none over 20 ms after warm-up; p99 at most 17.5 ms | `unity probe` |
 | GC | 0 B per warm sim step or quiet frame | `alloc_quiet` |
-| Draws, triangles | 120 and 250k per view (Pocket Crew, a 3D platformer) | |
+| Draws, triangles | 120 and 250k per view (a 3D platformer) | |
 | Behind a full-screen menu | 0 world cameras or passes; 1 pass in play | `invisible_work` |
 | Look | `RenderSettings` and shared materials identical before and after each level and warm-up | `look_leak` |
-| Unpacked `.app` | 2D 80 MB, 3D 100 MB, engine 45 MB, at most 2 MiB unexplained growth per build (proposed; Dead Letter, 2D, is 133 MB) | `size_budget` |
+| Unpacked `.app` | 2D 80 MB, 3D 100 MB, engine 45 MB, at most 2 MiB unexplained growth per build (proposed; one 2D game is 133 MB) | `size_budget` |
 | `Resources/` | 0 bytes of test-only or Editor-only files | `resources_hygiene` |
 | Memory | 117–174 MB was measured; a budget is not in the report | |
 
@@ -40,24 +36,24 @@ Per tier (phone, tablet, Mac): `unity probe --tier`, from `probe.md`.
 
 ## Procedure
 
-1. Measure in a player build, with `unity probe`. Editor draws read 134–151 against 74–114 in the player. Under URP draws read 0 in some players (Particle Rush), so read SetPass calls too.
+1. Measure in a player build, with `unity probe`. Editor draws read 134–151 against 74–114 in the player. Under URP draws read 0 in some players, so read SetPass calls too.
 2. Attribute each slow frame before fixing it: game work, GC, the host Mac, or your own screenshot. A `ScreenCapture` costs 100–130 ms, and it and a Mac at load 36 were blamed on the game twice; game work in those frames was 0.4–0.7 ms. The probe reports hitches with their own work and skips 4 frames after each capture.
 3. Fix first-use stutters. Put every level id in the warm queue; warm glyphs, the first level's shaders (a ShaderVariantCollection, never `Shader.WarmupAllShaders`) and sounds behind the title; build the next level while a menu is up. Then run `look_leak`, since a warm-up can leave global state changed.
 4. Turn off invisible work: no world drawn behind opaque menus, and menus at 30 fps.
 5. Take allocations to 0 B. Use flat `struct` events in a reused list, no LINQ, closures or string building per frame, and rebuild text only on change. Measure in a release player, since 30–200 B per frame in the dev player is engine-side.
-6. Load: hold the splash on black until the scene is loaded and 10 smooth frames pass (1 s minimum, 3 s cap; `JoydleSplash` does). Async-preload each screen's textures while loading, and prewarm a throwaway run behind the title: The Hot Gates' Play tap went from 87 to 1.9 ms.
-7. Heat and battery: poll thermal state and Low Power Mode every 2 s. Hot or Low Power drops render scale from 0.83 to 0.66; critical caps matches at 30 fps; 120 Hz only when cool, falling back with a doubling back-off. Keep MSAA fixed, because changing it at runtime recompiled every pipeline state in Pocket Crew (a 1.5 s frame). Turn off Unity's own thermal frame-rate adjust: two controllers on one knob.
+6. Load: hold the splash on black until the scene is loaded and 10 smooth frames pass (1 s minimum, 3 s cap). Async-preload each screen's textures while loading, and prewarm a throwaway run behind the title: one game's Play tap went from 87 to 1.9 ms.
+7. Heat and battery: poll thermal state and Low Power Mode every 2 s. Hot or Low Power drops render scale from 0.83 to 0.66; critical caps matches at 30 fps; 120 Hz only when cool, falling back with a doubling back-off. Keep MSAA fixed, because changing it at runtime recompiled every pipeline state in one game (a 1.5 s frame). Turn off Unity's own thermal frame-rate adjust: two controllers on one knob.
 8. Size: measure the unpacked `.app` from the archive, with a delta against the last build. Apply the size settings (stripping High, engine stripping, IL2CPP OptimizeSize), then LZ4HC. Keep test files out of `Resources/`: the Unity test runner drops `PerformanceTestRun*.json` there, and it ships.
 9. Report every claim as before and after. The owner's direction ("ensure the performance is top") became `frame_budget` and `invisible_work` in every round.
    The fixes that gave the most, each with its before and after: `fixes.md`.
 
 ## Worked example
 
-The Hot Gates, the whole seed-7 run. Over 17,246 frames, frames over 34 ms went from 17 to 2 and the worst frame from 98.4 to 19.0 ms; p99 was 18.2 ms. Warming shaders, pipeline states and the Vase grab on the first frames took the worst frame of the "tide" (a moment the report does not define) from 249 to 18.6 ms. The last 48 ms hitch was a missing glyph, and the last allocation was a "+N" badge string; the game holds 0 B over 600 frames. The quality governor now judges the median of 90 frames, so one hitch no longer drops a resolution rung.
+A port from three.js, the whole seed-7 run. Over 17,246 frames, frames over 34 ms went from 17 to 2 and the worst frame from 98.4 to 19.0 ms; p99 was 18.2 ms. Warming shaders, pipeline states and the Vase grab on the first frames took the worst frame of the "tide" (a moment the report does not define) from 249 to 18.6 ms. The last 48 ms hitch was a missing glyph, and the last allocation was a "+N" badge string; the game holds 0 B over 600 frames. The quality governor now judges the median of 90 frames, so one hitch no longer drops a resolution rung.
 
 ## Common mistakes
 
-- A short warm list. Pocket Crew warmed World 1 only, so World 2 started with a 398 ms hitch.
-- A warm-up that leaves global state changed. Pocket Crew's left fog and sky altered and every launch flashed violet for about 1 s; another kept references, so movers drew frozen.
-- Reading "Complete build size": in Hot Gates it was the Xcode project.
-- Test files in `Resources/`. Pocket Crew's release export carried about 1 MB of test reference meshes.
+- A short warm list. One game warmed World 1 only, so World 2 started with a 398 ms hitch.
+- A warm-up that leaves global state changed. One game's left fog and sky altered and every launch flashed violet for about 1 s; another kept references, so movers drew frozen.
+- Reading "Complete build size": in one game it was the Xcode project.
+- Test files in `Resources/`. One game's release export carried about 1 MB of test reference meshes.

package/plugins/cursor/skills/funpixel-unity-game/references/probe.md

@@ -1,10 +1,10 @@
 # Measuring the player: com.funpixel.probe and funtools unity probe
 
-Five games each wrote a probe of their own: Knockout Lap's `HitchProbe`, Particle Rush's `PerfProbe`, The Hot Gates' `PerfRecorder`, Pocket Crew's `PerfProbe` and `Hitch`, and Gallery Heist's. Pocket Crew also wrote a 661-line `RemotePlay.cs` for input over TCP. The kit now ships one package with both halves. Don't write another probe; give the package your game's facts instead.
+Five games each wrote a probe of their own (`HitchProbe`, `PerfProbe`, `PerfRecorder`, `PerfProbe` and `Hitch`, and one more). One of them also wrote a 661-line `RemotePlay.cs` for input over TCP. The kit now ships one package with both halves. Don't write another probe; give the package your game's facts instead.
 
 ## Getting it into a project
 
-`npx @funpixel/tools unity probe install --project <dir>` adds one line to `Packages/manifest.json` and prints it. The line is a `file:` path to the kit's copy, relative to `Packages/`, the way the studio's games reference `com.joydle.core`. Pass `--git <url> --ref <tag>` for a pinned git URL; an unpinned one is refused. `--tests` also lists the package under `testables`; leave it off on a game whose test count is a baseline. `unity probe uninstall` takes the line out. Nothing is installed silently: `probe`, `play` and `capture` refuse a project without the line and say how to add it.
+`npx @funpixel/tools unity probe install --project <dir>` adds one line to `Packages/manifest.json` and prints it. The line is a `file:` path to the kit's copy, relative to `Packages/`, the way a game references a local package. Pass `--git <url> --ref <tag>` for a pinned git URL; an unpinned one is refused. `--tests` also lists the package under `testables`; leave it off on a game whose test count is a baseline. `unity probe uninstall` takes the line out. Nothing is installed silently: `probe`, `play` and `capture` refuse a project without the line and say how to add it.
 
 What reaches a store build: nothing. The player assembly (`Funpixel.Probe.Player`) has define constraints `DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE` and `!FUNPIXEL_NO_PROBE`. The game calls `FunpixelProbe`, whose methods are `[Conditional]`, so in a release build the calls and their arguments are compiled away. `FUNPIXEL_PROBE` exists only for the capture build (below), and the package's build guard fails any build whose Player Settings carry it.
 
@@ -53,7 +53,7 @@ Left out, and counted: the first 30 frames of the path, every capture frame and
 | tablet | 17.5 ms | 20 ms | 34 ms | 160 | 200 | 400k | 256 B | 1536 MB |
 | mac | 17.5 ms | 20 ms | 34 ms | 400 | 400 | 4M | 256 B | 3072 MB |
 
-The frame numbers are `frame_budget`; draws and triangles are Pocket Crew's per view; SetPass and memory are Particle Rush's tiers. The GC line allows the 30–200 B a development player allocates in the engine. Judge 0 B (`alloc_quiet`) in a release player or in tests. A Mac target is judged as `mac`, and a Simulator as `phone` or `tablet` by its device name. `--tier` and `--budget '{"draws": 200}'` (or a file, one budget per tier) override this.
+The frame numbers are `frame_budget`; draws and triangles are one game's per view; SetPass and memory are another's tiers. The GC line allows the 30–200 B a development player allocates in the engine. Judge 0 B (`alloc_quiet`) in a release player or in tests. A Mac target is judged as `mac`, and a Simulator as `phone` or `tablet` by its device name. `--tier` and `--budget '{"draws": 200}'` (or a file, one budget per tier) override this.
 
 Three states, as on the web: a number the player did not report is "not observed", never a pass. A run under 120 measured frames does not judge frame time.
 
@@ -68,7 +68,7 @@ A Simulator, or a Mac at load 36 or more, adds single long frames the game did n
 - `play key Space`, `play pad south` and `play act "stick 1 0 800"`;
 - `play state`, `play ui` (every pressable thing with its rect), `play views` and `play scene Level2`;
 - `play shot --out f.png`, upright at full resolution;
-- `play record --seconds 10`: frames plus a WAV of the game's own mix, through Unity's offline `AudioRenderer` after Floe Jam's `Recorder.cs`, joined into an MP4 when ffmpeg is there;
+- `play record --seconds 10`: frames plus a WAV of the game's own mix, through Unity's offline `AudioRenderer` after one game's `Recorder.cs`, joined into an MP4 when ffmpeg is there;
 - `play end`.
 
 Input goes in as Input System device state (touch, mouse with `--mouse`, keyboard, pad), so it takes the path a finger takes.

package/plugins/cursor/skills/funpixel-unity-game/references/shared-mac.md

@@ -8,7 +8,7 @@ now has one of each, shared by every session of this user on the Mac.
 ## Unity: `funtools unity run`
 
 ```
-funtools unity run -- -nographics -buildTarget iOS -executeMethod Joydle.Core.Editor.BuildTools.SimulatorDev
+funtools unity run -- -nographics -buildTarget iOS -executeMethod Setup.BuildSimulator
 funtools unity run --project ../my-game -- -nographics -runTests -testPlatform EditMode -testResults results.xml
 funtools unity jobs
 ```

package/plugins/cursor/skills/funpixel-unity-game/references/traps.md

@@ -12,14 +12,14 @@ starts Unity, and prints each finding with its fix. One line per trap it catches
 - Git LFS pointer files where binaries belong (FSBTool "Failed decoding audio clip", blank textures): fails, names the repository to pull in.
 - `activeInputHandler: 0`, the old Input Manager alone, on an iOS or Android project (no touch in a player build): fails.
 - `UnityEngine.Input` calls on a project set to the Input System only (each throws): fails.
-- The Input System hooked at `AfterAssembliesLoaded` (throws on iOS; `BackButton` hooks on first read): warns.
+- The Input System hooked at `AfterAssembliesLoaded` (throws on iOS; hook on first read): warns.
 - TextMesh Pro used with no Essential Resources (`CreateFontAsset` returns null): fails; a batch-mode ImportPackage of them (hangs): warns.
-- A camera in a scene or made in code with nothing adding an AudioListener (a silent build; `Sfx.EnsureListener()`): warns.
+- A camera in a scene or made in code with nothing adding an AudioListener (a silent build): warns.
 - `Shader.WarmupAllShaders` (segfaults with URP keyword spaces; warm a ShaderVariantCollection): fails on URP.
 - A GLB glTFast cannot decode (meshopt, Draco or Basis without its decoder package, WebP ever): fails, because it imports as nothing.
 - `Shader.Find` of a project shader nothing references (null in a build): warns.
 - `enableWordWrapping`, a bare `new RenderParams{}`, runtime `QualitySettings.antiAliasing`, `-quit` with `-runTests`: warn.
-- ProjectSettings drifted from the project's setup method (Knockout Lap's iOS graphics APIs went back to automatic three times): warns; build through `Setup.Configure`.
+- ProjectSettings drifted from the project's setup method (one game's iOS graphics APIs went back to automatic three times): warns; build through `Setup.Configure`.
 - A build module a target needs (Mac IL2CPP and Windows were missing): warns with the Unity Hub line.
 - No distribution certificate, Xcode account or App Store Connect key on an iOS project (each blocks TestFlight): warns.
 
@@ -29,31 +29,30 @@ starts Unity, and prints each finding with its fix. One line per trap it catches
   says nothing about it (`funpixel-art`, Unity page).
 - glTFast decodes textures embedded in a GLB to RGBA32; its "latest" tag pointed at an experimental
   7.0, so pin 6.20 (`funpixel-3d`, Unity page).
-- `UnityRuntime.framework`'s plist says iOS 15.0 and its binary 16.0: ITMS-90208 (`IosPostprocess`).
+- `UnityRuntime.framework`'s plist says iOS 15.0 and its binary 16.0: ITMS-90208: stamp each embedded framework's minimum OS with the app's in a post-process step.
 - High stripping removes an assembly reached only through `RuntimeInitializeOnLoadMethod`, and Unity
-  ignores a package's own `link.xml` (`com.joydle.firebase` hands its file to the linker).
+  ignores a package's own `link.xml` (hand that file to the linker yourself).
 - TMP outline and underlay variants of materials made at runtime are stripped, and so are
   `shader_feature` variants: use `multi_compile_local`.
 - TMP lives in uGUI 2.x, not a package of its own; its Essential Resources still go in `Assets/TextMesh Pro`.
 - Burst can time out under heavy host load; never ship that export.
 - Re-importing an atlas regenerates sprite ids, and a PNG of a new size keeps the old sprite rect, so
   Unity drops the sprite.
-- iOS caches launch storyboards by name across updates: rename the storyboard (`JoydleLaunch`).
+- iOS caches launch storyboards by name across updates: rename the storyboard.
 - A project can be URP with `GraphicsSettings` saying none: the monorepo games assign the URP asset only
-  in `QualitySettings` (`m_CustomRenderPipeline: {fileID: 0}`), while Knockout Lap, Gallery Heist and
-  Particle Rush set it in `GraphicsSettings`. Read both before calling a project built-in; Floe Jam is
-  the one that is.
+  in `QualitySettings` (`m_CustomRenderPipeline: {fileID: 0}`), while others set it in
+  `GraphicsSettings`. Read both before calling a project built-in.
 - A WebGL build compressed with Brotli fails on a phone over the Mac's LAN address
   (`ERR_CONTENT_DECODING_FAILED`: Brotli needs https or localhost): serve it with `funtools serve`,
   which falls back to gzip there.
 - Addressables bundles built uncompressed (for a CDN to Brotli) weigh about twice as much from a
-  server that sends them raw (Gallery Heist's Room 1: 99.7 MB against 47.3 MB). `funtools serve`
+  server that sends them raw (one game's Room 1: 99.7 MB against 47.3 MB). `funtools serve`
   compresses them on the fly as a CDN would, so its sizes and load times are what a player gets;
   `--no-compress` shows the raw weight.
 
 ## Runtime
 
-- Mono never sees `simctl launch` arguments: read them natively (`LaunchArgs.Get()`).
+- Mono never sees `simctl launch` arguments: read them natively.
 - PlayerPrefs reads the launch-argument domain first: a flag `-coins` shadows the save key `coins`.
 - A Unity API call in a field initializer throws: move it to `Start`.
 - `OnApplicationPause(true)` also fires on resign-active (Control Center, Siri, call banners, Face ID).
@@ -64,7 +63,7 @@ starts Unity, and prints each finding with its fix. One line per trap it catches
 - `Screen.cutouts` allocates on every call: read it when the screen changes.
 - `preserveAspect` fits around the pivot; a `Slider` stretches to the row height; stretch anchors
   plus a non-zero `sizeDelta` double the width.
-- The first scene load can eat about 1 s of a startup animation (`JoydleSplash` waits for it).
+- The first scene load can eat about 1 s of a startup animation (wait for it before one starts).
 - Unity 6 renamed the draw-call profiler counter, so an old probe reads 0.
 - C# `Math.Round` is banker's rounding, `List.Sort` is unstable, `Math.Sin` differs from V8 on about
   6% of inputs and a naive hypot on about 40% (`references/from-a-web-game.md`).
@@ -75,7 +74,7 @@ starts Unity, and prints each finding with its fix. One line per trap it catches
 - `Object.Destroy` does nothing in edit-mode captures: use `DestroyImmediate`.
 - `CaptureScreenshotIntoRenderTexture` is upside down on Metal, and `ScreenCapture` stalls the next
   frames.
-- Frames a judge scores come from a capture rig, not the Editor (Particle Rush, Oct 2026):
+- Frames a judge scores come from a capture rig, not the Editor (Oct 2026):
   - a player build with a scripting define that turns the launch flags on and is not a development
     build, because a development build stamps its watermark and console into every frame;
   - `-shotscale 2` (passed to `ScreenCapture.CaptureScreenshot`'s supersize) for a full-resolution phone
@@ -97,7 +96,7 @@ starts Unity, and prints each finding with its fix. One line per trap it catches
 - TMP dynamic font assets are rewritten by every batch run and conflict on every merge: keep shipped
   fonts static, or clear them after captures.
 - The root `.gitignore`'s `*.csproj` silently drops hand-written test and server projects.
-- A copied project keeps its source's identity: Particle Rush's `.gitattributes` names The Hot Gates'
+- A copied project keeps its source's identity: one game's `.gitattributes` names its source's
   paths, its Android id is still Unity's template `com.UnityTechnologies…urpblank`, and standalone ids
   are left as `com.DefaultCompany.2D-URP`. Check the ids and `.gitattributes` against the game's name.
 

package/plugins/cursor/skills/funpixel-verify/references/bar.md

@@ -39,7 +39,7 @@ the skeptic."). Each seat scores the same seven axes and overall; the persona de
 **Blind** means each seat gets what the calibrated panel gets: the frames, a store description, the
 five AD rules, the screen audit's numbers and its own previous verdict, and nothing else: no design
 note, no target frame, no verify summary, no builder's explanation, no other seat's scores, no code.
-On the same Lanternfall frames, seats briefed with the note and the builder's summary scored 7.10 where
+On the same frames of one game, seats briefed with the note and the builder's summary scored 7.10 where
 blind seats scored 6.90 (Sonnet, one panel each), and the whole in-loop panel ran 0.6 above the
 calibrated anchored one, which also saw the payoff frame.
 

package/plugins/cursor/skills/funpixel-verify/references/fidelity.md

@@ -1,7 +1,7 @@
 # Plan fidelity: what was planned against what was built
 
-The critic panel never sees the plan, so it cannot see that the game drifted from it. Held Note (a
-third-person horror chapter, the Held Note lane, 29 Sep 2026) scored 6.55 overall and 7.62 on look
+The critic panel never sees the plan, so it cannot see that the game drifted from it. A
+third-person horror chapter (29 Sep 2026) scored 6.55 overall and 7.62 on look
 from the panel; a blind judge holding the same build against its own GDD gave art direction 4 and
 creative direction 3, and named what the panel could not: the thesis frame's fingers missing from
 the seam, the first walker at arm's length instead of far down the corridor, a stencil colour that
@@ -42,18 +42,18 @@ the reason, never scored.
 drew, the splice as it completes, the merge at its pop. A view whose `enter()` replays a recorded run
 to that beat (the playtest reference's `game.replay.seek('first-walker')`), or a journey mark placed
 at it, lands there on every build; a clock time drifts the first time the level changes. Two of our
-own fallback pairs show the cost: Plush Pop's play view was captured with an empty basket, so the
-seat could only say the target's pile and squish were missing; Gesundheit's was captured before
+own fallback pairs show the cost: one game's play view was captured with an empty basket, so the
+seat could only say the target's pile and squish were missing; another's was captured before
 any sneeze, so the flowers the target promises were not on the ground.
 
 **Or pin it to a time on the saved route, and name both.** From the first playtest on, the blind
 player's steps are kept as the route (`test/journeys/playtest-route.json`) and every playtest replays
 it with the same viewport and seed. A game frame `at 1:00` (or a moment written `1:00 the first
 walker`) is the route's frame at that time on the script's own clock: like with like every round,
-as Held Note's films were (0:10, 1:00, 2:00, 3:00, 5:00). A row that names both, `at 1:00, view
+as the horror chapter's films were (0:10, 1:00, 2:00, 3:00, 5:00). A row that names both, `at 1:00, view
 firstWalker`, is judged on the played frame, and the view stays beside it as the staged frame. When
 the played route never reaches what a staged view or a lane's file shows (no moment, screen or beat
-by that name in play), the report says so: Held Note's Diver was showcase art in its lane's frame
+by that name in play), the report says so: the horror chapter's diver was showcase art in its lane's frame
 and "a few coral points" in play. A moment past the route's end is play that never got there. Keep
 the route while the level holds; when the level changes, record a new one (`journey record
 playtest-route --force`) and read the history's next column as a new baseline, which the report marks.
@@ -77,8 +77,8 @@ Borrowed, with credit, from Scenario's quality skills (MIT; research 06 §2.2–
 
 ## The plan's interface: UI and UX as imagined or not
 
-The owner's second question, from the Held Note lane: is the interface the one the plan designed?
-Held Note's GDD draws its phone HUD and its message screen as HTML at 852 × 393, each element
+The owner's second question, from that game's lane: is the interface the one the plan designed?
+Its GDD draws its phone HUD and its message screen as HTML at 852 × 393, each element
 numbered with a line of spec ("1 collar ring: health, five cyan lights"; "nothing sits in the middle
 of the screen"). When a GDD has such mockups (a `.phone` or `[data-mockup]` element in any page under
 `design/`, the first look's `hud.html` first), `funtools playtest` renders each as an element
@@ -102,7 +102,7 @@ a dodge never taught). Per screen it scores ui (layout, what sits on the charact
 glass, sizes, the visual language) and ux (does it work as intended); each numbered element held,
 partly or missing; what the game adds that the plan does not have, and whether each serves or fights
 the plan's rules; then UI and UX fidelity and five changes. The report puts them beside the art
-seat's scores and ranks the changes, a missing planned element first. On Held Note's two mockups
+seat's scores and ranks the changes, a missing planned element first. On that game's two mockups
 it gave UI 5 and UX 4: of 15 planned elements 3 held, 8 partly and 4 missing, and four additions
 (a tutorial line at top centre, a permanent minimap) fought "nothing sits in the middle".
 
@@ -112,8 +112,8 @@ The report puts art direction and creative direction beside the last round, each
 ranks the seat's changes among the next steps (a broken rule first). A low creative score with a
 held look usually means the moment was shot at the wrong time or the frame's subject is missing;
 fix the view or the moment before the art. When three of our games were judged against their
-single target frame, Lantern Night kept its palette and lantern design (art 8) but lost the wheel of
-lanterns and the visible chain (creative 6); Plush Pop built the target's set but not its round felt
+single target frame, one kept its palette and lantern design (art 8) but lost the wheel of
+lanterns and the visible chain (creative 6); another built the target's set but not its round felt
 critters or the squish (5 and 3, AD-1 broken).
 
 ## After a greenlight lock: reference-match rounds

package/plugins/cursor/skills/funpixel-verify/references/mobile-qa.md

@@ -1,7 +1,7 @@
 # Mobile QA: is it native to a phone?
 
 The critic panel scores stills (each seat re-reading the phone captures), and the blind player plays by touch.
-Neither asks whether the game was made for the phone it runs on. Floe (an ice-slide puzzle, round 3,
+Neither asks whether the game was made for the phone it runs on. An ice-slide puzzle (round 3,
 29 Sep 2026) scored mobile 7 and up from the panel and passed its blind phone round, and the owner
 opened it on an iPhone simulator and saw desktop thinking: the board under half the screen, four
 large on-screen arrows repeating the swipe the board already took, Undo/Restart/Hint panels in the
@@ -95,24 +95,24 @@ showed once, plainly, and prefixes one only some showed with them, "[iOS Safari
 
 ## Calibration (29 Sep 2026)
 
-Floe round 3 (read-only copy) and Drift, a scratch swipe puzzle made phone-first for this (swipe
+An ice puzzle's round 3 (read-only copy) and Drift, a scratch swipe puzzle made phone-first for this (swipe
 anywhere, board 75% of the screen, one undo button bottom-left, pause top-right), each through one
 seat, real Mobile Safari in both orientations:
 
 | Game | Seat | Phone-native | High findings |
 |---|---|---|---|
-| Floe R3 | Opus-class | 5 | controls (four arrows repeat the swipe), play-share (board ~48%) |
-| Floe R3 | Opus-class, second run | 6 | controls (arrows repeat the swipe; board ~37% of the screen) |
-| Floe R3 | Sonnet-class | 4 | controls, play-share (board ~40%) |
-| Floe R3 | Opus-class, with the window sweep | 6 | controls (arrows repeat the swipe; board ~44%) |
+| Ice puzzle R3 | Opus-class | 5 | controls (four arrows repeat the swipe), play-share (board ~48%) |
+| Ice puzzle R3 | Opus-class, second run | 6 | controls (arrows repeat the swipe; board ~37% of the screen) |
+| Ice puzzle R3 | Sonnet-class | 4 | controls, play-share (board ~40%) |
+| Ice puzzle R3 | Opus-class, with the window sweep | 6 | controls (arrows repeat the swipe; board ~44%) |
 | Drift | Opus-class | 8 | none (landscape board small: medium) |
 | Drift | Sonnet-class | 7 | none |
-| Plush Pop R3 | Opus-class, with the window sweep | 6 | none; medium: left/right/Drop buttons beside a drag the basket takes, the basket ~35% of the Mobile Safari page, landscape a squeezed sidebar |
+| Basket game R3 | Opus-class, with the window sweep | 6 | none; medium: left/right/Drop buttons beside a drag the basket takes, the basket ~35% of the Mobile Safari page, landscape a squeezed sidebar |
 
-The first-paint times of the window sweep ran 2.5–7.7 s for Floe on a machine at load 50–60: read
+The first-paint times of the window sweep ran 2.5–7.7 s for the ice puzzle on a machine at load 50–60: read
 them against runs made the same way, as the profile's numbers.
 
-The funtools scaffold is gesture-first since the Riad Rush phone round: a swipe on the play steps,
+The funtools scaffold is gesture-first since one game's phone round: a swipe on the play steps,
 a tap or swipe up hops, and its on-screen buttons are a setting, off by default.
 
 ## Sources
@@ -120,4 +120,4 @@ a tap or swipe up hops, and its on-screen buttons are a setting, off by default.
 - The harness's mobile reviewer: `mobile_review.txt` (severity discipline, plan as intent),
   `quirks_mobile.txt` (thumb zones, targets, safe areas), `sections/base/mobile.txt`.
 - Skill `funpixel-mobile-ui`, `references/phone-check.md`: the 28 phone fixes and the four looks.
-- Floe's round 3 and the owner's look at it on an iPhone simulator.
+- The ice puzzle's round 3 and the owner's look at it on an iPhone simulator.

package/plugins/cursor/skills/funpixel-verify/references/playtest.md

@@ -2,11 +2,11 @@
 
 A playtest is the mirror held up between creator rounds: free measurements, three blind critics and
 a blind phone player look at the same build, and a short ranked list says what stands between this
-round and the next. It applies nothing. This page is what the Held Note lane learned running that
+round and the next. It applies nothing. This page is what one game's lane learned running that
 loop on a survival-horror chapter in Three.js (29 Sep 2026): what made the evidence trustworthy,
 what misled once, and what the person read. Take what fits your game.
 
-Held Note, round by round, same panel words and bar:
+That game, round by round, same panel words and bar:
 
 | Round | Overall | Look and feel | What happened |
 |---|---|---|---|
@@ -33,12 +33,12 @@ does scores it kinder (0.2 in the calibration): the separation is the instrument
 |---|---|---|
 | free measures | the build | numbers nobody argues with: HUD cover, text size, contrast, ΔE, frame time, verb timings |
 | three critic seats | premise, frames, facts | three personas notice different things; each re-reads the phone captures (no mobile seat) |
-| blind phone player | premise, the screen, touch | the only seat that plays: it finds what stills cannot (Held Note: the camera entering walls, a tell too short to see on a muted phone, a tap that cut nothing and showed nothing) |
+| blind phone player | premise, the screen, touch | the only seat that plays: it finds what stills cannot (one game: the camera entering walls, a tell too short to see on a muted phone, a tap that cut nothing and showed nothing) |
 | report | all of the above | ranks what blocks a new player first, then what several seats asked for, weighted by where the game trails its genre hit most, so one loud seat does not set the agenda |
 
 ## The loop, round after round (the default)
 
-Held Note's v1 → v4 pages were worth reading because the instrument stayed the same; `playtest`
+That game's v1 → v4 pages were worth reading because the instrument stayed the same; `playtest`
 runs that loop by default, and a round can run less.
 
 - **One route, one camera.** The first blind round's steps become the saved route; later playtests
@@ -54,7 +54,7 @@ runs that loop by default, and a round can run less.
 
 ## Look at the captures before you trust a score
 
-Held Note's first v2 round scored 4.9, and the seats were right about what they were shown. When the
+Its first v2 round scored 4.9, and the seats were right about what they were shown. When the
 game was split into modules, the capture hooks reached the game through a loose cast; the replay
 cursor and the intro timer had moved, the cast hid it, and every view's fast-forward silently left
 the game at t = 0 behind the opening shot. Twenty frames of the title card's camera, scored as a
@@ -91,27 +91,27 @@ export function views(game: Game) {
 - **Name the actors so the instruments find them.** `look --read` measures the player and the
   threats against the ground around them. Name each actor's root node `player-…` or `threat-…`
   (or set `userData.role`); once a scene tags a role, only tagged nodes play it. Without tags it
-  falls back to the usual words, which in Held Note took a prop, `hazard_barrier`, as a threat, and
+  falls back to the usual words, which in that game took a prop, `hazard_barrier`, as a threat, and
   the seats read "threat ΔE 0.7, weakest hazard_barrier at ΔE 0.5". Read the line `look --read` prints per role (how it found the
   role, the nodes it took) before reading its number.
 - **Wire `feel` early.** Expose `hero { x, y, grounded, unit, vx, state, invulnerable }`,
   `threats [{ id, phase }]` with a tell and a strike phase, `dead` and `control` in `__FPX_STATE__`,
-  and write `test/feel.json` (skill `funpixel-game-feel`, references/measure.md). It read Held
-  Note's dodge back from real key presses: 1.92 m in 0.30 s against the design's 2.0 m in 0.26 s,
+  and write `test/feel.json` (skill `funpixel-game-feel`, references/measure.md). It read one
+  game's dodge back from real key presses: 1.92 m in 0.30 s against the design's 2.0 m in 0.26 s,
   untouchable for 0.217 s against 0.21. Its script never reached a walker, so the tell, the death
   beat and the restart stayed "not measured": a script that walks to the first threat is what
   measures the fight.
 - **Run `feel` twice.** The first run's long frame (a warm-up shader compile) moved the wall-clock
   windows; one run's dodge hit the rail. Two runs that agree are a measurement; one is an anecdote.
 - **Faded screens.** The HUD judge and the phone audit skip what a faded or hidden ancestor hides.
-  Held Note's chapter card, faded to opacity 0 but still on the page, once counted as HUD all
+  One game's chapter card, faded to opacity 0 but still on the page, once counted as HUD all
   chapter (41% of the play); taking faded layers out of the page after their fade also keeps them
   from screen readers.
 
 ## Films that show the game
 
 A still cannot carry a fight, so the review page leads with one filmed run: a bot on the real
-controls, nothing staged. Bots that only walk the route make films with no combat: Held Note's
+controls, nothing staged. Bots that only walk the route make films with no combat: one game's
 route bots never fired the driver or used the knife, so no film showed the weapons the owner asked
 for. A film-only `fighter` bot style that plays the verbs a keen player would fixed it, while the
 tests keep the median bot, because tests measure a typical player and a film shows what the game
@@ -122,7 +122,7 @@ rebuild partway through a round leaves late steps on newer code (say so when it
 ## What the review page carries
 
 `playtest report` writes `report.md`: the ranked steps, this round against the last and the genre
-hit, what each seat said, the measures and the cost. The page Held Note's owner read added what
+hit, what each seat said, the measures and the cost. The page that game's owner read added what
 only the creator can assemble, and each part earned its place:
 
 1. **The score against the last round**, overall and look-and-feel, the seats' scores, each
@@ -139,8 +139,8 @@ only the creator can assemble, and each part earned its place:
    (a script that never reached a walker is a finding about the script, not a pass).
 8. **Target frames against the game**: each GDD target frame beside the same beat in the game,
    one line each, "Close" or "Right idea", then what is missing.
-9. **A pillar audit against the GDD**: each pillar graded, what matches, what still drifts. Held
-   Note found requests made mid-build ("add guns", "make her faster") had quietly broken stated
+9. **A pillar audit against the GDD**: each pillar graded, what matches, what still drifts. One game
+   found requests made mid-build ("add guns", "make her faster") had quietly broken stated
    pillars; re-reading the pillars after each request folded them back in.
 10. **The critics in their own words**: each seat's one-line quote and its overall.
 11. **The blind round**: the steps where it struggled, as frames, its verdict and the caveats.
@@ -153,7 +153,7 @@ The kit does not build this page yet: `report.json` holds the numbers, `frames/`
 
 ## When the numbers disagree with your eyes
 
-Trust neither alone. Held Note's threat read ΔE 0.7 on the phone, part of it measured on a prop, and
+Trust neither alone. One game's threat read ΔE 0.7 on the phone, part of it measured on a prop, and
 the critics independently called the walkers hard to read in the dark; the step stood on the
 critics and the frames: light the dark a notch. When a
 number says pass and the frames look wrong, the instrument may be measuring the wrong thing (the

package/plugins/cursor/skills/funpixel-verify/references/unity.md

@@ -1,16 +1,16 @@
 # Proving a Unity build plays
 
-This skill is the order of checks that shows a build boots, plays to a win and a loss, and logs no exception. The failure it prevents is trusting what a capture shows: a Dawg Ball tour log held 321 exceptions while every screenshot looked fine, and Pocket Crew's first TestFlight build drew every moving platform frozen after the first level, behind 1,118 green tests. A check sees only the path it runs, so these steps run the paths players take.
+This skill is the order of checks that shows a build boots, plays to a win and a loss, and logs no exception. The failure it prevents is trusting what a capture shows: one game's tour log held 321 exceptions while every screenshot looked fine, and another's first TestFlight build drew every moving platform frozen after the first level, behind 1,118 green tests. A check sees only the path it runs, so these steps run the paths players take.
 
 ## Tools
 
 Not shipped by the kit: the Unity starter, its one `check` command (exit codes 0 pass, 1 fail, 2 not observed, 3 error), the checks below and the studio scripts they were learned with (`unity_check.py`, `unity_sim.sh`, `smoke_sim.sh`, `pcplay.py`, `testflight.sh`'s pre-flight, per-game smoke, remote-play and perf scripts) are proposed. Until the starter ships, run each step with what exists:
 
-- Compile and test: `dotnet build` and `dotnet test` on the engine-free core (its `CoreTests~` project; Unity ships a `dotnet` under `Contents/Resources/Scripting/DotNetSdk/`), and Unity's test runner for the rest: `funtools unity run -- -nographics -runTests -testPlatform EditMode -testResults results.xml` (the machine-wide queue: one run per project across agents; never with `-quit`: the test runner exits by itself). Play Mode tests run the same way with `-testPlatform PlayMode`; Floe Jam's `unity/build.sh test` runs Edit Mode then Play Mode (`FloeJam.PlayTests`) and reads the NUnit XML, the only project that does.
-- Build for the Simulator with the studio's `com.joydle.core` (funpixel-unity-game, `references/studio-packages.md`): `funtools unity run -- -nographics -buildTarget iOS -executeMethod Joydle.Core.Editor.BuildTools.SimulatorDev` (a development build: its dev flags and test ads work; `Simulator` is the stripped release build), then `xcodebuild -project Unity-iPhone.xcodeproj -scheme Unity-iPhone -sdk iphonesimulator build`; install and launch on a Simulator of your own (`udid=$(funtools sim lease)`) with `xcrun simctl install $udid <app>` and `xcrun simctl launch --console-pty $udid <bundle id> -smoke`, never `booted` (it may be another agent's), and `funtools sim release $udid` at the end. About 5–10 minutes a round.
+- Compile and test: `dotnet build` and `dotnet test` on the engine-free core (its `CoreTests~` project; Unity ships a `dotnet` under `Contents/Resources/Scripting/DotNetSdk/`), and Unity's test runner for the rest: `funtools unity run -- -nographics -runTests -testPlatform EditMode -testResults results.xml` (the machine-wide queue: one run per project across agents; never with `-quit`: the test runner exits by itself). Play Mode tests run the same way with `-testPlatform PlayMode`; one game's `unity/build.sh test` runs Edit Mode then Play Mode and reads the NUnit XML, the only project that does.
+- Build for the Simulator with the game's own build method: `funtools unity run -- -nographics -buildTarget iOS -executeMethod Setup.BuildSimulatorDev` (a development build: its dev flags and test ads work; keep a stripped release Simulator build beside it), then `xcodebuild -project Unity-iPhone.xcodeproj -scheme Unity-iPhone -sdk iphonesimulator build`; install and launch on a Simulator of your own (`udid=$(funtools sim lease)`) with `xcrun simctl install $udid <app>` and `xcrun simctl launch --console-pty $udid <bundle id> -smoke`, never `booted` (it may be another agent's), and `funtools sim release $udid` at the end. About 5–10 minutes a round.
 - A smoke run: a dev-only launch flag in your game that plays from the title to an ending and writes `smoke.txt` to the app's Documents; read it with `xcrun simctl get_app_container $udid <bundle id> data`.
-- Dev flags: launch arguments for dev builds that jump to a state or start a bot (the games used `-autoplay -startlevel N`, `-hg-seed 7 -hg-autoplay`, and a tour flag that writes every menu to PNG), read through `LaunchArgs.Get()` behind the game's own dev gate, with `Telemetry.Muted` set while a flag is on. A launch with any flag also skips the studio splash (`-splash` forces it).
-- Hand play from a script: `npx @funpixel/tools unity play start`, then `play tap`, `drag`, `key`, `pad`, `state`, `ui`, `shot`, `record` and `end` (the kit's `com.funpixel.probe`, lifted from Pocket Crew's remote play: real Input System device state, in the game's own upright coordinates). `unity probe --path path.json` plays a scripted path and measures it; `unity capture --all` shoots every registered view (funpixel-unity-game, `references/probe.md`).
+- Dev flags: launch arguments for dev builds that jump to a state or start a bot (the games used `-autoplay -startlevel N`, `-seed 7 -autoplay`, and a tour flag that writes every menu to PNG), read natively (Mono never sees `simctl launch` arguments) behind the game's own dev gate, with telemetry muted while a flag is on.
+- Hand play from a script: `npx @funpixel/tools unity play start`, then `play tap`, `drag`, `key`, `pad`, `state`, `ui`, `shot`, `record` and `end` (the kit's `com.funpixel.probe`, lifted from one game's remote play: real Input System device state, in the game's own upright coordinates). `unity probe --path path.json` plays a scripted path and measures it; `unity capture --all` shoots every registered view (funpixel-unity-game, `references/probe.md`).
 - Screens: `funtools sim shot $udid --out shot.png`, upright in the game's orientation; `funtools sim tap $udid x y` presses a point of that picture.
 
 ## Checks
@@ -47,14 +47,14 @@ A person still checks feel on a real phone and audio by ear.
 
 ## Worked example
 
-Pocket Crew, a three.js port with 26 levels. Build 1 went to TestFlight behind 1,118 green tests, and every level after the first of a session drew its movers frozen: a warm-up had left the views bound to a throwaway sim. Every audit had started levels fresh at boot, so none saw it. Once fixed, the audit's frozen category went from 219 to 0. A production gate (fresh install, every level through real flows, 7 kill-and-relaunch cycles, every setting persisted) found 4 more bugs behind 1,377 green tests. Hand play through the game's remote-play server found what bots had passed: fans that looked walkable, Tiny Pip drawn as a speck, and threats under the buttons.
+A three.js port with 26 levels. Build 1 went to TestFlight behind 1,118 green tests, and every level after the first of a session drew its movers frozen: a warm-up had left the views bound to a throwaway sim. Every audit had started levels fresh at boot, so none saw it. Once fixed, the audit's frozen category went from 219 to 0. A production gate (fresh install, every level through real flows, 7 kill-and-relaunch cycles, every setting persisted) found 4 more bugs behind 1,377 green tests. Hand play through the game's remote-play server found what bots had passed: fans that looked walkable, the smallest hero drawn as a speck, and threats under the buttons.
 
 ## Common mistakes
 
-- Launching with dev flags every time. Dawg Ball's `-db-*` flags muted telemetry, so a Firebase crash path first ran when the owner launched normally.
-- A smoke that asserts only "no errors". Scrap Riot's bot failed to beat the boss for 11 minutes, then stood holding USE; the run now uses `-lgr-god`, `DebugBossHit` and a walk-to-lever script.
-- Reading screenshots and skipping the log. In Dawg Ball a NullReferenceException in `Hud.Pad` hung a demo match silently.
+- Launching with dev flags every time. One game's dev flags muted telemetry, so a Firebase crash path first ran when the owner launched normally.
+- A smoke that asserts only "no errors". One game's bot failed to beat the boss for 11 minutes, then stood holding USE; the run now uses a god-mode flag, `DebugBossHit` and a walk-to-lever script.
+- Reading screenshots and skipping the log. In one game a NullReferenceException in `Hud.Pad` hung a demo match silently.
 - Trusting benches for boot. A static cache declared after the colours it used threw a TypeInitializationException and no build booted for about 7 h; which game is not in the report.
-- Hand-written `.csproj` files left ignored by git. Dead Letter's tests could not run from a fresh clone.
-- A regression test that passes on the old code, as a Dawg Ball cheat test did.
+- Hand-written `.csproj` files left ignored by git. One game's tests could not run from a fresh clone.
+- A regression test that passes on the old code, as one game's cheat test did.
 - Shipping without the audio check. All four first games reached TestFlight silent, because a camera made in code has no AudioListener (`funtools doctor` warns before the build).

package/plugins/cursor/skills/funpixel-world-and-story/SKILL.md

@@ -96,4 +96,4 @@ clear, a ring round the tower, in 3 draw calls. The opening: title
 - A strange number never explained. Voices placed by room and deed, cards that name what happened:
   [references/opening-and-chapters.md](references/opening-and-chapters.md#a-radio-placed-rather-than-narrated).
 
-Where this comes from: the hits (research 18), Crayon's GDD (research 19), Held Note, our lab.
+Where this comes from: the hits (research 18), Crayon's GDD (research 19), our own games, our lab.

package/plugins/cursor/skills/funpixel-world-and-story/references/atmosphere.md

@@ -1,7 +1,7 @@
 # Atmosphere: a world that notices the player
 
-A place feels alive when things in it move on their own and answer what the player does. Saltwake
-(our racer, 29 Sep) played well and still read as "a game of shapes": no one in the stands, nothing
+A place feels alive when things in it move on their own and answer what the player does. Our
+racer (29 Sep) played well and still read as "a game of shapes": no one in the stands, nothing
 at the trackside, no moment at the finish. The owner's words: "environment and crowd cheers were
 missing". This page is a shelf of patterns per genre and the cheap code under them. Pick what the
 brief wants; a puzzle in an empty white room may want none of it, on purpose.
@@ -175,7 +175,7 @@ The end of a race or a round is the moment players remember, so stage it like th
 2. The crowd at its loudest, a sting, the stand on its feet.
 3. Light: flashbulbs (small white sprites flickering at random in the stands for 1.5 s), a burst of
    confetti in the team colours, fireworks at night (particles: skill `funpixel-art`).
-4. Someone says something: the announcer ("And it's Saltwake by a nose!"), a rival's line, the
+4. Someone says something: the announcer ("And it's the blue boat by a nose!"), a rival's line, the
    coach. One line, on screen and voiced if you have voice (see [voice.md](voice.md)).
 5. Then the result card over the still-cheering world, not over a black screen.
 
@@ -187,7 +187,7 @@ erupts, and declare the view `moment: true` so capture shoots it as a burst.
 Horror inverts the pattern: the world reacts by going quiet. Keep the bed low and let it drop out
 entirely about a second before a threat appears, so the silence is the warning. Space distant
 sounds unevenly (8–25 s apart, never on a timer the player can learn), pan them, and put one
-sound close and behind at the worst moment. Held Note's hum rising under the last recorder line is
+sound close and behind at the worst moment. One horror game's hum rising under the last recorder line is
 the model: the world answers the story, not the player's score.
 
 ## Budget and cost

package/plugins/cursor/skills/funpixel-world-and-story/references/living-world.md

@@ -1,6 +1,6 @@
 # A living world: people, creatures and a place that moves
 
-The owner's verdict after three rounds of one game built two ways (Blue Freight, Oct 2026): "both
+The owner's verdict after three rounds of one game built two ways (Oct 2026): "both
 did nice work, some in environment, some in dynamics... models static, NPCs static: it has to be a
 living environment." The build that lost on dynamics had 28 townsfolk animated in place (none
 walked anywhere), kites that slid, a still hound and one person standing inside a container. The
@@ -171,7 +171,7 @@ mesh.geometry.attributes.aAnim.needsUpdate = true;
 ## Technique 4: painted cut-outs that animate (Pixi, and billboards in Three)
 
 A picture moved is motion, not animation: a crab sprite slid along the ground, a goat card that bobs
-or flips, a kite that drifts and pulses its opacity all read as stones (fresh Blue Freight, 3 Oct).
+or flips, a kite that drifts and pulses its opacity all read as stones (a fresh build of that game, 3 Oct).
 A cut-out lives by one of four means. **Frames by distance:** a walker gets 6+ frames, the hero
 8–12 (contact, down, passing, up for each foot), and the frame advances by ground covered, one
 cycle per about 0.8 body heights (1.4 m at 1.75 m), so it never treadmills when standing or skates

package/plugins/cursor/skills/funpixel-world-and-story/references/opening-and-chapters.md

@@ -157,7 +157,7 @@ story.start(save.data.chapter ?? 0, save.data.step ?? 0);
 
 ## A radio, placed rather than narrated
 
-Held Note (a three.js horror game, 29 Sep 2026) told its story through two sources with different
+One three.js horror game (29 Sep 2026) told its story through two sources with different
 voices, both in the world: the station speaks only in readouts (who is behind a door, open water,
 lift power, the nearest dead relay when she is lost), and a recorder plays fragments of the crew's
 last night, timestamped, with the enemies' hum rising under them until the last line ends in

package/plugins/cursor/skills/funpixel-world-and-story/references/story-at-size.md

@@ -34,7 +34,7 @@ words, it is the voice, the timing and the testing of each one.
 ## The outer story, at 10 minutes and up
 
 A want inside the hero is not enough past ten minutes; the player needs something to point at.
-Five lines in the GDD, each something the player sees or does. Blue Freight lacked all five.
+Five lines in the GDD, each something the player sees or does. One of our games lacked all five.
 
 | Line | What it is | From |
 |---|---|---|
@@ -137,7 +137,7 @@ player does not hear the opening twice.
 
 ## Staged versus played
 
-A beat that exists only in a staged view is not in the game. The Held Note playtest caught a
+A beat that exists only in a staged view is not in the game. One game's playtest caught a
 showcase frame play never reached; the same happens to story. Three places see it:
 
 - `funtools depth` reads the `## Story` table and the `beat` field in real play logs (blind

package/plugins/cursor/skills/funpixel-world-and-story/references/voice.md

@@ -19,7 +19,7 @@ So for real words, four honest options: the platform's voice, then three cheaper
 
 **A story game offers voice by default** (the Silt bar S3:
 at least one voiced line before first control, every line voiced and captioned, a line advancing on
-its clip's end). Silt voiced 57 lines heard by objective 33; Blue Freight typed its radio lines and
+its clip's end). Silt voiced 57 lines heard by objective 33; one of our games typed its radio lines and
 lost on it. So for a game with a story, characters who speak or a cold open, the plan's Art budget
 lists the voiced lines with their price as the default, and the creator picks voice, one of the
 cheaper options below, or none: still priced, still the creator's choice, never made unasked. For an