@codyswann/lisa 2.160.0 → 2.162.0

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

@@ -0,0 +1,89 @@
+---
+name: phaser-project-structure
+description: This skill should be used when creating, restructuring, or reasoning about a Phaser 4 game project — the game config, the Vite + TypeScript layout, the Boot → Preloader → MainMenu → Game scene flow, scale/resolution setup for desktop and mobile, and where code and assets belong. Use it before scaffolding a project, adding a major subsystem, or deciding where a file should live. Pairs with phaser-scenes, phaser-assets, phaser-rendering, and phaser-testing.
+---
+
+# Phaser 4 Project Structure
+
+## Overview
+
+This stack targets **Phaser 4** (v4.1+ "Salusa", npm package `phaser`), 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 [[phaser-rendering]].
+- `Phaser.HEADLESS` exists for logic-only boots (tests) — see [[phaser-testing]].
+
+## Scene flow
+
+Four-stage boot, in order (see [[phaser-scenes]] 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 [[phaser-assets]]), 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-cursor/skills/phaser-rendering/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: phaser-rendering
+description: This skill should be used when working on rendering in Phaser 4 — the render node architecture that replaced v3 pipelines, the unified Filter system that replaced FX and masks, tint modes, pixel-rounding options (roundPixels, smoothPixelArt, vertexRoundMode), DynamicTexture's buffered drawing, the Extern object for external WebGL, and lighting. Use it for any visual-effect, shader, mask, or custom-rendering task, and whenever v3 rendering idioms (setPipeline, preFX/postFX, BitmapMask, tintFill) appear. Pairs with phaser-gameobjects and phaser-v3-migration.
+---
+
+# Phaser 4 Rendering
+
+## Overview
+
+Phaser 4 replaced the entire v3 WebGL pipeline system with a **render node
+architecture**: small single-purpose nodes (each with a `run` method, batchable
+where it matters) that the renderer composes per object. WebGL state is fully
+managed, context loss restores automatically, and rendering is just-in-time —
+GPU work is deferred until actually needed. WebGL2 is fully supported; WebGL1
+still works; **there is no WebGPU backend**; the Canvas renderer is deprecated.
+
+Practical consequences, in order of how often they bite:
+
+## Filters replaced FX and masks
+
+The v3 `preFX`/`postFX` controllers and `BitmapMask` are gone. Phaser 4 has one
+unified **Filter** system that works on any GameObject **and on cameras**:
+
+- Geometry/bitmap masks → the `Mask` filter.
+- Bloom / Shine / Circle FX → `Phaser.Actions.AddEffectBloom()`,
+  `AddEffectShine()`, `AddMaskShape()` helpers.
+- Gradient FX → the new `Gradient` GameObject.
+- Filters split into **internal** and **external** lists (replacing the
+  pre/post distinction); filter setters are chainable.
+- A filtered or masked `Container` can itself be used as a mask source — new
+  capability, not possible in v3.
+
+## Tinting
+
+`tintFill` and `setTintFill()` were removed. Use `setTint(color)` plus
+`setTintMode(mode)` with `Phaser.TintModes`: `MULTIPLY` (default), `FILL`,
+`ADD`, `SCREEN`, `OVERLAY`, `HARD_LIGHT`.
+
+## Custom shaders and pipelines
+
+- A v3 custom pipeline must be rewritten as a **RenderNode**, registered at boot
+  via the game config's `render.renderNodes` map.
+- The `Shader` GameObject was rewritten: config-based constructor
+  (`ShaderQuadConfig`), explicit `setUniform()`, `renderImmediate`, GLSL
+  `#pragma` directives. Shadertoy-style automatic uniforms are gone.
+- **Never make raw WebGL calls** — wrap external GL renderers in the `Extern`
+  GameObject, which fences GL state around your code.
+- Texture coordinates now follow GL orientation (**Y=0 at bottom**). Phaser
+  translates standard usage automatically, but custom shaders and pre-compressed
+  textures must account for the flip (re-encode compressed textures).
+
+## Pixel rounding and pixel art
+
+- `roundPixels` defaults to **`false`** in v4 (v3: true). The old default caused
+  flicker on rotated/scaled objects; leave the new default alone.
+- Pixel-art projects choose ONE strategy: `pixelArt: true` (crisp,
+  nearest-neighbor) or `render.smoothPixelArt: true` (WebGL-only, anti-aliased
+  scaling/rotation of pixel art).
+- Per-object fine-tuning: `gameObject.vertexRoundMode` —
+  `"off" | "safe" | "safeAuto" | "full" | "fullAuto"`.
+
+## DynamicTexture / RenderTexture are buffered
+
+Draw commands no longer execute immediately — they queue until you call
+**`render()`**. Forgetting `render()` is the #1 "my RenderTexture is blank" bug
+in v4. Related: `preserve()` keeps a command buffer for reuse, `callback()`
+injects custom steps, and `RenderTexture#renderMode` selects
+`"render" | "redraw" | "all"`.
+
+## Lighting
+
+`setPipeline('Light2D')` is gone. Enable per object with
+`gameObject.setLighting(true)`; lights have an explicit `z`; self-shadowing is
+supported; lighting now works on many more object types (including particles).
+
+## Performance notes specific to the v4 renderer
+
+- Quads render from index buffers (4 vertices, not 6) and batching survives
+  multi-texture switches better, especially on mobile — but atlases are still
+  the foundation of batching ([[phaser-assets]]).
+- For massive draw counts use `SpriteGPULayer` / `TilemapGPULayer`
+  ([[phaser-gameobjects]]) instead of thousands of individual sprites.
+
+## Verification
+
+Rendering changes are verified visually in a real browser: `bun run dev`, then a
+Playwright screenshot assertion or manual confirmation that the effect renders
+and the console shows no WebGL errors. For filter/shader work, verify on both a
+WebGL2 and (if supported) WebGL1 context before calling it done.

package/plugins/lisa-phaser-cursor/skills/phaser-scenes/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: phaser-scenes
+description: This skill should be used when creating or editing Phaser 4 scenes — the init/preload/create/update lifecycle, starting/stopping/sleeping scenes, running scenes in parallel (HUD/pause overlays), passing data between scenes, the registry, and event-based communication. Use it when adding a scene, wiring scene transitions, or debugging lifecycle/ordering issues. Pairs with phaser-project-structure, phaser-assets, and phaser-gameobjects.
+---
+
+# Phaser 4 Scenes
+
+## Overview
+
+Scenes are Phaser's unit of game-flow composition. The lifecycle is unchanged
+from Phaser 3 — `init(data)` → `preload()` → `create(data)` → `update(time, delta)`
+— and each scene owns its display list, input, camera, time events, and (if
+enabled) physics world.
+
+One scene class per file under `src/scenes/`, exported as a class whose key
+matches the file name:
+
+```ts
+export class Game extends Phaser.Scene {
+  constructor() {
+    super("Game"); // the scene key — also a constant in src/assets.ts
+  }
+  init(data: GameStartData) { /* receive data, reset state */ }
+  preload() { /* per-scene late loads only — bulk loading is the Preloader's job */ }
+  create() { /* build GameObjects, wire input + events */ }
+  update(_time: number, delta: number) { /* per-frame; delta in ms */ }
+}
+```
+
+## Lifecycle rules
+
+- `init` receives the data passed by `scene.start(key, data)` — type that payload
+  (an interface per scene) instead of `any`.
+- `preload` in gameplay scenes should be rare; the Preloader scene loads the game
+  pack up front ([[phaser-assets]]). Use per-scene `preload` only for genuinely
+  scene-local or late-bound assets.
+- `create` is where GameObjects are built. Everything constructed here must be
+  cleaned up on shutdown if it lives outside the scene's display list (timers on
+  other scenes, global event listeners, DOM elements).
+- `update(time, delta)` runs per render frame. Frame-rate-independent movement
+  multiplies by `delta`; physics movement belongs in Arcade bodies, not manual
+  position math ([[phaser-physics]]).
+
+## Scene control
+
+Via `this.scene` (the ScenePlugin):
+
+- `start(key, data)` — stop the current scene, start another.
+- `launch(key, data)` — start another scene **in parallel** (HUD, pause overlay).
+- `pause` / `resume`, `sleep` / `wake` — suspend update/render without rebuild.
+- `stop(key)` — shuts a scene down (fires `Phaser.Scenes.Events.SHUTDOWN`).
+- `bringToTop` / `sendToBack` — z-order between parallel scenes.
+
+Overlay pattern: `Game` launches `HUD`; `HUD` renders score/health and listens to
+events from `Game`. Pause: launch `Pause`, `this.scene.pause("Game")`.
+
+## Communicating between scenes
+
+In preference order:
+
+1. **Events** — emit on the scene's own emitter and have the other scene listen:
+   `gameScene.events.emit("score-changed", score)`. Always remove listeners on
+   `SHUTDOWN`: `this.events.once(Phaser.Scenes.Events.SHUTDOWN, () => …)`.
+2. **`scene.start`/`launch` data** — for handoff at transition time.
+3. **The registry** (`this.registry`) — game-wide key/value store with change
+   events; for cross-cutting state like settings or the run seed.
+
+Never reach into another scene's GameObjects directly
+(`this.scene.get("Game").player.x = …`) — that couples scenes to each other's
+display-list internals and breaks when the other scene rebuilds.
+
+## Project conventions
+
+- Scene keys are constants in `src/assets.ts` (e.g. `SceneKeys.Game`) — `super(SceneKeys.Game)`.
+- A scene is an orchestrator: input wiring, GameObject lifecycles, and event
+  plumbing. Game rules live in `src/logic/**` and are called from the scene.
+- Per-scene state is reset in `init`, not in field initializers — scene classes
+  are instantiated once but started many times; stale fields from a previous run
+  are a classic restart bug.
+
+## Verification
+
+A scene change is verified by booting the game (`bun run dev`) and exercising the
+actual transition: start → play → (pause/resume or restart) → confirm no
+duplicated listeners (events firing twice after a restart is the canonical
+symptom of a missed `SHUTDOWN` cleanup).

package/plugins/lisa-phaser-cursor/skills/phaser-testing/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: phaser-testing
+description: This skill should be used when writing or designing tests for a Phaser 4 game — unit-testing pure game logic with Vitest, keeping logic Phaser-free so it tests without a browser, the Phaser.HEADLESS renderer for logic-only boots, asset-manifest coverage tests, and Playwright smoke tests that prove the game actually boots and renders. Use it when adding tests, setting up CI verification, or deciding what is testable at which level. Pairs with phaser-project-structure, phaser-assets, and phaser-physics.
+---
+
+# 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. **Playwright smoke test** — the game boots in a real browser, renders past
+   the Preloader, no console errors.
+
+There is no official Phaser testing harness — this layering IS the strategy.
+
+## 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 ([[phaser-assets]]).
+- **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).
+
+## Project conventions
+
+- `bun run test` = Vitest (layers 1–2, coverage-gated). Playwright smoke runs as
+  its own script/CI job against a built preview.
+- Tests never assert on private scene fields; they assert on logic outputs
+  (layer 1) or observable behavior (layer 4).
+
+## Verification
+
+The testing setup itself is verified when `bun run test` passes with coverage
+over `src/logic/**`, and the Playwright smoke fails when you deliberately break
+boot (rename a pack file) — a smoke test that can't fail is decoration.

package/plugins/lisa-phaser-cursor/skills/phaser-v3-migration/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: phaser-v3-migration
+description: This skill should be used when migrating a Phaser 3 game to Phaser 4, reviewing code that contains Phaser 3 idioms, or answering "does this v3 API still exist" questions — pipelines→render nodes, preFX/postFX/BitmapMask→Filters, tintFill→TintModes, removed namespaces (Geom.Point, Struct, Mesh/Plane, Camera3D, bundled Spine), config default changes, and texture-orientation changes. Pairs with phaser-rendering and phaser-project-structure.
+---
+
+# Phaser 3 → Phaser 4 Migration
+
+## Overview
+
+Phaser 4.0.0 "Caladan" (April 2026; current line v4.1 "Salusa") keeps the core
+game-facing API stable — scenes, input, Arcade/Matter physics, tweens,
+animations, audio, and the scale manager are **unchanged** — and replaces the
+rendering internals. The official estimate for a standard-API game is hours,
+not weeks. The npm package is still `phaser`; v4 ships its own
+`types/phaser.d.ts`.
+
+Upstream references for deeper detail: the official migration guide in the
+phaser repo (`changelog/v4/4.0/MIGRATION-GUIDE.md`) and the shader-specific
+guide. This skill is original Lisa content written against those primary
+sources — it is not a port of any upstream plugin or skill package.
+
+## What did NOT change (don't "migrate" these)
+
+Scene lifecycle (`init/preload/create/update`), `this.scene` control, Loader
+API (plus new `atlasPCT`), Input, Arcade & Matter physics, Tweens/Timelines,
+`anims`, Scale Manager, Sound managers, Groups, Containers, particle emitter
+API (v3.60 style).
+
+## The breaking changes, by frequency of impact
+
+| Phaser 3 | Phaser 4 |
+| --- | --- |
+| `setPipeline(...)` / `setPostPipeline(...)` / `resetPipeline()` | RenderNodes (`render.renderNodes` config) — rewrite required |
+| `preFX` / `postFX` controllers | Unified **Filter** system (internal/external lists) |
+| `BitmapMask` / `GeometryMask` | `Mask` filter; `Phaser.Actions.AddMaskShape()` |
+| Bloom/Shine/Circle FX | `Actions.AddEffectBloom()` / `AddEffectShine()` |
+| Gradient FX | `Gradient` GameObject |
+| `setTintFill(c)` / `tintFill` | `setTint(c)` + `setTintMode(Phaser.TintModes.FILL)` |
+| `setPipeline('Light2D')` | `gameObject.setLighting(true)`; lights gained `z` |
+| `Phaser.Geom.Point` | Removed — `Phaser.Math.Vector2` (geometry returns Vector2) |
+| `Phaser.Struct.Set` / `Struct.Map` | Native `Set` / `Map` |
+| Shadertoy-style `Shader` uniforms | Rewritten Shader: `ShaderQuadConfig`, `setUniform()`, `#pragma` |
+| RenderTexture/DynamicTexture draw-executes-immediately | **Buffered** — call `render()`; `preserve()`, `renderMode` |
+| Bundled Spine 3/4 plugins | Removed — Esoteric's official Phaser Spine runtime |
+| `Mesh`, `Plane`, OBJ loader, `Camera3D`, `Layer3D` | Removed, no replacement |
+| `Math.TAU` = π/2 (wrong) | `Math.TAU` = 2π (correct); `PI_OVER_2` added; `PI2` removed |
+| `Create.GenerateTexture`, polyfills, IE9 entry | Removed |
+
+## Behavior/default changes that silently alter a port
+
+- `roundPixels` default flipped **true → false**. If a pixel-art game looks
+  blurry after porting, set `pixelArt: true` (or `render.smoothPixelArt`) —
+  don't blanket-restore roundPixels.
+- **Texture Y-flip**: UVs are GL-oriented (Y=0 bottom). Standard usage is
+  translated automatically, but custom shaders and **compressed textures** must
+  be updated/re-encoded.
+- `Camera#matrix` no longer includes position (`matrixExternal` does;
+  `matrixCombined` removed) — affects code doing manual camera-space math.
+- `Grid` "outline" properties renamed to "stroke". TileSprite was rebuilt
+  (atlas frames, `tileRotation`; cropping removed). `DOMElement` without a
+  container parent now throws.
+
+## Migration procedure
+
+1. Bump `phaser` to `^4.1.0`; remove any `@types/phaser`.
+2. Typecheck — removed APIs surface as compile errors; fix using the table.
+3. Grep for the silent ones types won't catch: `Light2D`, `tintFill`,
+   `Math.TAU`, custom shader GLSL, compressed-texture loads.
+4. Rewrite pipelines/FX as RenderNodes/Filters ([[phaser-rendering]]); re-add
+   `render()` calls after DynamicTexture drawing.
+5. Swap Spine to the Esoteric runtime; check third-party plugins (`rex` users:
+   the v4 line is the separate `phaser4-rex-plugins` package, which also ships
+   `p3-fx` ports of the dropped v3 FX).
+6. Verify visually per [[phaser-rendering]] — renderer migrations produce
+   wrong-pixels bugs, not exceptions.
+
+## Project conventions
+
+This stack's lint config hard-bans the left column of the table in `src/**` —
+a migration is not complete until lint passes with those rules on, with zero
+disables.

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-rails",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "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.160.0",
+  "version": "2.162.0",
   "description": "Ruby on Rails-specific skills and hooks for RuboCop and ast-grep scanning on edit.",
   "author": {
     "name": "Cody Swann"

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "TypeScript-specific hooks for formatting, linting, and ast-grep scanning on edit.",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "TypeScript-specific hooks — Prettier formatting, ESLint linting, ast-grep scanning, and error-suppression blocking on edit",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "Distributable LLM Wiki kernel — ingest, query, lint, and maintain a git-native markdown knowledge base across Claude and Codex.",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

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

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.160.0",
+  "version": "2.162.0",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

package/plugins/src/harper-fabric/.claude-plugin/plugin.json

@@ -5,6 +5,14 @@
   "author": { "name": "Cody Swann" },
   "dependencies": ["lisa-typescript"],
   "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/block-generated-artifact-edits.sh" }
+        ]
+      }
+    ],
     "SessionStart": [
       { "matcher": "", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/inject-rules.sh" }] }
     ],

package/plugins/src/harper-fabric/generated-artifact-globs.txt

@@ -0,0 +1,4 @@
+harper-app/resources.js
+harper-app/resource-*.js
+harper-app/web/**
+harper-app/lib/**