@funpixel/tools 0.1.0 → 0.1.1

package/plugins/claude/skills/audio/references/adaptive-music.md

@@ -159,7 +159,7 @@ music.muffle(0.2);
 ## Prove it follows play (free, before anyone listens)
 
 A mix driven by a timer reads as a playlist; one that never moves is a single loop with extra
-files. Keep the decision pure and beside the rules, as Gesundheit's `src/mix.ts` does:
+files. Keep the decision pure and beside the rules, as one game's `src/mix.ts` does:
 `musicMix(run, screen, lift) → { calm, swarm, lift }`, where `swarm` rises with the bugs on the
 field and sniffling ones count more. The `Music` class sets gains from it each frame, and a probe
 can chart the same function while a bot plays, with no browser and no audio device:
@@ -171,7 +171,7 @@ timelines: [{ name: 'wave 3', follow: [{ layer: 'swarm', driver: 'threats' }], r
 ```
 
 `npx @funpixel/tools sim` then says, per layer: it never moved (warn), it moved but not with what
-it follows (note, with the correlation), or it follows (r and the sample count). Gesundheit's
+it follows (note, with the correlation), or it follows (r and the sample count). That game's
 `music-timeline.ts` printed the same chart as bars per half second with the chain and bloom
 marks beside them, which is how its creator saw the lift arrive on the payoff. The numbers
 cannot say it sounds good; listen once the chart says it moves.
@@ -183,8 +183,8 @@ cannot say it sounds good; listen once the chart says it moves.
   between them is part of the music.
 - The set piece: `muffle()` down for a beat before it, `sting()` on the reveal, then
   `switchOnBar()` to the `wonder` take, and leave it on while the player looks.
-- A score built on the game's own sound. Held Note (a horror game, 29 Sep 2026) built its music
-  on one held note that bends as an enemy nears and gains layers with the threat, per-room ambience
+- A score built on the game's own sound. A horror game (29 Sep 2026) built its music
+  on one sustained note that bends as an enemy nears and gains layers with the threat, per-room ambience
   beds under it, stingers on reveals, and real silence between phrases; the silence is what
   makes the next phrase land. Its radio voices were band-limited and driven like a small speaker
   with line noise, so a recording sounds like a recording.

package/plugins/claude/skills/audio/references/engine.md

@@ -21,10 +21,10 @@ line below answers a failure our games shipped with.
   sound per overlapping frame turns one hit into four (the tide-pool chime in the skill's worked
   example read `sounds` +4 per match until a 50 ms cooldown made it 1). ±6% pitch jitter keeps a
   repeated sound from reading as a loop. For the sounds a player hears most (footsteps, the core
-  hit), Held Note generated 2–4 takes and picked one at random per play with ±4% pitch and ±2 dB,
+  hit), one game generated 2–4 takes and picked one at random per play with ±4% pitch and ±2 dB,
   which hid the repeat better than jitter on one take.
 - **Voices over everything else.** Duck music and beds under a voice line, and let a sound
-  behind a wall go through a low-pass (Held Note's occlusion), so the voice and the room stay
+  behind a wall go through a low-pass (occlusion), so the voice and the room stay
   legible.
 - **Mute where the player looks first.** Players who want silence look on the first screen and in
   the HUD; a mute that resets on reload, or lives only in a settings menu, sends them away.

package/plugins/claude/skills/audio/references/measure.md

@@ -88,7 +88,7 @@ ffmpeg -i pool.mp3 -af loudnorm=I=-18:TP=-1 -ac 1 -b:a 96k pool-m.mp3
 ```
 
 `loudnorm` cannot measure a clip under about 0.4 s (its integrated loudness needs longer blocks),
-and on short files it silently changes how it behaves. Held Note (29 Sep 2026) levelled its short
+and on short files it silently changes how it behaves. One game (29 Sep 2026) levelled its short
 sounds by their loudest 100 ms instead (the snippet above uses a 300 ms window; shorten `w` for
 clips that short), and kept `loudnorm` for music and loops.
 

package/plugins/claude/skills/audio/references/unity.md

@@ -4,9 +4,10 @@ The audio bug these games hit most was no sound at all. Four games went to TestF
 
 ## Tools
 
-The studio's `com.joydle.core` package carries the player side (fp:unity-game, `references/studio-packages.md`): `Sfx.Create(musicClip)` makes 8 pooled one-shot sources and one looping music source at volume 0.45 and calls `Sfx.EnsureListener()`, which adds an `AudioListener` when none exists; `Play(clip, volume)` jitters pitch by 0.06; `Settings.Sound` and `Settings.Music` are the player's toggles; `BuildTools.SimulatorMuted` builds a Simulator build with audio off for captures and restores the setting after. Not shipped by the kit or the package: the Unity starter, its checks and the studio scripts (the upload pre-flight, a music length check, a one-funnel effect tap, the audio import rule). Do those with what exists:
+Not shipped by the kit: the Unity starter, its checks and the studio scripts (the upload pre-flight, a music length check, a one-funnel effect tap, the audio import rule). Do those with what exists:
 
 - Generate into the project: `npx @funpixel/tools gen sound "<cue>" --unity .` (`gen music`, `gen line`; `--loop` for a bed), after `npx @funpixel/tools login`. It lands 48 kHz WAV (ffmpeg trims the MP3's encoder padding) in `Assets/_Game/Generated/Sfx/`, `Loops/`, `Music/` or `Voice/`, and a rule set once per file: effects mono, ADPCM, decompress on load, normalisation off; loops PCM; music Vorbis, streaming. The studio's `gen_sfx.py` and `gen_music.py` call the same providers with `.env` keys: no metering, no cost log.
+- A sound class of your own: 8 pooled one-shot sources with a pitch jitter of about 0.06, one looping music source at volume 0.45, an `AudioListener` added when none exists, and the player's Sound and Music toggles.
 - Before every upload, read `ProjectSettings/AudioManager.asset` yourself: `grep "m_DisableAudio: 1"` must find nothing.
 - `npx @funpixel/tools loudness Assets/Audio` reads every cue against its loudness target (ffmpeg EBU R128); ffmpeg's `ebur128`, `volumedetect` and `silencedetect` filters do the same by hand. `npx @funpixel/tools beats Assets/Audio/Music` writes each track's beat map.
 - Music length: an Edit Mode test that compares each clip's `AudioClip.samples` with its reference length.
@@ -18,7 +19,7 @@ Checks: `audio_runtime` and `recording_check` are proposed, not built. The studi
 
 ## Procedure
 
-1. Make exactly one AudioListener and assert it at startup. A scene generated by code gets none by default; `Sfx.Create` adds it (or call `Sfx.EnsureListener()`).
+1. Make exactly one AudioListener and assert it at startup. A scene generated by code gets none by default; have the sound class add one when none exists.
 2. Set the project through the setup script, not a copied file: audio on (`m_DisableAudio: 0`) and `m_SampleRate` 48000. A cloned project carried `m_DisableAudio: 1`, and the Simulator mixed at 24 kHz without the rate.
 3. Write import rules in code and change the rule, never the `.meta`. A size pass that edited 190 SFX metas by hand was silently reverted by the rule on the next import.
 
@@ -35,23 +36,23 @@ Checks: `audio_runtime` and `recording_check` are proposed, not built. The studi
 
    | Game | Figure |
    |---|---|
-   | Pocket Crew | music −18.5 LUFS, peaks at most −1 dBFS |
-   | Stitch Pop | SFX mean −18 to −28 dB; music volume 0.45, about 7 dB under SFX |
-   | Noodle Nights | crowd bed −30 LUFS |
-
-8. Mix in code. No game uses an AudioMixer asset. Dead Letter ports its web mixer: buses, an 8-voice cap, round-robin variants, cooldowns, ±6% pitch, music crossfade, stinger ducks, and a tension loop that ducks music by 4 dB.
-9. In a port, route every sound through one tap so an audit runs headless. Pocket Crew: 468 events, 0 mismatches against the web.
-10. Re-render procedural web audio offline in C# instead of synthesising live. Dawg Ball's 70 clips (17.7 s) warm in 64 ms at boot; The Hot Gates' 41 cues and 3 loops match Chromium sample for sample (138 tests).
-11. Handle interruptions: an Ambient audio session (it respects the silent switch and other apps), sound held on pause and during the studio splash (`JoydleSplash` pauses the game's audio until it ends; start the title music once `JoydleSplash.Playing` is false), resumed after backgrounding, calls or Siri. `OnApplicationPause(true)` also fires on resign-active (Control Center, Siri, call banners, Face ID).
+   | A 3D platformer | music −18.5 LUFS, peaks at most −1 dBFS |
+   | A casual game | SFX mean −18 to −28 dB; music volume 0.45, about 7 dB under SFX |
+   | An idle game | crowd bed −30 LUFS |
+
+8. Mix in code. No game uses an AudioMixer asset. One port carries over its web mixer: buses, an 8-voice cap, round-robin variants, cooldowns, ±6% pitch, music crossfade, stinger ducks, and a tension loop that ducks music by 4 dB.
+9. In a port, route every sound through one tap so an audit runs headless. One port: 468 events, 0 mismatches against the web.
+10. Re-render procedural web audio offline in C# instead of synthesising live. One game's 70 clips (17.7 s) warm in 64 ms at boot; another's 41 cues and 3 loops match Chromium sample for sample (138 tests).
+11. Handle interruptions: an Ambient audio session (it respects the silent switch and other apps), sound held on pause, resumed after backgrounding, calls or Siri. `OnApplicationPause(true)` also fires on resign-active (Control Center, Siri, call banners, Face ID).
 12. Run `audio_runtime` in the player: 1 listener, 48 kHz output, music playing within 3 s (of the splash's end, when one plays).
 13. Before sharing or uploading any video, run `recording_check`: 0 frame gaps over 34 ms and audio at 44.1 kHz or higher.
 14. Run the numeric lint (LUFS, peak, seam), then have a person listen. An agent can measure audio but not hear it, so the listen is a required gate on every game's ship-blocker list.
 
-Music that follows play: Dawg Ball's crowd volume swells near goals; Dead Letter crossfades and ducks on stingers. No game has layered adaptive music.
+Music that follows play: one sports game's crowd volume swells near goals; another game crossfades and ducks on stingers. No game has layered adaptive music.
 
 ## Worked example
 
-Scrap Riot (a 2D port from Pixi), music loops and SFX levels:
+A 2D port from Pixi, music loops and SFX levels:
 
 1. The MP3 loops decoded 1,245–1,997 samples long, so loops gapped.
 2. The loops were rebuilt as OGG from the web's `.m4a` at exact sample counts. Background music went 96 → 10 MB.
@@ -62,12 +63,12 @@ Scrap Riot (a 2D port from Pixi), music loops and SFX levels:
 ## Common mistakes
 
 - A code-made camera with no AudioListener: all four first games reached TestFlight silent; it cost one TestFlight round for three of them. `funtools doctor` warns when nothing adds one.
-- A cloned ProjectSettings: Dead Letter inherited `m_DisableAudio: 1`; the studio's upload pre-flight (proposed for the kit) caught it.
-- No 48 kHz setting: The Hot Gates mixed at 24 kHz and sounded muffled.
-- MP3 or ADPCM for loops: gaps (Scrap Riot) or clicks.
-- Uncommitted reimports: two review builds (Dead Letter, Scrap Riot) carried 190 reimported `.wav.meta` files, so main no longer matched what Apple reviewed.
-- Showing a recording before measuring it: a `simctl recordVideo` capture of The Hot Gates had 19 frame gaps up to 0.85 s and 24 kHz audio, cost about 1 h and was cancelled.
-- Generated audio nobody heard: Dawg Ball's 70 sounds, as of 29 Sep.
-- Many relaunches wedge the Simulator's CoreAudio (crash at audio init); `BuildTools.SimulatorMuted` (audio off for that build only, restored after) avoids it for capture runs, and the upload pre-flight refuses any build with audio off.
+- A cloned ProjectSettings: one game inherited `m_DisableAudio: 1`; the studio's upload pre-flight (proposed for the kit) caught it.
+- No 48 kHz setting: one game mixed at 24 kHz and sounded muffled.
+- MP3 or ADPCM for loops: gaps or clicks.
+- Uncommitted reimports: two review builds carried 190 reimported `.wav.meta` files, so main no longer matched what Apple reviewed.
+- Showing a recording before measuring it: a `simctl recordVideo` capture of one game had 19 frame gaps up to 0.85 s and 24 kHz audio, cost about 1 h and was cancelled.
+- Generated audio nobody heard: one game's 70 sounds, as of 29 Sep.
+- Many relaunches wedge the Simulator's CoreAudio (crash at audio init); a Simulator build with audio off for that build only, restored after, avoids it for capture runs, and the upload pre-flight refuses any build with audio off.
 - `git commit -a` after a headless run: every run rewrites AudioManager.
 - The silent switch mutes Unity's Ambient session; accepted for casual games.

package/plugins/claude/skills/game-feel/SKILL.md

@@ -46,7 +46,7 @@ responses. More particles or shake do not automatically mean better feel.
    compulsory bundle. Keep the most important event distinct from routine actions. In an action
    game with several weapons, one contact function they all call keeps the feel consistent and
    tunable in one place; a new weapon that opens or cashes a state the old verbs already make
-   (a reeling enemy) gives combos without new systems. Held Note's values, its weapons as tools
+   (a reeling enemy) gives combos without new systems. One action game's values, its weapons as tools
    of a pillar, and what its blind player caught: [references/contact.md](references/contact.md).
 
 3. **Protect control and fairness.** Hitstop freezes the picture, not the player: a press during
@@ -92,13 +92,13 @@ input problem may instead need a contact pose and a short impact cue.
 - Deleting feedback in reduced motion instead of replacing uncomfortable effects.
 - Calling effects measured in a quiet one-second sample proof that attacks read correctly.
 - A verb that exists only in the sim: with no pose, sound or visible result, players report it
-  missing (Held Note's shove, for weeks).
-- Limiting a helper the genre's hit never limits (Lantern Night's capped jar, reported as a bug
+  missing (one game's shove, for weeks).
+- Limiting a helper the genre's hit never limits (one game's capped jar, reported as a bug
   twice; Peggle's bucket never runs out). A real resource keeps its empty state visible.
 - A tell carried by sound alone: a muted phone never hears it, so the visual has to build across
   the whole warning.
 
-Where this comes from: our own games (the juice tables, Held Note's contact work, the `feel`
+Where this comes from: our own games (the juice tables, one action game's contact work, the `feel`
 measures) and the hits in research 18; the juice vocabulary from Vlambeer's talks and "Juice it or
 lose it"; review habits from Claude Code Game Studios (MIT); hitstop that freezes the picture, not
 the player, began as a platform engine note.

package/plugins/claude/skills/game-feel/references/contact.md

@@ -1,6 +1,6 @@
 # Contact, verbs and weapons in an action game
 
-What one 3D action game learned about hits, verbs and weapons. Held Note is a third-person
+What one 3D action game learned about hits, verbs and weapons. It is a third-person
 deep-sea horror game in three.js, built with the GDK's tools in September 2026 (its making notes:
 `design/MAKING.md`, `PERF.md`, `assets.md`). Between its first and second playtest, the round
 that added the contact work below, the blind critic panel's juice score went 5.60 → 6.17 and look
@@ -9,10 +9,10 @@ reason, not a proven recipe. A quiet puzzle needs none of this.
 
 ## One contact function
 
-Every weapon in Held Note calls one `impact(target, dir, kind)`, so a weapon added later inherits
+Every weapon in it calls one `impact(target, dir, kind)`, so a weapon added later inherits
 the feel, and tuning happens in one place. What that function did:
 
-| Part | Held Note's value | Why |
+| Part | Its value | Why |
 |---|---|---|
 | Target jolt | along the hit direction | shows where the force went |
 | Flash | the struck part goes white for a few frames | says "that one", even in the dark |
@@ -40,7 +40,7 @@ export function impact(t: Target, dir: Vec3, kind: 'hit' | 'sever' | 'kill') {
 
 ## A verb nobody can see does not exist
 
-Held Note's shove worked in the sim for weeks with no body animation, and the owner asked "don't we
+The game's shove worked in the sim for weeks with no body animation, and the owner asked "don't we
 have a melee attack?". To a player, a verb without a pose, a sound and a visible result is not
 there. A two-handed shove and a slash fixed it. `funtools feel` reads each actor's look per state
 ([measure](measure.md)), which shows a state that borrows another's pose.
@@ -61,7 +61,7 @@ A question to ask of any new verb or weapon: which state does it open, and which
 
 ## Weapons as tools that serve a pillar
 
-Held Note's three tools each answer a design pillar and draw on the one shared resource (the gas
+The game's three tools each answer a design pillar and draw on the one shared resource (the gas
 canister), so adding them kept the economy:
 
 - the cutter takes joints (the core verb);
@@ -104,7 +104,7 @@ sound can add to it without carrying it alone.
 
 ## Films need a bot that fights
 
-Held Note's route bots only cut, so films made from their runs showed no combat and a review could
+The game's route bots only cut, so films made from their runs showed no combat and a review could
 not judge the weapons. A `fighter` bot style, for films only (the tests keep the median bot), plays
 the verbs a keen player would: Counters, knives, rivets, a death. If the payoff is a fight, film a
 fight.

package/plugins/claude/skills/game-feel/references/unity.md

@@ -1,28 +1,23 @@
 # Game feel: motion, juice and haptics
 
-Feel bugs pass every test. Dawg Ball's sim (the engine-free rules, stepped at a fixed 60 Hz) was correct, but 1 frame in 8 advanced 0 or 2 sim ticks, so the ball stalled and then jumped all match; the owner called it trembling. This skill gives each moment a measured answer and names the effects that were built, then removed.
+Feel bugs pass every test. One soccer game's sim (the engine-free rules, stepped at a fixed 60 Hz) was correct, but 1 frame in 8 advanced 0 or 2 sim ticks, so the ball stalled and then jumped all match; the owner called it trembling. This skill gives each moment a measured answer and names the effects that were built, then removed.
 
 ## Tools
 
-The studio's `com.joydle.core` package carries the tweens and haptics (fp:unity-game, `references/studio-packages.md`):
-
-- `Juice.Tween(duration, step, unscaled)` with `EaseOutBack`, `EaseOutCubic` and `EaseInQuad`; `Juice.Pop` (scale 0.18 over 0.22 s, keeping the true rest scale) and `Juice.Shake` (0.08 over 0.25 s); `Juice.Ring` and `Juice.Dot` sprites for ripples and sparkles.
-- `Haptics.Light`, `Medium`, `Heavy`, `Success` and `Error`: iOS taptics through the package's native plugin, Android vibration effects, off when `Settings.Haptics` is. The throttle and merge in step 5 are the game's.
-
-Not in the kit or the package: the Unity starter, a frame-owner `GameDriver`, an interpolation blend with a trace flag, a near-miss tracker and the `moment_freq` check. Write those yourself:
+Not in the kit: the Unity starter, coroutine tweens (a pop, a shake, eases), haptics by strength (iOS taptics through a native plugin, Android vibration effects, off with the player's setting), a frame-owner `GameDriver`, an interpolation blend with a trace flag, a near-miss tracker and the `moment_freq` check. Write those yourself:
 
 - A frame owner: one `MonoBehaviour` that reads input, steps the sim at a fixed rate (`sim.Update(dt)`), sends events to presenters and draws with `Render(alpha)`.
 - Interpolation and its trace: blend the drawn state between the last two ticks, and a dev-only launch flag that writes per-frame tick counts to a `trace.csv`.
 - A near-miss detector in the engine-free core, so bots can count it.
 - Frequency tests: bot batches in an Edit Mode test (`funtools unity run -- -nographics -runTests -testPlatform EditMode -testResults results.xml`, never with `-quit`: the test runner exits by itself), or `dotnet test` on an engine-free core, at 30 and 60 fps.
 
-No game uses DOTween (`Juice` does the tweens). Gallery Heist's views branch aims its camera with Cinemachine 6.6 and plays its intro on Timeline; the rest drive the camera in code. Nothing checks sliding feet or loop pops.
+No game uses DOTween (coroutine tweens do). One game's views branch aims its camera with Cinemachine 6.6 and plays its intro on Timeline; the rest drive the camera in code. Nothing checks sliding feet or loop pops.
 
 ## Procedure
 
 1. Render interpolated between the last two fixed sim ticks. Check: 100% of frames with steps other than 1 are blended, and drawn-ball jerk p99 is under a threshold (value not in the report). A teleported or thrown ball blends for 0.18 s.
 2. Tie per-frame effects to sim steps, or scale them by dt (`1 - Math.Pow(0.4, dt*60)`). Check: headless runs at 60 and 120 Hz give the same end-state hash and effect counts per sim second.
-3. Buffer the main action. Dawg Ball's kick has a 200 ms buffer (`BufferMs`): a press arms it and the foot swings when the ball arrives.
+3. Buffer the main action. The soccer game's kick has a 200 ms buffer (`BufferMs`): a press arms it and the foot swings when the ball arrives.
 4. Answer each moment from the table.
 
    | Moment | Answer | Duration |
@@ -37,9 +32,9 @@ No game uses DOTween (`Juice` does the tweens). Gallery Heist's views branch aim
    | Goal | net bulge, goal shake, the only big callout | no slow-mo |
 
 5. Map haptics by strength: a web vibration of 30 ms or more is heavy, 14 ms or more medium, else light. Throttle to 80–90 ms and merge pulses inside 120 ms into the strongest, so a light tap does not swallow a heavy one.
-6. Keep each tween's true rest scale (`Juice.Pop` keys it by Transform); otherwise a second pop records a mid-pop scale as the base.
-7. Draw particles from fixed pools; the pool is the budget. Dead Letter: 2 quad batches, 600 particles. Dawg Ball: 220 sprites, 120 confetti, 14 rings in 6 batched meshes. At most 120 spawns per second, oldest recycled; ambient at most 40 live.
-8. Frequency-test every juice event with bot batches at 30 and 60 fps. Dawg Ball's targets: own goals at most 0.3 per match, misses and blocks 2–5 per 90 s.
+6. Keep each tween's true rest scale (key it by Transform); otherwise a second pop records a mid-pop scale as the base.
+7. Draw particles from fixed pools; the pool is the budget. One 2D game: 2 quad batches, 600 particles. The soccer game: 220 sprites, 120 confetti, 14 rings in 6 batched meshes. At most 120 spawns per second, oldest recycled; ambient at most 40 live.
+8. Frequency-test every juice event with bot batches at 30 and 60 fps. The soccer game's targets: own goals at most 0.3 per match, misses and blocks 2–5 per 90 s.
 9. Keep in-match overlays minimal; do not freeze or slow play while the clock runs.
 10. Measure a camera change against the problem it is meant to fix, in frames.
 11. Honour the effects setting: shake is skipped when "Shake & flashes" is off, and the kickoff dolly (about 1/3 closer over the 1.5 s countdown) when screen effects are off.
@@ -48,17 +43,17 @@ No game uses DOTween (`Juice` does the tweens). Gallery Heist's views branch aim
    | Role | How | Numbers |
    |---|---|---|
    | Hero | code; ports copy the web's procedural rig | pose tweens 0.22–0.4 s |
-   | Rigged cast (Noodle Nights only) | Animator blend trees | transitions 0.12–0.15 s, exit time 0.9 |
-   | Crowd (The Hot Gates) | vertex-animation textures, GPU instancing | 1,800 units in 18 draws |
+   | Rigged cast (one game only) | Animator blend trees | transitions 0.12–0.15 s, exit time 0.9 |
+   | Crowd | vertex-animation textures, GPU instancing | 1,800 units in 18 draws |
    | UI | coroutine tweens | defaults above |
 
    Root motion is off everywhere: the sim owns positions.
 13. Show the owner a zoomed close-up on one asset before rolling out a style.
-14. Finish with a person playing on a phone: Dawg Ball's feel bugs came from the owner's TestFlight play.
+14. Finish with a person playing on a phone: the soccer game's feel bugs came from the owner's TestFlight play.
 
 ## Worked example
 
-Dawg Ball (a 3D port from three.js):
+A soccer game (a 3D port from three.js):
 
 1. A dev trace flag wrote `trace.csv`: at a 60 Hz sim, 1 frame in 8 (12%) advanced 0 or 2 ticks.
 2. A blend draws every frame between the last two ticks.
@@ -68,11 +63,11 @@ Dawg Ball (a 3D port from three.js):
 
 ## Common mistakes
 
-- Slow-mo on goals (Dawg Ball): fired 14 times a match, read as lag, and shipped in every TestFlight build until 1 Oct.
-- A follow camera (Dawg Ball) showed both goals only 18–40% of the time; reverted to a fixed full-pitch view. With the next item, two rounds lost.
-- A camera lift for barks (Dead Letter): changed 0 covered frames (2–8 of 165 either way) and added a 25–69 pt view shift; PR #11 was reverted in PR #12.
-- A sticker-border shader (Dawg Ball): a 2D mock-up style put on dogs, ball and goals before a close-up was shown. It did not transfer to 3D, broke static merging (dozens more draws), cost about 3 builds and was removed: "it was much better before". Four more decorations were reverted the same way in 24 h.
-- A 1.6 s freeze after goals (Dawg Ball) read as "freezy".
-- Effects per render frame: at 120 Hz Pocket Crew's bobs and sparkles ran twice as fast.
+- Slow-mo on goals: fired 14 times a match, read as lag, and shipped in every TestFlight build until 1 Oct.
+- A follow camera showed both goals only 18–40% of the time; reverted to a fixed full-pitch view. With the next item, two rounds lost.
+- A camera lift for barks (a 2D game): changed 0 covered frames (2–8 of 165 either way) and added a 25–69 pt view shift; PR #11 was reverted in PR #12.
+- A sticker-border shader: a 2D mock-up style put on dogs, ball and goals before a close-up was shown. It did not transfer to 3D, broke static merging (dozens more draws), cost about 3 builds and was removed: "it was much better before". Four more decorations were reverted the same way in 24 h.
+- A 1.6 s freeze after goals read as "freezy".
+- Effects per render frame: at 120 Hz one game's bobs and sparkles ran twice as fast.
 - Concurrent pop tweens on one Transform: the cash pill grew huge (game not named).
-- "44 of 304 kicks connected" (Dawg Ball) is cited for this skill; its cause and fix are not in the report.
+- "44 of 304 kicks connected" (the soccer game) is cited for this skill; its cause and fix are not in the report.

package/plugins/claude/skills/game-logic/SKILL.md

@@ -49,7 +49,7 @@ native in about a day each, and the ports found four bugs the tests had missed (
    `__FPX_STATE__()` exposes `seed`.
 3. **Rules as numbered, named constants** (`R1 jump height 3.2 tiles`, `R2 coyote 80 ms`) in
    `src/sim/rules.ts`, listed in the design note, each proved by a test named after it
-   (`R2: a jump 70 ms after leaving a ledge still fires`). Dead Letter's rule ids let traversal tests
+   (`R2: a jump 70 ms after leaving a ledge still fires`). One game's rule ids let traversal tests
    catch a ledge with 64 px of headroom (research 12); a change then moves the note, the constant and
    the test together.
 4. **Determinism as a test.** Same seed and inputs, same state hash; a tiebreaker on every sort and a
@@ -68,7 +68,7 @@ hand-made anchors plus a seeded recipe the bots check: [references/content-at-sc
 ## Escalation changes what the player does
 
 Faster alone leaves the game the same, only harder to read, and `check_plan` flags a ramp that is
-speed alone. Dead Letter's review found its ramp invisible: the area indicator was computed and not
+speed alone. One game's review found its ramp invisible: the area indicator was computed and not
 drawn. A ramp as a list of what changes, new things one at a time, waves with rests, and a ramp the
 player can see: [references/escalation.md](references/escalation.md).
 
@@ -83,7 +83,7 @@ option with its reason; the bots below measure them.
 
 A headless loop over `src/sim` plays thousands of runs in seconds, where a browser session plays
 one, so tuning from bots, a frozen novice floor, a bot that finishes the level in `npm test` (in
-Held Note it caught a speed change that starved a route), a blind phone player, a parameter sweep
+one game it caught a speed change that starved a route), a blind phone player, a parameter sweep
 and a hunt for what bots never do all come cheap once the rules stand alone. Each, with its reason
 and where it came from: [references/balance.md](references/balance.md); the five probe players and
 `sim`: [references/probes.md](references/probes.md).

package/plugins/claude/skills/game-logic/references/balance.md

@@ -33,10 +33,10 @@ fitted the seeds or the game. This floor is a regression check: it predicts no h
 and fails the suite when it no longer reaches the end, is the other half: a balance change that
 makes the level unfinishable turns the tests red at once. A `funtools init` game starts with one
 (`rules.test.ts`: `botRound` wins a round on seed 5); a longer game grows it. This is a lesson from
-one game, Held Note (a 3D horror chapter, September 2026, gathered by the Held Note lane), and no
+one game (a 3D horror chapter, September 2026, gathered by its lane), and no
 first-try action game has tested it yet.
 
-Held Note's chapter test (`chapter.test.ts`, "Contract H", named after the GDD's numbers) carried:
+Its chapter test (`chapter.test.ts`, "Contract H", named after the GDD's numbers) carried:
 
 - `median_bot_finishes` for each of two routes (seal every weldable door, or fight through) on five
   seeds. The bot plays through the same intent a thumb produces, with a human reaction budget.

package/plugins/claude/skills/game-logic/references/depth.md

@@ -4,8 +4,8 @@ What a player gets from a game over ten minutes, and what brings them back for r
 in one session can match a hit on feel per second; the next thing it loses on is depth. In our
 head-to-heads against the genre hits (29 Sep), the player seat chose the hit almost every time and
 said why: "a dense, escalating ten-minute score attack against a single sparse maze, a 1:38 run"
-(Riad Rush against Pac-Man CE DX), "the early basket is too sparse, there is no packing pressure"
-(Plush Pop against Suika Game), "no endless mode, no leaderboard" (Gesundheit). Depth here is
+(a maze game against Pac-Man CE DX), "the early basket is too sparse, there is no packing pressure"
+(a merge game against Suika Game), "no endless mode, no leaderboard" (an arcade game). Depth here is
 structure and numbers, not content volume, so it is within a session's reach. Everything below is an
 option with its reason; pick what serves the game and write the choice into the design note.
 

package/plugins/claude/skills/game-logic/references/escalation.md

@@ -1,7 +1,7 @@
 # Escalation that changes what the player does
 
 Detail for the escalation section of the game-logic skill. Faster alone leaves the game the same,
-only harder to read. Dead Letter's review found its ramp invisible: the area indicator was computed
+only harder to read. One game's review found its ramp invisible: the area indicator was computed
 and not drawn. What has worked:
 
 1. A ramp written as a list of what changes: a new enemy type, a pattern, a narrower gap, a second
@@ -19,12 +19,12 @@ and not drawn. What has worked:
 novice and skilled players, how many clear each level, how many lose there and how long they spend.
 It warns on four shapes that lost players on 30 Sep:
 
-- **Flat**: everyone clears it, nobody loses, in under 45 s (Lantern Night's first garden gave three
+- **Flat**: everyone clears it, nobody loses, in under 45 s (one game's first garden gave three
   stars in 35 s). A first level may teach; a flat level mid-ramp is time with nothing to learn.
-- **A wall for people**: the skilled bot clears it only at 60 decisions a second (Saltwake's Dusk
-  Cup). Wrap the sharp policy in `humanRate` (12 decisions a second, 200 ms to react; a thumb makes
+- **A wall for people**: the skilled bot clears it only at 60 decisions a second (one racer's last
+  cup). Wrap the sharp policy in `humanRate` (12 decisions a second, 200 ms to react; a thumb makes
   10–15) and read both: a level the twin cannot clear asks for superhuman input.
-- **Cannot be lost**: no player lost a run over minutes of play (Sunhop). A puzzle or toy on purpose
+- **Cannot be lost**: no player lost a run over minutes of play (one of our games). A puzzle or toy on purpose
   says so; else a threat, a clock or a resource can end a run.
 - **No ramp**: the novice loses no more and takes no longer later than early.
 

package/plugins/claude/skills/game-logic/references/probes.md

@@ -16,15 +16,15 @@ the game means to have, so a good run can end on its own.
 
 | Role | Plays | Finds | Where it came from |
 |---|---|---|---|
-| `idle` | never presses | standing still wins, or waves clear themselves | Gesundheit: the blind phone player idled ~12 s reading the screen and wave 3 cleared itself; `idle-probe.ts` then measured it on 40 seeds per wave |
+| `idle` | never presses | standing still wins, or waves clear themselves | one arcade game: the blind phone player idled ~12 s reading the screen and wave 3 cleared itself; `idle-probe.ts` then measured it on 40 seeds per wave |
 | `naive` | steers straight at the nearest target, human-slow | no skill ceiling: the objective set holds no challenge | Research 19 §15 lesson 9: if a naive steer-to-marker bot clears everything, the design note says so on purpose |
-| `taught` | does exactly what the tutorial teaches, with ~0.2 s reaction | a tutorial that teaches a losing line; a mechanic that hurts the player who uses it | Gesundheit `core-metrics.ts`: "tap a bug, wait for the wedge to go white, slip sideways out"; it measured how often the bee was safe from its own chain and whether the chain's reward reached it |
+| `taught` | does exactly what the tutorial teaches, with ~0.2 s reaction | a tutorial that teaches a losing line; a mechanic that hurts the player who uses it | the same game's `core-metrics.ts`: "tap a bug, wait for the wedge to go white, slip sideways out"; it measured how often the bee was safe from its own chain and whether the chain's reward reached it |
 | `skilled` | the sharp line, fast | exploits, and whether a win is reachable at all | every bar game's balance bot |
-| `novice` | slow, hesitates, one press in five wrong, only what a player sees | onboarding: does a newcomer reach the first success? | Gesundheit `novice.ts`: frozen policy and policy hash, 100 fixed seeds plus 100 held out, deaths by cause |
-| `middle` (optional) | SOME of what is taught (leans and rests, never takes cover) | a difficulty cliff: half the lesson loses like none of it | Blue Freight r4: the careless and the careful bots, nothing between |
+| `novice` | slow, hesitates, one press in five wrong, only what a player sees | onboarding: does a newcomer reach the first success? | the same game's `novice.ts`: frozen policy and policy hash, 100 fixed seeds plus 100 held out, deaths by cause |
+| `middle` (optional) | SOME of what is taught (leans and rests, never takes cover) | a difficulty cliff: half the lesson loses like none of it | one game's round 4: the careless and the careful bots, nothing between |
 
 Each player sees only what a player could see: positions, marks, the HUD, never the rules'
-private state. A policy that clones the run or simulates seconds ahead (Blue Freight r4's sharp bot:
+private state. A policy that clones the run or simulates seconds ahead (that round's sharp bot:
 `glare()` looked 4–7 s ahead) is not a person at any rate: say so with `foresight: '<what it
 knows>'` on the policy, and sim does not count its wins as a careful player's at a human pace. Freeze the novice (its code, its seeds) before tuning, or the floor moves with
 the balance.
@@ -39,7 +39,7 @@ the balance.
 - **note**: no skill ceiling. The naive player wins as often, and as fast, as the sharp one; or
   wins as often and skill shows only as time. Fine for a toy, a relaxed game or a race against
   the clock: say so in the design note. Otherwise give the verb something to master: a risk that
-  pays (Gesundheit's chain that reaches the bee), a line to read, a combo that holds.
+  pays (the arcade game's chain that reaches the bee), a line to read, a combo that holds.
 - **length**: how long the sharp bot's run lasts (with its spread over seeds, and the second it
   reached each level when `level(run)` is given) against 15 minutes (funpixel.json
   `play_min_minutes` moves it) and the design doc's `Play length:` line. Under it is a warn: a game
@@ -48,7 +48,7 @@ the balance.
 - **ending**: `ended(run)` on the game names the ending (the last content reached, an end screen; a
   won outcome counts too), and the cohort reports `ended` (seeds) and `endedAt` (the mean second)
   apart from losses. A skilled run that never ends warns "no ending reached in 900 s" (content that
-  loops, as Riad Rush's three mazes did); an endless score attack says "on purpose" on its line.
+  loops, as one game's three mazes did); an endless score attack says "on purpose" on its line.
 - **curve** (with `level(run)`): clear rate, loss rate and time per level for each player. A flat
   level, a wall, a run nothing loses and a missing ramp are named ([escalation.md](escalation.md)).
   A human-rate twin of the sharp player (`humanRate(skilled, game.dt, { rest: 0 })` from `src/probe-human.ts`, 12 decisions a
@@ -77,14 +77,14 @@ wiring, and it replaces a hand-written bot script. A probe still importing the d
 so when `sim` runs it; `--timeout` gives a campaign probe more than 300 s, and anything the probe
 prints to stderr is shown.
 
-The worst case matters, not the average (Iron Line's playtest tracked the deepest overlap and
+The worst case matters, not the average (one game's playtest tracked the deepest overlap and
 the longest stuck time over 240 s of AI against AI). What should not happen at all goes in `broken()`.
 
 ## Stage the signature moment from the rules
 
 Critics judge stills, and a moment view that fakes its payoff shows a frame play cannot reach.
 `stageMoment(game, skilled, { seeds, at: [6, 8, 10, 12], window: 6, score })` plays each seed to
-each start time, then scores the events in the window after (Gesundheit's `moment.ts`: the longest
+each start time, then scores the events in the window after (the arcade game's `moment.ts`: the longest
 real chain within 6 s). `sim` prints the best seed and time. The moment view replays it through
 the rules:
 
@@ -97,7 +97,7 @@ const views = {
 `capture` then shoots a payoff the game really reaches, and a later rules change that breaks the
 moment shows up as a lower score in `sim`, not as a stale picture.
 
-## Numbers from Gesundheit (its own probes, 100 seeds unless named)
+## Numbers from one arcade game (its own probes, 100 seeds unless named)
 
 - Idle: the blind phone player idled about 12 s and wave 3 cleared itself. On today's rules an
   idle bee clears 0 of 40 seeds in every combat wave and lives 17 to 28 s (`idle-probe.ts`, 29 Sep).

package/plugins/claude/skills/game-logic/references/unity.md

@@ -1,9 +1,9 @@
 # Game logic in a Unity game
 
 Rules kept in plain C#, outside the engine, can be tested in seconds and played by bots thousands
-of times. That only helps when the tests and bots see what a player sees. Pocket Crew's first
+of times. That only helps when the tests and bots see what a player sees. A 3D platformer's first
 TestFlight build drew every moving platform frozen after the first level behind 1,118 green
-tests, and Porcelain Panic was tuned twice against bots that aimed worse than a person, who then
+tests, and a ball puzzle was tuned twice against bots that aimed worse than a person, who then
 cleared level 62 in one shot.
 
 ## Tools
@@ -13,7 +13,7 @@ learned with (`unity_check.py` among them) are proposed. "Partial" below means a
 studio's games, not in the kit. Until the starter ships, run what exists: `dotnet test` on an
 engine-free core (seconds, many agents at once), Unity's own test runner for the rest
 (`funtools unity run -- -nographics -runTests -testPlatform EditMode -testResults results.xml`,
-or `-testPlatform PlayMode` for tests that need a running scene, as Floe Jam's `FloeJam.PlayTests` do,
+or `-testPlatform PlayMode` for tests that need a running scene, as one game's `PlayTests` assembly does,
 queued one run per project across agents, and never with `-quit`: the test runner exits by itself), and each check below as an ordinary test in your own project.
 
 | Check | Pass | Status and tool |
@@ -22,14 +22,14 @@ queued one run per project across agents, and never with `-quit`: the test runne
 | `core_tests` | 0 failures, count ≥ baseline, csproj tracked | partial: a `CoreTests~` project; count and csproj checks proposed |
 | `core_engine_free` | no `UnityEngine` in Core | partial: compiler-enforced, no lint guards the flag |
 | `determinism_lint` | 0 uses of `Math.Round`, `List.Sort`, `Mathf.*` and similar outside the JS-math shims | proposed |
-| `web_goldens` | 0 diffs against web traces | partial: Hot Gates |
+| `web_goldens` | 0 diffs against web traces | partial: one port |
 | `rules_guard` | `Rules.Mobile` with fix flags off equals `Rules.WebParity` | partial: branches |
 | `alloc_quiet` | 0 B per warm sim step | partial: an allocation test in one game |
-| `balance_gate` | every character 40–60% at every AI level, N ≥ 200 per pairing | partial: Dawg Ball, one level only |
-| `difficulty_bots` | sharp bot ≥ 2 shots past onboarding; noisy bot ≥ 75% clears per section | partial: Porcelain Panic |
-| `softlock_bot` | 0 states with no valid action | partial: Dead Letter level tests |
-| `economy_pacing` | time to finish in band; offline pay ≤ next purchase | partial: Noodle Nights, Dawg Ball |
-| `physics_fuzz` | 0 inside-solid, tunnel, NaN or stuck | partial: Pocket Crew |
+| `balance_gate` | every character 40–60% at every AI level, N ≥ 200 per pairing | partial: one game, one level only |
+| `difficulty_bots` | sharp bot ≥ 2 shots past onboarding; noisy bot ≥ 75% clears per section | partial: one game |
+| `softlock_bot` | 0 states with no valid action | partial: one game's level tests |
+| `economy_pacing` | time to finish in band; offline pay ≤ next purchase | partial: two games |
+| `physics_fuzz` | 0 inside-solid, tunnel, NaN or stuck | partial: one game |
 
 `Rules` flags are default-off switches in the Core for experiments and mobile fixes. The report
 defines `Rules.WebParity` and `Rules.Mobile` only through `rules_guard`.
@@ -48,43 +48,43 @@ defines `Rules.WebParity` and `Rules.Mobile` only through `rules_guard`.
 
    | Pattern | Proof | Game |
    |---|---|---|
-   | Generated, solvable by construction | a solver test | Koi Out: 600 levels by reverse removal, 29 tests |
-   | Generated, fitted to a bot | budgets fitted to sharp-bot shots, then capped from human play | Porcelain Panic |
+   | Generated, solvable by construction | a solver test | a puzzle game: 600 levels by reverse removal, 29 tests |
+   | Generated, fitted to a bot | budgets fitted to sharp-bot shots, then capped from human play | the ball puzzle |
    | Data from the web build | level laws as tests | every port |
 
-   Level laws are properties held as tests. Pocket Crew's: widest gap, dock distance, player at
+   Level laws are properties held as tests. The platformer's: widest gap, dock distance, player at
    least 9% of screen height, every attack at least 0.6 s after its tell, plus a journey bot
    that frees all crew on 5 seeds.
 5. Set difficulty with two bots and a person. A sharp bot plays like a sharp player and gives
-   the floor; a noisy bot gives the clear rate; the cap comes from a person playing. Porcelain
-   Panic ended at budget = bot estimate × 0.5, capped at 10 balls (one room) and 14 (two).
+   the floor; a noisy bot gives the clear rate; the cap comes from a person playing. The ball
+   puzzle ended at budget = bot estimate × 0.5, capped at 10 balls (one room) and 14 (two).
 6. Gate balance at every AI level, on unseen seeds, one change at a time. Four matches per
    pairing is ±5 points of noise, so use 200. Run the sweep before building art for a rule
-   change: Dawg Ball built two rounds of goal art first.
+   change: a soccer game built two rounds of goal art first.
 7. Judge a power-up with paired seeds at large N. Pass: the holder's goal delta is under 0.3
-   either way (2,400 pairs, about 10 minutes, in Dawg Ball).
+   either way (2,400 pairs, about 10 minutes, in the soccer game).
 8. Simulate the economy with offline earnings and a spend-everything bot.
 9. Hold the warm sim step at 0 B of garbage with a test: a 40-robot chain went from 4 KB to 0 B
-   (game not in the report), and Hot Gates holds 0 B over 600 frames.
+   (game not in the report), and one port holds 0 B over 600 frames.
 10. Fuzz physics per level: a short fuzz every run, a deep fuzz before TestFlight.
 11. Test levels the way players reach them: enter each as a second or later level through Next,
     Continue or Restart (the check `entry_path`, proposed).
-12. Run each new regression test against the parent commit, where it must fail. A Dawg Ball
+12. Run each new regression test against the parent commit, where it must fail. A soccer-game
     cheat test passed on the old server too.
 13. Play by hand through remote input after the bots pass. Bots miss readability: hand play in
-    Pocket Crew found fans that looked walkable.
+    the platformer found fans that looked walkable.
 14. Test the save: migration from every earlier format and corruption (the games test 12 kinds of
     bad JSON). Unity's NUnit is old (no `Assert.Multiple`, no `Does.Contain` on an enum), so write
     those tests for the plain .NET project or keep to the old asserts.
 15. Treat a hit you are measuring against as a reference, not a target: measure it frame by frame
     (the owner's recording at `ffmpeg -vf fps=1`, contact sheets, a timed log) before copying a
-    number. Dawg Ball's ball was 40% too big and play 1.6× faster than Head Ball 2's; a taller goal
+    number. The soccer game's ball was 40% too big and play 1.6× faster than Head Ball 2's; a taller goal
     to match it added 15–20% goals and was rejected ("if it makes scoring too easy, don't"). A tempo
     of 0.75 matched its 10.5 goals per 90 s.
 
 ## Worked example
 
-Dawg Ball's balance gate (a three.js port with several characters and AI levels):
+The soccer game's balance gate (a three.js port with several characters and AI levels):
 1. A narrower pitch with ground goals looked fine at the "good" AI level.
 2. At the Alpha level it spread 33–68%.
 3. The dead end cost about 220,000 simulated matches.
@@ -93,16 +93,16 @@ Dawg Ball's balance gate (a three.js port with several characters and AI levels)
 
 ## Common mistakes
 
-- Tuning against a weak bot: Porcelain Panic's random-aim bot won 90–100% everywhere, and its
+- Tuning against a weak bot: the ball puzzle's random-aim bot won 90–100% everywhere, and its
   "human-style" bot left 33 balls on level 72. Two redesigns in two days.
-- Calibrating at one AI level: a Dawg Ball head then spread 15–76% at Alpha.
-- Leaving offline pay out of the economy sim: Noodle Nights paid about $50K for two hours away
+- Calibrating at one AI level: one head then spread 15–76% at Alpha.
+- Leaving offline pay out of the economy sim: an idle city game paid about $50K for two hours away
   at minute 5, about the price of the whole city. Offline pay is now ≤ the next pad's cost, and
   cost growth 1.12 gives a 162-minute city.
 - A bot that takes only legal actions: it missed food picked up with nowhere to deliver it
-  (reported with Noodle Nights).
-- Starting every level fresh at boot: Pocket Crew's movers drew frozen in every level after the
+  (reported with the idle game).
+- Starting every level fresh at boot: the platformer's movers drew frozen in every level after the
   first; the audit's frozen count went 219 → 0 once fixed.
-- Skipping the physics fuzz: Pocket Crew had 1,988 respawns inside solid geometry on 24 of 26
+- Skipping the physics fuzz: the platformer had 1,988 respawns inside solid geometry on 24 of 26
   levels.
-- A test that never asserts: Dawg Ball's "always ends with a winner" did not.
+- A test that never asserts: the soccer game's "always ends with a winner" did not.

package/plugins/claude/skills/game-spine/SKILL.md

@@ -70,7 +70,7 @@ bundles ESM packages, and a CDN script is a runtime fetch the build cannot see.
 
 No model was trained on `@funpixel/sdk`, so a guessed name costs a build, and a guess that
 type-checks can do nothing at runtime: look it up in [references/sdk.md](references/sdk.md) or
-`node_modules/@funpixel/sdk/dist/*.d.ts`, never cast it. Pin it exactly (`"0.6.0"`). The six worth
+`node_modules/@funpixel/sdk/dist/*.d.ts`, never cast it. Pin it exactly (`"0.7.0"`). The six worth
 using: `setupGameResize` from `@funpixel/sdk` (the only root export), `AudioEngine` from
 `@funpixel/sdk/audio`, `SaveManager` from `@funpixel/sdk/save`, `initLiveParams` from
 `@funpixel/sdk/liveParams`, `safeArea` from `@funpixel/sdk/device`, and `Room`, `getGameKey`,

package/plugins/claude/skills/game-spine/references/performance.md

@@ -86,10 +86,10 @@ handful of characters and some dozens of props spend about a millisecond in simu
 
 ## Worked examples
 
-- The per-stage frame budget: Knockout Lap's `src/game/prof.ts`, with its marks in
+- The per-stage frame budget: one racer's `src/game/prof.ts`, with its marks in
   `src/game/loop.ts` (private repository; copy the approach). It reads as `window.__FPX_PROF__()`
   and on screen behind `#prof`.
-- Measuring a load: Gallery Heist's repository (private; copy the approach, not a dependency) keeps
+- Measuring a load: one game's repository (private; copy the approach, not a dependency) keeps
   the measuring scripts in `game/tools/perf/`: `phone-load.mjs` (the throttled load: time to Play,
   bytes before it, long tasks and 20 s of play, as one JSON line), `phone-ab.sh` (builds
   alternated), `phone-profile.mjs` (a CPU profile of the load) and `gpu-mem.mjs` with `gputrack.js`