clinkx 1.1.1 → 1.2.0

package/docs/verification/dashboard-real-disk.md

@@ -0,0 +1,436 @@
+# Dashboard Real-Disk Check
+
+## Feature
+
+The built dashboard CLI serves persisted workflow history from a real state
+directory. When a run's `state.json` is atomically replaced, the run detail
+and call inspector refresh: the run generation stays the same and the state
+revision changes.
+
+Required test: `actual CLI serves persisted history and refreshes same-generation raw content`
+in `clinkx-workflows/dashboard-ui/e2e/dashboard.real-disk.spec.ts`. The
+Playwright project name is empty.
+
+Claim boundary: this exercises the real dashboard CLI, HTTP API, Chromium, and
+files on disk. The workflow records are fixtures written by
+`e2e/real-disk-server.mjs`. It does not prove provider or workflow-engine
+execution.
+
+## Prerequisites
+
+- An owned checkout with `npm ci` done and Node `>=24`. Acceptance evidence
+  should come from a clean checkout; see [Clean Checkout](#clean-checkout).
+- Chromium for the installed `@playwright/test`: `npx playwright install chromium`.
+- A private evidence root outside the checkout, for example
+  `export EVIDENCE_ROOT="${XDG_STATE_HOME:-$HOME/.local/state}/clinkx-verification"`
+  created with `mkdir -p` and `chmod 700`.
+- `CLINKX_DASHBOARD_REAL_DISK_TEST_CHILD` unset. It is a test-only seam that
+  replaces the dashboard CLI with a stub from `tests/fixtures/`. When it is
+  honored, the fixture writes `real-disk dashboard fixture: TEST CHILD <name>
+  is replacing the real dashboard CLI` to stderr; the check below rejects any
+  `stderr.log` containing `TEST CHILD`.
+
+The preflight below checks each of these, so an unavailable prerequisite is
+reported as `blocked` instead of surfacing as a failed run.
+
+Playwright prefixes every fixture line in `stderr.log` with `[WebServer] `.
+The lines quoted below omit that prefix; the checks match substrings.
+
+## Commands
+
+Run every block from the checkout root. Build once. Invocations below do not
+build.
+
+```bash
+npm run clean && npm run build:all
+```
+
+Create one private attempt directory per attempt and run the preflight into
+it:
+
+```bash
+: "${EVIDENCE_ROOT:?set EVIDENCE_ROOT}"
+RUN="$(mktemp -d "$EVIDENCE_ROOT/real-disk.XXXXXX")"
+chmod 700 "$RUN"
+EVIDENCE_ROOT="$EVIDENCE_ROOT" node clinkx-workflows/dashboard-ui/e2e/real-disk-doctor.mjs preflight \
+  > "$RUN/doctor.jsonl"
+echo "preflight exit=$?"; cat "$RUN/doctor.jsonl"
+```
+
+The preflight prints one JSON line per check, `{check, status, detail}`, then
+`{"verdict":"ready"}` (exit 0) or `{"verdict":"blocked"}` (exit 2). It checks
+the Node major; that `dist` is present and that no sampled source is newer
+than its output: the pairs `scripts/check-dist-fresh.mjs` samples,
+`src/dashboard-cli.ts` against `dist/dashboard-cli.js`, and the newest file
+under `clinkx-workflows/dashboard-ui/src` against
+`clinkx-workflows/dist/dashboard-ui/index.html` (mtime samples, not a full
+freshness proof); that Chromium launches; that the test child is unset; and that `EVIDENCE_ROOT` is a writable `700` directory outside
+the checkout. Only when all of those pass does it check app health: it starts
+`real-disk-server.mjs` with a temporary bootstrap file, waits for readiness,
+fetches the dashboard page and the authenticated `/api/env` over the
+bootstrapped origin (10 s timeout each), then sends `SIGTERM` and requires
+`fixture stopped (ok)` with no bootstrap file or state left behind. A skipped
+app-health check is `not_run`. The token is never printed. Continue only on
+`ready`; the result check below requires it in `$RUN/doctor.jsonl`.
+
+Run one invocation in the attempt directory. The first command records what
+the attempt executes in `$RUN/identity.json`; Playwright runs only if it
+succeeds, so a failed or refused identity step cannot pair an old
+`identity.json` with a new report. `exit.txt` then holds the identity step's
+status, and `classify` reports `not_run`:
+
+```bash
+: "${RUN:?set RUN to an attempt directory}"
+node clinkx-workflows/dashboard-ui/e2e/real-disk-doctor.mjs identity "$RUN" \
+&& CLINKX_DASHBOARD_REAL_DISK_BOOTSTRAP_FILE="$RUN/bootstrap.json" \
+PLAYWRIGHT_JSON_OUTPUT_FILE="$RUN/report.json" \
+PLAYWRIGHT_LAST_RUN_OUTPUT_FILE="$RUN/last-run.json" \
+npm run test:dashboard:e2e:real-disk -- \
+  --output "$RUN/artifacts" \
+  --reporter=line,json \
+  --retries=0 \
+  --forbid-only \
+  > "$RUN/stdout.log" 2> "$RUN/stderr.log"
+echo "exit=$?" > "$RUN/exit.txt"
+```
+
+`identity.json` records Git `HEAD`; whether the worktree is dirty
+(`git status --porcelain=v1 -uall`); the SHA-256 of
+`git diff --binary --no-ext-diff --no-textconv --no-color --src-prefix=a/
+--dst-prefix=b/ --diff-algorithm=myers --no-relative HEAD` and of each
+untracked, non-ignored file (`git ls-files --others --exclude-standard`).
+Every Git command in identity mode runs with `GIT_CONFIG_GLOBAL=/dev/null`
+and `GIT_CONFIG_NOSYSTEM=1`, so global and system Git configuration
+(including a global `core.excludesFile`) is ignored, and the flags pin the
+remaining output.
+Repository-local diff settings in `.git/config` (for example `diff.context`
+or `diff.renames`) can still change the digest. The record also holds
+SHA-256 digests of `dist/dashboard-cli.js`, the served
+`clinkx-workflows/dist/dashboard-ui` tree, and the whole `dist` and
+`clinkx-workflows/dist` trees, plus the Node, `@playwright/test`, platform,
+and architecture versions. It refuses to replace an existing `identity.json`.
+A Git `HEAD` alone does not identify what ran: ignored build output can be
+stale, which is why the built trees are hashed.
+
+Keep `report.json`, `last-run.json`, and `bootstrap.json` beside
+`artifacts/`, never inside it: Playwright empties the `--output` directory at
+startup.
+
+## Checking The Result
+
+Exit status zero is not proof. Require all of the following from the
+attempt directory. The command below checks them and exits nonzero if any
+fails:
+
+- `report.json` exists and parses, with no top-level `errors`.
+- The report's `config.rootDir` is this checkout's
+  `clinkx-workflows/dashboard-ui/e2e`, and its only project is the unnamed
+  one (`name: ""`) that `playwright.real-disk.config.ts` produces.
+- Exactly one test has the required title, spec file exactly
+  `dashboard.real-disk.spec.ts` (relative to `rootDir`), and project name `""`.
+- That test has `expectedStatus: "passed"` and exactly one result with
+  `status: "passed"` and `retry: 0`.
+- The result carries exactly one `real-disk-observation` attachment of type
+  `application/json` whose decoded body has `observation_version: 1`, a
+  loopback `origin`, absolute `state_dir` and `state_dir_realpath`,
+  `run_id: "real_disk_run"`, an unchanged non-empty generation, a changed
+  non-empty revision, and no `#token=`.
+- `identity.json` exists with `identity_version: 1`, a commit `head`, a
+  boolean `dirty`, and a `checkout` equal to this checkout. The command
+  prints `head` and `dirty`. A dirty attempt is not rejected, but it is not
+  acceptance evidence: its source is only identified by digests, not
+  recoverable from a commit.
+- `exit.txt` is `exit=0`.
+- `doctor.jsonl` records `"verdict":"ready"`.
+- Cleanup ran: `$RUN` holds no `bootstrap.json` and no
+  `.bootstrap.json.<pid>.tmp`, and the state root named in `stderr.log`
+  (see Cleanup) no longer exists.
+- `stderr.log` contains `real-disk dashboard fixture stopped (ok)` and does
+  not contain `TEST CHILD`. `(ok)` means the dashboard CLI exited with code 0
+  after the fixture requested the stop; a signal death or nonzero code is
+  `stopped (failed: ...)`. Playwright ignores the web server's exit status at
+  teardown, so a fixture shutdown failure shows up only in this line, not in
+  the exit status or the report.
+
+Run the command from the checkout root; it compares `rootDir` with the
+physical working directory (`pwd -P`), so a symlinked path to the checkout,
+such as `/tmp` on macOS, does not fail the check.
+
+```bash
+node -e '
+const { readFileSync, realpathSync } = require("node:fs");
+const { isAbsolute, join } = require("node:path");
+const [reportPath, checkout, identityPath] = process.argv.slice(1);
+const r = JSON.parse(readFileSync(reportPath, "utf8"));
+const title = "actual CLI serves persisted history and refreshes same-generation raw content";
+const tests = [];
+const walk = (s) => {
+  for (const sp of s.specs ?? []) if (sp.title === title && sp.file === "dashboard.real-disk.spec.ts") tests.push(...sp.tests);
+  for (const c of s.suites ?? []) walk(c);
+};
+(r.suites ?? []).forEach(walk);
+const res = tests[0]?.results ?? [];
+const att = (res[0]?.attachments ?? []).filter((a) => a.name === "real-disk-observation");
+let obs;
+try { obs = JSON.parse(Buffer.from(att[0]?.body ?? "", "base64").toString("utf8")); } catch {}
+let id;
+try { id = JSON.parse(readFileSync(identityPath, "utf8")); } catch {}
+console.log(`identity head=${id?.git?.head} dirty=${id?.git?.dirty}`);
+const text = (v) => typeof v === "string" && v !== "";
+const t = obs?.transition;
+const ok = (r.errors ?? []).length === 0
+  && r.config?.rootDir === join(checkout, "clinkx-workflows", "dashboard-ui", "e2e")
+  && r.config.projects?.length === 1 && r.config.projects[0].name === ""
+  && tests.length === 1 && tests[0].projectName === "" && tests[0].expectedStatus === "passed"
+  && res.length === 1 && res[0].status === "passed" && res[0].retry === 0
+  && att.length === 1 && att[0].contentType === "application/json"
+  && obs?.observation_version === 1
+  && /^http:\/\/127\.0\.0\.1:[0-9]{1,5}$/.test(obs.origin)
+  && text(obs.state_dir) && isAbsolute(obs.state_dir)
+  && text(obs.state_dir_realpath) && isAbsolute(obs.state_dir_realpath)
+  && obs.run_id === "real_disk_run"
+  && text(t?.generation_before) && t.generation_after === t.generation_before
+  && text(t.revision_before) && text(t.revision_after) && t.revision_after !== t.revision_before
+  && !JSON.stringify(obs).includes("#token=")
+  && id?.identity_version === 1 && /^[0-9a-f]{40}([0-9a-f]{24})?$/.test(id.git?.head ?? "")
+  && typeof id.git.dirty === "boolean" && id.checkout === realpathSync(checkout);
+console.log(ok ? "report check passed" : "report check NOT proved");
+process.exit(ok ? 0 : 1);
+' "$RUN/report.json" "$(pwd -P)" "$RUN/identity.json" \
+&& grep -q "real-disk dashboard fixture stopped (ok)" "$RUN/stderr.log" \
+&& ! grep -q "TEST CHILD" "$RUN/stderr.log" \
+&& grep -qx "exit=0" "$RUN/exit.txt" \
+&& grep -q '"verdict":"ready"' "$RUN/doctor.jsonl" \
+&& [ -z "$(find "$RUN" -maxdepth 1 \( -name bootstrap.json -o -name '.bootstrap.json.*.tmp' \) -print)" ] \
+&& STATE_DIR="$(sed -n 's/^.*real-disk dashboard fixture state: //p' "$RUN/stderr.log")" \
+&& [ -n "$STATE_DIR" ] && [ ! -e "$(dirname "$STATE_DIR")" ]
+```
+
+## Classifying A Failed Attempt
+
+When the check above does not pass, classify the attempt before repairing
+anything:
+
+```bash
+node clinkx-workflows/dashboard-ui/e2e/real-disk-doctor.mjs classify "$RUN"
+```
+
+It prints exactly one outcome on stdout and one token-free detail line on
+stderr. The first matching rule wins:
+
+| Outcome | Rule | Exit |
+| --- | --- | --- |
+| `not_run` | `doctor.jsonl` is missing. | 2 |
+| `blocked` | `doctor.jsonl` has no `"verdict":"ready"` line (blocked, or the preflight did not finish). | 2 |
+| `not_run` | `identity.json` is missing. | 2 |
+| `blocked` | `stderr.log` contains `TEST CHILD`. | 2 |
+| `failed_fixture` | `stderr.log` contains `fixture stopped (failed: ...)`. | 1 |
+| `not_run` | `exit.txt` or `report.json` is missing, or `report.json` does not parse. | 2 |
+| `harness_drift` | The required test failed and an error matches `strict mode violation`, `element(s) not found`, or a `locator.<action>: ... timeout ... exceeded`. | 1 |
+| `failed_assertion` | The required test failed with any other error, such as an `expect` mismatch on a resolved element. | 1 |
+| `not_run` | The required test was `skipped` or `interrupted`, or `exit.txt` is `exit=130`. | 2 |
+| `failed_fixture` | The report has top-level errors. | 1 |
+| `not_run` | The report holds no result for the required test. | 2 |
+| `failed_fixture` | Nonzero exit, or no `fixture stopped (ok)` line, without a test failure. | 1 |
+| `passed` | Otherwise: one passing result, `exit=0`, `fixture stopped (ok)`. | 0 |
+
+These heuristics match Playwright 1.61 message text and only triage.
+`harness_drift` corresponds to the *Documentation drift* class in
+[README.md](README.md#maintaining-the-feature-map): the procedure or its
+selectors did not follow an intended product change. A missing element is
+`harness_drift` even when the product stopped rendering it, which is a
+*Product regression*, so confirm against the trace before choosing the repair
+class. `passed` does not replace the result check above.
+
+## Assertions
+
+The test keeps the intent of every assertion it had before the observation
+was added. Selectors and labels follow the redesigned run detail and history
+lane (`e8e9116`). One check could no longer be observed and was dropped: the
+history lane used to show the page number (`[ all 2 · page 2 ]`, then
+`[ all 100 · page 1 ]`). The redesign renders only the count of loaded rows,
+`[ history N ]`, and no component renders a page number, so the spec now
+asserts `[ history 2 ]` and `[ history 100 ]`. Paging is still covered by
+which rows each page shows: the older page has 2 rows including
+`real_disk_history_100`, and the newer page has 100 rows including the
+selected run.
+
+- The bootstrap `#token=` fragment is removed from the URL and the
+  `Run monitor` heading renders.
+- The selected run `real-disk-qa` shows its persisted prompt and final output
+  in the call inspector, in both the formatted and `Raw` tabs.
+- After an atomic `state.json` replacement, the title becomes
+  `real-disk-qa-revised`, the generation is unchanged, the revision changes,
+  and the inspector shows only the replaced output.
+- `[ older ]` shows `[ history 2 ]` with `real_disk_history_100`; `[ newer ]`
+  returns to `[ history 100 ]` with the selected run.
+- Authenticated `GET /api/env` reports the fixture's state directory.
+- No console or page errors occur.
+
+Only after all of these pass does the test attach `real-disk-observation`:
+origin, state directory (and its realpath), run id, and the
+generation/revision values before and after. It never contains the bearer
+token or the bootstrap URL.
+
+## Evidence
+
+Retain per attempt: `doctor.jsonl`, `identity.json`, `exit.txt`,
+`stdout.log`, `stderr.log`, `report.json`, `last-run.json`, and `artifacts/`
+(traces on failure).
+
+`EVIDENCE_ROOT` is owned by whoever runs the procedure. Retain an attempt
+directory until the exact state it proves has been accepted and integrated,
+or rejected; the procedure never prunes, so removing it is that owner's
+decision. Attempt directories can hold Playwright traces with page content
+and request data: keep them private (`700`) and share only checked,
+token-free summaries.
+
+## Clean Checkout
+
+Optional but recommended for acceptance evidence: run the procedure from a
+detached worktree of the exact revision under review, so uncommitted files
+and stale build output in your working checkout cannot leak into the result.
+Run from your normal checkout root:
+
+```bash
+: "${EVIDENCE_ROOT:?set EVIDENCE_ROOT}"
+REV="$(git rev-parse HEAD)"
+git worktree add --detach "$EVIDENCE_ROOT/checkout" "$REV"
+cd "$EVIDENCE_ROOT/checkout"
+npm ci && npm --prefix clinkx-workflows ci && npm run build:all
+```
+
+Then follow [Commands](#commands) from the attempt-directory step and
+[Checking The Result](#checking-the-result) with `$PWD` still at
+`$EVIDENCE_ROOT/checkout`. The checker must print `dirty=false`. Afterwards
+return to your normal checkout and remove the worktree; the attempt
+directories stay in `EVIDENCE_ROOT`:
+
+```bash
+cd - && git worktree remove "$EVIDENCE_ROOT/checkout"
+```
+
+Ignored `node_modules` and build output do not block the removal. If it
+refuses, something left untracked or modified files in the worktree; inspect
+them before forcing.
+
+## Checking Overlap
+
+To show two checks ran concurrently, save the invocation block above as
+`$EVIDENCE_ROOT/real-disk-run.sh` and run it in two attempt directories at
+once. Run the preflight into each directory first, as above:
+
+```bash
+: "${EVIDENCE_ROOT:?set EVIDENCE_ROOT}"
+RUN_A="$(mktemp -d "$EVIDENCE_ROOT/real-disk.XXXXXX")"
+RUN_B="$(mktemp -d "$EVIDENCE_ROOT/real-disk.XXXXXX")"
+chmod 700 "$RUN_A" "$RUN_B"
+if ! EVIDENCE_ROOT="$EVIDENCE_ROOT" node clinkx-workflows/dashboard-ui/e2e/real-disk-doctor.mjs preflight \
+     > "$RUN_A/doctor.jsonl"; then
+  echo "preflight blocked; see $RUN_A/doctor.jsonl"
+elif ! EVIDENCE_ROOT="$EVIDENCE_ROOT" node clinkx-workflows/dashboard-ui/e2e/real-disk-doctor.mjs preflight \
+     > "$RUN_B/doctor.jsonl"; then
+  echo "preflight blocked; see $RUN_B/doctor.jsonl"
+else
+  RUN="$RUN_A" bash "$EVIDENCE_ROOT/real-disk-run.sh" &
+  RUN="$RUN_B" bash "$EVIDENCE_ROOT/real-disk-run.sh" &
+  wait
+fi
+```
+
+Each `RUN` must hold its own intact results: run the result check above once
+with `RUN="$RUN_A"` and once with `RUN="$RUN_B"`. Then, from each
+`report.json`, take the required result's `startTime` and `duration`, compute
+`end = start + duration`, and require `max(startA, startB) < min(endA, endB)`.
+Launching both processes together is not enough. Also require distinct
+`origin` and `state_dir` values in the two observations. The command below
+checks both:
+
+```bash
+node -e '
+const { readFileSync } = require("node:fs");
+const title = "actual CLI serves persisted history and refreshes same-generation raw content";
+const read = (path) => {
+  const found = [];
+  const walk = (s) => {
+    for (const sp of s.specs ?? []) if (sp.title === title) found.push(...sp.tests.flatMap((t) => t.results));
+    for (const c of s.suites ?? []) walk(c);
+  };
+  (JSON.parse(readFileSync(path, "utf8")).suites ?? []).forEach(walk);
+  if (found.length !== 1) throw new Error(`${path}: expected one result, got ${found.length}`);
+  const att = (found[0].attachments ?? []).filter((a) => a.name === "real-disk-observation");
+  if (att.length !== 1) throw new Error(`${path}: expected one observation, got ${att.length}`);
+  const obs = JSON.parse(Buffer.from(att[0].body, "base64").toString("utf8"));
+  const start = Date.parse(found[0].startTime);
+  return { start, end: start + found[0].duration, origin: obs.origin, stateDir: obs.state_dir, stateDirReal: obs.state_dir_realpath };
+};
+const [a, b] = process.argv.slice(1).map(read);
+const overlap = Math.min(a.end, b.end) - Math.max(a.start, b.start);
+const distinct = a.origin !== b.origin && a.stateDir !== b.stateDir && a.stateDirReal !== b.stateDirReal;
+console.log(`overlap_ms=${overlap} distinct_origin_and_state_dir=${distinct}`);
+process.exit(overlap > 0 && distinct ? 0 : 1);
+' "$RUN_A/report.json" "$RUN_B/report.json"
+```
+
+## Cleanup
+
+Cleanup is automatic. The Playwright config sets
+`webServer.gracefulShutdown: { signal: "SIGTERM", timeout: 10_000 }`, so at
+teardown the fixture stops the dashboard CLI, waits for it to exit, then
+deletes its temporary state and `$RUN/bootstrap.json`. A clean run logs
+`real-disk dashboard fixture stopped (ok)` in `stderr.log` and leaves no
+`bootstrap.json` in `$RUN`. Any other `stopped (failed: ...)` line names the
+first failure. The fixture also cleans up when it fails on its own (spawn
+error, bootstrap publication failure, premature dashboard exit). Its lifecycle
+is covered by `npx vitest run tests/dashboard-real-disk-fixture.test.ts`, and
+the doctor by `npx vitest run tests/dashboard-real-disk-doctor.test.ts`. Chromium
+preflight creates an owned root for its profile and artifacts and removes only
+that root, including after a failed launch. Other Playwright runs' temporary
+directories are preserved and the caller's `TMPDIR` is unchanged. The app-health
+preflight removes its own temporary bootstrap directory and fixture state,
+and always sends `SIGKILL` to the fixture's process group afterwards. If the
+preflight itself receives `SIGINT` or `SIGTERM` during app health, it sends
+`SIGTERM` to that group, escalates to `SIGKILL` after 5 s, removes the same
+files, and exits 130 or 143 without a verdict line, so `classify` reports
+`blocked`. A repeated `SIGINT` or `SIGTERM` during that cleanup is ignored,
+so the cleanup still finishes.
+
+If the runner itself is killed (for example `SIGKILL`, or the 10 s grace
+expires), cleanup may not run. Then delete `$RUN/bootstrap.json`, which holds
+the bearer token for the stopped dashboard, and the state root printed in
+`stderr.log` as `[WebServer] real-disk dashboard fixture state: <dir>/state`
+(drop the `[WebServer] ` prefix and remove `<dir>`, a
+`clinkx-dashboard-real-disk-*` directory under the OS temp directory).
+
+## Limitations
+
+- A bare `npm run test:dashboard:e2e:real-disk` still writes artifacts to the
+  fixed `/tmp/clinkx-dashboard-real-disk-playwright-results` directory and
+  emits no JSON report. Concurrent bare runs share and wipe that directory.
+  Callers must pass the options above and check that `report.json` exists.
+- Playwright sends the shutdown `SIGTERM` to the whole process group, so the
+  dashboard CLI receives it directly and again from the fixture a fraction of
+  a millisecond later. That is safe because the CLI's `SIGTERM` handling is
+  idempotent: a repeat during or just after shutdown is ignored, and the CLI
+  exits explicitly once its listeners close (exit 1 if closing fails). Here a
+  hung close surfaces as the fixture's failed stop (5 s grace, then
+  `SIGKILL`); the CLI's own 8 s forced exit applies only when it runs
+  standalone, for example under Docker. The fixture counts a stop as clean
+  only when the CLI exits with code 0 after the fixture requested it. It also
+  treats the child's exit as requested only after its own `SIGTERM` handler
+  has run and it has signaled the child. If the CLI exited before the
+  fixture's own `SIGTERM` handler had signaled it, the fixture would log
+  `dashboard CLI exited unexpectedly` and `stopped (failed: ...)`; that
+  ordering can only cause a false failure, not a false pass. After the CLI's
+  explicit `process.exit`, a microsecond window remains in which a late
+  `SIGTERM` kills it by signal; the fixture reports that as a failed stop,
+  never `(ok)`. Because Playwright ignores the fixture's exit status, the
+  `stopped (ok)` check above is what turns any of these cases into a failed
+  check. `npx vitest run tests/dashboard-real-disk-fixture.test.ts` includes
+  a process-group `SIGTERM` test against the real built CLI.
+- `identity.json` is written before the run and records dependencies only by
+  the Node and `@playwright/test` versions, not a `node_modules` digest. It
+  does not detect a rebuild or edit made while the attempt runs; build once
+  and do not touch the checkout until the attempt finishes.
+- Retained evidence is identified by hashes only. This is a trusted local
+  execution model, not an attestation.

package/docs/verification/project-checks.example.json

@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "inputs": ["tests/unit.test.mjs"],
+  "checks": [
+    {
+      "id": "unit-tests",
+      "command": "node",
+      "args": ["--test", "tests/unit.test.mjs"],
+      "cwd": ".",
+      "timeout_seconds": 300,
+      "env_allowlist": []
+    }
+  ]
+}