# LicensePanel — Installation Guide

> Hosted online at **<https://license-install.mod-sol-sa.com/>** (this page); the
> installer scripts and version index live on the same host.

**Audience:** operators installing and running LicensePanel on their own server.
**Scope:** Linux (primary) and Windows Server; Docker-stack and standalone-binary
shapes; online, manual-verified, and air-gapped installs; first-boot setup;
upgrade; uninstall; the `server` CLI; and troubleshooting.

> Conventions in this guide:
> - `https://license-install.mod-sol-sa.com/…` is the canonical install URL your vendor gives
>   you (one URL for all customers; it is **not** versioned — you pin versions
>   with `--version`). The container image is published as
>   **`registry.innovation-lab.co/modern-solutions/licensepanel`** (the self-hosted
>   Forgejo registry; Docker Hub + GHCR were retired 2026-08-05).
> - macOS is not supported in R1 (planned via a Homebrew tap later).

---

## 1. What you get

LicensePanel installs as a small, self-managing control plane that runs your
licensed Docker-stack product(s). After install you complete a one-time
**Initial Configuration** in the browser, then manage everything from the panel
UI or the `server` CLI.

It ships in **two artifact shapes** (same brand-agnostic build for every
customer — your identity is applied at license-activation time):

| Shape | When to use | What runs |
|---|---|---|
| **Docker image** (primary) | Default. Docker is available (or installable) on the host. | A small compose stack: `panel` + `panel-postgres` + `traefik` + `dockerproxy` (+ optional bundled Keycloak). |
| **Self-contained binary** (secondary) | Locked-down hosts that can't run the panel in a container. | The `licensepanel` binary as a **systemd unit** (Linux) or **Windows Service**, plus its `wwwroot/` UI assets. |

Both shapes contain the same binary, including the embedded **`server` CLI**
(see §10) and the React SPA.

---

## 2. Requirements

| | Linux | Windows |
|---|---|---|
| OS | Ubuntu/Debian/RHEL/Fedora (systemd) | Windows Server 2019+ / Win 10/11 |
| Arch | `amd64` or `arm64` | `amd64` (arm64 later) |
| Privilege | root / `sudo` | Administrator (PowerShell 7+) |
| Docker | Engine **≥ 24.0** with Compose v2 (auto-installed if absent, unless `--no-docker`) | Docker Desktop or Engine (not auto-installed in R1) |
| Ports | **80**, **443** (Traefik) and **8443** (panel + bootstrap) must be free | same |
| Disk / RAM | ~2 GB free for the panel stack; product stacks need their own | same |
| Network | Outbound HTTPS to the release feed + your image registry (or use air-gap, §9) | same |

The Linux installer **refuses** to run inside a container (`/.dockerenv`
present) and refuses a state directory with unexpected permissions.

---

## 3. Quick start

### Linux (Docker shape — the common case)

```bash
# Self-signed bootstrap (reach the panel by IP, finish setup in the browser):
curl -sSL https://license-install.mod-sol-sa.com/install.sh | sudo bash

# Or DNS-ready with automatic Let's Encrypt TLS:
curl -sSL https://license-install.mod-sol-sa.com/install.sh | sudo bash -s -- \
  --panel-host panel.acme.example --acme-email ops@acme.example
```

On success the installer prints exactly one URL, e.g.:

```
LicensePanel installed.
Open in your browser:
  https://203.0.113.10:8443/

Bootstrap mode is active for the next 60 minutes.
If you can't reach the URL, run:
  ./server bootstrap status
```

No password or secret is ever printed. Continue at **§6 First boot**.

### Windows Server

```powershell
iwr -useb https://license-install.mod-sol-sa.com/install.ps1 | iex
# with flags:
& ([scriptblock]::Create((iwr -useb https://license-install.mod-sol-sa.com/install.ps1).Content)) `
  -PanelHost 'panel.acme.example' -AcmeEmail 'ops@acme.example'
```

---

## 4. Installer flags

**No flag is required.** Bare `curl … | sudo bash` lands the panel in
bootstrap mode (self-signed cert on the direct-access port); finish setup
— domain, ACME email, challenge type, DNS provider, DNS credentials — in
Initial Configuration in the browser. The flags below are pre-seeds:
anything you pass here is what you'd otherwise type in IC.

Linux flags (PowerShell uses the `-PascalCase` equivalents):

| Flag | Default | Effect |
|---|---|---|
| `--panel-host <host>` | unset | Pre-seed the panel host. ACME engages at first boot *only* when paired with `--acme-email`; otherwise bootstrap self-signed cert and IC collects it. |
| `--acme-email <email>` | unset | Let's Encrypt account contact. Without it, ACME stays off and IC collects it later. |
| `--version <semver>` | `latest` | Pin the panel image/version (e.g. `1.0.0`). |
| `--no-docker` | off | Don't auto-install Docker (use the host's existing Docker/Podman, or the binary-service shape). |
| `--no-start` | off | Write all state but don't start the stack (staged installs / config management). |
| `--panel-port <port>` | 8443 (auto-free) | Direct panel-access port (`https://<ip>:<port>/`). Prefers 8443; if taken, the installer auto-picks the next free port. Pin a specific one with this flag. |
| `--http-port <port>` | auto (prefers 80, falls back to a free port if taken) | Edge HTTP. **Empty/unset = auto-fallback** — bare `curl\|bash` works on Dokploy/nginx/CDN-occupied hosts. An explicit value is a pin (hard-fail on conflict). HTTP-01 ACME needs port 80; if the auto-pick falls off 80, switch to DNS-01 in IC (§4a). |
| `--https-port <port>` | auto (prefers 443, falls back if taken) | Edge HTTPS. **Empty/unset = auto-fallback.** Customers reaching the panel on standard 443 will then need an upstream proxy/CDN forwarding to the auto-picked port. |
| `--acme-dns-provider <p>` | unset | Use **ACME DNS-01** instead of HTTP-01 for Let's Encrypt — no inbound port required. Required on hosts where port 80 is taken (Dokploy/existing reverse proxy/ISP block/CDN/firewall). `<p>` is a [Lego provider name](https://go-acme.github.io/lego/dns/) (`cloudflare`, `route53`, `digitalocean`, `hetzner`, `gcloud`, …). Implies `--acme-email`. See §4a. |
| `--acme-dns-env KEY=VAL` | unset | Provider API credentials, repeatable. Examples: `--acme-dns-env CF_DNS_API_TOKEN=…` (Cloudflare), `--acme-dns-env AWS_ACCESS_KEY_ID=… --acme-dns-env AWS_SECRET_ACCESS_KEY=…` (Route53). Stored at `.env.acme-dns` (mode 0600) and passed to Traefik via `env_file`; never echoed. |
| `--from-tarball <dir>` | unset | **Air-gap** install from a local directory holding the tarball + `SHA256SUMS.asc` (see §9). |
| `--help` | — | Print help and exit 0. |

Equivalent env vars exist for automation: `LICENSEPANEL_PANEL_HOST`,
`LICENSEPANEL_ACME_EMAIL`, `LICENSEPANEL_VERSION`, `LICENSEPANEL_NO_DOCKER=1`,
`LICENSEPANEL_UPGRADE=1`, `LICENSEPANEL_NO_START=1`, `INSTALL_FROM_TARBALL=<dir>`.

---

## 4a. Installing where ports 80/443 are taken (DNS-01 ACME)

Most production hosts already have something on ports 80/443 — Dokploy,
an existing nginx/HAProxy, a CDN edge, or a corporate reverse proxy. The
HTTP-01 ACME challenge that Let's Encrypt uses by default needs port 80
inbound from the CA (this is hardcoded in RFC 8555 and isn't negotiable).
For those hosts the panel switches to **DNS-01**: ownership is proven by
creating a TXT record at the operator's DNS provider — no inbound port
required, and wildcard certificates (`*.acme.example`) become possible.

Pick a [Lego DNS provider](https://go-acme.github.io/lego/dns/) for the
domain you'll point the panel at, then pass `--acme-dns-provider` plus
the API credentials that provider's page documents. The panel writes
them to `<state>/panel-stack/.env.acme-dns` (mode 0600) and applies a
Compose overlay that swaps Traefik's HTTP-01 args for DNS-01 args.

### Cloudflare (most common)

Create an [API Token](https://dash.cloudflare.com/profile/api-tokens)
with `Zone:DNS:Edit` scoped to the zone, then:

```bash
curl -sSL https://license-install.mod-sol-sa.com/install.sh | sudo bash -s -- \
  --panel-host panel.acme.example \
  --acme-email ops@acme.example \
  --acme-dns-provider cloudflare \
  --acme-dns-env CF_DNS_API_TOKEN=<token> \
  --http-port 8080 --https-port 8443
```

### AWS Route53

```bash
curl -sSL https://license-install.mod-sol-sa.com/install.sh | sudo bash -s -- \
  --panel-host panel.acme.example \
  --acme-email ops@acme.example \
  --acme-dns-provider route53 \
  --acme-dns-env AWS_ACCESS_KEY_ID=<id> \
  --acme-dns-env AWS_SECRET_ACCESS_KEY=<secret> \
  --acme-dns-env AWS_REGION=us-east-1 \
  --http-port 8080 --https-port 8443
```

### DigitalOcean

```bash
curl -sSL https://license-install.mod-sol-sa.com/install.sh | sudo bash -s -- \
  --panel-host panel.acme.example \
  --acme-email ops@acme.example \
  --acme-dns-provider digitalocean \
  --acme-dns-env DO_AUTH_TOKEN=<token> \
  --http-port 8080 --https-port 8443
```

### Windows (PowerShell)

```powershell
iwr -useb https://license-install.mod-sol-sa.com/install.ps1 -OutFile install.ps1
.\install.ps1 -PanelHost panel.acme.example -AcmeEmail ops@acme.example `
  -AcmeDnsProvider cloudflare `
  -AcmeDnsEnv 'CF_DNS_API_TOKEN=<token>' `
  -HttpPort 8080 -HttpsPort 8443
```

### How customers reach the panel when 443 is taken

DNS-01 solves *certificate issuance*. Customers still expect
`https://panel.acme.example/` on standard 443, so an upstream component
on that host needs to forward traffic on `:443` to the panel's Traefik
on the override port. Two production-clean patterns:

- **TLS pass-through** at the upstream proxy — SNI-based TCP forward
  from `:443` to the panel's Traefik on `:8443`. The panel terminates
  TLS with its DNS-01-issued cert. (Per-domain SNI matchers on the
  upstream.)
- **Reverse-proxy / re-terminate** at the upstream — the upstream
  terminates TLS for the customer domain (using *its* own ACME on the
  host's 80/443), then HTTP-proxies to the panel. The panel itself
  needs no public cert in this mode.

Either works; the choice is dictated by what reverse proxy is already
running on the host. The installer doesn't take a position — it just
makes the panel ACME-self-sufficient on a non-standard port so either
pattern is available.

---

## 5. What the installer does

1. **Preflight** — checks OS/arch, root, free ports (80/443/8443), and refuses
   to run inside a container.
2. **Docker** — verifies Engine ≥ 24 (installs via `get.docker.com` if missing
   and `--no-docker` is not set); ensures the daemon is running.
3. **State** — creates `/var/lib/licensepanel/` (mode `0700`) with
   `keys/`, `postgres-tls/`, `traefik/`, `data/`, and the `panel-stack/` compose
   files.
4. **Key custody** — generates a per-host master key (Linux: X.509 PKCS#12 +
   hardware-fingerprint binding; Windows: DPAPI machine scope) and a Postgres TLS
   cert + a self-signed bootstrap cert.
5. **Encrypted state DB** — initialises the SQLCipher-encrypted `state.db`.
6. **Start** — `docker compose up -d` brings up the panel stack (unless
   `--no-start`), waits for health, and prints the one bootstrap URL.
7. **Idempotency marker** — records version + timestamp so a re-run is detected.

State directories:

| | Linux | Windows |
|---|---|---|
| State root | `/var/lib/licensepanel/` | `C:\ProgramData\LicensePanel\` |
| Compose files | `/var/lib/licensepanel/panel-stack/` | n/a (service shape) |
| Binary (service shape) | `/opt/licensepanel/` | `C:\Program Files\LicensePanel\` |

---

## 6. First boot — Initial Configuration

Open the printed URL (`https://<host>:8443/`). The first browser hits a one-time
setup that is open for **60 minutes** ("bootstrap mode"). You provide:

- **Panel access** — host + TLS mode (`bootstrap_self_signed`, `acme`, or
  `custom_cert`); ACME email if using Let's Encrypt.
- **Defaults** — default locale (`en`/`ar`) and IANA timezone.
- **Operations** — audit retention days (≥ 30) and daily-prune toggle.
- **Authentication** — your identity provider: **Hosted Keycloak**,
  **Remote Keycloak**, or **Microsoft Entra ID**, plus the bootstrap admin email
  (and a generated admin password for Hosted Keycloak — save it when prompted).
- **SMTP** (optional).

Submitting commits everything atomically and **closes bootstrap mode**. You're
redirected to your IdP to sign in as the admin.

> **If the 60-minute window expires before you finish**, reopen it from the host:
> run `server bootstrap reactivate` (see §10) and reload the page.

> **Self-signed cert warning:** when you install without `--panel-host`, the
> bootstrap cert is self-signed — your browser will warn. Verify the fingerprint
> with `server bootstrap status` (it prints the cert SHA-256) before trusting it.

---

## 7. Choosing the distribution shape

- **Docker shape (default):** everything (panel, Postgres, Traefik, the Docker
  socket-proxy) runs as a compose stack. Traefik owns ports 80/443 and routes to
  the panel; the panel manages your product stacks through the hardened
  socket-proxy. This is the fully-wired, recommended path.
- **Binary / service shape (`--no-docker` hosts):** install from the tarball and
  register the `licensepanel` binary as a service. The panel still needs a
  container runtime (Docker or Podman) to manage *product* stacks; `--no-docker`
  only means *the panel itself* isn't containerised. See §8.
- **Inside an existing Dokploy (compose-app shape):** if you already run
  [Dokploy](https://dokploy.com), deploy the panel **as a Dokploy Compose app**
  instead of `install.sh`. Dokploy owns the edge (its Traefik) and lifecycle; the
  panel rides Dokploy's `dokploy-network`, and every installed product stack
  routes through the same Traefik automatically. No bundled Traefik, no
  `install.sh`. Requires panel ≥ 1.6.0. See
  [`infra/panel-stack/DOKPLOY.md`](../infra/panel-stack/DOKPLOY.md).

> The two co-existence stories are distinct: the **Docker shape** above can run
> *next to* a Dokploy/nginx edge that holds 80/443 (the installer auto-falls-back
> to free ports — §4a), whereas the **Dokploy compose-app shape** runs the panel
> *as* a Dokploy-managed app.

---

## 8. Manual (verified) install

For operators who want to inspect what they run before running it, or who deploy
the binary shape.

1. **Download** the artifacts — browse the version index at
   `https://license-install.mod-sol-sa.com/panel/` (or the GitHub Releases page);
   each version links to its assets on GitHub Releases:
   - `licensepanel-linux-amd64.tar.gz` (or `-arm64`, or `licensepanel-win-x64.zip`)
   - `SHA256SUMS` and `SHA256SUMS.asc`
2. **Verify the signature** against the vendor's published GPG key:
   ```bash
   gpg --verify SHA256SUMS.asc SHA256SUMS
   sha256sum -c SHA256SUMS --ignore-missing
   ```
3. **Extract** — the archive contains the `licensepanel` binary, its `wwwroot/`
   UI assets, and a `packaging/` directory (systemd unit + Windows service
   templates + `install-from-tarball.sh`).
4. **Install the binary shape (Linux):**
   ```bash
   sudo PREFIX=/opt/licensepanel ./licensepanel/packaging/install-from-tarball.sh
   ```
   This installs the binary, creates `/var/lib/licensepanel`, registers the
   systemd unit, and prints the bootstrap URL.
   **Windows:** run `packaging\windows\service-create.ps1` from an elevated shell.

---

## 9. Air-gapped install

Not shipped in R1. The previous `--from-tarball` flag verified the
tarball's PGP signature and SHA-256 but did not actually extract and run
the binary — a half-implementation we removed rather than ship as a
working-feature surface. Full air-gap support (verified extraction,
local-image-load, offline first-boot) will return as a real feature in
a later release.

If you need an offline install today, run the manual procedure in §8 on
the air-gapped host — it's the same steps without the network fetch.

---

## 10. The `server` CLI

The CLI ships inside the same binary (dual-mode: `licensepanel server <cmd>`).
Invoke it on the host:

```bash
# Docker shape:
docker compose -f /var/lib/licensepanel/panel-stack/docker-compose.yml \
  exec panel /app/licensepanel server <subcommand>

# Binary shape:
/opt/licensepanel/licensepanel server <subcommand>
```

(Older docs abbreviate these as `./server <subcommand>`.)

| Command | Purpose |
|---|---|
| `bootstrap status` | Show whether bootstrap mode is active + expiry + the self-signed cert fingerprint. |
| `bootstrap reactivate` | Reopen the 60-minute bootstrap window (only while no admin exists yet). |
| `healthcheck` | HTTP liveness probe of `/health` — exit 0 if healthy, non-zero otherwise (used by the container/service healthchecks). |
| `fingerprint` | Print the host hardware fingerprint for offline `.lic` activation. |
| `audit verify` | Verify the tamper-evident HMAC audit chain end-to-end. |
| `kek rotate` | Rotate the master key-encryption key (requires a restart). |
| `rollback` | Atomic binary + state rollback to the previous version. |

> Recovery/diagnostic commands above are wired today. The broader day-to-day
> management surface (projects, deploys, domains, licensing) is delivered through
> the panel UI; an expanded management CLI is on the roadmap.

---

## 11. Verifying the install

```bash
# Version (unauthenticated, static):
curl -fsk https://<host>:8443/api/version

# Deep health (200 healthy / 200 maintenance-degraded / 503 critical):
curl -sk -o /dev/null -w '%{http_code}\n' https://<host>:8443/health

# From the host, using the binary's own probe:
docker compose -f /var/lib/licensepanel/panel-stack/docker-compose.yml \
  exec panel /app/licensepanel server healthcheck
```

A panel that can't reach Postgres serves a **maintenance page** (it does not
crash-loop); fix the database and it recovers automatically.

---

## 12. Upgrading

**Use the panel UI: Settings → Updates → Apply.** From 1.5.0 onwards
upgrades are end-to-end self-managed. The operator does not SSH into the
host, does not re-run `install.sh`, and does not edit compose files. See
[ADR 0045](./adr/0045-migration-aware-self-update.md) for the contract.

What happens when you click Apply:

1. The panel polls the release feed, pulls the target image, and reads
   the migration manifest bundled at `/app/migrations/<version>.json` from
   that image.
2. The manifest is schema-validated server-side; an invalid manifest
   fails fast (`MIGRATION_MANIFEST_INVALID`) and nothing is mutated on
   the host.
3. A detached **updater container** applies the manifest's operations in
   order (new host directories, compose-file bind mounts, sibling-service
   restarts, retired companion stacks, `.env` keys) using a closed
   operation catalog — no shell escape hatches.
4. The updater re-pins `PANEL_VERSION`, pulls the new panel image, and
   recreates the `panel` service.
5. A 30 × 3 s health-gate against `/health` is the universal acceptance
   criterion. If any step or the gate fails, the updater reverses every
   reversible operation, re-pins the previous version, and brings the
   prior panel image back up. The SPA shows "Update failed, rolled back".

Before clicking Apply you can expand **"What will change?"** in the
confirmation modal — it lists every operation the manifest will perform
against the host. (Pre-1.5.0 image targets show no list; the older
image-swap-only flow applies.)

For the binary (service) shape — and as a manual override on the Docker
shape — `server rollback` reverts to the previous binary + state.

### Air-gapped upgrades

Same Settings → Updates flow once the panel can reach the release feed.
Operators running a private mirror of `https://license-install.mod-sol-sa.com/panel/`
point `Panel:UpdateFeedUrl` at it; everything downstream (manifest read,
migration apply, health-gate, rollback) is identical. The local-image-load
side of full air-gap support is still tracked under §9.

### Legacy: re-running `install.sh`

Re-running the installer remains idempotent and safe — useful for
recovering a broken panel-stack that can't reach its own UI, or for
pre-1.5.0 installs that don't yet carry the migration runner. For any
panel already on 1.5.0+, prefer Settings → Updates so the migration
contract (preview / health-gate / auto-rollback) applies.

---

## 13. Uninstalling

See [`implementation/uninstall.md`](./implementation/uninstall.md) for the full
procedure. In short: stop the stack/service, then remove the state root
(`/var/lib/licensepanel` or `C:\ProgramData\LicensePanel`) — **this deletes all
panel data, keys, and the encrypted state DB; back up first if needed.**

---

## 14. Unattended / config-management installs

```yaml
# Ansible
- name: Install LicensePanel
  shell: |
    curl -fsSL https://license-install.mod-sol-sa.com/install.sh | sudo bash -s -- \
      --panel-host {{ panel_host }} --acme-email {{ panel_acme_email }} \
      --no-start
  args:
    creates: /var/lib/licensepanel/.install-marker
- name: Start LicensePanel
  ansible.builtin.systemd: { name: licensepanel, state: started, enabled: true }
```

The `--no-start` + `creates:` pattern keeps the play idempotent.

---

## 15. Troubleshooting

### Installer exit codes

| Code | Meaning | Recovery |
|---|---|---|
| 0 | Success / idempotent re-run | — |
| 1 | Generic failure | Read the stderr message. |
| 2 | Preflight failed (RAM/disk; or an **explicit** `--http-port`/`--https-port`/`--panel-port` is in use) | The default ports auto-fall-back to a free port; an explicit override is a pin. Free the port or change/drop the flag. |
| 3 | Docker install failed | Install Docker manually, re-run with `--no-docker`. |
| 4 | *(reserved — air-gap install isn't shipped in R1)* | — |
| 5 | State dir has wrong permissions | Inspect `/var/lib/licensepanel` mode (expected `700/750`). |
| 6 | Hardware fingerprint failed | Ensure `/sys/class/dmi` is readable (bare-metal/VM, not a restricted container). |
| 7 | TLS cert generation failed | Check disk + OpenSSL availability; see install log. |
| 8 | `docker compose up` failed | `docker compose -f /var/lib/licensepanel/panel-stack/docker-compose.yml logs`. |

All install output is also written to `/var/log/licensepanel/install.log`.

### Common issues

- **Browser can't reach `https://<host>:8443/`** — confirm the firewall allows
  8443 and the stack is healthy (`server healthcheck`); the installer does **not**
  open firewall ports for you.
- **Bootstrap window expired** — `server bootstrap reactivate`, then reload.
- **Keycloak 401 during Initial Configuration** (bundled Hosted Keycloak) — the
  bundled admin credentials seed only on first volume creation; if stale, recreate
  the Keycloak data volume and restart the stack, then retry.
- **Panel shows a maintenance page** — Postgres is unreachable or a migration
  failed; check `panel-postgres` health and the panel logs. The panel recovers on
  its own once the DB is back.
- **Existing install detected** — a bare re-run is idempotent (no flag needed); state.db SHA-256 is checked to be unchanged. To wipe and start fresh, run the uninstaller (§13) first.

### Where to look

- Panel/stack logs: `docker compose -f /var/lib/licensepanel/panel-stack/docker-compose.yml logs -f`
- Service-shape logs: `journalctl -u licensepanel -f` (Linux) / Event Viewer (Windows)
- Health: `https://<host>:8443/health` · Version: `/api/version`

---

## 16. Reference

- **Ports:** 80, 443 (Traefik edge — overridable via `--http-port`/`--https-port`); the direct panel-access port defaults to **8443 but auto-selects a free port** if taken (`--panel-port` to pin). The installer preflights these and fails with guidance if 80/443 are occupied.
- **State root:** `/var/lib/licensepanel/` (Linux), `C:\ProgramData\LicensePanel\` (Windows).
- **Install host:** `https://license-install.mod-sol-sa.com` (scripts + `/panel/` version index).
- **Image:** `registry.innovation-lab.co/modern-solutions/licensepanel:{version}` (self-hosted Forgejo registry; Docker Hub + GHCR retired 2026-08-05).
- **Release artifacts** (GitHub Releases, linked from `/panel/`): `licensepanel-linux-amd64.tar.gz`, `licensepanel-linux-arm64.tar.gz`, `licensepanel-win-x64.zip`, `SHA256SUMS`, `SHA256SUMS.asc`; version index `latest.json` / `versions.json` at `/panel/`.
- **Related docs:** [`implementation/installation.md`](./implementation/installation.md) (design), [`implementation/uninstall.md`](./implementation/uninstall.md), [`implementation/updates.md`](./implementation/updates.md), [`implementation/reset-password.md`](./implementation/reset-password.md), [`adr/0008-distribution-and-installer.md`](./adr/0008-distribution-and-installer.md), [`adr/0044-single-binary-distribution-and-aot-burndown.md`](./adr/0044-single-binary-distribution-and-aot-burndown.md).

---

*Build & release internals (how these artifacts are produced) live in
[`superpowers/specs/2026-05-22-single-binary-build-and-release-design.md`](./superpowers/specs/2026-05-22-single-binary-build-and-release-design.md)
and `scripts/release.sh`.*
