Marketplace entitlement and licensing: 2026-08-16
★ SUPERSEDED IN PART, 2026-08-18, wherever this doc treats the
app-licence magic socket (builtin/license, -i license=LICENSE, the five
provisioning modes) as a live surface, it no longer is: the socket was
amputated by owner ruling. BYOL is a plain consumer var; cluster-side
licence enforcement is shcd’s; licence management lands on the portal
Frappe backend. See
docs/decisions/2026-08-18-builtin-vs-deploy-placement.md.
Status: THREE RULINGS recorded: approval/spending limits (§6), the identity seam (§2.2, ruled on amendment), and third-party proxying is not in v1 (§5.0, ruled on amendment), plus one CORRECTION of an earlier assistant recommendation (§7) and the remaining open owner questions in §9. Sections marked (verified) were read out of the tree today; sections marked (recommendation) are arguments, not decisions.
Amended 2026-08-16 (later the same day) with the owner’s follow-up rulings: §2.2 registration-as-identity is RULED, not a direction (§2.5 superseded; §9 Q1 closed); §5.0 third-party proxying is not in v1, which matches the code; and §6.5 records why per-seat cannot work for third-party marketplace apps; it is unverifiable by construction, not merely unbuilt.
Companions, both on main as of today:
2026-08-16-marketplace-identity-and-install.md:
who buys, who installs, the daemon-minted new-tab assertion ·
2026-08-16-portal-cluster-identity.md:
who administers a registered cluster, the L0/L1/L2 seal, and Ruling 1
(request-and-approve). Upstream:
../proposals/2026-08-14-marketplace-architecture.md
§5 (the three brokerage modes) ·
../internal/ee-licensing-design.md ·
../internal/ee-licensing-commercial-architecture.md
(the rulings doc; R3 2026-07-29 retired the certificate leg) ·
../internal/ee-licensing-invoice-to-rights.md.
0. The one-paragraph answer
Section titled “0. The one-paragraph answer”A marketplace paid install adds almost no licensing machinery and one
genuinely new plane. The purchase→entitlement substrate is built and
verified: ERPNext invoice → broker POST /record → Keygen record keyed on
metadata.domain → domain-proof → a signed, domain-bound shclic.v1 token
the daemon verifies offline against an embedded Ed25519 key. A marketplace
paid install reuses that verbatim for anything SHC itself asserts. What it
adds is (a) a request/approval state machine in front of the purchase, (b)
per-app entitlement codes rather than per-estate tier codes, and (c) for
proxied upstream licences, a secret-delivery path that is not minting at
all, and (c) is the only genuinely new plane. ★ (c) is now ruled OUT of
v1 (§5.0): third-party proxying waits, the v1 answer is link-out, and the
tree already refuses custodial-key by name, so v1 adds (a) and (b) only.
The seam that needed a ruling was not any of that: it was that the broker
binds entitlement to a domain proven by DNS control while the portal binds
to a cluster registration, and those are two spellings of one identity.
That seam is now ruled: registration is the durable identity, domain-proof
is retained as the bootstrap (§2.2).
1. The chain, verified by content, and where the thesis was wrong
Section titled “1. The chain, verified by content, and where the thesis was wrong”The thesis under test was:
purchase (ERPNext paid Sales Invoice) →
POST /record→ Keygen licence carryingmetadata.domain→ estate activates via domain-callback ({domain,nonce}, authoritative-DNS resolve + pinned dial + nonce echo, NO cert leg) → broker mints a signed domain-boundshclic.v1token folding policy entitlement codes +max*caps + expiry → runtime stays offline thereafter.
Every leg of that is correct except the last clause, and one path name. Corrections, in descending order of consequence:
1.1 ★ “Runtime stays offline thereafter” is FALSE as stated (verified)
Section titled “1.1 ★ “Runtime stays offline thereafter” is FALSE as stated (verified)”The runtime verification is offline forever: signature + domain + expiry,
against modules/license/pubkey.go, no network, on every boot and every 6h
cron. That part is exactly right and is the load-bearing property.
But the files expire and are re-fetched, so a paid online estate contacts the vendor on a schedule. Measured, not paraphrased:
| fact | value | source |
|---|---|---|
| file term when the Keygen record has no expiry | 35 days, rolling forever | brokerd/keygen.go defaultRollingTTL |
| overage file term | 35 days | brokerd/keygen.go overageTTL |
| file term when the record has an expiry | the record’s paid-through date | brokerd/keygen.go, the rec.Attributes.Expiry switch |
| re-verify cron | every 6 hours, LeaderOnly: false | modules/license/crons.go |
| renewal window | clamp(term/3.5, 10d, 45d) | modules/license/policy.go RenewalWindow |
| churn backoff | 6h → daily after 28 consecutive failures (~1 week) → weekly after 56 (~1 month) | modules/license/policy.go ChurnBackoff |
| grace after lapse | 14 days | modules/license/grace.go GraceDuration |
The 6h cron is a floor, not a rate: DecidePoll (policy.go) refuses to
ask at all unless the estate is trialing, degraded, inside a renewal window, or
over baseline. StateUnlicensed, StateDev, StateUninitialized,
StateReplicating and any license.offline estate poll zero times, ever.
So the honest claim is the one §4 of the commercial doc already makes:
“contacts us once per term to renew, and otherwise not at all”, and for an
annual committed estate that is roughly once a year. It is not “never”.
This distinction is the whole basis of §7’s correction, so it is stated first.
1.2 There is a fourth broker route the thesis omits: POST /refresh (verified)
Section titled “1.2 There is a fourth broker route the thesis omits: POST /refresh (verified)”brokerd/refresh.go. It is not /activate again. A refresh presents prior
proof: the estate names the licence ID it currently holds, and if the
minter implements LicenseRecordLookup and the broker’s system of record
still associates that ID with that domain, the callback is skipped. When
prior proof is absent (a trialing estate, a delinked one, a revoked record),
the callback runs exactly as /activate does, same verifier, same
requirements. There is no weaker path into a first licence.
This matters for the marketplace because it is the route a per-app entitlement change would ride: a newly approved paid app is a record edit, and the estate picks it up at the next refresh or at a gate-miss, without re-proving domain control.
1.3 The vendor-only surface is three routes, not one (verified)
Section titled “1.3 The vendor-only surface is three routes, not one (verified)”brokerd/server.go registers /activate and /refresh unconditionally, and
then, only when LB_VENDOR_TOKEN is set, /mint, /record and
/sync. An unarmed broker does not 401 those routes, it 404s them
(the route is never registered). The ERPNext README’s verification step keys
on exactly this: a 404 on /record means the token or the Keygen backend is
missing.
1.4 ★ Path drift: apps/business/keygen does not exist (verified)
Section titled “1.4 ★ Path drift: apps/business/keygen does not exist (verified)”brokerd/doc.go, brokerd/mint.go, brokerd/keygen.go and
brokerd/record.go all name apps/business/keygen. There is no
apps/business bucket in the catalog at all. The app is
apps/standalone/keygen. Nothing breaks (these are comments), but four
files point a reader at a directory that has never existed, and this document
would be repeating the error if it did not say so. Owed: a comment-only sweep.
1.5 What the thesis got right, and should stay right
Section titled “1.5 What the thesis got right, and should stay right”metadata.domainreally is the lookup key, and the exact-compare trap is real and documented in three places (record.goRecordRequest.Domain,erpnext/README.md,License.DomainMatches).cloud.acme.com≠acme.com, no suffix match, no wildcard, and the failure reads asX403035LICGRT“no purchase on record” with no hint that the domain is what is wrong.- The cert leg is genuinely gone (R3).
brokerd/doc.gonames the retired codeX403033LICTLSand states DNS control is the proof, on the ACME HTTP-01 precedent. What survives is authoritative NS walk → publicly-routable-address wall → IP-pinned dial → no redirects → nonce echo. - Multi-vantage validation is a deployment posture, not code: N broker replicas on different networks behind the activation host. The app package is stateless with no volumes precisely so replicas scale freely.
- Money never touches crypto. ERPNext holds one broker token; it never holds Keygen credentials and never holds the signing seed.
2. ★ THE SEAM: domain-proof vs cluster registration (RULED; see §2.2)
Section titled “2. ★ THE SEAM: domain-proof vs cluster registration (RULED; see §2.2)”This is the headline. Two identity notions exist in two lanes, and whichever gets coded first would have won by accident. The owner ruled on 2026-08-16: registration is the durable identity, domain-proof is retained as the bootstrap. §2.2 carries the ruling; §2.5 carries its honest limit.
The broker’s notion. Entitlement binds to a DOMAIN proven by DNS control.
The runtime check is License.DomainMatches(SHC_HOST), offline, exact,
normalized. The Keygen record is keyed on metadata.domain.
The portal’s notion. Entitlement rides a CLUSTER REGISTRATION. The sibling
doc’s §5 assertion is signed with the cluster registration credential and
is bound to the cluster id; the §6 anti-replay property is that the
assertion was minted by the target cluster. Cluster.account_owner is what
routes a purchase approval.
2.1 First, dissolve two false problems (verified)
Section titled “2.1 First, dissolve two false problems (verified)”“A cluster has several domains” is already resolved, cluster-side, to one.
modules/license/domain.go makes the estate serving domain an estate-wide
replicated fact: the node that knows it (SHC_HOST, else the
license.domain override) publishes it to a cluster-scoped kv row, and a node
that does not materialises estate-domain.json beside license.lic. Every
app’s own ingress hostname is irrelevant to licensing. So SHC’s own
entitlement has exactly one licensed domain per estate, by construction. (This
fix was not cosmetic: before it, joined nodes resolved their domain to ""
and discarded the estate’s own replicated licence on every reverify, observed
live on both production estates, 2026-07-30.)
The format already supports several, but the broker never emits them.
License.Domains is a list and DomainMatches is a membership test
(modules/license/license.go:322). Both minters emit a single-element
list (GrantsMinter.Mint: Domains: []string{req.Domain}). So multi-domain
is a capability that exists and is unused, which is exactly what makes the
domain-change fix in §2.4 cheap.
2.2 ★ RULED (owner, 2026-08-16): registration is the DURABLE identity; domain-proof is how a cluster DEMONSTRATES entitlement on the offline/self-serve path. Both retained.
Section titled “2.2 ★ RULED (owner, 2026-08-16): registration is the DURABLE identity; domain-proof is how a cluster DEMONSTRATES entitlement on the offline/self-serve path. Both retained.”RULED. This section was written as a recommendation and the owner ruled on it the same day. Registration-as-identity is the direction of authority, and domain-proof is retained as the bootstrap, the way a cluster demonstrates entitlement before, or without, a registration to lean on, and the only binding an offline verifier can evaluate.
Retaining domain-proof is not a hedge. It is what keeps the self-serve path
alive (shc license activate with no key, no account and no portal), keeps
the vendor-mint bootstrap loop-breaker working, and keeps a multi-week vendor
outage a “customers can’t grow” event rather than an outage; see §2.3
Alternative B, every line of which is a thing this ruling declines to break.
What the ruling obliges the next lane to do, concretely:
- Code
metadata.domainas an attribute of a registration, not as the record’s primary key. The Keygen record stays keyed onmetadata.domainat the broker wire level (that is the built substrate and this ruling does not rewrite it), but the system of record for identity is the registration, and the domain is a field on it. - §2.4’s dual-domain transition file becomes owed work rather than a
sketch: on a domain change, update
metadata.domainand mint one transition file carrying both domains for a single term. No format change is needed (License.Domainsis already a list,DomainMatchesalready a membership test; §2.1), and no invoice history is orphaned. - Nothing at runtime changes yet. §2.5 records the honest limit and is not repealed by this ruling; it is scoped by it: the ruling settles the direction, the limit describes how much of it is buildable today.
The argument that produced it, retained in full and in descending order of force:
-
The install channel is already keyed on cluster id, and entitlement is keyed on domain. If those stay two independent keys, every paid install needs a join between them that nothing maintains. That failure has a name in this repo:
brokerd/tiersync.goexists because “a projection with no projector looks exactly like a projection that is up to date”; two shipped features (SUPPORT_BUNDLE,MCP) were refused estate-wide on both production estates because a tier edit had no path to production at all. A domain↔cluster-id mapping with no projector is the same shape. Making registration the identity and domain an attribute of it removes the join rather than maintaining it. -
Registration survives events domain-identity cannot. A domain change, a second estate under one account, an airgapped cluster with no reachable domain, an estate migrating between hosting providers; under domain-as-identity each of these is a new Keygen record, which orphans the invoice chain (
metadata.invoiceis the audit link back to the money) and themetadata.noteoverride history. -
Domain-proof still has to exist, and cannot be replaced. It is the only answer to threat-table row 4 (“get a licence for a domain you don’t own”), and, more importantly, the runtime check is a domain compare performed offline. A registration credential proves we issued it; it proves nothing an airgapped daemon can check with no network. The binding in the signed file must stay a domain because that is the only thing the offline verifier can evaluate.
So the two are not competitors. Registration answers who is this customer’s cluster, across time. Domain-proof answers may this specific box receive a file bound to this specific name, right now.
2.3 What breaks under each alternative
Section titled “2.3 What breaks under each alternative”Alternative A: domain is the durable identity, registration is a view of it.
- A customer moving
cloud.acme.com→shc.acme.comself-inflicts a lapse: the held file stops verifying the momentSHC_HOSTchanges (X403030LICDOM), and the new domain has no record, so activation returnsX403035LICGRT(“no purchase on record”) to a fully-paid customer, with no hint that the domain is the problem. Today that is a support ticket and a hand-edit. - Airgapped clusters get an identity that is free text a vendor typed into
a
/mintcall. Nothing arbitrates two customers claiming one domain before the vendor types it. - The portal cannot express “this account owns three clusters” without inventing a second key anyway.
Alternative B: registration is the ONLY identity; drop domain-proof.
- The self-serve path dies. Today
shc license activatewith no key, no account and no portal produces a licensed estate. Requiring registration first makes the portal a hard dependency for entitlement, not just for the marketplace, and the marketplace architecture §1 already rules that an unregistered cluster gets no marketplace, a constraint entitlement must not inherit. - It breaks the bootstrap loop-breaker. The broker runs as an SHC app on a vendor estate that must be licensable without the broker. A registration dependency reintroduces exactly the chicken-and-egg the vendor-mint path exists to break.
- It breaks vendor-outage resilience (§8). Offline verification is what makes a multi-week vendor outage a “customers can’t grow” event rather than an outage. An identity that only the portal can assert is an identity the daemon cannot check when the portal is down.
2.4 What to do when a cluster changes domain, or holds several
Section titled “2.4 What to do when a cluster changes domain, or holds several”Changes. The registration keeps identity; the Keygen record’s
metadata.domain is updated, not replaced. Because Domains is already a
list and DomainMatches is already a membership test, the cutover needs no
format change: mint one transition file carrying BOTH the old and the new
domain for a single term, then drop the old on the next mint. The estate is
never unlicensed during the change, and no invoice history is orphaned. This is
a broker change (emit two entries) plus a portal verb; it is not a licensing
redesign.
Holds several. For SHC’s own entitlement, it does not; §2.1. For consumer (3) it emphatically does, and that is handled in §5.3.
2.5 The honest limit of this ruling
Section titled “2.5 The honest limit of this ruling”Registration-as-identity cannot be made load-bearing at runtime today. The
daemon has no registration-aware entitlement path, shc/modules/portal is a
feature-flagged skeleton that refuses X503145PTLNYI past the flag, and the
sibling doc’s “the daemon is the final authority” is ruled and owed, not
built; see §8.
★ Amended: the framing “a direction for the next lane to code against” described a request, and the request has been answered. §2.2 is now a ruling. What survives here is not a caveat on the decision; it is a statement about the tree: the ruling is a direction of authority the next lane codes against, and no running code implements it yet. Read this section as scope, not as doubt. Anyone quoting §2.2 in a design must still say “ruled and owed”, exactly as §8 requires for the install channel.
3. Consumer (1): SHC EE itself, the reference implementation (verified, built)
Section titled “3. Consumer (1): SHC EE itself, the reference implementation (verified, built)”Stated briefly because it is the only one that exists end to end, and because the other two are described as deltas from it.
- Tiers are data. The binary contains zero tier definitions. It knows
feature KEYS and reads VALUES from the signed payload.
record.go’svendorTiersmaps a tier id to a Keygen policy plus entitlement CODES;keygen.golowercases each code into a feature key. Adding a tier is a data change with no binary release. - The Pro→Enterprise delta is four codes, and that is the whole of it:
TENANCY,SUPPORT,CUSTOM_IMAGES,WHITE_LABEL(enterpriseOnlyCodes). Hobby is the one tier that is a strict subset rather than a smaller Pro. - Caps are enforced at the growth verb, not centrally.
max_seatsatCreateUser, estate-wide (daemon/wiring/user_seat_gate.go);max_tenantsat tenant create (modules/tenant/create_count_gate.go);max_nodes/max_coresat node join (modules/cluster/license_gate.go). All refuseX403031LICLIM, all soft-degrade, none touch existing resources. - The projector problem is solved and documented.
SyncTiersruns at broker startup so rolling the image is the sync. - Known gaps carried forward:
quotaandfleetare wired but latent;multi_provideris sold and ungated (nothing counts providers per family). Readmodules/license/feature_kind.gobefore quoting the entitlement list as a statement of what a lapsed licence loses.
4. Consumer (2): third-party developer apps sold through the marketplace
Section titled “4. Consumer (2): third-party developer apps sold through the marketplace”4.1 The signing question, and the recommended deal
Section titled “4.1 The signing question, and the recommended deal”A third-party app sold in the store would verify its entitlement against the
Ed25519 public key embedded in SHC binaries. That means SHC signs assertions
about someone else’s product, and the developer cannot verify
independently; they have no key, and there is exactly one seed in the whole
system (§12 key custody: “one public key in source, one private seed in
custody”).
RECOMMENDATION: state that plainly as the deal: the app is licensed WITHIN SHC, rather than building a per-developer CA. The framing sentence: your app’s entitlement is an SHC entitlement. We assert it, we sign it, we enforce it at our gates. You are selling into our licence plane, not shipping your own. This is precisely the GitHub Apps posture the sibling doc §8 already cites as precedent: an app installed onto an org relies on GitHub’s installation token, not on its own PKI.
The per-developer-key alternative, honestly costed. It is buildable and it is expensive:
- The format changes.
shclic.v1carries one signature over the raw payload bytes and the verifier holds one embedded key. Per-developer keys means either a key-id field plus a key directory shipped in the binary (which makes onboarding a developer a binary release, the exact property the data-driven design was built to avoid), or a chain. - A chain does not work here, and the reason is already written down. §12 rejected root+intermediate for the vendor’s own key: “offline verification means revocation cannot exist, so a leaked intermediate keeps working against shipped binaries anyway.” A per-developer intermediate is that problem multiplied by the number of developers, with the compromise surface moved outside our control.
- It buys the developer very little. They still cannot enforce anything; enforcement happens in SHC’s gates, in SHC’s daemon, on the customer’s estate. A signature they can verify is an audit capability, not a control.
- It costs the customer. Every additional trust root is another thing that can expire, leak, or be mis-shipped, in a plane whose entire selling point is “one public key in source, one private seed in custody”.
If a developer’s objection survives that, the correct answer is a read capability, not a key: give them the sales visibility described next, so they can reconcile revenue against installs. That is what they actually want.
4.2 ★ The real missing surface: DEV-SCOPED SALES VISIBILITY
Section titled “4.2 ★ The real missing surface: DEV-SCOPED SALES VISIBILITY”This is the concrete gap, and it does not exist in any form today.
What it is. A developer selling app X must be able to read their own
invoices, entitlements and install counts, and nobody else’s. Today the
entire sales record lives in ERPNext Sales Invoices, whose fields are the
vendor’s own (custom_shc_estate_domain, custom_shc_keygen_license_id, …),
and whose natural permission model is “an ERPNext user who can read Sales
Invoice can read all Sales Invoices”. Handing a third-party developer an
ERPNext login is handing them the vendor’s whole book.
Why it cannot be solved by ERPNext permissions alone. A per-developer ERPNext role with a row-level restriction is one misconfiguration away from leaking every customer’s name, domain and spend to a third party, and the restriction has to hold across list views, reports, the REST API and exports. That is a large, permanently-load-bearing permission surface guarding someone else’s commercial data.
RECOMMENDED SHAPE (recommendation, not a ruling). A projection, not a permission: the developer reads a derived, developer-scoped ledger in the marketplace bench, the same bench the storefront already runs on (marketplace §3), populated by a one-way job from ERPNext. The developer never authenticates to ERPNext at all. Properties that follow:
- The blast radius of a bug is the projection, not the book of record.
- The projection carries only what the developer is owed a view of: their app, their units, their revenue share, their aggregate install count. Not the customer’s domain, not the customer’s name; a marketplace developer has no standing to receive our customer roster, and shipping it to them would create an obligation nobody priced.
- It composes with the L2 seal (
portal-cluster-identity§4): a sealed cluster still generates a purchase record, and the developer’s view is a billing projection, so nothing about the seal special-cases it.
Scoped work items, so this is actionable rather than a gesture:
- A developer-account population in the marketplace bench, distinct from portal/marketplace customer accounts. (This is a fourth population on top of the sibling doc’s three: anonymous, portal accounts, cluster tenant users. Naming it now avoids it being merged into “portal accounts” by accident.)
- The ERPNext → marketplace-bench revenue projection job (one way, idempotent,
invoice-id-keyed, the same reconciler doctrine
sync_paid_invoices.pyalready follows). - The per-app ownership binding: which developer account owns which catalog app, and what happens on transfer.
- A revenue-share rate field (marketplace §4 leaves the percentage TBD).
- A published statement of what a developer can and cannot see, because the answer to “can you see who bought it” must be the same before and after a customer asks.
5. Consumer (3): proxied upstream licences: the odd one out
Section titled “5. Consumer (3): proxied upstream licences: the odd one out”5.0 ★ RULED (owner, 2026-08-16): THIRD-PARTY PROXYING IS NOT IN V1
Section titled “5.0 ★ RULED (owner, 2026-08-16): THIRD-PARTY PROXYING IS NOT IN V1”“probably the initial version won’t even support third party proxying.”
RULED: v1 does not proxy third-party licences. Everything in §5.1–§5.4 stands as the design for when it does, and none of it is v1 work.
★ This matches the code exactly, which is why it costs nothing to rule.
§5.1 verified it below: of the five modes in the licence socket, byol-var
is the only live one (one consumer, apps/enterprise/windmill), and
custodial-key, which is consumer (3), is a typed-error stub that refuses
by name with X501891APLCUSTK (“not implemented yet custodial licences
arrive with the portal Keygen integration”, modules/applicense/errors.go,
builtin/license/license.socket.yaml). The other three modes, byol-file,
custodial-domain-registration, vendor-api, are stubs too. The ruling
does not defer work; it declines to start it, and the tree already says so out
loud in an error code. Nothing has to be removed, reverted or feature-flagged
to honour this.
★ The owner’s link-out instinct is exactly byol-var. He said “we might
link out to it”, and that is not a new mode; it is the mode that already
works, described from the storefront’s side:
List the app. Link to the vendor. The customer buys, and pastes the key.
Mechanically: the listing carries a “requires a licence from <vendor>”
statement and an outbound link; the customer transacts with the vendor
directly; the key arrives as a deployment var
(shc install windmill -i license=LICENSE --var license.key=<key>), refused by
name with X400891APLKEYNF if empty. Six catalog packages already carry
requires_paid_license: true and declare the need without brokering it
(§5.2); link-out is that marker plus a URL.
What link-out buys, stated as the three liabilities it does not incur: each of which is a whole subsection of this document that v1 now does not have to answer:
| liability | under proxying | under link-out |
|---|---|---|
| reseller agreement (§5.4) | a per-vendor legal check gating every brokered app, some vendors prohibit third-party resale outright | none: the customer is the vendor’s counterparty, as they already are today |
| secret custody (§5.1, §5.3c) | we hold and re-deliver someone else’s key, in a custodial store we have to build | none: the key is the customer’s, pasted by the customer, and the vault handling already exists |
| lapse asymmetry (§5.3c) | we can stop renewing but cannot revoke; a customer who stops paying us keeps working until upstream’s expiry, possibly eleven months | none: we were never the licensee of record, so there is nothing to be asymmetric about |
That third row is the one to notice. §5.3c calls the asymmetry “the structural fact” of proxying and spends five design responses on it. v1 does not have it, and the reason is not that we solved it; it is that we declined the position that creates it.
When this reopens: custodial-key is a designed slot with a name, an
error code and a catalog guard pinning the closed mode set. Filling it is a
decision to take on the three rows above deliberately. §9 Q5 (which vendors
are brokerable) and Q6 (upstream term policy) are not v1 questions while
this ruling stands, and are marked accordingly.
5.1 ★ It is SECRET DELIVERY, not minting, and the plane already exists
Section titled “5.1 ★ It is SECRET DELIVERY, not minting, and the plane already exists”The artifact is the upstream vendor’s key, not an shclic token. Nothing
in license-broker/ is involved: no Ed25519 signature, no domain binding, no
entitlement codes, no expiry we control. Treating it as a mint is the single
most likely way to get this section wrong.
The correction to the brief that matters most: this plane is already built as a socket, and four of its five modes are typed-error stubs. (verified)
builtin/license/ is a master-tenant system app (nginx answering /healthz,
deliberately dumb; it exists to be the exec context for the socket’s
dispatch), reached by consumers through the LICENSE magic token
(-i license=LICENSE), registered by the proprietary modules/applicense.
(★ Path corrected on amendment: this document first wrote apps/license/.
There is no such directory; the package is builtin/license/, and the
master-tenant guard refuses any non-builtin app in master, which is why it has
to be. Same class of error as §1.4’s apps/business/keygen, caught before it
propagated.)
builtin/license/license.socket.yaml dispatches on exactly five ruled modes, and
modules/applicense/errors.go is their Go-side single source:
| mode | state | code |
|---|---|---|
byol-var: user provides the key, it rides a deployment var | LIVE, one consumer | X400891APLKEYNF on an empty key |
byol-file: user provides a licence FILE | STUB: needs the daemon-side file store | X501890APLFILE |
custodial-key: we purchase and custodian the key | STUB: “arrives with the portal Keygen integration” | X501891APLCUSTK |
custodial-domain-registration: no key exists; the vendor registers the estate’s domain (plane.so-style) | STUB | X501892APLCUSTD |
vendor-api: auto-provision through the vendor’s own API | STUB | X501893APLVAPI |
custodial-key is consumer (3). It is declared, coded, named in a closed
set pinned by a catalog guard, and refuses by code. That is a much better
starting position than the brief assumed, and it means this section is
specifying the contents of a designed slot rather than a new subsystem.
The socket file also states the separation this document should not blur:
this is “the THIRD-PARTY app licence plane … deliberately distinct from SHC’s
OWN entitlement licence (shc license, modules/license): two different
products’ paperwork, never one surface.”
The only live consumer is apps/enterprise/windmill: license.plug.yaml,
mode byol-var, var license.key, with a post-deployment job that reads
/proc/1/environ in the windmill-server container to assert the key actually
landed (never printing it). Note its second warning: the key alone does not
flip the edition; EE features live in windmill’s EE image, so a real BYOL
also repoints images.windmill. A custodial mode inherits that problem.
5.2 ★ apps/enterprise/defectdojo and apps/classic/defectdojo-classic do NOT do this (verified)
Section titled “5.2 ★ apps/enterprise/defectdojo and apps/classic/defectdojo-classic do NOT do this (verified)”Checked because the brief asked. The only occurrence of the string “keygen”
in either package is a comment in vars.yaml noting that DefectDojo’s
first-boot JIRA webhook secret is printed to stdout: “same leak class as
keygen:setup’s key banner”. It is an analogy to the Keygen app’s setup
command leaking a key into a container log. It is not licence proxying, not
a Keygen integration, and not a license plug.
What DefectDojo actually carries is the marker, not the machinery:
requires_paid_license: true with a class-(b) reason: since DefectDojo 3.0,
SAML/OIDC/OAuth SSO and RBAC are DefectDojo Pro only, so the package ships no
oidc.plug.yaml and its SHC answer is --gated (a Keycloak wall in front of
DefectDojo’s own login, not a sign-in). Six catalog packages carry
requires_paid_license: true today.
Conclusion: nothing in the catalog proxies an upstream licence. One package does BYOL (windmill). Everything else that needs a commercial licence merely declares that it does. Consumer (3) is greenfield inside a designed slot.
5.3 The three consequences, worked through
Section titled “5.3 The three consequences, worked through”(a) Upstream binds to ITS OWN identity notion, and it will not match ours.
Our proof is this DNS name is under your control. Upstream’s binding is a
seat count, an instance UUID, a hostname, an activation count, or a licence
server heartbeat. Concretely: the domain we proved is the estate serving
domain (SHC_HOST); the hostname an upstream app will bind to is the app’s
own ingress hostname, which is a different string, and there may be several
per estate (this is where §2.4’s “holds several” actually bites). Three
consequences:
- We cannot promise portability. Moving an app between estates, or changing its ingress hostname, may invalidate an upstream licence in ways our own machinery would have absorbed. That has to be said on the listing, not discovered.
- Seat counts are unobservable to us in general. SHC meters its own estate seats via the Keycloak realm inventory. It does not know how many users exist inside a third-party app’s own user table, and it has no right to. Any per-seat proxied licence is sold on a number the customer asserts.
- The custodial store must record upstream’s identity fields verbatim, as opaque data. The moment we try to derive them from our own facts, we are guessing on the customer’s behalf about someone else’s contract.
(b) Renewal runs on UPSTREAM’s clock. Our whole cadence design, 35-day
rolling files, clamp(term/3.5,10d,45d) renewal windows, peak sizes the next term, overage never back-billed, is ours because we control both ends.
None of it applies. A proxied licence renews when upstream says, in upstream’s
units, possibly on a calendar we cannot query. Design consequence: the
custodial record must carry upstream’s own expiry as a first-class field and
alarm on it independently of every shclic clock. Do not fold it into the
estate’s licence posture; a customer whose SHC licence is perfectly current can
have a lapsed proxied app, and shc license status must not imply otherwise.
(c) ★ LAPSE IS ASYMMETRIC: we can stop renewing, we CANNOT revoke.
This is the structural fact and it deserves to be designed for rather than discovered. Once an upstream key is delivered to a customer’s estate, it is a secret in their possession, on their hardware. If they stop paying us:
- we can stop paying upstream, so we stop renewing;
- we cannot claw the key back, and upstream generally will not revoke on our say-so (and may not be able to; most of these keys are themselves offline signed artifacts, for the same reasons ours is);
- so the customer keeps working until upstream’s expiry, which may be eleven months away.
Note the shape: this is the same exposure our own design deliberately accepts (§14a, “the baseline clone window becomes a year for annual customers”), but there we chose the exposure and can shorten it, and here it is chosen for us.
Design responses, in order of value:
- Prefer short upstream terms even at worse unit price. The exposure window is the upstream term. If a vendor sells monthly, buy monthly and eat the margin; the difference is cheaper than a year of unbilled use.
- Never let the proxied term outrun the paid-through date. Do not pre-purchase a 12-month upstream key against a monthly SHC subscription. If upstream only sells annual, then the SHC-side sale must be annual too, or the deal is knowingly underwritten.
- Make the asymmetry a pricing input, not a surprise. Proxied apps carry real bad-debt risk that first-party entitlements do not, because first-party entitlements self-expire in ≤35 days.
- Do not build a revocation mechanism that cannot revoke. Marking the
custodial record “revoked” while the customer’s app keeps running is worse
than nothing: it makes our records say a false thing. Record it as
lapsed-but-live-until
<upstream expiry>and let that date drive collections. - Secret hygiene, since this is secret delivery: the key lands in the
estate vault, is never echoed (the
byol-varjob already models this; it tests presence and never prints), and the custodial store keeps a copy because we are the licensee of record and will need it again.
5.4 One factual flag on resale, not legal advice
Section titled “5.4 One factual flag on resale, not legal advice”Reselling another vendor’s commercial licence generally requires a reseller or partner agreement, and some vendors’ terms prohibit third-party resale or third-party provisioning outright. The marketplace architecture already concedes the shape of this: “at least the 3rd party ones that will let me” and “vendors that do not permit third-party provisioning are simply not brokered.” The point worth recording is the timing: checking a vendor’s terms costs an afternoon before the mode is built and a rebuild after. Suggest a per-app field in the custodial record naming the agreement (or its absence) that authorises the proxy, so the answer to “may we resell this” is stored next to the thing being resold rather than remembered.
6. ★ THE RULING: approval and spending limits are ONE state machine (owner, 2026-08-16)
Section titled “6. ★ THE RULING: approval and spending limits are ONE state machine (owner, 2026-08-16)”This is the FRONT END of everything above. Recorded here as the licensing
pipeline’s entry point; the purchasing-authority half is
2026-08-16-portal-cluster-identity.md
Ruling 1, which this extends rather than restates.
BUILT 2026-08-16:
2026-08-16-install-request-state-machine.md
is the implementation record: the state machine, the four policies and all
three traps below, in frappe/apps/portal/portal/install_request.py, with
mutation proofs. Read its §5 before describing a paid install as working:
the grant seam is deliberately unwired, and the reason is a finding about
this document’s own §8: POST /record keys its lookup on
metadata.domain and holds exactly ONE record per estate, so a per-app
grant posted to it would overwrite the estate’s tier record rather than add
an entitlement.
Every paid install is a REQUEST. Policy decides whether a human sees it. A spending limit is an AUTO-APPROVAL RULE, not a second path. One state machine, one audit record, one grant point.
The reasoning, so it is not re-derived: removing the request path to “just do
pre-approval” removes the audit record and the escape hatch at once. A limit is
a predicate evaluated inside the request flow; auto_approved_by_policy
is a decision outcome, not a bypass. Every request therefore produces a row
whether a human touched it or not, and there is exactly one place where a
grant is issued.
6.1 Trap 1: RECURRING vs TRANSACTION spend
Section titled “6.1 Trap 1: RECURRING vs TRANSACTION spend”A $20/mo app under a $100/mo budget consumes budget forever, not once. Evaluate a subscription request against committed recurring spend, not against the transaction amount:
committed_monthly_recurring + this_request_monthly <= monthly_limitEvaluate a one-time purchase against a separate one-time allowance. Twelve individually-correct $20/mo approvals under a $100/mo limit land at $240/mo, and every one of those decisions was right in isolation. The limit must be a statement about the running total, and the running total must be recomputed from the grant ledger rather than decremented from a counter; a counter drifts on cancellation, refund, downgrade and failed provisioning, and a drifted budget counter fails open.
6.2 Trap 2: the budget check and the grant must be ATOMIC
Section titled “6.2 Trap 2: the budget check and the grant must be ATOMIC”Two requests evaluated concurrently against the same budget both pass and both
grant. This is the classic check-then-act race, and it has a precedent in this
tree: modules/cluster/enroll_capacity_race_test.go exists because the node
capacity gate had the same shape. The budget check and the grant write must
happen under one transaction (or one serialized decision point) against the
grant ledger, not “check, then call the broker, then write”. The broker call
is the slow, failable part and must sit inside a reservation the ledger
already holds, released on failure.
6.3 Trap 3: the limit is set by the APPROVER, in the PORTAL, never cluster-side
Section titled “6.3 Trap 3: the limit is set by the APPROVER, in the PORTAL, never cluster-side”A control the restricted party can flip is not a control. This is exactly
the principle portal-cluster-identity §4.1 uses for the L2 seal, applied in
the mirror direction: there, the control must be enforceable at the cluster
because the vendor is the restricted party; here it must be enforced at the
portal because the cluster’s users are.
Concretely: the spending limit lives on the portal-side cluster record, next
to Cluster.account_owner, is editable only by the account that owns the
billing relationship, and is never a daemon config key, never a
shc config set, never a var. The daemon does not need to know it; the daemon
is not the approver, and §8 records that the daemon is not even the final
authority on installs yet.
6.4 Trap 4: requests must EXPIRE, and the requester must be told
Section titled “6.4 Trap 4: requests must EXPIRE, and the requester must be told”An unexpiring request queue becomes a zombie queue: the approver stops reading
it, the requester assumes denial, and the queue’s existence starts arguing that
approval is theatre. Requests carry a TTL, expire to a terminal state
(expired, distinct from denied; they are different facts about the
approver), and the requester is notified on expiry, over the same channel
§2.1 of the sibling doc routes the original notification (the daemon, because
the tenant realm holds the requester’s email). Silent expiry is the failure
mode; an expired request the requester never heard about is worse than a
denial.
6.5 What already exists here (verified), and the pricing question it partly answers
Section titled “6.5 What already exists here (verified), and the pricing question it partly answers”The owner’s suspicion that tiersync.go and the max* caps mean cap
machinery is present is correct, with one important boundary.
What works today, live:
- Per-seat caps work.
max_seatsis enforced atCreateUser, estate-wide across every tenant realm (daemon/wiring/user_seat_gate.go), refusingX403031LICLIMat the cap while existing accounts keep working. The file records why the population is the estate and not the realm: a realm-scoped count withmax_seats=100across five 90-account realms produced zero refusals at create time and then froze every mutation at 540 seats: “an estate can never be locked for exceeding a cap that its own gates would have let it pass.” - Per-core and per-node caps work at node join, with a deliberate fail-open
on registry-read faults, backstopped by the hourly sampler and the R16
compliance gate (
modules/license/capgate.godocuments the fail-open and why it stays). - Per-tenant caps work at tenant create.
- Metering is real: an hourly sampler records a per-term high-water mark
(nodes/cores/seats/tenants) persisted through the replicated config table so
it survives leadership moves, and that peak rides the renewal ask
(
PeakRecord,usage.go). - All three pricing strategies are already expressible in the record:
one-time (perpetual record,
termOptional), subscription (record expiry + rolling ~35-day files), per-seat/per-core (maxSeats/maxCores+ peak-driven resizing). Themeteredflag on atierSpecis what selects the metered treatment.
The boundary that matters for the marketplace: every one of those meters counts the SHC estate: SHC’s realms, SHC’s nodes, SHC’s tenants. None of them counts anything inside a third-party app. So “per-seat pricing” is already answered for SHC EE and is not answered for a marketplace app whose seats live in its own user table. Marketplace §4 anticipates this: the meter spec is “anything SHC has information on … plus an SHC API apps push their own metrics into”, and that push API does not exist.
6.6 ★ RULED (owner, 2026-08-16): PER-SEAT DOES NOT WORK FOR THIRD-PARTY MARKETPLACE APPS
Section titled “6.6 ★ RULED (owner, 2026-08-16): PER-SEAT DOES NOT WORK FOR THIRD-PARTY MARKETPLACE APPS”RULED: per-seat is not a pricing model a third-party marketplace app may use. One-time and subscription are.
And record WHY, because “the metrics-push API is unbuilt” understates it by a category. Building the push surface would not fix this. The defect is not missing plumbing:
The app runs on the customer’s own hardware and SELF-REPORTS. The count is unverifiable BY CONSTRUCTION.
Follow it through. A metrics-push API is, definitionally, the customer’s container telling us a number. The container is on the customer’s machine, under the customer’s root, running an image the customer can pin, patch or replace. There is no observation point we hold. A customer who reports 5 seats while running 500 is not defeating a control; there is no control to defeat, and there is no audit that could find out without an inspection right on their infrastructure that the entire product exists to avoid. §5.3(a) already reached the same wall from the proxying side: “any per-seat proxied licence is sold on a number the customer asserts.”
★ The contrast that makes this precise, and that keeps it from reading as a general objection to per-seat:
| SHC’s own meters | a third-party marketplace app | |
|---|---|---|
| who counts | SHC’s code, in SHC’s daemon (user_seat_gate.go at CreateUser) | the app’s own code, in the app’s own user table |
| enforcement point | the growth verb itself: CreateUser refuses X403031LICLIM at the cap | nothing; the app has no reason to consult us and no obligation to |
| what a false number gets you | nothing; the gate refuses before the seat exists | the seats, silently |
| verifiability | SHC controls the counting code | self-report on the customer’s hardware |
Per-seat works for SHC’s own meters precisely because SHC controls the counting code and the refusal point. The seat gate does not measure seats and bill for them; it refuses to create the 4th one. That is enforcement, not metering, and it is why the number can be trusted: an over-count cannot occur, because the excess account never comes into existence.
One-time and subscription do not depend on measuring anything. A one-time purchase is a fact about a transaction; a subscription is a fact about a date. Neither asks the customer’s hardware a question, so neither inherits the problem. That is the whole reason they remain available and per-seat does not.
Consequence for the metrics-push API (§8 item 6): it is not a prerequisite for per-seat pricing, because per-seat is ruled out for this consumer regardless. If it is built, build it for what it can honestly support (dashboards, capacity hints, a developer’s own view of their app’s usage (§4.2)), and do not present a self-reported number as a billing meter.
7. ★ CORRECTION: “gate at the edge with forward-auth” on entitlement lapse was WRONG
Section titled “7. ★ CORRECTION: “gate at the edge with forward-auth” on entitlement lapse was WRONG”An earlier assistant recommendation to the owner said that entitlement lapse should be handled by gating at the edge with forward-auth. That recommendation is withdrawn. It is wrong, and the reason is architectural rather than stylistic.
Why it is wrong. Edge forward-auth gating implies the edge asks “is this customer current?” at request time. That is a live billing check on the serving path, and it destroys the property the entire design was built around: verification is local, offline, and needs no vendor. It would make our availability a dependency of the customer’s availability, break every airgapped estate by construction, and violate the published fine print that “we cannot turn your infrastructure off.” It also converts a licensing outage into a customer outage, the exact inversion §8 forbids.
The right answer is the one the design already has. Enforcement is by expiry, not by lookup. The token carries its own validity window; the estate renews while online; the daemon verifies offline; an offline estate keeps working until the token lapses. Nothing phones home to enforce anything. Time is the enforcement mechanism.
The corrected version, with the actual numbers rather than the adjective
“short-lived” (verified, §1.1): a rolling file is 35 days
(defaultRollingTTL, overageTTL), a record-bound file runs to the record’s
paid-through date, the re-verify cron fires every 6 hours but only asks
when state says to, the renewal window is clamp(term/3.5, 10d, 45d),
so ~10 days of a 35-day file, and a lapse is followed by 14 days of grace
(GraceDuration) before anything freezes. An annual committed estate inside
its baseline asks roughly once a year.
7.1 What lapse should DO to a running paid app
Section titled “7.1 What lapse should DO to a running paid app”RECOMMENDED: never destroy data, and never stop a container. That is already the floor and it should extend unchanged to marketplace apps: a marketplace app whose entitlement lapsed is in exactly the position an over-capacity estate is in.
What the token expiring actually causes today (verified,
modules/license/lock.go, compliance.go, grace.go):
- At expiry, the resolver moves to
StateDegraded. Growth verbs refuse; everything running keeps running. - The 14-day grace clock starts at the first observed lapse.
- After grace, the estate freezes: no installs, no deployment updates or
re-rendering restarts, no config/cluster/tenant/seat changes, and no
backup create and no restore, all
X403038LICLCK. - Never affected, at any point: running stacks keep serving and no
container is ever stopped; start/stop/restart of existing deployments
stay allowed; reads always pass (the CE middleware short-circuits
GET/HEAD/OPTIONS before it ever asks), so
shc backup exportkeeps working and data stays downloadable; certs renew; DNS reconciles. - Instantly reversible with no vendor contact, and reversible offline: both lock conditions are computed from the local file and local counts.
- A never-licensed estate is never locked, under any condition.
What is NOT yet decided, and should be: a marketplace app is a tenant deployment, not an estate capability, so per-app lapse could plausibly mean (a) the estate-wide freeze above, (b) freeze changes to that one deployment only, or (c) nothing at all until the customer touches it. Recommend (b): scope the consequence to the thing that was not paid for. Freezing an entire estate because one $9/mo app lapsed is disproportionate, and it punishes every other tenant on the estate for a decision they did not make. This is listed as an open question in §9 because it is not ruled.
8. What a marketplace paid install ADDS, and what it reuses verbatim
Section titled “8. What a marketplace paid install ADDS, and what it reuses verbatim”Reused verbatim, no change
Section titled “Reused verbatim, no change”- The
shclic.v1format, the embedded pubkey, the offline verifier, the domain binding, the six-hourly soft re-verify, the union-of-files resolver. POST /record→ Keygen upsert keyed onmetadata.domain, idempotent on invoice id.POST /activate(first proof) andPOST /refresh(prior-proof re-fetch)./mintas the airgap/break-glass route.- The lock semantics, the grace window, and the no-rug floor.
- The
licensesocket andmodules/applicensemode dispatch, for consumer (3). SyncTiersat broker startup, as the pattern for any new entitlement code reaching production.
Genuinely added
Section titled “Genuinely added”- Per-app entitlement codes alongside per-estate tier codes. Mechanically
this is
record.go’s existing shape, codes on a policy, lowercased into feature keys, but the namespace is new: an app entitlement is not a tier entitlement, and the two must not collide in one flat key space. Owed: a naming rule before the first app code is coined. - The request/approval state machine (§6), with the recurring-spend predicate, the atomic grant, the portal-side limit, and request expiry.
- A developer-scoped sales projection (§4.2) and a fourth account population to read it.
- The custodial store for consumer (3): upstream keys, upstream identity
fields verbatim, upstream expiry as a first-class alarmable field, and the
reseller-agreement reference. This is the one genuinely new subsystem, and
X501891APLCUSTKis already the slot it fills. ★ NOT V1: §5.0 rules third-party proxying out of the initial version. The slot stays a typed refusal; the v1 answer is link-out viabyol-var. An✅ BUILT 2026-08-18: ce!114.installed_by-shaped record, which the sibling doc §9 verified does not exist:ce/ent/schema/deployment.gohas no installer/owner column, and the auditactorcolumn defaults to the literal"shc"with every producer setting a process name. Apps have owners is not sayable today.deployment.installed_byandvdeployment.installed_bycarry a closed<kind>:<id>actor grammar (user:<sub>@<realm>,local:,portal:[<account>]), nullable, with NULL meaning “the row predates the column”. Apps have owners is now sayable, for installs performed after the column landed; nothing was backfilled, because theactorcolumn named here is exactly why nothing honest could be. Shape: sibling §9.1. Still missing: the portal account, which the dispatch wire does not carry (sibling §9.2).A metrics-push API, if per-seat pricing is wanted for third-party apps (§6.5).★ STRUCK: §6.6 rules per-seat out for third-party apps entirely. The push API would not have delivered it: a number the customer’s own hardware self-reports is unverifiable by construction, so building the surface changes nothing about whether the meter can be trusted. If a push API is built, it is for dashboards and developer visibility, never as a billing meter.
★ Honest note on the install channel: ruled and owed, not built
Section titled “★ Honest note on the install channel: ruled and owed, not built”As 2026-08-16-portal-cluster-identity.md §1.5 established by reading
modules/portal/wire/wire.go: the down-channel today is exactly two directive
kinds (install_dispatch, catalog_query); InstallDispatch is {app, version}; Directive.ID correlates a directive with its answer. There is
no portal-user field, no requester field, and no cluster-minted
pending-request correlation. So the sibling doc’s §6 belt-and-braces
property, “the daemon honours an inbound install dispatch only if it matches
a pending request it minted”, is RULED AND OWED, NOT BUILT, and must not
be described as operative in any design that depends on it. Everything in §6 of
this document assumes it, so it is a hard prerequisite for the approval flow
being trustworthy end to end.
9. Owner questions this raises: one closed, two parked, the rest unresolved
Section titled “9. Owner questions this raises: one closed, two parked, the rest unresolved”Nothing above answers the unresolved ones, and no implementer should read a preference into the ordering.
Q1: Is the §2.2 direction of authority ruled? ✅ CLOSED: YES (owner,
2026-08-16). Registration = durable identity, domain-proof = demonstration
and bootstrap, both retained. The consequences the question named are now
owed work, not conditionals: the next lane codes metadata.domain as an
attribute of a registration rather than as the record’s key, and §2.4’s
dual-domain transition file is owed. See §2.2 for the ruling and §2.5 for
the honest limit; the direction is settled, no runtime code implements it
yet.
Q2: Per-app lapse scope (§7.1). Does a lapsed marketplace app freeze the estate, freeze only that deployment, or do nothing until touched? Recommended (b); not ruled.
Q3: Do we sign for third-party developers, and say so? (§4.1) The recommendation is to state “licensed within SHC” as the deal. Confirm, because the alternative gets much more expensive after the first developer ships.
Q4: What may a developer see? (§4.2) Specifically: aggregate installs only, or customer identity? The answer must be publishable and must not change after a customer asks.
Q5: Which upstream vendors are actually brokerable? (§5.4): ⏸ PARKED, NOT
V1. §5.0 rules third-party proxying out of the initial version, so no
custodial-key app exists to gate. The question returns intact the day
X501891APLCUSTK stops being a stub. Do not do the per-vendor legal sweep
now; its answers perish, and link-out (§5.0) needs none of them, because
the customer is the vendor’s counterparty.
Q6: Upstream term policy (§5.3c). ⏸ PARKED, NOT V1. Same reason: with no proxied term, there is nothing to outrun the paid-through date. The risk-appetite question is real and it is not a v1 question.
Q7: Recurring-spend accounting (§6.1). Is the limit monthly-recurring, annualised, or both with separate one-time allowance? And what happens to a committed recurring grant when a cluster is deregistered?
Q8: Request TTL (§6.4). How long, and does an expired request auto-resubmit or require the requester to ask again?
Q9: Entitlement key namespace (§8). Do app entitlement codes share the
flat feature-key space with tier codes (clustering, tenancy, …) or get a
prefix? Cheap to decide now; a migration afterwards.
Q10: The comment sweep (§1.4). apps/business/keygen appears in four
brokerd files and does not exist. Fix on touch, or a dedicated pass?
Bindings honoured
Section titled “Bindings honoured”R3 (2026-07-29): no certificate leg on the challenge; this document does not
reintroduce one. R15/R16: the strong lock and the over-capacity gate, quoted
from lock.go and compliance.go rather than paraphrased. R18: a permanent
entitlement is not a permanent file. §12 key custody: one public key in
source, one private seed in custody; §4.1 declines to multiply it. “Money never
touches crypto”: the developer sales projection in §4.2 is a read-only
derivation and writes nothing back. 2026-08-16-portal-cluster-identity Ruling
1 (request-and-approve), extended with the spending-limit mechanics, not
reopened. Sibling §3 (one-way federation), untouched; nothing here points an
arrow from a customer realm into our store. Placement: the licence socket is
shc-proprietary (marketplace §5); ce carries none of this.