@pixerate/editor 0.221.0 → 0.221.1

package/dist/image-editor/index.cjs

@@ -2807,6 +2807,21 @@ function inspectMaskEdge(mask, image, options = {}) {
     blk.x1 = Math.max(blk.x1, x);
     blk.y1 = Math.max(blk.y1, y);
   };
+  const antiAliased = (x, y) => {
+    let full = false;
+    let none = false;
+    for (let dy = -2; dy <= 2; dy++) {
+      for (let dx = -2; dx <= 2; dx++) {
+        const nx = x + dx;
+        const ny = y + dy;
+        if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+        const n = a[ny * W + nx];
+        if (n === 255) full = true;
+        else if (n === 0) none = true;
+      }
+    }
+    return full && none;
+  };
   const x0 = Math.max(0, b.x - 1);
   const y0 = Math.max(0, b.y - 1);
   const x1 = Math.min(W, b.x + b.width + 1);
@@ -2836,7 +2851,7 @@ function inspectMaskEdge(mask, image, options = {}) {
       const partial = v > 0 && v < 255;
       if (hi && lo || partial) {
         band++;
-        if (partial) soft++;
+        if (partial && !antiAliased(x, y)) soft++;
       }
       if (v < 128) continue;
       const inCanvasLow = (nx, ny) => nx >= 0 && ny >= 0 && nx < W && ny < H && a[ny * W + nx] < 128;
@@ -13784,7 +13799,7 @@ function createImageSelectionTools(controller) {
   const inspectEdge = {
     name: "inspect_mask_edge",
     title: "Inspect a mask edge",
-    description: "Measures the edge of the selection (default), a layer's painted mask (layer-mask) or its vector mask (vector-mask), so you can check it without looking. Returns haloScore 0-1 (background colour left just inside the edge; worse above 0.35), edgeAlignment 0-1 (share of the edge on strong image edges; worse below 0.5), jaggedness (outline turning in radians per 100 px beyond what closing it needs; smooth outlines score under 3, worse above 15), softFraction 0-1 (share of edge pixels partly selected), holes and islands (count, total area, the 10 largest with bounds), worst (up to 5 regions with a reason, ready for capture_view rect) and issues (findings with a suggested fix; empty when clean). Measures a pixel layer's masks against its own pixels, otherwise the composite. Read-only: inspect, fix the issues, inspect again.",
+    description: "Measures the edge of the selection (default), a layer's painted mask (layer-mask) or its vector mask (vector-mask), so you can check it without looking. Returns haloScore 0-1 (background colour left just inside the edge; worse above 0.35), edgeAlignment 0-1 (share of the edge on strong image edges; worse below 0.5), jaggedness (outline turning in radians per 100 px beyond what closing it needs; smooth outlines score under 3, worse above 15), softFraction 0-1 (share of edge pixels in a transition wider than anti-aliasing), holes and islands (count, total area, the 10 largest with bounds), worst (up to 5 regions with a reason, ready for capture_view rect) and issues (findings with a suggested fix; empty when clean). Measures a pixel layer's masks against its own pixels, otherwise the composite. Read-only: inspect, fix the issues, inspect again.",
     inputSchema: {
       type: "object",
       properties: {

package/dist/image-editor/index.js

@@ -2807,6 +2807,21 @@ function inspectMaskEdge(mask, image, options = {}) {
     blk.x1 = Math.max(blk.x1, x);
     blk.y1 = Math.max(blk.y1, y);
   };
+  const antiAliased = (x, y) => {
+    let full = false;
+    let none = false;
+    for (let dy = -2; dy <= 2; dy++) {
+      for (let dx = -2; dx <= 2; dx++) {
+        const nx = x + dx;
+        const ny = y + dy;
+        if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+        const n = a[ny * W + nx];
+        if (n === 255) full = true;
+        else if (n === 0) none = true;
+      }
+    }
+    return full && none;
+  };
   const x0 = Math.max(0, b.x - 1);
   const y0 = Math.max(0, b.y - 1);
   const x1 = Math.min(W, b.x + b.width + 1);
@@ -2836,7 +2851,7 @@ function inspectMaskEdge(mask, image, options = {}) {
       const partial = v > 0 && v < 255;
       if (hi && lo || partial) {
         band++;
-        if (partial) soft++;
+        if (partial && !antiAliased(x, y)) soft++;
       }
       if (v < 128) continue;
       const inCanvasLow = (nx, ny) => nx >= 0 && ny >= 0 && nx < W && ny < H && a[ny * W + nx] < 128;
@@ -13784,7 +13799,7 @@ function createImageSelectionTools(controller) {
   const inspectEdge = {
     name: "inspect_mask_edge",
     title: "Inspect a mask edge",
-    description: "Measures the edge of the selection (default), a layer's painted mask (layer-mask) or its vector mask (vector-mask), so you can check it without looking. Returns haloScore 0-1 (background colour left just inside the edge; worse above 0.35), edgeAlignment 0-1 (share of the edge on strong image edges; worse below 0.5), jaggedness (outline turning in radians per 100 px beyond what closing it needs; smooth outlines score under 3, worse above 15), softFraction 0-1 (share of edge pixels partly selected), holes and islands (count, total area, the 10 largest with bounds), worst (up to 5 regions with a reason, ready for capture_view rect) and issues (findings with a suggested fix; empty when clean). Measures a pixel layer's masks against its own pixels, otherwise the composite. Read-only: inspect, fix the issues, inspect again.",
+    description: "Measures the edge of the selection (default), a layer's painted mask (layer-mask) or its vector mask (vector-mask), so you can check it without looking. Returns haloScore 0-1 (background colour left just inside the edge; worse above 0.35), edgeAlignment 0-1 (share of the edge on strong image edges; worse below 0.5), jaggedness (outline turning in radians per 100 px beyond what closing it needs; smooth outlines score under 3, worse above 15), softFraction 0-1 (share of edge pixels in a transition wider than anti-aliasing), holes and islands (count, total area, the 10 largest with bounds), worst (up to 5 regions with a reason, ready for capture_view rect) and issues (findings with a suggested fix; empty when clean). Measures a pixel layer's masks against its own pixels, otherwise the composite. Read-only: inspect, fix the issues, inspect again.",
     inputSchema: {
       type: "object",
       properties: {

package/dist/image-editor/selection/inspect.d.cts

@@ -31,7 +31,7 @@ export interface MaskEdgeReport {
     edgeAlignment: number;
     /** Turning of the outline beyond what closing it needs, in radians per 100 px of outline (0: smooth). */
     jaggedness: number;
-    /** 0–1: the share of edge pixels that are partly covered (0 < α < 1). */
+    /** 0–1: the share of edge pixels in a transition wider than anti-aliasing (partly covered, no fully selected and unselected pixel within 2 px). */
     softFraction: number;
     /** Unselected areas enclosed by the selection, largest first (at most 10 listed). */
     holes: {

package/dist/image-editor/selection/inspect.d.ts

@@ -31,7 +31,7 @@ export interface MaskEdgeReport {
     edgeAlignment: number;
     /** Turning of the outline beyond what closing it needs, in radians per 100 px of outline (0: smooth). */
     jaggedness: number;
-    /** 0–1: the share of edge pixels that are partly covered (0 < α < 1). */
+    /** 0–1: the share of edge pixels in a transition wider than anti-aliasing (partly covered, no fully selected and unselected pixel within 2 px). */
     softFraction: number;
     /** Unselected areas enclosed by the selection, largest first (at most 10 listed). */
     holes: {

package/package.json

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

package/skills/README.md

@@ -5,6 +5,11 @@ Each editor domain in `@pixerate/editor` ships an [Agent Skill](https://agentski
 expert in the domain would follow. They are published with the package, so an app or agent
 that uses the tools can load the matching skill.
 
+## Reference skills
+
+One per editor domain. A reference skill owns its domain's tool and command tables, its mental
+model and its general practice.
+
 | Skill | Covers |
 | --- | --- |
 | [`pixerate-agent-tools`](pixerate-agent-tools/SKILL.md) | What every editor has in common: the MCP bridge, toolsets and tool naming, finding tools with `list_toolsets` / `search_tools` / `enable_tools` / `get_skill`, `list_commands` / `run_command` / `run_commands`, errors, undo. Load it with any domain skill. |
@@ -15,12 +20,9 @@ that uses the tools can load the matching skill.
 | [`pixerate-chart`](pixerate-chart/SKILL.md) | Chart specs, data, series, presets, trendlines, Office and Mermaid charts. |
 | [`pixerate-diagram`](pixerate-diagram/SKILL.md) | Mermaid diagrams: nodes, edges, groups, layout. |
 | [`pixerate-image-editor`](pixerate-image-editor/SKILL.md) | Adjustments, adjustment layers, selections and masks. |
-| [`pixerate-image-selection-masking`](pixerate-image-selection-masking/SKILL.md) | Workflow: cutouts, background and sky replacement, local adjustments through masks; choosing a selection method, checking and refining edges, and outputting an editable mask. Built on `pixerate-image-editor`'s tools. |
 | [`pixerate-paint-editor`](pixerate-paint-editor/SKILL.md) | Natural-media painting: paper and grain, dry-media brushes, the brush library, strokes as data, pigment mixing. |
 | [`pixerate-animation-editor`](pixerate-animation-editor/SKILL.md) | Vector animation: shots, commands, timing, Flair and Lottie. |
 | [`pixerate-video-editor`](pixerate-video-editor/SKILL.md) | Non-linear video editing: tracks, clips, transitions, export. |
-| [`pixerate-talking-head-edit`](pixerate-talking-head-edit/SKILL.md) | Talking-head cleanup by transcript: fillers, long pauses and stutters found in one pass and cut as one plan reviewed before it applies. |
-| [`pixerate-bgm-alignment`](pixerate-bgm-alignment/SKILL.md) | Background music: beats and cuts on the beat, ducking under speech, loudness in LUFS. |
 | [`pixerate-generation`](pixerate-generation/SKILL.md) | Planning, estimating and running paid media generation. |
 | [`pixerate-parameters`](pixerate-parameters/SKILL.md) | Effect parameters, presets and keyframes. |
 | [`pixerate-tokens`](pixerate-tokens/SKILL.md) | Design tokens: collections, modes, variables and aliases, through the whole-set document tools. |
@@ -28,6 +30,20 @@ that uses the tools can load the matching skill.
 | [`pixerate-color`](pixerate-color/SKILL.md) | Colour inspection, WCAG accessibility and contrast optimization, CVD simulation, palette audits, harmonies, and OKLab/OKLCH blends. |
 | [`pixerate-typography`](pixerate-typography/SKILL.md) | Fonts and fallback stacks, font loading, modular type scales and hierarchies, fluid sizes, readability and type-aware contrast audits, text segmentation, the font picker. |
 
+## Workflow skills
+
+A workflow skill covers one job from start to finish: what to confirm first, the steps in
+order with a check after each, a decision table, recipes and the job's pitfalls. It is built on
+its reference skill's tools (load both), and its description is written about the job, so a
+request like "clean up this export" finds it.
+
+| Skill | Editor | Covers |
+| --- | --- | --- |
+| [`pixerate-image-selection-masking`](pixerate-image-selection-masking/SKILL.md) | Image (`pixerate-image-editor`) | Cutouts, background and sky replacement, local adjustments through masks; choosing a selection method, checking and refining edges, and outputting an editable mask. |
+| [`pixerate-spreadsheet-clean-import`](pixerate-spreadsheet-clean-import/SKILL.md) | Spreadsheet (`pixerate-spreadsheet`) | Imported or pasted data made tidy: structure, headers, types (currency, comma decimals, day-first dates, leading zeros, missing values), text, duplicates and validation. |
+| [`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. |
+
 ## Using them
 
 Copy or symlink the directories into your agent's skills folder, for example for Claude Code:
@@ -75,12 +91,27 @@ same change.
   `create*ToolProvider` / `create*Commands` factory is not mapped to a skill. A new domain
   gets a new skill directory, an entry in `expectedBySkill()` and `FACTORIES`, and a row in
   the table above.
-- **Workflow skills.** A skill that covers one job end to end on another skill's tools (for
-  example `pixerate-image-selection-masking` on `pixerate-image-editor`) has no tool table.
-  Its frontmatter adds `metadata` with `kind: workflow` and `reference: <skill>`, it lists the
-  tools it uses as bullets under `## Tools used`, and it is mapped in `WORKFLOWS` in the test
-  (and to `[]` in `expectedBySkill()`). The test checks that every tool it uses exists in the
-  reference skill.
+- **Workflow skills.** A skill that covers one job end to end on another skill's tools has no
+  tool table (unless the job has its own provider, as the two video ones do). Start from
+  [`WORKFLOW_TEMPLATE.md`](WORKFLOW_TEMPLATE.md). Its frontmatter adds `metadata` with
+  `kind: workflow` and `reference: <skill>`; it lists the tools it uses as bullets under
+  `## Tools used`; and it is mapped in `WORKFLOWS` in the test (and to `[]` in
+  `expectedBySkill()`). The test checks that every tool it uses exists in the reference skill,
+  that every backticked tool or command name in its prose is real, that the reference skill
+  names it under `## Workflow skills`, that it stays under 250 body lines (aim for 200) and that
+  it ships evals. Add its row to the workflow table above.
+- **Evals.** Each workflow skill ships at least three scenarios in `evals/*.json`, run by
+  `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" }` or
+  `{ "editor": "image", "width", "height", "background", "shapes" }`), `checks` (a read-only
+  tool, 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
+  of the solution. In `expect`, objects match key by key and arrays element by element, with
+  operators for ranges and lists (`$min`, `$max`, `$match`, `$every`, `$some`, `$length`,
+  `$unique`, `$distinct`, `$sum`, `$column`, `$nonEmpty`, `$not`, `$in`, `$type`); a check's
+  argument can read a value the job created with `{ "$read": "list_layers", "path":
+  "layers.-1.id" }`. Checks test the outcome the user asked for, not one way of getting it.
 - **Workflows and practice.** The test cannot check advice. When a feature changes the best
   way to do something (a new batch tool, a new check, a better default), update the working
   method and best practices too.

package/skills/WORKFLOW_TEMPLATE.md

@@ -0,0 +1,50 @@
+---
+name: pixerate-<editor>-<job>
+description: The <job> workflow in the Pixerate <editor> - <what it produces, in the user's words, and the main steps>. Use when asked to <trigger phrases: the verbs and nouns people use for this job>, or when <a tool or two that signal the job> are available. Load with pixerate-<editor>, which lists every tool.
+metadata:
+  kind: workflow
+  reference: pixerate-<editor>
+---
+
+# <The job, as a short title>
+
+<Two to four sentences: the model of the job a person needs before starting. What the
+document is made of here, and the one or two facts that make this job go right or wrong.>
+
+This skill is the method. `pixerate-<editor>` has the full tool reference.
+
+## Goal and quality bar
+
+- <What the finished result is, stated so it can be checked: numbers, ranges, absences.>
+- <What must stay editable, reversible or untouched.>
+
+## Inputs to confirm
+
+Ask when you cannot tell from the document; say what you assumed when you can.
+
+- **<Decision>:** <the options, and the default when the user does not say>.
+
+## Working method
+
+1. **<Step>.** <What to do, with which tool and which arguments matter (units, defaults).>
+   **Check:** <a read tool and what its result must show before going on>.
+2. **<Step>.** ...
+   **Check:** ...
+
+## Decision table
+
+| Situation | Approach |
+| --- | --- |
+| <case> | <method, tool, setting> |
+
+## Recipes
+
+**<Common request>.** <The tool calls in order, with arguments, as short prose.>
+
+## Pitfalls
+
+- **<Failure>.** <Why it happens and how to avoid or detect it.>
+
+## Tools used
+
+- `<tool_name>`, `<tool_name>`: <one-line purpose in this job>

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

@@ -33,6 +33,13 @@ Also an optional selection and crop/rotate/flip. See `pixerate-agent-tools` for
 - **Coordinates** for selections are natural pixels of the source image (before crop, rotate
   or flip). Read `get_selection` bounds or the image size, never screen pixels.
 
+## 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-image-selection-masking`: cutouts, background and sky replacement, local adjustments through masks.
+
 ## Working method
 
 1. **Read.** `get_adjustments` for the current values, process version and layers;

package/skills/pixerate-image-selection-masking/evals/local-adjustment.json

@@ -0,0 +1,22 @@
+{
+	"prompt": "Make just the red ball black and white, and keep it adjustable so I can tweak it later. The sign in the corner should stay red.",
+	"fixture": {
+		"editor": "image",
+		"width": 120,
+		"height": 80,
+		"background": [40, 90, 200],
+		"shapes": [
+			{ "shape": "ellipse", "x": 40, "y": 20, "width": 40, "height": 40, "color": [210, 40, 40] },
+			{ "shape": "rect", "x": 100, "y": 6, "width": 12, "height": 8, "color": [210, 40, 40] }
+		]
+	},
+	"checks": [
+		{ "why": "a Black & White adjustment layer, masked to the ball and not the sign", "tool": "list_layers", "expect": { "layers": { "$some": { "type": "adjustment", "kind": "blackWhite", "mask": { "kind": "raster", "defaultValue": 0, "paintedBounds": { "x": { "$min": 38, "$max": 41 }, "y": { "$min": 18, "$max": 21 }, "width": { "$min": 39, "$max": 44 }, "height": { "$min": 39, "$max": 44 } } } } } } },
+		{ "why": "the photo's own pixels are not changed", "tool": "list_layers", "expect": { "layers": { "$some": { "id": "background", "type": "pixel", "mask": null } } } }
+	],
+	"solution": [
+		{ "tool": "magic_wand", "args": { "x": 60, "y": 40, "tolerance": 20, "contiguous": true } },
+		{ "tool": "get_selection" },
+		{ "tool": "add_adjustment_layer", "args": { "kind": "blackWhite" } }
+	]
+}

package/skills/pixerate-image-selection-masking/evals/mask-out-background.json

@@ -0,0 +1,24 @@
+{
+	"prompt": "Hide the blue background so only the red ball shows. Don't delete any pixels; I may want the background back later.",
+	"fixture": {
+		"editor": "image",
+		"width": 120,
+		"height": 80,
+		"background": [40, 90, 200],
+		"shapes": [
+			{ "shape": "ellipse", "x": 40, "y": 20, "width": 40, "height": 40, "color": [210, 40, 40] },
+			{ "shape": "rect", "x": 100, "y": 6, "width": 12, "height": 8, "color": [210, 40, 40] }
+		]
+	},
+	"checks": [
+		{ "why": "the top layer has a layer mask that reveals only the ball", "tool": "list_layers", "expect": { "layers": { "$some": { "type": "pixel", "mask": { "kind": "raster", "enabled": true, "defaultValue": 0, "paintedBounds": { "x": { "$min": 38, "$max": 41 }, "y": { "$min": 18, "$max": 21 }, "width": { "$min": 39, "$max": 44 }, "height": { "$min": 39, "$max": 44 } } } } } } },
+		{ "why": "the mask edge is clean", "tool": "inspect_mask_edge", "args": { "target": "layer-mask", "layerId": { "$read": "list_layers", "path": "layers.-1.id" } }, "expect": { "issues": [], "haloScore": { "$max": 0.35 } } }
+	],
+	"solution": [
+		{ "tool": "list_layers" },
+		{ "tool": "magic_wand", "args": { "x": 60, "y": 40, "tolerance": 20, "contiguous": true } },
+		{ "tool": "inspect_mask_edge" },
+		{ "tool": "add_layer_mask", "args": { "layerId": "background", "from": "selection" } },
+		{ "tool": "inspect_mask_edge", "args": { "target": "layer-mask", "layerId": "background" } }
+	]
+}

package/skills/pixerate-image-selection-masking/evals/select-one-of-two.json

@@ -0,0 +1,22 @@
+{
+	"prompt": "Select the red ball in the middle of the photo, not the red sign in the top-right corner. Just the selection for now; I'll decide what to do with it.",
+	"fixture": {
+		"editor": "image",
+		"width": 120,
+		"height": 80,
+		"background": [40, 90, 200],
+		"shapes": [
+			{ "shape": "ellipse", "x": 40, "y": 20, "width": 40, "height": 40, "color": [210, 40, 40] },
+			{ "shape": "rect", "x": 100, "y": 6, "width": 12, "height": 8, "color": [210, 40, 40] }
+		]
+	},
+	"checks": [
+		{ "why": "the selection hugs the ball and leaves the sign out", "tool": "get_selection", "expect": { "empty": false, "bounds": { "x": { "$min": 38, "$max": 41 }, "y": { "$min": 18, "$max": 21 }, "width": { "$min": 39, "$max": 44 }, "height": { "$min": 39, "$max": 44 } }, "percent": { "$min": 12, "$max": 14.5 } } },
+		{ "why": "a clean edge: no halo, holes or islands", "tool": "inspect_mask_edge", "expect": { "issues": [], "holes": { "count": 0 }, "islands": { "count": 0 } } }
+	],
+	"solution": [
+		{ "tool": "magic_wand", "args": { "x": 60, "y": 40, "tolerance": 20, "contiguous": true } },
+		{ "tool": "get_selection" },
+		{ "tool": "inspect_mask_edge" }
+	]
+}

package/skills/pixerate-spreadsheet/SKILL.md

@@ -15,6 +15,13 @@ leading `'` forces text.
 
 Errors, namespacing and `run_commands` batching are in the `pixerate-agent-tools` skill.
 
+## 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-spreadsheet-clean-import`: tidying imported or pasted data: structure, headers, types, dates, duplicates.
+
 ## Working method
 
 1. **Read.** `get_range` on the area you will touch (and its header row). The result gives

package/skills/pixerate-spreadsheet-clean-import/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: pixerate-spreadsheet-clean-import
+description: The clean-up workflow for imported data in a Pixerate spreadsheet - a CSV export, a pasted table or a report dump turned into tidy data. Covers finding the data region, profiling each column, removing title, blank, total and repeated header rows, normalising headers, fixing types (numbers stored as text, currency and European decimals, day-first dates read month-first, lost leading zeros, missing-value markers), trimming and unifying text, removing duplicates by a key, and validating the result without damaging the source. Use when asked to clean, tidy, fix, normalise, deduplicate or prepare imported or pasted data for analysis, or when a column will not sum or sort. Load with pixerate-spreadsheet, which lists every tool.
+metadata:
+  kind: workflow
+  reference: pixerate-spreadsheet
+---
+
+# Cleaning imported data
+
+Imported data arrives as typed text: each cell is parsed the way a person's typing is (en-US),
+so `$1,200.00` and `(45)` become numbers, `3/4/2026` becomes the ISO date `2026-03-04`, and
+anything the parser does not recognise (`USD 300`, `1.250,50`, `31/03/2026`, `n/a`) stays text.
+`get_range` shows both sides: `raw` is what was typed, `values` what it became. Cleaning is
+reading both, deciding what each column should be, and writing it back in blocks.
+
+This skill is the method. `pixerate-spreadsheet` has the full tool reference and the formula list.
+
+## Goal and quality bar
+
+- One header row of short, unique, trimmed names, with units in the header (`Amount (USD)`).
+- One record per row: no title, notes, blank, subtotal, total or repeated header rows inside the data.
+- One type per column: numbers are numbers (they sum), dates are ISO dates, codes that must keep
+  leading zeros are text, missing values are empty cells (not 0, not `n/a`).
+- Text is trimmed and each category is spelled one way (`North`, not `north` and `NORTH `).
+- No duplicates by the key the user chose; the right row of each set is kept.
+- Nothing is lost by accident: the user can see what changed, and undo it.
+
+## Inputs to confirm
+
+Ask when you cannot tell from the data; say what you assumed when you can.
+
+- **In place or beside?** Clean the cells in place (the default for a sheet that is only an
+  import), or keep the raw columns and add clean ones next to them (when the raw data is the
+  only copy, or must be audited).
+- **Date order** of the source: month-first (US) or day-first (most other places). A raw date
+  whose first part is above 12 (`31/03/2026`) settles it.
+- **The duplicate key** (which columns make two rows the same record, and whether case and
+  spaces count) and **which row wins** (first, last, most recently updated, most complete).
+- **Missing values:** empty (the default), or a value the user names. Never 0 unless told.
+- **Category spelling:** the canonical form when variants disagree (`North` or `north`).
+
+## Working method
+
+1. **Find the data and keep a way back.** `get_range` a generous area (`A1:Z60`) and find the
+   header row, the first and last data row and any title, notes or total rows. If rows are
+   hidden or filtered, run `spreadsheet.unhideAll` or `spreadsheet.clearFilters` first so the
+   user sees what you clean. Before a large rewrite, `get_spreadsheet_document` keeps a copy
+   that `load_spreadsheet_document` can restore; small steps are each one `undo_spreadsheet`.
+   **Check:** you can name the data range and each column's intended type.
+2. **Profile each column** from `raw` and `values` together: numbers stored as text (a string in
+   `values` where the rest are numbers), currency codes, comma decimals, slash dates and their
+   order, codes that lost leading zeros (a number where text is expected: ZIP, ID, phone),
+   missing-value markers (`n/a`, `-`, `NULL`, `?`), stray spaces and case variants.
+   **Check:** a list of problems per column, with counts. Report anything you will not fix.
+3. **Fix the structure.** `unmerge_cells` over the region first. Delete title, notes, blank,
+   total and repeated header rows with `delete_rows`, from the bottom up so earlier row numbers
+   stay valid, or rewrite the whole block and delete the leftover tail once.
+   **Check:** `get_range` shows the header in row 1 of the region, data directly below, and
+   `sheet.rows` is the count you expect.
+4. **Fix the headers** in one `set_range` over the header row: trimmed, unique, plain names,
+   units in the header and not in the cells.
+   **Check:** no duplicates, no leading or trailing spaces.
+5. **Fix the values, a column (or a block) at a time** with `set_range`: numbers as JSON
+   numbers, dates as ISO text, text codes with a leading `'` (`'02134`), missing values as
+   `null`. For a large table use formula columns (see the recipes) rather than copying values
+   through the conversation.
+   **Check:** the returned `errors` is empty, and a `get_range` of the column shows one type.
+6. **Remove duplicates** by the confirmed key, keeping the winning row of each set. Rewrite the
+   kept rows as one block and delete the rest, or delete the losing rows from the bottom up.
+   **Check:** the row count fell by the number of duplicates you found in step 2.
+7. **Validate the whole region.** `get_range` it once more: `errors` is empty, every column has
+   one type, totals you can compute (a sum of amounts, a row count) match what you expect from
+   the source. For a big sheet, count in scratch cells instead of reading every value (see the
+   recipes), then clear them.
+   **Check:** every problem from step 2 is fixed or reported.
+8. **Report** what changed: rows removed (blank, total, duplicate) and why, columns converted,
+   assumptions (date order, the key, the canonical spelling) and anything left for the user.
+
+## Decision table
+
+| Situation | Approach |
+| --- | --- |
+| Small table (a few hundred cells to change), sheet is only an import | Read, then rewrite the cleaned block in place with `set_range`; delete leftover rows |
+| Large table, or the raw data must stay | Formula columns beside the raw ones (`=TRIM(C2:C5000)`, `=MAP(...)`); the raw columns stay as they are |
+| One or two broken columns, the rest fine | `set_range` on those columns only; leave every other cell untouched |
+| Numbers with a currency code or unit (`USD 300`, `12 kg`) | Strip it, put the unit in the header; ask when one column mixes currencies |
+| Comma decimals (`1.250,50`) | Convert to `1250.5`; then check that cells the parser already turned into numbers (`1,250` read as 1250) were not meant as `1.25` |
+| Slash dates, source is day-first | Rewrite every slash date in the column from `raw` as ISO, including the ones that already parsed (they parsed month-first and are wrong) |
+| Codes that must keep zeros (ZIP, ID, phone) | Text with a leading `'`, padded to the code's length |
+| Missing markers (`n/a`, `-`, `NULL`) | Empty cell (`null`), unless the user names a value |
+| Exact duplicate rows | Keep the first |
+| Same key, different details | Keep the row the user chose (latest, most complete); say which you dropped |
+| Merged title cells above the header | Unmerge, then delete the title rows or leave them above the data with a blank row between |
+
+## Recipes
+
+**Rewrite in place (small table).** `get_range` the region; build the clean block (header plus
+kept rows) in one `set_range` from the top-left cell; `delete_rows` the rows left below it.
+That is two undo steps, and every cell the user had is accounted for in your report.
+
+**Formula columns (large table).** Insert clean columns with `insert_columns` to the right of
+the raw ones and write one spilling formula at the top of each, leaving the cells below empty:
+
+- Trim text: `=TRIM(C2:C5000)`; one spelling: `=MAP(E2:E5000,LAMBDA(v,PROPER(TRIM(v))))`.
+- Currency text to numbers: `=MAP(D2:D5000,LAMBDA(v,IF(ISNUMBER(v),v,VALUE(TRIM(SUBSTITUTE(v,"USD",""))))))`.
+- Comma decimals: `VALUE(SUBSTITUTE(SUBSTITUTE(v,".",""),",","."))` inside the same `MAP`.
+- Day-first text dates: `DATE(RIGHT(v,4),MID(v,4,2),LEFT(v,2))`, which gives an ISO date; take
+  `v` from the raw text, since a date the parser already read month-first is wrong.
+
+Tell the user the clean columns are formulas over the raw ones (sorting or deleting the raw
+columns breaks them), and name the headers you gave them.
+
+**Count instead of reading (big sheets).** Write checks into a spare cell outside the data, read
+them, then clear the cell with `set_range` and `null`:
+
+- Duplicates by key: `=COUNTA(A2:A5000)-COUNTA(UNIQUE(A2:A5000))`.
+- Text in a number column: `=COUNTA(D2:D5000)-COUNT(D2:D5000)`.
+- Stray spaces: `=COUNTIF(C2:C5000," *")+COUNTIF(C2:C5000,"* ")`.
+
+**Keep the latest of each duplicate.** Read the key and date columns, pick the winner of each
+set by date, then rewrite the kept rows as one block (or delete the losers bottom up). Normalise
+the key (trim, lower case) only for comparing; write the kept row's own key back cleaned.
+
+## Pitfalls
+
+- **Month-first parsing.** `02/04/2026` from a day-first export is stored as 4 February, with no
+  error. Only `raw` shows the original; check it whenever a column has slash dates.
+- **Silent number parsing.** `1,250` becomes 1250 and `007` becomes 7 on input. Write codes with
+  a leading `'`, and check comma-decimal sources for values that parsed as thousands.
+- **Totals inside the data** double every sum. A total row is usually last, has an empty key and
+  a `SUM` in `raw`; delete it, and compute totals elsewhere if the user wants them.
+- **Deleting top-down** shifts the rows below, so the next row number you delete is wrong.
+  Delete from the bottom, or rewrite the block and delete the tail.
+- **Formulas that point into the data** become `#REF!` when rows they use are deleted. Read
+  `raw` for formulas before deleting and check `errors` after.
+- **Spills need room.** A spilling clean column turns into `#SPILL!` if anything sits below it.
+- **0 is not missing.** Writing 0 for `n/a` changes averages and counts; write `null`.
+- **Hidden rows are still data.** `get_range` returns them; unhide before you show the user a
+  result, so what they see matches what you counted.
+- **Copying values through the conversation** is slow and error-prone for thousands of cells;
+  use formula columns, and keep the values you write to the cells that change.
+
+## Tools used
+
+- `get_range`: read `raw` and `values`, the sheet size, errors and merges, before and after every step
+- `set_range`: write headers, cleaned blocks, formula columns and scratch checks, one undo step each
+- `set_cell`: fix one cell
+- `delete_rows`, `insert_rows`: remove title, blank, total and duplicate rows; make room
+- `insert_columns`, `delete_columns`: add clean formula columns; drop empty or unwanted ones
+- `unmerge_cells`: split merged cells before restructuring
+- `get_spreadsheet_document`, `load_spreadsheet_document`: keep a copy before a large rewrite, and restore it
+- `undo_spreadsheet`: take back a step
+- `spreadsheet.unhideAll`, `spreadsheet.clearFilters`: see every row before cleaning

package/skills/pixerate-spreadsheet-clean-import/evals/clean-in-place.json

@@ -0,0 +1,43 @@
+{
+	"prompt": "This sheet is a raw CSV export of orders from our European shop. Clean it up in place so it can be analysed: tidy headers, one type per column, and no blank, duplicate or total rows.",
+	"fixture": {
+		"editor": "spreadsheet",
+		"rows": [
+			["  Order ID", "date", "Customer name ", "Amount", "region"],
+			["1001", "2026-03-04", "acme corp", "$1,200.00", "north"],
+			["1002", "31/03/2026", "Globex ", "950", "South"],
+			["", "", "", "", ""],
+			["1003", "4-Mar-2026", "Initech", "USD 300", "NORTH"],
+			["1002", "31/03/2026", "Globex ", "950", "South"],
+			["1004", "02/04/2026", "Umbrella", "1.250,50", "  south"],
+			["", "", "Total", "=SUM(D2:D7)", ""]
+		]
+	},
+	"checks": [
+		{ "why": "headers are trimmed and unique", "tool": "get_range", "args": { "range": "A1:E1" }, "expect": { "values": [{ "$every": { "$match": "^\\S(.*\\S)?$" }, "$unique": true }] } },
+		{ "why": "one header row and the four distinct orders, with no blank, duplicate or total rows", "tool": "get_range", "args": { "range": "A1:H40" }, "expect": { "values": { "$nonEmpty": { "$length": 5 } } } },
+		{ "why": "order ids are unique", "tool": "get_range", "args": { "range": "A2:A40" }, "expect": { "values": { "$nonEmpty": { "$column": [0, { "$unique": true }] } } } },
+		{ "why": "amounts are numbers, European decimals and currency text included", "tool": "get_range", "args": { "range": "D2:D40" }, "expect": { "values": { "$nonEmpty": { "$column": [0, { "$sum": 3700.5 }] } } } },
+		{ "why": "dates are real dates read day-first, as the export writes them (02/04 is 2 April)", "tool": "get_range", "args": { "range": "B2:B40" }, "expect": { "values": { "$nonEmpty": { "$column": [0, { "$every": { "$match": "^\\d{4}-\\d{2}-\\d{2}$" }, "$some": "2026-04-02", "$not": { "$some": "2026-02-04" } }] } } } },
+		{ "why": "customer names are trimmed", "tool": "get_range", "args": { "range": "C2:C40" }, "expect": { "values": { "$nonEmpty": { "$column": [0, { "$every": { "$match": "^\\S(.*\\S)?$" } }] } } } },
+		{ "why": "regions are spelled one way", "tool": "get_range", "args": { "range": "E2:E40" }, "expect": { "values": { "$nonEmpty": { "$column": [0, { "$distinct": { "$length": 2 } }] } } } },
+		{ "why": "no formula errors", "tool": "get_range", "args": { "range": "A1:H40" }, "expect": { "errors": [] } }
+	],
+	"solution": [
+		{ "tool": "get_range", "args": { "range": "A1:Z50" } },
+		{
+			"tool": "set_range",
+			"args": {
+				"start": "A1",
+				"values": [
+					["Order ID", "Date", "Customer", "Amount", "Region"],
+					[1001, "2026-03-04", "Acme Corp", 1200, "North"],
+					[1002, "2026-03-31", "Globex", 950, "South"],
+					[1003, "2026-03-04", "Initech", 300, "North"],
+					[1004, "2026-04-02", "Umbrella", 1250.5, "South"]
+				]
+			}
+		},
+		{ "tool": "delete_rows", "args": { "start": 6, "count": 3 } }
+	]
+}

package/skills/pixerate-spreadsheet-clean-import/evals/dedupe-keep-latest.json

@@ -0,0 +1,25 @@
+{
+	"prompt": "Remove duplicate customers from this list. Two rows are the same customer when the email matches, ignoring case and spaces; keep each customer's most recently updated row.",
+	"fixture": {
+		"editor": "spreadsheet",
+		"rows": [
+			["Email", "Name", "Plan", "Updated"],
+			["ann@x.com", "Ann Lee", "Free", "2026-01-10"],
+			["bob@y.com", "Bob Ray", "Pro", "2026-02-01"],
+			["Ann@X.com ", "Ann Lee", "Pro", "2026-05-01"],
+			["cat@z.com", "Cat Sun", "Free", "2026-03-15"],
+			["bob@y.com", "Bob Ray", "Pro", "2026-02-01"]
+		]
+	},
+	"checks": [
+		{ "why": "one row per customer under the header", "tool": "get_range", "args": { "range": "A1:F40" }, "expect": { "values": { "$nonEmpty": { "$length": 4 } } } },
+		{ "why": "Ann's latest row (Pro, updated 1 May) is the one kept", "tool": "get_range", "args": { "range": "A2:D40" }, "expect": { "values": { "$some": [{ "$match": ["^\\s*ann@x\\.com\\s*$", "i"] }, "Ann Lee", "Pro", "2026-05-01"] } } },
+		{ "why": "Bob and Cat are still there", "tool": "get_range", "args": { "range": "A2:A40" }, "expect": { "values": { "$some": ["bob@y.com"], "$nonEmpty": { "$some": ["cat@z.com"] } } } },
+		{ "why": "the header row is unchanged", "tool": "get_range", "args": { "range": "A1:D1" }, "expect": { "values": [["Email", "Name", "Plan", "Updated"]] } }
+	],
+	"solution": [
+		{ "tool": "get_range", "args": { "range": "A1:D20" } },
+		{ "tool": "set_range", "args": { "start": "A2", "values": [["ann@x.com", "Ann Lee", "Pro", "2026-05-01"], ["bob@y.com", "Bob Ray", "Pro", "2026-02-01"], ["cat@z.com", "Cat Sun", "Free", "2026-03-15"]] } },
+		{ "tool": "delete_rows", "args": { "start": 5, "count": 2 } }
+	]
+}

package/skills/pixerate-spreadsheet-clean-import/evals/fix-types-only.json

@@ -0,0 +1,24 @@
+{
+	"prompt": "The ZIP column lost its leading zeros on import and Amount has some text in it. Fix those two columns so ZIPs are five-digit codes and amounts are numbers (leave missing amounts empty). Don't change anything else.",
+	"fixture": {
+		"editor": "spreadsheet",
+		"rows": [
+			["ZIP", "Amount", "Date", "Note"],
+			["2134", "300 USD", "2026-03-04", "rush"],
+			["90210", "1 200", "2026-03-05", ""],
+			["601", "(45)", "2026-03-05", "refund"],
+			["10001", "n/a", "2026-03-06", "check with sales"]
+		]
+	},
+	"checks": [
+		{ "why": "ZIPs are five-digit text, leading zeros restored", "tool": "get_range", "args": { "range": "A2:A5" }, "expect": { "values": [["02134"], ["90210"], ["00601"], ["10001"]] } },
+		{ "why": "amounts are numbers; a missing amount is empty, not 0", "tool": "get_range", "args": { "range": "B2:B5" }, "expect": { "values": [[300], [1200], [-45], [""]] } },
+		{ "why": "the other columns and the headers are untouched", "tool": "get_range", "args": { "range": "A1:D5" }, "expect": { "raw": [["ZIP", "Amount", "Date", "Note"], { "$length": 4 }, { "$length": 4 }, { "$length": 4 }, { "$length": 4 }] } },
+		{ "why": "dates and notes keep what was typed", "tool": "get_range", "args": { "range": "C2:D5" }, "expect": { "raw": [["2026-03-04", "rush"], ["2026-03-05", ""], ["2026-03-05", "refund"], ["2026-03-06", "check with sales"]] } },
+		{ "why": "the sheet keeps its size", "tool": "get_range", "args": { "range": "A1" }, "expect": { "sheet": { "rows": 5, "columns": 4 } } }
+	],
+	"solution": [
+		{ "tool": "get_range", "args": { "range": "A1:D5" } },
+		{ "tool": "set_range", "args": { "start": "A2", "values": [["'02134", 300], ["'90210", 1200], ["'00601", -45], ["'10001", null]] } }
+	]
+}

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

@@ -26,6 +26,14 @@ them from `get_video_project`; never invent them.
 
 For errors, namespaced tool names and undo conventions, see `pixerate-agent-tools`.
 
+## 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-talking-head-edit`: dialogue cleanup by transcript: fillers, pauses, stutters.
+- `pixerate-bgm-alignment`: cutting to the beat, ducking music under speech, loudness.
+
 ## Working method
 
 1. **Read.** `get_video_project` for settings, assets, tracks, clips (with end and source