@codyswann/lisa 2.195.4 → 2.195.7

package/plugins/lisa-phaser/.codex-plugin/skills/phaser-project-structure/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: phaser-project-structure
+description: "creating, restructuring, or…"
+---
+
+# Phaser 4 Project Structure
+
+## Overview
+
+This stack targets **Phaser 4** (v4.2+, npm package `phaser@^4.2.0`), built
+with **Vite + TypeScript** — the layout the official `phaserjs/template-vite-ts`
+template and `npm create @phaserjs/game@latest` scaffold. Phaser 4 ships its own
+type definitions (`types/phaser.d.ts`); do not add `@types/phaser`.
+
+## Canonical layout
+
+| Path | Role |
+| --- | --- |
+| `index.html` | Single page that loads `src/main.ts`; owns the game container div |
+| `src/main.ts` | Game config + `new Phaser.Game(config)` — the only bootstrap file |
+| `src/scenes/` | One scene class per file (`Boot.ts`, `Preloader.ts`, `MainMenu.ts`, `Game.ts`, …) |
+| `src/logic/` | Pure TypeScript game logic — **no `phaser` imports** (testable) |
+| `src/assets.ts` | Typed asset-key constants (texture, audio, anim, scene keys) |
+| `public/assets/` | Static assets served by Vite (atlases, audio, packs) — never imported |
+| `tests/` | Vitest unit tests for `src/logic/**` and pure helpers |
+| `dist/` | Vite build output — generated, never edited or committed |
+
+## The game config
+
+One config object in `src/main.ts`. The opinionated baseline:
+
+```ts
+const config: Phaser.Types.Core.GameConfig = {
+  type: Phaser.AUTO,            // WebGL; Canvas renderer is deprecated in v4
+  width: 1280,
+  height: 720,
+  parent: "game-container",
+  backgroundColor: "#028af8",
+  scale: {
+    mode: Phaser.Scale.FIT,
+    autoCenter: Phaser.Scale.CENTER_BOTH,
+  },
+  physics: {
+    default: "arcade",
+    arcade: { gravity: { x: 0, y: 0 }, debug: false }, // fixedStep defaults to true in v4 — keep it
+  },
+  scene: [Boot, Preloader, MainMenu, Game],
+};
+```
+
+v4-specific config facts:
+
+- `roundPixels` now defaults to **`false`** (v3 defaulted true). Leave it — the
+  new default prevents flicker on rotated/scaled objects.
+- Pixel-art games: `pixelArt: true` (nearest-neighbor + roundPixels), or the new
+  **`render.smoothPixelArt: true`** (WebGL-only) for pixel art that rotates or
+  scales smoothly. Pick one per project and record the choice.
+- Custom render nodes register under `render.renderNodes` — see the official `filters-and-postfx` skill.
+- `Phaser.HEADLESS` exists for logic-only boots (tests) — see [[phaser-testing]].
+
+## Scene flow
+
+Four-stage boot, in order (see the official `scenes` skill for lifecycle detail):
+
+1. **Boot** — loads only the handful of assets the Preloader's loading screen
+   needs (logo, progress-bar art). No game assets here.
+2. **Preloader** — renders the loading UI and loads everything else, preferably
+   via a single asset-pack manifest (see the official `loading-assets` skill), then starts MainMenu.
+3. **MainMenu** — entry UI; starts Game.
+4. **Game** (+ overlay scenes like `HUD`, `Pause` run in parallel) — gameplay.
+
+## Project conventions
+
+- All game code is TypeScript under `src/`; `bun run dev` (vite), `bun run build`
+  (vite build), `bun run preview` serve and package it.
+- Scenes orchestrate; they do not contain algorithmic game logic. Rules
+  evaluation, procedural generation, scoring, pathfinding, and state machines
+  live in `src/logic/` as pure functions/classes so Vitest can run them without
+  a browser.
+- Asset keys come from `src/assets.ts` constants — a typo in an inline string
+  key fails at runtime only; a typo in a constant fails at compile time.
+- Determinism: seed `Phaser.Math.RND` (or a local `RandomDataGenerator`) from a
+  single place; never `Math.random()` in game code.
+
+## Verification
+
+A structural change is verified when `bun run typecheck`, `bun run test`, and
+`bun run build` pass AND the game boots: `bun run dev`, open the page, confirm
+the canvas renders past the Preloader with no console errors.

package/plugins/lisa-phaser/.codex-plugin/skills/phaser-project-structure/agents/openai.yaml

@@ -0,0 +1,4 @@
+display_name: "Phaser Project Structure"
+short_description: "creating, restructuring, or…"
+default_prompt:
+  - "Use $phaser-project-structure: creating, restructuring, or…."

package/plugins/lisa-phaser/.codex-plugin/skills/phaser-services/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: phaser-services
+description: "wiring cross-cutting services…"
+---
+
+# Phaser 4 Services and Shared State
+
+## Overview
+
+Cross-cutting concerns — global state, app events, sound, input, save — live in
+`src/services/**` as thin, typed singletons, **not** scattered through scenes.
+Two rules anchor everything: state flows through a typed registry wrapper, and
+app messaging flows through **one dedicated EventsCenter** that is never
+`game.events`. Direct `localStorage` access outside `src/services/**` is
+lint-banned — persistence goes through SaveService.
+
+## Global state: a typed wrapper over the registry
+
+`this.registry` is a game-wide key/value `DataManager` shared across scenes. Raw
+access is stringly-typed and untestable, so wrap it once:
+
+```ts
+// src/services/state.ts
+interface GameState { coins: number; level: number; muted: boolean; seed: number; }
+const DEFAULTS: GameState = { coins: 0, level: 1, muted: false, seed: 0 };
+
+export class GameStore {
+  constructor(private reg: Phaser.Data.DataManager) {
+    for (const k in DEFAULTS) if (!reg.has(k)) reg.set(k, (DEFAULTS as any)[k]);
+  }
+  get<K extends keyof GameState>(k: K): GameState[K] { return this.reg.get(k); }
+  set<K extends keyof GameState>(k: K, v: GameState[K]) { this.reg.set(k, v); }
+  onChange<K extends keyof GameState>(k: K, fn: (v: GameState[K]) => void) {
+    const h = (_p: unknown, key: string, v: GameState[K]) => { if (key === k) fn(v); };
+    this.reg.events.on(Phaser.Data.Events.CHANGE_DATA, h);
+    return () => this.reg.events.off(Phaser.Data.Events.CHANGE_DATA, h); // caller .off()s in shutdown
+  }
+}
+```
+
+Construct it once (in Boot) and read it via the registry. Keys are typed by
+`GameState`, so a typo is a compile error. The registry holds *small* shared
+state (settings, run seed, currency) — not GameObjects and not per-frame data.
+
+## The EventsCenter bus (never `game.events`)
+
+App-level messaging ("enemy-died", "score-changed", "level-cleared") uses a
+single dedicated emitter. Reusing `game.events` (the engine's own bus) is
+lint-banned — it mixes your events with engine lifecycle events and is
+impossible to fully tear down.
+
+```ts
+// src/services/event-center.ts
+export const EventCenter = new Phaser.Events.EventEmitter();
+
+// typed key constants come from src/assets.ts (generated) — no raw strings
+import { GameEvent } from "../assets";
+EventCenter.emit(GameEvent.ScoreChanged, score);
+```
+
+## Listener discipline: every `.on()` has a matching `.off()`
+
+This is the leak rule the `require-shutdown-cleanup` lint rule and the testing
+leak gate ([[phaser-testing]]) enforce. **Any** external listener — `EventCenter`,
+`this.input`, `this.scale`, `this.time`, `window`, the registry — must be removed
+in the scene's `shutdown`. Listeners on the scene's own display objects die with
+the scene; external ones do not, and they fire again (doubled) after a restart.
+
+```ts
+export class Game extends Phaser.Scene {
+  private cleanups: Array<() => void> = [];
+
+  create() {
+    const onResize = (s: Phaser.Structs.Size) => this.layout(s.width, s.height);
+    this.scale.on(Phaser.Scale.Events.RESIZE, onResize);
+    this.cleanups.push(() => this.scale.off(Phaser.Scale.Events.RESIZE, onResize));
+
+    const onScore = (n: number) => this.hud.setScore(n);
+    EventCenter.on(GameEvent.ScoreChanged, onScore);
+    this.cleanups.push(() => EventCenter.off(GameEvent.ScoreChanged, onScore));
+
+    this.events.once(Phaser.Scenes.Events.SHUTDOWN, this.shutdown, this);
+  }
+
+  shutdown() { this.cleanups.forEach(fn => fn()); this.cleanups.length = 0; }
+}
+```
+
+Keeping the matching `.off()` next to each `.on()` (a `cleanups` array, or named
+handler methods you remove in `shutdown`) is the pattern that survives the leak
+gate. Prefer `.once()` where a listener should fire only once.
+
+## SoundService — audio unlock on first gesture
+
+Web Audio starts **suspended** until a user gesture; sound played before then is
+silently dropped ("works on my machine, silent on the phone"). Centralize the
+unlock and all playback:
+
+```ts
+// src/services/sound-service.ts
+export class SoundService {
+  private unlocked = false;
+  constructor(private sound: Phaser.Sound.BaseSoundManager, private store: GameStore) {}
+
+  attachUnlock(scene: Phaser.Scene) {
+    if (this.unlocked) return;
+    scene.input.once(Phaser.Input.Events.POINTER_DOWN, () => this.resume());
+    // Phaser also fires its own unlock; resume() is idempotent
+    this.sound.once(Phaser.Sound.Events.UNLOCKED, () => this.resume());
+  }
+  private resume() { if ((this.sound as any).context?.state === "suspended") (this.sound as any).context.resume(); this.unlocked = true; }
+  play(key: string, cfg?: Phaser.Types.Sound.SoundConfig) { if (!this.store.get("muted")) this.sound.play(key, cfg); }
+}
+```
+
+Scenes call `soundService.play(Sfx.Jump)` — never `this.sound.play("jump")`.
+Sound keys are generated constants ([[phaser-asset-pipeline]]).
+
+## InputService — semantic actions, not raw keys
+
+Scenes should ask "is *jump* down?", not "is the spacebar down?". A semantic
+layer makes rebinding, gamepads, and touch swap in without touching game code,
+and keeps replays deterministic (record actions, not hardware).
+
+```ts
+// src/services/input-service.ts
+export type Action = "left" | "right" | "jump" | "fire" | "pause";
+
+export class InputService {
+  private down = new Set<Action>();
+  private bindings: Record<number, Action> = {};
+  constructor(kb: Phaser.Input.Keyboard.KeyboardPlugin) {
+    this.bindings[Phaser.Input.Keyboard.KeyCodes.LEFT] = "left";
+    this.bindings[Phaser.Input.Keyboard.KeyCodes.SPACE] = "jump";
+    kb.on("keydown", (e: KeyboardEvent) => { const a = this.bindings[e.keyCode]; if (a) this.down.add(a); });
+    kb.on("keyup",   (e: KeyboardEvent) => { const a = this.bindings[e.keyCode]; if (a) this.down.delete(a); });
+  }
+  isDown(a: Action) { return this.down.has(a); }
+  snapshot(): readonly Action[] { return [...this.down]; } // for replay capture
+}
+```
+
+`update()` reads `input.isDown("jump")` and forwards the action set to pure logic
+in `src/logic/**`. (Register/remove the keyboard listeners with the same on/off
+discipline above.)
+
+## SaveService — versioned localStorage with a migration chain
+
+Raw `localStorage` outside `src/services/**` is lint-banned. Saves carry a schema
+`VERSION`; on load, unknown-but-older saves run forward through a migration chain,
+so an old player's data is never silently lost or crash-loaded.
+
+```ts
+// src/services/save-service.ts
+const KEY = "save:v"; const VERSION = 3;
+interface SaveV3 { version: 3; coins: number; unlocked: string[]; settings: { muted: boolean } }
+
+const migrations: Record<number, (s: any) => any> = {
+  1: s => ({ ...s, unlocked: [], version: 2 }),                 // v1 -> v2
+  2: s => ({ ...s, settings: { muted: false }, version: 3 }),  // v2 -> v3
+};
+
+export class SaveService {
+  load(): SaveV3 {
+    const raw = localStorage.getItem(KEY);                 // only legal localStorage access lives here
+    if (!raw) return this.fresh();
+    try {
+      let s = JSON.parse(raw);
+      while (s.version < VERSION) s = migrations[s.version](s);
+      return s as SaveV3;
+    } catch { return this.fresh(); }                       // corrupt save -> fresh, never crash
+  }
+  save(s: SaveV3) { localStorage.setItem(KEY, JSON.stringify({ ...s, version: VERSION })); }
+  private fresh(): SaveV3 { return { version: VERSION, coins: 0, unlocked: [], settings: { muted: false } }; }
+}
+```
+
+Bump `VERSION` and add the `n -> n+1` migration whenever the shape changes; never
+mutate the read path to "just handle" an old shape inline.
+
+## Errors and telemetry
+
+A vendor-neutral telemetry/analytics abstraction (`src/services/telemetry.ts`)
+exposes `track(event, props)` and `captureError(err, ctx)` behind a stable
+interface so the concrete sink (PostHog, Sentry, none) swaps without touching
+game code. Wire Phaser's error surfaces to it — `window.onerror`, the loader's
+`FILE_LOAD_ERROR`, and `try/catch` around scene transitions all route to
+`captureError`. Strings shown to players come from the i18n catalog
+([[phaser-i18n]]), never hardcoded.
+
+## Project conventions
+
+- Services live in `src/services/**`; that directory is the **only** place raw
+  `localStorage` is permitted.
+- One EventsCenter instance, exported once; never `game.events` for app events.
+- Every external `.on()` is paired with an `.off()` removed in `shutdown` (lint:
+  `require-shutdown-cleanup`; verified by the leak gate in [[phaser-testing]]).
+- Service logic that is pure (migrations, action mapping, mute gating) belongs in
+  or beside `src/logic/**` so Vitest covers it.
+
+## Verification
+
+Services are verified by the runtime gates: the leak gate ([[phaser-testing]])
+proves listeners are removed (start/stop a scene N times, counts return to
+baseline); a SaveService unit test feeds each old version through the migration
+chain and asserts the current shape; and on a real phone, the first tap unlocks
+audio (sound plays) — confirm before committing.
+</content>

package/plugins/lisa-phaser/.codex-plugin/skills/phaser-services/agents/openai.yaml

@@ -0,0 +1,4 @@
+display_name: "Phaser Services"
+short_description: "wiring cross-cutting services…"
+default_prompt:
+  - "Use $phaser-services: wiring cross-cutting services…."

package/plugins/lisa-phaser/.codex-plugin/skills/phaser-testing/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: phaser-testing
+description: "writing or designing tests for…"
+---
+
+# Phaser 4 Testing
+
+## Overview
+
+Games are testable when the game is not welded to the engine. The stack's test
+pyramid, bottom-up:
+
+1. **Vitest unit tests** over `src/logic/**` — the bulk of coverage.
+2. **Manifest/contract tests** — cheap structural checks (asset packs, scene
+   keys, anim definitions).
+3. **Headless integration** (sparingly) — `Phaser.HEADLESS` for things that
+   genuinely need the engine loop.
+4. **Playwright smoke** — the game boots in a real browser, renders past the
+   Preloader, no console errors.
+5. **CI runtime gates** — scenes/entities are excluded from unit coverage and
+   instead verified by deterministic runtime gates: boot smoke, allocation/perf
+   budget, leak gate, determinism gate, visual regression, bundle-size budget.
+
+There is no official Phaser testing harness — this layering IS the strategy. The
+dividing line: pure logic is unit-tested; everything that needs the engine is a
+runtime gate, never a brittle unit test that mocks the world.
+
+## Layer 1: pure logic under Vitest (the rule that makes it possible)
+
+`src/logic/**` contains game rules as plain TypeScript with **no `phaser`
+imports**: damage calculation, wave spawning schedules, inventory, scoring,
+state machines, procedural generation. Scenes call logic; logic never touches
+GameObjects.
+
+```ts
+// src/logic/score.ts
+export function comboMultiplier(streak: number): number { … }
+
+// tests/logic/score.test.ts — plain vitest, node environment, no browser
+import { comboMultiplier } from "../../src/logic/score";
+it("caps the combo multiplier at 8x", () => {
+  expect(comboMultiplier(999)).toBe(8);
+});
+```
+
+Determinism makes this work for anything random: logic takes a
+`Phaser.Math.RandomDataGenerator`-compatible interface (or just a `() => number`)
+as a parameter, production passes the seeded RND, tests pass a fixed sequence.
+
+If a piece of "logic" can't be tested without constructing a Scene, that is a
+design smell — extract the rule from the scene first, then test it.
+
+## Layer 2: contract tests
+
+Cheap tests that catch the silent runtime failures Phaser is famous for:
+
+- **Asset coverage**: every key constant in `src/assets.ts` appears in
+  `public/assets/pack.json` (and optionally vice versa). A missing pack entry
+  otherwise ships as a green-square texture (the official `loading-assets` skill).
+- **Scene registry**: every `SceneKeys` constant has a scene class registered in
+  the game config's `scene` array.
+- These are plain Vitest tests reading JSON/TS — no Phaser instance needed.
+
+## Layer 3: booting Phaser in tests (use sparingly)
+
+`Phaser.HEADLESS` (renderer type 3) boots a Game without creating a canvas or
+WebGL context — but Phaser still expects DOM-ish globals, so it needs a
+browser-like environment (jsdom/happy-dom) and careful teardown
+(`game.destroy(true)`). Reserve headless boots for integration tests of things
+that genuinely need the engine loop (scene transitions, timer events). Most of
+what people reach for headless to test belongs in Layer 1 instead.
+
+## Layer 4: Playwright smoke
+
+The non-negotiable end of the pyramid — proof the game runs:
+
+```ts
+test("game boots and renders", async ({ page }) => {
+  const errors: string[] = [];
+  page.on("pageerror", e => errors.push(e.message));
+  await page.goto("/");
+  const canvas = page.locator("canvas");
+  await expect(canvas).toBeVisible();
+  // Past the Preloader: poll a window hook the game sets, e.g. in MainMenu.create()
+  await page.waitForFunction(() => (window as never as { __sceneReady?: string }).__sceneReady === "MainMenu");
+  expect(errors).toEqual([]);
+  await expect(page).toHaveScreenshot("boot.png", { maxDiffPixelRatio: 0.02 });
+});
+```
+
+Convention: scenes set `window.__sceneReady = key` in `create()` (dev/test
+builds) so tests await real readiness instead of sleeping. Run against
+`bun run dev` (or `vite preview` in CI).
+
+## Layer 5: CI runtime gates (how scenes get verified)
+
+Scenes and entities are deliberately **excluded from unit coverage** — mocking
+the engine to "unit test" a scene tests the mock. Instead, CI runs a set of
+deterministic gates against a real (or headless) game. Each gate fails the build
+on regression; together they are the contract that the engine-coupled layer
+keeps working.
+
+**Boot smoke** — the Playwright test above, hardened: page error listener, wait
+for `__sceneReady`, assert zero console errors. This is the floor.
+
+**Allocation / perf budget** — run the game for N frames and assert the frame
+budget and heap growth. Per-frame allocation is what the `no-allocation-in-update`
+and `no-create-in-update` lint rules forbid statically; this gate catches what
+slips through dynamically.
+
+```ts
+test("steady-state frames stay within budget", async ({ page }) => {
+  await page.goto("/"); await bootTo(page, "Game");
+  const stats = await page.evaluate(async () => {
+    const g = (window as any).__game as Phaser.Game;
+    const frames: number[] = []; let last = performance.now();
+    for (let i = 0; i < 600; i++) { await new Promise(r => g.events.once("postrender", r)); const n = performance.now(); frames.push(n - last); last = n; }
+    return { p95: frames.sort((a,b)=>a-b)[Math.floor(frames.length*0.95)], heap: (performance as any).memory?.usedJSHeapSize };
+  });
+  expect(stats.p95).toBeLessThan(20); // ~50fps floor on CI hardware
+});
+```
+
+**Leak gate** — start and stop a scene N times and assert that texture count,
+event-listener count, active tweens, and timers all return to baseline. This is
+the runtime enforcement of the `require-shutdown-cleanup` rule and the
+on/off-discipline in [[phaser-services]].
+
+```ts
+test("scene start/stop leaves no leaks", async ({ page }) => {
+  await page.goto("/"); await bootTo(page, "MainMenu");
+  const before = await page.evaluate(() => (window as any).__game.textures.getTextureKeys().length);
+  for (let i = 0; i < 20; i++) await page.evaluate(async () => {
+    const g = (window as any).__game as Phaser.Game; g.scene.start("Game");
+    await new Promise(r => setTimeout(r, 50)); g.scene.stop("Game");
+    await new Promise(r => setTimeout(r, 50));
+  });
+  const after = await page.evaluate(() => (window as any).__game.textures.getTextureKeys().length);
+  expect(after).toBeLessThanOrEqual(before); // no per-cycle texture growth
+});
+```
+
+**Determinism gate** — boot twice with the same seed, drive the same inputs, and
+assert an identical state hash. Logic exposes a serializable snapshot; the gate
+hashes it. Same seed → same hash, always. This is the runtime backstop for the
+no-`Math.random()`/`Date.now()`/`performance.now()` rules ([[phaser-services]]).
+
+```ts
+const run = (seed: number) => page.evaluate(s => (window as any).__sim(s, REPLAY), seed);
+expect(hash(await run(1234))).toBe(hash(await run(1234)));
+```
+
+**Deterministic visual regression** — `toHaveScreenshot` under **software GL**
+(`--use-gl=swiftshader`), a **frozen frame** (pause the loop / step a fixed
+number of ticks at a fixed delta), and **masked dynamic regions** (timers,
+particles). Without all three, screenshots flake. Pin Playwright's browser and
+OS in CI so the baseline is stable.
+
+```ts
+await page.evaluate(() => { const g=(window as any).__game; g.loop.sleep(); g.step(0,16.6); });
+await expect(page).toHaveScreenshot("game.png", { mask: [page.locator("#timer")], maxDiffPixelRatio: 0.01 });
+```
+
+**Bundle-size budget** — assert the built bundle stays under a byte budget so a
+stray dependency or an un-split `phaser` chunk fails the PR. Wire it to the prod
+build's `manualChunks` split ([[phaser-build-deploy]]).
+
+```jsonc
+// size-limit / custom check after `bun run build`
+[{ "path": "dist/assets/index-*.js", "limit": "60 kB" },
+ { "path": "dist/assets/phaser-*.js", "limit": "400 kB" }]
+```
+
+## Project conventions
+
+- `bun run test` = Vitest (layers 1–2, coverage-gated **over `src/logic/**`
+  only** — scenes/entities are out of scope here). The layer-5 gates run as their
+  own CI jobs against a built `vite preview` (and a headless boot for the
+  determinism gate).
+- Build pins are part of the contract: `phaser ^4.2.0`, Vite, TypeScript 6.
+- Tests never assert on private scene fields; they assert on logic outputs
+  (layer 1), observable behavior (layer 4), or the runtime invariants the gates
+  measure (layer 5).
+
+## Verification
+
+The testing setup itself is verified when `bun run test` passes with coverage
+over `src/logic/**`, the Playwright smoke fails when you deliberately break boot
+(rename a pack file), and each layer-5 gate fails on its targeted regression —
+leak gate when a listener loses its `.off()`, determinism gate when a
+`Math.random()` sneaks in, visual gate when the frame changes. A gate that
+can't fail is decoration.

package/plugins/lisa-phaser/.codex-plugin/skills/phaser-testing/agents/openai.yaml

@@ -0,0 +1,4 @@
+display_name: "Phaser Testing"
+short_description: "writing or designing tests for…"
+default_prompt:
+  - "Use $phaser-testing: writing or designing tests for…."

package/plugins/lisa-phaser/hooks/inject-rules.sh

@@ -3,7 +3,7 @@
 # into Claude context at session/subagent start.
 set -euo pipefail
 
-ROOT="${CLAUDE_PLUGIN_ROOT:-${CODEX_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}"
+ROOT="${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-${CODEX_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}}"
 RULES_DIR="$ROOT/rules"
 
 [ -d "$RULES_DIR" ] || exit 0

package/plugins/lisa-phaser-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.195.4",
+  "version": "2.195.7",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-phaser-copilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.195.4",
+  "version": "2.195.7",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-phaser-copilot/hooks/inject-rules.sh

@@ -3,7 +3,7 @@
 # into Claude context at session/subagent start.
 set -euo pipefail
 
-ROOT="${CLAUDE_PLUGIN_ROOT:-${CODEX_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}"
+ROOT="${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:-${CODEX_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}}}"
 RULES_DIR="$ROOT/rules"
 
 [ -d "$RULES_DIR" ] || exit 0

package/plugins/lisa-phaser-cursor/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-phaser",
-  "version": "2.195.4",
+  "version": "2.195.7",
   "description": "Phaser 4 game-development rules for TypeScript projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-rails/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.195.4",
+  "version": "2.195.7",
   "description": "Ruby on Rails-specific hooks — RuboCop linting/formatting and ast-grep scanning on edit",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-rails/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.195.4",
+  "version": "2.195.7",
   "description": "Ruby on Rails-specific skills and hooks for RuboCop and ast-grep scanning on edit.",
   "author": {
     "name": "Cody Swann"
@@ -14,7 +14,7 @@
   "dependencies": [
     "lisa"
   ],
-  "skills": "./skills/",
+  "skills": "./.codex-plugin/skills/",
   "hooks": "./.codex-plugin/hooks.json",
   "interface": {
     "displayName": "Lisa Rails",