Skip to content
SHC Docs

License-broker topology: central vs per-estate, 2026-08-15

Status: open design. Nothing was moved, and the per-estate broker drift is still open. Every number below is a far-side reading taken 2026-08-15 between 19:50 and 20:15 UTC against the two live production estates and the two live broker hosts; the literal output is quoted inline so no claim here rests on a command’s own summary of itself.

Raised by the owner: “why does promanager have a license broker deployed? I thought we just have one single license broker, managed by selfhosted-cloud.”

The short answer: you are right, and the doctrine already says so; the drift is in the deployment, not the design. But the shape of the drift is not what the question assumes, and the measurement changed the interesting part of it: promanager’s local broker is not what promanager licenses itself from. It is a dead legacy deployment serving zero traffic, and promanager has been a genuine remote-broker customer of bitspur’s broker for at least three days.


Both estates run shc version 0.0.57-SNAPSHOT-a7d0422c0.

shc ls --all-tenants on promanager (compose01.hel1.hetzner.promanager.vip):

identity-broker corp prod identity-broker running
identity-broker-db corp prod postgres running
keygen corp prod keygen running
keygen-db corp prod keygen-db running
license-broker corp prod license-broker running

shc ls --all-tenants on bitspur (compose01.hel1.hetzner.bitspur.com):

identity-broker corp prod identity-broker running
identity-broker-db corp prod postgres running
keygen corp prod keygen running
keygen-db corp prod postgres running
license-broker corp prod license-broker running

So the owner’s observation is exactly right at the inventory level: two license brokers and two Keygen ledgers exist, one estate apart. Both are live and both are armed:

$ curl -s -o /dev/null -w 'http=%{http_code} ip=%{remote_ip} ssl=%{ssl_verify_result}\n' \
-X POST https://license.selfhostedcloud.org/sync
http=401 ip=37.27.215.210 ssl=0
$ curl -s -o /dev/null -w 'http=%{http_code} ip=%{remote_ip} ssl=%{ssl_verify_result}\n' \
-X POST https://license.corp.promanager.vip/sync
http=401 ip=204.168.129.34 ssl=0

(401, per license-broker/README.md, is the documented signal for “new image up AND the vendor routes armed”; ssl_verify_result=0 is a publicly-trusted chain on both.)

Both hosts run the same broker image:

registry.gitlab.com/bitspur/selfhosted-cloud/shc/license-broker:90c8d648@sha256:ffa1334c…

0.1 …but only one of them is doing anything

Section titled “0.1 …but only one of them is doing anything”

docker logs --since 72h on the two broker containers:

promanager brokerbitspur broker
total log lines in 72h1330
refresh granted events012
refresh declined events03
the restboot + startup tier sync + one vendor tier sync refused (that was this lane’s own unauthenticated /sync probe, 20:07:45)boot + syncs + one probe

bitspur’s broker log, the load-bearing lines:

2026-08-15T19:01:51Z INFO refresh granted domain=shc.hel1.hetzner.bitspur.com files=1
2026-08-15T19:01:53Z INFO refresh granted domain=shc.hel1.hetzner.promanager.vip files=1

and, at the same minute, shc license status on promanager:

state: keyed
tier: internal
holder: BitSpur (promanager estate)
estate: shc.hel1.hetzner.promanager.vip
auto-check: on
last check: 2026-08-15T19:01:52Z; reached the broker

The broker promanager reached at 19:01:52 was bitspur’s, over the public internet. That is not inference from the timestamps alone: the estate has no SHC_LICENSE_BROKER_URL override on shcd, so resolveBrokerURL() (modules/license/refresh.go) falls to the compiled-in license.DefaultBrokerURL = "https://license.selfhostedcloud.org" (modules/license/broker.go:80), which resolves to 37.27.215.210, bitspur. The corresponding grant is in bitspur’s log two seconds later.

The ledgers agree. bitspur’s Keygen holds a record for promanager:

$ psql -d keygen -At -F'|' -c "select metadata->>'domain', created_at::date, expiry from licenses order by created_at"
shc.hel1.hetzner.bitspur.com |2026-07-31|
shc.hel1.hetzner.promanager.vip|2026-07-31|
shc.10.200.14.1.nip.io |2026-08-12|

promanager’s own Keygen still holds the older, richer set: both estates plus the nine lane-*.test.invalid campaign fixtures:

shc.hel1.hetzner.promanager.vip|2026-07-30|
shc.hel1.hetzner.bitspur.com |2026-07-30|
lane-scaleway.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-proxmox.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-mesh.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-hetzner.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-exoscale.test.invalid |2026-07-30|2027-07-31 00:00:00
lane-vultr.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-gcp.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-aws.test.invalid |2026-07-30|2026-10-31 23:59:59
lane-openstack.test.invalid |2026-07-31|2026-10-31 23:59:59

Two rights ledgers have diverged, and the one that is authoritative is the sparser one. Nothing reads promanager’s ledger any more; nothing has since 0.0.12 rolled. This matters for §5: the campaign fixtures are in the ledger that is about to be retired.

The dead config row is still on both estates, and the product now says so:

$ shc config get license.broker_url
warning: [X400037CFGINR] config key license.broker_url is stored but not in effect, no component reads this key
https://license.corp.promanager.vip

1. Which components are CENTRAL, which are PER-ESTATE

Section titled “1. Which components are CENTRAL, which are PER-ESTATE”

The tree already answers this; docs/app-development/brokers.md §“Other things in this tree called broker” is explicit that the noun is overloaded and that these are unrelated surfaces. Restating it as a table, with the measured deployment beside it:

ComponentDoctrineCorrect topologyDeployed today
license-broker (license-broker/)“the vendor-side EE activation service … vendor infrastructure, not an estate component” (brokers.md:219); app.yaml header: “deployed by the VENDOR on their own estate … never installed by customers (their estates only call it)”; deliberately outside the public catalog, published only to the shc-apps-index infra indexCENTRAL, exactly one logical instance, behind one hostname, replica-scaled for the multi-vantage posture R3 requires. It is stateless with no volumes precisely so replicas scale freelyTWO: bitspur (live, all traffic) and promanager (live, zero traffic)
keygen (apps/standalone/keygen)the vendor’s rights ledger: “Keygen is the single system of record” (ruling R1, README “Mint backends”). The purchase pipeline writes it (ERPNext invoice → POST /record); the broker reads itCENTRAL, exactly one. “Single system of record” is not satisfiable by two. Note the app itself is a general catalog app a customer could legitimately install for their own product’s licensing; that is a different deployment with a different meaningTWO ledgers, DIVERGED (12 rows vs 3 rows)
identity-broker (apps/standalone/identity-broker)“one for the estate for identity-brokers (the realm is a singleton)” (brokers.md:834). It maps this estate’s Keycloak sub → each platform’s local id and seeds per-user credentials. Its socket key is realmPER-ESTATE, one per estate. Central would be a category error: it holds the estate’s user setone per estate, CORRECT. Nothing to change
keygen-db / identity-broker-dbprivate postgres per stackfollows its ownercorrect

The name collision is the whole of the owner’s confusion, and it is worth fixing in prose somewhere customer-facing. identity-broker and license-broker share four letters and nothing else: one is a per-estate convergence loop over the estate’s own users, the other is a vendor signing service that no customer ever installs. brokers.md already warns “Do not cite one for another”.

So: one license broker, one Keygen, managed by selfhosted-cloud, yes. promanager’s pair is the legacy provisional deployment, kept alive on purpose during the 0.0.12 cutover and never retired afterwards. modules/license/ broker.go states the cutover contract verbatim: “promanager’s broker stays live until both production estates roll v0.0.12 and verify against bitspur, because every ≤v0.0.11 binary in the field keeps renewing from the old host until it rolls.” Both estates now run 0.0.57 and both verify against bitspur. The condition the ruling attached to promanager’s broker was satisfied; the retirement it licensed was never performed.


2. What a customer estate actually talks to, and over what protocol

Section titled “2. What a customer estate actually talks to, and over what protocol”

A customer estate talks to one hostname, over ordinary HTTPS, on two POST routes, and never on the request path.

customer estate central broker central Keygen
(shcd on the ingress-picked node) license.selfhostedcloud.org (LAN-only, no
public route)
POST /activate {domain, nonce} ───────────► handleActivate
│
GET /.well-known/shc-license-challenge?nonce=… │ outbound callback,
◄─────────────────────────────────────────────────┘ dialled at the pinned
(echo the nonce; NO cert requirement; R3) authoritative-DNS answer
│
├─► lookup metadata.domain ──►│
│◄── policy + entitlements ───│
│
◄────────── 200 {licenses:["shclic.v1…"]} ──────┘ signed locally with the
broker Ed25519 seed
POST /refresh {domain, current_license_id, …} ─────► handleRefresh
◄────────── 200 {licenses:[…]} | {unchanged:true} | {error:"…"}

Concretely:

  • Outbound, estate → broker. POST /activate and POST /refresh only. Plus GET /healthz. That is the entire client surface (license-broker/brokerd/server.go:101–112). /mint, /record and /sync are vendor-only and are not registered at all unless LB_VENDOR_TOKEN is set; they 404 rather than existing in a permissive state.
  • Inbound, broker → estate. GET /.well-known/shc-license-challenge?nonce=… (modules/license/challenge.go:25). The estate must be publicly reachable at its SHC_HOST domain for the duration of the call. Traefik forwards that path to a single upstream, its own host’s daemon, so the node that completes activation is whichever node ingress picked, not the raft leader (modules/license/distribution.go:179).
  • The proof is two legs and no more (ruling R3, 2026-07-29): (1) authoritative DNS + reachability: the A/AAAA answer is read from the domain’s own nameservers, must be publicly routable, and the callback dial is pinned to that address (X403032LICDNS); (2) the nonce echo, no redirects followed (X403034LICNCE). There is no certificate leg. X403033LICTLS is retired and survives only in comments. An estate can activate before its TLS is up, and LE-staging estates activate normally.
  • Refresh presents PRIOR PROOF and skips the callback. If the estate names a current_license_id the broker’s ledger still associates with that domain, domain control was already proven and the callback does not run (license-broker/brokerd/refresh.go). When prior proof is absent (a trialing estate, a delinked one, a revoked record), the callback runs exactly as /activate does. There is no weaker path into a first license.
  • The location is compiled in and is a frozen consumer contract. license.DefaultBrokerURL, owner ruling 2026-07-30: “broker location does get baked into binary, not configurable.” There is no config key and no operator knob; SHC_LICENSE_BROKER_URL exists for the dev loop and tests. A binary in the field renews from whatever hostname it was built with, forever.
  • Runtime stays offline. The signed shclic.v1… token is verified locally against the pubkey embedded in the binary. The broker is touched at activation and by the periodic soft re-verify only, never on the request path, never as a per-boot gate.

3. What breaks today if the central broker is unreachable

Section titled “3. What breaks today if the central broker is unreachable”

Split into the two cases, because they are not remotely the same.

3.1 An already-keyed estate: nothing breaks, by design and in code

Section titled “3.1 An already-keyed estate: nothing breaks, by design and in code”

Service.Refresh “NEVER refuses anything: a fault returns X502962LICRFR for the caller to LOG, and the held file keeps resolving entitlements.” The held file is the authority; the network is not. shc license status then tells the operator the truth in the shape it actually happened:

last check: <ts>; FAILED (N consecutive failed asks)
this node has never successfully reached a broker
entitlements are unaffected; they resolve from the license file on disk

Only when the file itself lapses does anything change, and then:

  • GraceDuration = 14 * 24h (modules/license/grace.go), covering both an expired licence and a spent trial. The clock starts at the first observed lapse, recorded on disk (not at ExpiresAt), so an estate powered off for six months gets a real fourteen days on return, and a restore resumes the remaining grace rather than resetting it.
  • After grace: the strong lock (R15/R16): every change refused (installs, updates, config, cluster changes, backup create/restore). Running workloads are never stopped and existing backups stay downloadable. Six licensing paths stay open through the lock so the estate can always be fixed: shc.license.{activate,activate_online,refresh,trial,delink,status} (ce/core/api/middleware.go:492), plus the scale-down exemptions.
  • license.offline = true (R21) suppresses the dial entirely rather than failing it; no timeout, no “couldn’t reach broker” noise; the gate’s refusal points at obtaining a new signed file (X403037LICOFF).

So for a keyed estate, broker unreachability is a soft, bounded, honestly reported condition. This half is in good shape.

3.2 An estate that has never activated: this is where the live defect is

Section titled “3.2 An estate that has never activated: this is where the live defect is”

An estate with no file resolves to StateUnlicensed, whose Resolver.Limit returns 0 for every capacity key (modules/license/resolver.go:264), i.e. clustering growth is refused outright, not capped at one. (StateTrial and StateDev allowsAll(); StateUnlicensed does not.) It cannot get a file without reaching the broker, and it cannot reach a broker that cannot prove its domain.

And that is happening right now, in production, on a 6-hourly cadence. bitspur’s broker log, three times today:

2026-08-15T07:05:48Z INFO refresh declined at callback verification domain=91.92.224.48
err=[X403032LICDNS] activation callback for 91.92.224.48 failed the public-DNS leg:
authoritative DNS lookup failed: lookup 91.92.224.48: no NS delegation found
2026-08-15T13:07:06Z (identical)
2026-08-15T19:07:06Z (identical)

An estate is asking for a licence with a bare IPv4 address as its domain. The authoritative-DNS leg walks the NS delegation for the name it is given; an IP literal has no delegation, so the leg cannot pass, not “fails today”, cannot pass by construction. This is the broker-side root cause of the G10 cloud lane’s “this node has never successfully reached a broker”, and it is a design gap, not a bug in the verifier: domain-callback activation structurally excludes any estate that has no DNS name. The shc.10.200.14.1.nip.io row in bitspur’s Keygen is somebody having already hit this and worked around it with a wildcard-DNS service.

(The companion max_nodes=1 reading from that lane is NOT explained by the above and should not be folded into it; StateUnlicensed yields 0, not 1, and 1 is also what the capacity: now: line prints for a single-node estate. Which of the two lines carried the 1 decides whether there is a second defect. Left as Q6 rather than guessed at.)

3.3 T5 (offline licence activation): the “structurally unrunnable” verdict is half stale

Section titled “3.3 T5 (offline licence activation): the “structurally unrunnable” verdict is half stale”

DEFECTS-CLOUD-COMPLETE.md P14 declares T5 unrunnable two ways:

the fallback path needs the vendor’s Ed25519 signing key, and the broker path needs the estate publicly reachable on a production certificate while tests/clouds/azure/terraform/main.tf hardcodes acme: default: staging

The first half stands. The second half was invalidated by ruling R3 and nobody re-graded it. There is no certificate leg any more; the broker README states the consequence explicitly: “LE-staging estates activate normally (previously the reason a cert flip was needed before dogfooding)”. A staging-ACME estate can activate. What it cannot do is activate without a resolvable public domain, which is §3.2’s gap and a different sentence.

The first half is real and structural: shc license mint is gated by possession of the private signing key, never by a licence and never by a running server (modules/license/mint_cmd.go, “the chicken-and-egg loop-breaker”). A campaign lane cannot hold that key, so the offline path is correctly out of reach for automated testing. POST /mint (vendor token, skips the callback, still goes through the Keygen lookup) is the intended airgapped-delivery route and is the thing a T5 successor should exercise.

This repeats the lesson DEFECTS-CLOUD-COMPLETE.md already wrote for the retired P13: an impossibility claim needs the same far-side proof as a capability claim.


The lane’s framing was “the estate is BOTH the vendor and the customer; it self-licenses, so the customer path is never exercised.” The measurement splits that into two very different cases:

promanagerbitspur
dialslicense.selfhostedcloud.org → 37.27.215.210 (bitspur)license.selfhostedcloud.org → itself
network pathgenuine internet, cross-estatehairpin: out to its own public IP and back through its own traefik
exercisesDNS, public TLS chain, the real broker, a foreign rights ledgerthe same code path, but nothing that could break independently
verdictalready a real customer. Keep it that waystructurally cannot dogfood the customer path, because it hosts the broker

So the dogfooding gap is narrower and more fixable than assumed: we already have one true customer estate. What we do not have is a customer estate whose licence survives the vendor estate being down, because the vendor estate is bitspur, and if bitspur is down, so is the broker.

Three properties worth ruling on as the target posture:

  1. Every SHC-owned estate holds a licence minted through the same /activate + /refresh path a customer uses, from the same central broker, against the same central Keygen. promanager already satisfies this. No estate should hold a hand-minted shc license mint file as its steady state; that is the bootstrap loop-breaker, not a posture.
  2. The vendor’s licensing plane should not live inside an estate that is itself a licensed customer. Today bitspur’s corp/prod tenant hosts both the broker every binary in the field dials and 40-odd unrelated workloads. A corp tenant incident is a global licensing incident.
  3. The internal blanket stays the internal tier through the ledger (vendorTiers["internal"], termOptional: true, enterpriseCodes()), which is what both estates measurably hold today (tier: internal, holder: BitSpur (… estate)). That is the right mechanism; it is a ledger row, not a code path, so it does not bypass anything.

Note this direction is already implied by rulings you have made elsewhere: docs/proposals/2026-08-14-portal-architecture.md puts the Portal at my.selfhostedcloud.org, “run by us, never self-hosted”, sharing one Keygen spine with the marketplace, with “a deep integration between this portal and keygen” that places a registered cluster’s domain into the paid tier. That spine cannot be two ledgers, and it is hard to argue it should be a stack inside a customer-shaped estate’s corp tenant.


Ordered so that each step is independently reversible and none of them can strand a binary in the field. None of this was performed.

Step 0: decide the destination first (blocks everything). Q1 below. If the licensing plane is moving to its own SHC-run plane alongside the Portal, steps 2–4 should land there once rather than at bitspur and then again later. acme_provider is install-time only; neither shc update nor the update API carries it, so moving the issuing CA means terraform must replace the deployment. Doing that twice is two blast radii.

Step 1: reconcile promanager-ops with reality (do this regardless). promanager-ops main pins the broker at license-broker:894d2a18@sha256:8dd44729… but the estate runs 90c8d648@sha256:ffa1334c…, the same digest bitspur runs. The applied state did not come from the committed terraform. Find out which worktree/branch or out-of-band shc update did it and commit the pin, before anything else touches that resource; a terraform apply against the committed pin today would roll promanager’s broker backwards. Risk if skipped: an unrelated apply silently reverts a broker image. Zero customer impact today only because that broker serves nobody.

Step 2: reconcile the two ledgers. bitspur’s Keygen has 3 rows; promanager’s has 12, including the nine lane-*.test.invalid campaign fixtures and their expiries. Decide per row: migrate, recreate through POST /record, or abandon. The idempotency key is the invoice id; /record replaying an invoice reports unchanged and writes nothing, so re-recording is safe. Risk: silently abandoning the campaign fixtures breaks the licensing test campaign’s rig the next time it runs, in a way that will read as a product defect. Risk: the account ids differ deliberately (bitspur’s is a fresh uuid, “two estates sharing an account id would collide the moment either is pointed at the other’s data”), so this is a re-record, never a database copy.

Step 3: prove the survivor before retiring anything. On the central broker: POST /sync with the vendor token twice; the second run must report an empty attached, which is what “Keygen already agrees with the binary” looks like. Then shc license refresh on both estates and read shc license status for the expected entitlement set. The README’s three-step ledger discipline (roll the image → sync the policies → re-mint each estate) applies in full; “skipping step 3 leaves the ledger correct and every estate unchanged, which is the state that reads most like success and is not.”

Step 4: retire promanager’s license-broker stack. Only after 2 and 3. Removal order matters: the DNS name license.corp.promanager.vip should keep answering (a redirect or a 410 with a coded body) rather than NXDOMAIN, for the same reason DefaultBrokerURL is a frozen contract: “this is a name we are prepared to keep serving forever, or to keep serving a redirect from.” Risk, and it is the one that needs a positive check rather than an assumption: any binary ≤0.0.11 still in the field renews from that host and nothing else. Before removal, prove the negative; 72h of that broker’s log showing zero refresh granted is the evidence (it currently shows exactly that), and it should be re-taken immediately before the removal, not inherited from this document.

Step 5: retire promanager’s keygen + keygen-db stacks. After 4, and after 2 has actually landed the rows somewhere. keygen-db is the backed-up half; take and verify a final archive before destroy, because this is the only copy of the campaign fixture history.

Step 6: clear the dead config row on both estates. license.broker_url is stored, warned-as-inert, and points at a host that is about to stop existing. It is harmless (nothing reads it) but it is the exact row config_keys.go documents as having “told the operator the wrong vendor.”

Step 7: the multi-vantage posture R3 requires. The compensating control for dropping the certificate leg is “multi-vantage validation, and that is a deployment posture, not code: run several broker replicas on different networks/providers behind the activation host, so a localized hijack cannot fool all of them.” Today there is one replica on one provider in one datacentre. Retiring promanager’s broker does not make this worse (promanager’s was never behind the same activation host, so it was never a vantage), but it does make it visible that the control the ruling relied on is not implemented anywhere. This is a new work item that the migration surfaces rather than causes.

Cross-cutting risk: the single point of failure gets sharper. After retirement there is exactly one host every EE binary ever shipped will dial forever. Its failure mode is soft (§3.1) and bounded by the 14-day grace, and no running estate stops working, but a new estate cannot activate at all while it is down, and neither can a customer who just paid.


6. Open questions: for an owner ruling, not for this lane to decide

Section titled “6. Open questions: for an owner ruling, not for this lane to decide”

Q1. Where does the licensing plane live? Stay in bitspur corp/prod alongside 40 unrelated stacks; move to a dedicated SHC-run estate; or fold into the Portal plane at *.selfhostedcloud.org that 2026-08-14-portal-architecture.md already rules is “run by us, never self-hosted”? This blocks the whole migration because acme_provider is install-time and the replace should happen once.

Q2. Can an estate with no DNS name be licensed at all? Measured live: X403032LICDNS declining 91.92.224.48 three times today, structurally unpassable. Three candidate answers, all product decisions: (a) No; say so loudly. A domain is a prerequisite; make the refusal name that instead of reading as a DNS fault, and document it in the install prerequisites. (b) Yes, via a different proof for IP-literal estates (HTTP challenge to the pinned literal with no NS walk, accepting the weaker guarantee, gated to public IPs only). (c) Yes, via the vendor path only: POST /mint, i.e. every domainless estate is a manual sale. Today the product implicitly chose (a) and communicates it as a bug.

Q3. Does the R3 multi-vantage posture get built, and if so when? It is the stated compensating control for a ruling already shipped. Right now the control does not exist. Is it a release gate, a backlog item, or is the ruling amended to accept single-vantage validation?

Q4. What happens to promanager’s Keygen rows: migrate, re-record, or abandon? Specifically the nine lane-*.test.invalid campaign fixtures, which are test infrastructure living in a production rights ledger. Should the campaign have its own ledger rather than fixtures in the vendor’s system of record at all?

Q5. Does bitspur’s hairpin self-licensing count as dogfooding? If not, what is the acceptance criterion: a third SHC estate that is purely a customer, with no vendor component, whose licence is proven to survive a broker outage? promanager nearly is one already; the gap is that it shares an owner and an outage domain with the broker.

Q6. The G10 max_nodes=1 reading: licensed: line or now: line? StateUnlicensed yields 0, and 1 is also the correct now: value for a single-node estate. If it was the licensed: line there is a second defect here that this proposal has not characterised; if it was now: after two voters joined, the defect is in usage sampling, not licensing. One re-read of that lane’s raw output settles it.

Q7. Rename or re-document identity-broker vs license-broker? The collision cost an owner-level question today. brokers.md already carries the disambiguation table but it is an app-development doc; the confusion happens at the deployment surface (shc ls), which has no such note.


7. Doc drift found while reading (not fixed by this lane)

Section titled “7. Doc drift found while reading (not fixed by this lane)”

Small, but each one is a wrong statement in a doc that gets cited:

  1. license-broker/README.md, “Known blocker (ce)”: claims a non-?autogen ref+vault:// reaches the container verbatim and the broker exits 1. Stale. ce/modules/app/secrets_resolve.go now resolves required refs and fails closed with vault.X404905SECREQ naming the missing key; both estates’ terraform relies on exactly that. The blocker note should be retired or rewritten as history.
  2. license-broker/brokerd/refresh.go:16–20: still describes /activate as requiring “a strict public-CA certificate”. Retired by R3; the file’s own sibling (callback.go:122) documents the retirement.
  3. DEFECTS-CLOUD-COMPLETE.md P14 / HANDOFF.md T5: the production-certificate half of the “structurally unrunnable” verdict is invalid post-R3 (§3.3). The signing-key half stands.
  4. bitspur-ops/hetzner/hel1/deployments/corp.tf:299: describes corp-keygen as “the licensing rights ledger (Keygen CE), the TEST instance mirroring promanager’s.” It has been the production ledger for every estate in the field since 0.0.12 rolled. That comment is now the single most misleading line in either ops repo.