oh-my-opencode 5.1.54 → 5.1.55

package/dist/oh-my-opencode.schema.json

@@ -194,6 +194,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -746,6 +753,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -1298,6 +1312,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -1850,6 +1871,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -2405,6 +2433,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -2957,6 +2992,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -3509,6 +3551,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -4061,6 +4110,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -4613,6 +4669,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -5165,6 +5228,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -5717,6 +5787,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -6269,6 +6346,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -6821,6 +6905,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -7373,6 +7464,13 @@
                 ]
               }
             },
+            "models_distribution": {
+              "type": "string",
+              "enum": [
+                "sequential",
+                "round_robin"
+              ]
+            },
             "fallback_models": {
               "anyOf": [
                 {
@@ -7926,6 +8024,13 @@
               ]
             }
           },
+          "models_distribution": {
+            "type": "string",
+            "enum": [
+              "sequential",
+              "round_robin"
+            ]
+          },
           "fallback_models": {
             "anyOf": [
               {
@@ -8487,6 +8592,13 @@
               ]
             }
           },
+          "models_distribution": {
+            "type": "string",
+            "enum": [
+              "sequential",
+              "round_robin"
+            ]
+          },
           "fallback_models": {
             "anyOf": [
               {

package/dist/skills/browser/runtime/omowright/manifest.json

@@ -5,5 +5,5 @@
     "index.js": "8b14c1775f397e36967a0d094c67e2a31f8ae1e92add172925548723ca339046",
     "page-bundle.js": "bfd51e8383cf47200d57387bbbed258bce5a3a3d00c38fc108034d2888e23f0c"
   },
-  "stagedAtUtc": "2026-10-31T15:59:00.866Z"
+  "stagedAtUtc": "2026-11-01T07:04:29.772Z"
 }

package/dist/skills/programming/SKILL.md

@@ -199,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

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

@@ -56,12 +56,12 @@ When delegating test-writing, hand the child the behavior the test must distingu
 
 ## After writing: test your test
 
-A test earns its place by failing. Before the PR, for each new or reshaped test:
+A test earns its place by failing. Before the PR, run `bun run scripts/typescript/check-test-junk.ts <test files>` for the classes a regex can see (source grep, prose pin, fixed sleep, `.only`/`.skip`, self-comparison, lower bound), then for each new or reshaped test:
 
 1. **Break the owner** (flip the condition, drop the branch, return a constant, skip the write) and run the test. Confirm the mutated bytes are actually in the file before reading the result; a no-op edit "passes" identically to the original.
 2. **Red for the intended reason?** Read the failure message: a loose pattern can match the base's generic error by coincidence (a false red), and a fake that simulates the failure by a different mechanism than the guard reads fails with the fix present.
 3. **Still green?** Then one of: the test is vacuous (fix the assertion); the mutant is equivalent (a `try/catch`, fallback, or normalization maps it back to the same outcome: retarget the mutation at the observable claim); a second rule already produces the same outcome (make the input exercise only the rule under test and assert the recorded reason); or the mutated code is dead (delete the code, not the test's teeth).
-4. **Restore byte for byte.** Never commit a mutation.
+4. **Restore byte for byte.** Never commit a mutation. `bun run scripts/typescript/mutation-proof.ts --file <owner> --find <text> --replace <text> --test 'candidate=bun test <file>' --test 'keeper=bun test <file>'` does steps 1, 3 and 4 in one run and prints red/green per test.
 
 Assertion shapes that survive this step:
 

package/dist/skills/programming/scripts/typescript/check-test-junk-rules.ts

@@ -0,0 +1,140 @@
+import { extname } from "node:path"
+
+export type RuleId =
+  | "source-grep"
+  | "prose-pin"
+  | "fixed-sleep"
+  | "focused"
+  | "skipped"
+  | "self-compare"
+  | "lower-bound"
+
+export type Language = "typescript" | "python" | "rust" | "go"
+
+export type ReadKind = "prose" | "source"
+
+export type LineRule = {
+  readonly rule: RuleId
+  readonly languages: readonly Language[]
+  readonly pattern: RegExp
+  readonly message: string
+}
+
+export const RULE_IDS: readonly RuleId[] = [
+  "source-grep",
+  "prose-pin",
+  "fixed-sleep",
+  "focused",
+  "skipped",
+  "self-compare",
+  "lower-bound",
+]
+
+export function languageOf(file: string): Language | undefined {
+  switch (extname(file)) {
+    case ".ts":
+    case ".tsx":
+    case ".mts":
+    case ".cts":
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "typescript"
+    case ".py":
+      return "python"
+    case ".rs":
+      return "rust"
+    case ".go":
+      return "go"
+    default:
+      return undefined
+  }
+}
+
+const SLEEP_MESSAGE = "fixed sleep: wait on the event or state change, not on the clock"
+const SKIP_MESSAGE = "skipped test: fix the test or delete it with its proof; never park it"
+const LOWER_BOUND_MESSAGE = "lower bound on a cardinality: removing one item stays green; pin the exact set"
+
+export const LINE_RULES: readonly LineRule[] = [
+  {
+    rule: "fixed-sleep",
+    languages: ["typescript"],
+    pattern: /\bsetTimeout\s*\(\s*(resolve|res|r|done|cb)\s*,\s*[1-9]|\bawait\s+(Bun\.)?sleep\s*\(\s*[1-9]|new Promise\s*\(\s*\(?\s*\w*\s*\)?\s*=>\s*setTimeout\s*\(\s*\w+\s*,\s*[1-9]/,
+    message: SLEEP_MESSAGE,
+  },
+  { rule: "fixed-sleep", languages: ["python"], pattern: /\btime\.sleep\s*\(|\bawait\s+(asyncio|anyio|trio)\.sleep\s*\(\s*[0-9]/, message: SLEEP_MESSAGE },
+  { rule: "fixed-sleep", languages: ["rust"], pattern: /\bthread::sleep\s*\(|\btokio::time::sleep\s*\(/, message: SLEEP_MESSAGE },
+  { rule: "fixed-sleep", languages: ["go"], pattern: /\btime\.Sleep\s*\(/, message: SLEEP_MESSAGE },
+  {
+    rule: "focused",
+    languages: ["typescript"],
+    pattern: /\b(test|it|describe)\.only\s*\(/,
+    message: "focused test: the rest of the suite is skipped silently",
+  },
+  { rule: "skipped", languages: ["typescript"], pattern: /\b(test|it|describe)\.skip\s*\(|\b(xit|xdescribe|xtest)\s*\(/, message: SKIP_MESSAGE },
+  { rule: "skipped", languages: ["python"], pattern: /@pytest\.mark\.skip\b|\bpytest\.skip\s*\(|\bunittest\.skip\b/, message: SKIP_MESSAGE },
+  { rule: "skipped", languages: ["rust"], pattern: /#\[ignore\b/, message: SKIP_MESSAGE },
+  { rule: "skipped", languages: ["go"], pattern: /\bt\.Skip(f|Now)?\s*\(/, message: SKIP_MESSAGE },
+  {
+    rule: "lower-bound",
+    languages: ["typescript"],
+    pattern: /\.(length|size|count)\s*\)\s*\.(toBeGreaterThan\s*\(\s*[1-9]|toBeGreaterThanOrEqual\s*\(\s*([2-9]|\d{2,}))/,
+    message: LOWER_BOUND_MESSAGE,
+  },
+  {
+    rule: "lower-bound",
+    languages: ["python"],
+    pattern: /\bassert\s+len\s*\(.+\)\s*(>\s*[1-9]|>=\s*([2-9]|\d{2,}))/,
+    message: LOWER_BOUND_MESSAGE,
+  },
+]
+
+export const SELF_COMPARE: Readonly<Record<Language, RegExp>> = {
+  typescript: /\bexpect\s*\(\s*([^()]+?)\s*\)\s*\.(toBe|toEqual|toStrictEqual)\s*\(\s*\1\s*\)/,
+  python: /\bassert\s+([A-Za-z_][\w.]*)\s*==\s*\1\s*(#|$)/,
+  rust: /\bassert_eq!\s*\(\s*([^,()]+?)\s*,\s*\1\s*\)/,
+  go: /\b(Equal|Exactly)\s*\(\s*t\s*,\s*([^,()]+?)\s*,\s*\2\s*\)/,
+}
+
+const SOURCE_EXTENSIONS = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|py|rs|go)$/
+const PROSE_EXTENSIONS = /\.(md|mdc|txt|prompt)$/
+const READ_ASSIGNMENT = /\b(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?(?:\w+\.)?(?:readFileSync|readFile|readTextSync|Bun\.file|open|read_text|read)\s*\(([^\n]*)$/
+const PYTHON_READ_ASSIGNMENT = /^\s*(\w+)\s*=\s*(?:\w+\.)?(?:open|Path|read_text)\s*\(([^\n]*)$/
+const STRING_LITERAL = /["'`]([^"'`]+)["'`]/g
+
+function readKindOf(callArguments: string): ReadKind | undefined {
+  for (const literal of callArguments.matchAll(STRING_LITERAL)) {
+    const value = literal[1] ?? ""
+    if (PROSE_EXTENSIONS.test(value)) return "prose"
+    if (SOURCE_EXTENSIONS.test(value)) return "source"
+  }
+  return undefined
+}
+
+export function collectReadVariables(lines: readonly string[], language: Language): ReadonlyMap<string, ReadKind> {
+  const variables = new Map<string, ReadKind>()
+  const pattern = language === "python" ? PYTHON_READ_ASSIGNMENT : READ_ASSIGNMENT
+  for (const line of lines) {
+    const match = pattern.exec(line)
+    if (match === null) continue
+    const kind = readKindOf(match[2] ?? "")
+    if (kind !== undefined && match[1] !== undefined) variables.set(match[1], kind)
+  }
+  return variables
+}
+
+export function greppedVariable(line: string, language: Language): string | undefined {
+  if (language === "python") {
+    return /\bassert\s+(?:not\s+)?["'][^"']*["']\s+(?:not\s+)?in\s+(\w+)/.exec(line)?.[1]
+  }
+  return (
+    /\bexpect\s*\(\s*(\w+)\s*\)\s*(?:\.not)?\.(?:toContain|toMatch|toMatchSnapshot|toMatchInlineSnapshot|toInclude|toStartWith|toEndWith)\s*\(/.exec(line)?.[1] ??
+    /\bexpect\s*\(\s*(\w+)\.(?:includes|match|indexOf|search)\s*\(/.exec(line)?.[1]
+  )
+}
+
+export const READ_RULE_MESSAGES: Readonly<Record<ReadKind, { readonly rule: RuleId; readonly message: string }>> = {
+  prose: { rule: "prose-pin", message: "wording of a prompt/skill/doc is pinned; assert a machine-consumed value or write no test" },
+  source: { rule: "source-grep", message: "a source file is grepped as text; drive the module and assert behavior" },
+}

package/dist/skills/programming/scripts/typescript/check-test-junk.test.ts

@@ -0,0 +1,125 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import type { Finding, RuleId } from "./check-test-junk"
+
+const script = join(import.meta.dir, "check-test-junk.ts")
+let root = ""
+
+async function run(args: readonly string[]): Promise<{ readonly code: number; readonly findings: readonly Finding[] }> {
+  const child = Bun.spawn([process.execPath, script, "--json", ...args], { cwd: root, stdout: "pipe", stderr: "pipe" })
+  const [stdout, code] = await Promise.all([new Response(child.stdout).text(), child.exited])
+  const parsed: { readonly findings: readonly Finding[] } = JSON.parse(stdout)
+  return { code, findings: parsed.findings }
+}
+
+const JUNK_TS = `import { readFileSync } from "node:fs"
+test("source grep", () => {
+  const source = readFileSync("src/parser.ts", "utf8")
+  expect(source).toContain("export function parse")
+})
+test("prose pin", () => {
+  const skill = readFileSync("SKILL.md", "utf8")
+  expect(skill).toContain("You are a senior engineer")
+})
+test("sleeps", async () => {
+  await new Promise((resolve) => setTimeout(resolve, 500))
+})
+test.only("focused", () => {})
+it.skip("parked", () => {})
+test("self compare", () => {
+  expect(config.prompt).toEqual(config.prompt)
+})
+test("lower bound", () => {
+  expect(masked.length).toBeGreaterThanOrEqual(3)
+})
+test("opted out", async () => {
+  await new Promise((resolve) => setTimeout(resolve, 50)) // test-junk-ok: fixed-sleep debounce window is the behavior under test
+})
+`
+
+const CLEAN_TS = `import { readFileSync } from "node:fs"
+test("parses a date when the input has a timezone", () => {
+  expect(parse("2026-01-01T00:00:00Z")).toEqual({ year: 2026 })
+})
+test("the packaged skill equals its source", () => {
+  const source = readFileSync("skills/x/SKILL.md", "utf8")
+  const packaged = readFileSync("dist/skills/x/SKILL.md", "utf8")
+  expect(packaged).toBe(source)
+})
+test("the bundle keeps the runtime entry", () => {
+  const bundle = readFileSync("dist/index.js", "utf8")
+  expect(bundle.length).toBeGreaterThan(0)
+  expect(parseExports(bundle)).toEqual(["main"])
+})
+test("yields one tick before asserting", async () => {
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  expect(flushed).toBe(true)
+})
+`
+
+const JUNK_PY = `import time
+def test_sleeps():
+    time.sleep(1)
+def test_lower():
+    assert len(items) >= 2
+def test_lower_nested():
+    assert len(select(items)) > 1
+def test_prose():
+    body = Path("SKILL.md").read_text()
+    assert "You are" in body
+`
+
+const JUNK_GO = `func TestSleeps(t *testing.T) {
+\ttime.Sleep(100 * time.Millisecond)
+\tt.Skip("flaky")
+}
+`
+
+describe("#given test files with mechanically detectable junk", () => {
+  beforeAll(() => {
+    root = mkdtempSync(join(process.env.RUN_TMP ?? tmpdir(), "check-test-junk-"))
+    mkdirSync(join(root, "src"), { recursive: true })
+    writeFileSync(join(root, "src", "junk.test.ts"), JUNK_TS)
+    writeFileSync(join(root, "src", "clean.test.ts"), CLEAN_TS)
+    writeFileSync(join(root, "src", "test_junk.py"), JUNK_PY)
+    writeFileSync(join(root, "src", "junk_test.go"), JUNK_GO)
+    writeFileSync(join(root, "src", "parser.ts"), "export const parse = () => readFileSync('x.ts')\n")
+  })
+
+  afterAll(() => rmSync(root, { recursive: true, force: true }))
+
+  test("#when the TypeScript fixture is scanned #then every class is reported at its line and the opted-out line is not", async () => {
+    const { code, findings } = await run(["src/junk.test.ts"])
+    const byRule = new Map<RuleId, number[]>()
+    for (const finding of findings) byRule.set(finding.rule, [...(byRule.get(finding.rule) ?? []), finding.line])
+    expect(code).toBe(1)
+    expect(byRule.get("source-grep")).toEqual([4])
+    expect(byRule.get("prose-pin")).toEqual([8])
+    expect(byRule.get("fixed-sleep")).toEqual([11])
+    expect(byRule.get("focused")).toEqual([13])
+    expect(byRule.get("skipped")).toEqual([14])
+    expect(byRule.get("self-compare")).toEqual([16])
+    expect(byRule.get("lower-bound")).toEqual([19])
+  })
+
+  test("#when Python and Go fixtures are scanned #then their sleep, skip and lower-bound forms are reported", async () => {
+    const { findings } = await run(["src/test_junk.py", "src/junk_test.go"])
+    expect(findings.map((finding) => [finding.file.split("/").at(-1), finding.line, finding.rule])).toEqual([
+      ["test_junk.py", 3, "fixed-sleep"],
+      ["test_junk.py", 5, "lower-bound"],
+      ["test_junk.py", 7, "lower-bound"],
+      ["test_junk.py", 10, "prose-pin"],
+      ["junk_test.go", 2, "fixed-sleep"],
+      ["junk_test.go", 3, "skipped"],
+    ])
+  })
+
+  test("#when a clean test file and a production file are scanned #then nothing is reported and the exit code is 0", async () => {
+    const { code, findings } = await run(["src/clean.test.ts", "src/parser.ts"])
+    expect(findings).toEqual([])
+    expect(code).toBe(0)
+  })
+})

package/dist/skills/programming/scripts/typescript/check-test-junk.ts

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+/**
+ * Flag test files for the junk classes a regex can see (the rest need a reader):
+ *
+ *   source-grep    - a value read from a source file (.ts/.js/.py/.rs/.go/...) is grepped
+ *                    (toContain / toMatch / includes / `in`); byte equality between two reads is not flagged
+ *   prose-pin      - a value read from a prompt/skill/markdown file has its wording pinned
+ *                    (toContain / not.toContain / toMatch / toMatchSnapshot / `in`)
+ *   fixed-sleep    - setTimeout-as-wait, sleep(N), time.sleep, thread::sleep, time.Sleep
+ *   focused        - test.only / it.only / describe.only (a focused test silently skips the suite)
+ *   skipped        - .skip / xit / xdescribe / @pytest.mark.skip / #[ignore] / t.Skip
+ *   self-compare   - expect(x).toBe(x) / assert x == x / assert_eq!(x, x)
+ *   lower-bound    - toBeGreaterThan(N>=1) / toBeGreaterThanOrEqual(N>=2) on a length/size/count
+ *                    (removing one item stays green; a plain non-empty check is not flagged)
+ *
+ * Opt out per line with a trailing comment naming the rule and the reason:
+ *   // test-junk-ok: fixed-sleep debounce window is the behavior under test
+ *
+ * Usage:
+ *   bun run scripts/typescript/check-test-junk.ts [--json] <file-or-dir>...
+ *
+ * Exit codes: 0 no findings, 1 findings, 2 input error.
+ * Each class is explained in references/testing/junk-classes.md; a finding here is a candidate
+ * to prove with references/testing/README.md "test your test", not an automatic deletion.
+ */
+
+import { readdirSync, readFileSync, statSync } from "node:fs"
+import { basename, extname, join } from "node:path"
+import process from "node:process"
+
+import {
+  collectReadVariables,
+  greppedVariable,
+  languageOf,
+  LINE_RULES,
+  READ_RULE_MESSAGES,
+  RULE_IDS,
+  SELF_COMPARE,
+  type RuleId,
+} from "./check-test-junk-rules"
+
+export type { RuleId } from "./check-test-junk-rules"
+
+export type Finding = {
+  readonly file: string
+  readonly line: number
+  readonly rule: RuleId
+  readonly message: string
+}
+
+const EXCLUDED_DIRS: ReadonlySet<string> = new Set([".git", "node_modules", "dist", "build", "target", "__pycache__", ".venv", "vendor"])
+
+const TEST_FILE_PATTERNS: readonly RegExp[] = [
+  /\.(test|spec)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/,
+  /_test\.go$/,
+  /(^|\/)test_[^/]*\.py$/,
+  /(^|\/)[^/]*_test\.py$/,
+  /\.rs$/,
+]
+
+const OPT_OUT = /test-junk-ok:\s*([a-z-]+)/
+
+function isTestFile(file: string): boolean {
+  if (!TEST_FILE_PATTERNS.some((pattern) => pattern.test(file))) return false
+  // Rust unit tests live inside source files; only files declaring a test module count.
+  return extname(file) !== ".rs" || /#\[cfg\(test\)\]|#\[test\]/.test(readFileSync(file, "utf8"))
+}
+
+function* walk(root: string): Generator<string> {
+  if (statSync(root).isFile()) {
+    yield root
+    return
+  }
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!EXCLUDED_DIRS.has(entry.name)) yield* walk(join(root, entry.name))
+    } else if (entry.isFile()) {
+      yield join(root, entry.name)
+    }
+  }
+}
+
+function optedOut(line: string, rule: RuleId): boolean {
+  const match = OPT_OUT.exec(line)
+  return match !== null && match[1] === rule
+}
+
+function scanFile(file: string): readonly Finding[] {
+  const language = languageOf(file)
+  if (language === undefined) return []
+  const lines = readFileSync(file, "utf8").split("\n")
+  const readVariables = collectReadVariables(lines, language)
+  const findings: Finding[] = []
+  const report = (line: number, rule: RuleId, message: string): void => {
+    if (!optedOut(lines[line - 1] ?? "", rule)) findings.push({ file, line, rule, message })
+  }
+
+  lines.forEach((source, index) => {
+    const line = index + 1
+    for (const rule of LINE_RULES) {
+      if (rule.languages.includes(language) && rule.pattern.test(source)) report(line, rule.rule, rule.message)
+    }
+    if (SELF_COMPARE[language].test(source)) {
+      report(line, "self-compare", "the expected value is the value under test; derive it from the input")
+    }
+    const grepped = greppedVariable(source, language)
+    const kind = grepped === undefined ? undefined : readVariables.get(grepped)
+    if (kind !== undefined) report(line, READ_RULE_MESSAGES[kind].rule, READ_RULE_MESSAGES[kind].message)
+  })
+  return findings
+}
+
+function scan(paths: readonly string[]): readonly Finding[] {
+  const findings: Finding[] = []
+  for (const root of paths) {
+    for (const file of walk(root)) {
+      if (isTestFile(file)) findings.push(...scanFile(file))
+    }
+  }
+  return findings
+}
+
+function main(argv: readonly string[]): number {
+  const json = argv.includes("--json")
+  const paths = argv.filter((arg) => arg !== "--json")
+  if (paths.length === 0) {
+    console.error(`usage: ${basename(import.meta.path)} [--json] <file-or-dir>...`)
+    return 2
+  }
+  for (const path of paths) {
+    try {
+      statSync(path)
+    } catch {
+      console.error(`error: ${path} does not exist`)
+      return 2
+    }
+  }
+  const findings = scan(paths)
+  if (json) {
+    console.log(JSON.stringify({ findings, rules: RULE_IDS }, null, 2))
+  } else {
+    for (const finding of findings) console.log(`${finding.file}:${finding.line} ${finding.rule} ${finding.message}`)
+    console.log(findings.length === 0 ? "check-test-junk: no findings" : `check-test-junk: ${findings.length} finding(s)`)
+  }
+  return findings.length === 0 ? 0 : 1
+}
+
+if (import.meta.main) process.exit(main(process.argv.slice(2)))