Most of the estate's Go modules come in families. Each has a core, go/chat or go/config or go/forge, and a ring of adapters around it, one per provider or backend, each requiring the core. So there's a right order to release them in, and it's fairly obvious: the core goes first, then each adapter picks up the new core and releases against it.

I've known that for as long as the families have existed, which made it all the more irritating when twenty-three config adapters went out in the wrong order, all at once, and took thirty-nine second releases to put right.

Carriages without an engine

What happened was dull, and blindingly obvious in hindsight. go/config v0.17.3 went out, and all twenty-three config-* adapters then tagged releases still requiring v0.17.2, because their release merge requests had been open, perfectly green, since before the core moved. Each one shipped against a core that had already left the station, so each one needed another release the moment I noticed.

It's a train pulling out without its engine. The carriages are fine on their own, they're just not going anywhere useful, and someone (me) has to go back and fetch them.

It happened again in a smaller way while I was writing the spec for the fix. go/chat v0.31.0 was tagged one morning, and forty minutes later four chat adapters had release merge requests open and mergeable... still requiring v0.30.0.

A check on the platform

The releases go out through colophon, which opens a release merge request and tags when I merge it. It has no hook that runs before a release, so the only place to catch a stale core is the release merge request itself, as an ordinary pipeline job. And I didn't want it inside colophon either. It's a Go dependency rule specific to how this estate is laid out, and baking it into the release tool would have handed any outside user of colophon a default that pointed at my family list and decided what a correct release meant for their modules. So it's a component of its own in cicd, go-core-currency.

(The agent working on the code came up with the name, and it threw me at first. I was left scratching my head, thinking "money... concurrency???", and shrugged. It was only when I asked the agent what it meant that I got the explanation: "currency" in the sense of being current, as in the currency of a document. I could have swapped it for something blunter, but once I understood it, it made total sense and I kept it.)

It needs to know which modules are cores, and that question turned into something bigger than the guard: the family list started out in a private file and is now part of the estate's public feed at phpboyscout.uk/projects.json. Membership, though, comes from each module's go.mod and not from the list. On the day the spec was written, three chat adapters were missing from the list, and a guard that trusted it would have waved all three through.

I asked for a red pipeline, and what shipped is yellow: a stale core is reported as an allowed failure, and a single setting turns it into a hard block once it's proved itself for a week. A guard that goes red by mistake across a whole family's releases is one I'd end up switching off myself, so I'm inclined to give it that week to show it can be trusted first.

Asking what "latest" means

All of that depends on knowing a module's latest release.

The spec's first guess was that the Go module proxy might lag a fresh tag by a few minutes, so the worst case was a guard that missed a brand new release briefly and stayed green. Then I measured it on a real release, and "a few minutes" was wrong by a couple of orders of magnitude. go/chat v0.32.0 was tagged at 19:57 one evening, and the proxy's index first saw it at 07:42 the next morning. Nearly twelve hours! And only because it was asked for by hand, since the proxy learns about a version when something requests it, and nothing had. Then, once it did know, its cached @latest carried on answering v0.31.0 for the best part of an hour.

I'd been grumbling for months that the proxy felt slow, and it has a nasty edge as well: ask for a version before the proxy can serve it and you make things worse. The proxy's own FAQ says as much, that if someone requested a version before the tag was pushed, it may take up to thirty minutes for the cache to expire.

So the fix comes in two parts. Colophon now tells the proxy about each new tag itself, with one request per tag, after a short pause, so it doesn't ask before the forge can show the tag. And the guard doesn't rely on @latest alone any more. It asks pkg.go.dev's module API, which the Go team announced back in May, and takes the higher of the two answers. This is the start of how it finds a latest version:

candidates, errors, misses = set(), [], 0 sources = [("proxy", f"{PROXY}/{proxy_path(module)}/@latest", "Version")] if PKGSITE: sources.insert(0, ("pkg.go.dev", f"{PKGSITE}/v1/module/{module}", "version")) 

Both only report versions the proxy can serve, so the guard still can't invent a release.

The rename that answered with someone else's name

There was one more trap, and it arrived with the go/chat-platform family being renamed to go/comms. Ask the proxy for the latest go/chat-platform today and it happily answers with a version whose own go.mod says it's go/comms. Take that answer at face value and you'd tell an adapter to bump to a version that doesn't resolve under the name it requires.

So a candidate version only counts if its go.mod still declares the module that was asked about. Anything else means the module moved, and that gets reported as a move, naming where it went, and not as stale.

The first proper look

Once it was in, I had it run across every open release merge request in the estate to see how far things had drifted. Sixty-eight of them ran the job. Fifty-nine were current and nine were behind, and ten of the eleven stale core requirements were go/chat, which had released twice in a single day. The furthest behind was go-tool-base's own CLI, eight chat releases adrift (a tad embarrassing, in my own framework). The guard also checks other first-party modules now, though only as a warning, since a stale leaf is far more often a deliberate pin than a stale core is.

It all went yellow, which was the plan, and it runs on every release merge request in the estate now. Once it's had its week I'll flip that setting, and a train with no engine won't get out of the station at all.

Originally published at phpboyscout.uk on 17 November 2026.