@pixerate/editor 0.222.1 → 0.222.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.222.1",
+  "version": "0.222.3",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

package/skills/README.md

@@ -47,6 +47,12 @@ request like "clean up this export" finds it.
 | [`pixerate-vector-icon-set`](pixerate-vector-icon-set/SKILL.md) | Vector (`pixerate-vector`) | Icons on one grid with padding, one stroke, cap, join and radius, crisp coordinates, clean paths, symbols and SVG export. |
 | [`pixerate-vector-logo`](pixerate-vector-logo/SKILL.md) | Vector (`pixerate-vector`) | Marks from primitives with live booleans, optical corrections, an aligned lockup, colour variants as symbols, outlined delivery files. |
 | [`pixerate-vector-illustration`](pixerate-vector-illustration/SKILL.md) | Vector (`pixerate-vector`) | Block in back to front, gradients and stacked fills for form, masks, blends, subtle shadows with one light, export. |
+| [`pixerate-paint-watercolour`](pixerate-paint-watercolour/SKILL.md) | Paint (`pixerate-paint-editor`) | Watercolour paper, light to dark with the paper's white kept, wet-in-wet and wet-on-dry washes, drying before glazing, steering the water. |
+| [`pixerate-paint-oil-impasto`](pixerate-paint-oil-impasto/SKILL.md) | Paint (`pixerate-paint-editor`) | A toned ground, thin block-in to thick paint, pigment mixing, impasto relief and its light. |
+| [`pixerate-paint-sketch-to-finish`](pixerate-paint-sketch-to-finish/SKILL.md) | Paint (`pixerate-paint-editor`) | Sketch, ink, flats under the lines, clipped shading and light, one named layer per pass. |
+| [`pixerate-video-social-cut`](pixerate-video-social-cut/SKILL.md) | Video (`pixerate-video-editor`) | Vertical or square reframes that fill the frame, the hook first, platform lengths, titles in the safe area. |
+| [`pixerate-video-colour-grade`](pixerate-video-colour-grade/SKILL.md) | Video (`pixerate-video-editor`) | Correct and match shots, then one look on an adjustment clip; LUTs at moderate strength with skin protected. |
+| [`pixerate-video-montage`](pixerate-video-montage/SKILL.md) | Video (`pixerate-video-editor`) | Selects on the beat, varied pacing, short transitions with handles, music under everything and a clean ending. |
 | [`pixerate-talking-head-edit`](pixerate-talking-head-edit/SKILL.md) | Video (`pixerate-video-editor`) | Talking-head cleanup by transcript: fillers, long pauses and stutters found in one pass and cut as one plan reviewed before it applies. Owns the dialogue tools. |
 | [`pixerate-bgm-alignment`](pixerate-bgm-alignment/SKILL.md) | Video (`pixerate-video-editor`) | Background music: beats and cuts on the beat, ducking under speech, loudness in LUFS. Owns the music tools. |
 
@@ -110,7 +116,8 @@ same change.
   `packages/core/tests/agent-skill-evals.test.ts`. An eval has a `prompt` (the task, in the
   user's words), a `fixture` (the starting document: `{ "editor": "spreadsheet", "rows" }`,
   `{ "editor": "image", "width", "height", "background", "shapes" }` or `{ "editor":
-  "vector", "width", "height", "setup" }` with commands that draw the starting art), `checks` (a read-only
+  "vector", "width", "height", "setup" }` with commands that draw the starting art, 
+  `{ "editor": "paint", "width", "height", "setup" }` or `{ "editor": "video", "setup" }` with tool calls), `checks` (a read-only
   tool, or `run_command` with a read-only command such as `vector.list`, its `args`, what its result must match in `expect`, and `why`) and a `solution` (the
   tool calls an expert would make). The test proves each eval: some check fails on the fixture,
   and all pass after the solution. A model harness runs the same file with the model in place

package/skills/pixerate-paint-editor/SKILL.md

@@ -47,6 +47,15 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
 - **Undo**: one tool call that changes the painting is one undo step (`undo_paint`). Brush,
   colour, view, hand and the Mixer Brush load are editor state, not undo steps.
 
+## Workflow skills
+
+For these jobs, load the workflow skill too: it has the method, the checks between steps and
+the pitfalls, and uses the tools below.
+
+- `pixerate-paint-watercolour`: paper, light to dark, wet-in-wet and wet-on-dry, drying and glazing.
+- `pixerate-paint-oil-impasto`: toned ground, thin to thick, pigment mixing, impasto and its light.
+- `pixerate-paint-sketch-to-finish`: sketch, ink, flats, clipped shading and light, one layer per pass.
+
 ## Working method
 
 1. **Read.** `get_canvas_info` (size, paper, active layer, active brush, colour), then
@@ -82,8 +91,7 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
    `repeat` for hatching, grass, foliage, rows, fans or spirals, in one undo step.
 8. **Check** with `render_preview` after each block of work, not after each stroke.
    `pick_color` reads exact values. Undo what made it worse.
-9. **Watercolour** is its own way of working (see "Wet media" below): wet the paper or not,
-   lay washes light to dark, let them flow (`advance_wet_paint`), dry them (`dry_paint`), glaze.
+9. **Watercolour** is its own way of working: see "Wet media" below.
 10. **Deliver**: `export_image` (PNG, or JPEG / WebP in a browser), `export_psd` for Photoshop,
    `save_paint_document` to keep the painting with its strokes (when the host has storage).
 
@@ -133,71 +141,24 @@ is never part of a layer. Coordinates are document pixels, (0, 0) top-left, y do
 
   PSD has none of them: `export_psd` writes the nearest standard mode (watercolor and shadow
   as Multiply, tint as Color, highlight as Screen) and warns; the merged image stays exact.
-- **Grow the canvas instead of starting big**: when the picture needs more room, call
-  `extend_canvas` with the pixels to add on each side (nothing painted moves relative to
-  anything else). Adding on the `left` or `top` shifts every coordinate you hold (stroke points,
-  guide and stencil positions, layer bounds) by (+left, +top); re-read with `list_layers` or use
-  the returned `rect` (the new canvas in the old coordinates). Wet paint dries first, so finish
-  or dry a wash (`dry_paint`) before extending. `set_canvas` only crops or grows at the
-  bottom-right and never moves the picture.
+- **Grow the canvas instead of starting big** with `extend_canvas` (pixels per side; nothing
+  painted moves relative to anything else). Adding `left` or `top` shifts every coordinate you
+  hold by (+left, +top): re-read `list_layers` or use the returned `rect`. Dry wet paint first.
+  `set_canvas` only crops or grows at the bottom-right.
 - **Save brushes you build** (`set_brush` then `save_brush`), and share them with
   `export_brushes` / `import_brushes`.
 
 ## Wet media
 
-1. **Choose a watercolour paper** (`cold-pressed`, `rough-watercolor` for granulation and broken
-   edges, `hot-pressed` for smooth washes). Absorption, permeability and roughness of the paper
-   drive the simulation.
-2. **Plan light to dark.** Watercolour is transparent: you cannot paint light over dark (use
-   `gouache`, body 1, for that). Lay the lightest washes first.
-3. **Wet-in-wet or wet-on-dry.** `wet_paper` over an area first for soft, feathered, blooming
-   colour (skies, backgrounds); paint on dry paper for crisp edges with a darker rim.
-4. **Paint washes** with `watercolor-wash` (large, flat, very wet) in a few long strokes, then
-   shapes with `watercolor-round`, details with `watercolor-detail`. Colours touching while wet
-   bleed into each other; that is the point.
-5. **Let it flow, then dry.** `advance_wet_paint` (`seconds` 1..5) to let water spread, run and
-   bloom; `render_preview` shows the paint as it is now (wet paper looks a little darker).
-   `dry_paint` sets it where it is. Dry before glazing a second wash over a first, or the two
-   mix instead of layering.
-6. **Steer the water** with the wet tools: `add-water` (softens and lifts with `rewet`),
-   `hair-dryer` (stops a wash spreading), `blow` (pushes the water along the stroke),
-   `wet-blend` (evens out a wash), `wet-drag` (drags wet paint), `blot` (lifts wet paint: clouds,
-   highlights). `set_canvas_tilt` makes washes run downhill and very wet paint drip;
-   `set_flow_map` pushes water in a swirl, a direction or eddies.
-7. **Tune the medium** per layer with `set_wet_settings`: `granulation` (grainy pigment, needs a
-   rough paper), `edgeDarkening`, `bloom`, `bleed`, `viscosity` (runny .. thick), `evaporation`,
-   `pigmentWeight`, `pickup` (how easily dried paint lifts), `fixture` (staining).
-
-- **Saving dries the paint** (deterministically): the saved file and every export hold dried
-  pixels; the editor keeps painting wet. A dry brush, fill, merge or duplicate on a wet layer
-  dries it first (in the same undo step).
-- **Time** runs by itself in an editor on screen (`pause_wet_paint` stops it); for an agent with
-  no screen, nothing moves until `advance_wet_paint` or `dry_paint`.
-- **The GPU only draws.** With WebGPU and a large wet area (16 tiles of 256 px by default), Engine B
-  shades the wet paint on the GPU; the CPU engine still computes every step, so the painting,
-  `dry_paint`, saving, export and replay come out the same with it on or off. `get_wet_paint`
-  shows it as `engine` (`state`, `reason`). Leave it on `auto`; `set_wet_engine` with `gpu` "off"
-  only when the user says the display looks wrong or the GPU is needed for something else.
+Watercolour, gouache and wet oil run on a fluid simulation: lay washes light to dark, let them
+flow (`advance_wet_paint`), dry them (`dry_paint`) before glazing. Nothing moves for an agent
+until you advance or dry it, and saving dries the paint. Load `pixerate-paint-watercolour`, and
+read [references/wet-media.md](references/wet-media.md) for the engine and the wet tools.
 
 ## Oils and thick paint
 
-- **Wet oil** (`oil-round`, `oil-flat`; any wet brush with `wet.medium: "oil"`) runs on the wet
-  simulation as a thick, slow-drying medium: it barely flows, stays wet for minutes of simulated
-  time, and the brush picks up and mixes the wet oil it meets (`behavior.pickup` / `mix`), so
-  colours blend on the canvas. A layer takes the medium's wet settings the first time it holds
-  wet paint; keep oil and watercolour on separate layers. `set_instant_dry` on makes every wet
-  stroke dry as it ends (strokes stay exactly as laid).
-- **Thick paint** (`engine: "impasto"`, category `impasto`) gives a layer relief (height) and
-  material (gloss, metallic) next to its colour, lit at render time by `set_lighting`
-  (azimuth, elevation, relief). Tools: `impasto-brush` (bristle ridges), `paint-tube` (blobs),
-  `palette-knife` (scrapes the relief flat and smears the paint), `paint-roller` (flat stippled
-  band), `gloop-pen` (glossy bead), `metallic-paint` (highlights in the paint's colour).
-- **Loading and thinner**: `wet.load` / `impasto.load` below 1 make the brush run out along a
-  long stroke (dry-brush ends); `thinner` makes paint flatter and more transparent.
-- **Light** is a view of the relief, not paint: move it (`set_lighting`) to read the texture
-  (a low elevation, 15..30°, shows brushwork best) and pick the final light before exporting.
-  `get_relief` reads a layer's relief; `flatten_relief` removes it but keeps the colour.
-- **Metallic paper**: `set_paper` `metallic` 0..1 makes the grain sparkle under the light.
+Wet oil barely flows and blends where the brush meets it; impasto brushes add relief lit by
+`set_lighting`. Load `pixerate-paint-oil-impasto`, and read [references/oils.md](references/oils.md).
 
 ## Gradient paint
 

package/skills/pixerate-paint-editor/references/oils.md

@@ -0,0 +1,19 @@
+# Oils and thick paint
+
+- **Wet oil** (`oil-round`, `oil-flat`; any wet brush with `wet.medium: "oil"`) runs on the wet
+  simulation as a thick, slow-drying medium: it barely flows, stays wet for minutes of simulated
+  time, and the brush picks up and mixes the wet oil it meets (`behavior.pickup` / `mix`), so
+  colours blend on the canvas. A layer takes the medium's wet settings the first time it holds
+  wet paint; keep oil and watercolour on separate layers. `set_instant_dry` on makes every wet
+  stroke dry as it ends (strokes stay exactly as laid).
+- **Thick paint** (`engine: "impasto"`, category `impasto`) gives a layer relief (height) and
+  material (gloss, metallic) next to its colour, lit at render time by `set_lighting`
+  (azimuth, elevation, relief). Tools: `impasto-brush` (bristle ridges), `paint-tube` (blobs),
+  `palette-knife` (scrapes the relief flat and smears the paint), `paint-roller` (flat stippled
+  band), `gloop-pen` (glossy bead), `metallic-paint` (highlights in the paint's colour).
+- **Loading and thinner**: `wet.load` / `impasto.load` below 1 make the brush run out along a
+  long stroke (dry-brush ends); `thinner` makes paint flatter and more transparent.
+- **Light** is a view of the relief, not paint: move it (`set_lighting`) to read the texture
+  (a low elevation, 15..30°, shows brushwork best) and pick the final light before exporting.
+  `get_relief` reads a layer's relief; `flatten_relief` removes it but keeps the colour.
+- **Metallic paper**: `set_paper` `metallic` 0..1 makes the grain sparkle under the light.

package/skills/pixerate-paint-editor/references/wet-media.md

@@ -0,0 +1,35 @@
+# Wet media
+
+1. **Choose a watercolour paper** (`cold-pressed`, `rough-watercolor` for granulation and broken
+   edges, `hot-pressed` for smooth washes). Absorption, permeability and roughness of the paper
+   drive the simulation.
+2. **Plan light to dark.** Watercolour is transparent: you cannot paint light over dark (use
+   `gouache`, body 1, for that). Lay the lightest washes first.
+3. **Wet-in-wet or wet-on-dry.** `wet_paper` over an area first for soft, feathered, blooming
+   colour (skies, backgrounds); paint on dry paper for crisp edges with a darker rim.
+4. **Paint washes** with `watercolor-wash` (large, flat, very wet) in a few long strokes, then
+   shapes with `watercolor-round`, details with `watercolor-detail`. Colours touching while wet
+   bleed into each other; that is the point.
+5. **Let it flow, then dry.** `advance_wet_paint` (`seconds` 1..5) to let water spread, run and
+   bloom; `render_preview` shows the paint as it is now (wet paper looks a little darker).
+   `dry_paint` sets it where it is. Dry before glazing a second wash over a first, or the two
+   mix instead of layering.
+6. **Steer the water** with the wet tools: `add-water` (softens and lifts with `rewet`),
+   `hair-dryer` (stops a wash spreading), `blow` (pushes the water along the stroke),
+   `wet-blend` (evens out a wash), `wet-drag` (drags wet paint), `blot` (lifts wet paint: clouds,
+   highlights). `set_canvas_tilt` makes washes run downhill and very wet paint drip;
+   `set_flow_map` pushes water in a swirl, a direction or eddies.
+7. **Tune the medium** per layer with `set_wet_settings`: `granulation` (grainy pigment, needs a
+   rough paper), `edgeDarkening`, `bloom`, `bleed`, `viscosity` (runny .. thick), `evaporation`,
+   `pigmentWeight`, `pickup` (how easily dried paint lifts), `fixture` (staining).
+
+- **Saving dries the paint** (deterministically): the saved file and every export hold dried
+  pixels; the editor keeps painting wet. A dry brush, fill, merge or duplicate on a wet layer
+  dries it first (in the same undo step).
+- **Time** runs by itself in an editor on screen (`pause_wet_paint` stops it); for an agent with
+  no screen, nothing moves until `advance_wet_paint` or `dry_paint`.
+- **The GPU only draws.** With WebGPU and a large wet area (16 tiles of 256 px by default), Engine B
+  shades the wet paint on the GPU; the CPU engine still computes every step, so the painting,
+  `dry_paint`, saving, export and replay come out the same with it on or off. `get_wet_paint`
+  shows it as `engine` (`state`, `reason`). Leave it on `auto`; `set_wet_engine` with `gpu` "off"
+  only when the user says the display looks wrong or the GPU is needed for something else.

package/skills/pixerate-paint-oil-impasto/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: pixerate-paint-oil-impasto
+description: The oil and impasto workflow in the Pixerate paint editor - a toned ground on canvas, blocking in thin and building to thick (fat over lean), mixing colours as real pigment, blending wet oil on the canvas, thick impasto paint with relief from brushes, tubes and palette knives, lighting the relief, and keeping thick passages on their own layers. Use when asked to paint in oils or acrylics, paint thickly, add impasto or texture, use a palette knife, mix paint, block in a painting, or paint with visible brushwork, or when set_lighting, get_relief, mix_colors or the oil, impasto and bristle brushes are available. Load with pixerate-paint-editor, which lists every tool.
+metadata:
+  kind: workflow
+  reference: pixerate-paint-editor
+---
+
+# Painting in oils and impasto
+
+An oil painting is built in passes: a toned ground, a thin block-in of the big shapes and
+values, then thicker, more opaque paint for the forms, and the thickest paint last for the
+lights. Wet oil (`oil-round`, `oil-flat`) barely flows and stays wet, so the brush picks up and
+mixes what it meets. Thick paint (the `impasto` brushes) also gives the layer relief, which a
+movable light shows at render time.
+
+This skill is the method. `pixerate-paint-editor` has the full tool reference and
+`references/oils.md` the media's detail.
+
+## Goal and quality bar
+
+- Lean to fat: thin paint first, thick paint on top; the thickest paint in the lights.
+- Colours mixed as pigment (`mix_colors` predicts Kubelka-Munk mixes: blue and yellow make
+  green, white tints), from a small palette.
+- Relief where it reads: highlights and focal areas thick, shadows and background thin
+  (`get_relief` `maxHeight` on the thick layer).
+- One light on the relief, chosen deliberately (`set_lighting`), and the thick passages on
+  their own layers so they can be changed.
+
+## Inputs to confirm
+
+- **Subject and palette.**
+- **Texture:** smooth and blended, or heavy impasto with visible brushwork and knife marks.
+- **Light direction** for the relief, if the user has one in mind (default top-left).
+
+## Working method
+
+1. **Ground.** `set_paper` `cotton-canvas` or `fine-linen` (or `gesso` for a smooth panel);
+   `fill_layer` a mid-tone ground (a warm earth or grey) on the bottom layer.
+   **Check:** `get_canvas_info` paper; `pick_color` shows the ground.
+2. **Mix the palette.** `mix_colors` for each mixture (read `mixed`), `add_swatch` to keep them;
+   `color_harmony` around a key colour if needed.
+3. **Block in thin.** `add_layer` "Block-in"; `oil-flat` or `bristle-flat` with large strokes,
+   the big shapes and values only, darks first.
+   **Check:** `list_strokes` shows the thin brushes; `render_preview` reads as a simple value
+   study.
+4. **Build the forms.** `oil-round` on a new layer, more opaque and more colour; let the brush
+   pick up and blend wet paint (`behavior.pickup` 0.3-0.6) for soft turns of form; `blender`
+   for transitions.
+5. **Thick paint last.** `add_layer` "Impasto"; `impasto-brush` for ridged strokes,
+   `palette-knife` to scrape and smear, `paint-tube` for blobs, in the lights and focal areas.
+   **Check:** `get_relief` on that layer has `maxHeight` well above 0.
+6. **Light the relief.** `set_lighting` `azimuth` (degrees clockwise from the top: 315 top-left,
+   45 top-right), `elevation` 15-30 to show brushwork, 40-60 for a calmer surface.
+   **Check:** `get_relief` `lighting` is what you set; `render_preview` to look.
+7. **Finish.** Details and accents; export. `flatten_relief` only if the user wants the colour
+   without texture.
+
+## Decision table
+
+| Want | Brush or tool |
+| --- | --- |
+| Large, thin block-in | `oil-flat`, `bristle-flat` |
+| Soft blended form | `oil-round` with pick-up; `blender` |
+| Visible bristle ridges | `impasto-brush`, `bristle-round` |
+| Scraped, smeared texture | `palette-knife` |
+| Blobs of paint straight from the tube | `paint-tube` |
+| A glossy bead or line | `gloop-pen` |
+| Dry, broken strokes over texture | `dry-brush`, or a lower `impasto.load` |
+| A metallic highlight | `metallic-paint` |
+| Paint that stays exactly as laid | `set_instant_dry` on |
+
+## Recipes
+
+**Mixed green.** `mix_colors` `{ colors: [{ color: "#1f3a93", weight: 1 }, { color: "#f2c500",
+weight: 1 }] }` → `set_color` with the result's `mixed` → `set_brush` `oil-round` →
+`paint_stroke`.
+
+**Impasto highlights.** `add_layer` "Impasto" → `set_brush` `impasto-brush` → `set_color` a
+light → short strokes following the form → `set_lighting` → `get_relief`.
+
+## Pitfalls
+
+- **Thick before thin.** Heavy paint in the block-in fights every later pass; keep it lean.
+- **Mud from over-mixing.** A brush with high pick-up dragged through many colours greys them;
+  `clean_mixer_brush` and fewer passes.
+- **RGB mixing in your head.** Blue and yellow light make grey; paint makes green; use
+  `mix_colors`.
+- **Relief everywhere.** Uniform texture flattens the picture; keep shadows thin.
+- **Oil and watercolour on one layer.** A layer keeps the first medium's wet settings.
+- **A lighting change is global**: it lights every thick layer; pick it once, near the end.
+
+## Tools used
+
+- `get_canvas_info`, `list_layers`, `list_strokes`, `render_preview`, `pick_color`: read and check
+- `set_paper`, `fill_layer`: canvas and a toned ground
+- `add_layer`, `update_layer`: a layer per pass
+- `mix_colors`, `color_harmony`, `add_swatch`, `set_color`: palette
+- `set_brush`, `paint_stroke`, `clean_mixer_brush`: block in, build, blend and impasto strokes
+- `set_lighting`, `get_relief`, `flatten_relief`: the relief and its light
+- `set_instant_dry`: strokes that dry as they end
+- `undo_paint`: take back a step
+- `export_image`: deliver

package/skills/pixerate-paint-oil-impasto/evals/impasto-highlights.json

@@ -0,0 +1,24 @@
+{
+	"prompt": "Add a thick impasto highlight stroke across the middle of this painting on its own layer, so I can remove it later, and light the paint from the top right.",
+	"fixture": {
+		"editor": "paint",
+		"width": 64,
+		"height": 64,
+		"setup": [
+			{ "tool": "set_paper", "args": { "preset": "cotton-canvas" } },
+			{ "tool": "fill_layer", "args": { "color": "#3b5b7a" } }
+		]
+	},
+	"checks": [
+		{ "why": "the highlight is on a new layer above the painting", "tool": "list_layers", "expect": { "layers": { "$length": { "$min": 2 }, "$expr": "v[0].type === 'pixel' && v[0].bounds !== null && v[v.length - 1].bounds !== null" } } },
+		{ "why": "thick paint with relief on that layer", "tool": "get_relief", "expect": { "relief": { "maxHeight": { "$min": 50 } } } },
+		{ "why": "lit from the top right", "tool": "get_relief", "expect": { "lighting": { "azimuth": { "$min": 20, "$max": 70 } } } }
+	],
+	"solution": [
+		{ "tool": "add_layer", "args": { "name": "Impasto highlights" } },
+		{ "tool": "set_brush", "args": { "id": "impasto-brush" } },
+		{ "tool": "set_color", "args": { "color": "#f4e7c5" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 8, "y": 32 }, { "x": 56, "y": 30 }] } },
+		{ "tool": "set_lighting", "args": { "azimuth": 45 } }
+	]
+}

package/skills/pixerate-paint-oil-impasto/evals/lean-to-thick.json

@@ -0,0 +1,17 @@
+{
+	"prompt": "Paint this the traditional way: block in the background first with thin paint, then build the subject in the centre with thick paint on top.",
+	"fixture": { "editor": "paint", "width": 64, "height": 64, "setup": [{ "tool": "set_paper", "args": { "preset": "cotton-canvas" } }] },
+	"checks": [
+		{ "why": "thin paint first", "tool": "list_strokes", "expect": { "strokes": { "$expr": "v.length >= 2 && ['oil-round', 'oil-flat', 'bristle-flat', 'bristle-round', 'dry-brush'].includes(v[0].brushId)" } } },
+		{ "why": "thick paint after it", "tool": "list_strokes", "expect": { "strokes": { "$expr": "v.slice(1).some((s) => ['impasto-brush', 'palette-knife', 'paint-tube', 'gloop-pen'].includes(s.brushId))" } } },
+		{ "why": "the thick paint stands up from the canvas", "tool": "get_relief", "expect": { "relief": { "maxHeight": { "$min": 50 } } } }
+	],
+	"solution": [
+		{ "tool": "set_brush", "args": { "id": "oil-flat" } },
+		{ "tool": "set_color", "args": { "color": "#6b7f6a" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 0, "y": 8 }, { "x": 64, "y": 8 }, { "x": 64, "y": 24 }, { "x": 0, "y": 24 }, { "x": 0, "y": 40 }, { "x": 64, "y": 40 }, { "x": 64, "y": 56 }, { "x": 0, "y": 56 }] } },
+		{ "tool": "set_brush", "args": { "id": "impasto-brush" } },
+		{ "tool": "set_color", "args": { "color": "#d9783b" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 24, "y": 32 }, { "x": 40, "y": 32 }] } }
+	]
+}

package/skills/pixerate-paint-oil-impasto/evals/mix-green.json

@@ -0,0 +1,15 @@
+{
+	"prompt": "Mix a green from ultramarine (#1f3a93) and cadmium yellow (#f2c500) the way real paint mixes, then paint a short oil stroke with it from (10, 32) to (54, 32).",
+	"fixture": { "editor": "paint", "width": 64, "height": 64, "setup": [{ "tool": "set_paper", "args": { "preset": "cotton-canvas" } }] },
+	"checks": [
+		{ "why": "the stroke's colour is a green", "tool": "list_strokes", "expect": { "strokes": { "$some": { "color": { "$expr": "(([r, g, b]) => g > r && g > b)([1, 3, 5].map((i) => parseInt(v.slice(i, i + 2), 16)))" } } } } },
+		{ "why": "the canvas shows green paint", "tool": "pick_color", "args": { "x": 32, "y": 32 }, "expect": { "color": { "$expr": "(([r, g, b]) => g > r && g > b)([1, 3, 5].map((i) => parseInt(v.slice(i, i + 2), 16)))" } } },
+		{ "why": "an oil brush", "tool": "list_strokes", "expect": { "strokes": { "$some": { "brushId": { "$in": ["oil-round", "oil-flat", "bristle-round", "bristle-flat", "impasto-brush", "palette-knife"] } } } } }
+	],
+	"solution": [
+		{ "tool": "mix_colors", "args": { "colors": [{ "color": "#1f3a93", "weight": 1 }, { "color": "#f2c500", "weight": 1 }] } },
+		{ "tool": "set_brush", "args": { "id": "oil-round" } },
+		{ "tool": "set_color", "args": { "color": { "$read": "mix_colors", "args": { "colors": [{ "color": "#1f3a93", "weight": 1 }, { "color": "#f2c500", "weight": 1 }] }, "path": "mixed" } } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 10, "y": 32 }, { "x": 54, "y": 32 }] } }
+	]
+}

package/skills/pixerate-paint-sketch-to-finish/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: pixerate-paint-sketch-to-finish
+description: The sketch-to-finish workflow in the Pixerate paint editor - a loose pencil sketch on its own layer, construction with guides, clean line art inked over it, flat colours on a layer under the lines, shading and light on clipped layers in multiply, shadow or highlight modes, final detail, and a tidy, named layer stack for export. Use when asked to draw and colour, ink a sketch, make line art, add flat colours, shade or light a drawing, take a drawing from sketch to finished illustration, or colour comic or cartoon art, or when add_layer, update_layer, paint_stroke or set_tracing_image are available. Load with pixerate-paint-editor, which lists every tool.
+metadata:
+  kind: workflow
+  reference: pixerate-paint-editor
+---
+
+# From sketch to finished drawing
+
+A drawing is finished in passes, each on its own layer, so each can be changed without
+redoing the others: sketch, line art, flat colours, shading and light, details. Layers above
+others can be clipped to them so shading stays inside the flats, and painterly blend modes do
+the glazing. `list_layers` lists the stack top first.
+
+This skill is the method. `pixerate-paint-editor` has the full tool reference.
+
+## Goal and quality bar
+
+- A named layer per pass ("Sketch", "Ink", "Flats", "Shading", "Light"), in the right order:
+  flats under the line art, shading and light clipped to the flats.
+- The sketch is hidden (or deleted) in the finished piece.
+- Lines are clean and confident: few long strokes, pressure tapering at the ends.
+- Flats fill the shapes without gaps at the lines; shading and light stay inside them.
+
+## Inputs to confirm
+
+- **Style:** line and flat colour (comic, cartoon), or soft rendering.
+- **Line weight and colour** (black ink, or a coloured line).
+- **Palette** for the flats; light direction for the shading.
+
+## Working method
+
+1. **Ground.** `set_paper` `smooth` (bristol) for ink and digital-looking work, `cartridge` for
+   pencil; `get_canvas_info` to confirm.
+2. **Sketch.** Rename or add a layer "Sketch" (`update_layer` `name`, or `add_layer`); a light
+   pencil (`pencil-hb`) in a mid grey or blue, loose construction lines. `set_symmetry` for
+   symmetric subjects, `set_perspective_guide` for buildings, `set_tracing_image` to trace a
+   reference.
+   **Check:** `list_strokes` shows pencil strokes on the Sketch layer.
+3. **Ink.** `add_layer` "Ink" above it; `ink-pen` or `brush-pen`, dark colour, long strokes with
+   points that carry `pressure` (lighter at the ends) and `t` for speed dynamics.
+   **Check:** `pick_color` on a line is dark.
+4. **Hide the sketch.** `update_layer` the Sketch layer `visible: false` (or lower its `opacity`
+   while inking, then hide it).
+   **Check:** `list_layers` shows it hidden.
+5. **Flats.** `add_layer` "Flats", then `move_layer` it below the Ink layer; fill each shape with
+   its base colour (`marker` or a flat brush, or `fill_layer` for a background).
+   **Check:** `pick_color` inside a shape is the flat colour; on a line still the ink.
+6. **Shading and light.** `add_layer` "Shading" directly above the flats, `update_layer`
+   `blend: "multiply"` (or `shadow`) and `clipped: true`; paint shadows on the side away from the
+   light. A "Light" layer the same way with `highlight` or `screen`.
+   **Check:** `list_layers`: the clipped layers sit directly above the flats.
+7. **Details and finish.** Accents, textures and line fixes on their own layers; `render_preview`;
+   `export_image`, or `export_psd` to keep the layers (painterly modes export as the nearest
+   standard mode, with a warning).
+
+## Decision table
+
+| Pass | Brush and layer |
+| --- | --- |
+| Sketch | `pencil-hb`, light colour, own layer, hidden at the end |
+| Line art | `ink-pen` (even), `brush-pen` (swelling); own layer on top |
+| Flats | `marker` or a flat brush on a layer under the ink |
+| Shadows | Clipped layer, `multiply` or `shadow`, a cool colour |
+| Light, glow | Clipped layer, `highlight` or `screen` |
+| Warm or cool a whole area | Clipped layer in `tint` |
+| Repeated marks (hatching, grass) | One stroke, then `replay_strokes` with offsets |
+
+## Recipes
+
+**Flats under ink.** `add_layer` "Flats" → `move_layer` with the new layer's id and `index` below
+the Ink layer → `set_brush` `marker` → `set_color` → strokes inside the shape.
+
+**Clipped shading.** `add_layer` "Shading" above Flats → `update_layer` `{ blend: "multiply",
+clipped: true }` → `set_brush` `airbrush` → paint the shadow side.
+
+## Pitfalls
+
+- **Inking on the sketch layer** mixes the two; you cannot hide the sketch afterwards.
+- **Flats above the ink** cover the lines; they belong under them.
+- **Unclipped shading** spills outside the shapes; clip it to the flats.
+- **Shadows in black** look dirty; use a cool, darker version of the colour in multiply or
+  `shadow`.
+- **Many short, hairy strokes** make weak line art; fewer, longer strokes with pressure.
+- **`list_layers` is top first**: index 0 is the top layer; `move_layer` `index` counts from the
+  bottom.
+
+## Tools used
+
+- `get_canvas_info`, `list_layers`, `list_strokes`, `pick_color`, `render_preview`: read and check
+- `set_paper`, `fill_layer`: the ground and backgrounds
+- `add_layer`, `update_layer`, `move_layer`, `remove_layer`: one layer per pass; hide, clip, blend
+- `set_brush`, `set_color`, `paint_stroke`, `replay_strokes`: sketch, ink, flats and shading
+- `set_symmetry`, `set_perspective_guide`, `set_tracing_image`: construction guides
+- `undo_paint`: take back a step
+- `export_image`, `export_psd`: deliver

package/skills/pixerate-paint-sketch-to-finish/evals/clipped-shading.json

@@ -0,0 +1,26 @@
+{
+	"prompt": "Add shading to the yellow shape on a separate layer that only affects the yellow and darkens it (multiply), so I can adjust or remove it later.",
+	"fixture": {
+		"editor": "paint",
+		"width": 64,
+		"height": 64,
+		"setup": [
+			{ "tool": "set_paper", "args": { "preset": "smooth" } },
+			{ "tool": "update_layer", "args": { "layerId": { "$read": "list_layers", "path": "layers.0.id" }, "name": "Flats" } },
+			{ "tool": "set_brush", "args": { "id": "marker" } },
+			{ "tool": "set_color", "args": { "color": "#f2c14e" } },
+			{ "tool": "paint_stroke", "args": { "points": [{ "x": 16, "y": 20 }, { "x": 48, "y": 20 }, { "x": 48, "y": 32 }, { "x": 16, "y": 32 }, { "x": 16, "y": 44 }, { "x": 48, "y": 44 }] } }
+		]
+	},
+	"checks": [
+		{ "why": "a multiply layer clipped to the layer below", "tool": "list_layers", "expect": { "layers": { "$some": { "blend": "multiply", "clipped": true } } } },
+		{ "why": "directly above the flats", "tool": "list_layers", "expect": { "layers": { "$expr": "(() => { const i = v.findIndex((l) => l.name === 'Flats'); return i > 0 && v[i - 1].clipped && v[i - 1].bounds !== null; })()" } } }
+	],
+	"solution": [
+		{ "tool": "add_layer", "args": { "name": "Shading" } },
+		{ "tool": "update_layer", "args": { "layerId": { "$read": "list_layers", "path": "layers.0.id" }, "blend": "multiply", "clipped": true } },
+		{ "tool": "set_brush", "args": { "id": "airbrush" } },
+		{ "tool": "set_color", "args": { "color": "#b08a6a" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 40, "y": 22 }, { "x": 46, "y": 42 }] } }
+	]
+}

package/skills/pixerate-paint-sketch-to-finish/evals/flats-under-ink.json

@@ -0,0 +1,27 @@
+{
+	"prompt": "Colour the inside of the inked box with a flat warm yellow, on its own layer under the line art so the lines stay on top.",
+	"fixture": {
+		"editor": "paint",
+		"width": 64,
+		"height": 64,
+		"setup": [
+			{ "tool": "set_paper", "args": { "preset": "smooth" } },
+			{ "tool": "update_layer", "args": { "layerId": { "$read": "list_layers", "path": "layers.0.id" }, "name": "Ink" } },
+			{ "tool": "set_brush", "args": { "id": "ink-pen" } },
+			{ "tool": "set_color", "args": { "color": "#111111" } },
+			{ "tool": "paint_stroke", "args": { "points": [{ "x": 12, "y": 12 }, { "x": 52, "y": 12 }, { "x": 52, "y": 52 }, { "x": 12, "y": 52 }, { "x": 12, "y": 12 }] } }
+		]
+	},
+	"checks": [
+		{ "why": "a colour layer below the Ink layer (list_layers is top first)", "tool": "list_layers", "expect": { "layers": { "$expr": "(() => { const i = v.findIndex((l) => l.name === 'Ink'); return i >= 0 && v.slice(i + 1).some((l) => l.type === 'pixel' && l.bounds); })()" } } },
+		{ "why": "the inside is yellow", "tool": "pick_color", "args": { "x": 32, "y": 32 }, "expect": { "color": { "$expr": "(([r, g, b]) => r > 200 && g > 160 && b < r - 60)([1, 3, 5].map((i) => parseInt(v.slice(i, i + 2), 16)))" } } },
+		{ "why": "the line is still dark on top", "tool": "pick_color", "args": { "x": 32, "y": 12 }, "expect": { "color": { "$expr": "(([r, g, b]) => r + g + b < 300)([1, 3, 5].map((i) => parseInt(v.slice(i, i + 2), 16)))" } } }
+	],
+	"solution": [
+		{ "tool": "add_layer", "args": { "name": "Flats" } },
+		{ "tool": "move_layer", "args": { "layerId": { "$read": "list_layers", "path": "layers.0.id" }, "index": 0 } },
+		{ "tool": "set_brush", "args": { "id": "marker" } },
+		{ "tool": "set_color", "args": { "color": "#f2c14e" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 14, "y": 16 }, { "x": 50, "y": 16 }, { "x": 50, "y": 24 }, { "x": 14, "y": 24 }, { "x": 14, "y": 32 }, { "x": 50, "y": 32 }, { "x": 50, "y": 40 }, { "x": 14, "y": 40 }, { "x": 14, "y": 48 }, { "x": 50, "y": 48 }] } }
+	]
+}

package/skills/pixerate-paint-sketch-to-finish/evals/sketch-ink-hide.json

@@ -0,0 +1,20 @@
+{
+	"prompt": "Start a drawing of a box: a light pencil sketch first, then clean ink lines over it on a separate layer, and hide the sketch when the inking is done.",
+	"fixture": { "editor": "paint", "width": 64, "height": 64, "setup": [{ "tool": "set_paper", "args": { "preset": "smooth" } }] },
+	"checks": [
+		{ "why": "sketch and ink on separate layers", "tool": "list_strokes", "expect": { "strokes": { "$expr": "v.some((s) => s.brushId.startsWith('pencil')) && v.some((s) => ['ink-pen', 'brush-pen'].includes(s.brushId)) && new Set(v.map((s) => s.layerId)).size >= 2" } } },
+		{ "why": "the sketch layer is hidden, the ink layer shown", "tool": "list_layers", "expect": { "layers": { "$some": { "visible": false }, "$length": { "$min": 2 } } } },
+		{ "why": "the ink is visible on the page", "tool": "pick_color", "args": { "x": 32, "y": 12 }, "expect": { "color": { "$expr": "(([r, g, b]) => r + g + b < 300)([1, 3, 5].map((i) => parseInt(v.slice(i, i + 2), 16)))" } } }
+	],
+	"solution": [
+		{ "tool": "update_layer", "args": { "layerId": { "$read": "list_layers", "path": "layers.0.id" }, "name": "Sketch" } },
+		{ "tool": "set_brush", "args": { "id": "pencil-hb" } },
+		{ "tool": "set_color", "args": { "color": "#8a8f98" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 12, "y": 12 }, { "x": 52, "y": 12 }, { "x": 52, "y": 52 }, { "x": 12, "y": 52 }, { "x": 12, "y": 12 }] } },
+		{ "tool": "add_layer", "args": { "name": "Ink" } },
+		{ "tool": "set_brush", "args": { "id": "ink-pen" } },
+		{ "tool": "set_color", "args": { "color": "#111111" } },
+		{ "tool": "paint_stroke", "args": { "points": [{ "x": 12, "y": 12 }, { "x": 52, "y": 12 }, { "x": 52, "y": 52 }, { "x": 12, "y": 52 }, { "x": 12, "y": 12 }] } },
+		{ "tool": "update_layer", "args": { "layerId": { "$read": "list_layers", "path": "layers.1.id" }, "visible": false } }
+	]
+}