oh-my-opencode 4.7.4 → 4.8.0

package/packages/omo-codex/plugin/skills/visual-qa/scripts/png-crc.ts

@@ -0,0 +1,27 @@
+import { Buffer } from "node:buffer"
+
+export const PNG_SIGNATURE: Buffer = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
+
+function buildCrcTable(): Uint32Array {
+	const table = new Uint32Array(256)
+	for (let n = 0; n < 256; n++) {
+		let c = n
+		for (let k = 0; k < 8; k++) {
+			c = (c & 1) === 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
+		}
+		table[n] = c >>> 0
+	}
+	return table
+}
+
+const CRC_TABLE = buildCrcTable()
+
+export function crc32(data: Buffer): number {
+	let crc = 0xffffffff
+	for (let i = 0; i < data.length; i++) {
+		const byte = data[i] ?? 0
+		const entry = CRC_TABLE[(crc ^ byte) & 0xff] ?? 0
+		crc = entry ^ (crc >>> 8)
+	}
+	return (crc ^ 0xffffffff) >>> 0
+}

package/packages/omo-codex/plugin/skills/visual-qa/scripts/png-decode.ts

@@ -0,0 +1,206 @@
+import { Buffer } from "node:buffer"
+import { inflateSync } from "node:zlib"
+
+import { PNG_SIGNATURE } from "./png-crc"
+import type { DecodedImage } from "./types"
+
+export class PngDecodeError extends Error {
+	readonly name = "PngDecodeError"
+}
+
+interface PngHeader {
+	readonly width: number
+	readonly height: number
+	readonly bitDepth: number
+	readonly colorType: number
+	readonly channels: number
+}
+
+interface PngChunk {
+	readonly type: string
+	readonly data: Buffer
+}
+
+function readChunks(buffer: Buffer): readonly PngChunk[] {
+	const chunks: PngChunk[] = []
+	let offset = 8
+	while (offset + 8 <= buffer.length) {
+		const length = buffer.readUInt32BE(offset)
+		const type = buffer.toString("ascii", offset + 4, offset + 8)
+		const dataStart = offset + 8
+		const dataEnd = dataStart + length
+		if (dataEnd + 4 > buffer.length) break
+		chunks.push({ type, data: buffer.subarray(dataStart, dataEnd) })
+		offset = dataEnd + 4
+	}
+	return chunks
+}
+
+function channelsForColorType(colorType: number): number {
+	switch (colorType) {
+		case 0:
+			return 1
+		case 2:
+			return 3
+		case 4:
+			return 2
+		case 6:
+			return 4
+		default:
+			throw new PngDecodeError(`unsupported color type ${colorType}`)
+	}
+}
+
+function parseHeader(data: Buffer): PngHeader {
+	if (data.length < 13) {
+		throw new PngDecodeError("invalid IHDR chunk length")
+	}
+	const colorType = data[9] ?? 0
+	return {
+		width: data.readUInt32BE(0),
+		height: data.readUInt32BE(4),
+		bitDepth: data[8] ?? 0,
+		colorType,
+		channels: channelsForColorType(colorType),
+	}
+}
+
+function paeth(a: number, b: number, c: number): number {
+	const p = a + b - c
+	const pa = Math.abs(p - a)
+	const pb = Math.abs(p - b)
+	const pc = Math.abs(p - c)
+	if (pa <= pb && pa <= pc) return a
+	if (pb <= pc) return b
+	return c
+}
+
+function unfilterRow(filterType: number, row: Buffer, prev: Buffer | null, bpp: number): Buffer {
+	const out = Buffer.alloc(row.length)
+	for (let i = 0; i < row.length; i++) {
+		const raw = row[i] ?? 0
+		const a = i >= bpp ? (out[i - bpp] ?? 0) : 0
+		const b = prev ? (prev[i] ?? 0) : 0
+		const c = i >= bpp && prev ? (prev[i - bpp] ?? 0) : 0
+		switch (filterType) {
+			case 0:
+				out[i] = raw
+				break
+			case 1:
+				out[i] = (raw + a) & 0xff
+				break
+			case 2:
+				out[i] = (raw + b) & 0xff
+				break
+			case 3:
+				out[i] = (raw + ((a + b) >> 1)) & 0xff
+				break
+			case 4:
+				out[i] = (raw + paeth(a, b, c)) & 0xff
+				break
+			default:
+				throw new PngDecodeError(`unsupported filter type ${filterType}`)
+		}
+	}
+	return out
+}
+
+function decodePixels(idat: Buffer, width: number, height: number, bpp: number): Buffer {
+	const inflated = inflateSync(idat)
+	const rowBytes = width * bpp
+	if (inflated.length < height * (rowBytes + 1)) {
+		throw new PngDecodeError("truncated image data")
+	}
+	const pixels = Buffer.alloc(width * height * bpp)
+	let prev: Buffer | null = null
+	for (let y = 0; y < height; y++) {
+		const rowStart = y * (rowBytes + 1)
+		const filterType = inflated[rowStart] ?? 0
+		const filtered = inflated.subarray(rowStart + 1, rowStart + 1 + rowBytes)
+		const row = unfilterRow(filterType, filtered, prev, bpp)
+		row.copy(pixels, y * rowBytes)
+		prev = row
+	}
+	return pixels
+}
+
+function normalizeToRgba(
+	pixels: Buffer,
+	pixelCount: number,
+	channels: number,
+): { readonly rgba: Uint8Array; readonly hasTransparent: boolean } {
+	const rgba = new Uint8Array(pixelCount * 4)
+	let hasTransparent = false
+	for (let i = 0; i < pixelCount; i++) {
+		const src = i * channels
+		let r = 0
+		let g = 0
+		let b = 0
+		let a = 255
+		switch (channels) {
+			case 1: {
+				const v = pixels[src] ?? 0
+				r = v
+				g = v
+				b = v
+				break
+			}
+			case 2: {
+				const v = pixels[src] ?? 0
+				r = v
+				g = v
+				b = v
+				a = pixels[src + 1] ?? 255
+				break
+			}
+			case 3: {
+				r = pixels[src] ?? 0
+				g = pixels[src + 1] ?? 0
+				b = pixels[src + 2] ?? 0
+				break
+			}
+			default: {
+				r = pixels[src] ?? 0
+				g = pixels[src + 1] ?? 0
+				b = pixels[src + 2] ?? 0
+				a = pixels[src + 3] ?? 255
+			}
+		}
+		const dst = i * 4
+		rgba[dst] = r
+		rgba[dst + 1] = g
+		rgba[dst + 2] = b
+		rgba[dst + 3] = a
+		if (a < 255) hasTransparent = true
+	}
+	return { rgba, hasTransparent }
+}
+
+export function decodePng(buffer: Buffer): DecodedImage {
+	if (buffer.length < 8 || !buffer.subarray(0, 8).equals(PNG_SIGNATURE)) {
+		throw new PngDecodeError("not a PNG file (bad signature)")
+	}
+	const chunks = readChunks(buffer)
+	const ihdr = chunks.find((chunk) => chunk.type === "IHDR")
+	if (ihdr === undefined) {
+		throw new PngDecodeError("missing IHDR chunk")
+	}
+	const header = parseHeader(ihdr.data)
+	if (header.bitDepth !== 8) {
+		throw new PngDecodeError(`unsupported bit depth ${header.bitDepth}`)
+	}
+	const idatChunks = chunks.filter((chunk) => chunk.type === "IDAT")
+	if (idatChunks.length === 0) {
+		throw new PngDecodeError("missing IDAT chunk")
+	}
+	const idat = Buffer.concat(idatChunks.map((chunk) => chunk.data))
+	const pixels = decodePixels(idat, header.width, header.height, header.channels)
+	const normalized = normalizeToRgba(pixels, header.width * header.height, header.channels)
+	return {
+		width: header.width,
+		height: header.height,
+		rgba: normalized.rgba,
+		hasAlphaChannel: header.colorType === 4 || header.colorType === 6,
+		hasTransparentPixels: normalized.hasTransparent,
+	}
+}

package/packages/omo-codex/plugin/skills/visual-qa/scripts/png-synth.ts

@@ -0,0 +1,57 @@
+import { Buffer } from "node:buffer"
+import { deflateSync } from "node:zlib"
+
+import { crc32, PNG_SIGNATURE } from "./png-crc"
+
+const BIT_DEPTH_8 = 8
+const COLOR_TYPE_RGBA = 6
+const FILTER_NONE = 0
+const RGBA_CHANNELS = 4
+
+function pngChunk(type: string, data: Buffer): Buffer {
+	const typeBuffer = Buffer.from(type, "ascii")
+	const length = Buffer.alloc(4)
+	length.writeUInt32BE(data.length, 0)
+	const crcBuffer = Buffer.alloc(4)
+	crcBuffer.writeUInt32BE(crc32(Buffer.concat([typeBuffer, data])), 0)
+	return Buffer.concat([length, typeBuffer, data, crcBuffer])
+}
+
+export function encodeRgbaPng(width: number, height: number, rgba: Uint8Array): Buffer {
+	const rowBytes = width * RGBA_CHANNELS
+	const raw = Buffer.alloc(height * (rowBytes + 1))
+	for (let y = 0; y < height; y++) {
+		const rowStart = y * (rowBytes + 1)
+		raw[rowStart] = FILTER_NONE
+		for (let x = 0; x < rowBytes; x++) {
+			raw[rowStart + 1 + x] = rgba[y * rowBytes + x] ?? 0
+		}
+	}
+	const header = Buffer.alloc(13)
+	header.writeUInt32BE(width, 0)
+	header.writeUInt32BE(height, 4)
+	header[8] = BIT_DEPTH_8
+	header[9] = COLOR_TYPE_RGBA
+	return Buffer.concat([
+		PNG_SIGNATURE,
+		pngChunk("IHDR", header),
+		pngChunk("IDAT", deflateSync(raw)),
+		pngChunk("IEND", Buffer.alloc(0)),
+	])
+}
+
+export function solidRgba(
+	width: number,
+	height: number,
+	color: readonly [number, number, number, number],
+): Uint8Array {
+	const rgba = new Uint8Array(width * height * RGBA_CHANNELS)
+	for (let pixel = 0; pixel < width * height; pixel++) {
+		const offset = pixel * RGBA_CHANNELS
+		rgba[offset] = color[0]
+		rgba[offset + 1] = color[1]
+		rgba[offset + 2] = color[2]
+		rgba[offset + 3] = color[3]
+	}
+	return rgba
+}

package/packages/omo-codex/plugin/skills/visual-qa/scripts/tui-grid.ts

@@ -0,0 +1,88 @@
+import { hasAnsi, stripAnsi } from "./ansi"
+import { charWidth, stringWidth } from "./east-asian-width"
+import type { OverflowLine, TuiCheckResult } from "./types"
+
+const BOX_DRAWING_START = 0x2500
+const BOX_DRAWING_END = 0x257f
+const MAX_WIDE_COLUMNS = 64
+
+function splitLines(text: string): string[] {
+	const lines = text.split(/\r?\n/)
+	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop()
+	return lines
+}
+
+function isFrameLine(plain: string): boolean {
+	for (const char of plain) {
+		const codePoint = char.codePointAt(0)
+		if (codePoint !== undefined && codePoint >= BOX_DRAWING_START && codePoint <= BOX_DRAWING_END) {
+			return true
+		}
+	}
+	return false
+}
+
+function wideStartColumns(plain: string): number[] {
+	const columns: number[] = []
+	let column = 0
+	for (const char of plain) {
+		const codePoint = char.codePointAt(0)
+		if (codePoint === undefined) continue
+		const width = charWidth(codePoint)
+		if (width === 2) columns.push(column)
+		column += width
+	}
+	return columns
+}
+
+function summarize(
+	lineCount: number,
+	maxWidth: number,
+	expectedColumns: number,
+	overflowCount: number,
+	borderMisaligned: boolean,
+	containsAnsi: boolean,
+): string {
+	const parts = [`${lineCount} line(s)`, `max width ${maxWidth}/${expectedColumns}`]
+	if (overflowCount > 0) parts.push(`${overflowCount} overflow line(s)`)
+	if (borderMisaligned) parts.push("borders misaligned")
+	if (containsAnsi) parts.push("contains ANSI")
+	return `${parts.join("; ")}.`
+}
+
+export function checkTui(text: string, expectedColumns: number): TuiCheckResult {
+	const lines = splitLines(text)
+	const lineWidths: number[] = []
+	const overflowLines: OverflowLine[] = []
+	const wideColumns = new Set<number>()
+	const frameWidths = new Set<number>()
+
+	for (let index = 0; index < lines.length; index++) {
+		const plain = stripAnsi(lines[index] ?? "")
+		const width = stringWidth(plain)
+		lineWidths.push(width)
+		if (expectedColumns > 0 && width > expectedColumns) {
+			overflowLines.push({ line: index + 1, width })
+		}
+		if (isFrameLine(plain)) frameWidths.add(width)
+		for (const column of wideStartColumns(plain)) {
+			if (wideColumns.size < MAX_WIDE_COLUMNS) wideColumns.add(column)
+		}
+	}
+
+	const maxWidth = lineWidths.reduce((max, width) => (width > max ? width : max), 0)
+	const borderMisaligned = frameWidths.size > 1
+	const containsAnsi = hasAnsi(text)
+	return {
+		command: "tui-check",
+		expectedColumns,
+		lineCount: lines.length,
+		lineWidths,
+		maxWidth,
+		overflowLines,
+		borderMisaligned,
+		wideCharColumns: [...wideColumns].sort((a, b) => a - b),
+		hasAnsi: containsAnsi,
+		summary: summarize(lines.length, maxWidth, expectedColumns, overflowLines.length, borderMisaligned, containsAnsi),
+	}
+}

package/packages/omo-codex/plugin/skills/visual-qa/scripts/types.ts

@@ -0,0 +1,54 @@
+export interface DecodedImage {
+	readonly width: number
+	readonly height: number
+	readonly rgba: Uint8Array
+	readonly hasAlphaChannel: boolean
+	readonly hasTransparentPixels: boolean
+}
+
+export interface Hotspot {
+	readonly gridX: number
+	readonly gridY: number
+	readonly x: number
+	readonly y: number
+	readonly width: number
+	readonly height: number
+	readonly diffRatio: number
+}
+
+export interface ImageDimensions {
+	readonly width: number
+	readonly height: number
+}
+
+export interface ImageDiffResult {
+	readonly command: "image-diff"
+	readonly dimensionsMatch: boolean
+	readonly reference: ImageDimensions
+	readonly actual: ImageDimensions
+	readonly totalPixels: number
+	readonly diffPixels: number
+	readonly diffRatio: number
+	readonly similarityScore: number
+	readonly alphaChannelIntact: boolean
+	readonly hotspots: readonly Hotspot[]
+	readonly summary: string
+}
+
+export interface OverflowLine {
+	readonly line: number
+	readonly width: number
+}
+
+export interface TuiCheckResult {
+	readonly command: "tui-check"
+	readonly expectedColumns: number
+	readonly lineCount: number
+	readonly lineWidths: readonly number[]
+	readonly maxWidth: number
+	readonly overflowLines: readonly OverflowLine[]
+	readonly borderMisaligned: boolean
+	readonly wideCharColumns: readonly number[]
+	readonly hasAnsi: boolean
+	readonly summary: string
+}

package/packages/omo-codex/plugin/test/aggregate-agents.test.mjs

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { root } from "./aggregate-plugin-fixture.mjs";
+
+test("#given bundled Codex agents #when components/ultrawork/agents directory is scanned #then planner support TOMLs are present and match expected schema keys", async () => {
+	const agentsDir = join(root, "components", "ultrawork", "agents");
+	const entries = (await readdir(agentsDir, { withFileTypes: true }))
+		.filter((entry) => entry.isFile() && entry.name.endsWith(".toml"))
+		.map((entry) => entry.name)
+		.sort();
+
+	assert.deepEqual(entries, [
+		"codex-ultrawork-reviewer.toml",
+		"explorer.toml",
+		"librarian.toml",
+		"metis.toml",
+		"momus.toml",
+		"plan.toml",
+	]);
+
+	for (const fileName of entries) {
+		const content = await readFile(join(agentsDir, fileName), "utf8");
+		assert.match(content, /^name\s*=\s*".+"$/m);
+		assert.match(content, /^description\s*=\s*".+"$/m);
+		assert.match(content, /^nickname_candidates\s*=\s*\[.+\]$/m);
+		assert.match(content, /^model\s*=\s*".+"$/m);
+		assert.match(content, /^model_reasoning_effort\s*=\s*".+"$/m);
+		assert.match(content, /^developer_instructions\s*=\s*"""/m);
+	}
+});
+
+test("#given planner agent prompt #when inspected #then generated artifacts stay under .omo", async () => {
+	const prompt = await readFile(join(root, "components", "ultrawork", "agents", "plan.toml"), "utf8");
+
+	assert.match(prompt, /\.omo\/plans\/<slug>\.md/);
+	assert.match(prompt, /\.omo\/evidence\/task-<N>-<slug>\.<ext>/);
+	assert.doesNotMatch(prompt, /(?<!\.omo\/)plans\/<slug>\.md/);
+	assert.doesNotMatch(prompt, /(?<!\.omo\/)evidence\/task-/);
+});
+
+test("#given reviewer agent prompt #when inspected #then default model uses bounded reasoning", async () => {
+	const prompt = await readFile(
+		join(root, "components", "ultrawork", "agents", "codex-ultrawork-reviewer.toml"),
+		"utf8",
+	);
+
+	assert.match(prompt, /^model\s*=\s*"gpt-5\.5"$/m);
+	assert.match(prompt, /^model_reasoning_effort\s*=\s*"high"$/m);
+	assert.doesNotMatch(prompt, /^model_reasoning_effort\s*=\s*"xhigh"$/m);
+	assert.doesNotMatch(prompt, /^model\s*=\s*"gpt-5\.2"$/m);
+	assert.match(prompt, /ChatGPT account/);
+});

package/packages/omo-codex/plugin/test/aggregate-build.test.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import { readJson, root } from "./aggregate-plugin-fixture.mjs";
+
+test("#given aggregate plugin build script #when inspected #then hook status and telemetry sync run before workspace builds", async () => {
+	// given
+	const packageText = await readFile(join(root, "package.json"), "utf8");
+	const packageJson = await readJson("package.json");
+	const telemetrySyncScript = await readFile(join(root, "..", "scripts", "sync-telemetry-component.mjs"), "utf8");
+
+	// when
+	const buildScript = packageJson.scripts.build;
+	const testScript = packageJson.scripts.test;
+
+	// then
+	assert.equal(
+		buildScript,
+		"node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
+	);
+	assert.equal(testScript, "node --test test/*.test.mjs");
+	assert(packageJson.workspaces.includes("components/ultrawork"));
+	assert.match(telemetrySyncScript, /syncTelemetryComponent/);
+	assert.doesNotMatch(packageText, /\bpython3?\b|ultrawork-detector\.py/);
+});
+
+test("#given omo-codex package build script #when inspected #then delegates to the aggregate plugin package", async () => {
+	// given
+	const packageJson = JSON.parse(await readFile(join(root, "..", "package.json"), "utf8"));
+
+	// when
+	const buildPluginScript = packageJson.scripts["build:plugin"];
+
+	// then
+	assert.equal(buildPluginScript, "bun run --cwd plugin build");
+});

package/packages/omo-codex/plugin/test/aggregate-hooks.test.mjs

@@ -0,0 +1,164 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+	collectCommandHooks,
+	exists,
+	hookLocation,
+	readComponentHookManifests,
+	readJson,
+	readPluginVersion,
+	root,
+} from "./aggregate-plugin-fixture.mjs";
+
+test("#given isolated components #when hooks are inspected #then commands stay inside component roots", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const text = JSON.stringify(hooks);
+
+	// when
+	const componentMarkers = [
+		"components/comment-checker/dist/cli.js",
+		"components/lsp/dist/cli.js",
+		"components/rules/dist/cli.js",
+		"components/start-work-continuation/dist/cli.js",
+		"components/telemetry/dist/cli.js",
+		"components/ulw-loop/dist/cli.js",
+		"components/ultrawork/dist/cli.js",
+		"scripts/auto-update.mjs",
+	];
+
+	// then
+	for (const marker of componentMarkers) {
+		assert.match(text, new RegExp(marker.replaceAll("/", "\\/")));
+	}
+	assert.doesNotMatch(text, /codex-(comment-checker|lsp|rules|telemetry|ulw-loop|ultrawork)@/);
+	assert.equal(await exists("scripts/migrate-codex-config.mjs"), true);
+});
+
+test("#given aggregate PostCompact hooks #when hooks are inspected #then LSP diagnostics cache reset is registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const aggregateVersion = await readPluginVersion();
+
+	// when
+	const lspPostCompactHooks = collectCommandHooks(hooks, "hooks/hooks.json").filter(
+		(hook) =>
+			hook.eventName === "PostCompact" &&
+			hook.handler.command === 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-compact',
+	);
+
+	// then
+	assert.equal(lspPostCompactHooks.length, 1);
+	assert.equal(lspPostCompactHooks[0]?.handler.statusMessage, `LazyCodex(${aggregateVersion}): Resetting LSP Diagnostics Cache`);
+});
+
+test("#given aggregate hook commands #when inspected #then every command exposes a Codex status message", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+
+	// when
+	const commandHooks = collectCommandHooks(hooks, "hooks/hooks.json");
+	const missingStatusMessages = commandHooks
+		.filter(({ handler }) => typeof handler.statusMessage !== "string" || handler.statusMessage.trim() === "")
+		.map(hookLocation);
+
+	// then
+	assert.deepEqual(missingStatusMessages, []);
+});
+
+test("#given aggregate hook commands #when inspected #then commands stay Node-based and platform-neutral", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+
+	// when
+	const commands = collectCommandHooks(hooks, "hooks/hooks.json").map(({ handler }) => handler.command);
+
+	// then
+	assert(!commands.some((command) => /\bpython3?\b/i.test(command)));
+	assert(commands.includes('node "${PLUGIN_ROOT}/components/ultrawork/dist/cli.js" hook user-prompt-submit'));
+	assert(commands.every((command) => command.startsWith("node ")));
+	assert(commands.every((command) => !command.includes("\\")));
+});
+
+test("#given component hook commands #when inspected #then standalone packages expose Codex status messages", async () => {
+	// given
+	const componentHooks = await readComponentHookManifests();
+
+	// when
+	const missingStatusMessages = componentHooks
+		.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source))
+		.filter(({ handler }) => typeof handler.statusMessage !== "string" || handler.statusMessage.trim() === "")
+		.map(hookLocation);
+
+	// then
+	assert.deepEqual(missingStatusMessages, []);
+});
+
+test("#given hook status messages #when inspected #then labels describe OMO responsibilities instead of the hook runner", async () => {
+	// given
+	const aggregateHooks = await readJson("hooks/hooks.json");
+	const componentHooks = await readComponentHookManifests();
+
+	// when
+	const commandHooks = [
+		...collectCommandHooks(aggregateHooks, "hooks/hooks.json"),
+		...componentHooks.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source)),
+	];
+	const genericStatusMessages = commandHooks
+		.filter(({ handler }) => typeof handler.statusMessage !== "string" || /\bhook\b/i.test(handler.statusMessage))
+		.map(hookLocation);
+
+	// then
+	assert.deepEqual(genericStatusMessages, []);
+});
+
+test("#given aggregate OMO plugin is enabled #when hooks are inspected #then shell guidance and ulw-loop guard are registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const text = JSON.stringify(hooks);
+
+	// when
+	const preToolUseGroups = hooks.hooks.PreToolUse;
+
+	// then
+	assert.match(text, /components\/git-bash\/dist\/cli\.js/);
+	assert.match(text, /Recommending Git Bash Mcp/);
+	assert.match(text, /hook post-compact/);
+	assert.match(text, /Resetting Git Bash Mcp Reminder/);
+	assert.match(text, /components\/ulw-loop\/dist\/cli\.js/);
+	assert.match(text, /hook pre-tool-use/);
+	assert.deepEqual(preToolUseGroups.map((group) => group.matcher), ["^Bash$", "^create_goal$"]);
+});
+
+test("#given aggregate SessionStart hooks #when inspected #then LazyCodex auto-update is registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const text = JSON.stringify(hooks);
+
+	// when
+	const sessionStartCommands = collectCommandHooks(hooks, "hooks/hooks.json")
+		.filter(({ eventName }) => eventName === "SessionStart")
+		.map(({ handler }) => handler.command);
+	const autoUpdateGroup = hooks.hooks.SessionStart.find((group) => JSON.stringify(group).includes("scripts/auto-update.mjs"));
+
+	// then
+	assert.equal(autoUpdateGroup?.matcher, "^startup$");
+	assert.match(text, /scripts\/auto-update\.mjs/);
+	assert.match(text, /Checking Auto Update/);
+	assert(sessionStartCommands.some((command) => command.includes("scripts/auto-update.mjs")));
+});
+
+test("#given aggregate plugin packaging #when inspected #then hooks and compatibility sentinels stay Python-free", async () => {
+	// given
+	const hooksText = await readFile(join(root, "hooks/hooks.json"), "utf8");
+	const aggregateTestText = await readFile(join(root, "test/aggregate.test.mjs"), "utf8");
+
+	// when
+	const aggregateText = `${hooksText}\n${aggregateTestText}`;
+
+	// then
+	assert.doesNotMatch(aggregateText, /\bpython3?\b|ultrawork-detector\.py/);
+});