@avi2dg/checks 0.70.0 → 0.71.0

package/docs/gates/checks-whole-tree-run.md

@@ -0,0 +1,281 @@
+---
+kind: reference
+audience: consumers
+---
+# checks-whole-tree-run
+
+`checks-whole-tree-run` turns each finding of a whole-tree run on `main` into a GitHub issue.
+A finding is a file whose mutation score fell, a failing test, a failed whole-tree gate or a missing mutation report.
+It closes the issue of a test, gate or missing mutation report that a later run no longer reports, and it comments on a mutation issue it no longer reports without closing it, but only when a previous run exists and every requested mutation report is present.
+
+## What it checks
+
+It scores each file of this run's Stryker reports as Stryker does, the `Killed` and `Timeout` mutants over every mutant but the `Ignored`, `CompileError`, `RuntimeError` and `Pending` ones.
+It compares each file's score with the same file's score from the previous run.
+A file whose score is lower than the previous run's is a finding.
+A file only one run holds is no finding, since it lacks one of the two scores.
+A file with no scored mutant has no score, so it is no finding either.
+An equal score is no finding, even when it counts other mutants.
+Each failing test in a JUnit report is a finding, whatever the previous run holds.
+Each whole-tree gate the lint log names as failed is a finding.
+A log where every named gate is undecided files `checks-lint` itself, with no per-gate issue.
+A log with no passing run and no named gate files `checks-lint` itself, so a gate run that never finished still reaches an issue.
+A file whose test worker crashed is one finding, since Bun reports none of its tests.
+With no previous run it compares no score and still files each failing test.
+Each mutation report `--mutation` names that does not exist is a finding, since the mutation job that writes it failed, timed out or was cancelled.
+With no mutation report it compares and records no score and still files each failing test.
+With some mutation reports missing it compares the files the others hold and records no score.
+The next run then compares every file with the last run that scored them all.
+
+Each finding has a key that stays the same from run to run:
+
+| Finding | Key |
+| --- | --- |
+| a file whose mutation score fell | `mutation:<file>` |
+| a failing test | `test:<file> > <describe> > <name>` |
+| a file whose test worker crashed | `test:<file>` |
+| a whole-tree gate that failed | `gates:<gate>` |
+| a missing mutation report | `mutation-report:<path>` |
+
+## How it files a finding
+
+It creates the `whole-tree-run` label when the repository lacks it.
+It reads every open issue labelled `whole-tree-run`, and reads the key each one carries in a hidden marker in its body.
+A finding whose key an open issue carries gets one comment on that issue, so a regression that lasts two runs stays one issue.
+Any other finding opens one issue labelled `whole-tree-run`.
+The issue and the comment name this run, the file and the test, the score of both runs or the failed gate.
+The body holds the file, the full test name or the failed gate, and the finding key.
+A title longer than GitHub's 256 characters is cut to at most 256 and ends in `…`.
+A run with no finding creates no label and writes no issue, and only reads the open issues to close any test, gate or mutation-report issue whose finding is gone and, when a previous run exists and every requested mutation report is present, to comment on any mutation issue whose finding is gone.
+Closing an issue ends it, and the same finding on a later run opens a new one.
+
+## How it closes an issue
+
+An open test, gate or mutation-report issue whose key this run's findings lack gets one comment naming this run and the key.
+It then closes as completed.
+When a previous run exists and every requested mutation report is present, an open mutation issue whose key this run's findings lack gets one comment that names this run and the key, and stays open.
+A closed issue is no longer read, so a later run without the finding comments on it no more.
+A comment that reports the finding carries a reported marker, and a note that a mutation finding is gone carries a noted marker.
+A mutation issue whose latest marked comment already notes the finding gone gets no further note.
+So a mutation finding gone for many runs is noted once, and noted again only after a later run reports it again.
+A person's comment carries no marker, so it never makes the run note an issue twice.
+It judges a key only from a report it read this run:
+
+| Key | Closes when |
+| --- | --- |
+| `test:<file> > <describe> > <name>` | this run read a JUnit report, the test is not failing, and `<file>`'s worker did not crash |
+| `test:<file>` | this run read a JUnit report and `<file>`'s worker did not crash |
+| `gates:<gate>` | this run read a lint log that passes or names its failed gates, and `<gate>` is not among them |
+| `mutation-report:<path>` | this run read the mutation report at `<path>` |
+| `mutation:<file>` | never |
+
+A crashed worker loses every result of its file, so the issue of a test in that file stays open.
+A lint log that is undecided or never finished says nothing of any one gate, so every gate issue stays open.
+A mutation finding is a fall from one run to the next.
+A later run that does not fall again still holds the lower score.
+Only a run that compared scores with every requested mutation report present comments on the mutation issue without closing it, since a score can recover and drop again.
+So a person closes a mutation issue once the score is back.
+An issue with no key in its body is never read, so a person's issue under the `whole-tree-run` label is never commented on or closed.
+A run off `main` comments on and closes no issue.
+Agents and people fix each issue as a task of its own, so no pull request waits for a whole-tree run.
+A run on any ref but `refs/heads/main` files no issue and records no score, and lists each finding in its log only.
+
+## What it reads
+
+It reads this run's Stryker `mutation.json` reports and any number of JUnit reports, such as the ones `checks-test --junit=<file>` keeps, as [checks-test](checks-test.md#arguments) says.
+It reads the lint log `--gates` names for the `gate(s) failed:` line `checks-lint --whole-tree` prints.
+It scans the newest 30 successful runs of the same workflow on `main` from newest to oldest.
+It takes the first run whose `whole-tree-run` artifact still exists as the previous run.
+That artifact holds `whole-tree-run.json`, the scores the run recorded.
+When no scanned run holds the artifact it compares no score.
+A run on another branch never becomes the previous run.
+On `main` with every mutation report present it writes this run's scores to `reports/whole-tree-run.json`, and the workflow uploads that file as the `whole-tree-run` artifact.
+It reads the run from `GITHUB_SERVER_URL`, `GITHUB_REPOSITORY`, `GITHUB_RUN_ID`, `GITHUB_WORKFLOW_REF` and `GITHUB_REF`, so it runs only inside a GitHub Actions job.
+It calls `gh` with the job's `GH_TOKEN`, which needs `actions: read` for the previous run and `issues: write` for the issues.
+
+## Arguments
+
+```sh
+checks-whole-tree-run [--mutation <mutation-report>]... [--tests <junit-report>]... [--gates <lint-log>]
+```
+
+`--mutation` names one of this run's Stryker reports and is given once per report the workflow's mutation jobs write, whether or not each job wrote it.
+`--tests` names one JUnit report and is given once per report.
+`--gates` names this run's `checks-lint --whole-tree` log and is given at most once.
+At least one report is given.
+
+## Exit codes
+
+| Code | When |
+| --- | --- |
+| 0 | it filed every finding, closed each issue whose finding is gone and recorded this run's scores, it found nothing to file, or the run is off `main` and it listed each finding |
+| 2 | an argument does not parse, a report or the lint log does not decode, a GitHub Actions variable is unset or a `gh` call fails |
+
+It never exits 1, because a finding becomes an issue rather than a failed run.
+
+## Sample output
+
+```
+checks-whole-tree-run: the whole-tree run https://github.com/acme/widget/actions/runs/12 compared with the whole-tree run https://github.com/acme/widget/actions/runs/11; 2 finding(s)
+  opened #31 for mutation:src/cart.ts
+  commented on #27 for test:tests/unit/cart.test.ts > totals > rounds half to even
+  closed #24 for gates:checks-repetition
+checks-whole-tree-run: recorded 42 file score(s) in reports/whole-tree-run.json
+```
+
+## When it runs
+
+Only a whole-tree workflow the repository writes runs it, after that workflow's full mutation run, its long test tiers and its whole-tree lint gates.
+
+## Coverage that stops running
+
+Neither release nor CI runs a full mutation run, the four whole-tree gates or the issue filing in any repository below.
+Each answer comes from the workflows under `.github/workflows` of that repository.
+
+- checks keeps none of the three on a workflow.
+  Mutation testing runs only by hand through the mutation workflow baseline.
+  The four whole-tree gates run only by hand through `checks-lint --whole-tree`.
+  Nothing files issues until someone adds a `whole-tree-run` workflow.
+- skills runs all three by hand through its `night-run` workflow.
+  That workflow runs a full Stryker mutation run, the four gates and the unit and e2e tiers with issue filing.
+- dotfiles runs mutation testing on pull requests as an advisory scoped compare, and the full baseline by hand, both through `mutation.yml`.
+  The four gates run only by hand through its `night-run` workflow.
+  Nothing files issues.
+- career runs the four gates only by hand through its `night-run` workflow.
+  No mutation testing and no issue filing run anywhere.
+- home-vpn runs the four gates only by hand through its `night-run` workflow.
+  No mutation testing and no issue filing run anywhere.
+- orc runs mutation testing only by hand through its mutation workflow baseline.
+  The four gates run only by hand through its `night-run` workflow.
+  Nothing files issues.
+- shopping runs the four gates only by hand through its `night-run` workflow.
+  No mutation testing and no issue filing run anywhere.
+
+## Running it by hand
+
+A repository runs it from a workflow named `whole-tree-run`, which someone starts with `gh workflow run whole-tree-run`.
+The workflow holds no schedule, since [checks-ci-wiring](checks-ci-wiring.md#schedules) refuses one:
+
+```yaml
+name: whole-tree-run
+on:
+  workflow_dispatch:
+permissions:
+  contents: read
+concurrency:
+  group: whole-tree-run
+  cancel-in-progress: false
+jobs:
+  mutation:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: .bun-version
+      - run: bun install --frozen-lockfile
+      - run: bunx stryker run
+      - uses: actions/upload-artifact@v4
+        with:
+          name: whole-tree-run-mutation
+          path: reports/mutation/mutation.json
+          retention-days: 1
+  tests:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: .bun-version
+      - run: bun install --frozen-lockfile
+      - run: |
+          bunx checks-test --tier=live --junit=reports/whole-tree-run-tests/live.xml || true
+          bunx checks-test --tier=pixel --junit=reports/whole-tree-run-tests/pixel.xml || true
+      - uses: actions/upload-artifact@v4
+        with:
+          name: whole-tree-run-tests
+          path: reports/whole-tree-run-tests/
+          retention-days: 1
+  gates:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: .bun-version
+      - run: bun install --frozen-lockfile
+      - run: mkdir -p reports/whole-tree-run-gates && bunx checks-lint --whole-tree > reports/whole-tree-run-gates/gates.log 2>&1 || true
+      - uses: actions/upload-artifact@v4
+        with:
+          name: whole-tree-run-gates
+          path: reports/whole-tree-run-gates/
+          retention-days: 1
+  report:
+    needs: [mutation, gates, tests]
+    if: ${{ !cancelled() && needs.tests.result == 'success' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: read
+      actions: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v5
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version-file: .bun-version
+      - run: bun install --frozen-lockfile
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: whole-tree-run-mutation
+          path: reports/mutation
+      - if: needs.gates.result == 'success'
+        uses: actions/download-artifact@v4
+        with:
+          name: whole-tree-run-gates
+          path: reports/whole-tree-run-gates
+      - uses: actions/download-artifact@v4
+        with:
+          name: whole-tree-run-tests
+          path: reports/whole-tree-run-tests
+      - env:
+          GH_TOKEN: ${{ github.token }}
+        run: bunx checks-whole-tree-run --mutation reports/mutation/whole-tree-run-mutation/mutation.json --tests reports/whole-tree-run-tests/live.xml --tests reports/whole-tree-run-tests/pixel.xml ${{ needs.gates.result == 'success' && '--gates reports/whole-tree-run-gates/gates.log' || '' }}
+      - uses: actions/upload-artifact@v4
+        with:
+          name: whole-tree-run
+          path: reports/whole-tree-run.json
+          if-no-files-found: ignore
+          retention-days: 90
+```
+
+The tests job runs each long tier the repository holds, `live` and `pixel` as [checks-test](checks-test.md#test-tiers) names them, and keeps each JUnit report.
+Each `|| true` lets the job go on to the upload after a failing test, since that test becomes an issue.
+A tier that writes no report fails the report job, because `checks-whole-tree-run` cannot read it.
+The gates job runs the whole-tree lint gates and keeps the log, since a failing gate becomes an issue.
+The report job runs whenever the tests job succeeds, so a failing test that also stops Stryker still becomes an issue.
+It always passes `--mutation`, so a mutation job that failed or timed out leaves a missing report that becomes an issue.
+The download names the artifact by `pattern`, which downloads nothing rather than failing when the artifact is missing.
+A full run too long for one job splits into a matrix of shards.
+Each shard uploads its own artifact under the one pattern, and each report gets its own `--mutation`.
+It passes `--gates` only when the gates job succeeded, and the failed gates job still fails the run.
+The concurrency group queues a run behind one already going, so two runs never file the same finding twice.
+A dispatch on a branch runs both jobs and lists its findings in the report job's log, and `if-no-files-found: ignore` lets that run upload no record.
+`issues: write` on the report job is the one permission beyond reading the repository and its runs.
+A public repository keeps `runs-on: ubuntu-latest` on every job.
+A private repository sets `runs-on` on the mutation job to the labels declared under `checks.mutationRunner` in `package.json`, and [checks-ci-wiring](checks-ci-wiring.md#runners) refuses a mutation job that names `CI_RUNS_ON`.
+A private repository sets `runs-on: ${{ vars.CI_RUNS_ON || 'ubuntu-latest' }}` on the tests, gates, and report jobs.
+A successful run with every mutation report present uploads `whole-tree-run`, so the next run compares with it, and a run that failed or missed a report uploads nothing a later run reads.
+The artifact keeps 90 days, so a gap of runs still leaves a previous run to compare with.
+
+## Related topics
+
+- [checks-test](checks-test.md)
+- [checks-mutation](checks-mutation.md)
+- [checks-mutation-compare](checks-mutation-compare.md)
+- [checks-ci-wiring](checks-ci-wiring.md)

package/docs/how-to/set-up-a-repository.md

@@ -147,10 +147,10 @@ The same job reports the title step's outcome under that name on every run, whic
    ```
 
 A private repository sets `runs-on: ${{ vars.CI_RUNS_ON || 'ubuntu-latest' }}` on each job, as [checks-ci-wiring](../gates/checks-ci-wiring.md#runners) requires.
-Run the four nightly gates from a night-run workflow once the repository tracks TypeScript:
+To run the four whole-tree gates on demand, a repository adds a whole-tree-run workflow:
 
    ```yaml
-   name: night-run
+   name: whole-tree-run
    on:
      workflow_dispatch:
    jobs:
@@ -165,7 +165,7 @@ Run the four nightly gates from a night-run workflow once the repository tracks
            with:
              bun-version-file: .bun-version
          - run: bun install --frozen-lockfile
-         - run: bunx checks-lint --night
+         - run: bunx checks-lint --whole-tree
    ```
 
 `checks-effect-scope` writes the Effect paths of `oxlint.config.ts` and the kit's severities into `tsconfig.json`, as [The Effect rules](../configs/effect-rules.md#language-service) says.

package/docs/how-to/upgrade-the-kit.md

@@ -31,8 +31,11 @@ To move a repository to a newer release of the kit:
 1. Run `bun run build`, whose `checks-effect-scope` rewrites the Effect override and the kit's severities in `tsconfig.json` when a release changes them.
    A severity key the release drops stays in `tsconfig.json` until the repository removes it.
 1. Copy `node_modules/@avi2dg/checks/bunfig.toml` over `bunfig.toml` again, since `checks-test-layout` compares the copy with the installed preset.
-1. When the repository tracks TypeScript, add a night-run workflow with a run step that invokes `checks-lint --night`, as [Set up a repository](set-up-a-repository.md) shows, or add that step to the workflow that already runs nightly.
-   Only that step runs the four nightly gates.
+1. When the repository still holds the workflow the previous kit wrote for the whole-tree gates, delete that workflow.
+   Run the gates with `checks-lint --whole-tree` instead.
+   [Set up a repository](set-up-a-repository.md) and [checks-whole-tree-run](../gates/checks-whole-tree-run.md#running-it-by-hand) show the current names.
+1. A stale workflow left behind still passes `checks-ci-wiring`, but dispatching it fails, so delete it before dispatching it.
+1. The release notes hold the old-to-new name mapping for the workflow, label, artifacts and report file.
 1. Run `bun run lint`, `bun run typecheck` and `bun run test`.
 
 The repository's lockfile pins the kit, so a repository moves only when it runs these steps.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avi2dg/checks",
-  "version": "0.70.0",
+  "version": "0.71.0",
   "description": "Deterministic checks shared across a set of TypeScript repositories",
   "author": {
     "name": "avi2d",
@@ -71,10 +71,9 @@
     "src/testing/mutation-baseline-full.ts",
     "src/testing/mutation-baseline-saved.ts",
     "src/testing/subsumed-tests.ts",
-    "src/testing/night-run.ts",
-    "src/testing/night-run-findings.ts",
+    "src/testing/whole-tree-run.ts",
+    "src/testing/whole-tree-run-findings.ts",
     "src/delivery/ci-wiring.ts",
-    "src/delivery/night-step.ts",
     "src/delivery/shell-command.ts",
     "src/delivery/workflow-references.ts",
     "src/delivery/bun-pin.ts",
@@ -195,7 +194,7 @@
     "checks-mutation-baseline": "src/testing/mutation-baseline.ts",
     "checks-mutation-scope": "src/testing/mutation-scope.ts",
     "checks-subsumed-tests": "src/testing/subsumed-tests.ts",
-    "checks-night-run": "src/testing/night-run.ts",
+    "checks-whole-tree-run": "src/testing/whole-tree-run.ts",
     "checks-ci-wiring": "src/delivery/ci-wiring.ts",
     "checks-comment-gate": "src/quality/comment-gate.ts",
     "checks-css-size": "src/quality/css-size.ts",

package/src/core/gates.ts

@@ -26,7 +26,7 @@ export type KitGate = {
   readonly args?: readonly string[];
   readonly env?: Readonly<Record<string, string>>;
   readonly appliesTo: typeof EVERY_REPOSITORY | TrackedContent;
-  readonly night?: true;
+  readonly wholeTree?: true;
 };
 
 export const ENTRY_POINT: Program = { bin: "checks-lint", script: "core/lint.ts" };
@@ -52,7 +52,7 @@ const COPY_DECLARATION: TrackedContent = { pathspecs: ["copy.json"], content: "a
 export const WHOLE_TREE = "--whole-tree";
 
 export const KIT_GATES = [
-  { bin: "checks-lint-coverage", vector: "quality", file: "lint-coverage.sh", reads: "tree", appliesTo: LINTED_SOURCE, night: true },
+  { bin: "checks-lint-coverage", vector: "quality", file: "lint-coverage.sh", reads: "tree", appliesTo: LINTED_SOURCE, wholeTree: true },
   { bin: "checks-test-layout", vector: "testing", file: "test-layout.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-commit-identity", vector: "delivery", file: "commit-identity.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-comment-gate", vector: "quality", file: "comment-gate.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
@@ -60,14 +60,14 @@ export const KIT_GATES = [
   { bin: "checks-frontend-syntax", vector: "quality", file: "frontend-syntax.ts", reads: "tree", appliesTo: FRONTEND_SYNTAX_DECLARATION },
   { bin: "checks-css-size", vector: "quality", file: "css-size.ts", reads: "tree", appliesTo: STYLESHEET },
   { bin: "checks-no-plain-js", vector: "quality", file: "no-plain-js.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-suppressions-ratchet", vector: "complexity", file: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY, night: true },
+  { bin: "checks-suppressions-ratchet", vector: "complexity", file: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY, wholeTree: true },
   { bin: "checks-ci-wiring", vector: "delivery", file: "ci-wiring.ts", reads: "tree", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-secrets", vector: "delivery", file: "secrets.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-docs", vector: "docs", file: "docs.ts", reads: "range", alsoReads: "every agent file at the head commit", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-copy", vector: "docs", file: "copy.ts", reads: "tree", appliesTo: COPY_DECLARATION },
-  { bin: "checks-repetition", vector: "complexity", file: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE, night: true },
+  { bin: "checks-repetition", vector: "complexity", file: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE, wholeTree: true },
   { bin: "checks-graphwalk", vector: "complexity", file: "graphwalk.ts", reads: "range", appliesTo: LINTED_SOURCE },
-  { bin: "checks-quarantine-clock", vector: "testing", file: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY, night: true },
+  { bin: "checks-quarantine-clock", vector: "testing", file: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY, wholeTree: true },
   {
     bin: "checks-advisories",
     vector: "dependencies",
@@ -78,6 +78,6 @@ export const KIT_GATES = [
   }
 ] as const satisfies readonly KitGate[];
 
-export const NIGHT_GATES: readonly KitGate[] = KIT_GATES.filter((gate) => "night" in gate);
+export const WHOLE_TREE_GATES: readonly KitGate[] = KIT_GATES.filter((gate) => "wholeTree" in gate);
 
-export const PR_GATES: readonly KitGate[] = KIT_GATES.filter((gate) => !("night" in gate));
+export const PR_GATES: readonly KitGate[] = KIT_GATES.filter((gate) => !("wholeTree" in gate));

package/src/core/lint.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
-import { EVERY_REPOSITORY, NIGHT_GATES, PR_GATES, WHOLE_TREE, type KitGate } from "./gates.ts";
+import { EVERY_REPOSITORY, PR_GATES, WHOLE_TREE, WHOLE_TREE_GATES, type KitGate } from "./gates.ts";
 import { changedPaths, defaultBranch, git, pathsOf } from "./git.ts";
 import { runMain, Usage } from "./main.ts";
 import { FAST_TREE_GATES, selectScope } from "./scope.ts";
@@ -22,8 +22,7 @@ class GatesUndecided extends Schema.TaggedError<GatesUndecided>()("GatesUndecide
 }) {}
 
 const NAME = "checks-lint";
-const USAGE = "usage: lint.ts [--full | --desk] [<base-ref> <head-ref>] | --night";
-const NIGHT = "--night";
+const USAGE = "usage: lint.ts [--full | --desk] [<base-ref> <head-ref>] | --whole-tree";
 const PULL_REQUEST_EVENT = "pull_request";
 const SHALLOW_HINT = "a CI checkout needs actions/checkout fetch-depth: 0";
 
@@ -220,34 +219,34 @@ const pullRequestSelection = Effect.fn("pullRequestSelection")(function* (
   return yield* scopedGates(range, root);
 });
 
-function selectionDetail(night: boolean, mode: LintMode, scopeDetail: string, count: number): string | undefined {
-  if (night) return undefined;
+function selectionDetail(wholeTree: boolean, mode: LintMode, scopeDetail: string, count: number): string | undefined {
+  if (wholeTree) return undefined;
   if (mode === "scoped" && scopeDetail === "") return `${count} gate(s) for this change`;
   return scopeDetail === "" ? undefined : scopeDetail;
 }
 
 const lint = Effect.gen(function* () {
   const raw = process.argv.slice(2);
-  const night = raw.includes(NIGHT);
-  if (night && raw.length > 1) return yield* new Usage({ message: USAGE });
-  const split = night ? { mode: "full" as const, rest: [] as readonly string[] } : splitMode(raw);
+  const wholeTree = raw.includes(WHOLE_TREE);
+  if (wholeTree && raw.length > 1) return yield* new Usage({ message: USAGE });
+  const split = wholeTree ? { mode: "full" as const, rest: [] as readonly string[] } : splitMode(raw);
   if (split === undefined) return yield* new Usage({ message: USAGE });
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const range = night ? yield* wholeTreeRange() : yield* resolveRange(split.rest);
+  const range = wholeTree ? yield* wholeTreeRange() : yield* resolveRange(split.rest);
   yield* Console.log(`${NAME}: ${describe(range)} from ${range.source}`);
-  const applicable = yield* Effect.filter(night ? NIGHT_GATES : PR_GATES, (gate) =>
+  const applicable = yield* Effect.filter(wholeTree ? WHOLE_TREE_GATES : PR_GATES, (gate) =>
     gate.appliesTo === EVERY_REPOSITORY
       ? Effect.succeed(true)
       : git(["ls-files", "--", ...gate.appliesTo.pathspecs], root).pipe(Effect.map((files) => files.trim() !== "")),
   );
-  const scoped = night
+  const scoped = wholeTree
     ? { bins: applicable.map((gate) => gate.bin) as readonly string[] | undefined, detail: "" }
     : yield* pullRequestSelection(split, range, root, applicable);
   const bins = scoped.bins;
   const gates = bins === undefined ? applicable : applicable.filter((gate) => bins.includes(gate.bin));
-  const detail = selectionDetail(night, split.mode, scoped.detail, gates.length);
+  const detail = selectionDetail(wholeTree, split.mode, scoped.detail, gates.length);
   if (detail !== undefined) yield* Console.log(`${NAME}: ${detail}`);
-  const verdicts = yield* Effect.forEach(gates, (gate) => runGate(gate, range, night));
+  const verdicts = yield* Effect.forEach(gates, (gate) => runGate(gate, range, wholeTree));
   const failed = verdicts.filter((verdict) => verdict.outcome !== "passed");
   if (failed.length === 0) {
     yield* Console.log(`${NAME}: ${gates.length} gate(s) pass`);

package/src/delivery/ci-wiring.ts

@@ -2,7 +2,7 @@
 import { Config, Console, Effect, FileSystem, Path, Schema } from "effect";
 import { defaultBranch, git } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
-import { ENTRY_POINT, KIT_GATES, TYPESCRIPT_SOURCE, type KitGate } from "../core/gates.ts";
+import { ENTRY_POINT, KIT_GATES, type KitGate } from "../core/gates.ts";
 import { findBunPinFaults, formatBunPinReport, readBunPinPolicy } from "./bun-pin.ts";
 import { findLongJobs, formatLongJobReport } from "./job-timeout.ts";
 import { readScheduleFiles, readShellFiles } from "./mutation-job.ts";
@@ -10,7 +10,6 @@ import { findScheduledReleases, formatScheduleReport } from "./release-schedule.
 import { findRunnerFaults, formatRunnerReport, jobRuns, readRunnerConfig } from "./runner-policy.ts";
 import { findScheduledRuns, formatScheduledRunReport } from "./schedule-policy.ts";
 import { invokes, mentions, plainCommand, type Command } from "./shell-command.ts";
-import { findNightStepFaults, formatNightStepReport } from "./night-step.ts";
 import { findMissingWorkflows, formatMissingReport, isRecord, localUses, names, skippedBy, switchedOff, workflowJobs, type Workflow } from "./workflow-references.ts";
 
 export { BunPinError, findBunPinFaults, formatBunPinReport } from "./bun-pin.ts";
@@ -311,11 +310,7 @@ const wiring = Effect.gen(function* () {
   if (scheduledRuns.length > 0) yield* Console.error(formatScheduledRunReport(scheduledRuns));
   const longJobs = findLongJobs(workflows);
   if (longJobs.length > 0) yield* Console.error(formatLongJobReport(longJobs));
-  const tracksTypeScript =
-    (yield* git(["ls-files", "--", ...TYPESCRIPT_SOURCE.pathspecs], root)).trim() !== "";
-  const nightFaults = findNightStepFaults(tracksTypeScript, workflows, { scripts, files: scheduleFiles });
-  if (nightFaults.length > 0) yield* Console.error(formatNightStepReport(nightFaults));
-  return [gaps, faults, missing, bunFaults, scheduled, scheduledRuns, longJobs, nightFaults].every((found) => found.length === 0);
+  return [gaps, faults, missing, bunFaults, scheduled, scheduledRuns, longJobs].every((found) => found.length === 0);
 });
 
 if (import.meta.main) runMain("ci-wiring", wiring);

package/src/delivery/setup-workflow.ts

@@ -1,31 +1,6 @@
 const HOSTED_FALLBACK = "ubuntu-latest";
 const HOSTED_DEFAULT = "${{ vars.CI_RUNS_ON || 'ubuntu-latest' }}";
 
-export function nightWorkflow(isPrivate: boolean): string {
-  const lines = [
-    "name: night-run",
-    "",
-    "on:",
-    "  workflow_dispatch:",
-    "",
-    "jobs:",
-    "  gates:",
-    "    runs-on: " + (isPrivate ? HOSTED_DEFAULT : HOSTED_FALLBACK),
-    "    timeout-minutes: 20",
-    "    steps:",
-    "      - uses: actions/checkout@v5",
-    "        with:",
-    "          fetch-depth: 0",
-    "      - uses: oven-sh/setup-bun@v2",
-    "        with:",
-    "          bun-version-file: .bun-version",
-    "      - run: bun install --frozen-lockfile",
-    "      - run: bunx checks-lint --night",
-    "",
-  ];
-  return lines.join("\n");
-}
-
 export function ciWorkflow(isPrivate: boolean, hasBuild: boolean): string {
   const lines = [
     "name: ci",

package/src/delivery/setup.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { runMain, Usage } from "../core/main.ts";
-import { ciWorkflow, nightWorkflow } from "./setup-workflow.ts";
+import { ciWorkflow } from "./setup-workflow.ts";
 import { TEMPLATES } from "../docs/doc-templates.ts";
 import { scriptOptions } from "../testing/test.ts";
 import { withServiceOverrides, type ServiceOverride } from "../quality/effect-scope.ts";
@@ -349,7 +349,6 @@ const check = Effect.gen(function* () {
   yield* setupTsconfig(root, oxlintText);
   yield* setupFile(root, "knip.config.ts", KNIP_CONFIG);
   yield* setupFile(root, ".github/workflows/ci.yml", ciWorkflow(isPrivate, outcome.hasBuild));
-  yield* setupFile(root, ".github/workflows/night-run.yml", nightWorkflow(isPrivate));
   for (const kind of Object.keys(TEMPLATES)) {
     yield* setupFile(root, "templates/" + kind + ".md", yield* kitText("dist/templates/" + kind + ".md"));
   }

package/src/delivery/shell-command.ts

@@ -289,10 +289,6 @@ export function shellWords(script: string): readonly (readonly Word[])[] {
   return parse.commands.filter((command) => command.length > 0);
 }
 
-export function shellCommands(script: string): readonly Command[] {
-  return shellWords(script).map(texts);
-}
-
 export function withoutOptions(words: Command, operands: ReadonlySet<string>): Command {
   const [first = "", ...rest] = words;
   if (first === "--") return rest;

package/src/testing/{night-run-findings.ts → whole-tree-run-findings.ts}

@@ -6,15 +6,15 @@ const ScoreSchema = Schema.Struct({ detected: Schema.Int, valid: Schema.Int });
 
 export type Score = typeof ScoreSchema.Type;
 
-export const NightRecordSchema = Schema.Struct({ scores: Schema.Record(Schema.String, ScoreSchema) });
+export const WholeTreeRecordSchema = Schema.Struct({ scores: Schema.Record(Schema.String, ScoreSchema) });
 
-export type NightRecord = typeof NightRecordSchema.Type;
+export type WholeTreeRecord = typeof WholeTreeRecordSchema.Type;
 
 export type TestReport = { readonly results: readonly TestResult[]; readonly crashedFiles: readonly string[] };
 
-export type Tonight = { readonly scores: NightRecord["scores"]; readonly tests: readonly TestReport[] };
+export type CurrentRun = { readonly scores: WholeTreeRecord["scores"]; readonly tests: readonly TestReport[] };
 
-export type PreviousNight = { readonly url: string; readonly record: NightRecord };
+export type PreviousRun = { readonly url: string; readonly record: WholeTreeRecord };
 
 export type Finding =
   | { readonly kind: "mutation"; readonly file: string; readonly before: Score; readonly after: Score; readonly since: string }
@@ -35,7 +35,7 @@ function scoreOf(file: ReportFile): Score {
   return { detected, valid };
 }
 
-export function scoresOf(files: ReadonlyMap<string, ReportFile>): NightRecord["scores"] {
+export function scoresOf(files: ReadonlyMap<string, ReportFile>): WholeTreeRecord["scores"] {
   return Object.fromEntries([...files].map(([path, file]) => [path, scoreOf(file)] as const).sort(([one], [other]) => one.localeCompare(other)));
 }
 
@@ -44,7 +44,7 @@ function fell(before: Score, after: Score): boolean {
   return before.valid > 0 && after.valid > 0 && after.detected * before.valid < before.detected * after.valid;
 }
 
-// A night judges a key only from a report it read, since a report it lacks leaves every finding in it absent.
+// A run judges a key only from a report it read, since a report it lacks leaves every finding in it absent.
 export type Observed = { readonly tests: boolean; readonly gates: boolean; readonly mutation: boolean; readonly mutationReports: ReadonlySet<string> };
 
 export function keyOf(finding: Finding): string {
@@ -55,7 +55,7 @@ export function keyOf(finding: Finding): string {
   return `test:${finding.file}`;
 }
 
-function scoreFindings(previous: Option.Option<PreviousNight>, scores: NightRecord["scores"]): readonly Finding[] {
+function scoreFindings(previous: Option.Option<PreviousRun>, scores: WholeTreeRecord["scores"]): readonly Finding[] {
   if (Option.isNone(previous)) return [];
   const { url, record } = previous.value;
   return Object.entries(scores).flatMap(([file, after]): readonly Finding[] => {
@@ -72,8 +72,8 @@ function testFindings(reports: readonly TestReport[]): readonly Finding[] {
   return [...new Map(failing.map((finding) => [keyOf(finding), finding])).values()];
 }
 
-export function findingsOf(previous: Option.Option<PreviousNight>, tonight: Tonight, others: readonly Finding[] = []): readonly Finding[] {
-  return [...scoreFindings(previous, tonight.scores), ...testFindings(tonight.tests), ...others].sort((one, other) =>
+export function findingsOf(previous: Option.Option<PreviousRun>, current: CurrentRun, others: readonly Finding[] = []): readonly Finding[] {
+  return [...scoreFindings(previous, current.scores), ...testFindings(current.tests), ...others].sort((one, other) =>
     keyOf(one).localeCompare(keyOf(other)),
   );
 }
@@ -95,7 +95,7 @@ export function gatesDecided(log: string): boolean {
   return FAILED_GATES.test(log) || PASSED_GATES.test(log);
 }
 
-// A mutation finding is a fall between two nights, so a night without it shows no score recovered.
+// A mutation finding is a fall between two runs, so a run without it shows no score recovered.
 export function cleared(key: string, present: ReadonlySet<string>, observed: Observed): boolean {
   if (present.has(key)) return false;
   if (key.startsWith("gates:")) return observed.gates;