This one covers November 10 to 17. It was a week about tests that finish: my workflow kit moved onto Node's own test runner and learned to end a run that has stopped doing anything. The rest went into a new engine for my awesome lists, a deploy fix in my framework, and how my machines upgrade Node.
A hung npm test is not a slow one
workkit is my workflow kit for Claude Code: GitHub issues as the work list, labels as the pipeline, hooks that enforce the rules. Agents run most of my test suites now, usually in the background. A suite that waits on a socket that never closes does not fail. It just sits there, and so does the agent waiting on it.
Version 0.94 puts every root npm test and every workkit prove under a supervisor. It checks the run every five minutes (tests.check changes that), and each check asks two questions. Was the run's log written since the last check? Did any of its processes use the processor? Processor time counts as work once it reaches 1 percent of one core over the check.
The verdicts are simple:
- Output or work: alive. Nothing happens.
- Neither, two checks in a row: frozen. The evidence goes in the log, one line per process, then the run is ended with exit code 124.
- No output for six checks, but working: a look. The run keeps going, and the call attached to it prints the evidence and exits 125.
A busy run is never ended, however long it takes. A frozen one ends with a line that says why:
detach: no output and no processor use for <N> minutes, so the run was ended (exit 124) Inside a run there is a second bound. The runner ends a suite file's whole process group after 600 seconds (TEST_DEADLINE=<seconds> sets another) and reports one timed-out failure, so one stuck file costs a line in the report instead of the whole run.
Why it matters: "it's still running" used to be a guess. Now it is a measurement, and the two exit codes tell an agent whether to wait or to go look.
The runner is Node's now
The other half of the week was the runner itself. Since version 0.95, a workkit suite is plain node:test: describe, test, the usual hooks, and an expect with Jest's matchers, exported from workkit-core/test. Any suite runs alone with node <file>. The kit's own case engine, with its group, assertEq and selfRun, is gone.
Removing an API means migrating everyone on it, so the release shipped workkit convert. It rewrites an old-shape suite in place and maps each statement one for one: group('x') becomes describe('x', ...), assertEq(actual, wanted) becomes expect(actual).toBe(wanted). It only rewrites a file it fully understands. Cases made in a loop, a whole-file skip or a setup line between cases leave the file byte for byte, with one line saying where and why:
converted <path> (<n> cases) left <path>:<line> <why> A file already on Node's functions is left alone, so a second run changes nothing. My own machine-setup repo moved over the same week.
The next release built on that base: --filter=<text> runs only the cases whose full name, describe path included, holds the text, and a bare run at a monorepo root also runs each workspace member's own npm test.
Why it matters: Node's runner is the one every JavaScript developer can already read. The kit stops maintaining a test framework and keeps only the parts that are its job: finding suites, bounding them, and recording proof.
24 copies of the same bots, now one engine
I maintain 24 public awesome lists. Each one had its own copy of the same three jobs: a pull request check that judges a new entry, a weekly sweep for dead links and archived repos, and a daily sync of the shared text. Each copy had its own scripts and tests. A fix meant 24 commits.
awesome-kit is new this week, and it holds that code once. A list now carries three short workflow files, each calling the kit's composite action with one command:
jobs: sweep: runs-on: ubuntu-latest steps: - uses: ianwieds/awesome-kit@v2 with: command: sweep GitHub fetches the kit at the tag the list names, so a kit release reaches every list without a commit to any of them. Moving a list onto it deleted 1,628 lines from each one, about 39,000 lines across all 24.
The 2.0 release added awesome-kit setup. Run in a fresh repo, it scaffolds every missing file a list needs, writes the three workflows, runs sync, and sets the repo's description and topics through gh. It never overwrites a file the list owns, and since 2.0.1 it fails before any write when the config names a different repo than origin.
Two details I like. The pull request check runs on pull_request_target, so it can comment on a fork's PR, but it checks out only the base branch and reads the head README as data, never code. And the daily job keeps one empty commit on a maintenance branch, so GitHub never pauses the Monday sweep after 60 quiet days.
Why it matters: a new list starts with one command, and a fix reaches every list at its next run.
Deploys that stop growing the repo
omega is my framework for shipping a website, backend, desktop app and browser extension from one project. Each deploy pushes a snapshot to a deploy ref, and every snapshot chained on the one before, so the mirror grew by a full copy per deploy.
A change now on main (not in a release yet) re-roots that chain on GitHub's side before each deploy. Through the git data API, the deploy ref's tip becomes a parentless copy of its own tree, the push waits until the ref reads that root, and the new snapshot chains on it. The ref then holds one root, the latest snapshot, and any admin publish since. Nothing older.
Why it matters: a deploy mirror should cost the same on deploy 500 as on deploy 5.
Node upgrades that cannot strand a terminal
One private story, from the scripts that set up my machines. They used to move the default Node to the newest release as soon as it installed. If a global package then failed to install, every new terminal opened on a Node with missing tools.
Now a new release becomes the default only once its global packages are in. A failed install leaves new terminals on the release that worked. Globals install only when missing or behind, so the package firewall I route npm through keeps its 133 MB binary between runs.
Why it matters: an upgrade is stage first, then flip the pointer. Flip it first and a half-finished upgrade is the default.
Next week I want the supervisor's two exit codes wired into how my agents react to a stuck run. What does your test runner do when a test never returns? Comments are open.

