Skip to content
SHC Docs

license-broker folds into the portal deployment: 2026-08-20

Owner, 2026-08-20: “the license broker should actually be part of our portal deployment”.

This is the continuation of the 2026-08-18 architecture ruling already recorded verbatim at the top of deploy/license-broker.shc.yaml:

“[shcd] is supposed to handle the cluster side of license… the license management itself, it’s keygen and any custom business logic, custom APIs… is supposed to be on the portal frappe.”

That file deferred one thing explicitly: “what can never move to Frappe is the signing seed and the shclic mint boundary the estates trust; where that lands is decided in the migration’s own lane, not silently here.” This document is that lane’s decision.

Verdict: the fold is correct, its tenant/database/ingress answers are all settled, and it is blocked on exactly one thing that is not mine to do: the marketplace bench’s own corp → shc tenant move, ruled on 2026-08-16 and still not executed. The design is below; the question is in §8. Nothing on the estate was mutated by this lane.


1. What “the portal deployment” is, concretely

Section titled “1. What “the portal deployment” is, concretely”

There is no stack named portal on the estate, in either tenant. Measured on bitspur-new (2.29.3.100), 2026-08-20:

$ shc ls -t corp | grep -iE 'market|portal'
marketplace corp prod /var/lib/shc/_w34/marketplace/marketplace running
$ shc inspect marketplace -t corp (stack_record.json)
"tenant": "corp", "stack_name": "marketplace", "environment": "prod",
"hosts": ["marketplace.selfhostedcloud.org",
"api.marketplace.selfhostedcloud.org",
"my.selfhostedcloud.org"],
"host_specs": [ marketplace:3000 , bench-web:8000 , portal:3000 ],
"access": "open", "exposure": "internet"

The portal is the marketplace stack. Owner ruling 2026-08-16 merged them onto one Frappe bench (one site, one database, two bench apps), and the 2026-08-17 ruling (“why the hell is this using frappe for the ui”) moved my.<zone> off the bench onto its own One runtime inside the same stack. The stack keeps the name marketplace deliberately (deploy/marketplace.shc.yaml explains why renaming it installs a second stack rather than renaming the live one).

So the candidates and their disposition, stated rather than picked silently:

candidatewhat it actually isis it “the portal deployment”?
marketplace stack, corp/prod9 services: bench-web/worker/scheduler/init/configure, mariadb, valkey, marketplace SSR, portal SSR. Serves all three selfhostedcloud.org product hosts.Yes. This is the deployment.
frappe/apps/portala bench app (code + schema) installed on that stack’s single sitea component of it, not a deployment
apps/portalthe One/Tamagui runtime image behind my.<zone>a service of it, not a deployment
shc portal (CLI)the estate-side verb that registers a cluster with the portala consumer, not the thing
deploy/shc/portal, deploy/portal.shc.yamldeleted 2026-08-16; merged_bench_test.go holds their tombstonesdoes not exist

Measured, same estate, same day:

$ shc ls -t shc
STACK TENANT ENV APP STATUS
keygen shc prod …/_platform/keygen/keygen running
keygen-db shc prod …/_platform/keygen-db/keygen-db running
license-broker shc prod …/_platform/license-broker/… running
  • Its own stack, tenant shc, env prod, app package license-broker/app (deliberately outside apps/, vendor infra, published only to the SHC-INFRA index).
  • One service, one image: registry.gitlab.com/…/license-broker:90c8d648@sha256:ffa1334c…, 384M/0.75 CPU, expose: 8080.
  • No volumes, no backup.yaml, no database. Stateless by construction: every /activate re-verifies from scratch and the rights ledger lives in Keygen. This is the single most important fact for §4.
  • One ingress host: license.selfhostedcloud.org → license-broker:8080, path /, access: open (ungated; the SSO forward-auth gate would 401 every machine activation).
    $ shc ingress ls | grep license
    ingress-shc_prod_license_broker.yaml shc_prod_license_broker
    license.selfhostedcloud.org http://shc_prod_license_broker-license-broker-1:8080
  • One integration: keygen plug → provider stack keygen, same tenant. The container is attached to shc_prod_keygen_public and dials LB_KEYGEN_URL=http://keygen-web:3000 with LB_KEYGEN_HOST=prod.keygen-web.keygen.
  • Live and armed, proven from outside the process:
    $ curl -s -o /dev/null -w '%{http_code}\n' --resolve license.selfhostedcloud.org:443:127.0.0.1 \
    -k https://license.selfhostedcloud.org/healthz
    200
    $ curl -s -o /dev/null -w '%{http_code}\n' … -X POST https://license.selfhostedcloud.org/sync
    401 # 404 would mean the vendor routes are unarmed
  • All four product hosts already resolve to the new cluster: license., marketplace., api.marketplace. and my. all answer 2.29.3.100. This is the live vendor estate, not a staging copy.

3.1 Tenant: shc, and the fold does NOT move the broker

Section titled “3.1 Tenant: shc, and the fold does NOT move the broker”

The merged deployment lives in tenant shc.

This is not a new ruling. docs/decisions/2026-08-16-marketplace-belongs-in-the-shc-tenant.md already decided it; owner: “SHC’s own products leave the corp tenant”, and the verdict there is “yes; marketplace belongs in the shc tenant, on the class criterion, and it is by a wide margin the cheapest of the three tenant moves.” Both packages tag themselves shc-infra; deploy/shc/marketplace/app.yaml names license-broker/app as “the nearest sibling in shape”.

So the fold crosses a tenant boundary in one direction only, and it is not the broker’s:

  • license-broker is already in shc (moved 2026-08-19 as the closure {license-broker, keygen, keygen-db}). The fold moves it nowhere.
  • marketplace is in corp and has to move to shc first. That move was ruled 2026-08-16 and has not happened.

There is no variant in which the merged stack sits in corp. The broker reaches keygen by bare service name on keygen’s provider overlay, and ce resolves an ordinary provider reference same-tenant only; the one cross-tenant door (ce/modules/app/integration_magic.go) is a closed allowlist holding a single row, KEYCLOAK, routed to master:

“a closed allowlist of system-namespace, critical-dependency providers… Every OTHER integration stays confined to the consumer’s own tenant.”

Keygen publishes no routed host at all (its stack record carries no hosts key), so there is no public fallback either. A broker in corp with keygen in shc mints nothing.

Putting keygen on the magic allowlist is not an escape: magic providers resolve to (master, default), and master is builtin-only (traefik/keycloak/openobserve/postgres). The customer rights ledger does not belong in the system tenant.

3.2 Database: there is none to argue about

Section titled “3.2 Database: there is none to argue about”

license-broker has no data store. No volumes in its compose, no backup.yaml, and its app package says why: “Stateless by design (every /activate re-verifies from scratch; purchases live in Keygen / the grants var); no volumes, no backup.yaml, and replicas scale freely.”

So the owner’s hard rule (never share a database across tenants) is not engaged by the broker in any variant of this fold. Concretely:

  • The broker gains no database from the fold. It does not get a table in the marketplace bench’s MariaDB. Folding it in means adding a container and a host to a compose project, not a schema to a site.
  • The rights ledger stays where it is: keygen-db, its own stack, its own tenant-local volume, in shc. Nothing about the fold touches it, and nothing about the fold gives the portal bench a connection to it.
  • The one database that moves is the marketplace bench’s own MariaDB, and it moves whole, with its stack, from corp to shc. That is relocation, not sharing; it is never readable from two tenants at once. Tenant isolation forbids the second, not the first.

That relocation is nevertheless the expensive part, because of what that database holds. From deploy/shc/marketplace/backup.yaml, verbatim:

the database this stack now carries holds Cluster, Registration Code, Support Grant, Install Request, Install Spending Policy, and… Portal Cloud Credential, Cluster Secret, Terraform Run and Terraform State. None of that is derived from anything. sites/ additionally holds the site’s encryption_key, which is the ONLY thing that can decrypt the __Auth rows those Password fields live in; a database restored without the matching sites volume is ciphertext.

The sites + mariadb pair is atomic or it is nothing. Any carry of this stack takes both, together, or produces a site that authenticates nobody and a provisioning ledger nobody can read.

3.3 Ingress: the broker keeps its own hostname. This is not negotiable.

Section titled “3.3 Ingress: the broker keeps its own hostname. This is not negotiable.”

license.selfhostedcloud.org stays a host, bound at path /, on the merged stack. It does not become a path on my.<zone> and it does not go internal-only.

modules/license/broker.go:

const DefaultBrokerURL = "https://license.selfhostedcloud.org"

“THIS VALUE IS SETTLED (owner ruling 2026-07-31, v0.0.12)… It is a FROZEN CONSUMER CONTRACT: every binary ever shipped renews from whatever hostname it was built with, and a binary in the field cannot be told a new one; that is the whole point of baking it in.”

There is no config key and no flag that changes where an estate renews (SHC_LICENSE_BROKER_URL is the dev-loop door only). broker_url_test.go already pins the literal; this lane adds tests/unit/catalog/broker_deployfile_tenant_test.go, which pins the other half: that the deployfile’s prod render equals that constant’s host, and that the broker is never bound at a path.

x-shc-path (secondary routes on one host) is the right tool for a surface that is genuinely a sub-path of another product. It is the wrong tool here: /activate, /register, /record, /sync and /mint are all root-relative on DefaultBrokerURL, and every binary in the field concatenates them onto it.

The merged deployment therefore serves four hosts from four services:

marketplace.<zone> marketplace:3000 SSR storefront, anonymous
api.marketplace.<zone> bench-web:8000 the Frappe bench, under its site name
my.<zone> portal:3000 the One runtime
license.<zone> license-broker:8080 the activation API <- new

access is a stack-level property and both stacks are already open, so the broker’s ungated posture survives the merge unchanged. exposure: internet (prod LE chain via acme-prod-dns-hetzner) is what the marketplace stack already has and what the broker needs.

The surface order matters: the first surface names the GitLab environment URL, so marketplace.{host} stays first and the broker is appended last.

4. Integrations: who consumes the broker, and what the fold does to each

Section titled “4. Integrations: who consumes the broker, and what the fold does to each”
consumerhow it reaches the brokereffect of the fold
every SHC estate in the field: POST /activate, the periodic soft re-verify, shc license refreshDefaultBrokerURL, compiled innone; same host, same path, same TLS chain
CI / lab estates: shc license register <code>, the shc_license terraform resourcesame host, POST /registernone
ERPNext: erpnext/sync_paid_invoices.py, invoice-paid → POST /recordbroker_url in its own config, over the public hostnone; and note ERPNext stays in corp; it calls the broker over the internet, not over an overlay, so no tenant edge exists to break
vendor ops: POST /mint, POST /syncsame host + LB_VENDOR_TOKENnone
keygen: the mint backendkeygen.plug.yaml → shc_prod_keygen_public, http://keygen-web:3000the one edge at risk. Same-tenant-only; survives iff the merged stack is in shc (§3.1) and the edge is re-established on it (§6.3)
the marketplace/portal benchdoes not call the broker today; frappe/apps/portal names it only in comments (dispatch.py:177, install_request.py:146,880), never in a requestunchanged; the 2026-08-18 ruling’s eventual “business logic on the portal frappe” is a later lane

Nothing else breaks. The two things that would break (the compiled-in host and the keygen overlay) are the two things §3.3 and §3.1 refuse to move.

Owner’s standing architecture (SHC canon: “builtin = traefik/keycloak/ openobserve/postgres ONLY; shcd owns branding + license cluster-side; frappe owns marketplace/portal/license business logic; keygen separate”), and the 2026-08-18 ruling restates it: “it’s keygen and any custom business logic… with Keygen staying its own service.”

So after the fold, tenant shc holds two deployments where it holds three today:

before after
keygen keygen (unchanged, own stack)
keygen-db keygen-db (unchanged, the ledger)
license-broker marketplace (storefront + bench + portal + broker)
marketplace (in corp)

The signing seed does not move to Frappe. It stays what it is: a required (non-autogen) vault ref resolved at install into SHC_LICENSE_SIGNING_KEY on the broker container, failing closed with X404905SECREQ when absent. The shclic mint boundary stays in the Go service. That is the part of the 2026-08-18 ruling this lane rules on, and the ruling is: the boundary does not move; only its deployment does.

6. The migration path for the existing deployment

Section titled “6. The migration path for the existing deployment”

Ordered, and each step is a decision someone can refuse.

6.1 Precondition: confirm which estate CI reaches

Section titled “6.1 Precondition: confirm which estate CI reaches”

SHC_HOST is a protected project CI variable. It read 37.27.215.210 on 2026-08-16 (the legacy cluster). The estate flipped to 2.29.3.100 on 2026-08-19 and all four product hostnames now resolve there. The legacy host is still up and answering ICMP. Nobody plays any gate until SHC_HOST is read and confirmed to name the cluster that is actually serving. This is not part of the fold; it is a precondition of any deploy from this repo.

6.2 The marketplace tenant move: the gating step, not mine

Section titled “6.2 The marketplace tenant move: the gating step, not mine”

marketplace must be at (shc, marketplace, prod) before anything is folded into it. Two mechanisms exist and they are not equivalent:

  • shc move --target-tenant shc (clone.Move): a real relocation, carries the mounts. This is the path the licence closure took on 2026-08-19, and it came back with three open ce bugs measured on this estate: a quiesce hook unexecable mid-move (X500467BKPHKF), cross-tenant recovery discarding the scaffold error (X404401STKNOF; ce!33 fixed preflight only), and the move leaving targets stopped and routeless. On a stateless 256M broker that is an annoyance. On the stack holding customer cloud credentials, the cluster registry and terraform state it is an outage plus a manual repair.
  • backup → install-in-shc → recover → retire corp; the deployfile path cannot relocate (§5 of the 2026-08-16 decision: “a tenant change is a fresh install, not a relocation”), so this is the explicit-carry alternative. It produces a provable archive of the sites+mariadb pair before anything is destroyed, which the live saga does not. It costs a downtime window, because two stacks cannot both hold marketplace.selfhostedcloud.org (see 6.5), and the archive is customer cloud credentials; the portal-backup-guard.sh custody rules apply to it in full.

Do not flip deploy/marketplace.shc.yaml to tenant: shc before the move. The CI existence check matches the tenant, so a flip ahead of the move takes the install branch and stands up a second, empty bench beside the live one, both claiming three public hostnames. That flip is step 3 of the 2026-08-16 decision’s own order of operations and it is the last step, not the first.

6.3 Re-establishing the keygen edge: one manual command, and it has to be

Section titled “6.3 Re-establishing the keygen edge: one manual command, and it has to be”

The deployfile grammar has no integrate: key (ce’s deployfileRaw is stack/app/public/domain/vars/surfaces/environments), and the CI deploy path emits no -i; shc-base.yml builds exactly shc install|update $TENANT_FLAG … $HOST_FLAGS $PUBLIC_FLAG $VAR_FLAGS.

The socket-less fallback is closed too, and this is measured rather than assumed:

$ shc deploy -f probe2.shc.yaml -e prod --dry-run
shc: [X400408DPFREQ] deployfile …: vars.keygen.token is missing or unusable:
'keygen.token=ref+vault://keygen_admin_token' carries characters outside
[A-Za-z0-9._:@/=-]; the same charset the CI generator enforces

ref+vault:// cannot be spelled in a deployfile var, because + is outside the generator’s safe() charset. So the token can only ever arrive as a default in the app package’s own vars.yaml (which is correct and is where signingKey already lives), and apiUrl/apiHost/accountId can only arrive from the socket.

Therefore the edge is created once, by hand, and then never again:

Terminal window
shc update marketplace -t shc -e prod -i keygen=keygen

shc update documents this as supported in place: “Integrations are persistent deployment state like routes, ports and --var overrides: -i oidc=keycloak adds or repoints ONE edge and leaves every other integration on the deployment wired.” There is no shc integration add; shc integration is ls/plugs/sockets only, so shc update -i is the whole mechanism. It is one command, it is logged in the ops intervention log, and every subsequent CI deploy replays it from persisted state.

This is a genuine product gap and belongs on the zero-manual-intervention backlog: a deployfile cannot express an integration, so any stack with a plug needs one out-of-band command before CI can own it.

  • deploy/shc/marketplace/compose.yaml gains the license-broker service, lifted verbatim from license-broker/app/compose.yaml, including its healthcheck, its resource limits and its {% if integrations.keygen … %} block.
  • deploy/shc/marketplace/ gains keygen.plug.yaml (copied from license-broker/app/), so the plug’s required: guard still fails the install fast rather than letting the container crash-loop.
  • deploy/shc/marketplace/vars.yaml gains the broker’s var tree: signingKey (the required vault ref), callbackTimeout, vendorToken (empty by default; arming it is a per-install decision), keygen.* and images.licenseBroker.
  • deploy/marketplace.shc.yaml gains the fourth surface license-broker:8080@license.{host} and images.licenseBroker.
  • deploy/license-broker.shc.yaml is deleted in the same commit; TestExactlyOneDeployfileBindsTheBroker fails otherwise, and two deployments on one hostname is not refused anywhere.
  • license-broker/app/ stays (do not delete it): it is still published to the SHC-INFRA index that terraform’s shc_deployment reads, and license-broker/README.md’s terraform wiring depends on it.

6.5 The cutover, and why it needs a window

Section titled “6.5 The cutover, and why it needs a window”

Two deployments claiming one hostname is not an error anywhere. ce’s error corpus has no cross-tenant hostname claim (the only “already claimed” host error is X400988PRTDUP, about shared-vip ports), and the ingress is written one file per deployment:

ingress-shc_prod_license_broker.yaml license.selfhostedcloud.org
ingress-corp_prod_marketplace.yaml marketplace./api.marketplace./my.

A second file with the same Host rule is a tie traefik breaks by router name, not something an operator is told about. So the old license-broker stack is uninstalled in the same window the merged stack takes over the host, and the activation baseline (healthz + a fixed-nonce /activate decline, which is byte-deterministic) is captured before and after.

6.6 What the fold costs, stated so it is a choice

Section titled “6.6 What the fold costs, stated so it is a choice”
  • The licence mint path inherits the storefront’s release cadence. Today the broker is a stateless container nobody restarts. Folded in, every marketplace deploy re-renders and recreates it, and every bench migration window is a window in the same compose project as the mint path.
  • Multi-vantage validation gets harder. license-broker/README.md names the compensating control for dropping the TLS leg: “run several broker replicas on different networks/providers behind the activation host.” Replicas of a service inside a stack that also owns a singleton MariaDB are pinned to that stack’s placement.
  • The image pin weakens. The live broker runs a digest-pinned image (:90c8d648@sha256:ffa1334c…) and license-broker/app/vars.yaml argues at length why a signing service must not ride a moving tag. Both deployfiles override with ${CI_REGISTRY_IMAGE}/…:${CI_COMMIT_SHORT_SHA}, immutable by convention, not by digest. That trade is already made by the deployfile; the fold inherits it rather than introducing it.

None of these is disqualifying. All three are the price of the direction the 2026-08-18 ruling set, and they should be paid knowingly.

Landed (safe, reversible, and required by every variant of the fold):

  1. deploy/license-broker.shc.yaml gains tenant: shc. This closes a live one-click hazard that predates the fold: the file landed 2026-08-18, the closure move to shc happened 2026-08-19, and the file’s own header still claimed “after the move the keys agree”. They did not; with no tenant: key the deploy targets $SHC_TENANT (measured corp), so playing gate_prod:license-broker would have installed a second broker in the tenant the live one had just left, both claiming the activation host. With the key, the CI existence check matches shc/license-broker/prod and the same click becomes an ordinary update of the live stack.

    Proven end-to-end against the pinned generator (cicd@0ac192a4):

    $ CI_REGISTRY_IMAGE=… CI_COMMIT_SHORT_SHA=deadbeef sh generate.sh
    generate.sh: 2 deployfile(s): deploy/license-broker.shc.yaml deploy/marketplace.shc.yaml
    ...
    deploy_prod:license-broker:
    SHC_STACK: license-broker
    SHC_STACK_TENANT: shc
    SHC_HOSTS: "license-broker:[email protected]"
  2. tests/unit/catalog/broker_deployfile_tenant_test.go: three guards that make the half-fold un-landable: exactly one deployfile may bind the broker service; the deployfile that does must pin tenant: to keygen’s tenant; and its prod render must equal license.DefaultBrokerURL’s host, at path /. The middle one fails on main as it stands and passes after (1).

  3. This document.

Deliberately not landed:

  • The merged compose/vars/surface (§6.4). Landing it before the marketplace tenant move would arm a worse hazard than the one being fixed: one click on gate_prod:marketplace would add a broker container to the corp stack, where it would claim license.selfhostedcloud.org against the live broker and crash-loop, because main.go exits 1 with no mint backend and the deployfile path cannot give it one.
  • tenant: shc on deploy/marketplace.shc.yaml. That is the premature flip the 2026-08-16 decision’s §5 and §7 both warn about: the existence check would route the run to install, standing up a second empty bench beside the live one.
  • Any estate mutation. Nothing was installed, updated, moved, restarted or uninstalled by this lane; every command run against 2.29.3.100 was a read (ls, inspect, ingress ls, --help, deploy --dry-run on a throwaway file in /var/tmp/shct/broker/) or a curl probe.

Does the marketplace/portal bench move corp → shc now, and by which mechanism: the live shc move saga, or a backup-carry cutover with a window?

Everything else in this design is settled. That move is:

  • already ruled in principle (2026-08-16, “SHC’s own products leave the corp tenant”), never executed;
  • the only reason the fold cannot be done tonight, because the merged stack must share keygen’s tenant and keygen’s tenant is shc;
  • an operation on a live, customer-facing stack whose database holds Portal Cloud Credentials, Cluster Secrets and terraform state, whose sites volume holds the only key that decrypts them, and whose move path has three open ce bugs measured on this estate one day ago, one of which leaves the moved stack stopped and routeless.

The licence ledger on this estate has been destroyed once already by a terraform path. That is the standard this move has to clear, and clearing it is an owner decision with a window, not a lane decision at 06:00.

Once it is ruled, §6.3–6.5 are a single afternoon: copy four files, add one surface, delete one deployfile, run one shc update -i, capture the activation baseline either side.

  1. deploy/license-broker.shc.yaml targeted the wrong tenant. Fixed here. Severity: one click from two brokers on one hostname, silently.
  2. The two deployfile renderers disagree about tenant:. The cicd generator reads it (0ac192a4, “TENANT AXIS”); ce’s ParseDeployfile decodes with KnownFields(true) and has no Tenant field, so:
    $ shc deploy -f probe.shc.yaml -e prod --dry-run
    shc: [X400406DPFPRS] … line 3: field tenant not found in type commands.deployfileRaw
    The safeValue comment in that same file says a value one renderer accepts and the other refuses “would make a deployfile non-portable between the two renderers, the one thing the primitive exists to prevent.” Owed: a Tenant string \yaml:“tenant”`field plus its-tplumbing ince/modules/app/commands/deployfile.go`.
  3. A deployfile cannot express an integration. No integrate: key, no -i in shc-base.yml. Every stack with a plug needs one out-of-band shc update -i before CI can own it. Zero-manual-intervention backlog.
  4. ref+vault:// cannot ride a deployfile var (+ is outside the generator’s charset, X400408DPFREQ). Not a bug; the right answer is that secrets live in the package’s vars.yaml, but it should be stated in the deployfile docs rather than discovered.
  5. tests/unit/catalog/vendor_infra_placement_test.go’s rationale is stale. Its header still reads “Measured live on the bitspur estate, 2026-08-16. shc ls --all-tenants put license-broker at tenant=corp/env=prod” and “on the vendor’s own estate, where it MUST share a tenant with customer-facing apps”. Since 2026-08-19 the broker shares its tenant with nothing but keygen and keygen-db. The assertions are still correct (launcher_placed: false is still the right posture); only the argument is out of date. Left alone here to keep this MR’s diff about one thing.
  6. SHC_HOST has not been confirmed against the cluster flip (§6.1).

Appendix: every command this lane ran against the live estate

Section titled “Appendix: every command this lane ran against the live estate”

Zero mutations. Recorded verbatim because the rule is that manual estate commands get logged whether or not they changed anything, and because a design argued from an estate is only as good as the reads behind it.

All against ssh -i ~/.ssh/hel1_new [email protected] (bitspur-new, owner LIVE), 2026-08-20.

commandwhy
shc versionestablish the daemon build (0.0.60) before trusting any other read
shc tenant lsthe tenant census: shc 3 stacks, corp 79, master 4
shc ls -t shc / shc ls -t master / shc ls -t corp | grep -iE 'market|portal|frappe|erp|license|keygen'which tenant holds the broker, keygen and the portal today
shc inspect license-broker -t shcthe broker’s rendered compose, plug, hosts, integrations and networks, §2
shc inspect keygen -t shc | awk '/stack_record/,0'prove keygen has no routed host, so there is no public fallback
shc inspect marketplace -t corpthe portal deployment’s services, vars, hosts, backup.yaml, §1, §3.2
shc ingress lsthe live routers, one file per deployment, the collision argument in §6.5
shc --help, shc deploy --help, shc update --help, shc integration --helpestablish that -i is an install/update flag and that shc integration has no add, §6.3
shc deploy -f /var/tmp/shct/broker/probe.shc.yaml -e prod --dry-runprove ce’s parser refuses tenant: (X400406DPFPRS). Throwaway file in this lane’s own scratch dir; --dry-run needs no daemon and changes nothing
shc deploy -f /var/tmp/shct/broker/probe2.shc.yaml -e prod --dry-runprove ref+vault:// cannot ride a deployfile var (X400408DPFREQ)
curl … --resolve license.selfhostedcloud.org:443:127.0.0.1 -k https://…/healthz → 200the broker is serving
curl … -X POST https://license.selfhostedcloud.org/sync → 401the vendor routes are armed on the running image (404 would mean unarmed)

Off-estate, on the lane box: dig +short on the four product hostnames (all 2.29.3.100), ping -c1 37.27.215.210 (legacy cluster still up), and the pinned cicd@0ac192a4 generator run over deploy/ in a scratch dir to prove the emitted SHC_STACK_TENANT.