oh-my-opencode 5.1.51 → 5.1.55

package/dist/skills/frontend/scripts/detect/snapshot/collect.ts

@@ -0,0 +1,158 @@
+import type { ElementSnapshot, PageSnapshot, PseudoSnapshot, Rect } from "../types"
+
+// Runs inside the page: the renderer serializes this function with toString() and evaluates it there,
+// so it must stay self-contained (no imports at runtime, no references to module scope).
+export function collectPageSnapshot(props: readonly string[], maxElements: number): PageSnapshot {
+	const collapse = (s: string): string => s.replace(/\s+/g, " ").trim()
+	const toRect = (r: DOMRect): Rect => ({
+		x: Math.round(r.x * 100) / 100,
+		y: Math.round(r.y * 100) / 100,
+		width: Math.round(r.width * 100) / 100,
+		height: Math.round(r.height * 100) / 100,
+	})
+	const readStyle = (style: CSSStyleDeclaration): Record<string, string> => {
+		const out: Record<string, string> = {}
+		for (const p of props) out[p] = style.getPropertyValue(p)
+		return out
+	}
+	const pseudo = (el: Element, which: "::before" | "::after"): PseudoSnapshot | null => {
+		const style = getComputedStyle(el, which)
+		const content = style.getPropertyValue("content")
+		if (content === "none" || content === "normal" || content === "") return null
+		return { style: readStyle(style), rect: null }
+	}
+	const cssEscape = (s: string): string => (typeof CSS !== "undefined" && CSS.escape ? CSS.escape(s) : s)
+	const selectorOf = (el: Element): string => {
+		const parts: string[] = []
+		let node: Element | null = el
+		while (node && node.nodeType === 1 && parts.length < 6) {
+			if (node.id) {
+				parts.unshift(`#${cssEscape(node.id)}`)
+				break
+			}
+			const tag = node.tagName.toLowerCase()
+			const parentEl: Element | null = node.parentElement
+			if (!parentEl) {
+				parts.unshift(tag)
+				break
+			}
+			const current: Element = node
+			const same = Array.from(parentEl.children).filter((c) => c.tagName === current.tagName)
+			parts.unshift(same.length > 1 ? `${tag}:nth-of-type(${same.indexOf(current) + 1})` : tag)
+			node = parentEl
+		}
+		return parts.join(" > ")
+	}
+	const lineRectsOf = (el: Element): Rect[] => {
+		const rects: Rect[] = []
+		for (const child of Array.from(el.childNodes)) {
+			if (child.nodeType !== 3 || !child.textContent || child.textContent.trim() === "") continue
+			const range = document.createRange()
+			range.selectNodeContents(child)
+			for (const r of Array.from(range.getClientRects())) {
+				if (r.width === 0 && r.height === 0) continue
+				const last = rects[rects.length - 1]
+				if (last && Math.abs(last.y - r.y) < 2) {
+					const right = Math.max(last.x + last.width, r.x + r.width)
+					const x = Math.min(last.x, r.x)
+					rects[rects.length - 1] = { x, y: last.y, width: right - x, height: Math.max(last.height, r.height) }
+				} else rects.push(toRect(r))
+			}
+		}
+		return rects
+	}
+	const kebab = (p: string): string => (p === "cssOffset" ? "offset" : p.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`))
+	const motionOf = (el: Element): string[] => {
+		const moving = new Set<string>()
+		for (const anim of el.getAnimations()) {
+			if (anim.playState !== "running") continue
+			if (typeof CSSTransition !== "undefined" && anim instanceof CSSTransition) moving.add(anim.transitionProperty)
+			const effect = anim.effect
+			if (!(effect instanceof KeyframeEffect)) continue
+			for (const frame of effect.getKeyframes()) {
+				for (const key of Object.keys(frame)) if (!["offset", "computedOffset", "easing", "composite"].includes(key)) moving.add(kebab(key))
+			}
+		}
+		return [...moving].sort()
+	}
+	const all = Array.from(document.querySelectorAll("body, body *"))
+		.filter((el) => !["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE", "HEAD", "META", "LINK"].includes(el.tagName))
+		.slice(0, maxElements)
+	const indexOf = new Map<Element, number>()
+	all.forEach((el, i) => indexOf.set(el, i))
+	const elements: ElementSnapshot[] = all.map((el, index) => {
+		const attributes: Record<string, string> = {}
+		for (const a of Array.from(el.attributes)) attributes[a.name] = a.value.slice(0, 500)
+		const parentIndex = el.parentElement ? indexOf.get(el.parentElement) : undefined
+		const ownText = collapse(
+			Array.from(el.childNodes)
+				.filter((n) => n.nodeType === 3)
+				.map((n) => n.textContent ?? "")
+				.join(" "),
+		)
+		return {
+			index,
+			parent: parentIndex === undefined ? null : parentIndex,
+			children: Array.from(el.children)
+				.map((c) => indexOf.get(c))
+				.filter((i): i is number => i !== undefined),
+			tag: el.tagName.toLowerCase(),
+			selector: selectorOf(el),
+			attributes,
+			rect: toRect(el.getBoundingClientRect()),
+			ownText,
+			textRuns: Array.from(el.childNodes)
+				.filter((n) => n.nodeType === 3)
+				.map((n) => collapse(n.textContent ?? ""))
+				.filter((t) => t !== ""),
+			text: collapse(el.textContent ?? "").slice(0, 2000),
+			lineRects: ownText === "" ? [] : lineRectsOf(el),
+			style: readStyle(getComputedStyle(el)),
+			before: pseudo(el, "::before"),
+			after: pseudo(el, "::after"),
+			scroll: { scrollWidth: el.scrollWidth, clientWidth: el.clientWidth, scrollHeight: el.scrollHeight, clientHeight: el.clientHeight },
+			motion: motionOf(el),
+			placeholder: el.matches(":placeholder-shown") ? { style: readStyle(getComputedStyle(el, "::placeholder")), rect: null } : null,
+			modal: (() => {
+				try {
+					return el.matches(":modal")
+				} catch (error) {
+					if (error instanceof DOMException) return false
+					throw error
+				}
+			})(),
+		}
+	})
+	const cssText: string[] = []
+	for (const sheet of Array.from(document.styleSheets)) {
+		const rules = (() => {
+			try {
+				return Array.from(sheet.cssRules)
+			} catch (error) {
+				if (error instanceof DOMException) return []
+				throw error
+			}
+		})()
+		cssText.push(rules.map((r) => r.cssText).join("\n"))
+	}
+	const root = document.documentElement
+	const errors: unknown = Reflect.get(globalThis, "__detectScriptErrors")
+	return {
+		viewport: { width: window.innerWidth, height: window.innerHeight },
+		url: location.href,
+		title: document.title,
+		lang: root.lang,
+		document: { scrollWidth: root.scrollWidth, clientWidth: root.clientWidth, scrollHeight: root.scrollHeight },
+		elements,
+		cssText,
+		scriptErrors: Array.isArray(errors) ? errors.filter((e): e is string => typeof e === "string") : [],
+		scriptErrorsCaptured: Array.isArray(errors),
+	}
+}
+
+/** Installed before page scripts run, so errors thrown during load reach the snapshot's scriptErrors. */
+export const SCRIPT_ERROR_PROBE = `(() => {
+	const sink = (globalThis.__detectScriptErrors = []);
+	addEventListener("error", (e) => sink.push(String(e.message || e.error || "error")));
+	addEventListener("unhandledrejection", (e) => sink.push(String(e.reason && e.reason.message || e.reason)));
+})();`

package/dist/skills/frontend/scripts/detect/snapshot/style-props.ts

@@ -0,0 +1,25 @@
+export const STYLE_PROPS = [
+	"display", "position", "visibility", "opacity", "z-index", "overflow-x", "overflow-y", "transform", "contain",
+	"top", "left", "right", "bottom", "width", "height", "max-width", "min-width", "max-height",
+	"color", "background-color", "background-image", "background-clip", "-webkit-background-clip", "-webkit-text-fill-color",
+	"background-size", "background-repeat", "background-position",
+	"font-family", "font-size", "font-weight", "font-style", "line-height", "letter-spacing", "word-spacing",
+	"text-transform", "text-align", "text-align-last", "text-decoration-line", "text-decoration-thickness", "text-underline-offset",
+	"text-overflow", "text-wrap", "white-space", "word-break", "overflow-wrap", "hyphens", "font-variant-numeric", "font-feature-settings",
+	"-webkit-line-clamp", "overflow-clip-margin", "font-variant", "font-variant-caps", "background-blend-mode", "mix-blend-mode", "scale", "rotate", "translate", "will-change",
+	"border-top-width", "border-right-width", "border-bottom-width", "border-left-width",
+	"border-top-style", "border-right-style", "border-bottom-style", "border-left-style",
+	"border-top-color", "border-right-color", "border-bottom-color", "border-left-color",
+	"border-top-left-radius", "border-top-right-radius", "border-bottom-right-radius", "border-bottom-left-radius",
+	"border-image-source", "outline-style", "outline-width", "outline-color", "outline-offset",
+	"box-shadow", "text-shadow", "filter", "backdrop-filter", "-webkit-backdrop-filter", "clip-path", "mask-image", "-webkit-mask-image",
+	"padding-top", "padding-right", "padding-bottom", "padding-left",
+	"margin-top", "margin-right", "margin-bottom", "margin-left",
+	"row-gap", "column-gap", "grid-template-columns", "flex-direction", "flex-wrap", "justify-content", "align-items", "column-count",
+	"animation-name", "animation-duration", "animation-iteration-count", "animation-timing-function", "animation-direction",
+	"animation-delay", "animation-fill-mode", "animation-play-state", "animation-composition",
+	"transition-property", "transition-duration", "transition-timing-function",
+	"object-fit", "caret-color", "content", "list-style-type", "cursor", "pointer-events",
+] as const
+
+export type StyleProp = (typeof STYLE_PROPS)[number]

package/dist/skills/frontend/scripts/detect/testing/build-snapshot.ts

@@ -0,0 +1,78 @@
+import type { ElementSnapshot, PageSnapshot, PseudoSnapshot, Rect, Viewport } from "../types"
+
+// Computed-style defaults a Chromium page reports for an unstyled element; a node spec overrides only what it sets.
+const DEFAULT_STYLE: Readonly<Record<string, string>> = {
+	display: "block", position: "static", visibility: "visible", opacity: "1", "z-index": "auto",
+	"overflow-x": "visible", "overflow-y": "visible", transform: "none",
+	color: "rgb(0, 0, 0)", "background-color": "rgba(0, 0, 0, 0)", "background-image": "none", "background-clip": "border-box",
+	"-webkit-background-clip": "border-box", "-webkit-text-fill-color": "rgb(0, 0, 0)",
+	"font-family": "Georgia, serif", "font-size": "16px", "font-weight": "400", "font-style": "normal", "line-height": "24px",
+	"letter-spacing": "normal", "word-spacing": "0px", "text-transform": "none", "text-align": "start", "text-align-last": "auto",
+	"text-decoration-line": "none", "text-overflow": "clip", "text-wrap": "wrap", "white-space": "normal",
+	"border-top-width": "0px", "border-right-width": "0px", "border-bottom-width": "0px", "border-left-width": "0px",
+	"border-top-style": "none", "border-right-style": "none", "border-bottom-style": "none", "border-left-style": "none",
+	"border-top-color": "rgb(0, 0, 0)", "border-right-color": "rgb(0, 0, 0)", "border-bottom-color": "rgb(0, 0, 0)", "border-left-color": "rgb(0, 0, 0)",
+	"border-top-left-radius": "0px", "border-top-right-radius": "0px", "border-bottom-right-radius": "0px", "border-bottom-left-radius": "0px",
+	"border-image-source": "none", "outline-style": "none", "box-shadow": "none", "text-shadow": "none", filter: "none",
+	"backdrop-filter": "none", "clip-path": "none", "mask-image": "none",
+	"padding-top": "0px", "padding-right": "0px", "padding-bottom": "0px", "padding-left": "0px",
+	"margin-top": "0px", "margin-right": "0px", "margin-bottom": "0px", "margin-left": "0px",
+	"row-gap": "normal", "column-gap": "normal", "animation-name": "none", "animation-duration": "0s",
+	"animation-iteration-count": "1", "animation-timing-function": "ease", "transition-property": "all",
+	"transition-duration": "0s", "transition-timing-function": "ease", "object-fit": "fill", content: "normal",
+}
+
+export type NodeSpec = {
+	readonly tag?: string
+	readonly id?: string
+	readonly attributes?: Readonly<Record<string, string>>
+	readonly style?: Readonly<Record<string, string>>
+	readonly text?: string
+	readonly textRuns?: readonly string[]
+	readonly rect?: Partial<Rect>
+	readonly lineRects?: readonly Rect[]
+	readonly before?: Readonly<Record<string, string>>
+	readonly after?: Readonly<Record<string, string>>
+	readonly scroll?: Partial<ElementSnapshot["scroll"]>
+	readonly motion?: readonly string[]
+	readonly modal?: boolean
+	readonly placeholder?: Readonly<Record<string, string>>
+	readonly children?: readonly NodeSpec[]
+}
+
+const pseudo = (style: Readonly<Record<string, string>> | undefined): PseudoSnapshot | null =>
+	style ? { style: { ...DEFAULT_STYLE, content: '""', ...style }, rect: null } : null
+
+/** Builds a PageSnapshot from a tree of node specs under <body>, filling Chromium's default computed values. */
+export function buildSnapshot(body: readonly NodeSpec[], options: { readonly viewport?: Viewport; readonly cssText?: readonly string[]; readonly scriptErrors?: readonly string[]; readonly scriptErrorsCaptured?: boolean } = {}): PageSnapshot {
+	const viewport = options.viewport ?? { width: 1280, height: 800 }
+	const elements: ElementSnapshot[] = []
+	const add = (spec: NodeSpec, parent: number | null, path: string): number => {
+		const index = elements.length
+		const tag = spec.tag ?? "div"
+		const selector = spec.id ? `#${spec.id}` : `${path} > ${tag}:nth-of-type(${index})`
+		const placeholder: ElementSnapshot = {
+			index, parent, children: [], tag, selector,
+			attributes: { ...(spec.id ? { id: spec.id } : {}), ...spec.attributes },
+			rect: { x: 0, y: 0, width: 200, height: 40, ...spec.rect },
+			ownText: spec.text ?? "", textRuns: spec.textRuns ?? (spec.text ? [spec.text] : []), text: "", lineRects: spec.lineRects ?? (spec.text ? [{ x: 0, y: 0, width: 160, height: 24, ...spec.rect }] : []),
+			style: { ...DEFAULT_STYLE, ...(tag === "span" || tag === "a" ? { display: "inline" } : {}), ...spec.style },
+			before: pseudo(spec.before), after: pseudo(spec.after),
+			scroll: { scrollWidth: 200, clientWidth: 200, scrollHeight: 40, clientHeight: 40, ...spec.scroll },
+			motion: spec.motion ?? [],
+			modal: spec.modal ?? false,
+			placeholder: spec.placeholder ? { style: { ...DEFAULT_STYLE, ...spec.placeholder }, rect: null } : null,
+		}
+		elements.push(placeholder)
+		const children = (spec.children ?? []).map((c) => add(c, index, selector))
+		const text = [spec.text ?? "", ...children.map((i) => elements[i]?.text ?? "")].filter(Boolean).join(" ")
+		elements[index] = { ...placeholder, children, text }
+		return index
+	}
+	add({ tag: "body", rect: { width: viewport.width, height: viewport.height }, children: body }, null, "html")
+	return {
+		viewport, url: "about:blank", title: "", lang: "en",
+		document: { scrollWidth: viewport.width, clientWidth: viewport.width, scrollHeight: viewport.height },
+		elements, cssText: options.cssText ?? [], scriptErrors: options.scriptErrors ?? [], scriptErrorsCaptured: options.scriptErrorsCaptured ?? true,
+	}
+}

package/dist/skills/frontend/scripts/detect/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": ["bun-types"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true
+  },
+  "include": ["./**/*.ts"]
+}

package/dist/skills/frontend/scripts/detect/types.ts

@@ -0,0 +1,124 @@
+// Public types of the frontend detect SDK: rules, findings, snapshots, options.
+// Rule semantics are adapted from Impeccable's detector (Apache-2.0, Copyright 2025 Paul Bakaus); see ATTRIBUTION.md sections 6-7.
+
+export type Severity = "error" | "warning" | "advisory"
+export type RuleCategory = "slop" | "quality"
+export type RuleSetting = Severity | "off"
+
+/** Where a rule reads from: the rendered page, or raw source text with no rendering. */
+export type RuleEngine = "page" | "source"
+
+export type RuleMeta = {
+	readonly id: string
+	readonly name: string
+	readonly category: RuleCategory
+	readonly severity: Severity
+	readonly engine: RuleEngine
+	readonly description: string
+	readonly fixHint: string
+}
+
+export type Rect = { readonly x: number; readonly y: number; readonly width: number; readonly height: number }
+
+export type ElementLocation = {
+	readonly kind: "element"
+	readonly file?: string
+	readonly selector: string
+	readonly rect: Rect
+	readonly viewport: Viewport
+}
+
+export type SourceLocation = {
+	readonly kind: "source"
+	readonly file: string
+	readonly line: number
+	readonly column: number
+}
+
+export type PageLocation = { readonly kind: "page"; readonly file?: string; readonly viewport: Viewport }
+
+export type FindingLocation = ElementLocation | SourceLocation | PageLocation
+
+export type Finding = {
+	readonly ruleId: string
+	readonly name: string
+	readonly category: RuleCategory
+	readonly severity: Severity
+	readonly message: string
+	readonly fixHint: string
+	readonly location: FindingLocation
+	readonly snippet: string
+}
+
+export type Viewport = { readonly width: number; readonly height: number }
+
+/** Computed style values, keyed by CSS property name (kebab-case), as getComputedStyle reports them. */
+export type ComputedStyle = Readonly<Record<string, string>>
+
+export type PseudoSnapshot = { readonly style: ComputedStyle; readonly rect: Rect | null }
+
+export type ElementSnapshot = {
+	readonly index: number
+	readonly parent: number | null
+	readonly children: readonly number[]
+	readonly tag: string
+	readonly selector: string
+	readonly attributes: Readonly<Record<string, string>>
+	readonly rect: Rect
+	/** Text of this element's own direct text nodes, whitespace-collapsed. */
+	readonly ownText: string
+	/** Each non-empty direct text node of this element, trimmed and whitespace-collapsed, in document order. */
+	readonly textRuns: readonly string[]
+	/** Full text content, whitespace-collapsed, capped at 2000 characters. */
+	readonly text: string
+	/** Rendered line boxes of the element's own text nodes, top-down. */
+	readonly lineRects: readonly Rect[]
+	readonly style: ComputedStyle
+	readonly before: PseudoSnapshot | null
+	readonly after: PseudoSnapshot | null
+	readonly scroll: { readonly scrollWidth: number; readonly clientWidth: number; readonly scrollHeight: number; readonly clientHeight: number }
+	/** CSS properties a running animation or transition on this element is moving at capture time (kebab-case, deduplicated). */
+	readonly motion: readonly string[]
+	/** True when the element is in the top layer as a modal (matches `:modal`: a modal dialog or a fullscreen element). */
+	readonly modal: boolean
+	/** Computed `::placeholder` style of an input or textarea while it shows its placeholder (`:placeholder-shown`); null otherwise. */
+	readonly placeholder: PseudoSnapshot | null
+}
+
+export type PageSnapshot = {
+	readonly viewport: Viewport
+	readonly url: string
+	readonly title: string
+	readonly lang: string
+	readonly document: { readonly scrollWidth: number; readonly clientWidth: number; readonly scrollHeight: number }
+	readonly elements: readonly ElementSnapshot[]
+	/** Text of every same-origin stylesheet, in document order (for @keyframes, @font-face, raw declarations). */
+	readonly cssText: readonly string[]
+	/** Errors thrown by page scripts while the snapshot was taken. */
+	readonly scriptErrors: readonly string[]
+	/** False when the renderer could not install the error probe before page scripts (WebKit on an http(s) URL), so scriptErrors is not evidence of a clean load. */
+	readonly scriptErrorsCaptured: boolean
+}
+
+export type SourceFile = { readonly path: string; readonly text: string }
+
+export type DetectConfig = {
+	/** Per-rule override: a severity, or "off". */
+	readonly rules?: Readonly<Record<string, RuleSetting>>
+	/** Typefaces the project chose on purpose; never reported as overused. Case-insensitive family names. */
+	readonly allowFonts?: readonly string[]
+	/** Timing functions the project's design tokens name on purpose (for example an intentional spring). */
+	readonly allowEasings?: readonly string[]
+	/** The project's design-system tokens; the design-system-* rules report values outside them and stay silent without them. */
+	readonly designTokens?: DesignTokens
+}
+
+export type DesignTokens = {
+	readonly fonts?: readonly string[]
+	/** CSS colors (any form parseColor accepts). */
+	readonly colors?: readonly string[]
+	/** Border radii in px. */
+	readonly radii?: readonly number[]
+	/** Font sizes in px. */
+	readonly fontSizes?: readonly number[]
+}

package/dist/skills/programming/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: programming
-description: "Applies strict, modern language practice (typed errors, exhaustive match, tests that can fail) for Python, Rust, TypeScript, JavaScript, and Go. Use for work on .py, .rs, .ts, .js, or .go files."
+description: "Applies strict, modern language practice (typed errors, exhaustive match, tests that can fail) for Python, Rust, TypeScript, JavaScript, and Go. Use for work on .py, .rs, .ts, .js, or .go files, and whenever a test or spec file is written, reshaped, reviewed, or deleted: the four-question test authoring gate and the junk-test classes live here."
 ---
 
 # Programming
@@ -24,6 +24,7 @@ This skill is an index. The hard per-language rules live under `references/`. Lo
    | `.rs`, `Cargo.toml`, "Rust" | `references/rust/README.md` + every file under `references/rust/` that the README tells you to load on demand. **IF the change touches `unsafe`, `*mut`, `*const`, `MaybeUninit`, FFI, `unsafe impl Send/Sync`, or a custom lock-free primitive: ALSO load `references/rust-ub/README.md` plus every file under `references/rust-ub/`.** |
    | `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`, "TypeScript" / "JavaScript" | `references/typescript/README.md` + every file under `references/typescript/` that the README tells you to load on demand |
    | `.go`, `go.mod`, `go.sum`, `.golangci.yml`, `*.proto` next to a Go module, "Go" / "Golang" | `references/go/README.md` + every file under `references/go/` that the README tells you to load on demand |
+   | any test file (`*.test.*`, `*.spec.*`, `*_test.go`, `test_*.py`, `*_test.py`, under `test/`, `tests/` or `__tests__/`), or a change that adds, reshapes, or deletes a test | the language row above PLUS `references/testing/README.md` (the authoring gate) and `references/testing/junk-classes.md` (the table the gate reviewer applies) |
 
 3. Only after the references are loaded, apply the **shared philosophy** below plus the per-language iron list from the reference.
 
@@ -31,7 +32,7 @@ This skill is an index. The hard per-language rules live under `references/`. Lo
 
 ---
 
-## Shared philosophy (all three languages)
+## Shared philosophy (all four languages)
 
 These are not style preferences. They are the seven axioms every recipe in `references/` derives from.
 
@@ -47,82 +48,22 @@ These are not style preferences. They are the seven axioms every recipe in `refe
 
 5. **Trust framework guarantees. Validate only at boundaries.** No null checks for values the type system already proves non-null. No `try/except` around code that cannot raise. No `unwrap`/`!`/`as` to paper over a contract you should have encoded in types. No defensive layer for a scenario you cannot name.
 
-6. **Tests are the behavior of record, and only tests that can fail count.** READ the tests covering the area BEFORE you change it: do they encode the intent, cover this path, pass? One wrong before your change is a FINDING — never edit it green. Reproduce a bug before fixing it. The run proves the change; add a test ONLY where the repository keeps tests for this behavior AND a regression would otherwise pass unnoticed — sized like its neighbors, never restating the change. See the test discipline below.
+6. **Tests are the behavior of record, and only tests that can fail count.** READ the tests covering the area BEFORE you change it: do they encode the intent, cover this path, pass? One wrong before your change is a FINDING — never edit it green. Reproduce a bug before fixing it. The run proves the change; add a test ONLY where the repository keeps tests for this behavior AND a regression would otherwise pass unnoticed — sized like its neighbors, never restating the change. The authoring gate and the junk-class table are in `references/testing/`.
 
 ---
 
 ## TEST DISCIPLINE
 
-### The shape of the test pyramid
+Tests are code: the language gate above applies to them, plus [`references/testing/README.md`](references/testing/README.md) (the contract every language's recipes assume) and [`references/testing/junk-classes.md`](references/testing/junk-classes.md) (the table the gate reviewer applies to every test in a diff). Read both before adding, reshaping, or deleting a test.
 
-Where the repository keeps these rungs, test at the cheapest rung that observes the behavior:
+**The authoring gate.** Before a test exists, answer all four; a missing answer means do not add it yet.
 
-| Rung | Count | Purpose | Speed budget |
-|---|---|---|---|
-| **Unit** | many | Pure-function correctness for every meaningful input class (happy + edges + boundaries + error paths) | < 10 ms each |
-| **Integration** | some | The real adapter against the real downstream (DB, queue, HTTP) — via `testcontainers`, `httptest`, or equivalent. NEVER a unit test pretending to be integration. | < 1 s each |
-| **E2E scenario** | few | One narrative per user-visible outcome. Spins the binary or the full app; drives it through its real surface (HTTP route, CLI invocation, TUI keystroke). Asserts the *observable outcome*, not internal state. | seconds, run on CI |
+1. What observable behavior, invariant, or independent contract does it protect?
+2. What credible regression makes it fail?
+3. Why does existing coverage not already catch that failure? One primary owner per contract, at the strongest boundary; extend a table row before adding a near-duplicate, a copy in another package, or a replay through a wrapper.
+4. Does it need a production seam (export, flag, getter, wrapper, injection hook) no production caller needs? Then test at the real boundary instead.
 
-A user-visible outcome you never drove through its real surface is unverified — a green unit suite does not stand in for that run.
-
-### Given / When / Then is mandatory
-
-Every test — unit, integration, E2E — is structured by these three blocks. Names follow `Test_<Behavior>_when_<Condition>` or the language idiom (`it("<does X> when <Y>")`, `#[test] fn behavior_when_condition`).
-
-```
-Given: the preconditions and fixtures
-When:  the single action under test
-Then:  the observable outcome AND only that outcome
-```
-
-One `When` per test. Multiple `When`s = multiple tests. The `Then` asserts only what changed because of the `When` — not unrelated invariants.
-
-### Less mock, the better
-
-Mocks are a last resort, not a default. The priority order:
-
-1. **Real object.** Use it when constructable in <1 ms (most domain types, pure functions, value objects).
-2. **In-memory fake.** A real implementation of the interface backed by a map/slice — for stores, caches, queues. The fake has its OWN test that proves it behaves like the real one.
-3. **Testcontainer / sandbox.** Real Postgres, real Redis, real S3-compatible (MinIO), via `testcontainers`. Slow but truthful.
-4. **HTTP-level fake.** `httptest.Server` (Go), `respx` (Python), `msw` (TS) — fake at the wire, not at the SDK.
-5. **Mock.** Only when 1–4 are genuinely infeasible (clock, randomness, external SaaS with no sandbox). Then mock the **narrowest** seam — never an entire service. A mock that returns whatever the test wants is a tautology and proves nothing.
-
-**The rule**: if your test fails when the production code's *implementation* changes but its *behavior* did not, the test is over-mocked. Delete the mock; assert on observable outputs.
-
-### Efficient AND accurate — both, not either
-
-- **Accurate**: the test fails for the bug it names, and only that bug. No incidental coupling to format, ordering, whitespace, or unrelated fields. Assert on the *contract*, not on the dump.
-- **Efficient**: the whole unit suite runs in < 30 seconds on a developer laptop. The whole integration suite in < 5 minutes. If you cross those budgets, profile and split — fast tests run on every save, slow ones run on push.
-- **Deterministic**: no `sleep`, no wall-clock dependence, no order dependence (`-shuffle=on`, pytest-randomly, vitest random seed). Inject a `Clock`. Subscribe to the event, do not poll for it. Time-based flake is a bug, not a test issue.
-- **Isolated**: every test starts from a known fixture and tears down. `t.TempDir()`, `t.Setenv()`, transactional rollback for DB tests. Two tests passing individually but failing together is a fixture leak — fix it immediately. Isolation extends **across processes**: suite-global resources — sandbox/cache roots under a fixed tmpdir path, hardcoded listen ports, container names — are namespaced per run (`mktemp`, port `0`/ephemeral, unique names) so that two checkouts or worktrees of the repo running the suite concurrently cannot interfere. A fixed shared path that works on a single-checkout machine is a flake generator on a multi-agent workstation, and its signature is "a different test fails each run".
-
-### Prompt tests: NEVER assert prose
-
-**FORBIDDEN — NO EXCEPTIONS: a test MUST NOT assert natural-language prompt text.** `expect(prompt).toContain("based on GPT-5.6")`, `not.toContain("old wording")`, `toMatchSnapshot()` on prose, grepping a sentence fragment — every one of these is pretend-coverage. It stays green while the behavior it claims to guard breaks, then blocks every legitimate rewording until someone bumps the pinned string. A reviewer MUST block it as HIGH; deleting such a test is a fix, not a coverage loss. "A nearby test already does it" is not a defense — that test is the disease, not the convention.
-
-Assert ONLY what a machine consumes:
-
-- the builder's routing decision — `expect(getPromptSource(model)).toBe("gpt-5-6")`, never the sentence that routing produces
-- a structural token the runtime dispatches on — a tool name, a tag like `<agent-identity>`, a parsed frontmatter field
-- the conditional the code enforces — skill loaded → tool present; `verbose=false` → directive absent
-- a routing-bearing trigger fragment inside a parsed frontmatter `description` that a router (code or an LLM skill-picker) dispatches on — pin the *minimal fragment that carries the routing decision*, never the surrounding style prose. Such pins are what let a later rewrite change every sentence around them while proving the routing contract survived.
-
-If no machine consumes the text, there is no seam: write NO test and say so in the PR; review guards prose. When you DELEGATE test-writing, hand the child the behavior the test must distinguish ("fails if override precedence breaks"), never a ready-made assertion string, prompt fragment, or marker to copy — a prescribed mechanism that is wrong gets implemented faithfully, and the error ships with a green suite.
-
-### Anti-patterns the skill rejects
-
-| Anti-pattern | Why it fails | Fix |
-|---|---|---|
-| A test that restates the change (pins a constant, a string, a rename, a call) | Cannot fail for any regression; certifies the diff, not the behavior. | The run is the proof. Delete the test. |
-| One mega-test asserting 12 things | First failure hides the next 11. | Split by `Then` clause — one assertion class per test. |
-| Mocking every collaborator | Test passes regardless of real behavior. | Use a fake or the real thing. Mock only true unmockables. |
-| `time.sleep(0.1)` to "let it finish" | Flake guaranteed. | Subscribe to the completion signal; bounded await. |
-| Snapshot tests for everything | Locks formatting, not behavior. | Snapshots for *structure* (CLI help, JSON shape). Assertions for *behavior*. |
-| Removing a failing test to "unblock CI" | You just deleted a bug report. | Fix the code or fix the test — never delete to silence. |
-| `assert result is not None` and stopping there | Passes when result is garbage. | Assert the *value*, not its existence. |
-| Expected value derived from the output under test (`expect(config.prompt).toBe(getPrompt(config.model))` when the criterion is about `config.prompt`) | Recomputes a projection of the output and compares it to itself — passes even when the artifact is built from the wrong input. | Derive the expected value from the test's *input*: `expect(config.prompt).toBe(getPrompt(inputModel))` (independent known-good builder fed the fixture's input), or a stable builder routing decision. |
-| Override/precedence fixture equal to its fallback (override == system default) | The assertion passes whether or not the code honored the override — precedence is never exercised. | Make every value the code must select, preserve, or override differ from its fallback. Prove it: temporarily force the regression the test names, watch it fail, revert. |
-| Single happy-path E2E, no edges | Most bugs live on edges. | Edges are unit-test territory — but include at least one E2E that exercises an error path. |
+The README owns the shape (Given / When / Then, the pyramid, the mock ladder, determinism, isolation, the prompt-test rule) and the "test your test" step: break the production owner, watch the test go red for the intended reason, restore byte for byte. A test that fails on the unchanged base is a bug to fix at its owner; one your own change turns red is fixed at the code or at the test; neither is deleted or edited green to unblock a run.
 
 ---
 
@@ -180,7 +121,7 @@ A bare default constructor for any of these (no timeouts, no pool tuning, no sch
 | Test runner | **pytest** | **cargo-nextest** | `bun test` / `vitest` | stdlib `go test -race -shuffle=on -count=1` + `goleak` |
 | UB / soundness gate | (n/a) | **nightly miri** with strict provenance + Tree Borrows pass | (n/a) | **`nilaway`** + `-race` detector + `goleak` are the equivalent gate |
 | Disposable scripts | **PEP 723** inline metadata + `uv run script.py` | **rust-script** with inline `Cargo.toml` block | `bun run script.ts` | `//go:build ignore` + `go run script.go` |
-| Bootstrap a new project | `scripts/python/new-project.py` | `scripts/rust/new-project.py` | `scripts/typescript/new-project.ts` | `scripts/go/new-project.py` |
+| Bootstrap a new project | `bun run scripts/python/new-project.ts` | `bun run scripts/rust/new-project.ts` | `bun run scripts/typescript/new-project.ts` | `bun run scripts/go/new-project.ts` |
 | Pre-commit / CI gate | `ruff check . && basedpyright && pytest` | `cargo clippy --all-targets -- -D warnings && cargo nextest run && cargo test --doc && cargo +nightly miri nextest run` | `bunx oxlint --type-aware --deny-warnings && bunx oxfmt --check && bunx tsc --noEmit && bun test` | `gofumpt -l . && golangci-lint run ./... && nilaway ./... && go test -race -shuffle=on -count=1 ./...` |
 
 For TS/JS, **use oxlint + oxfmt with these two rules by default**: `no-em-dash-copy` and `require-suppression-reason`. Strongly prefer this OXC toolchain for new projects; retain ESLint, Prettier, or Biome only when the repository already uses them. Load [`references/typescript/oxc-lint.md`](references/typescript/oxc-lint.md) for the complete configs, plugin, and type-aware support requirements. Rewrite paired em dashes as asides using parentheses or commas, not colon chains.
@@ -258,6 +199,8 @@ uv run scripts/python/check-no-excuse-rules.py <changed paths>
 bash scripts/rust/check-no-excuse-rules.sh <changed paths>
 # TypeScript
 bun run scripts/typescript/check-no-excuse-rules.ts <changed paths>
+# Any language, test files you touched: the junk classes a regex can see (candidates for "test your test")
+bun run scripts/typescript/check-test-junk.ts <changed test paths>
 ```
 
 ### Step 2 — interpret
@@ -278,7 +221,7 @@ After every code-writing session, answer these out loud (in your reply) before d
 4. **Escape hatches?** Any `Any`, `# type: ignore`, `unwrap`, `expect` outside tests, `as` numeric cast, `!`, `@ts-ignore`, `@ts-expect-error`, a Rust `#[allow]` instead of `#[expect(lint, reason)]`? If yes, fix the type or document why with a comment.
 5. **Defensive layer?** Any null check, try/except, or `isinstance` guarding a value the type system already proves? If yes, delete.
 6. **Helpers for one-off?** Any function, class, or trait introduced for a single caller that will never get a second caller? If yes, inline — axiom 0 should have caught it pre-write; this is the backstop.
-7. **Tests?** Is the behavior I just introduced locked by a test that would fail if I revert this commit?
+7. **Tests?** Does every test I added or reshaped answer the four-question authoring gate (`references/testing/README.md`), go red when I break its production owner, and match no row of `references/testing/junk-classes.md`? Where the repository keeps tests for a behavior I introduced and a regression would otherwise pass unnoticed, is it covered at its owner, not by a copy or a change certificate?
 8. **Parameter bloat?** Any function I wrote or modified that takes more than 3 parameters — or smuggles them through a dict/kwargs/`...args`/throwaway options object? If yes, group related params into a typed value object. See [Smell 2](references/code-smells.md#smell-2--function-with-more-than-3-parameters).
 9. **Redundant verification?** Did I perform a destructive action (delete, remove, clear) and then immediately re-query to "confirm" it worked? Did I call a setter then a getter to "verify"? If yes, delete the verification — the operation's contract IS the proof. See [Smell 3](references/code-smells.md#smell-3--redundant-verification-after-a-destructive-action).
 10. **Negative naming?** Any variable, function, or flag named by the absence of a quality (`isNotValid`, `noErrors`, `DisableX`) when a positive name (`isValid`, `isClean`, `EnableX`) would work? If yes, rename to positive form and invert the branch. See [Smell 4](references/code-smells.md#smell-4--negative-form-names-and-conditions).
@@ -300,7 +243,7 @@ These two skills are not optional cosmetics. They are the recovery path for the
 | Trigger | Skill to load | Why |
 |---|---|---|
 | Any [code smell](#code-smells--automatic-review-triggers) fires (250+ LOC, >3 params, redundant verification), OR the post-write loop surfaces 2+ issues, OR the user says "reshape this", "extract this", "clean this up" | `refactor` | Safe codemap-driven multi-step refactor with LSP + tests after each step. Never improvise a structural change. |
-| Recent branch contains AI-authored patterns (broad except, dead helpers, vague comments, oversized files, redundant post-action verification), OR the user says "remove slop", "clean AI code", "deslop" | `remove-ai-slops` | Tests pinned FIRST, then categorized parallel cleanup, then quality gates. Behavior-preserving. |
+| Recent branch contains AI-authored patterns (broad except, dead helpers, vague comments, oversized files, redundant post-action verification, junk tests), OR the user says "remove slop", "clean AI code", "deslop" | `remove-ai-slops` | Behavior locked by gate-passing tests FIRST, then categorized parallel cleanup (junk tests included, each cut proven by a mutation), then quality gates. Behavior-preserving. |
 | Rust code touches `unsafe`, `*mut`, `*const`, `MaybeUninit`, FFI, `unsafe impl Send/Sync`, or a custom lock-free primitive | `references/rust-ub/` | Full UB taxonomy + Miri strictness escalation. Every `unsafe` block must survive Miri Level 3 (strict provenance + symbolic alignment + preemption) before it ships. |
 
 ---
@@ -389,6 +332,6 @@ These two skills are not optional cosmetics. They are the recovery path for the
 
 ## Activation
 
-This skill activates whenever you are writing or modifying any `.py`, `.pyi`, `.rs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.go` file, or any project manifest (`pyproject.toml`, `Cargo.toml`, `package.json`, `tsconfig.json`, `.oxlintrc.json`, `.oxfmtrc.json`, `go.mod`, `go.sum`, `.golangci.yml`, `Taskfile.yml`, `buf.yaml`, `sqlc.yaml`). **Even one-off scripts get the full treatment** - that is the whole point of `uv run` + PEP 723, `rust-script`, `bun run`, and `go run` + `//go:build ignore`: production hygiene with throwaway ergonomics.
+This skill activates whenever you are writing or modifying any `.py`, `.pyi`, `.rs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.go` file, any test or spec file in those languages, or any project manifest (`pyproject.toml`, `Cargo.toml`, `package.json`, `tsconfig.json`, `.oxlintrc.json`, `.oxfmtrc.json`, `go.mod`, `go.sum`, `.golangci.yml`, `Taskfile.yml`, `buf.yaml`, `sqlc.yaml`). **Even one-off scripts get the full treatment** - that is the whole point of `uv run` + PEP 723, `rust-script`, `bun run`, and `go run` + `//go:build ignore`: production hygiene with throwaway ergonomics.
 
 The references contain the recipes. **Read them before writing code. Re-read them when the model drifts.** The post-write review loop is non-negotiable.

package/dist/skills/programming/references/go/README.md

@@ -69,7 +69,7 @@ Read these per-file references for the canonical patterns:
 - **CLI** → `cobra-stack.md` — cobra layout, slog integration, graceful shutdown on signals, fang-style colored help.
 - **TUI** → `bubbletea-v2.md` — v2 model, `SetVirtualCursor(false)` + `tea.View{Cursor}` for CJK IME, why v1 was broken for Korean/Japanese/Chinese input.
 - **Testing** → `testing.md` — table-driven tests, `require` vs `assert`, `autogold` snapshots, `gopter` property tests, `testcontainers` for integration, `goleak` for goroutine leaks.
-- **Bootstrap** → `bootstrap.md` — `new-project.go` invocation, project layout (`cmd/`, `internal/`, `pkg/`), Taskfile, CI.
+- **Bootstrap** → `bootstrap.md` — `scripts/go/new-project.ts` invocation, project layout (`cmd/`, `internal/`, `pkg/`), Taskfile, CI.
 - **Strict config** → `golangci-strict.md` — the canonical `.golangci.yml` with the full linter whitelist and per-linter rationale.
 - **One-liners** → `one-liners.md` — `go run` scripts with `//go:build ignore`, `gorun`-style invocation.
 

package/dist/skills/programming/references/go/bootstrap.md

@@ -1,6 +1,6 @@
 # Bootstrap — Project Layout, Toolchain, Taskfile, CI
 
-What every new Go project gets in the first 60 seconds. Drop the script in `scripts/go/new-project.go` does all of this — this document explains *what* it produces and *why*.
+What every new Go project gets in the first 60 seconds. The scaffold `bun run ../../scripts/go/new-project.ts <name>` does all of this — this document explains *what* it produces and *why*.
 
 ## Toolchain pin
 
@@ -318,7 +318,7 @@ Go 1.23+ HTTP service for {one-line purpose}.
 - 250 pure LOC ceiling per file — split before adding lines
 ```
 
-The skill's `cmd/new-project.go` writes this file with project-specific values filled in.
+The skill's `scripts/go/new-project.ts` writes this file with project-specific values filled in.
 
 ## Sources
 

package/dist/skills/programming/references/python/README.md

@@ -221,9 +221,9 @@ Canonical defaults (override only if `pyproject.toml` explicitly picks something
 Scaffold a new project with all strict defaults pre-configured:
 
 ```bash
-uv run ../../scripts/python/new-project.py myproject
-uv run ../../scripts/python/new-project.py myproject --path ./workspace
-uv run ../../scripts/python/new-project.py myproject --lib   # publishable library
+bun run ../../scripts/python/new-project.ts myproject
+bun run ../../scripts/python/new-project.ts myproject --path ./workspace
+bun run ../../scripts/python/new-project.ts myproject --lib   # publishable library
 ```
 
 Creates via `uv init`, then injects basedpyright `typeCheckingMode = "all"` + ruff `select = ["ALL"]` + pytest strict. Cross-platform (macOS, Linux, Windows).
@@ -234,7 +234,7 @@ For manual setup: `uv init --app myproject`, then load `pyproject-strict.md`.
 
 Every `.py` script — even throwaway — MUST use PEP 723 inline metadata with the `# ─── How to run ───` comment block. No venv, no `requirements.txt`. The script IS the environment spec. A script without the usage comment block is incomplete.
 
-Scaffold with: `uv run ../../scripts/python/new-script.py <name> --deps "httpx2[http2,brotli,zstd]"` (writes to temp dir by default, `--output` for specific path).
+Scaffold with: `bun run ../../scripts/python/new-script.ts <name> --deps "httpx2[http2,brotli,zstd]"` (writes to temp dir by default, `--output` for specific path).
 
 Load `one-liners.md` for full patterns, examples, and anti-patterns.