oh-my-opencode 4.7.5 → 4.8.0

package/packages/shared-skills/skills/visual-qa/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: visual-qa
+description: "Rigorous visual QA for any UI you built or changed, across BOTH web/page UIs and TUI/terminal UIs. MUST USE after building or changing any UI to verify it visually before declaring it done. Captures objective reference evidence with a bundled diff script (image-diff for screenshots, tui-check for terminal captures), then runs two parallel read-only oracle passes (design-system and functional integrity; visual fidelity and CJK precision) and synthesizes one good/bad verdict. Triggers: visual QA, visual regression, screenshot diff, pixel diff, image comparison, UI looks wrong, design system check, is this really a design system or just an image, alpha channel breakage, responsive check, CJK text, Korean/Japanese/Chinese text clipping, baseline drop, glyph drop, TUI alignment, terminal UI, tmux capture, box-drawing border misalignment, wide-character column drift. Use it even when the user does not say visual QA but asks whether a page, component, or terminal layout looks right."
+---
+
+# Visual QA - Dual-Oracle Web and TUI Verification
+
+Verify a rendered UI against intent using objective script evidence plus two parallel read-only oracle passes, then synthesize one good/bad verdict. The script numbers focus the reviewers. They are not the verdict.
+
+## Purpose and when to use
+
+- Use after you build or change any UI, before calling it done. Covers web/page UIs and TUI/terminal UIs.
+- Use when output must match a mock, a baseline, or a stated design intent; when you suspect a regression; when CJK (Korean/Japanese/Chinese) text may clip, misalign, or wrap awkwardly; when a claimed design system might actually be a flat image; when a terminal layout may overflow or its borders may break.
+- Skip when there is no rendered surface (pure backend or library logic with no visual or terminal output). For broad post-implementation review use review-work; this skill is the visual specialist.
+
+In the commands below, `$SKILL_DIR` is this skill's own directory (the folder containing this SKILL.md). The bundled script lives at `scripts/cli.ts` inside it.
+
+## Step 1 - Detect the surface
+
+- Web/page UI: renders in a browser (HTML/CSS/JS, components, canvas, SVG). Evidence is screenshots.
+- TUI/terminal UI: renders as text in a terminal (box-drawing, panes, status lines, REPL/TUI apps). Evidence is terminal captures.
+
+If the change touches both, run both capture tracks and feed both into the passes.
+
+## Step 2 - Capture objective reference evidence
+
+### Web
+
+1. Capture a REFERENCE image: the user's mock/target, or a known-good baseline. Save as PNG.
+2. Capture the ACTUAL rendered screenshot at the same viewport size using the project's browser tooling (the playwright, agent-browser, or dev-browser skill). Save as PNG.
+3. Run the diff and keep the JSON:
+
+```
+bun "$SKILL_DIR/scripts/cli.ts" image-diff <reference.png> <actual.png>
+```
+
+Key fields: `dimensionsMatch`, `diffRatio` (0..1), `similarityScore` (0..100), `alphaChannelIntact`, `hotspots[]` (grid regions ranked by `diffRatio`).
+
+### TUI
+
+1. Capture plain text and an ANSI-preserving copy:
+
+```
+tmux capture-pane -p > capture.txt
+tmux capture-pane -e -p > capture-ansi.txt
+```
+
+2. Run the check with the REAL terminal width and keep the JSON:
+
+```
+bun "$SKILL_DIR/scripts/cli.ts" tui-check capture.txt --cols <N>
+```
+
+Key fields: `maxWidth`, `overflowLines[]`, `borderMisaligned`, `wideCharColumns[]`, `hasAnsi`.
+
+This JSON (diff ratio, similarity score, hotspots or overflow lines, border alignment, wide-char columns, alpha) is REFERENCE evidence to aim the reviewers. It is not the verdict by itself.
+
+## Step 3 - Dispatch two read-only QA subagents in parallel
+
+Send BOTH task calls in a single message so they run concurrently. Each oracle is read-only: it reviews and reports, it cannot modify files. Each returns PASS, REVISE, or FAIL with concrete, located findings. Pass A proves the surface is a real design-system implementation, not a mock-only or faked-image substitute. Pass B directly opens screenshots and inspects source/content for visual and CJK defects.
+
+Paste evidence directly into each prompt: source code, the plain-text TUI captures, the script JSON, and the screenshot paths plus your described observations for web. The two passes differ in depth by charter, not by any model or effort setting, which cannot be pinned per call.
+
+### Pass A - Design-system and functional integrity (deeper, strict)
+
+```
+task(subagent_type="oracle",
+  run_in_background=true,
+  load_skills=[],
+  description="Visual QA pass A: design-system and functional integrity",
+  prompt="""
+REVIEW TYPE: DESIGN-SYSTEM AND FUNCTIONAL INTEGRITY (read-only)
+TIER INTENT: Treat this as the deeper, stricter pass. Reason exhaustively before concluding. Assume a plausible-looking surface may be faked or mock-only until the source proves otherwise.
+
+INTENT:
+{What the user asked for, the mock or baseline, and the constraints.}
+
+SURFACE: {web | tui | both}
+
+SOURCE CODE:
+{Full source of the UI: components, styles/tokens, layout, render code. Include neighboring files that show existing patterns.}
+
+CAPTURES:
+{Web: actual screenshot path(s) plus your described observations. TUI: paste capture.txt and capture-ansi.txt inline.}
+
+SHARED SCRIPT EVIDENCE (reference, not verdict):
+{Paste the image-diff or tui-check JSON. Use alphaChannelIntact for the transparency check.}
+
+CHECK EACH:
+1. Real design system vs ad-hoc/mock-only: are styles driven by coherent design tokens and reused primitives, or one-off hardcoded values scattered per element? Treat mock-only screens, static compositions, or one-page hardcoded styling with no reusable system as BLOCKING unless the user explicitly requested a throwaway mock.
+2. Faked-with-an-image anti-pattern: is the UI a real DOM/component tree, or a pasted raster/screenshot or background-image standing in for live elements? For TUI: a real layout that reflows, or hardcoded pre-rendered text at fixed widths?
+3. Alpha and transparency: handled correctly, with no unexpected opaque or black fills and correct PNG/CSS alpha? Cross-check alphaChannelIntact.
+4. Code style and implementation quality.
+5. Responsive and resize behavior across viewport sizes (web) or terminal resize (TUI).
+6. Do the user-intended FEATURES actually work: interactions, states, navigation (web); input handling, resize, scroll (TUI)? Trace the code paths.
+
+OUTPUT:
+VERDICT: PASS | REVISE | FAIL
+CONFIDENCE: HIGH | MEDIUM | LOW
+SUMMARY: 1-3 sentences
+FINDINGS: for each, [dimension] [severity] what is wrong, where (file/line or capture region), and the concrete fix
+WHAT IS GOOD: correct aspects that must not regress
+BLOCKING: items that must be fixed; empty if PASS
+"""
+)
+```
+
+### Pass B - Visual fidelity and CJK precision (focused)
+
+```
+task(subagent_type="oracle",
+  run_in_background=true,
+  load_skills=[],
+  description="Visual QA pass B: visual fidelity and CJK precision",
+  prompt="""
+REVIEW TYPE: VISUAL FIDELITY AND CJK PRECISION (read-only)
+TIER INTENT: Treat this as the focused visual pass. Directly open the screenshots with the available image-viewing tool (`view_image`, `look_at`, or browser inspection) before judging. Anchor every claim to the script evidence, source code, and captures.
+
+INTENT:
+{What the user requested and the mock or baseline to match.}
+
+SURFACE: {web | tui | both}
+
+CAPTURES:
+{Web: actual and reference screenshot paths plus your described observations. TUI: paste capture.txt and capture-ansi.txt inline.}
+
+SOURCE CODE:
+{For web: include the rendered text/content, components, typography, layout, and style code. For TUI: include render code that controls wrapping, width, and wide-character handling.}
+
+SCRIPT EVIDENCE (required, consume every field):
+{Paste the image-diff or tui-check JSON.}
+
+USE THE EVIDENCE:
+- Web (image-diff): start from diffRatio and similarityScore, then directly open every screenshot path and inspect every hotspots[] entry (gridX, gridY, x, y, width, height, diffRatio). Explain the visual cause of each flagged region from the pixels and source/content together.
+- TUI (tui-check): inspect maxWidth vs expectedColumns, every overflowLines[] entry, borderMisaligned, and wideCharColumns[].
+
+CHECK:
+1. Does the rendered output match what the user requested: layout, spacing, color, type, alignment?
+2. CJK precision:
+   - Web: natural CJK line breaking for display and body text. Flag oversized headings that create orphaned one-character or final-syllable lines, split Korean/Japanese/Chinese semantic phrases unnaturally, detach labels such as `[Image #1]` from their content, clip baselines/descenders, drop glyphs (tofu), or show font metric mismatch. Treat the screenshot pattern `에이전트 오케스트 / 레이션 현황 및 미 / 래` as REVISE/FAIL, not acceptable wrapping.
+   - TUI: wide-character column drift (CJK cells counted as 1 instead of 2), box-drawing border misalignment, content overflowing past the terminal width.
+
+OUTPUT:
+VERDICT: PASS | REVISE | FAIL
+CONFIDENCE: HIGH | MEDIUM | LOW
+SUMMARY: 1-3 sentences
+EVIDENCE TRACE: each hotspot or overflow line mapped to its visual cause
+FINDINGS: for each, [severity] what is wrong, where (hotspot grid or capture line:col), and the concrete fix
+BLOCKING: items that must be fixed; empty if PASS
+"""
+)
+```
+
+## Step 4 - Synthesize one verdict
+
+When both passes return, merge them into a single report. Per dimension, mark good or bad with evidence. For each bad item, state what is wrong, where (file/line, hotspot grid, or capture line), and the concrete fix. Call out what is genuinely good so it is not regressed later.
+
+Completion gate: do not declare the UI done until both passes are satisfied, OR the remaining gaps are explicitly listed and accepted by the user. A high `similarityScore` with an open Pass A finding, for example a faked-image layout or a broken feature, is still a FAIL.
+
+```markdown
+# Visual QA - Verdict: GOOD | NEEDS WORK
+
+| Dimension | Pass | Verdict | Evidence |
+|---|---|---|---|
+| Design system real vs faked | A | good/bad | ... |
+| Features work | A | good/bad | ... |
+| Responsive / resize | A | good/bad | ... |
+| Alpha / transparency | A+B | good/bad | ... |
+| Visual fidelity to intent | B | good/bad | ... |
+| CJK precision | B | good/bad | ... |
+
+## Must fix
+[Blocking items, each with location and fix, in priority order]
+
+## Good, keep it
+[Correct aspects that must not regress]
+
+## Completion gate
+[Satisfied, or the exact remaining gaps and who accepted them]
+```
+
+## Reference evidence is not the verdict
+
+The script quantifies pixels and columns. It cannot judge whether the result is a real design system, whether features work, or whether intent was met. A 99/100 `similarityScore` can still hide a pasted-image fake, a broken interaction, or clipped CJK descenders. Use the numbers to aim the oracles, then trust the synthesized review.
+
+Illustrative output (locked field names):
+
+```json
+{
+  "command": "image-diff",
+  "dimensionsMatch": true,
+  "reference": { "width": 1440, "height": 900 },
+  "actual": { "width": 1440, "height": 900 },
+  "totalPixels": 1296000,
+  "diffPixels": 38880,
+  "diffRatio": 0.03,
+  "similarityScore": 97,
+  "alphaChannelIntact": true,
+  "hotspots": [
+    { "gridX": 2, "gridY": 0, "x": 960, "y": 0, "width": 480, "height": 300, "diffRatio": 0.21 }
+  ],
+  "summary": "97/100 similarity; one hotspot in the top-right header region."
+}
+```
+
+```json
+{
+  "command": "tui-check",
+  "expectedColumns": 80,
+  "lineCount": 24,
+  "lineWidths": [80, 80, 82, 80],
+  "maxWidth": 82,
+  "overflowLines": [ { "line": 3, "width": 82 } ],
+  "borderMisaligned": true,
+  "wideCharColumns": [12, 13],
+  "hasAnsi": false,
+  "summary": "Line 3 overflows 80 cols by 2; borders misaligned at wide-char columns 12-13."
+}
+```

package/packages/shared-skills/skills/visual-qa/scripts/ansi.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test"
+
+import { hasAnsi, stripAnsi } from "./ansi"
+
+const ESC = String.fromCharCode(0x1b)
+
+describe("stripAnsi", () => {
+	test("#given an ANSI-wrapped string #when stripped #then escape codes are removed", () => {
+		// given
+		const input = `${ESC}[31mred${ESC}[0m`
+		// when
+		const stripped = stripAnsi(input)
+		// then
+		expect(stripped).toBe("red")
+	})
+
+	test("#given a plain string #when stripped #then it is unchanged", () => {
+		// given
+		const input = "plain text"
+		// when
+		const stripped = stripAnsi(input)
+		// then
+		expect(stripped).toBe("plain text")
+	})
+})
+
+describe("hasAnsi", () => {
+	test("#given a string with ANSI codes #when checked #then it is true", () => {
+		// given
+		const input = `${ESC}[1mbold${ESC}[0m`
+		// when
+		const detected = hasAnsi(input)
+		// then
+		expect(detected).toBe(true)
+	})
+
+	test("#given a plain string #when checked #then it is false", () => {
+		// given
+		const input = "no ansi here"
+		// when
+		const detected = hasAnsi(input)
+		// then
+		expect(detected).toBe(false)
+	})
+})

package/packages/shared-skills/skills/visual-qa/scripts/ansi.ts

@@ -0,0 +1,17 @@
+const ESC = String.fromCharCode(0x1b)
+const CSI = String.fromCharCode(0x9b)
+
+// Matches CSI/escape sequences (colors, cursor moves) without embedding raw
+// control characters in the regex source.
+const ANSI_PATTERN = new RegExp(
+	`[${ESC}${CSI}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`,
+	"g",
+)
+
+export function stripAnsi(input: string): string {
+	return input.replace(ANSI_PATTERN, "")
+}
+
+export function hasAnsi(input: string): boolean {
+	return stripAnsi(input) !== input
+}

package/packages/shared-skills/skills/visual-qa/scripts/cli.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { run, runImageDiff, runTuiCheck } from "./cli"
+import { encodeRgbaPng, solidRgba } from "./png-synth"
+
+function tempDir(): string {
+	return mkdtempSync(join(tmpdir(), "visual-qa-"))
+}
+
+describe("runImageDiff", () => {
+	test("#given two identical PNG files #when diffed #then similarity is 100", () => {
+		// given
+		const dir = tempDir()
+		const reference = join(dir, "reference.png")
+		const actual = join(dir, "actual.png")
+		writeFileSync(reference, encodeRgbaPng(2, 2, solidRgba(2, 2, [1, 2, 3, 255])))
+		writeFileSync(actual, encodeRgbaPng(2, 2, solidRgba(2, 2, [1, 2, 3, 255])))
+		// when
+		const result = runImageDiff([reference, actual])
+		// then
+		expect(result.command).toBe("image-diff")
+		expect(result.similarityScore).toBe(100)
+		expect(result.dimensionsMatch).toBe(true)
+	})
+
+	test("#given missing arguments #when diffed #then it throws a usage error", () => {
+		// given / when / then
+		expect(() => runImageDiff([])).toThrow("usage")
+	})
+})
+
+describe("runTuiCheck", () => {
+	test("#given a CJK capture file #when checked #then widths count wide characters", () => {
+		// given
+		const dir = tempDir()
+		const file = join(dir, "capture.txt")
+		writeFileSync(file, "가나\nhello")
+		// when
+		const result = runTuiCheck([file, "--cols", "40"])
+		// then
+		expect(result.command).toBe("tui-check")
+		expect(result.expectedColumns).toBe(40)
+		expect(result.lineWidths).toEqual([4, 5])
+	})
+})
+
+describe("run dispatch", () => {
+	test("#given an unknown command #when run #then it throws", () => {
+		// given / when / then
+		expect(() => run(["bogus"])).toThrow("unknown command")
+	})
+})
+
+describe("cli entry", () => {
+	test("#given the cli is spawned for image-diff #when it runs #then it prints JSON and exits zero", () => {
+		// given
+		const dir = tempDir()
+		const reference = join(dir, "reference.png")
+		const actual = join(dir, "actual.png")
+		writeFileSync(reference, encodeRgbaPng(2, 2, solidRgba(2, 2, [0, 0, 0, 255])))
+		writeFileSync(actual, encodeRgbaPng(2, 2, solidRgba(2, 2, [255, 255, 255, 255])))
+		// when
+		const proc = Bun.spawnSync(["bun", join(import.meta.dir, "cli.ts"), "image-diff", reference, actual])
+		// then
+		expect(proc.exitCode).toBe(0)
+		const parsed: Record<string, unknown> = JSON.parse(proc.stdout.toString())
+		expect(parsed["command"]).toBe("image-diff")
+		expect(parsed["similarityScore"]).toBe(0)
+	})
+})

package/packages/shared-skills/skills/visual-qa/scripts/cli.ts

@@ -0,0 +1,82 @@
+import { readFileSync } from "node:fs"
+
+import { diffImages } from "./image-diff"
+import { decodePng } from "./png-decode"
+import { checkTui } from "./tui-grid"
+import type { ImageDiffResult, TuiCheckResult } from "./types"
+
+export class CliError extends Error {
+	readonly name = "CliError"
+}
+
+const DEFAULT_COLUMNS = 80
+const COLS_FLAG = "--cols"
+
+export function runImageDiff(args: readonly string[]): ImageDiffResult {
+	const referencePath = args[0]
+	const actualPath = args[1]
+	if (referencePath === undefined || actualPath === undefined) {
+		throw new CliError("usage: image-diff <reference.png> <actual.png>")
+	}
+	const reference = decodePng(readFileSync(referencePath))
+	const actual = decodePng(readFileSync(actualPath))
+	return diffImages(reference, actual)
+}
+
+function parseColumns(args: readonly string[]): number {
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index] ?? ""
+		if (arg === COLS_FLAG) {
+			const parsed = Number(args[index + 1])
+			if (!Number.isInteger(parsed) || parsed <= 0) {
+				throw new CliError(`${COLS_FLAG} requires a positive integer`)
+			}
+			return parsed
+		}
+		if (arg.startsWith(`${COLS_FLAG}=`)) {
+			const parsed = Number(arg.slice(COLS_FLAG.length + 1))
+			if (!Number.isInteger(parsed) || parsed <= 0) {
+				throw new CliError(`${COLS_FLAG} requires a positive integer`)
+			}
+			return parsed
+		}
+	}
+	return DEFAULT_COLUMNS
+}
+
+export function runTuiCheck(args: readonly string[]): TuiCheckResult {
+	const capturePath = args[0]
+	if (capturePath === undefined || capturePath.startsWith("--")) {
+		throw new CliError("usage: tui-check <capture.txt> [--cols N]")
+	}
+	const text = readFileSync(capturePath, "utf8")
+	return checkTui(text, parseColumns(args.slice(1)))
+}
+
+export function run(argv: readonly string[]): ImageDiffResult | TuiCheckResult {
+	const command = argv[0]
+	const rest = argv.slice(1)
+	switch (command) {
+		case "image-diff":
+			return runImageDiff(rest)
+		case "tui-check":
+			return runTuiCheck(rest)
+		default:
+			throw new CliError(`unknown command "${command ?? ""}"; expected "image-diff" or "tui-check"`)
+	}
+}
+
+function main(argv: readonly string[]): void {
+	try {
+		const result = run(argv)
+		process.stdout.write(`${JSON.stringify(result, null, 2)}\n`)
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error)
+		process.stderr.write(`visual-qa error: ${message}\n`)
+		process.exitCode = 1
+	}
+}
+
+if (import.meta.main) {
+	main(process.argv.slice(2))
+}

package/packages/shared-skills/skills/visual-qa/scripts/east-asian-width.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test"
+
+import { charWidth, stringWidth } from "./east-asian-width"
+
+describe("charWidth", () => {
+	test("#given an ASCII letter #when measured #then it is one column", () => {
+		// given / when / then
+		expect(charWidth(0x61)).toBe(1)
+	})
+
+	test("#given a Hangul syllable #when measured #then it is two columns", () => {
+		expect(charWidth(0xac00)).toBe(2)
+	})
+
+	test("#given a CJK ideograph #when measured #then it is two columns", () => {
+		expect(charWidth(0x4e00)).toBe(2)
+	})
+
+	test("#given a fullwidth Latin letter #when measured #then it is two columns", () => {
+		expect(charWidth(0xff21)).toBe(2)
+	})
+
+	test("#given a halfwidth katakana #when measured #then it is one column", () => {
+		expect(charWidth(0xff71)).toBe(1)
+	})
+
+	test("#given a combining diacritic #when measured #then it is zero columns", () => {
+		expect(charWidth(0x0301)).toBe(0)
+	})
+
+	test("#given a zero-width space #when measured #then it is zero columns", () => {
+		expect(charWidth(0x200b)).toBe(0)
+	})
+
+	test("#given an emoji #when measured #then it is two columns", () => {
+		expect(charWidth(0x1f600)).toBe(2)
+	})
+})
+
+describe("stringWidth", () => {
+	test("#given an ASCII string #when measured #then width equals character count", () => {
+		expect(stringWidth("hello")).toBe(5)
+	})
+
+	test("#given Hangul text #when measured #then each syllable counts as two", () => {
+		expect(stringWidth("가나다")).toBe(6)
+	})
+
+	test("#given CJK text #when measured #then each ideograph counts as two", () => {
+		expect(stringWidth("日本語")).toBe(6)
+	})
+
+	test("#given a base letter plus a combining mark #when measured #then it is one column", () => {
+		expect(stringWidth("e\u0301")).toBe(1)
+	})
+
+	test("#given mixed ASCII and CJK #when measured #then widths add up", () => {
+		expect(stringWidth("AB가")).toBe(4)
+	})
+})

package/packages/shared-skills/skills/visual-qa/scripts/east-asian-width.ts

@@ -0,0 +1,72 @@
+interface CodePointRange {
+	readonly start: number
+	readonly end: number
+}
+
+// Combining marks and zero-width code points advance the cursor by 0 columns.
+const ZERO_WIDTH_RANGES: readonly CodePointRange[] = [
+	{ start: 0x0300, end: 0x036f }, // combining diacritical marks
+	{ start: 0x0483, end: 0x0489 }, // combining Cyrillic
+	{ start: 0x0591, end: 0x05bd }, // Hebrew points
+	{ start: 0x0610, end: 0x061a }, // Arabic marks
+	{ start: 0x064b, end: 0x065f }, // Arabic marks
+	{ start: 0x0670, end: 0x0670 }, // Arabic superscript alef
+	{ start: 0x06d6, end: 0x06dc }, // Arabic small high marks
+	{ start: 0x1160, end: 0x11ff }, // Hangul Jamo medial/final (combining)
+	{ start: 0x200b, end: 0x200f }, // zero-width space / directional marks
+	{ start: 0x202a, end: 0x202e }, // bidi embeddings
+	{ start: 0x2060, end: 0x2064 }, // word joiner / invisible operators
+	{ start: 0x20d0, end: 0x20ff }, // combining marks for symbols
+	{ start: 0xfe20, end: 0xfe2f }, // combining half marks
+	{ start: 0xfeff, end: 0xfeff }, // zero-width no-break space (BOM)
+]
+
+// East Asian Wide + Fullwidth code points advance the cursor by 2 columns.
+const WIDE_RANGES: readonly CodePointRange[] = [
+	{ start: 0x1100, end: 0x115f }, // Hangul Jamo (leading consonants)
+	{ start: 0x231a, end: 0x231b }, // watch / hourglass
+	{ start: 0x2e80, end: 0x303e }, // CJK radicals, Kangxi, CJK symbols
+	{ start: 0x3041, end: 0x33ff }, // Kana, Bopomofo, CJK compatibility
+	{ start: 0x3400, end: 0x4dbf }, // CJK Unified Ext A
+	{ start: 0x4e00, end: 0x9fff }, // CJK Unified Ideographs
+	{ start: 0xa000, end: 0xa4cf }, // Yi syllables
+	{ start: 0xa960, end: 0xa97f }, // Hangul Jamo Ext-A
+	{ start: 0xac00, end: 0xd7a3 }, // Hangul syllables
+	{ start: 0xf900, end: 0xfaff }, // CJK compatibility ideographs
+	{ start: 0xfe10, end: 0xfe19 }, // vertical forms
+	{ start: 0xfe30, end: 0xfe6f }, // CJK compatibility / small forms
+	{ start: 0xff00, end: 0xff60 }, // fullwidth forms (halfwidth starts at 0xff61)
+	{ start: 0xffe0, end: 0xffe6 }, // fullwidth signs
+	{ start: 0x1b000, end: 0x1b16f }, // Kana supplement / extended
+	{ start: 0x1f200, end: 0x1f2ff }, // enclosed ideographic supplement
+	{ start: 0x1f300, end: 0x1faff }, // emoji and pictographs
+	{ start: 0x20000, end: 0x3fffd }, // CJK Unified Ext B and beyond
+]
+
+function inRanges(codePoint: number, ranges: readonly CodePointRange[]): boolean {
+	for (const range of ranges) {
+		if (codePoint >= range.start && codePoint <= range.end) {
+			return true
+		}
+	}
+	return false
+}
+
+export function charWidth(codePoint: number): 0 | 1 | 2 {
+	if (codePoint === 0) return 0
+	if (codePoint < 0x20) return 0 // C0 control
+	if (codePoint >= 0x7f && codePoint <= 0x9f) return 0 // DEL and C1 control
+	if (inRanges(codePoint, ZERO_WIDTH_RANGES)) return 0
+	if (inRanges(codePoint, WIDE_RANGES)) return 2
+	return 1
+}
+
+export function stringWidth(text: string): number {
+	let total = 0
+	for (const char of text) {
+		const codePoint = char.codePointAt(0)
+		if (codePoint === undefined) continue
+		total += charWidth(codePoint)
+	}
+	return total
+}

package/packages/shared-skills/skills/visual-qa/scripts/image-diff.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test"
+
+import { diffImages } from "./image-diff"
+import { solidRgba } from "./png-synth"
+import type { DecodedImage } from "./types"
+
+function makeImage(width: number, height: number, rgba: Uint8Array, transparent = false): DecodedImage {
+	return { width, height, rgba, hasAlphaChannel: true, hasTransparentPixels: transparent }
+}
+
+describe("diffImages", () => {
+	test("#given two identical images #when diffed #then similarity is 100 with no hotspots", () => {
+		// given
+		const ref = makeImage(4, 4, solidRgba(4, 4, [10, 20, 30, 255]))
+		const act = makeImage(4, 4, solidRgba(4, 4, [10, 20, 30, 255]))
+		// when
+		const result = diffImages(ref, act)
+		// then
+		expect(result.diffPixels).toBe(0)
+		expect(result.similarityScore).toBe(100)
+		expect(result.hotspots.length).toBe(0)
+		expect(result.dimensionsMatch).toBe(true)
+	})
+
+	test("#given two fully different images #when diffed #then similarity is 0 with hotspots", () => {
+		// given
+		const ref = makeImage(4, 4, solidRgba(4, 4, [0, 0, 0, 255]))
+		const act = makeImage(4, 4, solidRgba(4, 4, [255, 255, 255, 255]))
+		// when
+		const result = diffImages(ref, act)
+		// then
+		expect(result.diffPixels).toBe(16)
+		expect(result.similarityScore).toBe(0)
+		expect(result.hotspots.length).toBeGreaterThan(0)
+	})
+
+	test("#given images of different sizes #when diffed #then dimensionsMatch is false", () => {
+		// given
+		const ref = makeImage(4, 4, solidRgba(4, 4, [0, 0, 0, 255]))
+		const act = makeImage(2, 2, solidRgba(2, 2, [0, 0, 0, 255]))
+		// when
+		const result = diffImages(ref, act)
+		// then
+		expect(result.dimensionsMatch).toBe(false)
+	})
+
+	test("#given a transparent reference and an opaque actual #when diffed #then alpha is flagged", () => {
+		// given
+		const ref = makeImage(2, 2, solidRgba(2, 2, [0, 0, 0, 128]), true)
+		const act = makeImage(2, 2, solidRgba(2, 2, [0, 0, 0, 255]), false)
+		// when
+		const result = diffImages(ref, act)
+		// then
+		expect(result.alphaChannelIntact).toBe(false)
+	})
+
+	test("#given a single changed pixel #when diffed #then one hotspot marks its grid cell", () => {
+		// given
+		const base = solidRgba(8, 8, [0, 0, 0, 255])
+		const changed = solidRgba(8, 8, [0, 0, 0, 255])
+		changed[0] = 255
+		// when
+		const result = diffImages(makeImage(8, 8, base), makeImage(8, 8, changed))
+		// then
+		expect(result.diffPixels).toBe(1)
+		expect(result.hotspots.length).toBe(1)
+		expect(result.hotspots[0]?.gridX).toBe(0)
+		expect(result.hotspots[0]?.gridY).toBe(0)
+	})
+})