@@ -0,0 +1,18 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+      - run: npm ci
+      - run: npm run check
@@ -427,12 +427,32 @@ OpenCode's V2 plugin API; no code was copied from either project.
 git clone https://github.com/zignd/opencode-goal-plugin.git
 cd opencode-goal-plugin
 npm install
-npx tsc -p tsconfig.json
-node display.test.ts
-node budget.test.ts
-node settings.test.ts
+
+npm test              # the whole suite
+npm run check         # typecheck, then the suite — what CI runs
+npm run typecheck     # tsc alone
+npm run test:watch    # re-run on change
+npm run test:coverage # line, branch and function coverage
 ```
 
+The suite runs on Node's built-in test runner, so there is no test dependency to install.
+`node --test` discovers `*.test.ts` and strips the types, which is why the checks import
+`./settings.ts` while the plugin source imports `./settings.js` — the plugin needs `.js`
+specifiers for OpenCode's own loader. Where a module is imported by both, the import is
+`import type`, which is erased and so has no runtime cost.
+
+Current state: 140 checks over three modules, at 100% line, branch and function coverage.
+
+| Module | What it covers |
+| --- | --- |
+| `budget.ts` | Turn-budget parsing, the exhaustion gate, formatting, the `maxTurns` option |
+| `display.ts` | Which placements are shown, `/goal display` argument parsing |
+| `settings.ts` | The other three settings, override resolution, the `/goal settings` summary |
+
+`index.ts` and `tui.tsx` are not unit tested: they are mostly wiring, and the parts that
+historically broke were extracted into the three pure modules precisely so they could be.
+`npm run check` typechecks both.
+
 Bumping support for a new OpenCode release means bumping `@opencode/plugin` and re-running the
 typecheck. `tsconfig.json` carries `jsxImportSource: "@opentui/solid"`, which is what makes the
 panel's JSX typecheck.
 
@@ -1,88 +1,140 @@
 /**
- * Checks for the turn budget. Run with: node budget.test.ts
+ * The turn budget.
  *
- * The exhaustion test is the one backstop between a runaway loop and a very
- * large bill, so it is pinned here rather than living inline in the event loop.
+ * `isExhausted` is the one backstop between a runaway loop and a very large
+ * bill, so it is pinned here rather than left inline in the event loop.
  */
+import { describe, test } from "node:test"
+import assert from "node:assert/strict"
 import {
   budgetLabel,
   DEFAULT_BUDGET,
   formatTurns,
   isExhausted,
   parseBudgetArgument,
   readBudgetOption,
-  UNLIMITED_HINT,
   UNLIMITED_CAVEAT,
-  type Budget,
+  UNLIMITED_HINT,
 } from "./budget.ts"
 
-let failures = 0
+describe("isExhausted", () => {
+  test("is not spent at the start", () => {
+    assert.equal(isExhausted(0, 20), false)
+  })
+
+  test("is not spent one turn under the limit", () => {
+    assert.equal(isExhausted(19, 20), false)
+  })
+
+  test("is spent exactly at the limit", () => {
+    assert.equal(isExhausted(20, 20), true)
+  })
+
+  test("is spent past the limit", () => {
+    assert.equal(isExhausted(21, 20), true)
+  })
+
+  test("a limit of one is spent after one turn", () => {
+    assert.equal(isExhausted(1, 1), true)
+  })
+
+  for (const turns of [0, 20, 100_000]) {
+    test(`an unlimited budget is never spent after ${turns} turns`, () => {
+      assert.equal(isExhausted(turns, null), false)
+    })
+  }
+})
+
+describe("parseBudgetArgument", () => {
+  const unlimited = { kind: "budget", budget: null }
+
+  for (const word of ["unlimited", "unlim", "unbounded", "infinite", "inf", "none", "no-limit", "∞"]) {
+    test(`reads "${word}" as unlimited`, () => {
+      assert.deepEqual(parseBudgetArgument(word), unlimited)
+    })
+  }
+
+  test("ignores casing and padding", () => {
+    assert.deepEqual(parseBudgetArgument("  UNLIMITED "), unlimited)
+    assert.deepEqual(parseBudgetArgument(" ∞ "), unlimited)
+  })
+
+  test("reads a whole number", () => {
+    assert.deepEqual(parseBudgetArgument("40"), { kind: "budget", budget: 40 })
+  })
 
-function check(name: string, actual: unknown, expected: unknown) {
-  const a = JSON.stringify(actual)
-  const e = JSON.stringify(expected)
-  if (a === e) {
-    console.log(`  ok   ${name}`)
-  } else {
-    failures++
-    console.log(`  FAIL ${name}\n         expected ${e}\n         actual   ${a}`)
+  test("reads default as a clear", () => {
+    assert.deepEqual(parseBudgetArgument("default"), { kind: "default" })
+  })
+
+  for (const [input, value] of [
+    ["0", "0"],
+    ["-5", "-5"],
+    ["2.5", "2.5"],
+    ["lots", "lots"],
+    ["   ", ""],
+  ]) {
+    test(`rejects ${JSON.stringify(input)}`, () => {
+      assert.deepEqual(parseBudgetArgument(input), { kind: "invalid", value })
+    })
   }
-}
-
-console.log("isExhausted — the gate that stops a runaway")
-check("not spent at the start", isExhausted(0, 20), false)
-check("not spent one under", isExhausted(19, 20), false)
-check("spent exactly at the limit", isExhausted(20, 20), true)
-check("spent past the limit", isExhausted(21, 20), true)
-check("a limit of 1 is spent after one turn", isExhausted(1, 1), true)
-check("unlimited is never spent at zero", isExhausted(0, null), false)
-check("unlimited is never spent at 20", isExhausted(20, null), false)
-check("unlimited is never spent at 100000", isExhausted(100000, null), false)
-
-console.log("parseBudgetArgument — /goal budget …")
-check("unlimited", parseBudgetArgument("unlimited"), { kind: "budget", budget: null })
-check("Unlimited with odd casing", parseBudgetArgument("  UNLIMITED "), { kind: "budget", budget: null })
-check("infinite", parseBudgetArgument("infinite"), { kind: "budget", budget: null })
-check("none", parseBudgetArgument("none"), { kind: "budget", budget: null })
-check("inf is a short alias", parseBudgetArgument("inf"), { kind: "budget", budget: null })
-check("unlim is a short alias", parseBudgetArgument("unlim"), { kind: "budget", budget: null })
-check("the infinity sign is an alias", parseBudgetArgument("\u221e"), { kind: "budget", budget: null })
-check("infinity sign with padding", parseBudgetArgument(" \u221e "), { kind: "budget", budget: null })
-check("unlim is not read as a count", parseBudgetArgument("unlim").kind, "budget")
-check("a count", parseBudgetArgument("40"), { kind: "budget", budget: 40 })
-check("default", parseBudgetArgument("default"), { kind: "default" })
-check("zero is not a budget", parseBudgetArgument("0"), { kind: "invalid", value: "0" })
-check("a negative count is invalid", parseBudgetArgument("-5"), { kind: "invalid", value: "-5" })
-check("a decimal is invalid", parseBudgetArgument("2.5"), { kind: "invalid", value: "2.5" })
-check("nonsense is invalid", parseBudgetArgument("lots"), { kind: "invalid", value: "lots" })
-check("empty is invalid", parseBudgetArgument("   "), { kind: "invalid", value: "" })
-
-console.log("readBudgetOption — the maxTurns plugin option")
-check("absent uses the default", readBudgetOption(undefined), { budget: DEFAULT_BUDGET })
-check("a number is used as-is", readBudgetOption(40), { budget: 40 })
-check("null means unlimited", readBudgetOption(null), { budget: null })
-check("the word unlimited means unlimited", readBudgetOption("unlimited"), { budget: null })
-check("zero is rejected with a warning", readBudgetOption(0), {
-  budget: DEFAULT_BUDGET,
-  warning:
-    "maxTurns must be a whole number of at least 1, or \"unlimited\"; got 0. Using 20.",
 })
-check("a negative is rejected with a warning", readBudgetOption(-3).budget, DEFAULT_BUDGET)
-check("a decimal is rejected with a warning", readBudgetOption(1.5).budget, DEFAULT_BUDGET)
-check("garbage is rejected with a warning", readBudgetOption("lots").budget, DEFAULT_BUDGET)
-check("a warning is actually present", typeof readBudgetOption(0).warning, "string")
-
-console.log("display")
-check("label for a count", budgetLabel(20), "20")
-check("label when unlimited", budgetLabel(null), "unlimited")
-check("counter with a count", formatTurns(3, 20), "3/20")
-check("counter when unlimited", formatTurns(3, null), "3/∞")
-check("counter at zero when unlimited", formatTurns(0, null), "0/∞")
-
-console.log("misc")
-check("the caveat names what still stops it", /judge|stall|repeat/i.test(UNLIMITED_CAVEAT), true)
-check("the hint advertises a short alias", /\binf\b/.test(UNLIMITED_HINT), true)
-check("the caveat mentions no ceiling", /ceiling/i.test(UNLIMITED_CAVEAT), true)
-
-console.log(failures === 0 ? "\nall passed" : `\n${failures} FAILED`)
-process.exit(failures === 0 ? 0 : 1)
+
+describe("readBudgetOption", () => {
+  test("falls back to the default when absent", () => {
+    assert.deepEqual(readBudgetOption(undefined), { budget: DEFAULT_BUDGET })
+  })
+
+  test("uses a number as given", () => {
+    assert.deepEqual(readBudgetOption(40), { budget: 40 })
+  })
+
+  for (const input of [null, "unlimited", "inf", "none", "∞"]) {
+    test(`reads ${JSON.stringify(input)} as unlimited`, () => {
+      assert.deepEqual(readBudgetOption(input), { budget: null })
+    })
+  }
+
+  for (const input of [0, -3, 1.5, "lots"]) {
+    test(`rejects ${JSON.stringify(input)} and warns`, () => {
+      const result = readBudgetOption(input)
+      assert.equal(result.budget, DEFAULT_BUDGET)
+      assert.equal(typeof result.warning, "string")
+      assert.match(result.warning ?? "", /maxTurns must be a whole number/)
+    })
+  }
+})
+
+describe("display", () => {
+  test("labels a finite budget as a count", () => {
+    assert.equal(budgetLabel(20), "20")
+  })
+
+  test("labels an unlimited budget in words", () => {
+    assert.equal(budgetLabel(null), "unlimited")
+  })
+
+  test("formats the counter against a limit", () => {
+    assert.equal(formatTurns(3, 20), "3/20")
+  })
+
+  test("formats the counter against no limit", () => {
+    assert.equal(formatTurns(3, null), "3/∞")
+    assert.equal(formatTurns(0, null), "0/∞")
+  })
+})
+
+describe("wording", () => {
+  test("the unlimited caveat says what still stops the loop", () => {
+    assert.match(UNLIMITED_CAVEAT, /judge/i)
+    assert.match(UNLIMITED_CAVEAT, /stall|repetition/i)
+  })
+
+  test("the unlimited caveat admits there is no ceiling", () => {
+    assert.match(UNLIMITED_CAVEAT, /ceiling/i)
+  })
+
+  test("the usage hint advertises the short spelling", () => {
+    assert.match(UNLIMITED_HINT, /\binf\b/)
+  })
+})