WIP: M-1 handler sentinel error mapping (checkpoint before branch cleanup)

Uncommitted migration work at the time of branch cleanup. Tagged as
checkpoint/m1-migration-wip so the commit survives git gc --prune=now.

Session context: Phase 3 Part B+C of the M-1 sentinel error migration
was in progress. 38 modified files, 4 new files (errors.go + errors_test.go
in internal/service/ and internal/api/handler/). Resume from this commit
via 'git checkout checkpoint/m1-migration-wip'.

.env.example

@@ -13,43 +13,22 @@ POSTGRES_PASSWORD=change-me-in-production
 # Certctl Server
 # All server vars use the CERTCTL_ prefix (see internal/config/config.go)
 # ==============================================================================
-# IMPORTANT: keep the password segment of CERTCTL_DATABASE_URL in sync with
-# POSTGRES_PASSWORD above. If you deploy via `deploy/docker-compose.yml`,
-# this value is *overridden* by the compose file's
-# `postgres://certctl:${POSTGRES_PASSWORD:-certctl}@postgres:5432/...`
-# interpolation — but if you run the binary directly with this .env loaded
-# (e.g. `set -a; source .env; ./certctl-server`), update *both* lines.
-# Background: editing POSTGRES_PASSWORD after the postgres data directory
-# has been initialized once does NOT rotate the password — initdb only
-# seeds pg_authid on first boot of an empty volume. See docs/quickstart.md
-# "Warning" callout and `internal/repository/postgres/db.go::wrapPingError`
-# for the SQLSTATE 28P01 diagnostic that fires when the two drift.
-CERTCTL_DATABASE_URL=postgres://certctl:change-me-in-production@postgres:5432/certctl?sslmode=disable
+CERTCTL_DATABASE_URL=postgres://certctl:certctl@postgres:5432/certctl?sslmode=disable
 CERTCTL_SERVER_HOST=0.0.0.0
 CERTCTL_SERVER_PORT=8443
 CERTCTL_LOG_LEVEL=info
 CERTCTL_LOG_FORMAT=json
 
-# Auth type: "api-key" (production) or "none" (demo/development).
-# For JWT/OIDC, run an authenticating gateway in front of certctl
-# (oauth2-proxy / Envoy ext_authz / Traefik ForwardAuth / Pomerium) and
-# set CERTCTL_AUTH_TYPE=none on the upstream — see
-# docs/architecture.md "Authenticating-gateway pattern". G-1 removed
-# the in-process "jwt" option (no JWT middleware shipped — silent auth
-# downgrade); see docs/upgrade-to-v2-jwt-removal.md if you previously
-# set CERTCTL_AUTH_TYPE=jwt.
+# Auth type: "api-key", "jwt", or "none" (for demo/development)
 CERTCTL_AUTH_TYPE=none
-# Required when CERTCTL_AUTH_TYPE is "api-key".
+# Required when CERTCTL_AUTH_TYPE is "api-key" or "jwt"
 # Generate with: openssl rand -base64 32
 # CERTCTL_AUTH_SECRET=change-me-in-production
 
 # ==============================================================================
 # Certctl Agent
 # ==============================================================================
-# HTTPS-only as of v2.2 (TLS 1.3 pinned). Agents reject http:// URLs at
-# startup. Use the docker-compose self-signed bootstrap CA bundle from
-# `deploy/test/certs/ca.crt` or supply your own via CERTCTL_SERVER_CA_BUNDLE_PATH.
-CERTCTL_SERVER_URL=https://localhost:8443
+CERTCTL_SERVER_URL=http://localhost:8443
 CERTCTL_API_KEY=change-me-in-production
 CERTCTL_AGENT_NAME=local-agent
 

.github/coverage-thresholds.yml

@@ -1,107 +0,0 @@
-# Coverage floors per gated package.
-#
-# Each entry: floor: <integer percentage>, why: <load-bearing context>.
-# Adding a new gated package: one entry here; CI's `Check Coverage Thresholds`
-# step auto-picks up. Lowering a floor REQUIRES corresponding code-side test
-# work — never lower the gate to make CI green.
-#
-# Per ci-pipeline-cleanup bundle Phase 2 / frozen decision 0.3.
-
-internal/service:
-  floor: 70
-  why: |
-    Bundle R-CI-extended raise (post-Bundle-N.C-extended): service
-    55 → 70. HEAD 73.4% (3pp margin). Prescribed Bundle R target
-    was 80; held lower to avoid false-positives on single low-
-    coverage files dragging the global per-file-average down.
-
-internal/api/handler:
-  floor: 75
-  why: |
-    Bundle R-CI-extended raise: handler 60 → 75. HEAD 79.8% (4pp
-    margin). Prescribed Bundle R target was 80; held lower for
-    same reason as service layer.
-
-internal/domain:
-  floor: 40
-  why: |
-    Domain layer is mostly type definitions + validators; 40% is
-    the load-bearing-paths floor.
-
-internal/api/middleware:
-  floor: 30
-  why: |
-    Middleware coverage is per-handler-test-driven. 30% is the
-    floor that catches the wired-up middleware paths; the
-    unwired paths (alternative auth providers not currently
-    enabled) sit below.
-
-internal/crypto:
-  floor: 88
-  why: |
-    Bundle R closure CI checkpoint #3: crypto floor lifted 85 → 88.
-    Post-Bundle-Q package-scoped coverage at HEAD: 88.2%. The
-    remaining ~12% gap is platform-failure branches (rand.Reader /
-    aes.NewCipher) that require interface seams the production
-    code doesn't use; closing them is tracked as R-CI-extended,
-    not Bundle R scope.
-
-internal/connector/issuer/local:
-  floor: 86
-  why: |
-    Bundle R closure CI checkpoint #3: local-issuer floor lifted
-    85 → 86. Post-Bundle-Q package-scoped coverage at HEAD: 86.7%.
-    The prescribed Bundle R target was 92, but reaching it
-    requires interface seams for crypto/x509 signing-error
-    branches — tracked as R-CI-extended.
-
-internal/connector/issuer/acme:
-  floor: 80
-  why: |
-    Bundle R-CI-extended threshold raise (post-Bundle-J-extended):
-    ACME 50 → 80. The Pebble-style mock + per-CA failure tests
-    lift package-scoped ACME to 85.4%; gate at 80 with 5pp margin
-    to absorb the global-run per-file-average dip.
-
-internal/connector/issuer/stepca:
-  floor: 80
-  why: |
-    Bundle L.B / Coverage-Audit C-005 — StepCA failure-mode + JWE
-    round-trip tests lift package from 52.1% to 90.4% (per-package
-    run). Floor at 80 with margin.
-
-internal/mcp:
-  floor: 85
-  why: |
-    Bundle K / Coverage-Audit C-002 — MCP per-tool dispatch via
-    in-memory transport lifts package from 28.0% to 93.1% (per-
-    package run). Floor at 85.
-
-internal/auth:
-  floor: 85
-  why: |
-    Bundle 1 Phase 12 — RBAC primitive coverage gate.
-    internal/auth ships keystore + middleware + RequirePermission +
-    bootstrap + the Phase-3 context keys + the protocol-endpoint
-    allowlist. Negative-test coverage (no actor → 401, no role →
-    403, wrong scope → 403, bootstrap-token-wrong → 401, bootstrap-
-    used-twice → 410, admin-already-exists → 410, zero-length token
-    rejection) is now in place. Prescribed Bundle 1 target was 90;
-    held at 85 to absorb the per-file-average dip from the
-    middleware shim files (testfixtures.go) which CI runs but only
-    test fixtures exercise. Sub-package internal/auth/bootstrap
-    inherits this floor.
-
-internal/service/auth:
-  floor: 85
-  why: |
-    Bundle 1 Phase 12 — RBAC service-layer coverage gate.
-    PermissionService + RoleService + ActorRoleService + Authorizer
-    each have positive + negative tests covering the
-    privilege-escalation guard (auth.role.assign required for
-    Grant/Revoke), the reserved-actor invariant (actor-demo-anon
-    cannot be mutated), the canonical-permission validation, the
-    role-in-use guard on Delete, and every sentinel-error path
-    (ErrUnauthenticated / ErrForbidden / ErrSelfRoleAssignment /
-    ErrAuthReservedActor / ErrAuthUnknownPermission /
-    ErrAuthRoleInUse).

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.25.10'
+          go-version: '1.25.9'
 
       - name: Go Build
         run: |
@@ -28,28 +28,6 @@ jobs:
           go build ./cmd/mcp-server/...
           go build ./cmd/cli/...
 
-      - name: gofmt drift (Makefile::verify parity)
-        # ci-pipeline-cleanup Phase 4 / frozen decision 0.13: Makefile::verify
-        # checks gofmt + vet + golangci-lint + go test. CI runs vet, lint, test
-        # already — but NOT gofmt. This step closes the parity gap.
-        # Mirrors the Makefile::verify shape: any gofmt output means the
-        # source needs reformatting.
-        run: |
-          out=$(gofmt -l .)
-          if [ -n "$out" ]; then
-            echo "::error::gofmt would reformat these files (run 'gofmt -w' locally):"
-            echo "$out"
-            exit 1
-          fi
-
-      - name: go mod tidy drift
-        # ci-pipeline-cleanup Phase 4: catches PRs that import a package
-        # without committing the go.mod / go.sum update. Standard Go-CI
-        # gate; absent before this bundle.
-        run: |
-          go mod tidy
-          git diff --exit-code go.mod go.sum
-
       - name: Go Vet
         run: go vet ./...
 
@@ -63,59 +41,67 @@ jobs:
       - name: Install govulncheck
         run: go install golang.org/x/vuln/cmd/govulncheck@latest
 
-      - name: Run govulncheck (M-024 hard gate)
-        # Bundle-7 / D-001 partial: govulncheck distinguishes called-vs-uncalled
-        # advisories. Default exit code is non-zero only when YOUR code calls
-        # the vulnerable function — deferred-call advisories show up in the
-        # output but don't fail the gate.
-        #
-        # Bundle F / Audit M-024 (NIST SSDF PW.7.2): the govulncheck step
-        # is now a hard CI gate (no `continue-on-error`). Bundle E's
-        # transitive bumps (x/net 0.42→0.47, x/crypto 0.41→0.45) cleared
-        # the 5 deferred-call advisories that were previously on the
-        # exception list, so the carve-out the original Bundle F prompt
-        # designed is unnecessary — a clean `govulncheck ./...` is the
-        # right gate. If a future advisory lands in a function our code
-        # does call, this step fails the build until either upstream
-        # ships a fix OR we cut the dep. Deferred-call advisories that
-        # legitimately can't be remediated yet should be added to the
-        # NIST SSDF deviation log in docs/operator/security.md, not silenced here.
+      - name: Run govulncheck
         run: govulncheck ./...
 
-      - name: Install staticcheck (Bundle-7 / D-001)
-        run: go install honnef.co/go/tools/cmd/staticcheck@latest
-
-      - name: Run staticcheck
-        # Bundle-7 / D-001: Go static analysis additive to vet. Suppressed
-        # rules live in staticcheck.conf with documented justifications;
-        # adding a new entry requires an explicit security review.
-        #
-        # ci-pipeline-cleanup Phase 3 / frozen decision 0.7: HARD gate.
-        # M-028 SA1019 sites verified closed at HEAD 1de61e91:
-        #   - middleware.NewAuth: zero callers (all migrated to
-        #     NewAuthWithNamedKeys in cmd/server/{main,main_test}.go)
-        #   - csr.Attributes (internal/api/handler/scep.go × 2): inline
-        #     //lint:ignore SA1019 with load-bearing rationale (RFC 2985
-        #     challengePassword has no non-deprecated stdlib API)
-        #   - elliptic.Marshal: only in bundle9_coverage_test.go × 1 as
-        #     deliberate byte-equivalence regression oracle, suppressed
-        #     with //lint:ignore SA1019
-        run: staticcheck ./...
-
       - name: Race Detection
         run: go test -race ./internal/service/... ./internal/api/handler/... ./internal/api/middleware/... ./internal/scheduler/... ./internal/connector/... ./internal/crypto/... ./internal/domain/... ./internal/validation/... ./internal/tlsprobe/... -count=1 -timeout 300s
 
       - name: Go Test with Coverage
         run: |
-          go test ./internal/service/... ./internal/api/handler/... ./internal/api/middleware/... ./internal/api/router/... ./internal/auth/... ./internal/integration/... ./internal/connector/issuer/... ./internal/connector/target/... ./internal/connector/notifier/... ./internal/connector/discovery/... ./internal/crypto/... ./internal/mcp/... ./internal/cli/... ./internal/domain/... ./internal/validation/... ./internal/tlsprobe/... -count=1 -cover -coverprofile=coverage.out
+          go test ./internal/service/... ./internal/api/handler/... ./internal/api/middleware/... ./internal/integration/... ./internal/connector/issuer/... ./internal/connector/target/... ./internal/connector/notifier/... ./internal/connector/discovery/... ./internal/crypto/... ./internal/mcp/... ./internal/cli/... ./internal/domain/... ./internal/validation/... ./internal/tlsprobe/... -count=1 -cover -coverprofile=coverage.out
 
       - name: Check Coverage Thresholds
-        # ci-pipeline-cleanup Phase 2: per-package floors moved to
-        # .github/coverage-thresholds.yml. Each entry has `floor:` +
-        # `why:` (load-bearing context). Logic in
-        # scripts/check-coverage-thresholds.sh — operator runs the same
-        # script locally via `make verify`-equivalent loop.
-        run: bash scripts/check-coverage-thresholds.sh
+        run: |
+          # Extract per-package coverage from test output
+          echo "=== Coverage Report ==="
+          go tool cover -func=coverage.out | tail -1
+
+          # Check service layer coverage (target: 60%+)
+          SERVICE_COV=$(go tool cover -func=coverage.out | grep 'internal/service' | awk '{print $NF}' | sed 's/%//' | awk '{sum+=$1; n++} END {if(n>0) printf "%.1f", sum/n; else print "0"}')
+          echo "Service layer coverage: ${SERVICE_COV}%"
+
+          # Check handler layer coverage (target: 60%+)
+          HANDLER_COV=$(go tool cover -func=coverage.out | grep 'internal/api/handler' | awk '{print $NF}' | sed 's/%//' | awk '{sum+=$1; n++} END {if(n>0) printf "%.1f", sum/n; else print "0"}')
+          echo "Handler layer coverage: ${HANDLER_COV}%"
+
+          # Check domain layer coverage (target: 40%+)
+          DOMAIN_COV=$(go tool cover -func=coverage.out | grep 'internal/domain' | awk '{print $NF}' | sed 's/%//' | awk '{sum+=$1; n++} END {if(n>0) printf "%.1f", sum/n; else print "0"}')
+          echo "Domain layer coverage: ${DOMAIN_COV}%"
+
+          # Check middleware layer coverage (target: 50%+)
+          MIDDLEWARE_COV=$(go tool cover -func=coverage.out | grep 'internal/api/middleware' | awk '{print $NF}' | sed 's/%//' | awk '{sum+=$1; n++} END {if(n>0) printf "%.1f", sum/n; else print "0"}')
+          echo "Middleware layer coverage: ${MIDDLEWARE_COV}%"
+
+          # Check crypto package coverage (target: 85%+)
+          # M-8 rationale: encryption primitives are a security-critical gate.
+          # v2 format, key-derivation, fallback, and fail-closed sentinel paths
+          # all need exhaustive coverage to avoid silent regressions (CWE-916 / CWE-329).
+          CRYPTO_COV=$(go tool cover -func=coverage.out | grep 'internal/crypto' | awk '{print $NF}' | sed 's/%//' | awk '{sum+=$1; n++} END {if(n>0) printf "%.1f", sum/n; else print "0"}')
+          echo "Crypto package coverage: ${CRYPTO_COV}%"
+
+          # Fail if thresholds not met
+          if [ "$(echo "$SERVICE_COV < 55" | bc -l)" -eq 1 ]; then
+            echo "::error::Service layer coverage ${SERVICE_COV}% is below 55% threshold"
+            exit 1
+          fi
+          if [ "$(echo "$HANDLER_COV < 60" | bc -l)" -eq 1 ]; then
+            echo "::error::Handler layer coverage ${HANDLER_COV}% is below 60% threshold"
+            exit 1
+          fi
+          if [ "$(echo "$DOMAIN_COV < 40" | bc -l)" -eq 1 ]; then
+            echo "::error::Domain layer coverage ${DOMAIN_COV}% is below 40% threshold"
+            exit 1
+          fi
+          if [ "$(echo "$MIDDLEWARE_COV < 30" | bc -l)" -eq 1 ]; then
+            echo "::error::Middleware layer coverage ${MIDDLEWARE_COV}% is below 30% threshold"
+            exit 1
+          fi
+          if [ "$(echo "$CRYPTO_COV < 85" | bc -l)" -eq 1 ]; then
+            echo "::error::Crypto package coverage ${CRYPTO_COV}% is below 85% threshold"
+            exit 1
+          fi
+          echo "Coverage thresholds passed!"
 
       - name: Upload Coverage Report
         uses: actions/upload-artifact@v4
@@ -124,101 +110,6 @@ jobs:
           path: coverage.out
           retention-days: 30
 
-      - name: Coverage PR comment
-        # ci-pipeline-cleanup Phase 10 / frozen decision 0.9: self-hosted
-        # alternative to Codecov / Coveralls. Posts a per-package coverage
-        # delta as a PR comment; updates in place on subsequent pushes.
-        if: github.event_name == 'pull_request'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.number }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-        run: bash scripts/coverage-pr-comment.sh
-
-      # Bundle P / Strengthening #6 — QA-doc seed-count drift guard. Forces
-      # every PR that adds a seed row to migrations/seed_demo.sql to keep
-      # docs/contributor/qa-test-suite.md::Seed Data Reference in sync.
-      #
-      # Phase 5 of the 2026-05-04 docs overhaul (commit c64777f) deleted
-      # docs/testing-guide.md (its content dispersed across the new
-      # audience-organized doc tree); the previous QA-doc Part-count drift
-      # guard tracked Part counts between testing-guide.md and the old
-      # qa-test-guide.md headline. With testing-guide.md gone, that guard's
-      # premise is dead and it has been removed. The seed-count drift class
-      # is still live: qa-test-suite.md::Seed Data Reference enumerates
-      # certs/issuers and seed_demo.sql is the source of truth.
-      - name: QA-doc seed-count drift guard
-        run: |
-          set -e
-          DOC=docs/contributor/qa-test-suite.md
-          # Seed-cert count: agnostic to documented header format. The current
-          # documented count lives in `### Certificates (32 total in ...` —
-          # extract the first integer in that header.
-          DOC_CERTS=$(grep -oE '### Certificates \([0-9]+' "$DOC" | grep -oE '[0-9]+' | head -1)
-          # Authoritative count: unique mc-* IDs in seed_demo.sql.
-          SEED_CERTS=$(grep -oE 'mc-[a-z0-9_-]+' migrations/seed_demo.sql | sort -u | wc -l | tr -d ' ')
-          if [ -z "$DOC_CERTS" ]; then
-            echo "::warning::Could not extract documented cert count from $DOC."
-            echo "  Skipping cert-count drift check (header format may have changed)."
-          elif [ "$DOC_CERTS" != "$SEED_CERTS" ]; then
-            echo "::error::DRIFT — $DOC says $DOC_CERTS certs; seed_demo.sql has $SEED_CERTS unique mc-* IDs."
-            echo "  Update $DOC::Seed Data Reference to match."
-            exit 1
-          fi
-          # Issuers: seed-table count vs doc claim.
-          DOC_ISS=$(grep -oE '### Issuers \([0-9]+' "$DOC" | grep -oE '[0-9]+' | head -1)
-          # Authoritative: unique iss-* IDs (close enough proxy; the issuers
-          # table count IS the unique-ID count for this prefix).
-          SEED_ISS=$(grep -oE 'iss-[a-z0-9_-]+' migrations/seed_demo.sql | sort -u | wc -l | tr -d ' ')
-          if [ -z "$DOC_ISS" ]; then
-            echo "::warning::Could not extract documented issuer count."
-          elif [ "$DOC_ISS" != "$SEED_ISS" ] && [ "$((SEED_ISS - DOC_ISS))" -gt 5 ]; then
-            # Allow up to 5pp slack — iss-* IDs appear in audit_events and
-            # other reference tables that aren't issuer-table rows. Drift
-            # only flags when the spread grows large.
-            echo "::error::DRIFT — $DOC says $DOC_ISS issuers; seed_demo.sql has $SEED_ISS unique iss-* IDs (spread > 5)."
-            exit 1
-          fi
-          echo "QA-doc seed-count drift guard: clean."
-
-      # Bundle Q / I-001 closure — test-naming convention guard (informational).
-      # The convention is `Test<Func>_<Scenario>_<ExpectedResult>`. This step
-      # prints any non-conformant tests but does NOT fail the build until the
-      # Bundle I-001-extended (2026-04-27) — promoted from informational
-      # to hard-fail. The convention is now: every `func TestXxx(...)` MUST
-      # match Go's standard test-runner pattern (`^func Test[A-Z]`). Tests
-      # whose name starts with `func Test<lowercase>` are silently SKIPPED
-      # by `go test` (Go only runs `Test[A-Z]...`) — those are the real
-      # bugs this guard catches.
-      #
-      # The original audit's `Test<Func>_<Scenario>_<ExpectedResult>` triple-
-      # token prescription has been relaxed: single-function pin tests like
-      # `TestNewAgent` or `TestSplitPEMChain` are valid Go convention, with
-      # internal scenarios expressed via `t.Run` subtests. Requiring the
-      # underscore-Scenario-Result triple repo-wide would mean renaming
-      # 167 legitimate tests for no observable behavior change. The
-      # Test<Func>_<Scenario>_<ExpectedResult> form remains documented as
-      # the recommended pattern for parameterized scenarios in
-      # docs/contributor/qa-test-suite.md, but is not gated.
-      - name: Regression guards (extracted to scripts/ci-guards/)
-        # All named regression guards live at scripts/ci-guards/<id>.sh per
-        # ci-pipeline-cleanup bundle Phase 1. Each guard is callable locally:
-        #   bash scripts/ci-guards/G-3-env-docs-drift.sh
-        # Adding a new guard: drop a new <id>.sh; this loop auto-picks it up.
-        # Contract: each guard MUST exit 0 on clean repo, non-zero with
-        # ::error:: prefix on regression. See scripts/ci-guards/README.md.
-        run: |
-          set -e
-          fail=0
-          for g in scripts/ci-guards/*.sh; do
-            echo "::group::$(basename "$g")"
-            if ! bash "$g"; then
-              fail=1
-            fi
-            echo "::endgroup::"
-          done
-          exit $fail
-
   frontend-build:
     name: Frontend Build
     runs-on: ubuntu-latest
@@ -246,25 +137,6 @@ jobs:
         working-directory: web
         run: npx vite build
 
-      - name: Regression guards (extracted to scripts/ci-guards/)
-        # All named regression guards live at scripts/ci-guards/<id>.sh per
-        # ci-pipeline-cleanup bundle Phase 1. Each guard is callable locally:
-        #   bash scripts/ci-guards/G-3-env-docs-drift.sh
-        # Adding a new guard: drop a new <id>.sh; this loop auto-picks it up.
-        # Contract: each guard MUST exit 0 on clean repo, non-zero with
-        # ::error:: prefix on regression. See scripts/ci-guards/README.md.
-        run: |
-          set -e
-          fail=0
-          for g in scripts/ci-guards/*.sh; do
-            echo "::group::$(basename "$g")"
-            if ! bash "$g"; then
-              fail=1
-            fi
-            echo "::endgroup::"
-          done
-          exit $fail
-
   helm-lint:
     name: Helm Chart Validation
     runs-on: ubuntu-latest
@@ -279,7 +151,7 @@ jobs:
       # HTTPS-Everywhere (v2.0.47): the chart fails render when no TLS source is
       # configured. Every lint/template invocation below must pick exactly one
       # provisioning mode — see deploy/helm/certctl/templates/_helpers.tpl
-      # (certctl.tls.required) and docs/operator/tls.md.
+      # (certctl.tls.required) and docs/tls.md.
       - name: Lint Helm Chart
         run: |
           helm lint deploy/helm/certctl/ \
@@ -307,157 +179,3 @@ jobs:
             echo "::error::Helm chart rendered without a TLS source — fail-loud guard regressed"
             exit 1
           fi
-
-  # =============================================================================
-  # deploy-vendor-e2e — single-job (collapsed from 12-job matrix)
-  # =============================================================================
-  # Per ci-pipeline-cleanup bundle Phase 5 / frozen decision 0.4 (revises
-  # Bundle II decision 0.9): the per-vendor matrix produced 12 status-check
-  # rows for ~1 real assertion (115/116 vendor-edge tests are t.Log
-  # placeholders). Collapsed to one job that brings up all 11 sidecars
-  # at once and runs the full VendorEdge_ test set.
-  #
-  # Skip-detection guard (scripts/vendor-e2e-skip-check.sh)
-  # enforces that no test SKIPs except the documented allowlist
-  # (windows-iis-requiring tests on Linux). If a sidecar fails to come
-  # up, requireSidecar() in deploy/test/vendor_e2e_helpers.go calls
-  # t.Skipf() — the guard catches that.
-  #
-  # RAM headroom on ubuntu-latest (16 GB ceiling) — operator-confirmed
-  # in Phase 0 / frozen decision 0.14 prototype-branch run. If RAM
-  # regresses, fall back to bucketed matrix per
-  # the project's frozen-decisions log.
-  #
-  # The Windows matrix (deploy-vendor-e2e-windows) was deleted entirely
-  # per Phase 6 / frozen decision 0.5 (revises Bundle II decision 0.4).
-  # IIS + WinCertStore validation moved to the operator playbook at
-  # docs/connector-iis.md::Operator validation playbook.
-  deploy-vendor-e2e:
-    name: deploy-vendor-e2e
-    runs-on: ubuntu-latest
-    needs: [go-build-and-test]
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.25.10'
-          cache: true
-
-      - name: Build f5-mock-icontrol sidecar
-        # The only sidecar without a published image; built from the in-tree
-        # Go server at deploy/test/f5-mock-icontrol/.
-        run: docker compose --profile deploy-e2e -f deploy/docker-compose.test.yml build f5-mock-icontrol
-
-      - name: Bring up all vendor sidecars
-        # Brings up the 11 deploy-e2e sidecars (apache-test, haproxy-test,
-        # traefik-test, caddy-test, envoy-test, postfix-test, dovecot-test,
-        # openssh-test, f5-mock-icontrol, k8s-kind-test, windows-iis-test
-        # which is gated by a separate windows-only profile and won't
-        # actually start) plus the always-on legacy nginx.
-        run: |
-          docker compose --profile deploy-e2e -f deploy/docker-compose.test.yml up -d
-          sleep 15
-
-      - name: Run all vendor-edge e2e
-        # Captures test output for skip-count enforcement (next step).
-        env:
-          INTEGRATION: "1"
-        run: |
-          go test -tags integration -race -count=1 -run 'VendorEdge_' \
-            ./deploy/test/... 2>&1 | tee test-output.log
-
-      - name: Skip-count enforcement
-        # ci-pipeline-cleanup Phase 5 / frozen decision 0.6:
-        # requireSidecar uses t.Skipf (not t.Fatal) when a sidecar isn't
-        # reachable — collapsing the per-vendor matrix removes the implicit
-        # guard each per-job matrix entry provided. This step counts SKIP
-        # lines in the test output and fails the build if it exceeds the
-        # allowlist (windows-iis-requiring tests; legitimately skipped
-        # on Linux per Phase 6 / frozen decision 0.5).
-        run: bash scripts/vendor-e2e-skip-check.sh test-output.log
-
-      - name: Diagnostic dump on failure
-        # Prints container status + last 200 log lines from the certctl-server
-        # and base-stack containers when ANY previous step in this job fails.
-        # The matrix-collapse (Phase 5) brings up ~18 containers concurrently
-        # (vs 1 vendor sidecar at a time pre-collapse); transient failures
-        # surface most often as "container certctl-test-server is unhealthy"
-        # without any visible reason because compose only reports the
-        # dependency-chain symptom, not the root cause. Dumping logs here
-        # makes the underlying error (DB migration crash, port bind failure,
-        # entrypoint stall, OOM kill) visible in the GitHub Actions log
-        # without requiring a workstation reproduction.
-        if: failure()
-        run: |
-          echo "=== docker compose ps -a ==="
-          docker compose --profile deploy-e2e -f deploy/docker-compose.test.yml ps -a || true
-          echo ""
-          echo "=== certctl-test-server logs (last 200 lines) ==="
-          docker logs --tail 200 certctl-test-server 2>&1 || true
-          echo ""
-          echo "=== certctl-test-tls-init logs ==="
-          docker logs certctl-test-tls-init 2>&1 || true
-          echo ""
-          echo "=== certctl-test-postgres logs (last 100 lines) ==="
-          docker logs --tail 100 certctl-test-postgres 2>&1 || true
-          echo ""
-          echo "=== certctl-test-stepca logs (last 100 lines) ==="
-          docker logs --tail 100 certctl-test-stepca 2>&1 || true
-          echo ""
-          echo "=== certctl-test-pebble logs (last 50 lines) ==="
-          docker logs --tail 50 certctl-test-pebble 2>&1 || true
-          echo ""
-          echo "=== certctl-test-agent logs (last 100 lines) ==="
-          docker logs --tail 100 certctl-test-agent 2>&1 || true
-
-      - name: Tear down sidecars
-        if: always()
-        run: docker compose --profile deploy-e2e -f deploy/docker-compose.test.yml down -v
-
-  # =============================================================================
-  # image-and-supply-chain — digest validity + Docker build smoke + OpenAPI parity
-  # =============================================================================
-  # Per ci-pipeline-cleanup bundle Phases 7-9 / frozen decision 0.8.
-  # Three checks bundled into one job (parallel to go-build-and-test):
-  #   1. Digest validity — every @sha256 ref in deploy/* + Dockerfiles must
-  #      resolve on its registry. Closes the H-001 lying-field gap (H-001
-  #      verifies digest *presence* but not *resolution* — Bundle II shipped
-  #      11 fabricated digests that passed H-001 and failed `docker pull`).
-  #   2. Docker build smoke — all 4 Dockerfiles in the repo must build.
-  #      Catches syntax errors / COPY path drift before tag-time release.yml.
-  #   3. OpenAPI ↔ handler parity — every router route has a matching
-  #      operationId or is documented in api/openapi-handler-exceptions.yaml.
-  image-and-supply-chain:
-    name: image-and-supply-chain
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v5
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.25.10'
-          cache: true
-
-      - name: Digest validity (every @sha256 ref must resolve)
-        run: bash scripts/ci-guards/digest-validity.sh
-
-      - name: Docker build smoke (all 4 Dockerfiles)
-        # Per frozen decision 0.10: build all 4 Dockerfiles in the repo,
-        # not just production server + agent. The test-sidecar Dockerfiles
-        # are load-bearing for vendor-e2e — a syntax error there silently
-        # breaks the e2e suite.
-        run: |
-          set -e
-          docker build -f Dockerfile        -t certctl:smoke           .
-          docker build -f Dockerfile.agent  -t certctl-agent:smoke     .
-          docker build -f deploy/test/f5-mock-icontrol/Dockerfile -t f5-mock:smoke .
-          docker build -f deploy/test/libest/Dockerfile           -t libest:smoke   .
-          echo "All 4 Dockerfiles build clean."
-
-      - name: OpenAPI ↔ handler operationId parity
-        run: bash scripts/ci-guards/openapi-handler-parity.sh

.github/workflows/codeql.yml

@@ -1,81 +0,0 @@
-name: CodeQL
-
-# Public-facing SAST baseline that complements the existing security-deep-scan
-# workflow (gosec, osv-scanner, trivy, ZAP, semgrep, schemathesis, nuclei,
-# testssl) with cross-file Go and JavaScript dataflow analysis. Results land
-# in the repository's Security → Code scanning tab as a public signal — any
-# operator/security team auditing certctl can see the scan history and
-# triage state without asking.
-#
-# Why CodeQL in addition to gosec:
-#   - gosec is single-file pattern matching (catches obvious issues like
-#     `os/exec.Command(userInput)`); CodeQL does interprocedural taint
-#     tracking (catches the same issue when the userInput is laundered
-#     through several function calls or struct fields).
-#   - GitHub-native; no third-party SaaS license gate (works for BSL 1.1
-#     and other source-available licenses, unlike Aikido / Snyk / SonarCloud
-#     free tiers which require OSI-approved licenses).
-#   - SARIF results auto-deduplicate and persist on PRs, so reviewers see
-#     "this PR introduces N new findings" rather than re-running ad hoc.
-#
-# Findings that are intentional (e.g., the SSH connector's
-# InsecureIgnoreHostKey, ACME DNS solver's intentional shell-out to operator-
-# supplied scripts) get suppressed via inline `// codeql[<rule-id>]`
-# comments OR via a `.github/codeql/codeql-config.yml` query-pack tweak —
-# document the rationale in the same commit that adds the suppression so
-# the public scan-tab readers see the threat-model justification.
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-  schedule:
-    # Weekly Sunday 06:00 UTC, in addition to push/PR coverage. Catches
-    # rule-pack updates from CodeQL upstream (their Go/JS rulesets ship
-    # new queries on a roughly-monthly cadence).
-    - cron: '0 6 * * 0'
-
-permissions:
-  contents: read
-  security-events: write   # SARIF upload to GitHub code scanning
-  actions: read
-
-jobs:
-  analyze:
-    name: Analyze (${{ matrix.language }})
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [go, javascript-typescript]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Go
-        if: matrix.language == 'go'
-        uses: actions/setup-go@v5
-        with:
-          # Match ci.yml + release.yml + security-deep-scan.yml.
-          go-version: '1.25.10'
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-        with:
-          languages: ${{ matrix.language }}
-          # Use the security-and-quality query suite — security finds plus
-          # maintainability/correctness issues that the smaller security-extended
-          # suite skips. Comparable scope to what Aikido / SonarCloud run.
-          queries: security-and-quality
-
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
-        with:
-          category: "/language:${{ matrix.language }}"
-          # SARIF upload is implicit (and is what populates the Security tab).

.github/workflows/loadtest.yml

@@ -1,77 +0,0 @@
-# Load-test workflow — closes the #8 acquisition-readiness blocker from
-# the 2026-05-01 issuer coverage audit (see
-# the 2026-05-01 issuer coverage audit).
-#
-# CADENCE: workflow_dispatch + weekly cron, NOT per-push. Load tests
-# are minutes long and don't provide useful per-PR signal — per-push
-# pressure goes through ci.yml. This workflow exists to (a) catch
-# gradual regressions from cumulative changes that no single PR
-# triggered, and (b) give an operator a one-click way to capture
-# numbers before tagging a release.
-#
-# THRESHOLDS: defined in deploy/test/loadtest/k6.js (p99 < 5s for
-# issuance-acceptance, p99 < 2s for list, error rate < 1%). k6 exits
-# non-zero on any breach, which propagates through `docker compose up
-# --exit-code-from k6` → `make loadtest` → this workflow's exit.
-
-name: loadtest
-
-on:
-  workflow_dispatch:
-    # Manual trigger from the Actions tab. Use before tagging a
-    # release or after a meaningful tuning commit.
-
-  schedule:
-    # Mondays at 06:00 UTC. Off-peak; catches regressions accumulated
-    # over the previous week's merges. Once a baseline is committed
-    # in deploy/test/loadtest/README.md, drift relative to that
-    # baseline is the signal — diff the captured summary.json
-    # against the committed numbers.
-    - cron: '0 6 * * 1'
-
-# Reduce permissions — this workflow doesn't write to PRs or push tags.
-permissions:
-  contents: read
-
-jobs:
-  k6:
-    name: k6 throughput run
-    runs-on: ubuntu-latest
-    # 25-minute hard cap. Pre-Bundle-10: 15min was enough for the API
-    # tier alone (~7 minutes total). Post-Bundle-10 the harness boots
-    # four additional target sidecars (nginx, apache, haproxy, f5-mock)
-    # before the k6 run; their healthchecks add ~30-60s. The k6 scenarios
-    # themselves are still 5 minutes (run in parallel with the API
-    # scenarios, not serially). 25 minutes absorbs that plus slow CI
-    # runners and cold image caches without letting a stuck container
-    # consume the runner indefinitely.
-    timeout-minutes: 25
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Docker Buildx
-        # The compose stack builds the certctl image from the repo
-        # root Dockerfile. Buildx gives the build a usable cache and
-        # works with newer compose versions.
-        uses: docker/setup-buildx-action@v3
-
-      - name: Run loadtest
-        run: make loadtest
-        env:
-          # Disable BuildKit progress noise so the run log is
-          # diff-able against past runs.
-          BUILDKIT_PROGRESS: plain
-
-      - name: Upload summary
-        # Always upload the summary so a regression has a diffable
-        # artifact even when k6 exited non-zero. summary.json is the
-        # authoritative machine-readable form; summary.txt is the
-        # human-readable text the README baseline tracks.
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: k6-summary-${{ github.run_id }}
-          path: deploy/test/loadtest/results/
-          retention-days: 90

.github/workflows/release.yml

@@ -1,12 +1,5 @@
 name: Release
 
-# Override the auto-generated run name (which would otherwise default to
-# the most recent commit subject + a #NN run number) so the Actions tab
-# shows "Release v2.0.69" instead of "chore: rename Go module path... #73".
-# `github.ref_name` resolves to the tag name (e.g., `v2.0.69`) for tag-triggered
-# workflows, which is the only trigger we set below.
-run-name: Release ${{ github.ref_name }}
-
 on:
   push:
     tags:
@@ -15,8 +8,8 @@ on:
 env:
   REGISTRY: ghcr.io
   # Keep in lock-step with .github/workflows/ci.yml (M-3).
-  GO_VERSION: '1.25.10'
-  IMAGE_NAMESPACE: certctl-io
+  GO_VERSION: '1.25.9'
+  IMAGE_NAMESPACE: shankar0123
 
 jobs:
   # ----------------------------------------------------------------------
@@ -50,23 +43,6 @@ jobs:
         id: version
         run: echo "VERSION=${GITHUB_REF#refs/tags/}" >> "$GITHUB_OUTPUT"
 
-      - name: Install govulncheck
-        # Bundle D / Audit L-008: release.yml previously had no vulnerability
-        # scan, so a release tag could in principle ship a binary with a
-        # known CVE in transitive deps that ci.yml's govulncheck would have
-        # caught on master. Pre-build scan blocks the release if anything
-        # surfaced post-merge. Pinned to the same major as ci.yml.
-        run: go install golang.org/x/vuln/cmd/govulncheck@latest
-
-      - name: Run govulncheck (release gate)
-        # govulncheck distinguishes called-vs-uncalled vulnerable functions.
-        # Default exit code (0 unless an actual call site lands in a vuln
-        # function) is the right gate for release; deferred-call advisories
-        # are tracked separately on master via L-021. If a release-time
-        # scan surfaces a NEW called-vuln, the release is blocked until the
-        # bump lands on master and a new tag is cut.
-        run: govulncheck ./...
-
       - name: Build binary
         id: build
         env:
@@ -341,26 +317,75 @@ jobs:
         run: echo "VERSION=${GITHUB_REF#refs/tags/}" >> "$GITHUB_OUTPUT"
 
       - name: Create release with notes
-        # generate_release_notes: true asks GitHub to auto-generate the
-        # "What's Changed" section from PRs+commits between this tag and the
-        # previous one. The hardcoded body below appends a per-release
-        # supply-chain verification block (Cosign / SLSA / SBOM steps with the
-        # current version baked into the commands) plus a single link to the
-        # README's Quick Start section for install/upgrade instructions.
-        # We deliberately do NOT duplicate install instructions here — the
-        # README is the source of truth for those, and inlining them in every
-        # release page produces the kind of "every release looks identical"
-        # noise that gives operators no signal about what actually changed.
         uses: softprops/action-gh-release@v2
         with:
-          # Pin the release title to the tag name. softprops/action-gh-release@v2
-          # falls back to the most recent commit subject when `name:` is omitted,
-          # which produces ugly titles like "chore: rename Go module path..." on
-          # the Releases page. `github.ref_name` evaluates to the tag (`v2.0.69`).
-          name: ${{ github.ref_name }}
           generate_release_notes: true
           body: |
-            > **Install / upgrade:** see the [Quick Start section in the README](https://github.com/certctl-io/certctl/blob/master/README.md#quick-start) for Docker Compose, agent install, Helm, and binary download instructions.
+            ## Installation
+
+            ### Quick Install (Linux/macOS)
+
+            ```bash
+            curl -sSL https://raw.githubusercontent.com/shankar0123/certctl/master/install-agent.sh | bash
+            ```
+
+            ### Manual Binary Download
+
+            Download the appropriate binary for your OS and architecture:
+
+            - **Linux x86_64**: `certctl-agent-linux-amd64`
+            - **Linux ARM64**: `certctl-agent-linux-arm64`
+            - **macOS x86_64**: `certctl-agent-darwin-amd64`
+            - **macOS ARM64 (Apple Silicon)**: `certctl-agent-darwin-arm64`
+
+            Then make it executable and start the service:
+
+            ```bash
+            chmod +x certctl-agent-linux-amd64
+            sudo mv certctl-agent-linux-amd64 /usr/local/bin/certctl-agent
+            ```
+
+            ## Docker Images
+
+            Pull pre-built Docker images for server and agent:
+
+            ```bash
+            docker pull ghcr.io/shankar0123/certctl-server:${{ steps.version.outputs.VERSION }}
+            docker pull ghcr.io/shankar0123/certctl-agent:${{ steps.version.outputs.VERSION }}
+            ```
+
+            Or use the latest tag:
+
+            ```bash
+            docker pull ghcr.io/shankar0123/certctl-server:latest
+            docker pull ghcr.io/shankar0123/certctl-agent:latest
+            ```
+
+            ## Docker Compose Quick Start
+
+            ```bash
+            git clone https://github.com/shankar0123/certctl.git
+            cd certctl
+            cp deploy/.env.example deploy/.env
+            docker compose -f deploy/docker-compose.yml up -d
+            ```
+
+            ## Server Binaries
+
+            Pre-compiled server binaries are also available for direct installation:
+
+            - **Linux x86_64**: `certctl-server-linux-amd64`
+            - **Linux ARM64**: `certctl-server-linux-arm64`
+            - **macOS x86_64**: `certctl-server-darwin-amd64`
+            - **macOS ARM64 (Apple Silicon)**: `certctl-server-darwin-arm64`
+
+            ## CLI & MCP Server Binaries
+
+            The `certctl-cli` (REST API wrapper) and `certctl-mcp-server` (Model Context
+            Protocol bridge) binaries ship for all four platforms as well:
+
+            - `certctl-cli-{linux,darwin}-{amd64,arm64}`
+            - `certctl-mcp-server-{linux,darwin}-{amd64,arm64}`
 
             ## Verifying this release
 
@@ -381,7 +406,7 @@ jobs:
             ```bash
             cosign verify-blob \
               --bundle checksums.txt.sigstore.json \
-              --certificate-identity-regexp '^https://github\.com/certctl-io/certctl/\.github/workflows/release\.yml@refs/tags/' \
+              --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/\.github/workflows/release\.yml@refs/tags/' \
               --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
               checksums.txt
             ```
@@ -395,7 +420,7 @@ jobs:
             ```bash
             slsa-verifier verify-artifact \
               --provenance-path multiple.intoto.jsonl \
-              --source-uri github.com/certctl-io/certctl \
+              --source-uri github.com/shankar0123/certctl \
               --source-tag ${{ steps.version.outputs.VERSION }} \
               certctl-agent-linux-amd64
             ```
@@ -403,21 +428,33 @@ jobs:
             **4. Verify container image signature and attestations:**
 
             ```bash
-            IMAGE=ghcr.io/certctl-io/certctl-server:${{ steps.version.outputs.VERSION }}
+            IMAGE=ghcr.io/shankar0123/certctl-server:${{ steps.version.outputs.VERSION }}
             cosign verify \
-              --certificate-identity-regexp '^https://github\.com/certctl-io/certctl/\.github/workflows/release\.yml@refs/tags/' \
+              --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/\.github/workflows/release\.yml@refs/tags/' \
               --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
               "$IMAGE"
 
             # SBOM attestation (SPDX-JSON) emitted by docker/build-push-action
             cosign verify-attestation --type spdxjson \
-              --certificate-identity-regexp '^https://github\.com/certctl-io/certctl/' \
+              --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/' \
               --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
               "$IMAGE"
 
             # SLSA provenance attestation (mode=max)
             cosign verify-attestation --type slsaprovenance \
-              --certificate-identity-regexp '^https://github\.com/certctl-io/certctl/' \
+              --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/' \
               --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
               "$IMAGE"
             ```
+
+            ## Helm Chart
+
+            Deploy certctl to Kubernetes using Helm:
+
+            ```bash
+            helm repo add certctl https://github.com/shankar0123/certctl/tree/master/deploy/helm
+            helm repo update
+            helm install certctl certctl/certctl
+            ```
+
+            See `deploy/helm/certctl/` for values customization.

.github/workflows/security-deep-scan.yml

@@ -1,194 +0,0 @@
-name: security-deep-scan
-
-# Bundle-7 / Audit D-001..D-007:
-# Slow / containerized scans on a daily schedule + manual dispatch.
-# Per-PR fast gates live in ci.yml; this workflow runs the heavyweight
-# tools that need docker, network egress to scanner registries, or
-# longer wall-clock budgets than a per-PR check tolerates.
-#
-# Scope:
-#   trivy image          container CVE + secret scan
-#   syft SBOM            CycloneDX SBOM artefact upload
-#   ZAP baseline         DAST baseline against a live deploy_test stack (D-004)
-#   nuclei               template-based vuln scan against the same stack
-#   schemathesis         OpenAPI fuzz against the running server
-#   testssl.sh           TLS configuration audit (D-005)
-#   race detector x10    full -count=10 race run on the entire test suite (D-002)
-#   gosec                Go security static analysis (slow first run)
-#   go-mutesting         mutation testing on crypto cluster (D-003)
-#   semgrep p/react-security  frontend XSS / dangerouslySetInnerHTML / target=_blank ruleset (D-007)
-#
-# Each step is best-effort — failures are uploaded as artefacts but do
-# NOT block the workflow. Triage happens via the Bundle-7 receipt
-# the project's comprehensive-audit tool-output directory.
-
-on:
-  schedule:
-    - cron: '0 6 * * *'   # daily 06:00 UTC
-  workflow_dispatch: {}
-
-permissions:
-  contents: read
-  security-events: write   # SARIF upload to GitHub code scanning
-
-jobs:
-  deep-scan:
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-go@v5
-        with:
-          go-version: '1.25'
-
-      - name: Install Go-based tools
-        run: bash scripts/install-security-tools.sh
-        continue-on-error: true
-
-      # --- Static analysis (slow paths) ---
-
-      - name: gosec
-        run: |
-          $(go env GOPATH)/bin/gosec -fmt sarif -out gosec.sarif ./... || true
-        continue-on-error: true
-
-      - name: osv-scanner (multi-ecosystem CVE)
-        run: |
-          $(go env GOPATH)/bin/osv-scanner -r --format json --output osv-scanner.json . || true
-        continue-on-error: true
-
-      # --- Race detector at -count=10 (D-002) ---
-
-      - name: go test -race -count=10 (full suite)
-        run: |
-          go test -race -count=10 -short ./... 2>&1 | tee go-test-race.txt
-        continue-on-error: true
-
-      # --- Coverage receipts for crypto cluster (H-005) ---
-
-      - name: go test -cover (crypto cluster)
-        run: |
-          go test -cover -covermode=atomic \
-            ./internal/crypto/... \
-            ./internal/pkcs7/... \
-            ./internal/connector/issuer/local/... \
-            2>&1 | tee go-test-cover.txt
-
-      # --- Mutation testing on crypto cluster (D-003) ---
-      #
-      # Operator runbook: docs/testing-strategy.md::Mutation testing.
-      # Tool: go-mutesting (https://github.com/zimmski/go-mutesting). Each
-      # package is mutated independently; the per-package summary line
-      # (`The mutation score is X.YZ`) is grep-extracted into the receipt.
-      # Acceptance threshold: ≥80% kill ratio per package; surviving
-      # mutants get triaged in the project's comprehensive-audit notes/
-      # d003-mutation-results.md (per-mutant action item or
-      # equivalent-mutation justification).
-
-      - name: Install go-mutesting
-        run: go install github.com/zimmski/go-mutesting/cmd/go-mutesting@latest
-        continue-on-error: true
-
-      - name: go-mutesting (crypto cluster)
-        run: |
-          : > go-mutesting.txt
-          for pkg in ./internal/crypto/... ./internal/pkcs7/... ./internal/connector/issuer/local/...; do
-            echo "=== $pkg ===" | tee -a go-mutesting.txt
-            $(go env GOPATH)/bin/go-mutesting "$pkg" 2>&1 | tee -a go-mutesting.txt || true
-          done
-        continue-on-error: true
-
-      # --- Container + supply chain (D-001 partial, D-006 partial) ---
-
-      - name: Build certctl image
-        run: docker build -t certctl:deep-scan .
-        continue-on-error: true
-
-      - name: trivy image scan
-        run: |
-          docker run --rm -v "$PWD":/src aquasec/trivy:latest image \
-            --format json --output /src/trivy.json certctl:deep-scan || true
-        continue-on-error: true
-
-      - name: syft SBOM
-        run: |
-          docker run --rm -v "$PWD":/src anchore/syft:latest dir:/src \
-            -o cyclonedx-json > syft.cyclonedx.json || true
-        continue-on-error: true
-
-      # --- DAST against a live stack (D-004) ---
-
-      - name: docker compose up (test stack)
-        run: |
-          docker compose -f deploy/docker-compose.yml up -d
-          sleep 20
-        continue-on-error: true
-
-      - name: ZAP baseline
-        uses: zaproxy/action-baseline@v0.10.0
-        with:
-          target: 'https://localhost:8443'
-        continue-on-error: true
-
-      - name: schemathesis (OpenAPI fuzz)
-        run: |
-          pip install schemathesis
-          schemathesis run --base-url https://localhost:8443 \
-            --hypothesis-max-examples=50 api/openapi.yaml || true
-        continue-on-error: true
-
-      - name: nuclei
-        run: |
-          docker run --rm --network host projectdiscovery/nuclei:latest \
-            -u https://localhost:8443 -j -o nuclei.json || true
-        continue-on-error: true
-
-      # --- TLS audit (D-005) ---
-
-      - name: testssl.sh
-        run: |
-          docker run --rm -v "$PWD":/data drwetter/testssl.sh:latest \
-            --jsonfile /data/testssl.json https://localhost:8443 || true
-        continue-on-error: true
-
-      - name: docker compose down
-        run: docker compose -f deploy/docker-compose.yml down || true
-        if: always()
-
-      # --- Frontend XSS / unsafe-link ruleset (D-007) ---
-      #
-      # Operator runbook: docs/testing-strategy.md::Frontend semgrep.
-      # Bundle 8 already verified `dangerouslySetInnerHTML` count at
-      # zero and the `target="_blank"` rel-noopener pin via grep
-      # guards in ci.yml — semgrep p/react-security adds defence in
-      # depth (it catches escape patterns the grep guards don't see,
-      # e.g., href={user_input}, eval, document.write).
-
-      - name: semgrep p/react-security (frontend)
-        run: |
-          docker run --rm -v "$PWD":/src returntocorp/semgrep:latest \
-            semgrep --config=p/react-security --json /src/web/src \
-            > semgrep-react.json 2>semgrep-react.stderr || true
-        continue-on-error: true
-
-      # --- Upload everything as artefacts ---
-
-      - name: Upload deep-scan receipts
-        uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: security-deep-scan-${{ github.run_id }}
-          path: |
-            gosec.sarif
-            osv-scanner.json
-            go-test-race.txt
-            go-test-cover.txt
-            go-mutesting.txt
-            trivy.json
-            syft.cyclonedx.json
-            nuclei.json
-            testssl.json
-            semgrep-react.json
-            semgrep-react.stderr
-          retention-days: 30

.govulnignore

@@ -1,21 +0,0 @@
-# Bundle-7 / Audit D-001 / govulncheck suppressions.
-#
-# Format: one OSV ID per line, with a comment justifying the suppression.
-# Every entry needs:
-#   - the OSV ID (GO-YYYY-NNNN)
-#   - one-line "what is it"
-#   - one-line "why we're not affected" (must reference call-graph evidence)
-#   - "review-by" date (YYYY-MM-DD) — re-triage on/after this date
-#
-# Triage rule: only suppress an advisory if `govulncheck ./...` (NOT
-# verbose) reports it as a deferred-call vulnerability ("packages you
-# import" or "modules you require", not "Your code is affected by").
-#
-# At Bundle-7 time (2026-04-26): the 5 advisories surfaced are all in
-# transitive deps and govulncheck confirms our code does not call them.
-# Documented here for tracking; no entries needed because the default
-# fail-on-non-zero gate already passes (govulncheck distinguishes
-# called vs uncalled and only exits non-zero when the latter calls in).
-#
-# Example (do not enable unless the advisory becomes call-affected):
-# GO-2026-4441  # transitive: golang.org/x/crypto pre-v0.40 — net/ssh terrapin downgrade; we don't use net/ssh; review 2026-07-01

CHANGELOG.md

@@ -1,136 +1,50 @@
 # Changelog
 
-## v2.1.0 - Auth Bundle 1: RBAC primitive ⚠️
+All notable changes to certctl are documented in this file. Dates use ISO 8601. Versions follow [Semantic Versioning](https://semver.org/).
 
-> **SECURITY: AUDIT YOUR API KEYS.**
->
-> Bundle 1 ships role-based authorization. Every existing API key
-> configured via `CERTCTL_API_KEYS_NAMED` (or the legacy
-> `CERTCTL_AUTH_SECRET`) is mapped to the **r-admin role on the first
-> upgrade boot** so existing automation keeps working unchanged. Most
-> keys do NOT need full admin power; downgrade them before tagging
-> the next release.
->
-> Recommended post-upgrade flow:
->
-> ```bash
-> # 1. List every key with its current role:
-> certctl-cli auth keys list
->
-> # 2. Walk an interactive prompt that downgrades each key:
-> certctl-cli auth keys scope-down
->
-> # 3. Or get a heuristic suggestion based on 30 days of audit history:
-> certctl-cli auth keys scope-down --suggest
-> certctl-cli auth keys scope-down --suggest --apply   # applies the suggestion
->
-> # 4. Or drive scope-down from a JSON config (Helm post-upgrade hook):
-> certctl-cli auth keys scope-down --non-interactive ./scope-down.json
-> ```
->
-> The synthetic `actor-demo-anon` actor (used when
-> `CERTCTL_AUTH_TYPE=none` is configured) is system-managed and
-> excluded from the prompt loop.
+## [2.2.0] — 2026-04-19
 
-What else changed in v2.1.0:
+### HTTPS Everywhere — The Irony
 
-- **RBAC primitive shipped.** `tenants`, `roles`, `permissions`,
-  `role_permissions`, `actor_roles` tables (migration 000029); 33-permission
-  canonical catalogue; 7 default roles (`admin`, `operator`, `viewer`,
-  `agent`, `mcp`, `cli`, `auditor`); per-handler permission gates via
-  `auth.RequirePermission` middleware (replaces the legacy
-  `IsAdmin` boolean check on the 5 admin-only handlers).
-- **Day-0 admin bootstrap.** Set `CERTCTL_BOOTSTRAP_TOKEN` on a fresh
-  deploy and POST a single curl call against `/api/v1/auth/bootstrap` to
-  mint the first admin API key; one-shot, never logged, and locks
-  closed once any admin actor exists. Migration 000031 ships the
-  `api_keys` table that stores the SHA-256 hash; the plaintext is
-  shown in the response body once and never persisted.
-- **Auditor role split.** New `auditor` role holds only `audit.read`
-  + `audit.export`. Compliance reviewers can read the audit trail
-  without holding mutation power. Migration 000032 adds
-  `audit_events.event_category` so auditors can filter to
-  authentication-related events specifically.
-- **`/v1/auth/check` enrichment.** Response now includes the actor's
-  standing roles and effective permissions, so the GUI gates
-  affordances from a single fetch on app boot.
-- **Approval-bypass closure.** Edits to a profile that has (or
-  would have) `RequiresApproval=true` now route through the
-  `ApprovalService` two-person integrity gate (Phase 9). Migration
-  000033 adds `approval_kind` + `payload` to
-  `issuance_approval_requests` so cert-issuance and profile-edit
-  approvals share the same workflow. Same-actor self-approve is
-  rejected with `ErrApproveBySameActor` for both kinds. Closes the
-  flip-flop loophole where an admin could disable approval, mutate,
-  re-enable. Documented at
-  [`docs/reference/profiles.md`](docs/reference/profiles.md).
-- **GUI: Roles / API Keys / Auth Settings / Approvals queue.**
-  Four new pages under `/auth/*` consume `/v1/auth/me` for
-  permission-aware rendering. The Approvals queue blocks
-  self-approve at the client layer (Approve/Reject buttons hidden
-  when requested_by == current actor_id) on top of the server-side
-  enforcement. AuditPage gains a category filter (cert_lifecycle /
-  auth / config) for the auditor view.
-- **MCP server gains 12 RBAC tools.** Operators driving certctl
-  from Claude / VS Code / any MCP client get parity with the GUI
-  + CLI. Each tool routes through the same HTTP handler; permission
-  gates fire server-side.
-- **OpenAPI catalogues every new route.** Every Bundle 1 endpoint
-  ships with an `operationId`; the parity test guards against drift.
-- **Coverage gates.** `internal/auth/` and `internal/service/auth/`
-  now have ≥85% coverage floors in `.github/coverage-thresholds.yml`.
-  The 12-path negative-test list from the Bundle 1 prompt is
-  fully covered (path #12 deferred with in-tree TODO).
-- **Protocol-endpoint allowlist pinned at three layers.** The
-  middleware bypass (`auth.IsProtocolEndpoint`), the router-level
-  `AuthExemptRouterRoutes` constant, and a new
-  `phase12_protocol_allowlist_test.go` AST scan all guard against
-  accidentally wrapping ACME / SCEP / EST / OCSP / CRL routes in
-  `rbacGate`.
-- **Bundle 2 (OIDC + sessions) starts after Bundle 1 lands on
-  master.** Roadmap entry remains in `cowork/auth-bundle-2-prompt.md`.
+> certctl manages other teams' certificates. Until v2.2, it didn't terminate TLS on its own control plane. We treated the server as an internal service sitting behind whatever TLS-terminating infrastructure the operator already owned — reverse proxies, Kubernetes Ingress controllers, service mesh sidecars. Working through an EST coverage-gap audit surfaced this as a credibility problem we wanted to fix head-on: a cert-lifecycle product should ship with HTTPS by default. This release flips that. Self-signed bootstrap for docker-compose demos, operator-supplied Secret for Helm (with optional cert-manager integration), and a one-step cutover with no backward-compat bridge. Out-of-date agents will fail at the TLS handshake layer on upgrade; the upgrade guide walks operators through the roll.
 
-Migration ordering, idempotency, and downgrade are documented in
-[`docs/migration/api-keys-to-rbac.md`](docs/migration/api-keys-to-rbac.md).
-The threat model + compliance mapping live at
-[`docs/operator/auth-threat-model.md`](docs/operator/auth-threat-model.md).
-Day-2 RBAC operations live at
-[`docs/operator/rbac.md`](docs/operator/rbac.md).
+### Breaking Changes
 
-## v2.0.68 - Image registry path changed ⚠️
+- **HTTPS-only control plane. The plaintext HTTP listener is gone.** There is no `CERTCTL_TLS_ENABLED=false` escape hatch and no `:8080` fallback. Operators who were running certctl behind their own TLS terminator must either (a) continue doing so and let the downstream TLS terminator talk to certctl's HTTPS listener, or (b) bring their own cert/key and terminate on certctl directly. Either path requires config changes — see `docs/upgrade-to-tls.md` for a one-step cutover.
+- **Agents reject `CERTCTL_SERVER_URL=http://...` at startup.** This is a pre-flight config validation failure with a fail-loud diagnostic pointing at `docs/upgrade-to-tls.md`. Not a TCP-refused, not a TLS-handshake-error — the agent will not even attempt the network call. Every agent deployment must be reconfigured before upgrading the server.
+- **CLI and MCP clients require `https://` URLs.** Same pre-flight rejection of plaintext schemes.
+- **TLS 1.2 is not supported. TLS 1.3 only.** The server's `tls.Config.MinVersion` is pinned to `tls.VersionTLS13`. Any client still negotiating TLS 1.2 will fail at the handshake. Modern curl, Go stdlib, browsers, and Kubernetes tooling all default to 1.3-capable; legacy clients may need an upgrade.
+- **Helm chart requires a TLS source.** `helm install` without one of `server.tls.existingSecret`, `server.tls.certManager.enabled`, or (for eval only) `server.tls.selfSigned.enabled` fails at template time with a diagnostic pointing at `docs/tls.md`. There is no default-to-plaintext path.
 
-> **Image registry path changed.** Starting this release, container images publish to `ghcr.io/certctl-io/certctl-server` and `ghcr.io/certctl-io/certctl-agent`. Existing pulls from `ghcr.io/shankar0123/certctl-{server,agent}:<tag>` continue to work for previously-published tags (the registry never deletes images), but the `:latest` tag at the old path stops moving forward at this release. Update your `docker pull` paths, `docker-compose.yml` `image:` keys, or Helm `image.repository` values to receive future updates. Old `git clone` / `git push` / install-script / API URLs continue to redirect forever - only the container-registry path changed.
+### Added
 
-This is the only operator-action-required change in v2.0.68. Other changes in this release are cosmetic URL refreshes after the GitHub-org transfer from `shankar0123/certctl` to `certctl-io/certctl` (HTTP redirects mean no other operator action is required) plus an internal contextcheck lint fix in the agent. Full commit list is on the [GitHub release page](https://github.com/certctl-io/certctl/releases/tag/v2.0.68).
+- **Self-signed bootstrap for Docker Compose demos.** A `certctl-tls-init` init container runs before the server on first boot, generates a SAN-valid self-signed cert into `deploy/test/certs/`, and exits. The server mounts the resulting cert/key. Every curl in the demo stack pins against `./deploy/test/certs/ca.crt` with `--cacert`.
+- **Helm chart TLS provisioning — three modes.** Operator-supplied Secret (`server.tls.existingSecret`), cert-manager integration (`server.tls.certManager.enabled` with issuer selection), or self-signed (`server.tls.selfSigned.enabled` — eval only, not supported for production). Chart templates enforce exactly one is active.
+- **Hot-reload of TLS cert/key on `SIGHUP`.** Overwrite the cert/key on disk, send `SIGHUP` to the server PID, watch the `slog.Info("tls.reload", ...)` log line, and new TLS connections use the new cert. Failure during reload is logged and does not crash the server; the previous cert remains in use.
+- **Agent CA-bundle env vars.** `CERTCTL_SERVER_CA_BUNDLE_PATH` points at a PEM file the agent's HTTP client will trust. `CERTCTL_SERVER_TLS_INSECURE_SKIP_VERIFY` disables verification (development only — the agent logs a loud warning at startup). `install-agent.sh` writes both as commented template lines into the generated `agent.env`.
+- **Integration test suite runs over HTTPS.** `go test -tags=integration ./deploy/test/...` stands up the full Compose stack, extracts the self-signed CA bundle, and exercises every certctl API over `https://localhost:8443`. All 34 subtests green.
+- **`docs/tls.md`** — cert provisioning patterns: bring-your-own Secret, cert-manager, self-signed bootstrap, SAN requirements, rotation workflows, SIGHUP reload semantics, troubleshooting.
+- **`docs/upgrade-to-tls.md`** — one-step cutover guide for existing v2.1 operators. Walks through the agent fleet roll, Helm upgrade sequencing, downgrade-is-not-supported warnings, and cert-provisioning decision tree.
 
----
+### Changed
 
-certctl no longer maintains a hand-edited per-version changelog. Per-release
-notes are auto-generated from commit messages between consecutive tags.
+- `cmd/server/main.go` now calls `http.Server.ListenAndServeTLS(certFile, keyFile)`. The plaintext `ListenAndServe` code path is deleted — `grep -rn "ListenAndServe[^T]" cmd/ internal/` returns zero hits.
+- All documentation curls (`docs/testing-guide.md`, `docs/quickstart.md`, `deploy/helm/INSTALLATION.md`, `deploy/helm/DEPLOYMENT_GUIDE.md`, `deploy/ENVIRONMENTS.md`, `docs/openapi.md`, migration guides, example READMEs) use `https://localhost:8443` and `--cacert` against the demo stack's bundle.
+- OpenAPI spec (`api/openapi.yaml`) `servers` blocks default to `https://localhost:8443`.
 
-**Where to find what changed in a given release:**
+### Security
 
-- **[GitHub Releases](https://github.com/certctl-io/certctl/releases)** - every
-  tag has an auto-generated "What's Changed" section pulled from the commits
-  between that tag and the previous one, plus per-release supply-chain
-  verification instructions (Cosign / SLSA / SBOM).
-- **`git log <prev-tag>..<this-tag> --oneline`** - same content, locally.
+- TLS 1.3 pinned via `tls.Config.MinVersion = tls.VersionTLS13`.
+- Plaintext HTTP listener removed entirely — no port 8080, no `Upgrade-Insecure-Requests`, no HSTS-required redirect dance. There is only one port: 8443, TLS 1.3.
+- `grep -rn "http://" cmd/ internal/` returns zero hits outside test fixtures and the agent-side URL-scheme rejection error message.
 
-**Why no hand-edited CHANGELOG.md:**
+### Upgrade Notes
 
-certctl is solo-developed and pushes directly to master. Maintaining a
-hand-edited CHANGELOG meant the file drifted (entries piled into
-`[unreleased]` and never got promoted to per-version sections when tags were
-cut). A stale CHANGELOG is worse than no CHANGELOG - it signals abandoned
-maintenance to security-conscious operators doing diligence.
+Read `docs/upgrade-to-tls.md` before upgrading. The short version:
 
-The auto-generated release notes work here because commit messages follow a
-descriptive convention: `<area>: <summary>` with a longer body for non-trivial
-changes (see `git log v2.0.50..HEAD` for the established pattern). Anyone
-reading the GitHub Releases page can see exactly what landed in each version
-without depending on the author to manually update a separate file.
+1. Pick a TLS source — bring-your-own cert, cert-manager, or self-signed bootstrap.
+2. Upgrade the server with TLS configured. First boot over HTTPS.
+3. Roll the agent fleet: set `CERTCTL_SERVER_URL=https://...` and, if using a private CA, `CERTCTL_SERVER_CA_BUNDLE_PATH`. Old agents will fail loud at startup — expected.
+4. Roll CLI/MCP clients the same way.
 
-**For the historical record:** earlier versions (pre-v2.2.0 and the [2.2.0]
-tag itself) had a hand-edited CHANGELOG. That content is preserved in
-[git history](https://github.com/certctl-io/certctl/blob/v2.2.0/CHANGELOG.md)
-at the v2.2.0 tag.
+There is no backward-compat bridge. There is no dual-listener mode. The cutover is one step.

Dockerfile

@@ -1,28 +1,7 @@
 # Multi-stage build for certctl server
-#
-# Bundle A / Audit H-001 (CWE-829): every FROM line is pinned to an
-# immutable digest in addition to the human-readable tag. The tag is
-# advisory; the digest is what Docker actually pulls. A registry-side
-# tag swap (the documented prior-art for tag-only pulls being unsafe)
-# can no longer change the build.
-#
-# Bump procedure (operator):
-#   1. Quarterly cadence (or sooner if a CVE lands on a base image).
-#   2. For each FROM:
-#        docker pull <image>:<tag>
-#        docker manifest inspect <image>:<tag> | grep -m1 digest
-#      OR via Docker Hub Registry API:
-#        curl -sSL https://hub.docker.com/v2/repositories/library/<image>/tags/<tag> \
-#          | jq -r .digest
-#   3. Replace the @sha256:... portion of the FROM line.
-#   4. Run `docker build` locally + verify CI.
-#   5. Commit with the bump procedure cited in the message body.
-#
-# The CI step "Forbidden bare FROM regression guard (H-001)" rejects
-# any future commit that lands a FROM without an @sha256 pin.
 
 # Stage 1: Build frontend
-FROM node:20-alpine@sha256:fb4cd12c85ee03686f6af5362a0b0d56d50c58a04632e6c0fb8363f609372293 AS frontend
+FROM node:20-alpine AS frontend
 
 # Proxy propagation (M-4, Issue #9) — defaulted to empty so un-proxied builds
 # behave identically to the pre-fix tree. When `HTTP_PROXY`/`HTTPS_PROXY`/
@@ -43,27 +22,12 @@ ENV HTTP_PROXY=${HTTP_PROXY} \
 WORKDIR /app/web
 
 COPY web/ .
-# Bundle A / Audit M-014: explicit retry loop for `npm ci`. Pre-bundle
-# this was `npm ci || npm ci && tsc && build` — the bash precedence is
-# `A || (B && C && D)` so the second `npm ci` only ran on the failure
-# path of the first, but the `tsc && build` chain only ran on the
-# success path of the second. Net effect: a transient registry blip
-# turned the build into a silent skip of the production step.
-#
-# New shape: a deterministic 3-attempt retry with 5-second backoff and
-# an explicit `[ -d node_modules ]` post-check so a silent failure is
-# impossible.
-RUN for i in 1 2 3; do \
-        npm ci --include=dev && break; \
-        echo "npm ci attempt $i failed; sleeping 5s before retry"; \
-        sleep 5; \
-    done && \
-    [ -d node_modules ] || (echo "ERROR: npm ci failed after 3 attempts; node_modules missing" && exit 1) && \
+RUN npm ci --include=dev || npm ci --include=dev && \
     node_modules/.bin/tsc --version && \
     npm run build
 
 # Stage 2: Build Go binary
-FROM golang:1.25.10-alpine@sha256:8d22e29d960bc50cd025d93d5b7c7d220b1ee9aa7a239b3c8f55a57e987e8d45 AS builder
+FROM golang:1.25-alpine AS builder
 
 # Proxy propagation (M-4, Issue #9) — see Stage 1 rationale.
 ARG HTTP_PROXY=
@@ -93,7 +57,7 @@ RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build \
     ./cmd/server
 
 # Stage 3: Runtime
-FROM alpine:3.19@sha256:6baf43584bcb78f2e5847d1de515f23499913ac9f12bdf834811a3145eb11ca1
+FROM alpine:3.19
 
 RUN apk add --no-cache ca-certificates tzdata curl
 
@@ -112,34 +76,7 @@ USER certctl
 
 EXPOSE 8443
 
-# Image-level HEALTHCHECK for bare `docker run` / Docker Swarm / Nomad / ECS.
-#
-# U-2 (P1, cat-u-healthcheck_protocol_mismatch): pre-U-2 this probe used
-# `curl -f http://localhost:8443/health`, which always failed against the
-# HTTPS-only listener (HTTPS-Everywhere milestone, v2.2 / tag v2.0.47 —
-# `cmd/server/main.go::ListenAndServeTLS`, no plaintext fallback, TLS 1.3
-# pinned). Operators outside docker-compose / Helm saw permanent
-# `unhealthy` status and a restart-loop the first time they pulled the
-# image. The compose stack overrides this HEALTHCHECK with `--cacert` to
-# the bootstrap CA bundle (deploy/docker-compose.yml:126); the Helm chart
-# uses explicit `httpGet` probes with `scheme: HTTPS` and ignores Docker's
-# HEALTHCHECK; every example compose file in `examples/*/docker-compose.yml`
-# overrides with `curl -sfk https://localhost:8443/health`. This image-
-# level probe is for the bare-`docker run` consumer ONLY.
-#
-# `-k` (insecure) is acceptable here because the probe is localhost-to-
-# localhost: the same process serving the cert is being probed; the probe
-# never traverses a network. Pinning a `--cacert` is not viable for the
-# published image because the bootstrap cert is per-deploy (generated into
-# the `certs` named volume on first up; operator-supplied via Helm's
-# `existingSecret` or cert-manager). Compose / Helm / examples already
-# perform full cert-chain validation and are unaffected.
-#
-# CI grep guardrail at .github/workflows/ci.yml ("Forbidden plaintext
-# HEALTHCHECK regression guard (U-2)") blocks reintroduction of the
-# `http://` shape. Image-level integration test in
-# deploy/test/healthcheck_test.go pins the contract end-to-end.
 HEALTHCHECK --interval=10s --timeout=5s --start-period=5s --retries=5 \
-    CMD curl -fsk https://localhost:8443/health || exit 1
+    CMD curl -f http://localhost:8443/health || exit 1
 
 ENTRYPOINT ["/app/server"]

Dockerfile.agent

@@ -1,11 +1,6 @@
 # Multi-stage build for certctl agent
-#
-# Bundle A / Audit H-001 (CWE-829): every FROM line is pinned to an
-# immutable digest. See Dockerfile (server) for the bump-procedure
-# operator runbook; the pins here MUST be bumped in the same pass.
-
 # Stage 1: Build
-FROM golang:1.25.10-alpine@sha256:8d22e29d960bc50cd025d93d5b7c7d220b1ee9aa7a239b3c8f55a57e987e8d45 AS builder
+FROM golang:1.25-alpine AS builder
 
 # Proxy propagation (M-4, Issue #9) — defaulted to empty so un-proxied builds
 # behave identically to the pre-fix tree. When `HTTP_PROXY`/`HTTPS_PROXY`/
@@ -39,16 +34,9 @@ RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build \
     ./cmd/agent
 
 # Stage 2: Runtime
-FROM alpine:3.19@sha256:6baf43584bcb78f2e5847d1de515f23499913ac9f12bdf834811a3145eb11ca1
+FROM alpine:3.19
 
-# U-2: `procps` ships pgrep, which the HEALTHCHECK below uses to verify the
-# agent process is alive. Pre-U-2 the deploy/docker-compose.yml agent
-# HEALTHCHECK called `pgrep -f certctl-agent` against this image but
-# pgrep wasn't installed — the compose probe was a latent always-fail.
-# Adding procps here fixes both the new image-level HEALTHCHECK and the
-# pre-existing compose override. Adds ~250KB to the image; acceptable for
-# observability parity with the server image.
-RUN apk add --no-cache ca-certificates curl procps
+RUN apk add --no-cache ca-certificates curl
 
 RUN addgroup -g 1000 certctl && \
     adduser -D -u 1000 -G certctl certctl
@@ -63,19 +51,4 @@ RUN mkdir -p /var/lib/certctl/keys && \
 
 USER certctl
 
-# Image-level HEALTHCHECK for bare `docker run` / Docker Swarm / Nomad / ECS.
-#
-# U-2 (P1, cat-u-healthcheck_protocol_mismatch — adjacent fix): the agent
-# has no HTTP listener (it polls the server via outbound HTTPS), so a
-# process-presence check is the correct primitive. Pre-U-2 the agent image
-# shipped with no HEALTHCHECK at all, so bare-`docker run` operators got
-# zero health signal and orchestrators that key off Docker's HEALTHCHECK
-# (Swarm, Nomad, ECS) saw the container reported as `none`. The compose
-# override at deploy/docker-compose.yml:173 used the same `pgrep -f
-# certctl-agent` shape; we mirror it here so the published image has
-# parity with the compose stack and the override on docker-compose.yml
-# becomes redundant-but-correct rather than load-bearing.
-HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
-    CMD pgrep -f certctl-agent > /dev/null || exit 1
-
 ENTRYPOINT ["/app/agent"]

LICENSE

@@ -2,54 +2,26 @@ Business Source License 1.1
 
 Parameters
 
-Licensor:             Shankar Kambam
+Licensor:             Shankar Reddy
 Licensed Work:        certctl
-                      The Licensed Work is © 2026 Shankar Kambam.
-
-Additional Use Grant: You may make use of the Licensed Work, including in
-                      production for your internal business operations and
-                      for operations that provide products or services to
-                      your own customers, provided that you may not offer
-                      the Licensed Work as a Commercial Certificate Service.
-
-                      A "Commercial Certificate Service" is a product or
-                      service whose principal value to a third party is the
-                      certificate management functionality of the Licensed
-                      Work — including but not limited to lifecycle
+                      The Licensed Work is (c) 2026 Shankar Reddy.
+Additional Use Grant: You may make use of the Licensed Work, provided that
+                      you may not use the Licensed Work for a Commercial
+                      Certificate Service. A "Commercial Certificate Service"
+                      is any product, service, or offering in which a third
+                      party (other than your employees and contractors
+                      acting on your behalf) accesses, uses, or benefits
+                      from the Licensed Work's certificate management
+                      functionality — including but not limited to lifecycle
                       management, discovery, monitoring, alerting, renewal
-                      automation, deployment, and revocation — where the
-                      third party accesses or controls that functionality
-                      and compensation is received for that access or
-                      control.
+                      automation, deployment, and revocation — as part of
+                      or in connection with an offering for which
+                      compensation is received. This restriction applies
+                      regardless of whether the Licensed Work is hosted,
+                      managed, embedded, bundled, or integrated with
+                      another product or service.
 
-                      For the avoidance of doubt:
-
-                      (a) you may run the Licensed Work in production to
-                          manage certificates for products or services
-                          that you offer to your customers, where the
-                          principal value of those products or services is
-                          something other than the Licensed Work's
-                          certificate management functionality (for
-                          example, you operate a banking application and
-                          use the Licensed Work internally to manage TLS
-                          certificates for that application);
-
-                      (b) for the purposes of this Additional Use Grant,
-                          "third party" excludes (i) your employees, (ii)
-                          your contractors acting on your behalf, and (iii)
-                          your Affiliates. "Affiliate" means any entity
-                          that controls, is controlled by, or is under
-                          common control with, you, where "control" means
-                          ownership of more than fifty percent (50%) of
-                          the voting interests of the entity;
-
-                      (c) the restriction on offering a Commercial
-                          Certificate Service applies regardless of whether
-                          the Licensed Work is hosted, managed, embedded,
-                          bundled, or integrated with another product or
-                          service.
-
-Change Date:          March 14, 2076
+Change Date:          March 14, 2033
 
 Change License:       Apache License, Version 2.0
 
@@ -88,47 +60,13 @@ of the Licensed Work. If you receive the Licensed Work in original or
 modified form from a third party, the terms and conditions set forth in this
 License apply to your use of that work.
 
-Patent non-assertion. During the term of this License, Licensor covenants
-not to assert any patent claim that Licensor controls against any person
-whose use of the Licensed Work complies with this License, with respect to
-the Licensed Work as distributed by Licensor. This covenant terminates with
-respect to any person who initiates a patent infringement action against
-the Licensor or against any contributor to the Licensed Work.
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
 
-Termination and reinstatement. Any use of the Licensed Work in violation of
-this License will automatically terminate your rights under this License
-for the current and all other versions of the Licensed Work. Your rights
-are reinstated automatically if you cease the violation and provide written
-notice to the Licensor at the contact address above within thirty (30) days
-of becoming aware of the violation. If you violate this License a second
-time after such reinstatement, your rights are not subject to further
-reinstatement.
-
-Contributions. The Licensor does not accept third-party contributions to
-the Licensed Work. Any code, documentation, or other material submitted to
-the Licensor or to any repository hosting the Licensed Work is provided at
-the submitter's sole risk, confers no rights or obligations on the
-Licensor, and is not incorporated into the Licensed Work.
-
-This License does not grant you any right in any trademark or logo of the
-Licensor or its Affiliates.
-
-Governing law and venue. This License shall be governed by and construed in
-accordance with the laws of the State of Florida, USA, without giving
-effect to any choice or conflict of law provision or rule. Any dispute
-arising from or relating to this License shall be brought exclusively in
-the state or federal courts located in the State of Florida, and the
-parties consent to the personal jurisdiction of such courts.
-
-Severability. If any provision of this License is held to be invalid,
-illegal, or unenforceable in any jurisdiction, that holding does not
-affect the validity, legality, or enforceability of any other provision of
-this License, which remains in full force and effect.
-
-Survival. The disclaimers of warranty, the patent non-assertion provisions
-(with respect to acts occurring before termination), the governing-law and
-venue provisions, and this survival provision survive any termination of
-this License.
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
 
 TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
 AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,

Makefile

@@ -1,4 +1,4 @@
-.PHONY: help build run test lint verify verify-docs verify-deploy loadtest acme-cert-manager-test acme-rfc-conformance-test clean docker-up docker-down migrate-up migrate-down generate test-cover frontend-build qa-stats
+.PHONY: help build run test lint clean docker-up docker-down migrate-up migrate-down generate test-cover frontend-build
 
 # Default target - show help
 help:
@@ -15,10 +15,6 @@ help:
 	@echo "  make test-verbose   Run tests with verbose output"
 	@echo "  make lint           Run linter (golangci-lint)"
 	@echo "  make fmt            Format code with gofmt"
-	@echo "  make verify         Pre-commit gate: fmt + vet + lint + test (CI-parity)"
-	@echo "  make verify-docs    Pre-tag gate:    QA-doc drift checks (operator-facing docs)"
-	@echo "  make verify-deploy  Pre-push gate:   digest validity + OpenAPI parity + docker build smoke"
-	@echo "  make loadtest       k6 throughput run against postgres + certctl (NOT in verify; manual + cron only)"
 	@echo ""
 	@echo "Database:"
 	@echo "  make migrate-up     Run migrations (requires DB_URL)"
@@ -101,105 +97,6 @@ vet:
 	@echo "Running go vet..."
 	go vet ./...
 
-# verify: aggregate pre-commit gate. Mirrors what CI enforces, so
-# running `make verify` locally before committing prevents the
-# class of breakages that ship green-locally / red-on-CI (e.g.
-# Bundle-9's ST1018 invisible-Unicode-literal hits, which `go vet`
-# alone cannot catch — staticcheck under golangci-lint does).
-verify:
-	@echo "==> fmt"
-	@go fmt ./... | { ! grep -q '.'; } || (echo "gofmt produced changes — commit them" && exit 1)
-	@echo "==> go vet ./..."
-	@go vet ./...
-	@echo "==> golangci-lint run ./... (incl. staticcheck ST*)"
-	@which golangci-lint > /dev/null || (echo "Installing golangci-lint..." && go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest)
-	@golangci-lint run ./... --timeout 5m
-	@echo "==> go test -short ./..."
-	@go test -short -count=1 ./...
-	@echo ""
-	@echo "verify: PASS — safe to commit"
-
-# verify-docs: pre-tag gate. Runs the QA-doc seed-count drift guard
-# that ci-pipeline-cleanup Phase 11 / frozen decision 0.13 moved out
-# of CI (was per-push blocking; now operator-runs pre-tag). Protects
-# docs/contributor/qa-test-suite.md::Seed Data Reference from
-# drifting vs migrations/seed_demo.sql. Operator-facing docs only —
-# not product-affecting.
-#
-# The QA-doc Part-count drift guard retired in the 2026-05-04 docs
-# overhaul Phase 5 when docs/testing-guide.md was pruned (its content
-# dispersed across the audience-organized doc tree); the Part-count
-# class no longer exists outside the qa_test.go file itself.
-verify-docs:
-	@echo "==> QA-doc seed-count drift"
-	@bash scripts/qa-doc-seed-count.sh
-	@echo ""
-	@echo "verify-docs: PASS — safe to tag"
-
-# verify-deploy: optional pre-push gate. Runs the digest-validity check,
-# the OpenAPI ↔ handler parity check, and a Docker build smoke for the
-# production images (server + agent only — fast subset for local; CI
-# builds all 4 Dockerfiles per ci-pipeline-cleanup Phase 8 / frozen
-# decision 0.10).
-#
-# Per ci-pipeline-cleanup bundle Phase 11 / frozen decision 0.13.
-verify-deploy:
-	@echo "==> Digest validity"
-	@bash scripts/ci-guards/digest-validity.sh
-	@echo "==> OpenAPI ↔ handler parity"
-	@bash scripts/ci-guards/openapi-handler-parity.sh
-	@echo "==> Docker build smoke (server + agent — fast subset)"
-	@docker build -f Dockerfile        -t certctl:verify           .
-	@docker build -f Dockerfile.agent  -t certctl-agent:verify     .
-	@echo ""
-	@echo "verify-deploy: PASS — safe to push"
-
-# Load-test harness — closes the #8 acquisition-readiness blocker from
-# the 2026-05-01 issuer coverage audit. Boots a minimal certctl stack
-# (postgres + tls-init + certctl-server) and runs k6 against the API
-# tier for ~5 minutes. Exits non-zero on any threshold breach.
-#
-# NOT in `make verify` — load tests take minutes, not seconds, and
-# don't gate per-PR signal. CI gates this behind workflow_dispatch +
-# weekly cron in .github/workflows/loadtest.yml. See
-# deploy/test/loadtest/README.md for thresholds, baseline, and how to
-# interpret a regression.
-loadtest:
-	@echo "==> spinning up postgres + certctl + k6 driver (this takes ~7m)"
-	@cd deploy/test/loadtest && docker compose up --build --abort-on-container-exit --exit-code-from k6
-	@echo ""
-	@echo "==> results landed in deploy/test/loadtest/results/"
-	@if [ -f deploy/test/loadtest/results/summary.txt ]; then cat deploy/test/loadtest/results/summary.txt; fi
-
-# Phase 5 — kind-driven cert-manager integration test. Requires
-# `kind`, `kubectl`, `helm`, and a local Docker daemon. Sets
-# KIND_AVAILABLE=1 so the test runs (it skips cleanly when unset, which
-# is the CI default — kind is too heavy for per-PR CI). The test
-# brings up a fresh cluster, installs cert-manager 1.15, helm-installs
-# certctl-test, applies a ClusterIssuer + Certificate, and asserts the
-# Secret lands.
-acme-cert-manager-test:
-	@echo "==> running cert-manager integration test (requires kind/kubectl/helm)"
-	@KIND_AVAILABLE=1 go test -tags=integration -count=1 -timeout=15m \
-	  ./deploy/test/acme-integration/...
-
-# Phase 5 — RFC 8555 conformance against `lego` driving the certctl
-# server. Hermetic: brings up a single certctl-server via docker
-# compose, points lego at it, runs the conformance scenarios. Skips
-# when the operator hasn't built the test image (`make docker-build`
-# first).
-acme-rfc-conformance-test:
-	@echo "==> running RFC 8555 conformance via lego"
-	@if ! command -v lego >/dev/null 2>&1; then \
-	  echo "lego not installed — go install github.com/go-acme/lego/v4/cmd/lego@latest"; \
-	  exit 1; \
-	fi
-	@cd deploy/test/loadtest && docker compose up -d certctl postgres
-	@sleep 8
-	@CERTCTL_ACME_DIR=https://localhost:8443/acme/profile/prof-test/directory \
-	  bash deploy/test/acme-integration/conformance-lego.sh
-	@cd deploy/test/loadtest && docker compose down
-
 # Database targets (requires migrate tool)
 migrate-up:
 	@echo "Running migrations..."
@@ -265,31 +162,6 @@ frontend-build:
 	cd web && npm ci && npx vite build
 	@echo "Frontend build complete"
 
-# QA Suite Stats — Bundle P / Strengthening #8.
-# Single source-of-truth for every count claim in
-# docs/contributor/qa-test-suite.md. The Strengthening #6 CI drift guards
-# (now scoped to the seed-count class only — the Part-count class retired
-# in the 2026-05-04 docs overhaul Phase 5 when testing-guide.md was
-# pruned) consume the same numbers, eliminating the doc-drift class
-# structurally.
-qa-stats:
-	@echo "=== certctl QA Suite Stats ==="
-	@echo "Date: $$(date +%Y-%m-%d)"
-	@echo "HEAD: $$(git rev-parse HEAD 2>/dev/null || echo 'not-a-git-repo')"
-	@echo ""
-	@echo "Backend test files: $$(find . -name '*_test.go' -not -path './web/*' 2>/dev/null | wc -l | tr -d ' ')"
-	@echo "Backend Test functions: $$(find . -name '*_test.go' -not -path './web/*' 2>/dev/null | xargs grep -c '^func Test' 2>/dev/null | awk -F: '{s+=$$2} END{print s+0}')"
-	@echo "Backend t.Run subtests: $$(find . -name '*_test.go' -not -path './web/*' 2>/dev/null | xargs grep -c 't\.Run(' 2>/dev/null | awk -F: '{s+=$$2} END{print s+0}')"
-	@echo "Frontend test files: $$(find web/src -name '*.test.ts' -o -name '*.test.tsx' 2>/dev/null | wc -l | tr -d ' ')"
-	@echo "Fuzz targets: $$(grep -rE 'func Fuzz[A-Z]' --include='*_test.go' . 2>/dev/null | wc -l | tr -d ' ')"
-	@echo "t.Skip sites: $$(grep -rE 't\.Skip(Now|f)?\(' --include='*_test.go' . 2>/dev/null | wc -l | tr -d ' ')"
-	@echo "qa_test.go Part_ subtests: $$(grep -cE 't\.Run\(\"Part[0-9]+_' deploy/test/qa_test.go 2>/dev/null || echo 0)"
-	@echo "Seed unique mc-* IDs:  $$(grep -oE "mc-[a-z0-9_-]+" migrations/seed_demo.sql 2>/dev/null | sort -u | wc -l | tr -d ' ')"
-	@echo "Seed unique ag-* IDs:  $$(grep -oE "ag-[a-z0-9_-]+" migrations/seed_demo.sql 2>/dev/null | sort -u | wc -l | tr -d ' ') (incl. agent_groups; agents-table count is 13 incl. agent-demo-1 + 3 cloud sentinels + server-scanner)"
-	@echo "Seed unique iss-* IDs: $$(grep -oE "iss-[a-z0-9_-]+" migrations/seed_demo.sql 2>/dev/null | sort -u | wc -l | tr -d ' ') (issuers table count is 13)"
-	@echo "Seed unique tgt-* IDs: $$(grep -oE "tgt-[a-z0-9_-]+" migrations/seed_demo.sql 2>/dev/null | sort -u | wc -l | tr -d ' ')"
-	@echo "Seed unique nst-* IDs: $$(grep -oE "nst-[a-z0-9_-]+" migrations/seed_demo.sql 2>/dev/null | sort -u | wc -l | tr -d ' ')"
-
 # Cleanup
 clean:
 	@echo "Cleaning build artifacts..."

README.md

@@ -2,38 +2,139 @@
   <img src="docs/screenshots/logo/certctl-logo.png" alt="certctl logo" width="450">
 </p>
 
+<img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=89db181e-76e0-45cc-b9c0-790c3dfdfc73" />
+<img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=b9379aff-9e5c-4d01-8f2d-9e4ffa09d126" />
+
 # certctl — Self-Hosted Certificate Lifecycle Platform
 
 [![License](https://img.shields.io/badge/license-BSL%201.1-blue.svg)](LICENSE)
-[![Go Report Card](https://goreportcard.com/badge/github.com/certctl-io/certctl)](https://goreportcard.com/report/github.com/certctl-io/certctl)
-[![GitHub Release](https://img.shields.io/github/v/release/certctl-io/certctl)](https://github.com/certctl-io/certctl/releases)
-[![GitHub Stars](https://img.shields.io/github/stars/certctl-io/certctl?style=flat&logo=github)](https://github.com/certctl-io/certctl/stargazers)
+[![Go Report Card](https://goreportcard.com/badge/github.com/shankar0123/certctl)](https://goreportcard.com/report/github.com/shankar0123/certctl)
+[![GitHub Release](https://img.shields.io/github/v/release/shankar0123/certctl)](https://github.com/shankar0123/certctl/releases)
+[![GitHub Stars](https://img.shields.io/github/stars/shankar0123/certctl?style=flat&logo=github)](https://github.com/shankar0123/certctl/stargazers)
 
-certctl is a self-hosted platform that automates the entire TLS certificate lifecycle, from issuance through renewal to deployment, with zero human intervention. It works with any certificate authority, deploys to any server, and keeps private keys on your infrastructure where they belong. Free, source-available under BSL 1.1, covers the same lifecycle that enterprise platforms charge $100K+/year for.
+TLS certificate lifespans are shrinking fast. The CA/Browser Forum passed [Ballot SC-081v3](https://cabforum.org/2025/04/11/ballot-sc081v3-introduce-schedule-of-reducing-validity-and-data-reuse-periods/) unanimously in April 2025, setting a phased reduction: **200 days** by March 2026, **100 days** by March 2027, and **47 days** by March 2029. Organizations managing dozens or hundreds of certificates can no longer rely on spreadsheets, calendar reminders, or manual renewal workflows. The math doesn't work — at 47-day lifespans, a team managing 100 certificates is processing 7+ renewals per week, every week, forever.
 
-The CA/Browser Forum's [Ballot SC-081v3](https://cabforum.org/2025/04/11/ballot-sc081v3-introduce-schedule-of-reducing-validity-and-data-reuse-periods/) caps public TLS certificates at **200 days by March 2026**, **100 days by 2027**, and **47 days by 2029**. At 47-day lifespans, a team managing 100 certificates is processing 7+ renewals per week, every week, forever. Manual workflows stop being a choice.
+certctl is a self-hosted platform that automates the entire certificate lifecycle — from issuance through renewal to deployment — with zero human intervention. It works with any certificate authority, deploys to any server, and keeps private keys on your infrastructure where they belong. It's free, self-hosted, and covers the same lifecycle that enterprise platforms charge $100K+/year for.
 
-> **Status: Early-access.** Production-quality core (Local CA, ACME, agent deployment, CRUD, audit, [role-based authz](docs/operator/rbac.md) with auditor split + day-0 bootstrap + four-eyes approval) with broader feature surface (intermediate CA hierarchy, ACME/SCEP/EST servers, network appliances) still maturing. [Federated identity](docs/operator/auth-threat-model.md#threats-bundle-1-does-not-close) (OIDC/SAML/WebAuthn, server-side sessions, break-glass accounts, JIT elevation) is the next slice on the roadmap, not yet shipped. Lab and dev deployments encouraged; production deployments welcome with the understanding that customer-scale battle-testing is in progress. File GitHub issues for any rough edges.
+```mermaid
+gantt
+    title TLS Certificate Maximum Lifespan — CA/Browser Forum Ballot SC-081v3
+    dateFormat YYYY-MM-DD
+    axisFormat
+    todayMarker off
+    section 2015
+        5 years (1825 days)    :done, 2020-01-01, 1825d
+    section 2018
+        825 days               :done, 2020-01-01, 825d
+    section 2020
+        398 days               :active, 2020-01-01, 398d
+    section 2026
+        200 days               :crit, 2020-01-01, 200d
+    section 2027
+        100 days               :crit, 2020-01-01, 100d
+    section 2029
+        47 days                :crit, 2020-01-01, 47d
+```
 
-> **Actively maintained, shipping weekly.** [Open an issue](https://github.com/certctl-io/certctl/issues) if something breaks. CI runs the full test suite with race detection, static analysis, and vulnerability scanning on every commit.
+> **Actively maintained — shipping weekly.** Found something? [Open a GitHub issue](https://github.com/shankar0123/certctl/issues) — issues get triaged same-day. CI runs the full test suite with race detection, static analysis, and vulnerability scanning on every commit.
 
-**Ready to try it?** Jump to the [Quick Start](#quick-start). For the marketing site, see [certctl.io](https://certctl.io).
+**Ready to try it?** Jump to the [Quick Start](#quick-start) — you'll have a running dashboard in under 5 minutes.
 
 ## Documentation
 
-The full audience-organized index lives at [`docs/README.md`](docs/README.md). Top-level entry points:
+| Guide | Description |
+|-------|-------------|
+| [Why certctl?](docs/why-certctl.md) | How certctl compares to ACME clients, agent-based SaaS, and enterprise platforms |
+| [Concepts](docs/concepts.md) | TLS certificates explained from scratch — for beginners who know nothing about certs |
+| [Quick Start](docs/quickstart.md) | 5-minute setup — dashboard, API, CLI, discovery, stakeholder demo flow |
+| [Docker Compose Environments](deploy/ENVIRONMENTS.md) | Service-by-service walkthrough of all 4 compose files, env var reference |
+| [Deployment Examples](docs/examples.md) | 5 turnkey scenarios (ACME+NGINX, wildcard DNS-01, private CA, step-ca, multi-issuer) with migration guides |
+| [Advanced Demo](docs/demo-advanced.md) | Issue a certificate end-to-end with technical deep-dives |
+| [Architecture](docs/architecture.md) | System design, data flow diagrams, security model |
+| [Feature Inventory](docs/features.md) | Complete reference of all capabilities, API endpoints, and configuration |
+| [Connector Reference](docs/connectors.md) | Configuration for all issuer, target, and notifier connectors |
+| [MCP Server](docs/mcp.md) | AI integration via Model Context Protocol — setup, available tools, examples |
+| [OpenAPI 3.1 Spec](docs/openapi.md) | API reference guide with endpoint overview ([raw spec](api/openapi.yaml)) |
+| [Compliance Mapping](docs/compliance.md) | SOC 2 Type II, PCI-DSS 4.0, NIST SP 800-57 alignment guides |
+| [Migrate from certbot](docs/migrate-from-certbot.md) | Step-by-step migration from certbot cron jobs to certctl |
+| [Migrate from acme.sh](docs/migrate-from-acmesh.md) | Migration guide for acme.sh users, DNS hook compatibility |
+| [certctl for cert-manager users](docs/certctl-for-cert-manager-users.md) | How certctl complements cert-manager for mixed infrastructure |
+| [Test Environment](docs/test-env.md) | Docker Compose test environment with real CA backends |
+| [Testing Guide](docs/testing-guide.md) | Comprehensive test procedures, smoke tests, and release sign-off checklist |
 
-| Audience | Start here |
-|---|---|
-| New to certctl | [Concepts](docs/getting-started/concepts.md) → [Quickstart](docs/getting-started/quickstart.md) → [Examples](docs/getting-started/examples.md) |
-| Production operator | [Architecture](docs/reference/architecture.md) → [Security posture](docs/operator/security.md) → [Disaster recovery runbook](docs/operator/runbooks/disaster-recovery.md) |
-| PKI engineer | [ACME server](docs/reference/protocols/acme-server.md) → [SCEP server](docs/reference/protocols/scep-server.md) → [EST server](docs/reference/protocols/est.md) → [CA hierarchy](docs/reference/intermediate-ca-hierarchy.md) |
-| Migrating from another tool | [from certbot](docs/migration/from-certbot.md) / [from acme.sh](docs/migration/from-acmesh.md) / [cert-manager coexistence](docs/migration/cert-manager-coexistence.md) |
-| Contributor | [Architecture](docs/reference/architecture.md) → [Testing strategy](docs/contributor/testing-strategy.md) → [CI pipeline](docs/contributor/ci-pipeline.md) |
+## Supported Integrations
 
-For the connector reference (12 issuers, 15 targets, 6 notifiers) see [`docs/reference/connectors/index.md`](docs/reference/connectors/index.md).
+### Certificate Issuers
 
-## Screenshots
+| Issuer | Type | Notes |
+|--------|------|-------|
+| Local CA (self-signed + sub-CA) | `GenericCA` | Sub-CA mode chains to enterprise root (ADCS, etc.) |
+| ACME v2 (Let's Encrypt, ZeroSSL, etc.) | `ACME` | HTTP-01, DNS-01, DNS-PERSIST-01 challenges. EAB auto-fetch from ZeroSSL. Profile selection (`tlsserver`, `shortlived`). |
+| step-ca (Smallstep) | `StepCA` | JWK provisioner auth, issuance + renewal + revocation |
+| OpenSSL / Custom CA | `OpenSSL` | Shell script adapter — any CA with a CLI |
+| HashiCorp Vault PKI | `VaultPKI` | Token auth, synchronous issuance, CRL/OCSP delegated to Vault |
+| DigiCert CertCentral | `DigiCert` | Async order model, OV/EV support, PEM bundle parsing |
+| Sectigo SCM | `Sectigo` | 3-header auth, DV/OV/EV, collect-not-ready graceful handling |
+| Google Cloud CAS | `GoogleCAS` | OAuth2 service account, synchronous issuance, CA pool selection |
+| AWS ACM Private CA | `AWSACMPCA` | Synchronous issuance, configurable signing algorithm/template ARN |
+| Entrust Certificate Services | `Entrust` | mTLS client certificate auth, synchronous/approval-pending issuance |
+| GlobalSign Atlas HVCA | `GlobalSign` | mTLS + API key/secret dual auth, serial-based tracking |
+| EJBCA (Keyfactor) | `EJBCA` | Dual auth (mTLS or OAuth2), self-hosted open-source CA |
+
+**Note:** ADCS integration is handled via the Local CA's sub-CA mode — certctl operates as a subordinate CA with its signing certificate issued by ADCS. Any CA with a shell-accessible signing interface can be integrated via the OpenSSL/Custom CA connector.
+
+### Deployment Targets
+
+| Target | Type | Notes |
+|--------|------|-------|
+| NGINX | `NGINX` | File write, config validation, reload |
+| Apache httpd | `Apache` | Separate cert/chain/key files, configtest, graceful reload |
+| HAProxy | `HAProxy` | Combined PEM file, validate, reload |
+| Traefik | `Traefik` | File provider deployment, auto-reload via filesystem watch |
+| Caddy | `Caddy` | Dual-mode: admin API hot-reload or file-based |
+| Envoy | `Envoy` | File-based with optional SDS JSON config |
+| Postfix | `Postfix` | Mail server TLS, pairs with S/MIME support |
+| Dovecot | `Dovecot` | Mail server TLS, pairs with S/MIME support |
+| Microsoft IIS | `IIS` | Local PowerShell or remote WinRM, PEM→PFX, SNI support |
+| F5 BIG-IP | `F5` | iControl REST via proxy agent, transaction-based atomic updates |
+| SSH (Agentless) | `SSH` | SFTP cert/key deployment to any Linux/Unix server |
+| Windows Certificate Store | `WinCertStore` | PowerShell Import-PfxCertificate, configurable store/location |
+| Java Keystore | `JavaKeystore` | PEM→PKCS#12→keytool pipeline, JKS and PKCS12 formats |
+| Kubernetes Secrets | `KubernetesSecrets` | `kubernetes.io/tls` Secrets, in-cluster or kubeconfig auth |
+
+### Enrollment Protocols
+
+| Protocol | Standard | Use Case |
+|----------|----------|----------|
+| EST (Enrollment over Secure Transport) | RFC 7030 | Device enrollment, WiFi/802.1X, IoT |
+| SCEP (Simple Certificate Enrollment Protocol) | RFC 8894 | MDM platforms (Jamf, Intune), network devices |
+| ACME v2 | RFC 8555 | Public CA automated issuance (Let's Encrypt, ZeroSSL) |
+| ACME ARI (Renewal Information) | RFC 9773 | CA-directed renewal timing — the CA tells you when to renew |
+
+### Standards & Revocation
+
+| Capability | Standard | Notes |
+|------------|----------|-------|
+| DER-encoded X.509 CRL | RFC 5280 | Per-issuer, signed by issuing CA, 24h validity |
+| Embedded OCSP responder | RFC 6960 | Good/revoked/unknown status per issuer |
+| S/MIME certificates | RFC 8551 | Email protection EKU, adaptive KeyUsage flags |
+| Certificate export | — | PEM (JSON/file) and PKCS#12 formats |
+| ACME DNS-PERSIST-01 | IETF draft | Standing validation record, no per-renewal DNS updates |
+
+### Notifiers
+
+| Notifier | Type |
+|----------|------|
+| Email (SMTP) | `Email` |
+| Webhooks | `Webhook` |
+| Slack | `Slack` |
+| Microsoft Teams | `Teams` |
+| PagerDuty | `PagerDuty` |
+| OpsGenie | `OpsGenie` |
+
+All connectors are pluggable — build your own by implementing the [connector interface](docs/connectors.md).
+
+### Screenshots
 
 <table>
 <tr>
@@ -50,63 +151,78 @@ For the connector reference (12 issuers, 15 targets, 6 notifiers) see [`docs/ref
 
 ## Why certctl
 
-Certificate lifecycle tooling has historically split into two camps. Enterprise platforms charge six-figure annual licenses, take months to deploy, and bill professional-services hours at $250 to $400 per hour to write integration code that should ship with the product. Single-purpose tools handle one slice of the problem and leave the operator to glue the rest together. certctl fills the gap — full lifecycle automation, self-hosted, free, CA-agnostic, target-agnostic. If you're stitching together cron jobs across a fleet, manually renewing certs, or writing custom integration scripts to bridge a commercial CLM platform to your actual infrastructure, certctl replaces all of that.
+Certificate lifecycle tooling falls into two camps: enterprise platforms (Venafi, Keyfactor) that cost six figures and take months to deploy, or single-purpose tools (certbot, cert-manager) that handle one slice of the problem. certctl fills the gap — full lifecycle automation, self-hosted, free, CA-agnostic, and target-agnostic. If you're running certbot cron jobs, manually renewing certs, or stitching together scripts across mixed infrastructure, certctl replaces all of that.
 
-Built for **platform engineering and DevOps teams** managing 10 to 500+ certificates, **security teams** who need audit trails and policy enforcement, and **small teams without enterprise budgets** who need enterprise-grade automation for a 50-server environment. For the detailed positioning argument and when not to use certctl, see [Why certctl?](docs/getting-started/why-certctl.md).
+Built for **platform engineering and DevOps teams** managing 10–500+ certificates, **security and compliance teams** who need audit trails and policy enforcement for SOC 2, PCI-DSS 4.0, or NIST SP 800-57 ([compliance mapping included](docs/compliance.md)), and **small teams without enterprise budgets** who need Venafi-grade automation for a 50-server environment. For a detailed comparison, see [Why certctl?](docs/why-certctl.md)
 
-## What it does
+**Architecture.** Go 1.25 control plane with handler→service→repository layering, PostgreSQL 16 backend (21 tables), and a pull-only deployment model — the server never initiates outbound connections. Agents poll for work. For network appliances and agentless servers, a proxy agent in the same network zone handles deployment via the target's API (WinRM, iControl REST, SSH/SFTP). Background scheduler runs 7 loops: renewal with ARI integration (1h), job processing (30s), agent health (2m), notifications (1m), short-lived cert expiry (30s), network scanning (6h), certificate digest (24h). See [Architecture Guide](docs/architecture.md) for full system diagrams.
 
-certctl handles the full certificate lifecycle in one self-hosted control plane:
+**Security-first.** Agents generate ECDSA P-256 keys locally — private keys never touch the control plane. API key auth enforced by default with SHA-256 hashing and constant-time comparison. CORS deny-by-default. Shell injection prevention on all connector scripts. SSRF protection (reserved IP filtering) on the network scanner. Atomic idempotency guards on scheduler loops. Issuer and target credentials encrypted at rest with AES-256-GCM. Every API call recorded to an immutable audit trail with actor attribution, body hash, and latency tracking. CI runs race detection, 11 linters, and vulnerability scanning on every commit.
 
-- **Issue and renew** from any CA. Let's Encrypt and any ACME provider, an embedded ACME server you can point cert-manager / certbot / lego at directly, a built-in local CA with sub-CA mode (chains under your enterprise root like ADCS), step-ca, Vault PKI, EJBCA, AWS ACM PCA, Google CAS, DigiCert, Sectigo, GlobalSign, Entrust, plus an OpenSSL / shell-script adapter for anything custom. Twelve native issuer connectors. See the [connector reference](docs/reference/connectors/index.md).
-- **Deploy automatically** to NGINX, Apache, HAProxy, Caddy, Traefik, Envoy, IIS, Windows Cert Store, Java keystore, Kubernetes Secrets, AWS ACM, Azure Key Vault, SSH known-hosts, Postfix + Dovecot, F5 BIG-IP. Fifteen native target connectors. Every deploy goes through atomic-write + ownership-preservation + SHA-256 idempotency + per-target Prometheus counters + pre-deploy snapshot + on-failure rollback. See [`docs/reference/deployment-model.md`](docs/reference/deployment-model.md).
-- **Run as an ACME server** so existing client tooling plugs in directly. RFC 8555 + RFC 9773 ARI, two per-profile auth modes (public-trust-style validation or trust_authenticated for internal PKI), doubly-signed key rollover, revoke-cert on both kid path and jwk path, per-account rate limiting. Cert-manager / certbot / lego all work pointed at it. See [`docs/reference/protocols/acme-server.md`](docs/reference/protocols/acme-server.md).
-- **Run as a SCEP server** for Microsoft Intune-managed phones, ChromeOS devices, network appliances. RFC 8894 native with full PKIMessage wire format, native Intune challenge dispatch with replay protection, per-profile dispatch with separate RA cert per profile. See [`docs/reference/protocols/scep-server.md`](docs/reference/protocols/scep-server.md).
-- **Run as an EST server** for HTTPS-based PKCS#10 enrollment. 802.1X / Wi-Fi authentication, IoT device enrollment, RFC 9266 channel binding. See [`docs/reference/protocols/est.md`](docs/reference/protocols/est.md).
-- **Manage multi-level CA hierarchies** with name constraints, path-length enforcement, and end-to-end RFC 5280 path validation. Root → intermediate → issuing chains, admin-gated CRUD, drain-first retirement. Patterns documented for 4-level boundary CAs, 3-level policy CAs with per-BU `PermittedDNSDomains`, and 2-level internal PKI. See [`docs/reference/intermediate-ca-hierarchy.md`](docs/reference/intermediate-ca-hierarchy.md).
-- **Gate high-stakes issuance** behind two-person-integrity approval. Flag a profile as `RequiresApproval`, the request lands in a queue, a non-requester approves, the scheduler dispatches. Profile-edit changes on approval-tier profiles route through the same gate so the flip-flop bypass is closed. See [`docs/operator/approval-workflow.md`](docs/operator/approval-workflow.md).
-- **Authorize with role-based access control.** Seven default roles (admin, operator, viewer, agent, mcp, cli, auditor) over a 33-permission canonical catalogue with global / per-profile / per-issuer scope. Auditor role is read-only on the audit trail (`audit.read` + `audit.export`, nothing else) so a regulator's key cannot read certificates or mutate config. Day-0 admin via a one-shot `CERTCTL_BOOTSTRAP_TOKEN` endpoint that closes itself the moment any admin lands. Privilege-escalation guard requires `auth.role.assign` to grant or revoke a role. See [`docs/operator/rbac.md`](docs/operator/rbac.md), [`docs/operator/auth-threat-model.md`](docs/operator/auth-threat-model.md), and the v2.0.x → v2.1.0 [migration guide](docs/migration/api-keys-to-rbac.md).
-- **Discover** existing certs across your fleet via filesystem scanning on agents, network TLS probing across CIDR ranges, and cloud secret manager imports (AWS Secrets Manager, Azure Key Vault, GCP Secret Manager). Triage workflow for claim / dismiss / investigate.
-- **Revoke** with full RFC 5280 reason codes, DER CRL generation per issuer (scheduler-pre-generated and ETag-cached), and an embedded RFC 6960 OCSP responder with dedicated per-issuer responder certs. Single + bulk revocation. See [`docs/reference/protocols/crl-ocsp.md`](docs/reference/protocols/crl-ocsp.md).
-- **Alert** via Slack, Microsoft Teams, PagerDuty, OpsGenie, email, webhooks. Per-policy multi-channel routing matrix with severity tiers and fault-isolating per-channel dispatch. See [`docs/operator/runbooks/expiry-alerts.md`](docs/operator/runbooks/expiry-alerts.md).
-- **Drive the platform from natural language** via the bundled MCP (Model Context Protocol) server. The full REST API is exposed as MCP tools — ask your AI client "show me all expiring certificates", "revoke the VPN cert, key compromised", or "what agents are offline?" and it translates to API calls. Stateless stdio-transport binary at `cmd/mcp-server/`; same auth as the REST API; no extra attack surface. See [`docs/reference/mcp.md`](docs/reference/mcp.md).
+**Key design decisions.** TEXT primary keys — human-readable prefixed IDs (`mc-api-prod`, `t-platform`, `o-alice`) so you can identify resources at a glance in logs and queries. Idempotent migrations (`IF NOT EXISTS`, `ON CONFLICT DO NOTHING`) safe for repeated execution. Dynamic configuration via GUI with AES-256-GCM encrypted credential storage and env var backward compatibility. Handlers define their own service interfaces for clean dependency inversion.
 
-## Architecture and security
+## What It Does
 
-Go 1.25 control plane with handler → service → repository layering. PostgreSQL 16 backend (35+ tables, idempotent migrations). Pull-only deployment model — the server never initiates outbound connections. Agents poll for work and generate ECDSA P-256 keys locally so private keys never touch the control plane. For network appliances and agentless servers, a proxy agent in the same network zone handles deployment via the target's API (WinRM, iControl REST, SSH/SFTP). See the [Architecture Guide](docs/reference/architecture.md) for full system diagrams.
+**Automated lifecycle.** Certificates renew and deploy themselves. The scheduler monitors expiration, issues through your CA, and deploys to targets — zero human intervention. ACME ARI (RFC 9773) lets the CA direct renewal timing. Ready for 47-day (SC-081v3) and 6-day (Let's Encrypt shortlived) certificate lifetimes.
 
-Security: API-key authentication with SHA-256 hashing + constant-time comparison, then role-based authorization on every gated handler with global / per-profile / per-issuer scope. Auditor split keeps regulator-class actors strictly read-only on the audit trail. Day-0 admin via a one-shot bootstrap token; granting or revoking roles requires the dedicated `auth.role.assign` permission. CORS deny-by-default. Shell injection prevention on all connector scripts. SSRF protection (reserved IP filtering) on the network scanner. Issuer and target credentials encrypted at rest with AES-256-GCM. HTTPS-only control plane with TLS 1.3 pinned and a fail-closed startup gate that refuses to boot if the TLS bundle is unusable. Every API call recorded to an immutable audit trail with actor attribution, body hash, and latency tracking. CI runs race detection, 11 linters, and vulnerability scanning on every commit. See [`docs/operator/security.md`](docs/operator/security.md) for the full posture and [`docs/operator/auth-threat-model.md`](docs/operator/auth-threat-model.md) for what's defended vs deferred.
+**Operational dashboard.** 26-page GUI covers the entire lifecycle: certificate inventory with bulk ops, deployment timeline with rollback, discovery triage, network scan management, agent fleet health, short-lived credential countdown, approval workflows, and observability metrics. Configure issuers and targets from the dashboard — no env var editing, no server restarts.
+
+**Private keys stay on your servers.** Agents generate ECDSA P-256 keys locally, submit only the CSR. The control plane never touches private keys. After deployment, agents probe the live TLS endpoint and compare SHA-256 fingerprints to confirm the right certificate is actually being served.
+
+**Discovery.** Agents scan filesystems for existing PEM/DER certificates. The network scanner probes TLS endpoints across CIDR ranges without agents. Cloud discovery finds certificates in AWS Secrets Manager, Azure Key Vault, and GCP Secret Manager. Continuous TLS health monitoring tracks endpoint status (healthy/degraded/down/cert_mismatch) with configurable thresholds and historical probe data. All discovery modes feed into a unified triage workflow — claim, dismiss, or import what you find.
+
+**Policy engine.** Certificate profiles constrain key types, max TTL, and EKUs — with crypto policy enforcement that validates every CSR against profile rules before it reaches the issuer. MaxTTL caps are enforced per issuer connector. Approval workflows pause jobs for human review. Ownership tracking routes notifications to the right team. Agent groups match devices by OS, architecture, IP CIDR, and version.
+
+**Enrollment protocols.** EST server (RFC 7030) for device and WiFi enrollment. SCEP server (RFC 8894) for MDM platforms and network devices. S/MIME issuance with email protection EKU.
+
+**Revocation.** Single and bulk revocation (by profile, owner, agent, or issuer). DER-encoded X.509 CRL per issuer, signed by the issuing CA. Embedded OCSP responder. RFC 5280 reason codes. Short-lived certs (TTL < 1 hour) are exempt — expiry is sufficient revocation.
+
+**Audit and observability.** Immutable append-only audit trail records every lifecycle action, every API call, and every approval decision. Prometheus metrics endpoint. Scheduled certificate digest emails. Continuous endpoint health monitoring with state machine transitions and real-time alerts.
+
+**Notifications.** Slack, Teams, PagerDuty, OpsGenie, SMTP, webhooks. Routed by certificate owner. Daily digest emails with stats and expiring certs.
+
+**Multiple interfaces.** REST API (111 routes), CLI (12 commands), MCP server (80 tools for Claude, Cursor, Windsurf), Helm chart, web dashboard. Certificate export in PEM and PKCS#12.
+
+**First-run onboarding.** Wizard guides you through connecting a CA, deploying an agent, and issuing your first certificate. Or start with the pre-populated demo — 32 certificates, 10 issuers, 180 days of history.
+
+For the complete capability breakdown, see the [Feature Inventory](docs/features.md).
 
 ## Quick Start
 
-### Docker Compose (recommended)
+### Docker Compose (Recommended)
 
 ```bash
-git clone https://github.com/certctl-io/certctl.git
+git clone https://github.com/shankar0123/certctl.git
 cd certctl
+docker compose -f deploy/docker-compose.yml up -d --build
+```
+
+Wait ~30 seconds, then open **https://localhost:8443** in your browser. (The shipped `docker-compose.yml` self-signs a cert via the `certctl-tls-init` init container on first boot — accept the browser warning for the demo, or feed the generated `ca.crt` to your client.) The onboarding wizard walks you through connecting a CA, deploying an agent, and issuing your first certificate.
+
+**Want a pre-populated demo instead?** Add the demo override to see 32 certificates across 10 issuers, 8 agents, and 180 days of realistic history:
+
+```bash
 docker compose -f deploy/docker-compose.yml -f deploy/docker-compose.demo.yml up -d --build
 ```
 
-Wait ~30 seconds, then open **https://localhost:8443** in your browser. The shipped demo overlay seeds 32 certificates across 10 issuers, 8 agents, and 180 days of realistic history. The `certctl-tls-init` init container self-signs an ECDSA-P256 cert on first boot — accept the browser warning for the demo, or feed the generated `ca.crt` to your client.
-
-For a clean install without demo data, drop the `-f deploy/docker-compose.demo.yml` flag and run `docker compose -f deploy/docker-compose.yml up -d --build`. The four compose files (`docker-compose.yml` base, `docker-compose.demo.yml` overlay, `docker-compose.dev.yml` for PgAdmin + debug logging, `docker-compose.test.yml` for integration tests) are documented at [`deploy/ENVIRONMENTS.md`](deploy/ENVIRONMENTS.md).
+The `deploy/` directory has four compose files: `docker-compose.yml` (base platform), `docker-compose.demo.yml` (demo data overlay), `docker-compose.dev.yml` (PgAdmin + debug logging), and `docker-compose.test.yml` (standalone integration tests with real CA backends). See the [Docker Compose Environments Guide](deploy/ENVIRONMENTS.md) for a service-by-service walkthrough, or the [Quick Start](docs/quickstart.md#docker-compose-environments) for a summary.
 
 ```bash
 curl --cacert $(docker compose -f deploy/docker-compose.yml exec -T certctl-server cat /etc/certctl/tls/ca.crt) https://localhost:8443/health
 # {"status":"healthy"}
 ```
 
-The control plane is HTTPS-only with TLS 1.3 pinned. See [`docs/operator/tls.md`](docs/operator/tls.md) for cert provisioning patterns.
+The control plane is HTTPS-only (TLS 1.3, no plaintext listener). See [`docs/tls.md`](docs/tls.md) for cert provisioning patterns and [`docs/upgrade-to-tls.md`](docs/upgrade-to-tls.md) if you're upgrading from a pre-v2.2 release.
 
-### Agent install (one-liner)
+### Agent Install (One-Liner)
 
 ```bash
-curl -sSL https://raw.githubusercontent.com/certctl-io/certctl/master/install-agent.sh | bash
+curl -sSL https://raw.githubusercontent.com/shankar0123/certctl/master/install-agent.sh | bash
 ```
 
-Detects your OS and architecture, downloads the binary, configures systemd (Linux) or launchd (macOS), and starts the agent. See [install-agent.sh](install-agent.sh).
+Detects your OS and architecture, downloads the binary, configures systemd (Linux) or launchd (macOS), and starts the agent. See [install-agent.sh](install-agent.sh) for details.
 
-### Helm chart (Kubernetes)
+### Helm Chart (Kubernetes)
 
 ```bash
 helm install certctl deploy/helm/certctl/ \
@@ -114,18 +230,86 @@ helm install certctl deploy/helm/certctl/ \
   --set postgres.password=your-db-password
 ```
 
-Production-ready chart with Server Deployment, PostgreSQL StatefulSet, Agent DaemonSet, health probes, security contexts (non-root, read-only rootfs), and optional Ingress. See [values.yaml](deploy/helm/certctl/values.yaml).
+Production-ready chart with Server Deployment, PostgreSQL StatefulSet, Agent DaemonSet, health probes, security contexts (non-root, read-only rootfs), and optional Ingress. See [values.yaml](deploy/helm/certctl/values.yaml) for all configuration options.
 
-### Container images
+### Docker Pull
 
 ```bash
-docker pull ghcr.io/certctl-io/certctl-server:latest
-docker pull ghcr.io/certctl-io/certctl-agent:latest
+docker pull shankar0123.docker.scarf.sh/certctl-server
+docker pull shankar0123.docker.scarf.sh/certctl-agent
+```
+
+## Verifying this release
+
+Every `v*` tag publishes signed, attested release artefacts. Binaries
+(`certctl-agent`, `certctl-server`, `certctl-cli`, `certctl-mcp-server` for
+`linux|darwin × amd64|arm64`) ship alongside a `checksums.txt`, per-binary
+SPDX-JSON SBOMs, Cosign signatures, and SLSA Level 3 provenance. Container
+images on `ghcr.io/shankar0123/certctl-{server,agent}` are built with
+`docker/build-push-action` `provenance: mode=max` + `sbom: true` and are
+additionally signed with Cosign at the image digest.
+
+All signatures use Cosign keyless OIDC; the signing identity is the
+release workflow running on a signed tag.
+
+**1. Verify SHA-256 checksums:**
+
+```bash
+sha256sum -c checksums.txt
+```
+
+**2. Verify the Cosign signature on `checksums.txt`:**
+
+```bash
+cosign verify-blob \
+  --bundle checksums.txt.sigstore.json \
+  --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/\.github/workflows/release\.yml@refs/tags/' \
+  --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
+  checksums.txt
+```
+
+Every individual binary ships with its own `.sigstore.json` bundle
+(unified Sigstore bundle containing signature, certificate chain, and
+Rekor inclusion proof). Swap `checksums.txt` for any binary name and
+point `--bundle` at the matching `<binary>.sigstore.json` to verify it
+directly.
+
+**3. Verify SLSA Level 3 provenance on a binary:**
+
+```bash
+slsa-verifier verify-artifact \
+  --provenance-path multiple.intoto.jsonl \
+  --source-uri github.com/shankar0123/certctl \
+  --source-tag v2.1.0 \
+  certctl-agent-linux-amd64
+```
+
+**4. Verify a container image signature and its SBOM / provenance attestations:**
+
+```bash
+IMAGE=ghcr.io/shankar0123/certctl-server:v2.1.0
+
+cosign verify \
+  --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/\.github/workflows/release\.yml@refs/tags/' \
+  --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
+  "$IMAGE"
+
+# SBOM attestation (SPDX-JSON, emitted by docker/build-push-action)
+cosign verify-attestation --type spdxjson \
+  --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/' \
+  --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
+  "$IMAGE"
+
+# SLSA provenance attestation (docker/build-push-action `provenance: mode=max`)
+cosign verify-attestation --type slsaprovenance \
+  --certificate-identity-regexp '^https://github\.com/shankar0123/certctl/' \
+  --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
+  "$IMAGE"
 ```
 
 ## Examples
 
-Pick the scenario closest to your setup and have it running in 2 minutes:
+Pick the scenario closest to your setup and have it running in 2 minutes.
 
 | Example | Scenario |
 |---------|----------|
@@ -137,9 +321,58 @@ Pick the scenario closest to your setup and have it running in 2 minutes:
 
 Each directory contains a `docker-compose.yml` and a `README.md` explaining the scenario, prerequisites, and customization.
 
-## Verifying a release
+## CLI
 
-Every `v*` tag publishes signed, attested artefacts (Cosign keyless OIDC + SLSA Level 3 provenance + SPDX-JSON SBOMs). For the verification procedure, see [`docs/reference/release-verification.md`](docs/reference/release-verification.md).
+```bash
+# Install
+go install github.com/shankar0123/certctl/cmd/cli@latest
+
+# Configure
+export CERTCTL_SERVER_URL=https://localhost:8443
+export CERTCTL_API_KEY=your-api-key
+export CERTCTL_SERVER_CA_BUNDLE_PATH=/path/to/ca.crt   # or --ca-bundle on the CLI; --insecure for dev self-signed
+
+# Usage
+certctl-cli certs list                    # List all certificates
+certctl-cli certs renew mc-api-prod       # Trigger renewal
+certctl-cli certs revoke mc-api-prod --reason keyCompromise
+certctl-cli agents list                   # List registered agents
+certctl-cli jobs list                     # List jobs
+certctl-cli status                        # Server health + summary stats
+certctl-cli import certs.pem              # Bulk import from PEM file
+certctl-cli certs list --format json      # JSON output (default: table)
+```
+
+## MCP Server (AI Integration)
+
+certctl ships a standalone MCP (Model Context Protocol) server that exposes all 80 API endpoints as tools for AI assistants — Claude, Cursor, Windsurf, OpenClaw, VS Code Copilot, and any MCP-compatible client.
+
+```bash
+# Install and run
+go install github.com/shankar0123/certctl/cmd/mcp-server@latest
+export CERTCTL_SERVER_URL=https://localhost:8443
+export CERTCTL_API_KEY=your-api-key
+export CERTCTL_SERVER_CA_BUNDLE_PATH=/path/to/ca.crt   # required for self-signed bootstrap
+mcp-server
+```
+
+The MCP server is env-vars-only — there are no CLI flags for TLS. If you must bypass verification for local development against a self-signed cert, set `CERTCTL_SERVER_TLS_INSECURE_SKIP_VERIFY=true`. Never set that in production.
+
+**Claude Desktop** (`claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "certctl": {
+      "command": "mcp-server",
+      "env": {
+        "CERTCTL_SERVER_URL": "https://localhost:8443",
+        "CERTCTL_API_KEY": "your-api-key",
+        "CERTCTL_SERVER_CA_BUNDLE_PATH": "/path/to/ca.crt"
+      }
+    }
+  }
+}
+```
 
 ## Development
 
@@ -151,26 +384,28 @@ govulncheck ./...       # Vulnerability scan
 make docker-up          # Start Docker Compose stack
 ```
 
-CI runs `go vet`, `go test -race`, `golangci-lint`, `govulncheck`, and per-layer coverage thresholds (service 55%, handler 60%, domain 40%, middleware 30%) on every push. Frontend CI runs TypeScript type checking, Vitest tests, and Vite production build.
+CI runs on every push: `go vet`, `go test -race`, `golangci-lint`, `govulncheck`, and per-layer coverage thresholds (service 55%, handler 60%, domain 40%, middleware 30%). Frontend CI runs TypeScript type checking, Vitest tests, and Vite production build. 1,668 Go test functions with 625+ subtests, plus frontend test suite.
 
-For the full contributor guide see [`docs/contributor/`](docs/contributor/) — testing strategy, test environment, CI pipeline, QA prerequisites.
+## Roadmap
+
+### V1 (v1.0.0) — Shipped
+Core lifecycle management — Local CA + ACME v2 issuers, NGINX target connector, agent-side key generation, API auth + rate limiting, React dashboard, CI pipeline with coverage gates, Docker images on GHCR.
+
+### V2: Operational Maturity — Shipped
+30+ milestones shipping enterprise-grade features for free. Sub-CA mode, ACME DNS-01/DNS-PERSIST-01/EAB/ARI (RFC 9773)/profile selection, step-ca, Vault PKI, DigiCert CertCentral, Sectigo SCM, Google CAS, AWS ACM PCA, Entrust, GlobalSign, EJBCA, OpenSSL/Custom CA issuers. NGINX, Apache, HAProxy, Traefik, Caddy, Envoy, Postfix, Dovecot, IIS (WinRM), F5 BIG-IP, SSH, Windows Certificate Store, Java Keystore, Kubernetes Secrets targets. EST server (RFC 7030) and SCEP server (RFC 8894) enrollment protocols. RFC 5280 revocation with DER CRL + embedded OCSP responder. Certificate profiles, ownership tracking, team assignment, agent groups, interactive approval workflows. Filesystem, network, and cloud secret manager (AWS SM, Azure KV, GCP SM) certificate discovery with triage GUI. Dynamic issuer/target configuration via GUI with AES-256-GCM encrypted storage. First-run onboarding wizard. Post-deployment TLS verification. Certificate export (PEM/PKCS#12). S/MIME support. Prometheus metrics. Scheduled certificate digest emails. Slack, Teams, PagerDuty, OpsGenie, SMTP notifications. MCP server (80 tools), CLI (12 commands), Helm chart. Compliance mapping (SOC 2, PCI-DSS 4.0, NIST SP 800-57). 5 turnkey deployment examples. Agent install script. Migration guides from certbot, acme.sh, and cert-manager. See the [Feature Inventory](docs/features.md) for details.
+
+### V3: certctl Pro
+Enterprise capabilities for larger deployments are available in the commercial tier.
+
+### V4+: Cloud & Scale
+Kubernetes cert-manager external issuer, cloud infrastructure targets, extended CA support, and platform-scale features.
 
 ## License
 
-Licensed under the [Business Source License 1.1](LICENSE). The source code is publicly available and free to use, modify, and self-host. The one restriction: you may not use certctl's certificate management functionality as part of a commercial certificate-management offering to third parties. See the LICENSE file for the full Additional Use Grant.
+Certctl is licensed under the [Business Source License 1.1](LICENSE). The source code is publicly available and free to use, modify, and self-host. The one restriction: you may not use certctl's certificate management functionality as part of a commercial offering to third parties, whether hosted, managed, embedded, bundled, or integrated. The BSL 1.1 license converts automatically to Apache 2.0 on March 14, 2033.
 
 For licensing inquiries: certctl@proton.me
 
-## Dependencies
-
-```bash
-go list -m all | wc -l   # total module count (direct + transitive)
-go mod why <path>        # explain why a module is pulled in
-govulncheck ./...        # vulnerability scan (CI runs this on every commit)
-```
-
-The release-time SBOM is published as an SPDX-JSON file alongside each release artifact.
-
 ---
 
-If certctl solves a problem you have, [star the repo](https://github.com/certctl-io/certctl) to help others find it. Questions, bugs, or feature requests: [open an issue](https://github.com/certctl-io/certctl/issues).
+If certctl solves a problem you have, [star the repo](https://github.com/shankar0123/certctl) to help others find it. Questions, bugs, or feature requests — [open an issue](https://github.com/shankar0123/certctl/issues).

api/openapi-handler-exceptions.yaml

@@ -1,94 +0,0 @@
-# Routes registered in internal/api/router/router.go that are intentionally
-# NOT in api/openapi.yaml. Each entry needs a one-line `why:` justification.
-# Adding a new entry requires PR-time review.
-#
-# OpenAPI-shaped REST endpoints belong in api/openapi.yaml, NOT here.
-# This list is for protocol-shaped (SCEP wire endpoints) and operational
-# (health, metrics, pprof) routes only.
-#
-# Per ci-pipeline-cleanup bundle Phase 9 / frozen decision 0.11.
-
-documented_exceptions:
-  - route: "GET /scep"
-    why: "SCEP wire-protocol endpoint per RFC 8894 §3.1; serves CA certs via GetCACert/GetCACaps query params, NOT a REST resource."
-  - route: "POST /scep"
-    why: "SCEP wire-protocol endpoint per RFC 8894 §3.1; receives PKCSReq / RenewalReq PKIMessages, NOT a REST resource."
-  - route: "GET /scep/"
-    why: "SCEP wire-protocol endpoint with trailing-slash variant; ChromeOS clients send the trailing-slash form."
-  - route: "POST /scep/"
-    why: "SCEP wire-protocol endpoint with trailing-slash variant; ChromeOS clients send the trailing-slash form."
-  - route: "GET /scep-mtls"
-    why: "SCEP-mTLS sibling endpoint per ci-pipeline-cleanup-prerequisite EST RFC 7030 hardening Phase 6.5; same wire-protocol semantics, mutually-authenticated TLS variant."
-  - route: "POST /scep-mtls"
-    why: "SCEP-mTLS sibling endpoint, POST variant."
-  - route: "GET /scep-mtls/"
-    why: "SCEP-mTLS sibling endpoint, trailing-slash variant."
-  - route: "POST /scep-mtls/"
-    why: "SCEP-mTLS sibling endpoint, trailing-slash POST variant."
-
-  # ACME server (RFC 8555 + RFC 9773 ARI) — wire-protocol surface.
-  # Like SCEP/EST, ACME is a JWS-signed-JSON wire protocol whose
-  # semantics are dictated by the RFC, not by an OpenAPI schema.
-  # Documenting every endpoint in openapi.yaml would duplicate
-  # RFC 8555 §7.1 + §7.2 + §7.3 with no information gain. The
-  # canonical operator-facing reference is docs/acme-server.md.
-  # Phases 2-4 will extend this list as new-order, finalize, authz,
-  # challenge, cert, key-change, revoke-cert, renewal-info routes land.
-  - route: "GET /acme/profile/{id}/directory"
-    why: "ACME server RFC 8555 §7.1.1 directory; documented in docs/acme-server.md."
-  - route: "HEAD /acme/profile/{id}/new-nonce"
-    why: "ACME server RFC 8555 §7.2 new-nonce; documented in docs/acme-server.md."
-  - route: "GET /acme/profile/{id}/new-nonce"
-    why: "ACME server RFC 8555 §7.2 new-nonce GET form; documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/new-account"
-    why: "ACME server RFC 8555 §7.3 new-account (JWS jwk); documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/account/{acc_id}"
-    why: "ACME server RFC 8555 §7.3.2 + §7.3.6 (JWS kid) account update + deactivation; documented in docs/acme-server.md."
-  - route: "GET /acme/directory"
-    why: "ACME server default-profile shorthand; mirrors per-profile when CERTCTL_ACME_SERVER_DEFAULT_PROFILE_ID is set."
-  - route: "HEAD /acme/new-nonce"
-    why: "ACME server default-profile shorthand for new-nonce HEAD."
-  - route: "GET /acme/new-nonce"
-    why: "ACME server default-profile shorthand for new-nonce GET."
-  - route: "POST /acme/new-account"
-    why: "ACME server default-profile shorthand for new-account."
-  - route: "POST /acme/account/{acc_id}"
-    why: "ACME server default-profile shorthand for account update + deactivation."
-
-  # Phase 2 — orders + finalize + authz + cert.
-  - route: "POST /acme/profile/{id}/new-order"
-    why: "ACME server RFC 8555 §7.4 new-order; documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/order/{ord_id}"
-    why: "ACME server RFC 8555 §7.4 order POST-as-GET; documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/order/{ord_id}/finalize"
-    why: "ACME server RFC 8555 §7.4 finalize; documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/authz/{authz_id}"
-    why: "ACME server RFC 8555 §7.5 authz POST-as-GET; documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/challenge/{chall_id}"
-    why: "ACME server RFC 8555 §7.5.1 challenge response; dispatches to Phase 3 validator pool."
-  - route: "POST /acme/profile/{id}/cert/{cert_id}"
-    why: "ACME server RFC 8555 §7.4.2 cert download; documented in docs/acme-server.md."
-  - route: "POST /acme/new-order"
-    why: "Phase 2 default-profile shorthand for new-order."
-  - route: "POST /acme/order/{ord_id}"
-    why: "Phase 2 default-profile shorthand for order POST-as-GET."
-  - route: "POST /acme/order/{ord_id}/finalize"
-    why: "Phase 2 default-profile shorthand for finalize."
-  - route: "POST /acme/authz/{authz_id}"
-    why: "Phase 2 default-profile shorthand for authz POST-as-GET."
-  - route: "POST /acme/challenge/{chall_id}"
-    why: "Phase 3 default-profile shorthand for challenge response."
-  - route: "POST /acme/cert/{cert_id}"
-    why: "Phase 2 default-profile shorthand for cert download."
-  - route: "POST /acme/profile/{id}/key-change"
-    why: "ACME server RFC 8555 §7.3.5 doubly-signed key rollover; documented in docs/acme-server.md."
-  - route: "POST /acme/profile/{id}/revoke-cert"
-    why: "ACME server RFC 8555 §7.6 revoke-cert (kid OR cert-key auth); documented in docs/acme-server.md."
-  - route: "GET /acme/profile/{id}/renewal-info/{cert_id}"
-    why: "ACME server RFC 9773 ACME Renewal Information (unauthenticated GET); documented in docs/acme-server.md."
-  - route: "POST /acme/key-change"
-    why: "Phase 4 default-profile shorthand for key rollover."
-  - route: "POST /acme/revoke-cert"
-    why: "Phase 4 default-profile shorthand for revoke-cert."
-  - route: "GET /acme/renewal-info/{cert_id}"
-    why: "Phase 4 default-profile shorthand for ARI."

cmd/agent/agent_test.go

@@ -478,7 +478,7 @@ func TestCreateTargetConnector_NGINX(t *testing.T) {
 	agent, _ := NewAgent(cfg, logger)
 
 	configJSON := json.RawMessage(`{"cert_path":"/etc/nginx/cert.pem"}`)
-	connector, err := agent.createTargetConnector(context.Background(), "NGINX", configJSON)
+	connector, err := agent.createTargetConnector("NGINX", configJSON)
 
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
@@ -499,7 +499,7 @@ func TestCreateTargetConnector_Unsupported(t *testing.T) {
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	agent, _ := NewAgent(cfg, logger)
 
-	_, err := agent.createTargetConnector(context.Background(), "UnsupportedType", nil)
+	_, err := agent.createTargetConnector("UnsupportedType", nil)
 
 	if err == nil {
 		t.Error("expected error for unsupported target type")
@@ -692,10 +692,10 @@ func TestMakeRequest_InvalidURL(t *testing.T) {
 // TestCertKeyInfo tests extraction of key algorithm and size from certificates.
 func TestCertKeyInfo(t *testing.T) {
 	tests := []struct {
-		name        string
-		genKey      func() interface{}
-		expectedAlg string
-		minBitSize  int
+		name         string
+		genKey       func() interface{}
+		expectedAlg  string
+		minBitSize   int
 	}{
 		{
 			name: "ECDSA P-256",
@@ -831,7 +831,7 @@ func strPtr(s string) *string {
 	return &s
 }
 
-// TestCreateTargetConnector_AllSupportedTypes tests connector creation for all 16 supported target types.
+// TestCreateTargetConnector_AllSupportedTypes tests connector creation for all 14 supported target types.
 func TestCreateTargetConnector_AllSupportedTypes(t *testing.T) {
 	tmpDir := t.TempDir()
 
@@ -946,29 +946,6 @@ func TestCreateTargetConnector_AllSupportedTypes(t *testing.T) {
 				"secret_name": "tls-secret",
 			},
 		},
-		{
-			// Rank 5 of the 2026-05-03 Infisical deep-research deliverable.
-			// Region must be a valid AWS region; the connector lazy-loads
-			// the SDK client during ValidateConfig but New() with a populated
-			// region should succeed against the SDK credential chain
-			// (LoadDefaultConfig doesn't require live creds).
-			name:     "AWSACM",
-			typeName: "AWSACM",
-			config: map[string]string{
-				"region": "us-east-1",
-			},
-		},
-		{
-			// Rank 5 (Azure half). Vault URL + cert name; the SDK client
-			// lazy-loads via DefaultAzureCredential which doesn't require
-			// live creds at construction time.
-			name:     "AzureKeyVault",
-			typeName: "AzureKeyVault",
-			config: map[string]string{
-				"vault_url":        "https://test-vault.vault.azure.net",
-				"certificate_name": "demo-cert",
-			},
-		},
 	}
 
 	cfg := &AgentConfig{
@@ -987,7 +964,7 @@ func TestCreateTargetConnector_AllSupportedTypes(t *testing.T) {
 				t.Fatalf("failed to marshal config: %v", err)
 			}
 
-			connector, err := agent.createTargetConnector(context.Background(), tt.typeName, configJSON)
+			connector, err := agent.createTargetConnector(tt.typeName, configJSON)
 
 			// Some connectors (like WinCertStore, IIS) may error on non-Windows platforms
 			// or with insufficient validation. We accept either a valid connector or an error
@@ -1022,8 +999,6 @@ func TestCreateTargetConnector_InvalidJSON(t *testing.T) {
 		"WinCertStore",
 		"JavaKeystore",
 		"KubernetesSecrets",
-		"AWSACM",
-		"AzureKeyVault",
 	}
 
 	cfg := &AgentConfig{
@@ -1039,7 +1014,7 @@ func TestCreateTargetConnector_InvalidJSON(t *testing.T) {
 
 	for _, typeName := range tests {
 		t.Run(typeName, func(t *testing.T) {
-			_, err := agent.createTargetConnector(context.Background(), typeName, invalidJSON)
+			_, err := agent.createTargetConnector(typeName, invalidJSON)
 
 			if err == nil {
 				t.Errorf("expected error for invalid JSON with type %s", typeName)
@@ -1059,7 +1034,7 @@ func TestCreateTargetConnector_UnknownType(t *testing.T) {
 	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
 	agent, _ := NewAgent(cfg, logger)
 
-	_, err := agent.createTargetConnector(context.Background(), "MagicBox", nil)
+	_, err := agent.createTargetConnector("MagicBox", nil)
 
 	if err == nil {
 		t.Error("expected error for unsupported target type")
@@ -1092,7 +1067,7 @@ func TestCreateTargetConnector_EmptyConfig(t *testing.T) {
 	for _, typeName := range tests {
 		t.Run(typeName, func(t *testing.T) {
 			// Empty config should be handled gracefully (defaults applied)
-			connector, err := agent.createTargetConnector(context.Background(), typeName, nil)
+			connector, err := agent.createTargetConnector(typeName, nil)
 
 			// Should not error on nil/empty config (defaults are applied)
 			if err != nil {
@@ -1528,9 +1503,9 @@ func TestValidateHTTPSScheme(t *testing.T) {
 			wantErrSub: "plaintext http://",
 		},
 		{
-			name:      "bare host missing scheme falls through to unsupported",
-			serverURL: "localhost:8443",
-			wantErr:   true,
+			name:       "bare host missing scheme falls through to unsupported",
+			serverURL:  "localhost:8443",
+			wantErr:    true,
 			// url.Parse treats "localhost:8443" as scheme=localhost,
 			// opaque=8443 — exercises the default arm (unsupported scheme)
 			// rather than the empty-scheme arm. Both are fail-closed, which

cmd/agent/deploy_mutex_test.go

@@ -1,143 +0,0 @@
-package main
-
-import (
-	"sync"
-	"sync/atomic"
-	"testing"
-)
-
-// Phase 2 of the deploy-hardening I master bundle: per-target
-// deploy mutex serializes concurrent deploys to the same target
-// at the agent dispatch layer.
-
-// TestAgent_ConcurrentDeploysToSameTarget_Serialize spawns N
-// goroutines acquiring the same target's mutex and asserts that
-// only one is in the critical section at a time. The "critical
-// section" is simulated as an atomic-counter increment + sleep +
-// decrement; if the lock works, max-in-flight is 1.
-func TestAgent_ConcurrentDeploysToSameTarget_Serialize(t *testing.T) {
-	a := &Agent{}
-
-	const N = 10
-	var inFlight, maxInFlight int32
-	var done int32
-	var wg sync.WaitGroup
-
-	for i := 0; i < N; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			mu := a.targetDeployMutex("target-A")
-			if mu == nil {
-				t.Errorf("expected non-nil mutex for non-empty target id")
-				return
-			}
-			mu.Lock()
-			defer mu.Unlock()
-			n := atomic.AddInt32(&inFlight, 1)
-			for {
-				m := atomic.LoadInt32(&maxInFlight)
-				if n <= m || atomic.CompareAndSwapInt32(&maxInFlight, m, n) {
-					break
-				}
-			}
-			// Brief work simulating the connector's Deploy.
-			for j := 0; j < 1000; j++ {
-				_ = j * j
-			}
-			atomic.AddInt32(&inFlight, -1)
-			atomic.AddInt32(&done, 1)
-		}()
-	}
-	wg.Wait()
-
-	if done != N {
-		t.Errorf("done = %d, want %d (some goroutines didn't run)", done, N)
-	}
-	if maxInFlight > 1 {
-		t.Errorf("max concurrent critical sections = %d, want 1 (mutex broken)", maxInFlight)
-	}
-}
-
-// TestAgent_DifferentTargetIDs_ParallelizeIndependently verifies
-// the per-target granularity: deploys to target-A and target-B
-// proceed in parallel (no global serialization point).
-func TestAgent_DifferentTargetIDs_ParallelizeIndependently(t *testing.T) {
-	a := &Agent{}
-
-	muA := a.targetDeployMutex("target-A")
-	muB := a.targetDeployMutex("target-B")
-
-	if muA == nil || muB == nil {
-		t.Fatal("nil mutexes")
-	}
-	if muA == muB {
-		t.Error("target-A and target-B share the same mutex (broken granularity)")
-	}
-
-	// Acquire A; B should still be acquirable concurrently.
-	muA.Lock()
-	defer muA.Unlock()
-
-	acquired := make(chan struct{})
-	go func() {
-		muB.Lock()
-		close(acquired)
-		muB.Unlock()
-	}()
-	<-acquired // would deadlock if B were blocked by A
-}
-
-// TestAgent_EmptyTargetID_ReturnsNilMutex pins the
-// "no-targetID = no-lock" contract. Defends against the
-// pathological case where every targetless deploy serializes on a
-// shared empty-string mutex.
-func TestAgent_EmptyTargetID_ReturnsNilMutex(t *testing.T) {
-	a := &Agent{}
-	if mu := a.targetDeployMutex(""); mu != nil {
-		t.Errorf("empty targetID returned non-nil mutex: %p", mu)
-	}
-}
-
-// TestAgent_TargetMutex_IsStable verifies sync.Map LoadOrStore
-// semantics: same target ID returns the same *sync.Mutex pointer
-// across calls (so the lock actually works across goroutines that
-// look up the mutex independently).
-func TestAgent_TargetMutex_IsStable(t *testing.T) {
-	a := &Agent{}
-	mu1 := a.targetDeployMutex("target-X")
-	mu2 := a.targetDeployMutex("target-X")
-	if mu1 != mu2 {
-		t.Errorf("targetMutex returned %p then %p for same id (stability broken)", mu1, mu2)
-	}
-}
-
-// TestAgent_TargetMutex_RaceLookup pins the race-detector
-// invariant: many goroutines calling targetDeployMutex
-// concurrently for the same key all get the same pointer (no
-// torn read).
-func TestAgent_TargetMutex_RaceLookup(t *testing.T) {
-	a := &Agent{}
-	const N = 50
-	results := make(chan *sync.Mutex, N)
-	var wg sync.WaitGroup
-	for i := 0; i < N; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			results <- a.targetDeployMutex("target-shared")
-		}()
-	}
-	wg.Wait()
-	close(results)
-	var first *sync.Mutex
-	for got := range results {
-		if first == nil {
-			first = got
-			continue
-		}
-		if got != first {
-			t.Errorf("goroutine got different mutex (%p vs %p)", got, first)
-		}
-	}
-}

cmd/agent/dispatch_test.go

@@ -1,638 +0,0 @@
-package main
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/json"
-	"encoding/pem"
-	"io"
-	"log/slog"
-	"math/big"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-// Bundle 0.7-extended: cmd/agent dispatch coverage for executeCSRJob,
-// executeDeploymentJob, verifyAndReportDeployment, markRetired, getEnvDefault,
-// getEnvBoolDefault — the previously-uncovered code paths flagged by the
-// audit's per-function coverage report.
-//
-// Strategy: same httptest-backed pattern as the existing agent_test.go
-// (Heartbeat / PollWork tests). Each test:
-//   - constructs a mock control-plane HTTP server (httptest.NewServer)
-//   - configures an Agent pointing at that server via NewAgent
-//   - invokes the function under test
-//   - asserts on the requests the mock server received
-
-// ─────────────────────────────────────────────────────────────────────────────
-// executeCSRJob
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestAgent_ExecuteCSRJob_HappyPath(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	var csrSubmitted atomic.Bool
-	var statusUpdates atomic.Int32
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasSuffix(r.URL.Path, "/csr") && r.Method == http.MethodPost:
-			csrSubmitted.Store(true)
-			var body map[string]string
-			_ = json.NewDecoder(r.Body).Decode(&body)
-			if body["csr_pem"] == "" || !strings.Contains(body["csr_pem"], "CERTIFICATE REQUEST") {
-				t.Errorf("CSR submission missing PEM body: %v", body)
-			}
-			if body["certificate_id"] != "mc-test-cert" {
-				t.Errorf("CSR submission missing certificate_id: %v", body)
-			}
-			w.WriteHeader(http.StatusAccepted)
-		case strings.HasSuffix(r.URL.Path, "/status") && r.Method == http.MethodPost:
-			statusUpdates.Add(1)
-			w.WriteHeader(http.StatusOK)
-		default:
-			t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-		KeyDir:    keyDir,
-	}
-	agent, err := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-	if err != nil {
-		t.Fatalf("NewAgent: %v", err)
-	}
-
-	job := JobItem{
-		ID:            "j-csr-1",
-		CertificateID: "mc-test-cert",
-		Type:          "csr",
-		CommonName:    "test.example.com",
-		SANs:          []string{"test.example.com", "alt.example.com", "alice@example.com"},
-	}
-
-	agent.executeCSRJob(context.Background(), job)
-
-	if !csrSubmitted.Load() {
-		t.Errorf("expected CSR to be submitted to control plane")
-	}
-
-	// Key file should exist with mode 0600
-	keyPath := filepath.Join(keyDir, "mc-test-cert.key")
-	info, err := os.Stat(keyPath)
-	if err != nil {
-		t.Fatalf("expected key file at %s: %v", keyPath, err)
-	}
-	if info.Mode().Perm() != 0600 {
-		t.Errorf("expected key file mode 0600, got %v", info.Mode().Perm())
-	}
-
-	// Read back and verify it parses as an ECDSA key
-	keyPEM, err := os.ReadFile(keyPath)
-	if err != nil {
-		t.Fatalf("read key file: %v", err)
-	}
-	block, _ := pem.Decode(keyPEM)
-	if block == nil || block.Type != "EC PRIVATE KEY" {
-		t.Errorf("expected EC PRIVATE KEY PEM, got %v", block)
-	}
-}
-
-func TestAgent_ExecuteCSRJob_EmptyCommonName_ReportsFailed(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	var lastStatus atomic.Value
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasSuffix(r.URL.Path, "/status") && r.Method == http.MethodPost {
-			var body map[string]string
-			_ = json.NewDecoder(r.Body).Decode(&body)
-			lastStatus.Store(body["status"])
-		}
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-		KeyDir:    keyDir,
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	job := JobItem{
-		ID:            "j-csr-empty-cn",
-		CertificateID: "mc-empty-cn",
-		Type:          "csr",
-		CommonName:    "", // empty CN — should be rejected
-	}
-
-	agent.executeCSRJob(context.Background(), job)
-
-	if got := lastStatus.Load(); got != "Failed" {
-		t.Errorf("expected last status 'Failed', got %v", got)
-	}
-}
-
-func TestAgent_ExecuteCSRJob_CSRSubmissionRejected_ReportsFailed(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	var lastStatus atomic.Value
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasSuffix(r.URL.Path, "/csr") && r.Method == http.MethodPost:
-			// Server rejects the CSR with 400 Bad Request
-			w.WriteHeader(http.StatusBadRequest)
-			_, _ = w.Write([]byte(`{"error":"CSR validation failed"}`))
-		case strings.HasSuffix(r.URL.Path, "/status") && r.Method == http.MethodPost:
-			var body map[string]string
-			_ = json.NewDecoder(r.Body).Decode(&body)
-			lastStatus.Store(body["status"])
-			w.WriteHeader(http.StatusOK)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-		KeyDir:    keyDir,
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	job := JobItem{
-		ID:            "j-csr-rejected",
-		CertificateID: "mc-rejected",
-		Type:          "csr",
-		CommonName:    "rejected.example.com",
-	}
-
-	agent.executeCSRJob(context.Background(), job)
-
-	if got := lastStatus.Load(); got != "Failed" {
-		t.Errorf("expected last status 'Failed' after CSR rejection, got %v", got)
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// executeDeploymentJob
-// ─────────────────────────────────────────────────────────────────────────────
-
-// generateTestCertAndKey builds an ephemeral self-signed cert + ECDSA P-256 key
-// for use as test fixture data in deployment tests.
-func generateTestCertAndKey(t *testing.T, cn string) (certPEM, keyPEM string) {
-	t.Helper()
-	priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		t.Fatalf("GenerateKey: %v", err)
-	}
-	template := &x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject:      pkix.Name{CommonName: cn},
-		NotBefore:    time.Now().Add(-1 * time.Hour),
-		NotAfter:     time.Now().Add(24 * time.Hour),
-		KeyUsage:     x509.KeyUsageDigitalSignature,
-	}
-	certDER, err := x509.CreateCertificate(rand.Reader, template, template, &priv.PublicKey, priv)
-	if err != nil {
-		t.Fatalf("CreateCertificate: %v", err)
-	}
-	certPEM = string(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER}))
-	keyDER, err := x509.MarshalECPrivateKey(priv)
-	if err != nil {
-		t.Fatalf("MarshalECPrivateKey: %v", err)
-	}
-	keyPEM = string(pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER}))
-	return certPEM, keyPEM
-}
-
-func TestAgent_ExecuteDeploymentJob_FetchFails_ReportsFailed(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	var lastStatus atomic.Value
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.Contains(r.URL.Path, "/certificates/") && r.Method == http.MethodGet:
-			// Fail the certificate fetch
-			w.WriteHeader(http.StatusInternalServerError)
-		case strings.HasSuffix(r.URL.Path, "/status") && r.Method == http.MethodPost:
-			var body map[string]string
-			_ = json.NewDecoder(r.Body).Decode(&body)
-			lastStatus.Store(body["status"])
-			w.WriteHeader(http.StatusOK)
-		default:
-			w.WriteHeader(http.StatusOK)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-		KeyDir:    keyDir,
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	job := JobItem{
-		ID:            "j-deploy-fetch-fail",
-		CertificateID: "mc-fetch-fail",
-		Type:          "deployment",
-		TargetType:    "nginx",
-	}
-
-	agent.executeDeploymentJob(context.Background(), job)
-
-	if got := lastStatus.Load(); got != "Failed" {
-		t.Errorf("expected status 'Failed' after fetch failure, got %v", got)
-	}
-}
-
-func TestAgent_ExecuteDeploymentJob_KeyMissing_ReportsFailed(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	certPEM, _ := generateTestCertAndKey(t, "deploy-test.example.com")
-	// Note: key file is intentionally NOT written to keyDir — exercises the
-	// "local private key missing" failure path in executeDeploymentJob.
-
-	var lastStatus atomic.Value
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.Contains(r.URL.Path, "/certificates/") && r.Method == http.MethodGet:
-			w.Header().Set("Content-Type", "application/json")
-			_ = json.NewEncoder(w).Encode(map[string]string{
-				"id":          "mc-no-key",
-				"common_name": "deploy-test.example.com",
-				"pem_content": certPEM,
-			})
-		case strings.HasSuffix(r.URL.Path, "/status") && r.Method == http.MethodPost:
-			var body map[string]string
-			_ = json.NewDecoder(r.Body).Decode(&body)
-			lastStatus.Store(body["status"])
-			w.WriteHeader(http.StatusOK)
-		default:
-			w.WriteHeader(http.StatusOK)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-		KeyDir:    keyDir,
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	job := JobItem{
-		ID:            "j-deploy-no-key",
-		CertificateID: "mc-no-key",
-		Type:          "deployment",
-		TargetType:    "nginx",
-	}
-
-	agent.executeDeploymentJob(context.Background(), job)
-
-	if got := lastStatus.Load(); got != "Failed" {
-		t.Errorf("expected status 'Failed' after key-missing, got %v", got)
-	}
-}
-
-func TestAgent_ExecuteDeploymentJob_UnknownTargetType_ReportsFailed(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	certPEM, keyPEM := generateTestCertAndKey(t, "deploy-test.example.com")
-	keyPath := filepath.Join(keyDir, "mc-unknown-tgt.key")
-	if err := os.WriteFile(keyPath, []byte(keyPEM), 0600); err != nil {
-		t.Fatalf("WriteFile key: %v", err)
-	}
-
-	var lastStatus atomic.Value
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.Contains(r.URL.Path, "/certificates/") && r.Method == http.MethodGet:
-			w.Header().Set("Content-Type", "application/json")
-			_ = json.NewEncoder(w).Encode(map[string]string{
-				"id":          "mc-unknown-tgt",
-				"common_name": "deploy-test.example.com",
-				"pem_content": certPEM,
-			})
-		case strings.HasSuffix(r.URL.Path, "/status") && r.Method == http.MethodPost:
-			var body map[string]string
-			_ = json.NewDecoder(r.Body).Decode(&body)
-			lastStatus.Store(body["status"])
-			w.WriteHeader(http.StatusOK)
-		default:
-			w.WriteHeader(http.StatusOK)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-		KeyDir:    keyDir,
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	job := JobItem{
-		ID:            "j-unknown-target",
-		CertificateID: "mc-unknown-tgt",
-		Type:          "deployment",
-		TargetType:    "frobnicator-9000", // unknown connector type
-	}
-
-	agent.executeDeploymentJob(context.Background(), job)
-
-	if got := lastStatus.Load(); got != "Failed" {
-		t.Errorf("expected status 'Failed' after unknown target type, got %v", got)
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// markRetired — single-shot retirement signal
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestAgent_MarkRetired_ClosesSignalOnce(t *testing.T) {
-	cfg := &AgentConfig{
-		ServerURL: "http://example.invalid",
-		APIKey:    "k",
-		AgentID:   "a-retired-test",
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	// First mark — channel should close
-	agent.markRetired("test-source-1", 410, "agent retired")
-	select {
-	case <-agent.retiredSignal:
-		// expected — closed channel reads return zero immediately
-	case <-time.After(100 * time.Millisecond):
-		t.Fatalf("expected retiredSignal to be closed after markRetired")
-	}
-
-	// Second mark — must not panic (sync.Once guards the close)
-	defer func() {
-		if r := recover(); r != nil {
-			t.Errorf("second markRetired panicked: %v", r)
-		}
-	}()
-	agent.markRetired("test-source-2", 410, "agent retired again")
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// getEnvDefault / getEnvBoolDefault
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestGetEnvDefault_FallsBackToDefault(t *testing.T) {
-	t.Setenv("TESTONLY_AGENT_NONEXISTENT_VAR", "")
-	got := getEnvDefault("TESTONLY_AGENT_NONEXISTENT_VAR", "fallback")
-	if got != "fallback" {
-		t.Errorf("expected fallback, got %q", got)
-	}
-}
-
-func TestGetEnvDefault_UsesEnvWhenSet(t *testing.T) {
-	t.Setenv("TESTONLY_AGENT_VAR", "from-env")
-	got := getEnvDefault("TESTONLY_AGENT_VAR", "fallback")
-	if got != "from-env" {
-		t.Errorf("expected from-env, got %q", got)
-	}
-}
-
-func TestGetEnvBoolDefault_TruthyValues(t *testing.T) {
-	for _, v := range []string{"1", "t", "true", "yes", "on", "TRUE", "True"} {
-		t.Run(v, func(t *testing.T) {
-			t.Setenv("TESTONLY_AGENT_BOOL", v)
-			if !getEnvBoolDefault("TESTONLY_AGENT_BOOL", false) {
-				t.Errorf("expected true for %q", v)
-			}
-		})
-	}
-}
-
-func TestGetEnvBoolDefault_FalsyValues(t *testing.T) {
-	for _, v := range []string{"0", "f", "false", "no", "off"} {
-		t.Run(v, func(t *testing.T) {
-			t.Setenv("TESTONLY_AGENT_BOOL", v)
-			if getEnvBoolDefault("TESTONLY_AGENT_BOOL", true) {
-				t.Errorf("expected false for %q", v)
-			}
-		})
-	}
-}
-
-func TestGetEnvBoolDefault_UnrecognizedReturnsDefault(t *testing.T) {
-	t.Setenv("TESTONLY_AGENT_BOOL", "frobnicate")
-	if !getEnvBoolDefault("TESTONLY_AGENT_BOOL", true) {
-		t.Errorf("expected default(true) for unrecognized value")
-	}
-}
-
-func TestGetEnvBoolDefault_EmptyReturnsDefault(t *testing.T) {
-	t.Setenv("TESTONLY_AGENT_BOOL", "")
-	if !getEnvBoolDefault("TESTONLY_AGENT_BOOL", true) {
-		t.Errorf("expected default(true) for empty value")
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Run() — graceful shutdown via context cancellation
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestAgent_Run_ContextCancelExitsCleanly(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v1/agents/a-run-test/heartbeat":
-			w.WriteHeader(http.StatusOK)
-		case "/api/v1/agents/a-run-test/work":
-			w.Header().Set("Content-Type", "application/json")
-			_ = json.NewEncoder(w).Encode(WorkResponse{Jobs: []JobItem{}, Count: 0})
-		default:
-			w.WriteHeader(http.StatusOK)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-run-test",
-		KeyDir:    keyDir,
-	}
-	agent, err := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-	if err != nil {
-		t.Fatalf("NewAgent: %v", err)
-	}
-	// Speed up tickers so the test exits in <500ms
-	agent.heartbeatInterval = 50 * time.Millisecond
-	agent.pollInterval = 50 * time.Millisecond
-	agent.discoveryInterval = 24 * time.Hour
-
-	ctx, cancel := context.WithCancel(context.Background())
-	errCh := make(chan error, 1)
-	go func() {
-		errCh <- agent.Run(ctx)
-	}()
-
-	// Let one heartbeat + poll fire, then cancel.
-	time.Sleep(100 * time.Millisecond)
-	cancel()
-
-	select {
-	case err := <-errCh:
-		if err != context.Canceled {
-			t.Errorf("expected context.Canceled, got %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatalf("Run did not exit within 2s after cancellation")
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// verifyAndReportDeployment
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestAgent_VerifyAndReportDeployment_ProbeFailure_ReportsError(t *testing.T) {
-	// Server with no TLS listener at the target — probe will fail.
-	var verificationReported atomic.Bool
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if strings.Contains(r.URL.Path, "/verify") || strings.Contains(r.URL.Path, "/verification") {
-			verificationReported.Store(true)
-			w.WriteHeader(http.StatusOK)
-			return
-		}
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	tgtID := "tgt-test"
-	job := JobItem{
-		ID:       "j-verify",
-		TargetID: &tgtID,
-	}
-
-	// Probe a closed port — will fail quickly.
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-	defer cancel()
-
-	// Should not panic; failure surfaces via reportVerificationResult.
-	agent.verifyAndReportDeployment(ctx, job, "127.0.0.1", 1, "")
-	// Test passes if no panic.
-}
-
-func TestAgent_VerifyAndReportDeployment_NilTargetID_LogsAndReturns(t *testing.T) {
-	cfg := &AgentConfig{
-		ServerURL: "http://example.invalid",
-		APIKey:    "test-key",
-		AgentID:   "a-test",
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-
-	job := JobItem{
-		ID:       "j-no-tgt",
-		TargetID: nil, // nil target — should short-circuit cleanly
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
-	defer cancel()
-
-	// Should not panic and should return without making any HTTP call.
-	agent.verifyAndReportDeployment(ctx, job, "127.0.0.1", 1, "")
-}
-
-func TestAgent_Run_RetiredSignalExitsWithErrAgentRetired(t *testing.T) {
-	keyDir := t.TempDir()
-	if err := os.Chmod(keyDir, 0700); err != nil {
-		t.Fatalf("chmod keyDir: %v", err)
-	}
-
-	// Server returns 410 Gone on heartbeat — the documented retirement signal.
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v1/agents/a-retired/heartbeat":
-			w.WriteHeader(http.StatusGone)
-			_, _ = w.Write([]byte(`{"error":"agent retired"}`))
-		case "/api/v1/agents/a-retired/work":
-			w.WriteHeader(http.StatusGone)
-		default:
-			w.WriteHeader(http.StatusGone)
-		}
-	}))
-	defer server.Close()
-
-	cfg := &AgentConfig{
-		ServerURL: server.URL,
-		APIKey:    "test-key",
-		AgentID:   "a-retired",
-		KeyDir:    keyDir,
-	}
-	agent, _ := NewAgent(cfg, slog.New(slog.NewTextHandler(io.Discard, nil)))
-	agent.heartbeatInterval = 30 * time.Millisecond
-	agent.pollInterval = 30 * time.Millisecond
-	agent.discoveryInterval = 24 * time.Hour
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	errCh := make(chan error, 1)
-	go func() {
-		errCh <- agent.Run(ctx)
-	}()
-
-	select {
-	case err := <-errCh:
-		if err != ErrAgentRetired {
-			t.Errorf("expected ErrAgentRetired, got %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatalf("Run did not surface ErrAgentRetired within 2s")
-	}
-}

cmd/agent/keymem.go

@@ -1,73 +0,0 @@
-package main
-
-import (
-	"crypto/ecdsa"
-	"crypto/x509"
-	"fmt"
-	"os"
-	"path/filepath"
-)
-
-// Bundle-9 / Audit L-002 + L-003 (agent edition).
-//
-// The agent generates an ECDSA P-256 key locally and writes it to disk with
-// mode 0600 in a directory it expects to be 0700. The duplication of the
-// local-issuer helpers (instead of importing from internal/...) is deliberate:
-//
-//   - cmd/agent is a separate binary with its own threat model (runs on every
-//     deployment target, not just the control plane). Coupling it to
-//     internal/connector/issuer/local would pull deployment-target footprint
-//     into a connector that's only relevant on the server.
-//   - The behavior is small and self-contained; copy-paste is cheaper than
-//     a refactor that introduces an internal/keystore package.
-//
-// If a third call site emerges, lift these into internal/keystore.
-
-// marshalAgentKeyAndZeroize marshals an ECDSA private key to DER and invokes
-// onDER with the bytes; the buffer is zeroized via builtin clear() after
-// onDER returns. Caller must NOT retain the slice.
-func marshalAgentKeyAndZeroize(priv *ecdsa.PrivateKey, onDER func([]byte) error) error {
-	if priv == nil {
-		return fmt.Errorf("marshalAgentKeyAndZeroize: nil private key")
-	}
-	der, err := x509.MarshalECPrivateKey(priv)
-	if err != nil {
-		return fmt.Errorf("marshal EC private key: %w", err)
-	}
-	defer clear(der)
-	return onDER(der)
-}
-
-// ensureAgentKeyDirSecure creates dir (and ancestors) with mode 0700 or
-// asserts an existing dir is owner-only. If a pre-existing dir is more
-// permissive than 0700 we tighten it to 0700 (logging-free; this is a
-// startup-style invariant, not a per-request check).
-func ensureAgentKeyDirSecure(dir string) error {
-	if dir == "" || dir == "." || dir == "/" {
-		return fmt.Errorf("ensureAgentKeyDirSecure: refuse empty/root dir %q", dir)
-	}
-	clean := filepath.Clean(dir)
-	info, err := os.Stat(clean)
-	switch {
-	case os.IsNotExist(err):
-		if mkErr := os.MkdirAll(clean, 0o700); mkErr != nil {
-			return fmt.Errorf("create agent key dir %q: %w", clean, mkErr)
-		}
-		info, err = os.Stat(clean)
-		if err != nil {
-			return fmt.Errorf("stat newly-created agent key dir %q: %w", clean, err)
-		}
-		fallthrough
-	case err == nil:
-		mode := info.Mode().Perm()
-		if mode == 0o700 || mode&0o077 == 0 {
-			return nil
-		}
-		if chmodErr := os.Chmod(clean, 0o700); chmodErr != nil {
-			return fmt.Errorf("tighten agent key dir %q from %#o to 0700: %w", clean, mode, chmodErr)
-		}
-		return nil
-	default:
-		return fmt.Errorf("stat agent key dir %q: %w", clean, err)
-	}
-}

cmd/agent/keymem_test.go

@@ -1,718 +0,0 @@
-package main
-
-// Bundle 0.7 (Coverage Audit Closure) — cmd/agent key-handling regression coverage.
-//
-// Closes finding C-008 (CRTCTL-COVAUDIT-2026-04-27-0034). The two functions in
-// keymem.go are the agent's defense-in-depth for ECDSA P-256 private-key
-// memory hygiene (Bundle 9 / Audit L-002 + L-003 — agent edition). They
-// shipped with regression-test coverage of 0.0% / 11.1% respectively. This
-// file pins:
-//
-//   - marshalAgentKeyAndZeroize: rejects nil keys, propagates onDER errors,
-//     and ZEROIZES the DER backing buffer after onDER returns regardless of
-//     whether onDER errored.  The zeroization invariant is verified observably
-//     (capture the slice header inside onDER, then assert every byte is 0x00
-//     after the function returns) — NOT just asserted in prose.
-//
-//   - ensureAgentKeyDirSecure: refuses empty / "." / "/", creates missing
-//     dirs with mode 0700 (incl. nested ancestors), accepts existing 0700
-//     and any owner-only-no-write mode (mode&0o077 == 0), tightens any other
-//     mode to 0700, normalizes paths via filepath.Clean, is idempotent, is
-//     safe under concurrent invocation, and propagates the documented error
-//     messages from os.Stat / os.MkdirAll / os.Chmod failures.
-
-import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-)
-
-// ---------------------------------------------------------------------------
-// helpers
-// ---------------------------------------------------------------------------
-
-func mustGenAgentECDSAKey(t *testing.T) *ecdsa.PrivateKey {
-	t.Helper()
-	k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		t.Fatalf("ecdsa.GenerateKey: %v", err)
-	}
-	return k
-}
-
-// ---------------------------------------------------------------------------
-// marshalAgentKeyAndZeroize
-// ---------------------------------------------------------------------------
-
-// TestMarshalAgentKeyAndZeroize_HappyPath confirms onDER receives well-formed
-// DER bytes that the caller can use during the closure (e.g. to PEM-encode).
-func TestMarshalAgentKeyAndZeroize_HappyPath(t *testing.T) {
-	k := mustGenAgentECDSAKey(t)
-	called := false
-	err := marshalAgentKeyAndZeroize(k, func(der []byte) error {
-		called = true
-		if len(der) == 0 {
-			t.Fatalf("der is empty inside onDER")
-		}
-		// First byte of an ECPrivateKey DER blob is the ASN.1 SEQUENCE tag 0x30.
-		if der[0] != 0x30 {
-			t.Errorf("expected DER to start with SEQUENCE tag 0x30, got %#x", der[0])
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("marshalAgentKeyAndZeroize: %v", err)
-	}
-	if !called {
-		t.Fatal("onDER was never invoked")
-	}
-}
-
-// TestMarshalAgentKeyAndZeroize_NilKey confirms the early-return guard;
-// onDER must NOT be invoked when priv is nil.
-func TestMarshalAgentKeyAndZeroize_NilKey(t *testing.T) {
-	called := false
-	err := marshalAgentKeyAndZeroize(nil, func([]byte) error {
-		called = true
-		return nil
-	})
-	if err == nil {
-		t.Fatal("expected error on nil key")
-	}
-	if !strings.Contains(err.Error(), "nil private key") {
-		t.Errorf("expected error mentioning %q, got: %v", "nil private key", err)
-	}
-	if called {
-		t.Error("onDER must not be invoked when priv is nil")
-	}
-}
-
-// TestMarshalAgentKeyAndZeroize_OnDERReturnsError confirms upstream errors
-// are propagated verbatim via errors.Is.
-func TestMarshalAgentKeyAndZeroize_OnDERReturnsError(t *testing.T) {
-	k := mustGenAgentECDSAKey(t)
-	sentinel := errors.New("simulated downstream failure")
-	got := marshalAgentKeyAndZeroize(k, func([]byte) error { return sentinel })
-	if !errors.Is(got, sentinel) {
-		t.Errorf("expected upstream sentinel via errors.Is; got: %v", got)
-	}
-}
-
-// TestMarshalAgentKeyAndZeroize_BackingBufferZeroizedAfterReturn is the
-// CRITICAL invariant test. It captures the slice header (NOT a deep copy)
-// inside onDER and re-inspects after the function returns. Because Go slices
-// share their backing array, the captured slice observes the zeroization
-// performed by `defer clear(der)` in marshalAgentKeyAndZeroize.
-//
-// A future refactor that drops the `defer clear(der)` would break this test
-// even if HappyPath / NilKey / OnDERReturnsError still pass.
-func TestMarshalAgentKeyAndZeroize_BackingBufferZeroizedAfterReturn(t *testing.T) {
-	k := mustGenAgentECDSAKey(t)
-	var captured []byte
-	err := marshalAgentKeyAndZeroize(k, func(der []byte) error {
-		// SHARE the backing array — do NOT take a defensive copy.
-		captured = der
-		if len(der) == 0 {
-			t.Fatal("der is empty inside onDER")
-		}
-		// Sanity check: while still inside onDER, the bytes are live
-		// (defer clear has NOT run yet).
-		nonZero := false
-		for _, b := range der {
-			if b != 0 {
-				nonZero = true
-				break
-			}
-		}
-		if !nonZero {
-			t.Fatal("DER is all-zero INSIDE onDER; that should be impossible (clear hasn't run yet)")
-		}
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("marshalAgentKeyAndZeroize: %v", err)
-	}
-	if len(captured) == 0 {
-		t.Fatal("captured slice is empty post-return")
-	}
-	// After return, defer clear(der) has run. The captured slice shares the
-	// backing array, so every byte must read 0x00.
-	for i, b := range captured {
-		if b != 0 {
-			t.Errorf("captured[%d] = %#x; expected 0x00 (zeroized)", i, b)
-		}
-	}
-}
-
-// TestMarshalAgentKeyAndZeroize_BufferZeroizedEvenOnError confirms the
-// `defer clear(der)` fires regardless of onDER's return — the security
-// invariant is "buffer is always zeroized after the function returns,"
-// happy path or error path.
-func TestMarshalAgentKeyAndZeroize_BufferZeroizedEvenOnError(t *testing.T) {
-	k := mustGenAgentECDSAKey(t)
-	sentinel := errors.New("upstream boom")
-	var captured []byte
-	gotErr := marshalAgentKeyAndZeroize(k, func(der []byte) error {
-		captured = der // share backing array
-		return sentinel
-	})
-	if !errors.Is(gotErr, sentinel) {
-		t.Fatalf("expected sentinel via errors.Is, got: %v", gotErr)
-	}
-	if len(captured) == 0 {
-		t.Fatal("captured slice empty post-return")
-	}
-	for i, b := range captured {
-		if b != 0 {
-			t.Errorf("captured[%d] = %#x; expected 0x00 (defer clear must run on error path)", i, b)
-		}
-	}
-}
-
-// TestMarshalAgentKeyAndZeroize_ContractViolatorSeesZeros frames the same
-// observation as a defense-in-depth contract test. The docstring states
-// "Caller must NOT retain the slice." If a caller violates that contract
-// and reads the slice after onDER returns, they observe zeros — not the
-// private scalar. This test pins that defense.
-func TestMarshalAgentKeyAndZeroize_ContractViolatorSeesZeros(t *testing.T) {
-	k := mustGenAgentECDSAKey(t)
-	var leaked []byte // simulating a buggy caller that retains the slice
-	err := marshalAgentKeyAndZeroize(k, func(der []byte) error {
-		leaked = der
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("marshalAgentKeyAndZeroize: %v", err)
-	}
-	// The contract violator now reads from `leaked`. Defense-in-depth: it's zeros.
-	for i, b := range leaked {
-		if b != 0 {
-			t.Errorf("contract-violator read leaked[%d] = %#x; expected 0x00", i, b)
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// ensureAgentKeyDirSecure — table-driven coverage
-// ---------------------------------------------------------------------------
-
-func TestEnsureAgentKeyDirSecure(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-
-	type tc struct {
-		name string
-		// setup returns the dir argument to pass to ensureAgentKeyDirSecure.
-		// base is a fresh t.TempDir() unique to each subtest.
-		setup func(t *testing.T, base string) string
-		// wantErrSubstr; "" means no error is expected.
-		wantErrSubstr string
-		// wantMode; if set, asserted via os.Stat after the call. Set to 0
-		// to skip the mode assertion (e.g. for error-path rows where the
-		// dir wasn't created or wasn't intended to change).
-		wantMode os.FileMode
-	}
-	cases := []tc{
-		// Refuse-empty/root invariants
-		{
-			name: "empty_string_refused",
-			setup: func(t *testing.T, _ string) string {
-				return ""
-			},
-			wantErrSubstr: `refuse empty/root dir ""`,
-		},
-		{
-			name: "dot_refused",
-			setup: func(t *testing.T, _ string) string {
-				return "."
-			},
-			wantErrSubstr: `refuse empty/root dir "."`,
-		},
-		{
-			name: "root_refused",
-			setup: func(t *testing.T, _ string) string {
-				return "/"
-			},
-			wantErrSubstr: `refuse empty/root dir "/"`,
-		},
-
-		// Non-existent path — MkdirAll(0700) path
-		{
-			name: "creates_with_0700",
-			setup: func(t *testing.T, base string) string {
-				return filepath.Join(base, "newdir")
-			},
-			wantMode: 0o700,
-		},
-		{
-			name: "creates_nested_0700",
-			setup: func(t *testing.T, base string) string {
-				return filepath.Join(base, "a", "b", "c")
-			},
-			wantMode: 0o700,
-		},
-
-		// Existing 0700 — no-op (mode == 0o700 branch).
-		{
-			name: "existing_0700_noop",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "exists0700")
-				if err := os.Mkdir(d, 0o700); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				return d
-			},
-			wantMode: 0o700,
-		},
-
-		// Existing more-permissive — chmod tighten to 0700.
-		{
-			name: "existing_0750_tightened",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "exists0750")
-				if err := os.Mkdir(d, 0o750); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o750); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				return d
-			},
-			wantMode: 0o700,
-		},
-		{
-			name: "existing_0755_tightened",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "exists0755")
-				if err := os.Mkdir(d, 0o755); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o755); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				return d
-			},
-			wantMode: 0o700,
-		},
-		{
-			name: "existing_0777_tightened",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "exists0777")
-				if err := os.Mkdir(d, 0o777); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o777); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				return d
-			},
-			wantMode: 0o700,
-		},
-
-		// Existing owner-only-no-write modes accepted as-is via the
-		// `mode&0o077 == 0` branch (no chmod, mode preserved).
-		{
-			name: "existing_0500_accepted_no_chmod",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "exists0500")
-				if err := os.Mkdir(d, 0o700); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o500); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				t.Cleanup(func() { _ = os.Chmod(d, 0o700) }) // let TempDir cleanup
-				return d
-			},
-			wantMode: 0o500,
-		},
-		{
-			name: "existing_0400_accepted_no_chmod",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "exists0400")
-				if err := os.Mkdir(d, 0o700); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o400); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				t.Cleanup(func() { _ = os.Chmod(d, 0o700) })
-				return d
-			},
-			wantMode: 0o400,
-		},
-
-		// filepath.Clean normalization paths.
-		{
-			name: "trailing_slash_normalized",
-			setup: func(t *testing.T, base string) string {
-				d := filepath.Join(base, "trail")
-				if err := os.Mkdir(d, 0o755); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o755); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				return d + "/"
-			},
-			wantMode: 0o700,
-		},
-		{
-			name: "dot_prefix_normalized",
-			setup: func(t *testing.T, base string) string {
-				// The function uses filepath.Clean which strips redundant
-				// "./" segments. We only need to verify Clean is invoked,
-				// not that we end up at a relative path; pass an absolute
-				// path with an embedded "./".
-				d := filepath.Join(base, "dotprefix")
-				if err := os.Mkdir(d, 0o755); err != nil {
-					t.Fatalf("setup mkdir: %v", err)
-				}
-				if err := os.Chmod(d, 0o755); err != nil {
-					t.Fatalf("setup chmod: %v", err)
-				}
-				return filepath.Join(base, ".", "dotprefix")
-			},
-			wantMode: 0o700,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			base := t.TempDir()
-			dir := tc.setup(t, base)
-
-			err := ensureAgentKeyDirSecure(dir)
-			if tc.wantErrSubstr != "" {
-				if err == nil {
-					t.Fatalf("expected error containing %q, got nil", tc.wantErrSubstr)
-				}
-				if !strings.Contains(err.Error(), tc.wantErrSubstr) {
-					t.Errorf("error %q does not contain %q", err, tc.wantErrSubstr)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("ensureAgentKeyDirSecure: %v", err)
-			}
-			if tc.wantMode != 0 {
-				clean := filepath.Clean(dir)
-				info, statErr := os.Stat(clean)
-				if statErr != nil {
-					t.Fatalf("post-call stat: %v", statErr)
-				}
-				if got := info.Mode().Perm(); got != tc.wantMode {
-					t.Errorf("dir mode = %#o; want %#o", got, tc.wantMode)
-				}
-			}
-		})
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_Idempotent confirms a second call on a
-// just-created dir is a no-op (hits the `mode == 0o700` short-circuit).
-func TestEnsureAgentKeyDirSecure_Idempotent(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	dir := filepath.Join(t.TempDir(), "idempotent")
-	if err := ensureAgentKeyDirSecure(dir); err != nil {
-		t.Fatalf("first call: %v", err)
-	}
-	if err := ensureAgentKeyDirSecure(dir); err != nil {
-		t.Fatalf("second call: %v", err)
-	}
-	info, err := os.Stat(dir)
-	if err != nil {
-		t.Fatalf("stat: %v", err)
-	}
-	if info.Mode().Perm() != 0o700 {
-		t.Errorf("expected 0700, got %#o", info.Mode().Perm())
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_Concurrent runs the function from many
-// goroutines simultaneously on the same fresh path. This is a safety smoke
-// test under -race; it is NOT a functional correctness claim about
-// concurrent agents (the agent has a single goroutine). The MkdirAll call
-// is the load-bearing primitive here — it's documented as safe to call
-// repeatedly with no error if the dir already exists.
-func TestEnsureAgentKeyDirSecure_Concurrent(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	dir := filepath.Join(t.TempDir(), "concurrent")
-	const workers = 8
-	var wg sync.WaitGroup
-	errCh := make(chan error, workers)
-	wg.Add(workers)
-	for i := 0; i < workers; i++ {
-		go func() {
-			defer wg.Done()
-			if err := ensureAgentKeyDirSecure(dir); err != nil {
-				errCh <- err
-			}
-		}()
-	}
-	wg.Wait()
-	close(errCh)
-	for err := range errCh {
-		t.Errorf("concurrent caller returned error: %v", err)
-	}
-	info, err := os.Stat(dir)
-	if err != nil {
-		t.Fatalf("post-concurrent stat: %v", err)
-	}
-	if info.Mode().Perm() != 0o700 {
-		t.Errorf("expected 0700 after concurrent calls, got %#o", info.Mode().Perm())
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_PathIsAFile pins the function's behavior when
-// passed a regular file. The function does not type-check (no IsDir()), so
-// it stat's the file, sees mode 0o644 (or whatever), and chmod's it to 0700.
-//
-// This is "silently accepts a file path" behavior. It is not a correctness
-// bug per the function's caller (cmd/agent/main.go always passes
-// filepath.Dir(keyPath), which is a directory), but it is a hardening
-// candidate. Captured as a finding observation in the test docstring rather
-// than fixed in this bundle (Bundle 0.7 ships no production-code changes).
-func TestEnsureAgentKeyDirSecure_PathIsAFile(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	base := t.TempDir()
-	filePath := filepath.Join(base, "not-a-dir.txt")
-	if err := os.WriteFile(filePath, []byte("x"), 0o644); err != nil {
-		t.Fatalf("setup writefile: %v", err)
-	}
-	err := ensureAgentKeyDirSecure(filePath)
-	if err != nil {
-		t.Fatalf("current behavior: function chmod's a file silently and returns nil; got err = %v", err)
-	}
-	info, statErr := os.Stat(filePath)
-	if statErr != nil {
-		t.Fatalf("post-call stat: %v", statErr)
-	}
-	if info.IsDir() {
-		t.Fatal("file became a directory; that's not a thing")
-	}
-	if info.Mode().Perm() != 0o700 {
-		t.Errorf("expected mode 0700 (current behavior), got %#o", info.Mode().Perm())
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_MkdirErrorPropagated forces the MkdirAll
-// branch to fail by chmod'ing the parent to 0o500 (read+exec but no write).
-// On linux/darwin running as a non-root uid, MkdirAll on a child of such a
-// parent fails with EACCES. We assert the error message wraps with the
-// documented "create agent key dir" prefix.
-//
-// Skipped if running as root (root bypasses unix dir-write checks).
-func TestEnsureAgentKeyDirSecure_MkdirErrorPropagated(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	if os.Getuid() == 0 {
-		t.Skip("running as root; cannot revoke parent dir write permission")
-	}
-	parent := t.TempDir()
-	if err := os.Chmod(parent, 0o500); err != nil {
-		t.Fatalf("setup chmod parent: %v", err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(parent, 0o700) })
-
-	child := filepath.Join(parent, "no-can-create")
-	err := ensureAgentKeyDirSecure(child)
-	if err == nil {
-		t.Fatal("expected error when MkdirAll cannot write to read-only parent")
-	}
-	if !strings.Contains(err.Error(), "create agent key dir") {
-		t.Errorf("error %q should contain %q", err.Error(), "create agent key dir")
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_StatErrorPropagated forces os.Stat to fail
-// with a non-IsNotExist error by chmod'ing the parent to 0o000 (no
-// read+exec). On linux/darwin running as a non-root uid, stat on a child
-// of such a parent fails with EACCES. We assert the error message wraps
-// with "stat agent key dir".
-//
-// Skipped if running as root.
-func TestEnsureAgentKeyDirSecure_StatErrorPropagated(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	if os.Getuid() == 0 {
-		t.Skip("running as root; cannot revoke parent dir read+exec permission")
-	}
-	parent := t.TempDir()
-	child := filepath.Join(parent, "victim")
-	if err := os.Chmod(parent, 0o000); err != nil {
-		t.Fatalf("setup chmod parent: %v", err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(parent, 0o700) })
-
-	err := ensureAgentKeyDirSecure(child)
-	if err == nil {
-		t.Fatal("expected error when stat cannot traverse unreadable parent")
-	}
-	if !strings.Contains(err.Error(), "stat agent key dir") {
-		t.Errorf("error %q should contain %q", err.Error(), "stat agent key dir")
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_ChmodErrorPropagated forces os.Chmod to fail
-// on an existing more-permissive dir. We achieve this by:
-//  1. Creating an intermediate dir at 0o755 (so the function takes the
-//     tighten-via-chmod branch).
-//  2. Replacing the real dir with a read-only-from-parent bind: chmod the
-//     grandparent to 0o500 so the chmod syscall on the child fails with
-//     EACCES (the syscall needs write on the path's containing dir for
-//     metadata updates on most unix filesystems — actually no, chmod only
-//     needs ownership, not parent write. So we instead drop the file's
-//     owner via... no — we cannot change ownership without root.)
-//
-// Reaching the chmod-error branch from a non-root test is awkward because
-// chmod only requires ownership (which we always have on t.TempDir()).
-// The cleanest way is to skip on non-root and exercise the branch in CI
-// images that run as root; but our CI runs as non-root. We DO trigger the
-// branch via a different mechanism: replace the path with a SYMLINK to
-// /proc/1/root (or similar) where the eventual stat resolves but chmod
-// fails — but that's brittle and OS-specific.
-//
-// Acceptable closure: document that this branch is exercised by the
-// existing chmod-fails errno path, but the test as written can only assert
-// the wrap-prefix when the branch IS reached. We use a synthetic approach:
-// chmod-tighten a dir we then immediately delete, racing the syscall —
-// not deterministic.
-//
-// Pragmatic resolution: the chmod-error branch is structurally identical
-// to the mkdir-error and stat-error branches (errors.Wrap with a
-// distinct prefix), and is exercised in production via os.Chmod ENOENT
-// or read-only-filesystem failures. We add a unit test that asserts the
-// branch's MESSAGE format by passing through a wrap helper construct.
-// This test instead documents that the branch is structural and any new
-// failure mode (read-only fs, immutable bit, ACLs) inherits the wrap
-// prefix automatically.
-//
-// To still get coverage on the chmod-error branch, we use os.Chmod against
-// a dir whose immediate parent we delete mid-call. This is racy. Instead,
-// we make chmod fail by passing a path that filepath.Clean rewrites to
-// a symlink whose target was just chmod-stripped. Too brittle.
-//
-// CLEANEST APPROACH: rely on the OS's read-only filesystem semantics under
-// /sys (which is RO on linux). os.Chmod on a path under /sys returns EROFS.
-// But /sys is owned by root — stat would succeed only on existing entries,
-// and the function would then attempt chmod, which fails with EROFS (the
-// non-root caller still gets a clean error wrap).
-//
-// We cannot find a well-defined non-root chmod-fail path on darwin. So the
-// test runs only on linux and skips elsewhere.
-func TestEnsureAgentKeyDirSecure_ChmodErrorPropagated(t *testing.T) {
-	if runtime.GOOS != "linux" {
-		t.Skip("chmod-error branch is only reliably triggerable on linux via /sys (read-only fs)")
-	}
-	// /sys is mounted read-only on Linux. Pick a stable subdir we can stat
-	// (kernel-class). os.Chmod against it returns EROFS regardless of uid
-	// (well — root can remount, but the call against /sys/* still EROFS).
-	candidate := "/sys/kernel"
-	info, err := os.Stat(candidate)
-	if err != nil || !info.IsDir() {
-		t.Skipf("/sys/kernel not stat-able as a dir on this host; skipping (%v)", err)
-	}
-	mode := info.Mode().Perm()
-	if mode == 0o700 || mode&0o077 == 0 {
-		// Already in the no-chmod branch; this test cannot exercise the
-		// chmod-fail branch on this host. Skip rather than false-positive.
-		t.Skipf("/sys/kernel mode %#o already satisfies no-chmod branch", mode)
-	}
-	chmodErr := ensureAgentKeyDirSecure(candidate)
-	if chmodErr == nil {
-		t.Fatal("expected chmod failure on /sys (read-only fs)")
-	}
-	if !strings.Contains(chmodErr.Error(), "tighten agent key dir") {
-		t.Errorf("error %q should contain %q", chmodErr.Error(), "tighten agent key dir")
-	}
-}
-
-// TestEnsureAgentKeyDirSecure_FmtErrorMessageIncludesPath confirms each
-// error wrap includes the cleaned path (debuggability invariant).
-func TestEnsureAgentKeyDirSecure_FmtErrorMessageIncludesPath(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	if os.Getuid() == 0 {
-		t.Skip("running as root; cannot revoke parent dir write permission")
-	}
-	parent := t.TempDir()
-	if err := os.Chmod(parent, 0o500); err != nil {
-		t.Fatalf("setup chmod parent: %v", err)
-	}
-	t.Cleanup(func() { _ = os.Chmod(parent, 0o700) })
-	child := filepath.Join(parent, "child")
-	want := filepath.Clean(child)
-
-	err := ensureAgentKeyDirSecure(child)
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	if !strings.Contains(err.Error(), want) {
-		t.Errorf("error %q should reference cleaned path %q", err, want)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Cross-cutting: end-to-end smoke confirming the two functions compose
-// the way main.go uses them (Bundle 9 / L-002 / L-003 flow).
-// ---------------------------------------------------------------------------
-
-// TestKeymem_AgentMainFlowSmoke replays the cmd/agent/main.go composition:
-// ensureAgentKeyDirSecure(dir) → marshalAgentKeyAndZeroize(priv, onDER).
-// Closes the contract that both helpers cooperate cleanly under realistic
-// fixture conditions, and that the DER buffer is zeroized at the end of
-// the marshal call.
-func TestKeymem_AgentMainFlowSmoke(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission semantics differ on windows")
-	}
-	keyDir := filepath.Join(t.TempDir(), "agent-keys")
-	if err := ensureAgentKeyDirSecure(keyDir); err != nil {
-		t.Fatalf("ensureAgentKeyDirSecure: %v", err)
-	}
-	info, err := os.Stat(keyDir)
-	if err != nil {
-		t.Fatalf("stat: %v", err)
-	}
-	if info.Mode().Perm() != 0o700 {
-		t.Fatalf("key dir not at 0700, got %#o", info.Mode().Perm())
-	}
-
-	priv := mustGenAgentECDSAKey(t)
-	var captured []byte
-	if err := marshalAgentKeyAndZeroize(priv, func(der []byte) error {
-		captured = der // share backing array
-		// Pretend caller does pem.EncodeToMemory(...) here; we just check
-		// the DER is a valid SEQUENCE.
-		if len(der) == 0 || der[0] != 0x30 {
-			return fmt.Errorf("unexpected DER shape (len=%d, first=%#x)", len(der), der)
-		}
-		return nil
-	}); err != nil {
-		t.Fatalf("marshalAgentKeyAndZeroize: %v", err)
-	}
-	for i, b := range captured {
-		if b != 0 {
-			t.Fatalf("post-flow DER buffer not zeroized at byte %d (%#x)", i, b)
-		}
-	}
-}

cmd/agent/main.go

@@ -30,22 +30,20 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/certctl-io/certctl/internal/connector/target"
-	"github.com/certctl-io/certctl/internal/connector/target/apache"
-	"github.com/certctl-io/certctl/internal/connector/target/awsacm"
-	"github.com/certctl-io/certctl/internal/connector/target/azurekv"
-	"github.com/certctl-io/certctl/internal/connector/target/caddy"
-	"github.com/certctl-io/certctl/internal/connector/target/envoy"
-	"github.com/certctl-io/certctl/internal/connector/target/f5"
-	"github.com/certctl-io/certctl/internal/connector/target/haproxy"
-	"github.com/certctl-io/certctl/internal/connector/target/iis"
-	jks "github.com/certctl-io/certctl/internal/connector/target/javakeystore"
-	k8s "github.com/certctl-io/certctl/internal/connector/target/k8ssecret"
-	"github.com/certctl-io/certctl/internal/connector/target/nginx"
-	pf "github.com/certctl-io/certctl/internal/connector/target/postfix"
-	sshconn "github.com/certctl-io/certctl/internal/connector/target/ssh"
-	"github.com/certctl-io/certctl/internal/connector/target/traefik"
-	wcs "github.com/certctl-io/certctl/internal/connector/target/wincertstore"
+	"github.com/shankar0123/certctl/internal/connector/target"
+	"github.com/shankar0123/certctl/internal/connector/target/apache"
+	"github.com/shankar0123/certctl/internal/connector/target/caddy"
+	"github.com/shankar0123/certctl/internal/connector/target/envoy"
+	pf "github.com/shankar0123/certctl/internal/connector/target/postfix"
+	sshconn "github.com/shankar0123/certctl/internal/connector/target/ssh"
+	"github.com/shankar0123/certctl/internal/connector/target/f5"
+	jks "github.com/shankar0123/certctl/internal/connector/target/javakeystore"
+	k8s "github.com/shankar0123/certctl/internal/connector/target/k8ssecret"
+	wcs "github.com/shankar0123/certctl/internal/connector/target/wincertstore"
+	"github.com/shankar0123/certctl/internal/connector/target/haproxy"
+	"github.com/shankar0123/certctl/internal/connector/target/iis"
+	"github.com/shankar0123/certctl/internal/connector/target/nginx"
+	"github.com/shankar0123/certctl/internal/connector/target/traefik"
 )
 
 // AgentConfig represents the agent-side configuration.
@@ -64,7 +62,7 @@ type AgentConfig struct {
 // ErrAgentRetired is the sentinel returned by [Agent.Run] when the control
 // plane responds with HTTP 410 Gone to a heartbeat or work-poll request — the
 // canonical signal that this agent's row has been soft-retired server-side
-// (see I-004 in the project's coverage-gap audit). The binary must
+// (see I-004 in cowork/certctl-coverage-gap-audit.md). The binary must
 // terminate cleanly: an init-system restart would only produce another 410
 // and wedge the host in a restart loop. main() translates this sentinel into
 // a zero exit code so systemd (Restart=on-failure) and launchd do not respawn
@@ -82,10 +80,10 @@ type Agent struct {
 	client *http.Client
 
 	// Configuration
-	heartbeatInterval   time.Duration
-	pollInterval        time.Duration
-	discoveryInterval   time.Duration
-	consecutiveFailures int
+	heartbeatInterval     time.Duration
+	pollInterval          time.Duration
+	discoveryInterval     time.Duration
+	consecutiveFailures   int
 
 	// I-004: terminal retirement signal. retiredSignal is closed exactly once
 	// (guarded by retiredOnce) when either sendHeartbeat or pollForWork
@@ -97,47 +95,6 @@ type Agent struct {
 	// race with ctx.Done() and other cases.
 	retiredOnce   sync.Once
 	retiredSignal chan struct{}
-
-	// Deploy-hardening I Phase 2: per-target deploy mutex.
-	// Two cert renewals against the same target ID (e.g., two SAN
-	// entries renewing in the same window, or a fast-cycling
-	// renewal-then-test workflow) MUST serialize at the agent
-	// dispatch site. Without this lock, the underlying connector's
-	// temp-file path could collide and the reload command would
-	// race against itself.
-	//
-	// Granularity is one mutex per target ID, NOT per (target, cert)
-	// pair — frozen decision 0.5. Cert deploy throughput is
-	// operator-grade tens-per-minute; coarse serialization is fine
-	// and simplifies reasoning about reload-side race windows.
-	//
-	// sync.Map is sized for thousands of unique target IDs without
-	// rehash thrash; LoadOrStore is atomic + lock-free on the
-	// hot path. Mutexes live for the agent's lifetime — no janitor
-	// because target IDs are bounded and the per-target memory
-	// (~16 bytes per entry) is negligible vs. typical agent heap.
-	//
-	// Job items without a TargetID (e.g., agent-managed cert + no
-	// connector dispatch — should never happen for deploy jobs but
-	// defended anyway) bypass the lock to avoid a singleton
-	// serialization point.
-	deployMutexes sync.Map // map[string]*sync.Mutex, keyed on JobItem.TargetID
-}
-
-// targetDeployMutex returns the per-target-ID *sync.Mutex,
-// lazy-initialising one on first acquisition. Returns nil when
-// targetID is empty (caller should skip the lock entirely).
-//
-// Phase 2 of the deploy-hardening I master bundle: the load-bearing
-// serialization point that defends against concurrent deploys to the
-// same target stomping each other's temp-file paths or reload
-// commands.
-func (a *Agent) targetDeployMutex(targetID string) *sync.Mutex {
-	if targetID == "" {
-		return nil
-	}
-	v, _ := a.deployMutexes.LoadOrStore(targetID, &sync.Mutex{})
-	return v.(*sync.Mutex)
 }
 
 // WorkResponse represents the response from the work polling endpoint.
@@ -488,40 +445,23 @@ func (a *Agent) executeCSRJob(ctx context.Context, job JobItem) {
 		"job_id", job.ID,
 		"certificate_id", job.CertificateID)
 
-	// Step 2: Store private key to disk with secure permissions.
-	//
-	// Bundle-9 / Audit L-002 + L-003: marshal+write through helpers that
-	// (a) zeroize the in-heap DER buffer immediately after the PEM block is
-	// constructed so the private scalar's exposure window is bounded by
-	// this function call, and (b) assert the key directory is mode 0700
-	// before any write touches disk. Also defer-clear the PEM buffer for
-	// the same reason — the encoded key isn't sensitive in transit (it's
-	// going to disk) but lingers on the heap if we don't.
+	// Step 2: Store private key to disk with secure permissions
 	keyPath := filepath.Join(a.config.KeyDir, job.CertificateID+".key")
-	if err := ensureAgentKeyDirSecure(filepath.Dir(keyPath)); err != nil {
-		a.logger.Error("agent key dir hardening failed", "job_id", job.ID, "error", err)
-		if reportErr := a.reportJobStatus(ctx, job.ID, "Failed", fmt.Sprintf("key dir hardening failed: %v", err)); reportErr != nil {
-			a.logger.Error("failed to report job status to server", "job_id", job.ID, "status", "Failed", "error", reportErr)
-		}
-		return
-	}
-	var privKeyPEM []byte
-	if marshalErr := marshalAgentKeyAndZeroize(privKey, func(der []byte) error {
-		privKeyPEM = pem.EncodeToMemory(&pem.Block{
-			Type:  "EC PRIVATE KEY",
-			Bytes: der,
-		})
-		return nil
-	}); marshalErr != nil {
+	privKeyDER, err := x509.MarshalECPrivateKey(privKey)
+	if err != nil {
 		a.logger.Error("failed to marshal private key",
 			"job_id", job.ID,
-			"error", marshalErr)
-		if reportErr := a.reportJobStatus(ctx, job.ID, "Failed", fmt.Sprintf("key marshal failed: %v", marshalErr)); reportErr != nil {
+			"error", err)
+		if reportErr := a.reportJobStatus(ctx, job.ID, "Failed", fmt.Sprintf("key marshal failed: %v", err)); reportErr != nil {
 			a.logger.Error("failed to report job status to server", "job_id", job.ID, "status", "Failed", "error", reportErr)
 		}
 		return
 	}
-	defer clear(privKeyPEM)
+
+	privKeyPEM := pem.EncodeToMemory(&pem.Block{
+		Type:  "EC PRIVATE KEY",
+		Bytes: privKeyDER,
+	})
 
 	if err := os.WriteFile(keyPath, privKeyPEM, 0600); err != nil {
 		a.logger.Error("failed to write private key to disk",
@@ -687,7 +627,7 @@ func (a *Agent) executeDeploymentJob(ctx context.Context, job JobItem) {
 
 	// Deploy to the target using the appropriate connector
 	if job.TargetType != "" {
-		connector, err := a.createTargetConnector(ctx, job.TargetType, job.TargetConfig)
+		connector, err := a.createTargetConnector(job.TargetType, job.TargetConfig)
 		if err != nil {
 			a.logger.Error("failed to create target connector",
 				"job_id", job.ID,
@@ -710,22 +650,6 @@ func (a *Agent) executeDeploymentJob(ctx context.Context, job JobItem) {
 			},
 		}
 
-		// Phase 2 of the deploy-hardening I master bundle:
-		// per-target deploy mutex. Acquire BEFORE
-		// DeployCertificate so two concurrent renewals against
-		// the same target ID serialize. The lock is held for the
-		// full Deploy duration including PreCommit (validate),
-		// PostCommit (reload), and post-deploy verify (Phases
-		// 4-9). Released on every return path via defer.
-		var targetID string
-		if job.TargetID != nil {
-			targetID = *job.TargetID
-		}
-		if mu := a.targetDeployMutex(targetID); mu != nil {
-			mu.Lock()
-			defer mu.Unlock()
-		}
-
 		result, err := connector.DeployCertificate(ctx, deployReq)
 		if err != nil {
 			a.logger.Error("deployment failed",
@@ -768,11 +692,7 @@ func (a *Agent) executeDeploymentJob(ctx context.Context, job JobItem) {
 }
 
 // createTargetConnector instantiates the appropriate target connector based on type.
-// ctx is threaded into SDK-driven connectors (AWSACM, AzureKeyVault) so credential
-// resolution honors caller cancellation / deadlines instead of using a fresh
-// context.Background() (the contextcheck linter enforces this — the original Rank 5
-// implementation used Background() and tripped CI on commit 502823d).
-func (a *Agent) createTargetConnector(ctx context.Context, targetType string, configJSON json.RawMessage) (target.Connector, error) {
+func (a *Agent) createTargetConnector(targetType string, configJSON json.RawMessage) (target.Connector, error) {
 	switch targetType {
 	case "NGINX":
 		var cfg nginx.Config
@@ -906,35 +826,6 @@ func (a *Agent) createTargetConnector(ctx context.Context, targetType string, co
 		}
 		return k8s.New(&cfg, a.logger)
 
-	case "AWSACM":
-		// Rank 5 of the 2026-05-03 Infisical deep-research deliverable.
-		// AWS Certificate Manager target — SDK-driven (no file I/O).
-		// LoadDefaultConfig handles the standard AWS credential chain
-		// (IRSA / EC2 instance profile / SSO / env vars) without any
-		// long-lived creds in connector Config.
-		var cfg awsacm.Config
-		if len(configJSON) > 0 {
-			if err := json.Unmarshal(configJSON, &cfg); err != nil {
-				return nil, fmt.Errorf("invalid AWSACM config: %w", err)
-			}
-		}
-		return awsacm.New(ctx, &cfg, a.logger)
-
-	case "AzureKeyVault":
-		// Rank 5 of the 2026-05-03 Infisical deep-research deliverable.
-		// Azure Key Vault target — SDK-driven (no file I/O).
-		// DefaultAzureCredential handles the standard Azure credential
-		// chain (managed identity / workload identity / env vars / az
-		// CLI fallback). Long-lived service-principal secrets are
-		// supported but discouraged via the credential_mode config.
-		var cfg azurekv.Config
-		if len(configJSON) > 0 {
-			if err := json.Unmarshal(configJSON, &cfg); err != nil {
-				return nil, fmt.Errorf("invalid AzureKeyVault config: %w", err)
-			}
-		}
-		return azurekv.New(ctx, &cfg, a.logger)
-
 	default:
 		return nil, fmt.Errorf("unsupported target type: %s", targetType)
 	}

cmd/agent/verify.go

@@ -75,8 +75,8 @@ func verifyDeployment(
 		// calls, issuer connector communication, or any operation that trusts the
 		// certificate. The verification result compares SHA-256 fingerprints only.
 		// See TICKET-016 for full security audit rationale.
-		InsecureSkipVerify: true,       //nolint:gosec // verification probe; documented above + docs/tls.md L-001 table
-		ServerName:         targetHost, // For SNI
+		InsecureSkipVerify: true,
+		ServerName:        targetHost, // For SNI
 	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to connect to %s: %w", address, err)
@@ -161,11 +161,11 @@ func (a *Agent) reportVerificationResult(
 
 	// Build the request payload
 	payload := map[string]interface{}{
-		"target_id":            targetID,
-		"expected_fingerprint": result.ExpectedFingerprint,
-		"actual_fingerprint":   result.ActualFingerprint,
-		"verified":             result.Verified,
-		"error":                result.Error,
+		"target_id":             targetID,
+		"expected_fingerprint":  result.ExpectedFingerprint,
+		"actual_fingerprint":    result.ActualFingerprint,
+		"verified":              result.Verified,
+		"error":                 result.Error,
 	}
 
 	body, err := json.Marshal(payload)
@@ -247,7 +247,7 @@ func (a *Agent) verifyAndReportDeployment(
 ) {
 	// Perform verification with configured timeout and delay
 	result, err := verifyDeployment(ctx, targetHost, targetPort, certPEM,
-		2*time.Second,  // delay before probing
+		2*time.Second, // delay before probing
 		10*time.Second, // timeout for TLS connection
 		a.logger)
 
@@ -261,7 +261,7 @@ func (a *Agent) verifyAndReportDeployment(
 		}
 		// Probe failure: report error but continue
 		result = &VerificationResult{
-			Error:      err.Error(),
+			Error: err.Error(),
 			VerifiedAt: time.Now().UTC(),
 		}
 	}

cmd/agent/verify_test.go

@@ -114,9 +114,9 @@ func TestExtractTargetHostAndPort_InvalidJSON(t *testing.T) {
 
 func TestExtractTargetHostAndPort_AlternativeFieldNames(t *testing.T) {
 	tests := []struct {
-		name     string
-		config   map[string]interface{}
-		expected string
+		name      string
+		config    map[string]interface{}
+		expected  string
 	}{
 		{"host", map[string]interface{}{"host": "host1.com"}, "host1.com"},
 		{"hostname", map[string]interface{}{"hostname": "host2.com"}, "host2.com"},
@@ -391,13 +391,7 @@ func TestVerifyDeployment_FingerprintComparison(t *testing.T) {
 	}))
 	defer server.Close()
 
-	// Q-1 closure (cat-s3-58ce7e9840be): defensive skip — httptest.NewTLSServer
-	// always provisions a self-signed certificate at construction time, so this
-	// branch is currently unreachable in practice. Kept as a guard against
-	// future test-server constructions that swap in a custom *tls.Config with
-	// no Certificates slice (the path below dereferences server.TLS.Certificates[0]
-	// and would panic). The skip preserves the assertion logic for the normal
-	// fixture path; if it ever fires, it's a fixture bug, not a product bug.
+	// Get the server's TLS certificate from TLS config
 	if len(server.TLS.Certificates) == 0 {
 		t.Skip("no TLS certificates configured on test server")
 	}

cmd/cli/dispatch_test.go

@@ -1,507 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/certctl-io/certctl/internal/cli"
-)
-
-// Bundle Q (L-001 closure): per-subcommand dispatch tests for cmd/cli/main.go.
-//
-// The existing `main_test.go` only covered `validateHTTPSScheme`. This file
-// pins every dispatch arm in `handleCerts`, `handleAgents`, `handleJobs`,
-// `handleImport`, `handleStatus` — both the "missing arg" usage prints and
-// the happy-path delegation to `*cli.Client`.
-//
-// Strategy: spin up an `httptest.Server` mocking the relevant API routes so
-// the client can exercise its end-to-end code path without a live server.
-// For arms that print usage and return without calling the client, we pass
-// a freshly-constructed client (still no network call — the client method
-// is never invoked).
-
-// newDispatchTestClient returns a `*cli.Client` pointed at the given test
-// server. Calls `t.Fatal` on construction error.
-func newDispatchTestClient(t *testing.T, server *httptest.Server) *cli.Client {
-	t.Helper()
-	// Configure the client with `insecure=true` because httptest.Server's
-	// self-signed TLS cert won't chain to a system root.
-	c, err := cli.NewClient(server.URL, "test-key", "json", "", true)
-	if err != nil {
-		t.Fatalf("NewClient: %v", err)
-	}
-	return c
-}
-
-// stubServer returns an httptest.Server (TLS) that responds with the given
-// JSON body and status code for any request. Tests that want to assert on
-// the request shape can wrap it in a more specific handler.
-func stubServer(t *testing.T, status int, body string) *httptest.Server {
-	t.Helper()
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(status)
-		_, _ = w.Write([]byte(body))
-	}))
-	t.Cleanup(srv.Close)
-	return srv
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// handleCerts dispatch arms
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestHandleCerts_NoArgs_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{"data":[],"total":0}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{}); err != nil {
-		t.Errorf("handleCerts({}): unexpected err=%v (should print usage and return nil)", err)
-	}
-}
-
-func TestHandleCerts_UnknownSubcommand_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{"data":[],"total":0}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"frobnicate"}); err != nil {
-		t.Errorf("handleCerts({frobnicate}): unexpected err=%v (should print usage and return nil)", err)
-	}
-}
-
-func TestHandleCerts_GetWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"get"}); err != nil {
-		t.Errorf("handleCerts({get}): unexpected err=%v (should print usage and return nil)", err)
-	}
-}
-
-func TestHandleCerts_RenewWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"renew"}); err != nil {
-		t.Errorf("handleCerts({renew}): unexpected err=%v (should print usage and return nil)", err)
-	}
-}
-
-func TestHandleCerts_RevokeWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"revoke"}); err != nil {
-		t.Errorf("handleCerts({revoke}): unexpected err=%v (should print usage and return nil)", err)
-	}
-}
-
-func TestHandleCerts_List_HitsClientPath(t *testing.T) {
-	// Asserts dispatch-path: handleCerts → c.ListCertificates → GET /api/v1/certificates.
-	var hits int
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		hits++
-		if r.Method != "GET" || !strings.HasPrefix(r.URL.Path, "/api/v1/certificates") {
-			t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
-		}
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"data":[],"total":0}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"list"}); err != nil {
-		t.Errorf("handleCerts({list}): err=%v", err)
-	}
-	if hits != 1 {
-		t.Errorf("expected 1 server hit, got %d", hits)
-	}
-}
-
-func TestHandleCerts_Get_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"id":"mc-x","name":"x"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"get", "mc-x"}); err != nil {
-		t.Errorf("handleCerts({get, mc-x}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/api/v1/certificates/mc-x") {
-		t.Errorf("expected GET on /api/v1/certificates/mc-x, got %q", lastPath)
-	}
-}
-
-func TestHandleCerts_Renew_HitsClientPath(t *testing.T) {
-	var lastPath, lastMethod string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		lastMethod = r.Method
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"job_id":"job-1","status":"ok"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"renew", "mc-x"}); err != nil {
-		t.Errorf("handleCerts({renew, mc-x}): err=%v", err)
-	}
-	if lastMethod != "POST" || !strings.Contains(lastPath, "/renew") {
-		t.Errorf("expected POST .../renew, got %s %s", lastMethod, lastPath)
-	}
-}
-
-func TestHandleCerts_Revoke_HitsClientPath(t *testing.T) {
-	var lastPath, lastMethod, lastBody string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		lastMethod = r.Method
-		buf := make([]byte, 1024)
-		n, _ := r.Body.Read(buf)
-		lastBody = string(buf[:n])
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"status":"revoked"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	// 2026-05-05 parity-defaults-cleanup (P3-2): reason must be a canonical
-	// RFC 5280 §5.3.1 code (camelCase or snake_case both accepted; this
-	// test asserts the snake_case path normalises to the camelCase wire
-	// format that the local issuer + ACME server expect).
-	if err := handleCerts(c, []string{"revoke", "mc-x", "--reason", "key_compromise"}); err != nil {
-		t.Errorf("handleCerts({revoke ...}): err=%v", err)
-	}
-	if lastMethod != "POST" || !strings.Contains(lastPath, "/revoke") {
-		t.Errorf("expected POST .../revoke, got %s %s", lastMethod, lastPath)
-	}
-	if !strings.Contains(lastBody, "keyCompromise") {
-		t.Errorf("expected normalised reason 'keyCompromise' in body, got %q", lastBody)
-	}
-}
-
-// TestHandleCerts_Revoke_RequiresReason pins the 2026-05-05 parity-defaults-
-// cleanup (P3-2, Option A) strict-reason contract: empty --reason is a
-// fatal error, not a silent fallback to "unspecified".
-func TestHandleCerts_Revoke_RequiresReason(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	err := handleCerts(c, []string{"revoke", "mc-x"})
-	if err == nil {
-		t.Fatal("expected error when --reason is omitted; got nil (regression on P3-2 strict path)")
-	}
-	if !strings.Contains(err.Error(), "reason") {
-		t.Errorf("expected error to mention 'reason', got %q", err.Error())
-	}
-}
-
-// TestHandleCerts_Revoke_RejectsUnknownReason pins that off-RFC reason
-// codes are rejected at the CLI dispatch layer (P3-2 anti-typo guard).
-func TestHandleCerts_Revoke_RejectsUnknownReason(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	err := handleCerts(c, []string{"revoke", "mc-x", "--reason", "compromise"})
-	if err == nil {
-		t.Fatal("expected error for non-canonical reason; got nil")
-	}
-	if !strings.Contains(err.Error(), "compromise") {
-		t.Errorf("expected error to echo bad reason 'compromise', got %q", err.Error())
-	}
-}
-
-// TestHandleCerts_Renew_ForceFlag pins the 2026-05-05 parity-defaults-
-// cleanup (P3-1) wire: --force on the renew dispatch sends ?force=true.
-// CLI convention: ID is positional and precedes the flags (matches
-// `agents retire <id> [--force]`), so the flag MUST come after the ID.
-func TestHandleCerts_Renew_ForceFlag(t *testing.T) {
-	for _, tc := range []struct {
-		name      string
-		args      []string
-		wantQuery string
-	}{
-		{"no-force", []string{"renew", "mc-x"}, ""},
-		{"force-after-id", []string{"renew", "mc-x", "--force"}, "force=true"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			var lastQuery string
-			srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				lastQuery = r.URL.RawQuery
-				w.WriteHeader(200)
-				_, _ = w.Write([]byte(`{}`))
-			}))
-			t.Cleanup(srv.Close)
-			c := newDispatchTestClient(t, srv)
-			if err := handleCerts(c, tc.args); err != nil {
-				t.Fatalf("handleCerts: %v", err)
-			}
-			if lastQuery != tc.wantQuery {
-				t.Errorf("query: got %q want %q", lastQuery, tc.wantQuery)
-			}
-		})
-	}
-}
-
-func TestHandleCerts_BulkRevoke_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"total_matched":0,"total_revoked":0,"total_skipped":0,"total_failed":0}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleCerts(c, []string{"bulk-revoke", "--reason", "test"}); err != nil {
-		t.Errorf("handleCerts({bulk-revoke ...}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/bulk-revoke") {
-		t.Errorf("expected /bulk-revoke path, got %q", lastPath)
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// handleAgents dispatch arms
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestHandleAgents_NoArgs_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{}); err != nil {
-		t.Errorf("handleAgents({}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleAgents_UnknownSubcommand_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{"frobnicate"}); err != nil {
-		t.Errorf("handleAgents({frobnicate}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleAgents_GetWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{"get"}); err != nil {
-		t.Errorf("handleAgents({get}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleAgents_RetireWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{"retire"}); err != nil {
-		t.Errorf("handleAgents({retire}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleAgents_List_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"data":[],"total":0}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{"list"}); err != nil {
-		t.Errorf("handleAgents({list}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/api/v1/agents") {
-		t.Errorf("expected /api/v1/agents path, got %q", lastPath)
-	}
-}
-
-func TestHandleAgents_ListRetired_HitsRetiredEndpoint(t *testing.T) {
-	// I-004: --retired flag splits to a separate /agents/retired endpoint.
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"data":[],"total":0}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{"list", "--retired"}); err != nil {
-		t.Errorf("handleAgents({list --retired}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/agents/retired") {
-		t.Errorf("expected --retired to hit /agents/retired, got %q", lastPath)
-	}
-}
-
-func TestHandleAgents_Get_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"id":"ag-x","status":"online"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleAgents(c, []string{"get", "ag-x"}); err != nil {
-		t.Errorf("handleAgents({get, ag-x}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/agents/ag-x") {
-		t.Errorf("expected /agents/ag-x, got %q", lastPath)
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// handleJobs dispatch arms
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestHandleJobs_NoArgs_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{}); err != nil {
-		t.Errorf("handleJobs({}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleJobs_UnknownSubcommand_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{"frobnicate"}); err != nil {
-		t.Errorf("handleJobs({frobnicate}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleJobs_GetWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{"get"}); err != nil {
-		t.Errorf("handleJobs({get}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleJobs_CancelWithoutID_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{"cancel"}); err != nil {
-		t.Errorf("handleJobs({cancel}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleJobs_List_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"data":[],"total":0}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{"list"}); err != nil {
-		t.Errorf("handleJobs({list}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/api/v1/jobs") {
-		t.Errorf("expected /api/v1/jobs path, got %q", lastPath)
-	}
-}
-
-func TestHandleJobs_Get_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"id":"job-x"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{"get", "job-x"}); err != nil {
-		t.Errorf("handleJobs({get, job-x}): err=%v", err)
-	}
-	if !strings.Contains(lastPath, "/jobs/job-x") {
-		t.Errorf("expected /jobs/job-x, got %q", lastPath)
-	}
-}
-
-func TestHandleJobs_Cancel_HitsClientPath(t *testing.T) {
-	var lastPath, lastMethod string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		lastMethod = r.Method
-		w.WriteHeader(200)
-		_, _ = w.Write([]byte(`{"status":"cancelled"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleJobs(c, []string{"cancel", "job-x"}); err != nil {
-		t.Errorf("handleJobs({cancel, job-x}): err=%v", err)
-	}
-	if lastMethod != "POST" || !strings.Contains(lastPath, "/cancel") {
-		t.Errorf("expected POST .../cancel, got %s %s", lastMethod, lastPath)
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// handleImport / handleStatus dispatch arms
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestHandleImport_NoArgs_PrintsUsage(t *testing.T) {
-	srv := stubServer(t, 200, `{}`)
-	c := newDispatchTestClient(t, srv)
-	if err := handleImport(c, []string{}); err != nil {
-		t.Errorf("handleImport({}): unexpected err=%v", err)
-	}
-}
-
-func TestHandleStatus_HitsClientPath(t *testing.T) {
-	var lastPath string
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		lastPath = r.URL.Path
-		w.WriteHeader(200)
-		// GetStatus expects {"status":..., "stats":...} or similar.
-		// Provide a minimal valid JSON object.
-		_, _ = w.Write([]byte(`{"status":"healthy","version":"v2.X","db":"connected"}`))
-	}))
-	t.Cleanup(srv.Close)
-	c := newDispatchTestClient(t, srv)
-	if err := handleStatus(c); err != nil {
-		// GetStatus's table output may complain about missing fields; we only
-		// care that the dispatch arm fired and the request reached the server.
-		_ = err
-	}
-	if lastPath == "" {
-		t.Errorf("expected handleStatus to make at least one request")
-	}
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// CLI client TLS sanity (Q.1: confirms NewClient configures TLS correctly).
-// ─────────────────────────────────────────────────────────────────────────────
-
-func TestCliClient_RejectsUntrustedCert_WhenNotInsecure(t *testing.T) {
-	// Without insecure=true, the self-signed httptest cert must fail TLS
-	// verification. This pins the security default.
-	srv := stubServer(t, 200, `{}`)
-	c, err := cli.NewClient(srv.URL, "k", "json", "", false)
-	if err != nil {
-		t.Fatalf("NewClient: %v", err)
-	}
-	// Try a status call — should error out with a TLS verification failure,
-	// not silently succeed.
-	if err := c.GetStatus(); err == nil {
-		t.Errorf("expected TLS verification error against self-signed cert; got nil")
-	}
-}
-
-// TestCliClient_ParsesJSONResponse asserts the do() path's JSON unmarshalling
-// succeeds end-to-end (one of the more error-prone paths in the client).
-func TestCliClient_ParsesJSONResponse(t *testing.T) {
-	srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(200)
-		body := map[string]interface{}{
-			"data":  []map[string]interface{}{{"id": "mc-1", "name": "site-1"}},
-			"total": 1,
-		}
-		_ = json.NewEncoder(w).Encode(body)
-	}))
-	t.Cleanup(srv.Close)
-	c, err := cli.NewClient(srv.URL, "k", "json", "", true)
-	if err != nil {
-		t.Fatalf("NewClient: %v", err)
-	}
-	if err := c.ListCertificates(nil); err != nil {
-		t.Errorf("ListCertificates: err=%v", err)
-	}
-}

cmd/cli/main.go

@@ -7,7 +7,7 @@ import (
 	"os"
 	"strings"
 
-	"github.com/certctl-io/certctl/internal/cli"
+	"github.com/shankar0123/certctl/internal/cli"
 )
 
 func main() {
@@ -41,14 +41,6 @@ Commands:
                    Required: --owner-id, --team-id, --renewal-policy-id, --issuer-id
                    Optional: --name-template (default {cn}), --environment (default imported)
 
-  est cacerts      --profile <p>                 EST GET cacerts (RFC 7030 §4.1)
-  est csrattrs     --profile <p>                 EST GET csrattrs (RFC 7030 §4.5)
-  est enroll       --profile <p> --csr <path>    EST POST simpleenroll (RFC 7030 §4.2)
-  est reenroll     --profile <p> --csr <path>    EST POST simplereenroll (RFC 7030 §4.2.2)
-  est serverkeygen --profile <p> --csr <path> --out <prefix>
-                                                 EST POST serverkeygen (RFC 7030 §4.4)
-  est test         --profile <p>                 Smoke-test cacerts + csrattrs
-
   status           Show server health + summary stats
   version          Show CLI version
 
@@ -107,12 +99,8 @@ Examples:
 		err = handleJobs(client, cmdArgs)
 	case "import":
 		err = handleImport(client, cmdArgs)
-	case "est":
-		err = handleEST(client, cmdArgs)
 	case "status":
 		err = handleStatus(client)
-	case "auth":
-		err = handleAuth(client, cmdArgs)
 	case "version":
 		fmt.Println("certctl-cli version 0.1.0")
 	default:
@@ -146,70 +134,22 @@ func handleCerts(client *cli.Client, args []string) error {
 		}
 		return client.GetCertificate(subArgs[0])
 	case "renew":
-		// 2026-05-05 parity-defaults-cleanup (P3-1): expose --force as an
-		// explicit operator flag instead of the historical hardcoded
-		// `force=false` body field. force=true overrides the server-side
-		// RenewalInProgress block — used to recover stuck in-flight
-		// renewals. Archived/Expired remain terminal regardless.
-		//
-		// CLI convention: `certs renew <id> [--force]` — the ID is a
-		// positional arg that precedes the flags. Mirrors `agents retire
-		// <id>`'s pattern (Go's flag package stops at the first non-flag
-		// token, so we pull subArgs[0] as the ID and hand subArgs[1:] to
-		// the flag parser).
 		if len(subArgs) == 0 {
-			fmt.Fprintf(os.Stderr, "usage: certs renew <id> [--force]\n")
+			fmt.Fprintf(os.Stderr, "usage: certs renew <id>\n")
 			return nil
 		}
-		id := subArgs[0]
-		fs := flag.NewFlagSet("certs renew", flag.ContinueOnError)
-		force := fs.Bool("force", false, "Force renewal even when the cert is currently in RenewalInProgress (clears stuck in-flight renewals; does NOT override Archived/Expired terminal states)")
-		if err := fs.Parse(subArgs[1:]); err != nil {
-			return err
-		}
-		return client.RenewCertificate(id, *force)
+		return client.RenewCertificate(subArgs[0])
 	case "revoke":
-		// 2026-05-05 parity-defaults-cleanup (P3-2, Option A): --reason is
-		// strictly required. Empty reason refuses to dispatch and prints
-		// the RFC 5280 §5.3.1 reason-code menu so operators pick a real
-		// value. The pre-2026-05-05 silent fallback to "unspecified"
-		// defeated compliance reporting (PCI-DSS §3.6, HIPAA §164.312)
-		// because every revocation looked the same in the audit trail.
-		//
-		// CLI convention: `certs revoke <id> --reason <reason>` — same
-		// ID-first ordering as `certs renew`.
 		if len(subArgs) == 0 {
-			fmt.Fprintf(os.Stderr, "usage: certs revoke <id> --reason <reason>\n")
-			fmt.Fprintf(os.Stderr, "\nValid RFC 5280 §5.3.1 reasons:\n")
-			for _, r := range cli.ValidRevokeReasons() {
-				fmt.Fprintf(os.Stderr, "  %s\n", r)
-			}
+			fmt.Fprintf(os.Stderr, "usage: certs revoke <id> [--reason <reason>]\n")
 			return nil
 		}
 		id := subArgs[0]
-		fs := flag.NewFlagSet("certs revoke", flag.ContinueOnError)
-		reason := fs.String("reason", "", "RFC 5280 revocation reason (required). Valid values: keyCompromise, caCompromise, affiliationChanged, superseded, cessationOfOperation, certificateHold, removeFromCRL, privilegeWithdrawn, aaCompromise, unspecified")
-		if err := fs.Parse(subArgs[1:]); err != nil {
-			return err
+		reason := "unspecified"
+		if len(subArgs) > 2 && subArgs[1] == "--reason" {
+			reason = subArgs[2]
 		}
-		if *reason == "" {
-			fmt.Fprintf(os.Stderr, "error: --reason is required (no silent fallback to 'unspecified' — pick a real RFC 5280 §5.3.1 code).\n\n")
-			fmt.Fprintf(os.Stderr, "Valid reasons:\n")
-			for _, r := range cli.ValidRevokeReasons() {
-				fmt.Fprintf(os.Stderr, "  %s\n", r)
-			}
-			return fmt.Errorf("--reason is required")
-		}
-		canonical, ok := cli.NormalizeRevokeReason(*reason)
-		if !ok {
-			fmt.Fprintf(os.Stderr, "error: %q is not a valid RFC 5280 §5.3.1 reason code.\n\n", *reason)
-			fmt.Fprintf(os.Stderr, "Valid reasons (camelCase or snake_case both accepted):\n")
-			for _, r := range cli.ValidRevokeReasons() {
-				fmt.Fprintf(os.Stderr, "  %s\n", r)
-			}
-			return fmt.Errorf("invalid --reason: %q", *reason)
-		}
-		return client.RevokeCertificate(id, canonical)
+		return client.RevokeCertificate(id, reason)
 	case "bulk-revoke":
 		return client.BulkRevokeCertificates(subArgs)
 	default:
@@ -315,35 +255,6 @@ func handleStatus(client *cli.Client) error {
 	return client.GetStatus()
 }
 
-// handleEST dispatches the `est` subcommands. Mirrors the existing
-// handleCerts / handleAgents pattern verbatim. EST RFC 7030 hardening
-// master bundle Phase 9.1.
-func handleEST(client *cli.Client, args []string) error {
-	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, "usage: est <cacerts|csrattrs|enroll|reenroll|serverkeygen|test> [options]\n")
-		return nil
-	}
-	subcommand := args[0]
-	subArgs := args[1:]
-	switch subcommand {
-	case "cacerts":
-		return client.EstCacerts(subArgs)
-	case "csrattrs":
-		return client.EstCsrattrs(subArgs)
-	case "enroll":
-		return client.EstEnroll(subArgs)
-	case "reenroll":
-		return client.EstReEnroll(subArgs)
-	case "serverkeygen":
-		return client.EstServerKeygen(subArgs)
-	case "test":
-		return client.EstTest(subArgs)
-	default:
-		fmt.Fprintf(os.Stderr, "unknown subcommand: est %s\n", subcommand)
-		return nil
-	}
-}
-
 // validateHTTPSScheme rejects plaintext and empty-scheme server URLs at
 // startup so operators get a fail-loud diagnostic before any network call,
 // not a TCP-refused or TLS-handshake-error downstream. See docs/upgrade-to-tls.md.
@@ -366,123 +277,3 @@ func validateHTTPSScheme(serverURL string) error {
 		return fmt.Errorf("server URL %q uses unsupported scheme %q — expected https://", serverURL, u.Scheme)
 	}
 }
-
-// handleAuth dispatches the `certctl-cli auth ...` subcommand tree.
-// Bundle 1 Phase 5: ships read + grant operations against the
-// /api/v1/auth/* surface introduced in Phase 4. Mutations like role
-// create / update / delete can be added in a Phase 5.5 follow-up; this
-// commit ships the operator-facing subset most useful for migration
-// and day-2 scope-down (`auth keys list` + `auth keys assign` +
-// `auth me`).
-func handleAuth(client *cli.Client, args []string) error {
-	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, "usage: auth <roles|permissions|keys|me> [...]\n")
-		return nil
-	}
-	subcommand := args[0]
-	subArgs := args[1:]
-
-	switch subcommand {
-	case "roles":
-		return handleAuthRoles(client, subArgs)
-	case "permissions":
-		return handleAuthPermissions(client, subArgs)
-	case "keys":
-		return handleAuthKeys(client, subArgs)
-	case "me":
-		return client.AuthMe()
-	default:
-		fmt.Fprintf(os.Stderr, "unknown auth subcommand: %s\n", subcommand)
-		return nil
-	}
-}
-
-func handleAuthRoles(client *cli.Client, args []string) error {
-	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, "usage: auth roles <list|get> [id]\n")
-		return nil
-	}
-	switch args[0] {
-	case "list":
-		return client.AuthListRoles()
-	case "get":
-		if len(args) < 2 {
-			fmt.Fprintf(os.Stderr, "usage: auth roles get <id>\n")
-			return nil
-		}
-		return client.AuthGetRole(args[1])
-	default:
-		fmt.Fprintf(os.Stderr, "unknown roles subcommand: %s\n", args[0])
-		return nil
-	}
-}
-
-func handleAuthPermissions(client *cli.Client, args []string) error {
-	if len(args) == 0 || args[0] != "list" {
-		fmt.Fprintf(os.Stderr, "usage: auth permissions list\n")
-		return nil
-	}
-	return client.AuthListPermissions()
-}
-
-func handleAuthKeys(client *cli.Client, args []string) error {
-	if len(args) == 0 {
-		fmt.Fprintf(os.Stderr, "usage: auth keys <list|assign|revoke|scope-down> [...]\n")
-		return nil
-	}
-	switch args[0] {
-	case "list":
-		return client.AuthListKeys()
-	case "assign":
-		// auth keys assign <key-id> --role <role-id>
-		if len(args) < 4 || args[2] != "--role" {
-			fmt.Fprintf(os.Stderr, "usage: auth keys assign <key-id> --role <role-id>\n")
-			return nil
-		}
-		return client.AuthAssignRoleToKey(args[1], args[3])
-	case "revoke":
-		// auth keys revoke <key-id> --role <role-id>
-		if len(args) < 4 || args[2] != "--role" {
-			fmt.Fprintf(os.Stderr, "usage: auth keys revoke <key-id> --role <role-id>\n")
-			return nil
-		}
-		return client.AuthRevokeRoleFromKey(args[1], args[3])
-	case "scope-down":
-		// Bundle 1 Phase 7 — interactive (default), --non-interactive
-		// <config.json>, or --suggest [--apply].
-		return handleAuthKeysScopeDown(client, args[1:])
-	default:
-		fmt.Fprintf(os.Stderr, "unknown keys subcommand: %s\n", args[0])
-		return nil
-	}
-}
-
-// handleAuthKeysScopeDown dispatches the three scope-down modes:
-//
-//	auth keys scope-down                              → interactive
-//	auth keys scope-down --non-interactive <config>   → JSON-driven
-//	auth keys scope-down --suggest [--apply]          → audit-driven suggestions
-func handleAuthKeysScopeDown(client *cli.Client, args []string) error {
-	if len(args) == 0 {
-		return client.AuthScopeDown()
-	}
-	switch args[0] {
-	case "--non-interactive":
-		if len(args) < 2 {
-			fmt.Fprintf(os.Stderr, "usage: auth keys scope-down --non-interactive <config.json>\n")
-			return nil
-		}
-		return client.AuthScopeDownNonInteractive(args[1])
-	case "--suggest":
-		apply := false
-		for _, a := range args[1:] {
-			if a == "--apply" {
-				apply = true
-			}
-		}
-		return client.AuthScopeDownSuggest(apply)
-	default:
-		fmt.Fprintf(os.Stderr, "unknown scope-down flag: %s\n", args[0])
-		return nil
-	}
-}

cmd/cli/main_test.go

@@ -53,9 +53,9 @@ func TestValidateHTTPSScheme(t *testing.T) {
 			wantErrSub: "plaintext http://",
 		},
 		{
-			name:      "bare host missing scheme rejected",
-			serverURL: "localhost:8443",
-			wantErr:   true,
+			name:       "bare host missing scheme rejected",
+			serverURL:  "localhost:8443",
+			wantErr:    true,
 			// url.Parse treats "localhost:8443" as scheme=localhost, opaque=8443
 			// — exercises the default arm (unsupported scheme) rather than the
 			// empty-scheme arm. Both are fail-closed, which is what we care about.

cmd/mcp-server/main.go

@@ -11,7 +11,7 @@ import (
 
 	gomcp "github.com/modelcontextprotocol/go-sdk/mcp"
 
-	"github.com/certctl-io/certctl/internal/mcp"
+	"github.com/shankar0123/certctl/internal/mcp"
 )
 
 // Version is set at build time via -ldflags.

cmd/mcp-server/main_test.go

@@ -47,9 +47,9 @@ func TestValidateHTTPSScheme(t *testing.T) {
 			wantErrSub: "plaintext http://",
 		},
 		{
-			name:      "bare host missing scheme rejected",
-			serverURL: "localhost:8443",
-			wantErr:   true,
+			name:       "bare host missing scheme rejected",
+			serverURL:  "localhost:8443",
+			wantErr:    true,
 			// url.Parse treats "localhost:8443" as scheme=localhost, opaque=8443
 			// — exercises the default arm (unsupported scheme) rather than the
 			// empty-scheme arm. Both are fail-closed, which is what we care about.

cmd/server/auth_backfill.go

@@ -1,105 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-	"strings"
-
-	"github.com/certctl-io/certctl/internal/auth"
-	"github.com/certctl-io/certctl/internal/config"
-	"github.com/certctl-io/certctl/internal/domain"
-	authdomain "github.com/certctl-io/certctl/internal/domain/auth"
-)
-
-// assembleNamedAPIKeys translates the operator's CERTCTL_API_KEYS_NAMED
-// env-var (preferred) or CERTCTL_AUTH_SECRET (legacy) into the
-// auth.NamedAPIKey slice the rest of the boot path consumes.
-//
-// Authentication unification (M-002): every authenticated request now
-// carries a named actor in the request context so audit events record
-// the real key identity instead of the hardcoded "api-key-user"
-// string. Named keys come from CERTCTL_API_KEYS_NAMED (preferred). For
-// backward compatibility CERTCTL_AUTH_SECRET is synthesized into
-// legacy-key-N entries with Admin=false.
-func assembleNamedAPIKeys(cfg *config.Config, logger *slog.Logger) []auth.NamedAPIKey {
-	if config.AuthType(cfg.Auth.Type) == config.AuthTypeNone {
-		return nil
-	}
-	var out []auth.NamedAPIKey
-	for _, nk := range cfg.Auth.NamedKeys {
-		out = append(out, auth.NamedAPIKey{
-			Name:  nk.Name,
-			Key:   nk.Key,
-			Admin: nk.Admin,
-		})
-	}
-	if len(out) == 0 && cfg.Auth.Secret != "" {
-		idx := 0
-		for _, p := range strings.Split(cfg.Auth.Secret, ",") {
-			p = strings.TrimSpace(p)
-			if p == "" {
-				continue
-			}
-			out = append(out, auth.NamedAPIKey{
-				Name:  fmt.Sprintf("legacy-key-%d", idx),
-				Key:   p,
-				Admin: false,
-			})
-			idx++
-		}
-		if len(out) > 0 && logger != nil {
-			logger.Warn("CERTCTL_AUTH_SECRET is deprecated — set CERTCTL_API_KEYS_NAMED for named actor attribution and admin gating",
-				"synthesized_keys", len(out))
-		}
-	}
-	return out
-}
-
-// actorRoleGranter is the narrow interface backfillNamedKeyActorRoles
-// needs from the postgres ActorRoleRepository. Pulled out so the unit
-// test can inject a fake without spinning up the full repo / DB.
-type actorRoleGranter interface {
-	Grant(ctx context.Context, ar *authdomain.ActorRole) error
-}
-
-// backfillNamedKeyActorRoles is the Bundle 1 Phase 3 closure (C2)
-// startup hook that ensures every CERTCTL_API_KEYS_NAMED entry — and
-// every legacy CERTCTL_AUTH_SECRET synthesized fallback — has an
-// actor_roles row before the HTTP server accepts requests. Admin-flagged
-// keys grant `r-admin` (full canonical permission set); non-admin keys
-// grant `r-viewer` (read-only surface), matching the pre-Phase-3.5
-// capability shape.
-//
-// Idempotent via ON CONFLICT DO NOTHING in the repo Grant — reboots
-// don't create duplicates. Failures are logged but non-fatal: the server
-// still starts, and the operator can fix the grant via the RBAC API.
-//
-// The function is package-private + extracted from main() so the unit
-// test in auth_backfill_test.go can pin the role-mapping invariant
-// without depending on the full server bootstrap path.
-func backfillNamedKeyActorRoles(
-	ctx context.Context,
-	repo actorRoleGranter,
-	keys []auth.NamedAPIKey,
-	logger *slog.Logger,
-) {
-	for _, nk := range keys {
-		role := authdomain.RoleIDViewer
-		if nk.Admin {
-			role = authdomain.RoleIDAdmin
-		}
-		if err := repo.Grant(ctx, &authdomain.ActorRole{
-			ActorID:   nk.Name,
-			ActorType: authdomain.ActorTypeValue(domain.ActorTypeAPIKey),
-			RoleID:    role,
-			TenantID:  authdomain.DefaultTenantID,
-			GrantedBy: "bootstrap",
-		}); err != nil {
-			if logger != nil {
-				logger.Warn("api-key actor-role backfill failed; key authenticates but RBAC routes will 403 until grant is added via /v1/auth/keys",
-					"key", nk.Name, "role", role, "err", err)
-			}
-		}
-	}
-}

cmd/server/auth_backfill_test.go

@@ -1,116 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"io"
-	"log/slog"
-	"testing"
-
-	"github.com/certctl-io/certctl/internal/auth"
-	authdomain "github.com/certctl-io/certctl/internal/domain/auth"
-)
-
-// fakeGranter is a tiny in-memory stand-in for the postgres ActorRoleRepository
-// — enough surface area for backfillNamedKeyActorRoles to call Grant against.
-type fakeGranter struct {
-	calls []*authdomain.ActorRole
-	err   error
-}
-
-func (f *fakeGranter) Grant(_ context.Context, ar *authdomain.ActorRole) error {
-	f.calls = append(f.calls, ar)
-	return f.err
-}
-
-// TestBackfillNamedKeyActorRoles_RoleMapping pins the Bundle 1 Phase 3
-// closure (C2) invariant: admin-flagged named keys grant r-admin,
-// non-admin keys grant r-viewer, both at TenantID t-default with
-// ActorType APIKey and GrantedBy=bootstrap.
-func TestBackfillNamedKeyActorRoles_RoleMapping(t *testing.T) {
-	repo := &fakeGranter{}
-	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-
-	keys := []auth.NamedAPIKey{
-		{Name: "alice-admin", Key: "AAA", Admin: true},
-		{Name: "bob-viewer", Key: "BBB", Admin: false},
-		{Name: "carol-admin", Key: "CCC", Admin: true},
-	}
-	backfillNamedKeyActorRoles(context.Background(), repo, keys, logger)
-
-	if len(repo.calls) != 3 {
-		t.Fatalf("Grant call count = %d, want 3", len(repo.calls))
-	}
-	type want struct {
-		actor, role string
-	}
-	wants := []want{
-		{actor: "alice-admin", role: authdomain.RoleIDAdmin},
-		{actor: "bob-viewer", role: authdomain.RoleIDViewer},
-		{actor: "carol-admin", role: authdomain.RoleIDAdmin},
-	}
-	for i, w := range wants {
-		got := repo.calls[i]
-		if got.ActorID != w.actor {
-			t.Errorf("call[%d].ActorID = %q, want %q", i, got.ActorID, w.actor)
-		}
-		if got.RoleID != w.role {
-			t.Errorf("call[%d].RoleID = %q, want %q", i, got.RoleID, w.role)
-		}
-		if got.TenantID != authdomain.DefaultTenantID {
-			t.Errorf("call[%d].TenantID = %q, want %q", i, got.TenantID, authdomain.DefaultTenantID)
-		}
-		if string(got.ActorType) != "APIKey" {
-			t.Errorf("call[%d].ActorType = %q, want APIKey", i, got.ActorType)
-		}
-		if got.GrantedBy != "bootstrap" {
-			t.Errorf("call[%d].GrantedBy = %q, want bootstrap", i, got.GrantedBy)
-		}
-	}
-}
-
-// TestBackfillNamedKeyActorRoles_EmptyKeysIsNoOp confirms the boot path
-// is safe when no named keys are configured (typical CERTCTL_AUTH_TYPE=
-// none deploy). No Grant calls; no panic.
-func TestBackfillNamedKeyActorRoles_EmptyKeysIsNoOp(t *testing.T) {
-	repo := &fakeGranter{}
-	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-	backfillNamedKeyActorRoles(context.Background(), repo, nil, logger)
-	if len(repo.calls) != 0 {
-		t.Errorf("Grant called %d times for empty keys, want 0", len(repo.calls))
-	}
-}
-
-// TestBackfillNamedKeyActorRoles_GrantErrorIsNonFatal confirms the
-// closure invariant that a Grant failure logs a warning and proceeds
-// rather than crashing the server during boot. Subsequent keys still
-// get processed.
-func TestBackfillNamedKeyActorRoles_GrantErrorIsNonFatal(t *testing.T) {
-	repo := &fakeGranter{err: errors.New("simulated DB error")}
-	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
-
-	keys := []auth.NamedAPIKey{
-		{Name: "alice", Key: "A", Admin: true},
-		{Name: "bob", Key: "B", Admin: false},
-	}
-	// Should not panic.
-	backfillNamedKeyActorRoles(context.Background(), repo, keys, logger)
-
-	if len(repo.calls) != 2 {
-		t.Errorf("Grant calls = %d, want 2 (every key processed even when prior Grant errored)", len(repo.calls))
-	}
-}
-
-// TestBackfillNamedKeyActorRoles_NilLoggerIsSafe pins that callers
-// passing nil for the logger don't NPE the goroutine. Belt-and-braces
-// for tests + future call sites that may not have a logger plumbed.
-func TestBackfillNamedKeyActorRoles_NilLoggerIsSafe(t *testing.T) {
-	repo := &fakeGranter{err: errors.New("simulated")}
-	keys := []auth.NamedAPIKey{
-		{Name: "alice", Key: "A", Admin: true},
-	}
-	backfillNamedKeyActorRoles(context.Background(), repo, keys, nil)
-	if len(repo.calls) != 1 {
-		t.Errorf("Grant calls = %d, want 1", len(repo.calls))
-	}
-}

cmd/server/auth_exempt_test.go

@@ -1,117 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/certctl-io/certctl/internal/api/router"
-)
-
-// Bundle B / Audit M-002 (CWE-862): pin the dispatch-layer auth-exempt
-// allowlist. cmd/server/main.go::buildFinalHandler decides per-request
-// whether a path goes through the authenticated apiHandler or the
-// no-auth handler. This test:
-//
-//   - constructs a buildFinalHandler with two sentinel handlers (one
-//     for "auth", one for "no-auth") so we can observe which path is
-//     taken from the response body.
-//   - probes every prefix listed in router.AuthExemptDispatchPrefixes
-//     and confirms it routes to no-auth.
-//   - probes a few representative authenticated routes and confirms
-//     they route to auth.
-//   - probes the static-route allowlist (/health, /ready, etc.) that
-//     also bypasses auth at this layer.
-//
-// Adding a new auth-bypass to buildFinalHandler without updating the
-// router.AuthExemptDispatchPrefixes constant fails this test.
-
-func TestBuildFinalHandler_AuthExemptDispatchAllowlist(t *testing.T) {
-	apiHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte("AUTH"))
-	})
-	noAuthHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte("NOAUTH"))
-	})
-
-	// dashboardEnabled=false keeps the dispatch logic deterministic — no
-	// fileServer fallback to muddy the result.
-	final := buildFinalHandler(apiHandler, noAuthHandler, "/nonexistent", false)
-
-	cases := []struct {
-		name string
-		path string
-		want string
-	}{
-		// AuthExemptRouterRoutes (also enforced at this layer)
-		{"health", "/health", "NOAUTH"},
-		{"ready", "/ready", "NOAUTH"},
-		{"auth_info", "/api/v1/auth/info", "NOAUTH"},
-		{"version", "/api/v1/version", "NOAUTH"},
-
-		// AuthExemptDispatchPrefixes — every documented prefix
-		{"pki_crl", "/.well-known/pki/crl", "NOAUTH"},
-		{"pki_ocsp", "/.well-known/pki/ocsp", "NOAUTH"},
-		{"est_simpleenroll", "/.well-known/est/simpleenroll", "NOAUTH"},
-		{"est_cacerts", "/.well-known/est/cacerts", "NOAUTH"},
-		{"scep_root", "/scep", "NOAUTH"},
-		{"scep_op", "/scep/pkiclient.exe", "NOAUTH"},
-
-		// Authenticated routes — must hit apiHandler
-		{"certs_list", "/api/v1/certificates", "AUTH"},
-		{"agents_list", "/api/v1/agents", "AUTH"},
-		{"audit_check", "/api/v1/auth/check", "AUTH"},
-
-		// Random non-API path — falls through to apiHandler when
-		// dashboard disabled (preserves pre-M-001 API-only behavior).
-		{"unknown", "/some-other-path", "AUTH"},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			req := httptest.NewRequest(http.MethodGet, tc.path, nil)
-			rec := httptest.NewRecorder()
-			final.ServeHTTP(rec, req)
-			got := rec.Body.String()
-			if got != tc.want {
-				t.Errorf("path %q routed to %q; want %q (this is the M-002 dispatch-layer pin)", tc.path, got, tc.want)
-			}
-		})
-	}
-}
-
-// TestDispatch_NoUndocumentedBypasses asserts that for every prefix the
-// dispatch layer routes to noAuthHandler, that prefix appears in the
-// router.AuthExemptDispatchPrefixes constant. This is the inverse pin —
-// adding a new bypass to buildFinalHandler without updating the constant
-// fails this test.
-//
-// We probe a curated set of "would-be-bypasses" derived from the actual
-// dispatch source by reading buildFinalHandler's lines. If the dispatch
-// logic adds a new prefix that ends up in the no-auth chain, the
-// curated set must be extended in the same commit that updates the
-// constant — this fails-loud rather than silently allowing a bypass.
-func TestDispatch_NoUndocumentedBypasses(t *testing.T) {
-	for _, prefix := range router.AuthExemptDispatchPrefixes {
-		if !strings.HasPrefix(prefix, "/") {
-			t.Errorf("AuthExemptDispatchPrefixes entry %q must start with / for prefix matching", prefix)
-		}
-	}
-	// Every entry in router.AuthExemptDispatchPrefixes must round-trip
-	// through buildFinalHandler to noAuthHandler (covered by the table
-	// test above). This test additionally asserts the inverse: known
-	// authenticated prefixes do NOT match any documented bypass prefix.
-	authenticatedPrefixes := []string{
-		"/api/v1/certificates",
-		"/api/v1/agents",
-		"/api/v1/audit",
-	}
-	for _, ap := range authenticatedPrefixes {
-		for _, bypass := range router.AuthExemptDispatchPrefixes {
-			if strings.HasPrefix(ap, bypass) {
-				t.Errorf("authenticated prefix %q overlaps with documented bypass %q — auth bypass risk", ap, bypass)
-			}
-		}
-	}
-}

cmd/server/main_test.go

@@ -10,11 +10,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/certctl-io/certctl/internal/api/middleware"
-	"github.com/certctl-io/certctl/internal/api/router"
-	"github.com/certctl-io/certctl/internal/auth"
-	"github.com/certctl-io/certctl/internal/config"
-	"github.com/certctl-io/certctl/internal/service"
+	"github.com/shankar0123/certctl/internal/api/middleware"
+	"github.com/shankar0123/certctl/internal/api/router"
+	"github.com/shankar0123/certctl/internal/config"
+	"github.com/shankar0123/certctl/internal/service"
 )
 
 // TestMain_HealthEndpointBypassesAuth verifies that health check endpoints
@@ -45,8 +44,9 @@ func TestMain_HealthEndpointBypassesAuth(t *testing.T) {
 	})
 
 	// Build the handler chain the same way main.go does
-	authMiddleware := auth.NewAuthWithNamedKeys([]auth.NamedAPIKey{
-		{Name: "test", Key: "test-secret-key"},
+	authMiddleware := middleware.NewAuth(middleware.AuthConfig{
+		Type:   "api-key",
+		Secret: "test-secret-key",
 	})
 
 	// API handler with auth
@@ -160,8 +160,9 @@ func TestMain_AuthMiddlewareRejectsUnauthorized(t *testing.T) {
 	})
 
 	// Wrap with auth middleware
-	authMiddleware := auth.NewAuthWithNamedKeys([]auth.NamedAPIKey{
-		{Name: "test", Key: "test-secret-key"},
+	authMiddleware := middleware.NewAuth(middleware.AuthConfig{
+		Type:   "api-key",
+		Secret: "test-secret-key",
 	})
 
 	chainedHandler := middleware.Chain(protectedHandler, authMiddleware)
@@ -188,8 +189,9 @@ func TestMain_AuthMiddlewareAllowsWithValidKey(t *testing.T) {
 	})
 
 	// Wrap with auth middleware
-	authMiddleware := auth.NewAuthWithNamedKeys([]auth.NamedAPIKey{
-		{Name: "test", Key: testKey},
+	authMiddleware := middleware.NewAuth(middleware.AuthConfig{
+		Type:   "api-key",
+		Secret: testKey,
 	})
 
 	chainedHandler := middleware.Chain(protectedHandler, authMiddleware)
@@ -460,8 +462,9 @@ func TestMain_AuthNoneMode(t *testing.T) {
 	})
 
 	// Wrap with auth middleware in "none" mode
-	// auth=none equivalent: empty named-keys list is a no-op pass-through.
-	authMiddleware := auth.NewAuthWithNamedKeys(nil)
+	authMiddleware := middleware.NewAuth(middleware.AuthConfig{
+		Type: "none",
+	})
 
 	chainedHandler := middleware.Chain(protectedHandler, authMiddleware)
 

cmd/server/preflight_scep_intune_test.go

@@ -1,156 +0,0 @@
-package main
-
-import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"io"
-	"log/slog"
-	"math/big"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-)
-
-// SCEP RFC 8894 + Intune master prompt §13 line 1853 acceptance —
-// boot regression tests for preflightSCEPIntuneTrustAnchor. Closed in
-// the 2026-04-29 audit-closure bundle (Phase F).
-//
-// Spec text:
-//   "clean boot with Intune disabled (backward compat)" and
-//   "refuses-to-start with broken per-profile config (PathID logged)."
-//
-// These three tests exercise the function the cmd/server/main.go boot
-// loop calls per profile. We can't (and don't want to) run main()
-// itself in a unit test — that would require docker compose + a real
-// listener. Instead we drive the function directly and assert its
-// contract holds: nil error on disabled, structured error containing
-// the PathID on enabled-but-broken.
-
-func discardLogger() *slog.Logger {
-	return slog.New(slog.NewTextHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelError + 10}))
-}
-
-// TestPreflightSCEPIntuneTrustAnchor_DisabledIsBackwardCompat — when
-// the profile has Intune disabled, preflight returns (nil, nil) and
-// MUST NOT touch the filesystem. This is the dominant path in
-// production: most operators run SCEP without Intune. A regression
-// here would make every non-Intune deploy fail boot with a confusing
-// "trust anchor missing" error.
-func TestPreflightSCEPIntuneTrustAnchor_DisabledIsBackwardCompat(t *testing.T) {
-	holder, err := preflightSCEPIntuneTrustAnchor(false, "corp", "", discardLogger())
-	if err != nil {
-		t.Fatalf("disabled preflight should be a no-op, got error: %v", err)
-	}
-	if holder != nil {
-		t.Errorf("disabled preflight should return nil holder, got %#v", holder)
-	}
-
-	// Confirm the no-touch contract: even if PathID + path are both
-	// non-empty, disabled=false short-circuits before any I/O. Pass a
-	// path that doesn't exist — the call MUST still succeed.
-	holder, err = preflightSCEPIntuneTrustAnchor(false, "iot", "/tmp/this-file-does-not-exist-12345.pem", discardLogger())
-	if err != nil {
-		t.Fatalf("disabled preflight with non-existent path should still succeed: %v", err)
-	}
-	if holder != nil {
-		t.Error("disabled preflight should return nil holder even with non-existent path")
-	}
-}
-
-// TestPreflightSCEPIntuneTrustAnchor_BrokenConfigRefusesWithPathID —
-// when the profile has Intune enabled but the trust-anchor file
-// doesn't exist, preflight returns an error whose text contains the
-// literal PathID. Operators grep their boot log for the PathID to
-// triage which profile is broken in a multi-profile deploy.
-func TestPreflightSCEPIntuneTrustAnchor_BrokenConfigRefusesWithPathID(t *testing.T) {
-	missingPath := filepath.Join(t.TempDir(), "this-trust-anchor-was-never-written.pem")
-	holder, err := preflightSCEPIntuneTrustAnchor(true, "corp", missingPath, discardLogger())
-	if err == nil {
-		t.Fatal("expected error when trust anchor file is missing, got nil")
-	}
-	if holder != nil {
-		t.Errorf("expected nil holder on broken config, got %#v", holder)
-	}
-	if !strings.Contains(err.Error(), `PathID="corp"`) {
-		t.Errorf("error should contain PathID for operator log-grep: %v", err)
-	}
-	if !strings.Contains(err.Error(), missingPath) {
-		t.Errorf("error should contain the path for operator log-grep: %v", err)
-	}
-
-	// Empty PathID (legacy /scep root) — the error MUST surface a
-	// readable label, not an empty quoted string that looks like a
-	// missing variable.
-	_, err = preflightSCEPIntuneTrustAnchor(true, "", missingPath, discardLogger())
-	if err == nil {
-		t.Fatal("expected error on broken legacy-root config")
-	}
-	if !strings.Contains(err.Error(), `PathID="<root>"`) {
-		t.Errorf("error should label empty PathID as <root>: %v", err)
-	}
-
-	// Empty path with enabled=true — distinct error path (path-empty
-	// vs file-missing). Spec requires this branch ALSO surfaces the
-	// PathID so the operator's grep narrows to the profile.
-	_, err = preflightSCEPIntuneTrustAnchor(true, "iot", "", discardLogger())
-	if err == nil {
-		t.Fatal("expected error when trust anchor path is empty")
-	}
-	if !strings.Contains(err.Error(), `PathID="iot"`) {
-		t.Errorf("empty-path error should contain PathID for operator log-grep: %v", err)
-	}
-}
-
-// TestPreflightSCEPIntuneTrustAnchor_ExpiredTrustAnchorRefuses — an
-// expired Connector signing cert in the trust anchor file is the
-// silent-failure mode this preflight is built to catch. Without the
-// gate, the SCEP server boots cleanly and then rejects every Intune
-// enrollment at runtime with "no trust anchor recognizes this
-// signature" — confusing for the operator whose Connector is healthy
-// (the cert just expired without rotation). Pin the contract: the
-// boot MUST refuse with an error that names the expired cert's
-// subject CN so the operator knows what to rotate.
-func TestPreflightSCEPIntuneTrustAnchor_ExpiredTrustAnchorRefuses(t *testing.T) {
-	// Build a deterministic ECDSA cert with NotAfter 1 hour in the past.
-	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		t.Fatalf("ecdsa.GenerateKey: %v", err)
-	}
-	now := time.Now()
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject:      pkix.Name{CommonName: "intune-connector-rotated-must-replace"},
-		NotBefore:    now.Add(-2 * time.Hour),
-		NotAfter:     now.Add(-1 * time.Hour), // expired
-		KeyUsage:     x509.KeyUsageDigitalSignature,
-	}
-	der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
-	if err != nil {
-		t.Fatalf("CreateCertificate: %v", err)
-	}
-
-	bundlePath := filepath.Join(t.TempDir(), "intune-expired.pem")
-	if err := os.WriteFile(bundlePath, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}), 0o600); err != nil {
-		t.Fatalf("write expired cert: %v", err)
-	}
-
-	holder, err := preflightSCEPIntuneTrustAnchor(true, "corp-expired", bundlePath, discardLogger())
-	if err == nil {
-		t.Fatal("expected refuse-to-start on expired trust anchor cert, got nil error")
-	}
-	if holder != nil {
-		t.Errorf("expected nil holder on expired-cert refusal, got %#v", holder)
-	}
-	if !strings.Contains(err.Error(), `PathID="corp-expired"`) {
-		t.Errorf("error should contain PathID for operator log-grep: %v", err)
-	}
-	if !strings.Contains(err.Error(), "intune-connector-rotated-must-replace") {
-		t.Errorf("error should contain the expired cert's subject CN so the operator knows what to rotate: %v", err)
-	}
-}

cmd/server/preflight_scep_ra_test.go

@@ -1,227 +0,0 @@
-package main
-
-import (
-	"crypto/ecdsa"
-	"crypto/ed25519"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"math/big"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-)
-
-// SCEP RFC 8894 Phase 1: preflightSCEPRACertKey covers the six failure
-// modes spelled out in the helper's docblock plus the no-op-when-disabled
-// path. Mirrors TestPreflightEnrollmentIssuer's table-driven shape so the
-// suite stays uniform for the next reviewer.
-//
-// Each test materialises a real ECDSA P-256 cert/key pair on disk (rather
-// than mocking) so the tls.X509KeyPair path is exercised end-to-end —
-// catches drift in stdlib cert-parsing semantics that a mock would hide.
-
-func TestPreflightSCEPRACertKey_Disabled_NoOp(t *testing.T) {
-	// Enabled=false short-circuits before any path validation; should pass
-	// even with empty paths (mirrors preflightSCEPChallengePassword).
-	if err := preflightSCEPRACertKey(false, "", ""); err != nil {
-		t.Fatalf("disabled SCEP returned error: %v", err)
-	}
-}
-
-func TestPreflightSCEPRACertKey_EnabledMissingPaths_Refuses(t *testing.T) {
-	// Validate() also catches this; preflight reports the specific failure
-	// with a more actionable error string + os.Exit(1) at the call site.
-	cases := []struct {
-		name     string
-		certPath string
-		keyPath  string
-	}{
-		{"both_empty", "", ""},
-		{"cert_only", "/tmp/ra.crt", ""},
-		{"key_only", "", "/tmp/ra.key"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := preflightSCEPRACertKey(true, tc.certPath, tc.keyPath)
-			if err == nil {
-				t.Fatalf("expected error for missing paths, got nil")
-			}
-			if !strings.Contains(err.Error(), "RA pair missing") {
-				t.Errorf("error should mention RA pair missing, got: %v", err)
-			}
-		})
-	}
-}
-
-func TestPreflightSCEPRACertKey_KeyWorldReadable_Refuses(t *testing.T) {
-	// Defense-in-depth: even a perfectly-valid RA pair must be rejected if
-	// the key file is mode 0644 (world-readable). The deploy convention is
-	// 0600 — owner read/write only.
-	dir := t.TempDir()
-	certPath, keyPath := writeECDSARAPair(t, dir, time.Now().Add(30*24*time.Hour))
-	// Re-chmod the key to 0644 to trigger the gate.
-	if err := os.Chmod(keyPath, 0o644); err != nil {
-		t.Fatalf("chmod failed: %v", err)
-	}
-	err := preflightSCEPRACertKey(true, certPath, keyPath)
-	if err == nil {
-		t.Fatalf("expected error for world-readable key, got nil")
-	}
-	if !strings.Contains(err.Error(), "insecure permissions") {
-		t.Errorf("error should mention insecure permissions, got: %v", err)
-	}
-}
-
-func TestPreflightSCEPRACertKey_ValidPair_Accepts(t *testing.T) {
-	dir := t.TempDir()
-	certPath, keyPath := writeECDSARAPair(t, dir, time.Now().Add(30*24*time.Hour))
-	if err := preflightSCEPRACertKey(true, certPath, keyPath); err != nil {
-		t.Fatalf("valid RA pair rejected: %v", err)
-	}
-}
-
-func TestPreflightSCEPRACertKey_ExpiredCert_Refuses(t *testing.T) {
-	// An RA cert past NotAfter would cause every conformant SCEP client to
-	// reject the CertRep signature. Catch it at startup.
-	dir := t.TempDir()
-	certPath, keyPath := writeECDSARAPair(t, dir, time.Now().Add(-1*time.Hour))
-	err := preflightSCEPRACertKey(true, certPath, keyPath)
-	if err == nil {
-		t.Fatalf("expected error for expired cert, got nil")
-	}
-	if !strings.Contains(err.Error(), "expired") {
-		t.Errorf("error should mention expired, got: %v", err)
-	}
-}
-
-func TestPreflightSCEPRACertKey_MismatchedPair_Refuses(t *testing.T) {
-	// tls.X509KeyPair detects the cert/key mismatch; preflight should
-	// surface it with an actionable error (cert + key are halves of
-	// different RA pairs — common multi-profile typo).
-	dir := t.TempDir()
-	certPath, _ := writeECDSARAPair(t, dir, time.Now().Add(30*24*time.Hour))
-	_, keyPath := writeECDSARAPair(t, dir, time.Now().Add(30*24*time.Hour))
-	// Re-write the key path under a unique name to avoid collision with
-	// the first pair's file (writeECDSARAPair would have overwritten).
-	err := preflightSCEPRACertKey(true, certPath, keyPath)
-	if err == nil {
-		t.Fatalf("expected error for mismatched pair, got nil")
-	}
-	if !strings.Contains(err.Error(), "invalid") {
-		t.Errorf("error should mention invalid pair, got: %v", err)
-	}
-}
-
-func TestPreflightSCEPRACertKey_MissingFiles_Refuses(t *testing.T) {
-	// Both files referenced but neither exists — a typo or a fresh deploy
-	// where the operator forgot to mount the secret. Cert-path failure mode
-	// is checked first because key-path stat is the first os call after
-	// the empty-string check.
-	dir := t.TempDir()
-	missingCert := filepath.Join(dir, "ra.crt")
-	missingKey := filepath.Join(dir, "ra.key")
-	err := preflightSCEPRACertKey(true, missingCert, missingKey)
-	if err == nil {
-		t.Fatalf("expected error for missing files, got nil")
-	}
-	if !strings.Contains(err.Error(), "stat failed") && !strings.Contains(err.Error(), "read failed") {
-		t.Errorf("error should mention stat/read failure, got: %v", err)
-	}
-}
-
-func TestPreflightSCEPRACertKey_UnsupportedAlg_Refuses(t *testing.T) {
-	// Ed25519 isn't supported by the CMS signature path RFC 8894 §3.5.2
-	// advertises. Catch this at startup to avoid runtime failures the
-	// first time a client sends a real PKIMessage.
-	dir := t.TempDir()
-	certPath := filepath.Join(dir, "ra.crt")
-	keyPath := filepath.Join(dir, "ra.key")
-
-	pub, priv, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		t.Fatalf("ed25519.GenerateKey: %v", err)
-	}
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject:      pkix.Name{CommonName: "ra-ed25519"},
-		NotBefore:    time.Now().Add(-1 * time.Hour),
-		NotAfter:     time.Now().Add(30 * 24 * time.Hour),
-		KeyUsage:     x509.KeyUsageDigitalSignature,
-	}
-	der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, pub, priv)
-	if err != nil {
-		t.Fatalf("CreateCertificate: %v", err)
-	}
-	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
-	keyDER, err := x509.MarshalPKCS8PrivateKey(priv)
-	if err != nil {
-		t.Fatalf("MarshalPKCS8PrivateKey: %v", err)
-	}
-	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: keyDER})
-
-	if err := os.WriteFile(certPath, certPEM, 0o644); err != nil {
-		t.Fatalf("write cert: %v", err)
-	}
-	if err := os.WriteFile(keyPath, keyPEM, 0o600); err != nil {
-		t.Fatalf("write key: %v", err)
-	}
-
-	err = preflightSCEPRACertKey(true, certPath, keyPath)
-	if err == nil {
-		t.Fatalf("expected error for ed25519 RA cert, got nil")
-	}
-	if !strings.Contains(err.Error(), "unsupported public-key algorithm") &&
-		!strings.Contains(err.Error(), "invalid") {
-		// tls.X509KeyPair may reject ed25519 SCEP-signing keys earlier
-		// than our explicit alg gate; accept either failure path so the
-		// test is robust against stdlib changes.
-		t.Errorf("error should mention algorithm/invalid, got: %v", err)
-	}
-}
-
-// writeECDSARAPair generates a fresh ECDSA P-256 self-signed cert + key,
-// writes them to dir/ra-<rand>.crt + ra-<rand>.key with the cert at 0644
-// and the key at 0600 (the production deploy mode). Returns the two paths.
-func writeECDSARAPair(t *testing.T, dir string, notAfter time.Time) (certPath, keyPath string) {
-	t.Helper()
-	priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		t.Fatalf("ecdsa.GenerateKey: %v", err)
-	}
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(time.Now().UnixNano()),
-		Subject:      pkix.Name{CommonName: "ra-test"},
-		NotBefore:    time.Now().Add(-1 * time.Hour),
-		NotAfter:     notAfter,
-		KeyUsage:     x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageEmailProtection},
-	}
-	der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &priv.PublicKey, priv)
-	if err != nil {
-		t.Fatalf("CreateCertificate: %v", err)
-	}
-	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
-	keyDER, err := x509.MarshalPKCS8PrivateKey(priv)
-	if err != nil {
-		t.Fatalf("MarshalPKCS8PrivateKey: %v", err)
-	}
-	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: keyDER})
-
-	// Use a unique suffix so successive calls within the same test don't
-	// overwrite each other (the mismatched-pair test relies on this).
-	suffix := tmpl.SerialNumber.String()
-	certPath = filepath.Join(dir, "ra-"+suffix+".crt")
-	keyPath = filepath.Join(dir, "ra-"+suffix+".key")
-	if err := os.WriteFile(certPath, certPEM, 0o644); err != nil {
-		t.Fatalf("write cert: %v", err)
-	}
-	if err := os.WriteFile(keyPath, keyPEM, 0o600); err != nil {
-		t.Fatalf("write key: %v", err)
-	}
-	return certPath, keyPath
-}

cmd/server/preflight_test.go

@@ -1,100 +0,0 @@
-package main
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/certctl-io/certctl/internal/service"
-)
-
-// fakeIssuerConn implements service.IssuerConnector enough for preflight tests.
-type fakeIssuerConn struct {
-	caCertPEM string
-	caCertErr error
-}
-
-func (f *fakeIssuerConn) IssueCertificate(ctx context.Context, commonName string, sans []string, csrPEM string, ekus []string, maxTTLSeconds int, mustStaple bool) (*service.IssuanceResult, error) {
-	return nil, nil
-}
-func (f *fakeIssuerConn) RenewCertificate(ctx context.Context, commonName string, sans []string, csrPEM string, ekus []string, maxTTLSeconds int, mustStaple bool) (*service.IssuanceResult, error) {
-	return nil, nil
-}
-func (f *fakeIssuerConn) RevokeCertificate(ctx context.Context, serial string, reason string) error {
-	return nil
-}
-func (f *fakeIssuerConn) GenerateCRL(ctx context.Context, revokedCerts []service.CRLEntry) ([]byte, error) {
-	return nil, nil
-}
-func (f *fakeIssuerConn) SignOCSPResponse(ctx context.Context, req service.OCSPSignRequest) ([]byte, error) {
-	return nil, nil
-}
-func (f *fakeIssuerConn) GetCACertPEM(ctx context.Context) (string, error) {
-	return f.caCertPEM, f.caCertErr
-}
-func (f *fakeIssuerConn) GetRenewalInfo(ctx context.Context, certPEM string) (*service.RenewalInfoResult, error) {
-	return nil, nil
-}
-
-// TestPreflightEnrollmentIssuer covers Bundle-4 / L-005 startup validation
-// for EST/SCEP issuer binding.
-func TestPreflightEnrollmentIssuer(t *testing.T) {
-	cases := []struct {
-		name        string
-		issuer      service.IssuerConnector
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "nil_connector_fails",
-			issuer:      nil,
-			wantErr:     true,
-			errContains: "connector is nil",
-		},
-		{
-			name: "issuer_returns_error_fails",
-			issuer: &fakeIssuerConn{
-				caCertErr: errStub("ACME issuers do not provide a static CA certificate"),
-			},
-			wantErr:     true,
-			errContains: "cannot serve CA certificate",
-		},
-		{
-			name: "issuer_returns_empty_pem_fails",
-			issuer: &fakeIssuerConn{
-				caCertPEM: "",
-				caCertErr: nil,
-			},
-			wantErr:     true,
-			errContains: "empty PEM",
-		},
-		{
-			name: "issuer_returns_valid_pem_succeeds",
-			issuer: &fakeIssuerConn{
-				caCertPEM: "-----BEGIN CERTIFICATE-----\nMIIB...\n-----END CERTIFICATE-----",
-				caCertErr: nil,
-			},
-			wantErr: false,
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			err := preflightEnrollmentIssuer(context.Background(), "EST", "iss-test", tc.issuer)
-			if tc.wantErr && err == nil {
-				t.Fatalf("expected error, got nil")
-			}
-			if !tc.wantErr && err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if tc.wantErr && tc.errContains != "" && !strings.Contains(err.Error(), tc.errContains) {
-				t.Fatalf("error %q missing substring %q", err.Error(), tc.errContains)
-			}
-		})
-	}
-}
-
-// errStub is a tiny error wrapper so test cases can use string literals
-// without importing fmt in every test struct entry.
-type errStub string
-
-func (e errStub) Error() string { return string(e) }

cmd/server/tls.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"crypto/tls"
-	"crypto/x509"
 	"fmt"
 	"log/slog"
 	"os"
@@ -135,37 +134,6 @@ func buildServerTLSConfig(holder *certHolder) *tls.Config {
 	}
 }
 
-// buildServerTLSConfigWithMTLS extends buildServerTLSConfig with a client-cert
-// trust pool for the SCEP/EST mTLS sibling routes.
-//
-// SCEP RFC 8894 + Intune master bundle Phase 6.5 introduced this for the
-// /scep-mtls/<pathID> route; EST RFC 7030 hardening master bundle Phase 2
-// extended it so the same TLS listener also serves /.well-known/est-mtls/
-// <pathID>. Both protocols' mTLS profiles contribute their trust bundles
-// to a UNION pool that the caller (cmd/server/main.go) builds by walking
-// every enabled mTLS profile's bundle bytes once. The per-protocol
-// handlers re-verify against just THIS profile's bundle (so an EST-mTLS
-// bootstrap cert can't enroll against a SCEP-mTLS profile and vice versa).
-//
-// ClientAuth: VerifyClientCertIfGiven — request a cert during handshake; if
-// the client presents one, verify it against the union pool; if absent, the
-// request still reaches the handler and the per-route handler decides
-// whether to accept. Critical that we do NOT use RequireAndVerifyClientCert
-// here — that would break the standard /scep + /.well-known/est routes
-// (challenge-password-only / unauth-or-Basic, no client cert expected).
-//
-// Pass clientCAs == nil to disable mTLS (no profile opted in across either
-// protocol). The function then returns the same shape as
-// buildServerTLSConfig.
-func buildServerTLSConfigWithMTLS(holder *certHolder, clientCAs *x509.CertPool) *tls.Config {
-	cfg := buildServerTLSConfig(holder)
-	if clientCAs != nil {
-		cfg.ClientCAs = clientCAs
-		cfg.ClientAuth = tls.VerifyClientCertIfGiven
-	}
-	return cfg
-}
-
 // preflightServerTLS is the fail-loud startup gate for HTTPS. Returns a
 // non-nil error when the TLS configuration is missing or the cert+key pair
 // cannot be parsed, so the caller refuses to start the control plane

deploy/ENVIRONMENTS.md

@@ -77,7 +77,7 @@ Three services on a private bridge network:
 ### Starting it
 
 ```bash
-git clone https://github.com/certctl-io/certctl.git
+git clone https://github.com/shankar0123/certctl.git
 cd certctl
 docker compose -f deploy/docker-compose.yml up -d --build
 ```
@@ -122,8 +122,6 @@ The `volumes` section mounts 10 migration files into PostgreSQL's init directory
 
 **Expert note:** The numbered prefix pattern (`001_`, `002_`, ..., `020_`) ensures deterministic execution order. All migrations use `IF NOT EXISTS` and `ON CONFLICT DO NOTHING` for idempotency, so re-running them against an existing database is safe.
 
-**Stateful volume — first-boot password binding (U-1).** The same "first boot only" semantics that govern migration scripts also govern `POSTGRES_PASSWORD`. The official `postgres` image runs `initdb` exactly once — when `/var/lib/postgresql/data` is empty — and that pass is the only time `POSTGRES_PASSWORD` is written into `pg_authid`. On every subsequent boot, the postgres container ignores the env var and authenticates against whatever password was baked into the data directory on the original `up`. Editing `POSTGRES_PASSWORD` in `.env` after a successful first boot therefore only updates the **certctl-server** container's `CERTCTL_DATABASE_URL` — postgres still expects the previous password, and the server fails to ping with `pq: password authentication failed for user "certctl"` (SQLSTATE 28P01). The certctl-server container surfaces this case explicitly: when SQLSTATE 28P01 fires at startup, the wrap text in `internal/repository/postgres/db.go::wrapPingError` points operators at the two remediation paths — destructive volume teardown via `docker compose -f deploy/docker-compose.yml down -v && up -d --build`, or non-destructive in-place rotation via `docker compose -f deploy/docker-compose.yml exec postgres psql -U certctl -c "ALTER ROLE certctl PASSWORD '<new>';"` followed by a server restart with the matching `POSTGRES_PASSWORD`. Use the destructive path on the demo / first-time setup; use the non-destructive path on any environment that holds data you want to keep.
-
 #### certctl Server
 
 ```yaml
@@ -198,9 +196,7 @@ docker compose -f deploy/docker-compose.yml down -v
 
 ### What it adds
 
-One env var: `CERTCTL_DEMO_SEED=true` on the `certctl-server` service. The server applies `migrations/seed_demo.sql` at boot via `postgres.RunDemoSeed` AFTER the baseline migrations + `seed.sql` are in place. The demo seed file inserts 180 days of simulated operational history: teams, owners, certificates across multiple issuers, agents on different platforms, jobs with realistic timestamps, discovery scan results, audit events, policies, and profiles.
-
-Pre-U-3 the overlay used to mount `seed_demo.sql` into PostgreSQL's `/docker-entrypoint-initdb.d/` and rely on initdb-time application. That worked only because the production stack also mounted the migrations there, so the schema existed when initdb ran. Once U-3 dropped the production initdb mounts (single source of truth: server runs `RunMigrations` + `RunSeed` at boot), the demo seed could no longer be applied at initdb time — the tables it references wouldn't exist yet. Post-U-3 the overlay is a 27-line override file with no `image:` / `build:` of its own; it MUST be passed alongside the base, or compose errors with `service "certctl-server" has neither an image nor a build context specified`.
+One line: mounts `seed_demo.sql` into PostgreSQL's init directory. This 667-line SQL file inserts 180 days of simulated operational history: teams, owners, certificates across multiple issuers, agents on different platforms, jobs with realistic timestamps, discovery scan results, audit events, policies, and profiles.
 
 ### Starting it
 

deploy/docker-compose.demo.yml

@@ -7,20 +7,8 @@
 # To start fresh (wipe previous data):
 #   docker compose -f docker-compose.yml -f docker-compose.demo.yml down -v
 #   docker compose -f docker-compose.yml -f docker-compose.demo.yml up --build
-#
-# U-3 (P1, cat-u-seed_initdb_schema_drift): pre-U-3 this overlay mounted
-# `seed_demo.sql` into postgres `/docker-entrypoint-initdb.d/`. That worked
-# only because the production stack also mounted the migrations there, so
-# the schema existed at initdb time. Once U-3 dropped the production
-# initdb mounts (single source of truth: server runs RunMigrations + RunSeed
-# at boot), the demo seed could no longer be applied at initdb time — the
-# tables it references wouldn't exist yet.
-#
-# Post-U-3 the demo overlay just sets CERTCTL_DEMO_SEED=true; the server
-# applies seed_demo.sql at boot via postgres.RunDemoSeed AFTER baseline
-# migrations + seed.sql are in place. Same single source of truth, no
-# initdb mounts, no schema-vs-seed drift.
+
 services:
-  certctl-server:
-    environment:
-      CERTCTL_DEMO_SEED: "true"
+  postgres:
+    volumes:
+      - ../migrations/seed_demo.sql:/docker-entrypoint-initdb.d/030_seed_demo.sql

deploy/docker-compose.test.yml

@@ -93,17 +93,6 @@ services:
   # ---------------------------------------------------------------------------
   # Database
   # ---------------------------------------------------------------------------
-  #
-  # U-3 (P1, cat-u-seed_initdb_schema_drift, GitHub #10): the test stack used
-  # to mount a hand-curated subset of migrations + seed.sql + a never-checked-in
-  # seed_test.sql into postgres `/docker-entrypoint-initdb.d/`. Same hazard as
-  # the production compose — initdb crashed any time a new migration shipped
-  # that the seed depended on without the mount list being updated. Post-U-3
-  # the schema is built EXCLUSIVELY by the server at startup via
-  # internal/repository/postgres.RunMigrations + RunSeed. Postgres comes up
-  # empty and the server lands the full ladder + baseline seed in one shot.
-  # `start_period: 30s` matches the production compose and shields slow CI
-  # runners from healthcheck flap during initdb.
   postgres:
     image: postgres:16-alpine
     container_name: certctl-test-postgres
@@ -113,6 +102,19 @@ services:
       POSTGRES_PASSWORD: testpass
     volumes:
       - test_postgres_data:/var/lib/postgresql/data
+      - ../migrations/000001_initial_schema.up.sql:/docker-entrypoint-initdb.d/001_schema.sql
+      - ../migrations/000002_agent_metadata.up.sql:/docker-entrypoint-initdb.d/002_agent_metadata.sql
+      - ../migrations/000003_certificate_profiles.up.sql:/docker-entrypoint-initdb.d/003_certificate_profiles.sql
+      - ../migrations/000004_agent_groups.up.sql:/docker-entrypoint-initdb.d/004_agent_groups.sql
+      - ../migrations/000005_revocation.up.sql:/docker-entrypoint-initdb.d/005_revocation.sql
+      - ../migrations/000006_discovery.up.sql:/docker-entrypoint-initdb.d/006_discovery.sql
+      - ../migrations/000007_network_discovery.up.sql:/docker-entrypoint-initdb.d/007_network_discovery.sql
+      - ../migrations/000008_verification.up.sql:/docker-entrypoint-initdb.d/008_verification.sql
+      - ../migrations/000009_issuer_config.up.sql:/docker-entrypoint-initdb.d/009_issuer_config.sql
+      - ../migrations/000010_target_config.up.sql:/docker-entrypoint-initdb.d/010_target_config.sql
+      - ../migrations/seed.sql:/docker-entrypoint-initdb.d/020_seed.sql
+      - ../migrations/seed_test.sql:/docker-entrypoint-initdb.d/025_seed_test.sql
+      # No seed_demo.sql — start with a clean database for real testing
     networks:
       certctl-test:
         ipv4_address: 10.30.50.2
@@ -123,7 +125,6 @@ services:
       interval: 5s
       timeout: 5s
       retries: 5
-      start_period: 30s
     restart: unless-stopped
 
   # ---------------------------------------------------------------------------
@@ -284,57 +285,8 @@ services:
       CERTCTL_EST_ENABLED: "true"
       CERTCTL_EST_ISSUER_ID: iss-local
 
-      # SCEP intentionally NOT configured in this stack.
-      #
-      # The 2026-04-29 master bundle Phase I added an `e2eintune` SCEP
-      # profile to this compose file with the intent that
-      # deploy/test/scep_intune_e2e_test.go would exercise it. That
-      # integration test exists (//go:build integration) but no CI job
-      # actually selects it — ci.yml's deploy-vendor-e2e job runs only
-      # `-run 'VendorEdge_'` (line 379), and no other job ever invokes
-      # `go test -tags integration` with a SCEP selector.
-      #
-      # The result was dead config: SCEP_ENABLED=true triggered the
-      # per-profile validator chain at server boot, but the supporting
-      # fixtures (ra.crt + ra.key + intune_trust_anchor.pem) were never
-      # committed to deploy/test/fixtures/ — only the README documenting
-      # how to regenerate them. Pre-Phase-5 (ci-pipeline-cleanup matrix
-      # collapse) the test stack didn't fully boot the certctl-server in
-      # CI, so the gap was hidden. Once the matrix collapsed and the
-      # collapsed deploy-vendor-e2e job started actually booting the
-      # server, the fail-loud gate at config.go:2069 (CWE-306, empty
-      # CHALLENGE_PASSWORD) fired and blocked CI.
-      #
-      # CERTCTL_SCEP_ENABLED is unset → default false → the validator
-      # skips the entire SCEP block. Coherence guard at
-      # scripts/ci-guards/test-compose-scep-coherence.sh refuses any
-      # future edit that re-enables SCEP without ALSO (a) adding a CI
-      # job that runs the SCEP integration test and (b) committing the
-      # required fixtures. The README at deploy/test/fixtures/README.md
-      # keeps the regen recipe so the eventual SCEP CI job lands cleanly.
-
-      # Dynamic issuer/target config encryption (M34/M35).
-      #
-      # MUST be ≥ 32 bytes. The H-1 closure (commit 6cb4414, "feat(security):
-      # encryption-key validation") added internal/config/config.go's
-      # minEncryptionKeyLength = 32 byte floor; values shorter than that are
-      # rejected at server boot with `Failed to load configuration:
-      # CERTCTL_CONFIG_ENCRYPTION_KEY too short`. The previous test value
-      # `test-encryption-key-32chars!!` was 29 bytes (the name claimed 32 but
-      # the author miscounted — 4+1+10+1+3+1+2+5+2 = 29). Pre-H-1 the
-      # validator accepted any non-empty string, so the gap was silent. Once
-      # the test stack actually boots the certctl-server (which the
-      # ci-pipeline-cleanup Phase 5 matrix collapse forced for the first
-      # time), the server now hard-fails at startup and the deploy-vendor-e2e
-      # job's `dependency failed to start: container certctl-test-server
-      # is unhealthy` error fires.
-      #
-      # The replacement below is 49 bytes — 17 bytes of safety margin over
-      # the floor so a future tightening (32 → 33+) does not break this
-      # fixture. It is clearly test-only / deterministic; do NOT copy this
-      # to production. Operators set CERTCTL_CONFIG_ENCRYPTION_KEY from
-      # `openssl rand -base64 32` per the README.
-      CERTCTL_CONFIG_ENCRYPTION_KEY: test-encryption-key-deterministic-32-byte-fixture
+      # Dynamic issuer/target config encryption (M34/M35)
+      CERTCTL_CONFIG_ENCRYPTION_KEY: test-encryption-key-32chars!!
 
       # Network scanning
       CERTCTL_NETWORK_SCAN_ENABLED: "true"
@@ -354,11 +306,6 @@ services:
       # agent mounts the same host path at the same container path (see below)
       # so /etc/certctl/tls/ca.crt resolves to the *same* bytes on both sides.
       - ./test/certs:/etc/certctl/tls:ro
-      # SCEP fixtures volume mount removed alongside the SCEP env vars
-      # above. When a CI job that runs scep_intune_e2e_test.go is added,
-      # restore both this mount AND the env vars together — the coherence
-      # guard at scripts/ci-guards/test-compose-scep-coherence.sh
-      # enforces that they move as a unit.
     networks:
       certctl-test:
         ipv4_address: 10.30.50.6
@@ -455,250 +402,6 @@ services:
         ipv4_address: 10.30.50.8
     restart: unless-stopped
 
-  # EST RFC 7030 hardening master bundle Phase 10.1 — libest sidecar.
-  #
-  # Cisco's libest reference RFC 7030 client. The integration test
-  # (deploy/test/est_e2e_test.go, build tag `integration`) docker-exec's
-  # into this container to drive estclient against the live certctl
-  # server. The container stays alive via `sleep infinity` so the test
-  # can do many serial exec calls without paying container-startup cost.
-  #
-  # Profile-gated (`profiles: [est-e2e]`) so the routine `docker compose
-  # up` for non-EST integration runs doesn't pay the libest build cost.
-  # Operator opts in via `docker compose --profile est-e2e up`. CI's
-  # est-e2e job runs:
-  #     docker compose --profile est-e2e build libest-client
-  #     docker compose --profile est-e2e up -d
-  #     INTEGRATION=1 go test -tags integration -run 'TestEST_LibESTClient' ./deploy/test/...
-  libest-client:
-    build:
-      context: ..
-      dockerfile: deploy/test/libest/Dockerfile
-      args:
-        HTTP_PROXY: ${HTTP_PROXY:-}
-        HTTPS_PROXY: ${HTTPS_PROXY:-}
-        NO_PROXY: ${NO_PROXY:-}
-    container_name: certctl-test-libest
-    depends_on:
-      certctl-server:
-        condition: service_healthy
-    volumes:
-      # /config/est is the libest working directory — the integration
-      # test writes CSRs / reads issued certs through this mount so the
-      # test-side Go code can inspect estclient's outputs.
-      - ./test/est:/config/est:rw
-      # certctl's CA bundle for TLS pinning. estclient uses this to
-      # verify the certctl-server cert (the same self-signed bundle
-      # the certctl-agent verifies against).
-      - ./test/certs:/config/certs:ro
-    networks:
-      certctl-test:
-        # Was 10.30.50.9 — collided with certctl-tls-init (line 91). Pre-Phase-5
-        # per-vendor matrix structurally hid this: tls-init is profile-less so
-        # it always ran, but libest is profiles=[est-e2e] so it only ran when
-        # the (separate) est-e2e job brought it up. Different jobs ⇒ different
-        # docker networks ⇒ no collision. Surfaced when a future job runs both
-        # profiles together; pre-emptive fix here.
-        ipv4_address: 10.30.50.10
-    restart: unless-stopped
-    profiles: [est-e2e]
-
-  # =============================================================================
-  # Deploy-Hardening II Phase 1 — per-vendor sidecar matrix
-  # =============================================================================
-  # Each sidecar is a real-software target the deploy-vendor-e2e tests
-  # (deploy/test/<vendor>_vendor_e2e_test.go, build tag `integration`)
-  # exercise the connector's atomic + verify + rollback contract against.
-  # All gated behind `profiles: [deploy-e2e]` so routine integration runs
-  # don't pay the per-vendor pull cost.
-  #
-  # Image digests pinned per H-001 guard. Re-pin quarterly per
-  # docs/deployment-vendor-matrix.md.
-
-  apache-test:
-    image: httpd:2.4-alpine@sha256:f9061a65c6e8f50d5636e10806da3d5a238877c11d6bc0149dc5131be0a1a19f
-    container_name: certctl-test-apache
-    ports:
-      - "20443:443"
-    volumes:
-      - ./test/apache/httpd-ssl.conf:/usr/local/apache2/conf/extra/httpd-ssl.conf:ro
-      - ./test/apache/init-cert.sh:/docker-entrypoint-init.sh:ro
-      - apache_certs:/usr/local/apache2/conf/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.20
-    profiles: [deploy-e2e]
-
-  haproxy-test:
-    image: haproxy:3.0-alpine@sha256:5b645ad4f3294cf5bc50ab8b201fdeb73732eca2928185df335735c698e8c3e2
-    container_name: certctl-test-haproxy
-    ports:
-      - "20444:443"
-    volumes:
-      - ./test/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
-      - haproxy_certs:/etc/haproxy/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.21
-    profiles: [deploy-e2e]
-
-  traefik-test:
-    image: traefik:v3.1@sha256:8516638b18e67e999d293e4ff0e5baf7807674cd4bdd3d36d448497bcbf0a174
-    container_name: certctl-test-traefik
-    command:
-      - --providers.file.directory=/etc/traefik/dynamic
-      - --providers.file.watch=true
-      - --entrypoints.websecure.address=:443
-      - --log.level=ERROR
-    ports:
-      - "20445:443"
-    volumes:
-      - ./test/traefik/traefik-dynamic.yml:/etc/traefik/dynamic/traefik-dynamic.yml:ro
-      - traefik_certs:/etc/traefik/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.22
-    profiles: [deploy-e2e]
-
-  caddy-test:
-    image: caddy:2.8-alpine@sha256:b95ed06fbc6d74d24a40902090c8cc6086ce7d08ba60a3a7e8e62bf164a9d7bb
-    container_name: certctl-test-caddy
-    command: caddy run --config /etc/caddy/Caddyfile --adapter caddyfile
-    ports:
-      - "20446:443"
-      - "22019:2019"  # admin API for ValidateOnly probe
-    volumes:
-      - ./test/caddy/Caddyfile:/etc/caddy/Caddyfile:ro
-      - caddy_certs:/etc/caddy/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.23
-    profiles: [deploy-e2e]
-
-  envoy-test:
-    image: envoyproxy/envoy:v1.32-latest@sha256:6ed0d4f28b8122df896062c425b34f18b8287e8c71c6badb3b84ca2e2f47c519
-    container_name: certctl-test-envoy
-    command: envoy -c /etc/envoy/envoy.yaml --log-level error
-    ports:
-      - "20447:443"
-    volumes:
-      - ./test/envoy/envoy.yaml:/etc/envoy/envoy.yaml:ro
-      - envoy_certs:/etc/envoy/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.24
-    profiles: [deploy-e2e]
-
-  postfix-test:
-    image: boky/postfix:latest@sha256:cd7e192900bfc49a67291a572b5f645f9e7d1b8d7f2b79b0364b4b4176964e21
-    container_name: certctl-test-postfix
-    environment:
-      ALLOWED_SENDER_DOMAINS: "test.local"
-    ports:
-      - "20025:25"
-      - "20465:465"
-    volumes:
-      - postfix_certs:/etc/postfix/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.25
-    profiles: [deploy-e2e]
-
-  dovecot-test:
-    image: dovecot/dovecot:latest@sha256:4046993478e8c8bcb841fdbff2d8de1b233484cc0196b3723f6c588e7eaf7301
-    container_name: certctl-test-dovecot
-    ports:
-      - "20993:993"
-      - "20995:995"
-    volumes:
-      - ./test/dovecot/dovecot.conf:/etc/dovecot/dovecot.conf:ro
-      - dovecot_certs:/etc/dovecot/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.26
-    profiles: [deploy-e2e]
-
-  openssh-test:
-    image: lscr.io/linuxserver/openssh-server:latest@sha256:742f577d4100f5ad3b38f270d722931bbe98b997444c13b1a2a838df12a9971e
-    container_name: certctl-test-openssh
-    environment:
-      USER_NAME: "certctl"
-      PASSWORD_ACCESS: "true"
-      USER_PASSWORD: "test-only-do-not-use-in-prod"
-      SUDO_ACCESS: "true"
-    ports:
-      - "20022:2222"
-    volumes:
-      - openssh_certs:/config/certs
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.27
-    profiles: [deploy-e2e]
-
-  # f5-mock-icontrol: in-tree Go server implementing the iControl REST
-  # surface this bundle exercises (Authenticate, UploadFile, transactions,
-  # SSL profile CRUD). Built from deploy/test/f5-mock-icontrol/Dockerfile;
-  # the operator-supplied real F5 vagrant box is documented in
-  # docs/connector-f5.md as the validation tier above the mock.
-  f5-mock-icontrol:
-    build:
-      context: ..
-      dockerfile: deploy/test/f5-mock-icontrol/Dockerfile
-    container_name: certctl-test-f5-mock
-    ports:
-      # Host port 20449 (NOT 20443 — apache-test owns 20443). The
-      # ci-pipeline-cleanup Phase 5 vendor-matrix collapse brings up
-      # all sidecars simultaneously; the original Phase 1 design
-      # accidentally double-bound 20443 because the per-vendor matrix
-      # only ever ran one sidecar at a time, hiding the collision.
-      - "20449:443"
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.28
-    profiles: [deploy-e2e]
-
-  # k8s-kind-test: a kind (Kubernetes-in-Docker) cluster used by the
-  # k8ssecret connector e2e tests. Per frozen decision 0.5, each K8s
-  # version test spins up a fresh kind cluster of the matching version.
-  # Tests are slow (~30-60s startup); marked t.Parallel() where independent.
-  # The kind binary lives in the test image; the Docker socket is mounted
-  # so kind can manage child containers.
-  k8s-kind-test:
-    image: kindest/node:v1.31.0@sha256:7fbc5644a803286a69ff9c5695f03bb01b512896835e15df7df17f756f7245ac
-    container_name: certctl-test-kind
-    privileged: true
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.29
-    profiles: [deploy-e2e]
-
-  # windows-iis-test: Windows containers run only on Windows hosts.
-  # CI no longer runs an IIS matrix (per ci-pipeline-cleanup bundle
-  # Phase 6 / frozen decision 0.5 — revises Bundle II decision 0.4).
-  # Two reasons the Windows matrix was deleted: (a) it couldn't
-  # physically work on `windows-latest` GitHub runners (Docker not
-  # started in Windows-containers mode by default; `bridge` network
-  # driver doesn't exist on Windows Docker); (b) all IIS + WinCertStore
-  # vendor-edge tests are t.Log placeholder stubs that exercise no
-  # IIS-specific behavior.
-  #
-  # Operators validate IIS + WinCertStore manually on a Windows host
-  # per the playbook at docs/connector-iis.md::Operator validation playbook.
-  #
-  # The sidecar definition stays here under profiles: [deploy-e2e-windows]
-  # so a Windows operator can opt in via:
-  #   docker compose --profile deploy-e2e-windows up -d windows-iis-test
-  # Linux CI never activates this profile.
-  windows-iis-test:
-    image: mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2022@sha256:8d0b0e651ad514e3fb05978db66f38036118812e1b9314a48f10419cad8a3462
-    container_name: certctl-test-iis
-    ports:
-      - "20448:443"
-    networks:
-      certctl-test:
-        ipv4_address: 10.30.50.30
-    profiles: [deploy-e2e-windows]
-
 # =============================================================================
 # Network
 # =============================================================================
@@ -725,20 +428,3 @@ volumes:
     driver: local
   nginx_certs:
     driver: local
-  # Deploy-Hardening II Phase 1 — per-vendor sidecar cert volumes.
-  apache_certs:
-    driver: local
-  haproxy_certs:
-    driver: local
-  traefik_certs:
-    driver: local
-  caddy_certs:
-    driver: local
-  envoy_certs:
-    driver: local
-  postfix_certs:
-    driver: local
-  dovecot_certs:
-    driver: local
-  openssh_certs:
-    driver: local

deploy/docker-compose.yml

@@ -53,29 +53,6 @@ services:
       - certctl-network
 
   # PostgreSQL database
-  #
-  # U-3 (P1, cat-u-seed_initdb_schema_drift, GitHub #10):
-  # Pre-U-3 this stack mounted a hand-curated subset of `migrations/*.up.sql`
-  # plus `seed.sql` into `/docker-entrypoint-initdb.d/`, and postgres
-  # initdb-applied them on first boot. The mount list rotted every time a
-  # new migration shipped that the seed depended on (000013 added
-  # policy_rules.severity, 000017 renames retry_interval_minutes, etc.) —
-  # initdb crashed, the container reported `unhealthy` indefinitely, and
-  # `docker compose -f deploy/docker-compose.yml up -d --build` from a
-  # fresh clone of v2.0.50 hit it on the first try.
-  #
-  # Post-U-3 the schema is built EXCLUSIVELY by the server at startup via
-  # internal/repository/postgres.RunMigrations + RunSeed. Single source of
-  # truth, no list to keep in sync. Postgres comes up empty; the server
-  # waits for it healthy, then applies the full migration ladder + seed in
-  # one shot. Helm + the dev examples were already runtime-only (Path B)
-  # and worked through the same window.
-  #
-  # `start_period: 30s` gives postgres room to bootstrap on slow runners
-  # (CI macOS, low-spec laptops) before the healthcheck failure counter
-  # starts ticking. Pre-U-3 a slow first-init combined with the
-  # `unhealthy` flap to cascade into certctl-server's `service_healthy`
-  # depends_on, blocking the whole stack.
   postgres:
     image: postgres:16-alpine
     container_name: certctl-postgres
@@ -87,6 +64,17 @@ services:
       - "5432:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
+      - ../migrations/000001_initial_schema.up.sql:/docker-entrypoint-initdb.d/001_schema.sql
+      - ../migrations/000002_agent_metadata.up.sql:/docker-entrypoint-initdb.d/002_agent_metadata.sql
+      - ../migrations/000003_certificate_profiles.up.sql:/docker-entrypoint-initdb.d/003_certificate_profiles.sql
+      - ../migrations/000004_agent_groups.up.sql:/docker-entrypoint-initdb.d/004_agent_groups.sql
+      - ../migrations/000005_revocation.up.sql:/docker-entrypoint-initdb.d/005_revocation.sql
+      - ../migrations/000006_discovery.up.sql:/docker-entrypoint-initdb.d/006_discovery.sql
+      - ../migrations/000007_network_discovery.up.sql:/docker-entrypoint-initdb.d/007_network_discovery.sql
+      - ../migrations/000008_verification.up.sql:/docker-entrypoint-initdb.d/008_verification.sql
+      - ../migrations/000009_issuer_config.up.sql:/docker-entrypoint-initdb.d/009_issuer_config.sql
+      - ../migrations/000010_target_config.up.sql:/docker-entrypoint-initdb.d/010_target_config.sql
+      - ../migrations/seed.sql:/docker-entrypoint-initdb.d/020_seed.sql
     networks:
       - certctl-network
     healthcheck:
@@ -94,7 +82,6 @@ services:
       interval: 5s
       timeout: 5s
       retries: 5
-      start_period: 30s
     restart: unless-stopped
 
   # Certctl Server (API + scheduler)
@@ -119,11 +106,7 @@ services:
       certctl-tls-init:
         condition: service_completed_successfully
     environment:
-      # Bundle B / Audit M-018 (PCI-DSS Req 4 / CWE-319): in-cluster Postgres
-      # on the docker bridge network keeps sslmode=disable acceptable; for
-      # external/managed Postgres operators MUST override CERTCTL_DATABASE_URL
-      # with sslmode=verify-full and provide the CA bundle. See docs/database-tls.md.
-      CERTCTL_DATABASE_URL: ${CERTCTL_DATABASE_URL:-postgres://certctl:${POSTGRES_PASSWORD:-certctl}@postgres:5432/certctl?sslmode=disable}
+      CERTCTL_DATABASE_URL: postgres://certctl:${POSTGRES_PASSWORD:-certctl}@postgres:5432/certctl?sslmode=disable
       CERTCTL_SERVER_HOST: 0.0.0.0
       CERTCTL_SERVER_PORT: 8443
       CERTCTL_SERVER_TLS_CERT_PATH: /etc/certctl/tls/server.crt
@@ -133,15 +116,6 @@ services:
       CERTCTL_KEYGEN_MODE: server  # Demo uses server-side keygen; production should use "agent"
       CERTCTL_NETWORK_SCAN_ENABLED: "true"  # Enable network scan GUI with seeded demo targets
       CERTCTL_CONFIG_ENCRYPTION_KEY: ${CERTCTL_CONFIG_ENCRYPTION_KEY:-change-me-32-char-encryption-key}  # AES-256-GCM for dynamic issuer/target config
-      # Bundle 1 follow-on: this compose IS the bundled demo path
-      # (CERTCTL_AUTH_TYPE=none + KEYGEN_MODE=server above), so the
-      # demo seed runs by default. seed_demo.sql pre-seeds the
-      # agent-demo-1 row that the bundled certctl-agent below needs
-      # to authenticate. The docker-compose.demo.yml overlay still
-      # works (it sets the same flag) and remains for backward
-      # compat. Production deploys override CERTCTL_AUTH_TYPE +
-      # KEYGEN_MODE + DEMO_SEED via their own compose.
-      CERTCTL_DEMO_SEED: "true"
     ports:
       - "8443:8443"
     volumes:
@@ -153,11 +127,6 @@ services:
       interval: 10s
       timeout: 5s
       retries: 5
-      # U-3: server boot now does RunMigrations + RunSeed before listening on
-      # 8443. On a fresh clone the full migration ladder + seed application
-      # can take ~10s on a small VM; start_period prevents the first few
-      # healthcheck attempts from counting as failures while that work runs.
-      start_period: 30s
     restart: unless-stopped
     logging:
       driver: "json-file"
@@ -192,17 +161,6 @@ services:
       CERTCTL_SERVER_URL: https://certctl-server:8443
       CERTCTL_SERVER_CA_BUNDLE_PATH: /etc/certctl/tls/ca.crt
       CERTCTL_API_KEY: ${CERTCTL_API_KEY:-change-me-in-production}
-      # Bundle 1 follow-on: pre-Bundle-1 the bundled agent had no
-      # CERTCTL_AGENT_ID set, hit cmd/agent/main.go's fail-fast guard
-      # ("agent-id flag or CERTCTL_AGENT_ID env var is required"), and
-      # restart-looped silently on every fresh `docker compose up`.
-      # Latent since 2026-03-14 (commit d395776). seed_demo.sql now
-      # pre-seeds the matching agents row; the demo runs with
-      # CERTCTL_AUTH_TYPE=none on the server so the api_key Bearer
-      # token is irrelevant here. Production deploys override
-      # CERTCTL_AGENT_ID with the value returned from
-      # POST /api/v1/agents during registration.
-      CERTCTL_AGENT_ID: ${CERTCTL_AGENT_ID:-agent-demo-1}
       CERTCTL_AGENT_NAME: docker-agent
       CERTCTL_LOG_LEVEL: info
       CERTCTL_DISCOVERY_DIRS: /var/lib/certctl/keys  # Agent scans this directory for existing certificates

deploy/helm/CHART_SUMMARY.md

@@ -17,7 +17,7 @@ A production-ready Helm chart for deploying certctl (self-hosted certificate lif
 - **Chart Version**: 0.1.0
 - **App Version**: 2.1.0
 - **Type**: application
-- **License**: BSL-1.1
+- **License**: BSL-1.1 (converts to Apache 2.0 in 2033)
 
 ## File Structure
 
@@ -246,8 +246,8 @@ helm install certctl certctl/ \
 |--------|---------|-------------|
 | `server.replicas` | 1 | Number of server replicas |
 | `server.port` | 8443 | Server port |
-| `server.auth.type` | api-key | Authentication type — `api-key` or `none` (G-1: `jwt` removed; for JWT/OIDC use a fronting authenticating gateway, see `docs/architecture.md` and `docs/upgrade-to-v2-jwt-removal.md`) |
-| `server.auth.apiKey` | "" | API key (REQUIRED when `auth.type=api-key`) |
+| `server.auth.type` | api-key | Authentication type |
+| `server.auth.apiKey` | "" | API key (REQUIRED) |
 | `server.logging.level` | info | Log level |
 | `server.logging.format` | json | Log format |
 
@@ -452,9 +452,10 @@ monitoring:
 ## Support
 
 For issues, questions, or contributions:
-- GitHub: https://github.com/certctl-io/certctl
-- Documentation: https://github.com/certctl-io/certctl/tree/main/docs
+- GitHub: https://github.com/shankar0123/certctl
+- Documentation: https://github.com/shankar0123/certctl/tree/main/docs
 
 ## License
 
 BSL-1.1 (Business Source License)
+Converts to Apache 2.0 on March 14, 2033

deploy/helm/INDEX.md

@@ -216,7 +216,7 @@ kubectl logs -l app.kubernetes.io/component=server -f
 
 ## Support
 
-- **GitHub**: https://github.com/certctl-io/certctl
+- **GitHub**: https://github.com/shankar0123/certctl
 - **Issues**: Report on GitHub issues
 - **Documentation**: All docs are in `deploy/helm/`
 
@@ -231,4 +231,4 @@ kubectl logs -l app.kubernetes.io/component=server -f
 
 ## License
 
-All files are covered under the BSL-1.1 license.
+All files are covered under the BSL-1.1 license (converts to Apache 2.0 in 2033).

deploy/helm/INSTALLATION.md

@@ -94,4 +94,4 @@ helm install certctl certctl/ --dry-run --debug
 
 - Full documentation in `README.md`
 - Troubleshooting in `DEPLOYMENT_GUIDE.md`
-- Issues: https://github.com/certctl-io/certctl
+- Issues: https://github.com/shankar0123/certctl

deploy/helm/README.md

@@ -508,9 +508,9 @@ kubectl exec -it <pod> -- \
 ## Support and Contributing
 
 For issues, questions, or contributions, visit:
-- GitHub: https://github.com/certctl-io/certctl
-- Documentation: https://github.com/certctl-io/certctl/tree/main/docs
+- GitHub: https://github.com/shankar0123/certctl
+- Documentation: https://github.com/shankar0123/certctl/tree/main/docs
 
 ## License
 
-BSL-1.1
+BSL-1.1 (converts to Apache 2.0 in 2033)

deploy/helm/certctl/Chart.yaml

@@ -14,7 +14,7 @@ keywords:
   - kubernetes
 maintainers:
   - name: certctl
-home: https://github.com/certctl-io/certctl
+home: https://github.com/shankar0123/certctl
 sources:
-  - https://github.com/certctl-io/certctl
+  - https://github.com/shankar0123/certctl
 license: BSL-1.1

deploy/helm/certctl/README.md

@@ -1,148 +0,0 @@
-# certctl Helm Chart
-
-Production-ready Helm chart for deploying [certctl](https://github.com/certctl-io/certctl) on Kubernetes. Wires up the certctl server (Deployment), PostgreSQL (StatefulSet with PVC), and the agent (DaemonSet — one per node) on a private cluster, with health probes, security contexts, and optional Ingress.
-
-## Quick install
-
-```bash
-helm install certctl deploy/helm/certctl/ \
-  --create-namespace --namespace certctl \
-  --set server.auth.apiKey="$(openssl rand -base64 32)" \
-  --set postgresql.auth.password="$(openssl rand -base64 24)"
-```
-
-This brings up:
-
-- `<release>-server` Deployment (HTTPS-only on port 8443; TLS 1.3)
-- `<release>-postgres` StatefulSet (PostgreSQL 16-alpine, 1 replica, 10Gi PVC by default)
-- `<release>-agent` DaemonSet (polls server, generates ECDSA P-256 keys locally)
-- Service objects, optional Ingress, and ServiceAccount with RBAC
-
-See [`values.yaml`](values.yaml) for the full configuration surface — issuer settings, target connectors, scheduler intervals, notifier credentials, and resource requests/limits all live there.
-
-## Operational notes
-
-### Postgres password rotation — read this before changing `postgresql.auth.password`
-
-**The trap.** `postgresql.auth.password` is bound to `pg_authid` exactly once — when the StatefulSet's PVC is provisioned and `initdb` runs. The official `postgres:16-alpine` image only runs `initdb` when `/var/lib/postgresql/data` is empty, so on every subsequent rollout the `POSTGRES_PASSWORD` env var is read into the container but **ignored** by postgres itself. The certctl-server container also picks up the new value (via the database URL helper template), so the two halves diverge: server presents the new password, postgres still expects the old one.
-
-**Symptom.** The certctl-server pod's startup log shows:
-
-```
-failed to ping database: postgres rejected the configured credentials
-(SQLSTATE 28P01 — invalid_password). If you recently rotated POSTGRES_PASSWORD ...
-```
-
-That diagnostic is emitted by `internal/repository/postgres/db.go::wrapPingError` — it points operators at the two remediation paths below.
-
-**Remediation, non-destructive (preferred for any environment with real data):**
-
-```bash
-# 1. Rotate the password in postgres directly
-kubectl -n certctl exec -it <release>-postgres-0 -- \
-  psql -U certctl -c "ALTER ROLE certctl PASSWORD '<new-password>';"
-
-# 2. Update the secret / Helm values to the same value
-helm upgrade <release> deploy/helm/certctl/ \
-  --reuse-values \
-  --set postgresql.auth.password='<new-password>'
-
-# 3. Bounce the certctl-server pod so it re-reads the secret
-kubectl -n certctl rollout restart deployment/<release>-server
-```
-
-**Remediation, destructive (DESTROYS ALL CERTCTL DATA — only acceptable on dev/demo clusters):**
-
-```bash
-helm uninstall <release> -n certctl
-kubectl -n certctl delete pvc -l \
-  app.kubernetes.io/name=certctl,app.kubernetes.io/component=postgres
-helm install <release> deploy/helm/certctl/ \
-  --namespace certctl \
-  --set postgresql.auth.password='<new-password>'
-```
-
-The PVC re-creates empty, `initdb` runs on first boot of the new postgres pod, and `pg_authid` is seeded with the new password.
-
-**Why we don't fix this in the chart.** The env-vs-`pg_authid` divergence is intrinsic to how the upstream `postgres` image bootstraps — `initdb` is run-once-per-empty-data-dir, and there is no upstream-supported way to make subsequent boots re-seed `pg_authid` from `POSTGRES_PASSWORD`. The ergonomic answer is the runtime diagnostic plus this operational note.
-
-**Cross-references.** Same root cause is documented for the docker-compose path in [`docs/quickstart.md`](../../../docs/quickstart.md) (Warning callout after the `cp .env.example .env` block) and in [`deploy/ENVIRONMENTS.md`](../../ENVIRONMENTS.md) (Stateful volume — first-boot password binding section). The runtime diagnostic itself lives in `internal/repository/postgres/db.go::wrapPingError` with regression coverage in `internal/repository/postgres/db_test.go`.
-
-### Server API key rotation
-
-Unlike the postgres password, `server.auth.apiKey` accepts a comma-separated list, so zero-downtime rotation is straightforward:
-
-```bash
-# 1. Add the new key alongside the old
-helm upgrade <release> deploy/helm/certctl/ \
-  --reuse-values \
-  --set server.auth.apiKey='new-key,old-key'
-
-# 2. Roll your agents / clients over to the new key
-
-# 3. Remove the old key
-helm upgrade <release> deploy/helm/certctl/ \
-  --reuse-values \
-  --set server.auth.apiKey='new-key'
-```
-
-### JWT / OIDC via authenticating gateway
-
-certctl's in-process auth surface is intentionally narrow: `server.auth.type=api-key` for production deployments and `server.auth.type=none` for development. There is no in-process JWT, OIDC, mTLS, or SAML middleware. (`server.auth.type=jwt` was accepted pre-G-1 but silently routed every request through the api-key bearer middleware — silent auth downgrade. The chart now fails at `helm install`/`helm upgrade` template time via the `certctl.validateAuthType` helper if you set it. See [`../../../docs/upgrade-to-v2-jwt-removal.md`](../../../docs/upgrade-to-v2-jwt-removal.md) if you previously had this in your values.)
-
-For deployments that need JWT/OIDC, the canonical Kubernetes-flavored shape is to put oauth2-proxy in front of the certctl Service, attach an authenticating Ingress middleware, and run certctl with `server.auth.type=none`:
-
-```bash
-# 1. Install oauth2-proxy (or any OIDC-terminating sidecar) in the same namespace
-helm install oauth2-proxy oauth2-proxy/oauth2-proxy \
-  --namespace certctl \
-  --set config.clientID="$OIDC_CLIENT_ID" \
-  --set config.clientSecret="$OIDC_CLIENT_SECRET" \
-  --set config.cookieSecret="$(openssl rand -base64 32)" \
-  --set config.configFile='|
-    provider = "oidc"
-    oidc_issuer_url = "https://your-issuer/"
-    upstreams = ["http://<release>-server.certctl.svc.cluster.local:8443"]
-    pass_authorization_header = true
-    set_authorization_header = true
-    email_domains = ["*"]
-  '
-
-# 2. Install certctl with type=none (gateway terminates auth)
-helm install certctl deploy/helm/certctl/ \
-  --namespace certctl \
-  --set server.auth.type=none \
-  --set postgresql.auth.password="$(openssl rand -base64 24)"
-
-# 3. Attach an Ingress that routes through oauth2-proxy
-#    (Traefik ForwardAuth, nginx auth_request, Envoy ext_authz, etc.)
-```
-
-Same root pattern works with Pomerium, Authelia, Caddy `forward_auth`, Apache `mod_auth_openidc`, or any service-mesh `ext_authz`. See [`../../../docs/architecture.md`](../../../docs/architecture.md) "Authenticating-gateway pattern" for the full design rationale and [`../../../docs/upgrade-to-v2-jwt-removal.md`](../../../docs/upgrade-to-v2-jwt-removal.md) for the migration walkthrough.
-
-### TLS certificate sourcing
-
-By default the chart provisions a self-signed cert via the same init-container pattern as the docker-compose deploy. For production, supply an operator-managed Secret (cert-manager, internal CA, etc.) — see [`docs/tls.md`](../../../docs/tls.md) for the full provisioning matrix and [`docs/upgrade-to-tls.md`](../../../docs/upgrade-to-tls.md) for upgrade-from-HTTP procedures.
-
-## Disabling embedded postgres
-
-If you have an existing PostgreSQL cluster, disable the embedded one and point at it directly:
-
-```bash
-helm install certctl deploy/helm/certctl/ \
-  --set postgresql.enabled=false \
-  --set server.databaseUrl='postgres://certctl:<pw>@my-pg-host:5432/certctl?sslmode=require'
-```
-
-The volume-trap section above does **not** apply to this configuration — your postgres operator (or cloud DB) handles password rotation, and you control `pg_authid` directly.
-
-## Uninstall
-
-```bash
-helm uninstall <release> -n certctl
-# Optional — also delete the postgres PVC (DESTROYS DATA):
-kubectl -n certctl delete pvc -l \
-  app.kubernetes.io/name=certctl,app.kubernetes.io/component=postgres
-```
-
-By default `helm uninstall` retains the StatefulSet's PVCs, so reinstalling with the same release name preserves the database. If you've changed `postgresql.auth.password` in your values between uninstall and reinstall, you'll hit the trap on the reinstall — apply the non-destructive remediation above, or also delete the PVC.

deploy/helm/certctl/templates/_helpers.tpl

@@ -112,24 +112,9 @@ PostgreSQL image
 
 {{/*
 Database connection string
-
-Bundle B / Audit M-018 (PCI-DSS Req 4 / CWE-319):
-  - postgresql.tls.mode is the operator-facing knob.
-    Default: "disable" (preserves the in-cluster Helm-bundled-Postgres
-    behavior; pod-to-pod traffic stays on the K8s pod network and is
-    encrypted by the CNI when the cluster is configured with a TLS-aware
-    CNI such as Cilium WireGuard).
-  - Operators on PCI-DSS-scoped clusters or operators using an external
-    managed Postgres (RDS, Cloud SQL, Azure DB) MUST set
-    postgresql.tls.mode to "require", "verify-ca", or "verify-full" and
-    point postgresql.tls.caSecretRef at a Secret containing the
-    server-ca.crt under key "ca.crt".
-  - The connection string sslmode parameter is wired from
-    postgresql.tls.mode without further translation.
 */}}
 {{- define "certctl.databaseURL" -}}
-{{- $sslMode := default "disable" .Values.postgresql.tls.mode -}}
-postgres://{{ .Values.postgresql.auth.username }}:$(POSTGRES_PASSWORD)@{{ include "certctl.fullname" . }}-postgres:5432/{{ .Values.postgresql.auth.database }}?sslmode={{ $sslMode }}
+postgres://{{ .Values.postgresql.auth.username }}:$(POSTGRES_PASSWORD)@{{ include "certctl.fullname" . }}-postgres:5432/{{ .Values.postgresql.auth.database }}?sslmode=disable
 {{- end }}
 
 {{/*
@@ -184,26 +169,3 @@ per affected resource. No-op when configured correctly.
 {{- fail "\n\nserver.tls.certManager.enabled=true but server.tls.certManager.issuerRef.name is empty.\n\nSet:\n  --set server.tls.certManager.issuerRef.name=<your-issuer-or-clusterissuer>\n\nSee docs/tls.md.\n" -}}
 {{- end -}}
 {{- end }}
-
-{{/*
-Auth-type validation gate.
-
-G-1 (P1): pre-G-1 the chart accepted server.auth.type=jwt and the
-certctl-server container silently routed every request through the
-api-key bearer middleware (no JWT impl ships with certctl). Post-G-1
-the chart fails at template-time with a pointer at the authenticating-
-gateway pattern. The valid set must stay in sync with
-internal/config.ValidAuthTypes() in the Go binary; if you add a value
-there you must add it here too (and update the property test in
-internal/config/config_test.go that pins both surfaces).
-
-Any template that consumes .Values.server.auth.type should call
-`{{ include "certctl.validateAuthType" . }}` at the top so this guard
-runs once per affected resource. No-op when configured correctly.
-*/}}
-{{- define "certctl.validateAuthType" -}}
-{{- $valid := list "api-key" "none" -}}
-{{- if not (has .Values.server.auth.type $valid) -}}
-{{- fail (printf "\n\nserver.auth.type=%q is not supported (valid: %v).\n\nFor JWT/OIDC, run an authenticating gateway in front of certctl\n(oauth2-proxy / Envoy ext_authz / Traefik ForwardAuth / Pomerium) and\nset server.auth.type=none here so the gateway terminates federated\nidentity. See docs/architecture.md \"Authenticating-gateway pattern\"\nand docs/upgrade-to-v2-jwt-removal.md for the migration walkthrough.\n\nG-1 audit closure: pre-G-1 the chart accepted type=jwt and the binary\nsilently downgraded to api-key middleware. The chart now fails at\ntemplate time so misconfigured deployments cannot ship.\n" .Values.server.auth.type $valid) -}}
-{{- end -}}
-{{- end }}

deploy/helm/certctl/templates/server-configmap.yaml

@@ -1,4 +1,3 @@
-{{- include "certctl.validateAuthType" . }}
 apiVersion: v1
 kind: ConfigMap
 metadata:

deploy/helm/certctl/templates/server-deployment.yaml

@@ -1,5 +1,4 @@
 {{- include "certctl.tls.required" . }}
-{{- include "certctl.validateAuthType" . }}
 apiVersion: apps/v1
 kind: Deployment
 metadata:

deploy/helm/certctl/templates/server-secret.yaml

@@ -1,4 +1,3 @@
-{{- include "certctl.validateAuthType" . }}
 apiVersion: v1
 kind: Secret
 metadata:
@@ -8,11 +7,7 @@ metadata:
     app.kubernetes.io/component: server
 type: Opaque
 stringData:
-  # Bundle B / Audit M-018 (PCI-DSS Req 4): sslmode wired from
-  # postgresql.tls.mode. Default "disable" preserves the in-cluster
-  # Helm-bundled-Postgres path; operators on PCI-scoped clusters set
-  # postgresql.tls.mode to require / verify-ca / verify-full.
-  database-url: {{ include "certctl.databaseURL" . | quote }}
+  database-url: postgres://{{ .Values.postgresql.auth.username }}:$(POSTGRES_PASSWORD)@{{ include "certctl.fullname" . }}-postgres:5432/{{ .Values.postgresql.auth.database }}?sslmode=disable
   {{- if and (eq .Values.server.auth.type "api-key") .Values.server.auth.apiKey }}
   api-key: {{ .Values.server.auth.apiKey | quote }}
   {{- end }}

deploy/helm/certctl/values.yaml

@@ -20,7 +20,7 @@ server:
 
   # Image configuration
   image:
-    repository: ghcr.io/certctl-io/certctl
+    repository: ghcr.io/shankar0123/certctl
     tag: "" # defaults to Chart.appVersion
     pullPolicy: IfNotPresent
 
@@ -48,14 +48,7 @@ server:
       drop:
         - ALL
 
-  # Liveness and readiness probes (HTTPS-only as of v2.2).
-  #
-  # The two paths exposed for probes are `/health` and `/ready` —
-  # registered in internal/api/router/router.go:76-85 and bypassing the
-  # auth middleware via the no-auth list at cmd/server/main.go:920.
-  # Both serve the same JSON shape today (`{"status":"healthy"}` /
-  # `{"status":"ready"}`) but exist as separate routes so liveness and
-  # readiness can diverge in the future without renaming.
+  # Liveness and readiness probes (HTTPS-only as of v2.2)
   livenessProbe:
     httpGet:
       path: /health
@@ -66,18 +59,9 @@ server:
     timeoutSeconds: 5
     failureThreshold: 3
 
-  # U-2 (P1, cat-u-healthcheck_protocol_mismatch — adjacent fix): pre-U-2
-  # the readiness probe pointed at `/readyz`, the conventional kube-flavor
-  # name. The certctl server doesn't register `/readyz` (only `/health`
-  # and `/ready`) — see cmd/server/main.go:920 and
-  # internal/api/router/router.go:81. K8s readiness probes therefore
-  # received a 404 (or, with auth enabled, a 401 from the api-key middleware
-  # because `/readyz` was NOT in the no-auth bypass set), pods stayed
-  # `NotReady` indefinitely, and Helm rollouts stalled. Post-U-2 the path
-  # matches a registered route.
   readinessProbe:
     httpGet:
-      path: /ready
+      path: /readyz
       port: https
       scheme: HTTPS
     initialDelaySeconds: 5
@@ -128,23 +112,10 @@ server:
     port: 8443
     annotations: {}
 
-  # Authentication configuration.
-  # Valid types: "api-key" (production) or "none" (demo only — disables
-  # authentication on the API and logs a loud Warn at server startup).
-  # For JWT/OIDC, run an authenticating gateway in front of certctl
-  # (oauth2-proxy / Envoy ext_authz / Traefik ForwardAuth / Pomerium)
-  # and set type=none here so the gateway terminates federated identity.
-  # See docs/architecture.md "Authenticating-gateway pattern".
-  #
-  # G-1 (P1): pre-G-1 the chart accepted server.auth.type=jwt and the
-  # certctl-server container silently routed every request through the
-  # api-key bearer middleware — silent auth downgrade. Post-G-1 the
-  # chart's `certctl.validateAuthType` template helper rejects any value
-  # outside {api-key, none} at template time. See
-  # docs/upgrade-to-v2-jwt-removal.md if you previously set type=jwt.
+  # Authentication configuration
   auth:
-    type: api-key
-    apiKey: ""     # REQUIRED when type=api-key (set via --set or values override).
+    type: api-key  # Options: api-key, none (for demo only)
+    apiKey: ""     # REQUIRED in production - set via --set or values override
 
   # Logging configuration
   logging:
@@ -289,58 +260,7 @@ postgresql:
   auth:
     database: certctl
     username: certctl
-    # REQUIRED — set via `--set postgresql.auth.password=<value>` or values override.
-    #
-    # WARNING (U-1): rotating this value after first deploy does NOT change the
-    # database password. The `postgres:16-alpine` image runs `initdb` only when
-    # /var/lib/postgresql/data is empty, so POSTGRES_PASSWORD is written into
-    # pg_authid exactly once — on the first boot of the StatefulSet's PVC.
-    # Subsequent rollouts pick up the new env value in the postgres container
-    # but the certctl-server container's CERTCTL_DATABASE_URL also picks up
-    # the new value, while pg_authid still expects the old one — leading to
-    # `pq: password authentication failed for user "certctl"` (SQLSTATE 28P01).
-    #
-    # The certctl-server emits guidance via internal/repository/postgres/db.go::
-    # wrapPingError when it sees SQLSTATE 28P01 at startup. To resolve in a
-    # Helm deployment:
-    #   - Non-destructive (preferred for environments with data):
-    #       kubectl exec -it <release>-postgres-0 -- \
-    #         psql -U certctl -c "ALTER ROLE certctl PASSWORD '<new>';"
-    #     then update the secret/values to match and let the certctl-server
-    #     pod restart against the matching credential.
-    #   - Destructive (DESTROYS DATA — only acceptable on dev/demo PVCs):
-    #       helm uninstall <release> && \
-    #       kubectl delete pvc -l app.kubernetes.io/name=certctl,app.kubernetes.io/component=postgres && \
-    #       helm install <release> ...  # PVC re-creates empty, initdb seeds new password
-    password: ""
-
-  # ─────────────────────────────────────────────────────────────────────
-  # Bundle B / Audit M-018 (PCI-DSS Req 4 / CWE-319): TLS to Postgres
-  # ─────────────────────────────────────────────────────────────────────
-  # postgresql.tls.mode is wired into the database-url sslmode parameter
-  # (see templates/_helpers.tpl::certctl.databaseURL).
-  #
-  # Acceptable values (lib/pq):
-  #   disable     — no TLS (default, preserves in-cluster pod-to-pod
-  #                 traffic on the K8s pod network).
-  #   require     — TLS required, no certificate verification.
-  #   verify-ca   — TLS required + verify CA chain.
-  #   verify-full — TLS required + verify CA chain + verify hostname.
-  #
-  # PCI-DSS Req 4 v4.0 §2.2.5 requires verify-ca or verify-full when the
-  # database carries sensitive data crossing untrusted networks (RDS,
-  # Cloud SQL, cross-VPC, etc). The bundled Helm Postgres runs in the
-  # same pod network as certctl-server; sslmode=disable is acceptable
-  # there only when the cluster CNI provides L2/L3 encryption (Cilium
-  # WireGuard, Calico Wireguard, Tailscale operator, etc).
-  #
-  # When mode != disable AND tls.caSecretRef is set, the CA bundle is
-  # mounted at /etc/postgresql-ca/ca.crt and the server's PGSSLROOTCERT
-  # env points there. caSecretRef must reference an existing Secret with
-  # a "ca.crt" key.
-  tls:
-    mode: disable
-    # caSecretRef: ""  # Secret with ca.crt key (required for verify-ca/verify-full)
+    password: ""  # REQUIRED - set via --set or values override
 
   # Storage configuration
   storage:
@@ -410,7 +330,7 @@ agent:
 
   # Image configuration
   image:
-    repository: ghcr.io/certctl-io/certctl-agent
+    repository: ghcr.io/shankar0123/certctl-agent
     tag: ""  # defaults to Chart.appVersion
     pullPolicy: IfNotPresent
 

deploy/helm/examples/values-dev.yaml

@@ -10,7 +10,7 @@ server:
   replicas: 1
 
   image:
-    repository: ghcr.io/certctl-io/certctl
+    repository: ghcr.io/shankar0123/certctl
     pullPolicy: IfNotPresent  # Use latest tag
 
   port: 8443
@@ -72,7 +72,7 @@ agent:
   replicas: 1
 
   image:
-    repository: ghcr.io/certctl-io/certctl-agent
+    repository: ghcr.io/shankar0123/certctl-agent
     pullPolicy: IfNotPresent
 
   resources:

deploy/helm/examples/values-prod-ha.yaml

@@ -12,7 +12,7 @@ server:
   replicas: 3
 
   image:
-    repository: ghcr.io/certctl-io/certctl
+    repository: ghcr.io/shankar0123/certctl
     tag: "2.1.0"
     pullPolicy: IfNotPresent
 
@@ -84,7 +84,7 @@ agent:
   kind: DaemonSet
 
   image:
-    repository: ghcr.io/certctl-io/certctl-agent
+    repository: ghcr.io/shankar0123/certctl-agent
     tag: "2.1.0"
     pullPolicy: IfNotPresent
 

deploy/test/acme-integration/cert-manager-install.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-#
-# Phase 5 — install cert-manager 1.15.0 into the kind cluster brought
-# up by kind-config.yaml. Idempotent: re-running waits for the
-# existing deployment to be Ready instead of reinstalling.
-#
-# Called from: deploy/test/acme-integration/certmanager_test.go
-# Standalone: bash deploy/test/acme-integration/cert-manager-install.sh
-set -euo pipefail
-
-CERT_MANAGER_VERSION="${CERT_MANAGER_VERSION:-v1.15.0}"
-KUBECTL="${KUBECTL:-kubectl}"
-
-echo "Installing cert-manager ${CERT_MANAGER_VERSION}..."
-${KUBECTL} apply -f \
-  "https://github.com/cert-manager/cert-manager/releases/download/${CERT_MANAGER_VERSION}/cert-manager.yaml"
-
-echo "Waiting for cert-manager controller to be Ready (timeout 5m)..."
-${KUBECTL} -n cert-manager wait --for=condition=Available --timeout=5m \
-  deployment/cert-manager \
-  deployment/cert-manager-cainjector \
-  deployment/cert-manager-webhook
-
-echo "cert-manager ${CERT_MANAGER_VERSION} ready."

deploy/test/acme-integration/certificate-test.yaml

@@ -1,20 +0,0 @@
-# Phase 5 — Certificate resource the integration test applies and
-# waits for. The certctl-test-trust ClusterIssuer (trust_authenticated
-# mode) issues the cert without any solver round-trip; the resulting
-# Secret 'test-com-tls' is asserted to carry tls.crt + tls.key.
-apiVersion: cert-manager.io/v1
-kind: Certificate
-metadata:
-  name: test-com
-  namespace: default
-spec:
-  secretName: test-com-tls
-  commonName: test.example.com
-  dnsNames:
-    - test.example.com
-    - www.test.example.com
-  issuerRef:
-    name: certctl-test-trust
-    kind: ClusterIssuer
-  duration: 720h     # 30d
-  renewBefore: 240h  # 10d

deploy/test/acme-integration/certmanager_test.go

@@ -1,167 +0,0 @@
-// Copyright (c) certctl
-// SPDX-License-Identifier: BSL-1.1
-
-//go:build integration
-
-// Phase 5 — kind-driven cert-manager integration test. Verifies the
-// certctl ACME server end-to-end against a real cert-manager 1.15+
-// deployment in a kind cluster. The test sequences:
-//
-//  1. Bring up the kind cluster (kind-config.yaml).
-//  2. Install cert-manager 1.15 (cert-manager-install.sh).
-//  3. Helm-install certctl-server with acmeServer.enabled=true.
-//  4. Apply the ClusterIssuer + Certificate.
-//  5. Wait for the Certificate to become Ready.
-//  6. Assert the Secret has tls.crt + tls.key.
-//
-// Gated behind KIND_AVAILABLE — CI doesn't run kind and skips this
-// cleanly. Operators run locally via `make acme-cert-manager-test`.
-
-package acmeintegration
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-	"time"
-)
-
-// kindAvailable returns true when the operator opted into the kind-
-// driven test path. CI default is opt-out (env unset → skip).
-func kindAvailable() bool {
-	return os.Getenv("KIND_AVAILABLE") != ""
-}
-
-// kindClusterName is the name passed to `kind create/delete cluster`.
-// Kept as a const so the test cleanup uses the exact same name as
-// setup (avoid orphan-cluster-after-flake).
-const kindClusterName = "certctl-acme-test"
-
-// TestCertManagerTrustAuthenticatedIssuance is the happy-path
-// integration: cert-manager submits a new-order against a profile in
-// trust_authenticated mode; certctl auto-resolves authzs (no solver
-// round-trip in this mode); cert-manager finalizes; the Secret lands.
-//
-// Runtime: ~6-8 minutes wall-clock on a workstation (most of which is
-// kind-create + cert-manager-controller-bootstrap, both cached on
-// re-runs after the first). Skips cleanly when KIND_AVAILABLE is
-// unset.
-func TestCertManagerTrustAuthenticatedIssuance(t *testing.T) {
-	if !kindAvailable() {
-		t.Skip("KIND_AVAILABLE unset — kind-driven cert-manager integration test skipped")
-	}
-	ctx := context.Background()
-
-	t.Log("creating kind cluster")
-	runCmd(t, ctx, "kind", "create", "cluster",
-		"--name", kindClusterName,
-		"--config", "kind-config.yaml")
-	t.Cleanup(func() {
-		// Best-effort cluster teardown — never fail the test on cleanup
-		// failure (operator can `kind delete cluster` manually).
-		_ = exec.Command("kind", "delete", "cluster", "--name", kindClusterName).Run()
-	})
-
-	t.Log("installing cert-manager")
-	runCmd(t, ctx, "bash", "cert-manager-install.sh")
-
-	// Step 3 — deploy certctl-server. The Helm chart at
-	// deploy/helm/certctl/ takes acmeServer.enabled=true; the operator
-	// is expected to have built + pushed (or kind-loaded) a `:test`
-	// image tag before the test runs. Document this in docs/acme-server.md.
-	t.Log("helm-installing certctl-test")
-	runCmd(t, ctx, "helm", "install", "certctl-test", "../../helm/certctl/",
-		"--set", "acmeServer.enabled=true",
-		"--set", "acmeServer.defaultProfileId=prof-test",
-		"--set", "image.tag=test",
-	)
-	waitForDeploymentReady(t, ctx, "default", "certctl-test", 3*time.Minute)
-
-	t.Log("applying ClusterIssuer + Certificate")
-	runCmd(t, ctx, "kubectl", "apply", "-f", "clusterissuer-trust-authenticated.yaml")
-	runCmd(t, ctx, "kubectl", "apply", "-f", "certificate-test.yaml")
-
-	t.Log("waiting for Certificate to become Ready")
-	waitForCertificateReady(t, ctx, "default", "test-com", 3*time.Minute)
-
-	t.Log("asserting Secret has tls.crt")
-	assertSecretHasCert(t, ctx, "default", "test-com-tls")
-
-	t.Log("happy-path issuance verified end-to-end")
-}
-
-// runCmd runs the command; failures fail the test immediately. We
-// stream combined stdout+stderr to t.Log on completion so the operator
-// can read the kubectl/kind output in CI logs (when run there with
-// KIND_AVAILABLE=1).
-func runCmd(t *testing.T, ctx context.Context, name string, args ...string) {
-	t.Helper()
-	cmd := exec.CommandContext(ctx, name, args...) //nolint:gosec // ARGS are test-controlled literals.
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("%s %s failed: %v\n%s", name, strings.Join(args, " "), err, out)
-	}
-	t.Logf("%s %s: %s", name, strings.Join(args, " "), strings.TrimSpace(string(out)))
-}
-
-// waitForDeploymentReady polls until the named deployment reports
-// Available=True. Wraps `kubectl wait` with a Go-level timeout so test
-// hangs are bounded.
-func waitForDeploymentReady(t *testing.T, ctx context.Context, namespace, name string, timeout time.Duration) {
-	t.Helper()
-	cctx, cancel := context.WithTimeout(ctx, timeout)
-	defer cancel()
-	cmd := exec.CommandContext(cctx, "kubectl", "-n", namespace, "wait",
-		"--for=condition=Available", fmt.Sprintf("--timeout=%ds", int(timeout.Seconds())),
-		"deployment/"+name) //nolint:gosec // ARGS are test-controlled literals.
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("deployment %s/%s did not become Ready in %v: %v\n%s",
-			namespace, name, timeout, err, out)
-	}
-}
-
-// waitForCertificateReady polls until the cert-manager Certificate
-// resource transitions to Ready=True. cert-manager's own
-// reconciliation loop is what advances the state; this just blocks
-// until the controller is happy.
-func waitForCertificateReady(t *testing.T, ctx context.Context, namespace, name string, timeout time.Duration) {
-	t.Helper()
-	cctx, cancel := context.WithTimeout(ctx, timeout)
-	defer cancel()
-	cmd := exec.CommandContext(cctx, "kubectl", "-n", namespace, "wait",
-		"--for=condition=Ready", fmt.Sprintf("--timeout=%ds", int(timeout.Seconds())),
-		"certificate/"+name) //nolint:gosec // ARGS are test-controlled literals.
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		// Dump the Certificate's events on failure so the operator
-		// can see exactly which reconciliation step failed.
-		describe := exec.Command("kubectl", "-n", namespace, "describe", "certificate", name)
-		describeOut, _ := describe.CombinedOutput()
-		t.Fatalf("certificate %s/%s did not become Ready in %v: %v\n%s\n--- describe ---\n%s",
-			namespace, name, timeout, err, out, describeOut)
-	}
-}
-
-// assertSecretHasCert checks that the named Secret has a non-empty
-// tls.crt entry. We don't validate the chain itself here — that's the
-// job of certctl's own integration test layer; this just confirms
-// cert-manager wrote something into the Secret on the
-// trust_authenticated happy-path.
-func assertSecretHasCert(t *testing.T, ctx context.Context, namespace, name string) {
-	t.Helper()
-	cctx, cancel := context.WithTimeout(ctx, 30*time.Second)
-	defer cancel()
-	cmd := exec.CommandContext(cctx, "kubectl", "-n", namespace, "get", "secret", name,
-		"-o", "jsonpath={.data.tls\\.crt}") //nolint:gosec // ARGS are test-controlled literals.
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("get secret %s/%s: %v\n%s", namespace, name, err, out)
-	}
-	if len(out) == 0 {
-		t.Fatalf("secret %s/%s has empty tls.crt", namespace, name)
-	}
-}

deploy/test/acme-integration/clusterissuer-challenge.yaml

@@ -1,31 +0,0 @@
-# Phase 5 — sample ClusterIssuer for the certctl challenge auth mode
-# (RFC 8555 §8 HTTP-01 / DNS-01 / TLS-ALPN-01). Use this for public-
-# trust-style deployments where per-identifier ownership proof is
-# required.
-#
-# Same bootstrap-root caBundle requirement as the trust_authenticated
-# variant — see clusterissuer-trust-authenticated.yaml comments.
-apiVersion: cert-manager.io/v1
-kind: ClusterIssuer
-metadata:
-  name: certctl-test-challenge
-spec:
-  acme:
-    email: test@example.com
-    # Point at a profile whose certificate_profiles.acme_auth_mode is
-    # set to 'challenge'. The certctl operator manages this column
-    # per-profile; see certctl/docs/acme-server.md "Per-profile auth
-    # mode" section.
-    server: https://certctl-test.default.svc.cluster.local:8443/acme/profile/prof-challenge/directory
-    caBundle: |
-      LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCi4uLgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-    privateKeySecretRef:
-      name: certctl-test-challenge-account-key
-    solvers:
-      # HTTP-01 via the in-cluster ingress-nginx. The cert-manager
-      # http-solver pod publishes the key authorization at
-      # http://<identifier>/.well-known/acme-challenge/<token>; the
-      # certctl HTTP01Validator (Phase 3) fetches it.
-      - http01:
-          ingress:
-            class: nginx

deploy/test/acme-integration/clusterissuer-trust-authenticated.yaml

@@ -1,42 +0,0 @@
-# Phase 5 — sample ClusterIssuer for the certctl trust_authenticated
-# auth mode (RFC 8555 §6 + certctl auth_mode=trust_authenticated, where
-# the JWS-authenticated ACME account is trusted to issue any identifier
-# the profile policy permits — no per-identifier ownership challenges).
-#
-# Use this as the starting template for any internal-PKI rollout.
-# Replace the caBundle placeholder with the base64-encoded PEM of the
-# certctl-server's self-signed bootstrap root, then `kubectl apply`.
-#
-# Generate the caBundle via:
-#   cat deploy/test/certs/ca.crt | base64 -w0
-# (See certctl/docs/acme-server.md "TLS trust bootstrap" section for the
-# end-to-end walkthrough — this is the single biggest first-time-deploy
-# footgun on cert-manager, captured as audit fix #9.)
-apiVersion: cert-manager.io/v1
-kind: ClusterIssuer
-metadata:
-  name: certctl-test-trust
-spec:
-  acme:
-    email: test@example.com
-    # Replace 'certctl-test' with your release name + adjust the
-    # profile path segment. Default profile path:
-    #   https://<service>.<namespace>.svc.cluster.local:8443/acme/profile/<profile-id>/directory
-    server: https://certctl-test.default.svc.cluster.local:8443/acme/profile/prof-test/directory
-    # caBundle: Audit fix #9. cert-manager validates the ACME server's
-    # TLS chain before submitting any account/order/finalize. With a
-    # self-signed bootstrap root, the ClusterIssuer MUST carry the root
-    # explicitly via this field.
-    caBundle: |
-      LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCi4uLgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-    privateKeySecretRef:
-      name: certctl-test-trust-account-key
-    solvers:
-      # In trust_authenticated mode the solver is unused at the
-      # validation step but cert-manager still requires at least one
-      # solver in the spec. http01-via-ingress-nginx is the cheapest
-      # placeholder shape that round-trips correctly through cert-
-      # manager's validation webhooks.
-      - http01:
-          ingress:
-            class: nginx

deploy/test/acme-integration/conformance-lego.sh

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-#
-# Phase 5 — lego-driven RFC 8555 conformance test. Drives a real ACME
-# client (lego v4) against the certctl ACME server in trust_authenticated
-# mode and exercises the full happy-path: register → new-order →
-# finalize → cert download.
-#
-# Caller (`make acme-rfc-conformance-test`) brings up the certctl
-# docker-compose stack first; this script just runs lego against it.
-#
-# Skips cleanly when CERTCTL_ACME_DIR is unset (the operator probably
-# meant to run the make target instead of this script directly).
-set -euo pipefail
-
-if [[ -z "${CERTCTL_ACME_DIR:-}" ]]; then
-  echo "CERTCTL_ACME_DIR unset — point at the certctl ACME directory URL"
-  echo "  e.g. CERTCTL_ACME_DIR=https://localhost:8443/acme/profile/prof-test/directory"
-  exit 1
-fi
-
-WORKDIR="$(mktemp -d -t certctl-lego-conf-XXXXXX)"
-trap 'rm -rf "${WORKDIR}"' EXIT
-
-# Skip TLS verification — the test stack uses certctl's self-signed
-# bootstrap cert. Operators in production use --insecure-skip-verify=false
-# and pass --tls-bundle for the real CA.
-LEGO_INSECURE="--insecure-skip-verify"
-
-# Step 1: register a fresh account.
-echo "==> lego: register account"
-lego --server "${CERTCTL_ACME_DIR}" \
-     --email conformance@example.com \
-     --domains conformance.example.com \
-     --path "${WORKDIR}" \
-     --accept-tos \
-     ${LEGO_INSECURE} \
-     register
-
-# Step 2: issue a cert (trust_authenticated mode auto-resolves authzs).
-echo "==> lego: run (issue conformance.example.com)"
-lego --server "${CERTCTL_ACME_DIR}" \
-     --email conformance@example.com \
-     --domains conformance.example.com \
-     --path "${WORKDIR}" \
-     --accept-tos \
-     ${LEGO_INSECURE} \
-     run
-
-# Step 3: assert the cert PEM landed.
-CERT_FILE="${WORKDIR}/certificates/conformance.example.com.crt"
-if [[ ! -s "${CERT_FILE}" ]]; then
-  echo "FAIL: ${CERT_FILE} is missing or empty"
-  exit 1
-fi
-openssl x509 -in "${CERT_FILE}" -noout -subject -issuer -dates
-echo "PASS: lego conformance happy-path completed"

deploy/test/acme-integration/kind-config.yaml

@@ -1,34 +0,0 @@
-# Phase 5 — kind-cluster shape for the cert-manager integration test.
-#
-# Single control-plane + single worker. Port 8443 (certctl ACME server)
-# and 80/443 (ingress-nginx for HTTP-01 solver) are extra-mapped onto
-# the host so the in-test workflow can curl the in-cluster services.
-#
-# Used by: deploy/test/acme-integration/certmanager_test.go
-# Invoked via: kind create cluster --name certctl-acme-test --config <this file>
-kind: Cluster
-apiVersion: kind.x-k8s.io/v1alpha4
-name: certctl-acme-test
-nodes:
-  - role: control-plane
-    kubeadmConfigPatches:
-      - |
-        kind: InitConfiguration
-        nodeRegistration:
-          kubeletExtraArgs:
-            node-labels: "ingress-ready=true"
-    extraPortMappings:
-      # ingress-nginx HTTP — needed for the challenge-mode solver.
-      - containerPort: 80
-        hostPort: 80
-        protocol: TCP
-      - containerPort: 443
-        hostPort: 443
-        protocol: TCP
-      # certctl-server HTTPS (the ACME directory + JWS-authenticated
-      # POST surface). Only required for out-of-cluster smoke tests; the
-      # in-cluster ClusterIssuer talks via Service DNS.
-      - containerPort: 30843
-        hostPort: 8443
-        protocol: TCP
-  - role: worker

deploy/test/apache/httpd-ssl.conf

@@ -1,13 +0,0 @@
-# Deploy-hardening II Phase 1 — minimal Apache SSL config for the
-# apache-test sidecar. The cert + chain + key are bind-mounted into
-# /usr/local/apache2/conf/certs and the e2e tests rotate them via
-# the apache connector's atomic-deploy primitive.
-LoadModule ssl_module modules/mod_ssl.so
-Listen 443
-<VirtualHost *:443>
-    ServerName apache-test.local
-    SSLEngine on
-    SSLCertificateFile /usr/local/apache2/conf/certs/cert.pem
-    SSLCertificateKeyFile /usr/local/apache2/conf/certs/key.pem
-    SSLCertificateChainFile /usr/local/apache2/conf/certs/chain.pem
-</VirtualHost>

deploy/test/apache/init-cert.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-# Generate an initial known-good cert so Apache starts cleanly. The
-# e2e tests rotate this via the connector.
-set -e
-mkdir -p /usr/local/apache2/conf/certs
-if [ ! -f /usr/local/apache2/conf/certs/cert.pem ]; then
-    openssl req -x509 -newkey rsa:2048 -keyout /usr/local/apache2/conf/certs/key.pem \
-        -out /usr/local/apache2/conf/certs/cert.pem -days 1 -nodes \
-        -subj "/CN=apache-test.local"
-    cp /usr/local/apache2/conf/certs/cert.pem /usr/local/apache2/conf/certs/chain.pem
-fi

deploy/test/caddy/Caddyfile

@@ -1,9 +0,0 @@
-{
-    admin 0.0.0.0:2019
-    auto_https off
-}
-
-:443 {
-    tls /etc/caddy/certs/cert.pem /etc/caddy/certs/key.pem
-    respond "OK"
-}

deploy/test/crl_ocsp_e2e_test.go

@@ -1,489 +0,0 @@
-//go:build integration
-
-// Package integration_test — CRL/OCSP-Responder Bundle Phase 6 e2e.
-//
-// Verifies the full revocation-status flow against a live stack:
-//   1. Issue a cert via the local issuer.
-//   2. Fetch the OCSP response for that cert's serial — expect Good.
-//   3. Revoke the cert via the standard revoke endpoint.
-//   4. Wait for the scheduler to refresh the CRL cache (or trigger an
-//      immediate cache miss by fetching the CRL directly — the
-//      cache-miss path uses singleflight to coalesce + regenerate).
-//   5. Fetch the CRL — assert the cert's serial is in the revocation list.
-//   6. Fetch the OCSP response again — expect Revoked.
-//   7. Verify the OCSP response was signed by the dedicated responder
-//      cert (NOT the CA key directly), per RFC 6960 §2.6.
-//   8. Verify the responder cert carries id-pkix-ocsp-nocheck (RFC 6960
-//      §4.2.2.2.1).
-//
-// Sandbox note: the certctl development sandbox doesn't have Docker
-// available, so this test was written but not executed there. CI runs
-// it via the standard integration-test workflow which spins up the
-// docker-compose.test.yml stack. Run locally:
-//
-//	cd deploy && docker compose -f docker-compose.test.yml up --build -d
-//	cd deploy/test && go test -tags integration -v -run TestCRLOCSPLifecycle -timeout 10m ./...
-
-package integration_test
-
-import (
-	"crypto/x509"
-	"encoding/asn1"
-	"encoding/json"
-	"encoding/pem"
-	"fmt"
-	"io"
-	"math/big"
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"golang.org/x/crypto/ocsp"
-)
-
-// ---------------------------------------------------------------------------
-// Test-stack-specific identifiers — match deploy/docker-compose.test.yml's
-// seed data + migrations/seed.sql. The CRL/OCSP suite issues its own certs
-// (rather than reusing mc-local-test from the main TestIntegrationSuite)
-// so the suites can run independently and in parallel.
-// ---------------------------------------------------------------------------
-
-const (
-	crlE2EIssuerID    = "iss-local"
-	crlE2EOwnerID     = "owner-test-admin"
-	crlE2ETeamID      = "team-test-ops"
-	crlE2EPolicyID    = "rp-default"
-	crlE2EProfileID   = "prof-test-tls"
-	crlE2EJobsTimeout = 180 * time.Second
-)
-
-// TestCRLOCSPLifecycle exercises the CRL/OCSP-Responder backend
-// end-to-end against the running test stack. Skipped in -short.
-func TestCRLOCSPLifecycle(t *testing.T) {
-	if testing.Short() {
-		t.Skip("integration only")
-	}
-
-	// Boot-state preconditions — assumes docker-compose.test.yml is
-	// up; the existing integration_test.go tests rely on the same
-	// invariant. If your run errors out here, run the up command
-	// from the package doc comment first.
-	requireServerReady(t)
-
-	issuerID := "iss-local" // assumes local issuer is seeded in the test stack
-
-	// 1. Issue a cert. Reuses the existing helper from integration_test.go
-	//    (issueCertificateAgainstLocal).
-	cert, certPEM, certSerial := issueLocalCert(t, "crl-ocsp-e2e.example.com")
-	t.Logf("issued cert serial=%s", certSerial)
-
-	// 2. Fetch OCSP for the fresh cert — expect Good.
-	resp1, responder1 := fetchOCSP(t, issuerID, certSerial)
-	if resp1.Status != ocsp.Good {
-		t.Fatalf("pre-revoke OCSP status = %d, want Good (0)", resp1.Status)
-	}
-	if !certHasOCSPNoCheck(responder1) {
-		t.Errorf("responder cert missing id-pkix-ocsp-nocheck extension (RFC 6960 §4.2.2.2.1)")
-	}
-	if responder1.Subject.CommonName == cert.Issuer.CommonName {
-		t.Errorf("OCSP response was signed by CA cert directly; expected dedicated responder cert per RFC 6960 §2.6")
-	}
-
-	// 3. Revoke the cert via the standard API.
-	revokeCertViaAPI(t, certSerial, "key_compromise")
-
-	// 4. Trigger the cache-miss path by fetching CRL directly.
-	//    The cache service's singleflight gate collapses concurrent
-	//    misses; the first fetch after revocation regenerates the CRL
-	//    with the new entry. (The scheduler also refreshes on its 1h
-	//    tick, but the test doesn't wait that long.)
-	time.Sleep(2 * time.Second) // allow scheduler debounce
-
-	crl := fetchCRL(t, issuerID)
-	if !crlContainsSerial(crl, certSerial) {
-		// If the cache hadn't expired yet, force a regen by hitting
-		// the endpoint a second time after a small delay — the
-		// staleness check in CRLCacheEntry.IsStale flips on
-		// next_update.
-		time.Sleep(3 * time.Second)
-		crl = fetchCRL(t, issuerID)
-		if !crlContainsSerial(crl, certSerial) {
-			t.Fatalf("revoked serial %s not present in CRL after wait", certSerial)
-		}
-	}
-	t.Logf("CRL contains revoked serial %s", certSerial)
-
-	// 5. Fetch OCSP again — expect Revoked.
-	resp2, _ := fetchOCSP(t, issuerID, certSerial)
-	if resp2.Status != ocsp.Revoked {
-		t.Fatalf("post-revoke OCSP status = %d, want Revoked (1)", resp2.Status)
-	}
-	t.Logf("OCSP shows revoked, reason=%d", resp2.RevocationReason)
-
-	// 6. Sanity: silence unused-variable lint for certPEM (kept in
-	//    signature for future assertions on cert chain validity).
-	_ = certPEM
-}
-
-// TestCRLOCSPPostEndpoint verifies the POST OCSP endpoint
-// (RFC 6960 §A.1.1) accepts a binary OCSPRequest body. Companion to
-// TestCRLOCSPLifecycle which exercises the GET form via fetchOCSP.
-func TestCRLOCSPPostEndpoint(t *testing.T) {
-	if testing.Short() {
-		t.Skip("integration only")
-	}
-	requireServerReady(t)
-
-	cert, _, certSerial := issueLocalCert(t, "post-ocsp-e2e.example.com")
-	caCert := fetchCACert(t, "iss-local")
-
-	ocspReq, err := ocsp.CreateRequest(cert, caCert, nil)
-	if err != nil {
-		t.Fatalf("CreateRequest: %v", err)
-	}
-
-	url := serverBaseURL(t) + "/.well-known/pki/ocsp/iss-local"
-	httpReq, err := http.NewRequest(http.MethodPost, url, strings.NewReader(string(ocspReq)))
-	if err != nil {
-		t.Fatalf("NewRequest: %v", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/ocsp-request")
-
-	httpResp, err := httpClient(t).Do(httpReq)
-	if err != nil {
-		t.Fatalf("POST OCSP: %v", err)
-	}
-	defer httpResp.Body.Close()
-	if httpResp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(httpResp.Body)
-		t.Fatalf("POST OCSP: status %d, body=%s", httpResp.StatusCode, body)
-	}
-	respBytes, _ := io.ReadAll(httpResp.Body)
-	parsed, err := ocsp.ParseResponse(respBytes, caCert)
-	if err != nil {
-		t.Fatalf("ParseResponse: %v", err)
-	}
-	if parsed.SerialNumber.Cmp(cert.SerialNumber) != 0 {
-		t.Errorf("POST OCSP response serial mismatch: got %v, want %v",
-			parsed.SerialNumber, cert.SerialNumber)
-	}
-	t.Logf("POST OCSP returned status=%d for serial=%s", parsed.Status, certSerial)
-}
-
-// ---------------------------------------------------------------------------
-// Helpers — these wrap the existing integration_test.go primitives where
-// possible; new helpers (fetchCRL, fetchOCSP, certHasOCSPNoCheck) are
-// added here. The full set lives in this file rather than being scattered
-// across package_test.go to keep the e2e suite self-contained per the
-// existing convention.
-// ---------------------------------------------------------------------------
-
-// crlE2ECert tracks the certctl-side ID + the parsed leaf together. The
-// revoke endpoint is keyed by the certctl certificate ID (mc-*), not by
-// the X.509 serial — so the test threads both through the helpers.
-type crlE2ECert struct {
-	CertctlID string            // e.g. "mc-crl-e2e-<n>"
-	Leaf      *x509.Certificate // parsed leaf
-	HexSerial string            // lowercase hex of Leaf.SerialNumber, no leading zero stripping
-	PEMChain  string            // raw pem_chain string from versions endpoint
-	IssuerCA  *x509.Certificate // parsed issuer CA (chain[1] when present, else chain[0])
-}
-
-// crlE2ECerts holds the in-flight cert-ID → cert mapping so revokeCertViaAPI
-// can resolve the hex serial back to the certctl cert ID. Populated by
-// issueLocalCert. Map access is safe because the e2e test is single-threaded
-// (the integration tag suites don't t.Parallel()).
-var crlE2ECerts = map[string]*crlE2ECert{}
-
-// issueLocalCert issues a cert against the test-stack's local issuer and
-// returns the parsed leaf + raw PEM chain + hex serial. Wires through the
-// existing integration_test.go primitives:
-//   - newTestClient() for the HTTPS Bearer-authenticated client
-//   - waitForJobsDone() for the async issuance job
-//   - parsePEMCert() for the PEM → x509.Certificate parse
-//
-// The cert ID is derived from a monotonic counter so successive calls in
-// the same run get unique IDs (mc-crl-e2e-1, mc-crl-e2e-2, …) — keeps the
-// test re-runnable against the same DB without ON CONFLICT noise.
-func issueLocalCert(t *testing.T, commonName string) (cert *x509.Certificate, certPEM string, hexSerial string) {
-	t.Helper()
-
-	c := newTestClient()
-
-	certID := fmt.Sprintf("mc-crl-e2e-%d", len(crlE2ECerts)+1)
-	body := fmt.Sprintf(`{
-		"id": %q,
-		"name": %q,
-		"common_name": %q,
-		"sans": [%q],
-		"issuer_id": %q,
-		"owner_id": %q,
-		"team_id": %q,
-		"renewal_policy_id": %q,
-		"certificate_profile_id": %q,
-		"environment": "test"
-	}`, certID, certID, commonName, commonName,
-		crlE2EIssuerID, crlE2EOwnerID, crlE2ETeamID, crlE2EPolicyID, crlE2EProfileID)
-
-	resp, err := c.Post("/api/v1/certificates", body)
-	if err != nil {
-		t.Fatalf("issueLocalCert: POST /certificates: %v", err)
-	}
-	if resp.StatusCode/100 != 2 {
-		t.Fatalf("issueLocalCert: POST status %d, body=%s", resp.StatusCode, readBody(resp))
-	}
-	resp.Body.Close()
-
-	// Trigger issuance + wait for the job to finish.
-	resp, err = c.Post("/api/v1/certificates/"+certID+"/renew", "")
-	if err != nil {
-		t.Fatalf("issueLocalCert: POST renew: %v", err)
-	}
-	resp.Body.Close()
-	waitForJobsDone(t, c, certID, crlE2EJobsTimeout)
-
-	// Pull the freshly-issued version.
-	resp, err = c.Get("/api/v1/certificates/" + certID + "/versions")
-	if err != nil {
-		t.Fatalf("issueLocalCert: GET versions: %v", err)
-	}
-	rawBody := readBody(resp)
-	var versions []certVersion
-	if err := json.Unmarshal([]byte(rawBody), &versions); err != nil {
-		// Versions endpoint may use the paged envelope.
-		var pr pagedResponse
-		if err := json.Unmarshal([]byte(rawBody), &pr); err != nil {
-			t.Fatalf("issueLocalCert: decode versions: %v (body: %s)", err, rawBody)
-		}
-		if err := json.Unmarshal(pr.Data, &versions); err != nil {
-			t.Fatalf("issueLocalCert: unmarshal paged versions: %v", err)
-		}
-	}
-	if len(versions) == 0 {
-		t.Fatalf("issueLocalCert: no versions returned for %s", certID)
-	}
-	v := versions[0]
-	if v.PEMChain == "" {
-		t.Fatalf("issueLocalCert: empty pem_chain on version %s", v.ID)
-	}
-
-	leaf, issuerCA := parsePEMChain(t, v.PEMChain)
-	hex := strings.ToLower(leaf.SerialNumber.Text(16))
-
-	crlE2ECerts[hex] = &crlE2ECert{
-		CertctlID: certID,
-		Leaf:      leaf,
-		HexSerial: hex,
-		PEMChain:  v.PEMChain,
-		IssuerCA:  issuerCA,
-	}
-	return leaf, v.PEMChain, hex
-}
-
-// parsePEMChain decodes a leaf || issuer || ... PEM bundle. Returns the leaf
-// + the next cert in the chain (the issuing CA, used as the OCSP issuer).
-// If the chain has only one cert (self-signed test root), returns it twice.
-func parsePEMChain(t *testing.T, chainPEM string) (leaf, issuer *x509.Certificate) {
-	t.Helper()
-	rest := []byte(chainPEM)
-	var certs []*x509.Certificate
-	for {
-		var block *pem.Block
-		block, rest = pem.Decode(rest)
-		if block == nil {
-			break
-		}
-		if block.Type != "CERTIFICATE" {
-			continue
-		}
-		c, err := x509.ParseCertificate(block.Bytes)
-		if err != nil {
-			t.Fatalf("parsePEMChain: %v", err)
-		}
-		certs = append(certs, c)
-	}
-	if len(certs) == 0 {
-		t.Fatalf("parsePEMChain: no certificates decoded from chain")
-	}
-	leaf = certs[0]
-	if len(certs) >= 2 {
-		issuer = certs[1]
-	} else {
-		issuer = certs[0] // self-signed test root
-	}
-	return leaf, issuer
-}
-
-// revokeCertViaAPI calls POST /api/v1/certificates/{id}/revoke. The certctl
-// API keys revocation by certctl cert ID (mc-*), not by X.509 serial — so
-// this resolver looks up the cert ID via the hex-serial registry populated
-// by issueLocalCert.
-func revokeCertViaAPI(t *testing.T, hexSerial string, reason string) {
-	t.Helper()
-	entry, ok := crlE2ECerts[strings.ToLower(hexSerial)]
-	if !ok {
-		t.Fatalf("revokeCertViaAPI: no certctl ID registered for serial %s — call issueLocalCert first", hexSerial)
-	}
-	c := newTestClient()
-	body := fmt.Sprintf(`{"reason": %q}`, reason)
-	resp, err := c.Post("/api/v1/certificates/"+entry.CertctlID+"/revoke", body)
-	if err != nil {
-		t.Fatalf("revokeCertViaAPI: %v", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode/100 != 2 {
-		t.Fatalf("revokeCertViaAPI: POST status %d, body=%s", resp.StatusCode, readBody(resp))
-	}
-}
-
-// fetchCRL hits GET /.well-known/pki/crl/{issuer_id} and returns the
-// parsed RevocationList. Asserts 200 + content-type.
-func fetchCRL(t *testing.T, issuerID string) *x509.RevocationList {
-	t.Helper()
-	url := serverBaseURL(t) + "/.well-known/pki/crl/" + issuerID
-	resp, err := httpClient(t).Get(url)
-	if err != nil {
-		t.Fatalf("fetchCRL Get: %v", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(resp.Body)
-		t.Fatalf("fetchCRL: status %d, body=%s", resp.StatusCode, body)
-	}
-	body, _ := io.ReadAll(resp.Body)
-	crl, err := x509.ParseRevocationList(body)
-	if err != nil {
-		t.Fatalf("ParseRevocationList: %v", err)
-	}
-	return crl
-}
-
-// fetchOCSP hits the GET form of the OCSP endpoint (the POST form is
-// exercised separately in TestCRLOCSPPostEndpoint). Returns the parsed
-// response + the responder cert (so the test can assert it's NOT the
-// CA cert, per RFC 6960 §2.6).
-func fetchOCSP(t *testing.T, issuerID, hexSerial string) (*ocsp.Response, *x509.Certificate) {
-	t.Helper()
-	url := fmt.Sprintf("%s/.well-known/pki/ocsp/%s/%s", serverBaseURL(t), issuerID, hexSerial)
-	resp, err := httpClient(t).Get(url)
-	if err != nil {
-		t.Fatalf("fetchOCSP Get: %v", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(resp.Body)
-		t.Fatalf("fetchOCSP: status %d, body=%s", resp.StatusCode, body)
-	}
-	body, _ := io.ReadAll(resp.Body)
-	caCert := fetchCACert(t, issuerID)
-	parsed, err := ocsp.ParseResponse(body, caCert)
-	if err != nil {
-		t.Fatalf("ParseResponse: %v", err)
-	}
-	return parsed, parsed.Certificate
-}
-
-// fetchCACert returns the issuing CA certificate for the given issuer.
-//
-// Strategy: a cert issued via issueLocalCert against this issuer left its
-// chain in the crlE2ECerts registry; the second cert in that chain is the
-// issuing CA (or the leaf itself for a self-signed test root). This
-// avoids a dependency on a /.well-known/pki/cacert/ endpoint that the
-// backend doesn't expose today — the bundle is published via the EST
-// /.well-known/est/cacerts surface (PKCS#7) but the test-harness route
-// here is simpler and deterministic.
-//
-// If no leaf has been issued yet against this issuer, falls back to a
-// just-in-time issuance so the helper is callable from any phase order.
-func fetchCACert(t *testing.T, issuerID string) *x509.Certificate {
-	t.Helper()
-	for _, entry := range crlE2ECerts {
-		if entry.IssuerCA != nil && entry.Leaf.Issuer.CommonName != "" {
-			// All issued e2e certs share the same iss-local CA; the first
-			// one we find is correct for issuerID == "iss-local".
-			if issuerID == crlE2EIssuerID || strings.HasPrefix(issuerID, "iss-local") {
-				return entry.IssuerCA
-			}
-		}
-	}
-	// Fallback: no cert in registry for this issuer yet — synthesise one.
-	_, _, _ = issueLocalCert(t, fmt.Sprintf("cacert-bootstrap-%d.example.com", time.Now().UnixNano()))
-	for _, entry := range crlE2ECerts {
-		if entry.IssuerCA != nil {
-			return entry.IssuerCA
-		}
-	}
-	t.Fatalf("fetchCACert: no CA cert resolvable for issuer %s after bootstrap", issuerID)
-	return nil
-}
-
-// crlContainsSerial returns true if the parsed CRL has an entry for
-// the given hex-encoded serial.
-func crlContainsSerial(crl *x509.RevocationList, hexSerial string) bool {
-	target := new(big.Int)
-	target.SetString(hexSerial, 16)
-	for _, entry := range crl.RevokedCertificateEntries {
-		if entry.SerialNumber.Cmp(target) == 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// certHasOCSPNoCheck returns true if the cert carries the
-// id-pkix-ocsp-nocheck extension (OID 1.3.6.1.5.5.7.48.1.5) per
-// RFC 6960 §4.2.2.2.1.
-func certHasOCSPNoCheck(cert *x509.Certificate) bool {
-	if cert == nil {
-		return false
-	}
-	oid := asn1.ObjectIdentifier{1, 3, 6, 1, 5, 5, 7, 48, 1, 5}
-	for _, ext := range cert.Extensions {
-		if ext.Id.Equal(oid) {
-			return true
-		}
-	}
-	return false
-}
-
-// requireServerReady polls /health until it returns 200, or t.Fatals after
-// 30s. The endpoint is unauthenticated (router.go pins it as a Bearer-free
-// liveness route for K8s/Docker probes) so it doubles as a "is the test
-// stack up?" probe before the suite makes its first authenticated call.
-func requireServerReady(t *testing.T) {
-	t.Helper()
-	client := newUnauthHTTPClient()
-	deadline := time.Now().Add(30 * time.Second)
-	url := serverURL + "/health"
-	for time.Now().Before(deadline) {
-		resp, err := client.Get(url)
-		if err == nil {
-			resp.Body.Close()
-			if resp.StatusCode == http.StatusOK {
-				return
-			}
-		}
-		time.Sleep(500 * time.Millisecond)
-	}
-	t.Fatalf("requireServerReady: %s never returned 200 within 30s — is the test stack up? (run `docker compose -f deploy/docker-compose.test.yml up -d` first)", url)
-}
-
-// serverBaseURL returns the server URL configured by the integration
-// harness (CERTCTL_TEST_SERVER_URL, defaulting to https://localhost:8443
-// per deploy/docker-compose.test.yml).
-func serverBaseURL(t *testing.T) string {
-	t.Helper()
-	return serverURL
-}
-
-// httpClient returns the unauthenticated TLS-trust-aware client from the
-// integration harness. The /.well-known/pki/{crl,ocsp}/ endpoints are
-// reachable without a Bearer token by design (M-006: relying parties
-// must validate revocation without API keys), so we deliberately use the
-// no-Authorization client here — this matches how a real revocation-
-// validating consumer would hit the endpoints in production.
-func httpClient(t *testing.T) *http.Client {
-	t.Helper()
-	return newUnauthHTTPClient()
-}

deploy/test/deploy_e2e_test.go

@@ -1,226 +0,0 @@
-//go:build integration
-
-// Package test contains the deploy-hardening I Phase 11 cross-
-// cutting end-to-end integration tests. These exercise the
-// internal/deploy package's load-bearing invariants end-to-end:
-//
-//   - atomicity: kill mid-deploy → file is fully old or fully new;
-//     never torn.
-//   - post-verify: deploy a wrong-fingerprint cert + the connector's
-//     verify hook → the rollback wire restores the previous bytes.
-//   - idempotency: deploy the same bytes twice → the second attempt
-//     is a no-op (no PreCommit/PostCommit calls).
-//   - concurrency: N simultaneous deploys to the same destination
-//     serialize via the deploy package's file-level mutex.
-//
-// Run via `INTEGRATION=1 go test -tags integration -race ./deploy/test/... -run Deploy`.
-package integration
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/certctl-io/certctl/internal/deploy"
-)
-
-// TestDeploy_Atomicity_FileIsAlwaysOldOrNew pins the load-bearing
-// POSIX-rename atomicity invariant. A reader hammering the
-// destination during 30 alternating writes either sees the OLD
-// bytes or the NEW bytes — never an intermediate state. Closes
-// the operator-facing question "is my cert deploy interruption-
-// safe?".
-func TestDeploy_Atomicity_FileIsAlwaysOldOrNew(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "cert.pem")
-	old := []byte(strings.Repeat("OLD-CERT-PEM-", 200))
-	newer := []byte(strings.Repeat("NEW-CERT-PEM-", 200))
-	if err := os.WriteFile(path, old, 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	stop := make(chan struct{})
-	var torn atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		for {
-			select {
-			case <-stop:
-				return
-			default:
-			}
-			b, err := os.ReadFile(path)
-			if err != nil {
-				continue
-			}
-			s := string(b)
-			if s != string(old) && s != string(newer) {
-				torn.Store(true)
-				return
-			}
-		}
-	}()
-
-	for i := 0; i < 30; i++ {
-		writeBytes := old
-		if i%2 == 0 {
-			writeBytes = newer
-		}
-		if _, err := deploy.AtomicWriteFile(context.Background(), path, writeBytes, deploy.WriteOptions{
-			SkipIdempotent: true,
-		}); err != nil {
-			t.Fatalf("write %d: %v", i, err)
-		}
-	}
-	close(stop)
-	wg.Wait()
-	if torn.Load() {
-		t.Error("torn read observed (rename atomicity broken)")
-	}
-}
-
-// TestDeploy_PostVerify_WrongCertTriggersRollback simulates a
-// mis-deployed cert: the deploy.Apply succeeds at the file-write
-// + reload level, but the connector's post-deploy verify (run
-// AFTER Apply returns) detects the SHA-256 mismatch and rolls
-// back manually using the BackupPaths that Apply returned. The
-// final on-disk state matches the OLD bytes; the rollback wire
-// works end-to-end.
-func TestDeploy_PostVerify_WrongCertTriggersRollback(t *testing.T) {
-	dir := t.TempDir()
-	cert := filepath.Join(dir, "cert.pem")
-	if err := os.WriteFile(cert, []byte("OLD-CERT"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	plan := deploy.Plan{
-		Files: []deploy.File{{Path: cert, Bytes: []byte("WRONG-CERT")}},
-		PostCommit: func(_ context.Context) error {
-			// Reload would normally verify the cert via the post-deploy
-			// TLS handshake. Here we simulate the verify failure by
-			// returning an error from PostCommit (which triggers the
-			// deploy package's automatic rollback).
-			//
-			// On the first call (the real deploy), return an error so
-			// the rollback fires; on the second call (the rollback's
-			// re-PostCommit against the restored bytes), succeed so
-			// rollback completes cleanly.
-			return errors.New("post-deploy verify: SHA-256 mismatch")
-		},
-	}
-
-	// First call to PostCommit fails; the rollback's second call
-	// would also fail with the same handler — so we use a stateful
-	// counter.
-	var postCalls int32
-	plan.PostCommit = func(_ context.Context) error {
-		if atomic.AddInt32(&postCalls, 1) == 1 {
-			return errors.New("post-deploy verify: SHA-256 mismatch")
-		}
-		return nil
-	}
-
-	_, err := deploy.Apply(context.Background(), plan)
-	if !errors.Is(err, deploy.ErrReloadFailed) {
-		t.Fatalf("got %v, want ErrReloadFailed", err)
-	}
-	got, _ := os.ReadFile(cert)
-	if string(got) != "OLD-CERT" {
-		t.Errorf("cert after rollback = %q, want OLD-CERT", got)
-	}
-	if atomic.LoadInt32(&postCalls) != 2 {
-		t.Errorf("PostCommit calls = %d, want 2 (1 deploy + 1 rollback re-call)", postCalls)
-	}
-}
-
-// TestDeploy_Idempotency_SecondDeployIsNoOp pins the SHA-256
-// short-circuit. Defends against agent-restart retry storms that
-// otherwise hammer targets with no-op reloads.
-func TestDeploy_Idempotency_SecondDeployIsNoOp(t *testing.T) {
-	dir := t.TempDir()
-	cert := filepath.Join(dir, "cert.pem")
-	bytes := []byte("STABLE-CERT-PEM")
-	if err := os.WriteFile(cert, bytes, 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	var preCalls, postCalls int32
-	plan := deploy.Plan{
-		Files: []deploy.File{{Path: cert, Bytes: bytes}},
-		PreCommit: func(_ context.Context, _ map[string]string) error {
-			atomic.AddInt32(&preCalls, 1)
-			return nil
-		},
-		PostCommit: func(_ context.Context) error {
-			atomic.AddInt32(&postCalls, 1)
-			return nil
-		},
-	}
-	res, err := deploy.Apply(context.Background(), plan)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !res.SkippedAsIdempotent {
-		t.Error("expected SkippedAsIdempotent=true")
-	}
-	if preCalls != 0 || postCalls != 0 {
-		t.Errorf("expected 0 calls, got %d/%d", preCalls, postCalls)
-	}
-}
-
-// TestDeploy_Concurrent_SamePathsSerialize fires N simultaneous
-// deploys to the same destination. The deploy package's file-
-// level mutex must serialize them: max-in-flight = 1.
-func TestDeploy_Concurrent_SamePathsSerialize(t *testing.T) {
-	dir := t.TempDir()
-	cert := filepath.Join(dir, "cert.pem")
-
-	const N = 8
-	var inFlight, maxInFlight int32
-	var wg sync.WaitGroup
-	for i := 0; i < N; i++ {
-		wg.Add(1)
-		go func(idx int) {
-			defer wg.Done()
-			plan := deploy.Plan{
-				Files: []deploy.File{{
-					Path:  cert,
-					Bytes: []byte(fmt.Sprintf("WRITER-%d", idx)),
-				}},
-				SkipIdempotent: true,
-				PostCommit: func(_ context.Context) error {
-					n := atomic.AddInt32(&inFlight, 1)
-					for {
-						m := atomic.LoadInt32(&maxInFlight)
-						if n <= m || atomic.CompareAndSwapInt32(&maxInFlight, m, n) {
-							break
-						}
-					}
-					time.Sleep(2 * time.Millisecond)
-					atomic.AddInt32(&inFlight, -1)
-					return nil
-				},
-			}
-			if _, err := deploy.Apply(context.Background(), plan); err != nil {
-				t.Errorf("Apply %d: %v", idx, err)
-			}
-		}(i)
-	}
-	wg.Wait()
-	if maxInFlight > 1 {
-		t.Errorf("max in-flight = %d, want 1 (mutex broken)", maxInFlight)
-	}
-	got, _ := os.ReadFile(cert)
-	if !strings.HasPrefix(string(got), "WRITER-") {
-		t.Errorf("file content not from any writer: %q", got)
-	}
-}

deploy/test/dovecot/dovecot.conf

@@ -1,11 +0,0 @@
-protocols = imap
-listen = *
-ssl = required
-ssl_cert = </etc/dovecot/certs/cert.pem
-ssl_key = </etc/dovecot/certs/key.pem
-service imap-login {
-    inet_listener imaps {
-        port = 993
-        ssl = yes
-    }
-}

deploy/test/envoy/envoy.yaml

@@ -1,35 +0,0 @@
-admin:
-  address:
-    socket_address:
-      address: 0.0.0.0
-      port_value: 9901
-static_resources:
-  listeners:
-    - name: https
-      address:
-        socket_address: { address: 0.0.0.0, port_value: 443 }
-      filter_chains:
-        - transport_socket:
-            name: envoy.transport_sockets.tls
-            typed_config:
-              "@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
-              common_tls_context:
-                tls_certificates:
-                  - certificate_chain: { filename: /etc/envoy/certs/cert.pem }
-                    private_key:       { filename: /etc/envoy/certs/key.pem }
-          filters:
-            - name: envoy.filters.network.http_connection_manager
-              typed_config:
-                "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
-                stat_prefix: ingress_http
-                http_filters:
-                  - name: envoy.filters.http.router
-                    typed_config:
-                      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
-                route_config:
-                  virtual_hosts:
-                    - name: backend
-                      domains: ["*"]
-                      routes:
-                        - match: { prefix: "/" }
-                          direct_response: { status: 200 }

deploy/test/est/.gitkeep

@@ -1,6 +0,0 @@
-# EST RFC 7030 hardening master bundle Phase 10.1.
-# This directory is the libest sidecar's working dir (bind-mounted as
-# /config/est). The integration test writes CSRs here + reads issued
-# certs back; this .gitkeep keeps the directory present in the repo
-# so a fresh `docker compose --profile est-e2e up` doesn't bind-mount
-# a missing path.

deploy/test/est_e2e_test.go

@@ -1,354 +0,0 @@
-//go:build integration
-
-// EST RFC 7030 hardening master bundle Phase 10.2 — libest sidecar
-// integration tests. Five named tests exercise the live certctl
-// server's EST endpoints through Cisco's libest reference client
-// (estclient binary inside the certctl-test-libest sidecar container).
-//
-// Skip conditions:
-//   - INTEGRATION env var not set (matches integration_test.go).
-//   - The libest sidecar isn't running (the test detects this by
-//     `docker inspect certctl-test-libest` and skips if absent).
-//   - The EST endpoint isn't reachable from inside the network (the
-//     test probes /.well-known/est/cacerts via estclient -g and
-//     skips if the route returns 404).
-//
-// Operator workflow:
-//
-//	cd deploy
-//	docker compose -f docker-compose.test.yml --profile est-e2e build libest-client
-//	docker compose -f docker-compose.test.yml --profile est-e2e up -d
-//	cd test
-//	INTEGRATION=1 go test -tags integration -v -run 'TestEST_LibESTClient' ./...
-//
-// CI runs this in the same job that already runs integration_test.go;
-// the docker-compose.test.yml libest-client entry + the Dockerfile
-// land in the same commit so a fresh `make integration-test-est`
-// (CI-side wrapper) works without operator intervention.
-
-package integration_test
-
-import (
-	"bytes"
-	"context"
-	"crypto/x509"
-	"encoding/pem"
-	"fmt"
-	"os/exec"
-	"strings"
-	"testing"
-	"time"
-)
-
-// libestContainer is the docker-compose service name + container_name
-// the sidecar uses (deploy/docker-compose.test.yml::libest-client).
-const libestContainer = "certctl-test-libest"
-
-// estServerHostInsideNetwork is the certctl-server hostname libest
-// resolves inside the certctl-test docker network. The sidecar's
-// /etc/hosts is auto-populated by docker-compose's bridge network so
-// `certctl-server` resolves to 10.30.50.6 (the static IP from the
-// compose file).
-const estServerHostInsideNetwork = "certctl-server"
-
-// estPortInsideNetwork is the certctl HTTPS port inside the docker
-// network. NOT the host-mapped port (8443 → 8443 via compose); the
-// sidecar talks straight to the container.
-const estPortInsideNetwork = "8443"
-
-// estCABundleInContainer is the bind-mounted certctl CA bundle the
-// libest sidecar pins TLS against. Path matches the volume mount in
-// docker-compose.test.yml::libest-client.
-const estCABundleInContainer = "/config/certs/ca.crt"
-
-// dockerExec runs `docker exec <container> <args>` and returns
-// stdout + stderr + the run error. Used by every libest test below.
-// Centralised so a future docker-cli refactor (podman, kubectl exec)
-// only changes one place.
-func dockerExec(ctx context.Context, container string, args ...string) (string, string, error) {
-	full := append([]string{"exec", container}, args...)
-	cmd := exec.CommandContext(ctx, "docker", full...)
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
-	return stdout.String(), stderr.String(), err
-}
-
-// libestSidecarReady checks that the libest sidecar container is
-// running. Returns the docker-inspect status string + a boolean for
-// "ready"; the boolean is what tests use to skip cleanly when the
-// operator forgot the --profile est-e2e flag.
-func libestSidecarReady(ctx context.Context) (string, bool) {
-	cmd := exec.CommandContext(ctx, "docker", "inspect", "-f", "{{.State.Status}}", libestContainer)
-	var out, errBuf bytes.Buffer
-	cmd.Stdout = &out
-	cmd.Stderr = &errBuf
-	if err := cmd.Run(); err != nil {
-		return errBuf.String(), false
-	}
-	status := strings.TrimSpace(out.String())
-	return status, status == "running"
-}
-
-// runEstclient is the workhorse helper that drives `estclient` inside
-// the sidecar. Returns the raw stdout (typically the issued cert PEM
-// or the cacerts PKCS#7 base64 blob) + a useful error including
-// stderr on failure.
-//
-// The args are appended after a baseline {`estclient`, ...common
-// flags} shape that pins TLS against the certctl CA bundle + sets the
-// per-test-run output dir.
-func runEstclient(ctx context.Context, t *testing.T, extraArgs ...string) (string, error) {
-	t.Helper()
-	baseArgs := []string{
-		"estclient",
-		"-s", estServerHostInsideNetwork,
-		"-p", estPortInsideNetwork,
-		"-c", estCABundleInContainer,
-	}
-	args := append(baseArgs, extraArgs...)
-	stdout, stderr, err := dockerExec(ctx, libestContainer, args...)
-	if err != nil {
-		return stdout, fmt.Errorf("estclient %v: %w (stderr=%q)", args, err, stderr)
-	}
-	return stdout, nil
-}
-
-// requireESTSidecar is the per-test skip guard. If the libest sidecar
-// isn't running, every EST integration test skips with a message that
-// tells the operator the exact command to bring it up.
-func requireESTSidecar(t *testing.T) {
-	t.Helper()
-	if !integrationOptedIn() {
-		t.Skip("integration tests require INTEGRATION=1; skipping libest e2e suite")
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	if status, ready := libestSidecarReady(ctx); !ready {
-		t.Skipf("libest sidecar (container %q) not running (status=%q). Run `cd deploy && docker compose -f docker-compose.test.yml --profile est-e2e up -d libest-client` to bring it up.", libestContainer, status)
-	}
-}
-
-// integrationOptedIn mirrors integration_test.go's existing INTEGRATION
-// env-var convention. We can't import the helper from integration_test.go
-// because they're in the same package + the convention is just one
-// env-var read.
-func integrationOptedIn() bool {
-	for _, v := range []string{"INTEGRATION", "RUN_INTEGRATION"} {
-		if val := strings.TrimSpace(getenv(v)); val != "" && val != "0" && !strings.EqualFold(val, "false") {
-			return true
-		}
-	}
-	return false
-}
-
-// getenv is a tiny wrapper so we don't pull in os twice from this file
-// (integration_test.go has the canonical envOr that uses os.Getenv).
-// Kept self-contained so the est_e2e_test.go file is independently
-// readable.
-func getenv(k string) string {
-	v := exec.Command("printenv", k)
-	out, _ := v.Output()
-	return strings.TrimSpace(string(out))
-}
-
-// TestEST_LibESTClient_Enrollment_Integration is the canonical
-// happy-path test. estclient does:
-//
-//  1. GET cacerts to retrieve the CA chain.
-//  2. POST simpleenroll with a freshly-generated CSR; receive the
-//     issued cert chain back.
-//  3. Parse the issued cert + assert Subject CN matches what we asked.
-//
-// HTTP Basic auth is NOT used here — the test profile (CERTCTL_EST_PROFILE_E2E_*)
-// is configured without an enrollment password so the smoke test
-// exercises the simplest happy path.
-func TestEST_LibESTClient_Enrollment_Integration(t *testing.T) {
-	requireESTSidecar(t)
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
-	defer cancel()
-
-	// Step 1 — get cacerts. estclient writes the PKCS#7 to /config/est/cacerts.p7.
-	if _, err := runEstclient(ctx, t, "-g", "-o", "/config/est"); err != nil {
-		t.Fatalf("get cacerts: %v", err)
-	}
-
-	// Step 2 — generate a CSR + enroll. estclient -e mode generates
-	// the keypair + the CSR + drives simpleenroll in one shot.
-	if _, err := runEstclient(ctx, t, "-e", "--common-name", "device-e2e-001.example.com",
-		"-o", "/config/est"); err != nil {
-		t.Fatalf("simpleenroll: %v", err)
-	}
-
-	// Step 3 — read the issued cert back via docker exec + parse.
-	pemBytes, _, err := dockerExec(ctx, libestContainer, "cat", "/config/est/cert-0-0.pkcs7")
-	if err != nil {
-		t.Fatalf("read issued cert: %v", err)
-	}
-	if !strings.Contains(pemBytes, "BEGIN") && !strings.Contains(pemBytes, "MII") {
-		t.Errorf("issued cert output didn't look like PEM/base64: first 80 bytes = %q", truncateHead(pemBytes, 80))
-	}
-}
-
-// TestEST_LibESTClient_MTLSEnrollment_Integration drives the mTLS
-// sibling route /.well-known/est-mtls/<PathID>/simpleenroll. The
-// sidecar carries a bootstrap cert under /config/certs/bootstrap.pem
-// signed by the per-profile mTLS trust anchor; estclient presents
-// it via the -k/-c flags.
-//
-// Skip when the bootstrap cert isn't installed in the sidecar (the
-// operator has to run a one-time setup script to mint the cert
-// against the per-profile trust bundle's CA key — the integration
-// suite can't bootstrap that automatically without exposing the
-// trust anchor's private key, which we deliberately keep out of git).
-func TestEST_LibESTClient_MTLSEnrollment_Integration(t *testing.T) {
-	requireESTSidecar(t)
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// Probe for the bootstrap cert. Skip if the operator hasn't
-	// pre-provisioned one.
-	if _, _, err := dockerExec(ctx, libestContainer, "test", "-f", "/config/certs/bootstrap.pem"); err != nil {
-		t.Skip("/config/certs/bootstrap.pem not present in libest sidecar — skipping mTLS path. To enable: mint a bootstrap cert against the per-profile mTLS trust anchor and copy into deploy/test/certs/.")
-	}
-
-	if _, err := runEstclient(ctx, t,
-		"-e",
-		"--pem-output",
-		"-k", "/config/certs/bootstrap.key",
-		"-c", "/config/certs/bootstrap.pem",
-		"--common-name", "device-mtls-001.example.com",
-		"-o", "/config/est",
-	); err != nil {
-		t.Fatalf("mTLS simpleenroll: %v", err)
-	}
-}
-
-// TestEST_LibESTClient_ServerKeygen_Integration drives RFC 7030
-// §4.4 server-keygen. estclient submits a CSR + receives the issued
-// cert + the encrypted private key (CMS EnvelopedData) in a multipart
-// response. The test asserts both parts arrive + the key part is
-// non-empty. Decrypting the key requires the CSR-side private key
-// (which estclient holds) — left as a smoke check rather than a full
-// round-trip because libest's --serverkeygen flag does the decrypt
-// internally before writing the key to disk.
-func TestEST_LibESTClient_ServerKeygen_Integration(t *testing.T) {
-	requireESTSidecar(t)
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	if _, err := runEstclient(ctx, t,
-		"-e",
-		"--serverkeygen",
-		"--common-name", "device-keygen-001.example.com",
-		"-o", "/config/est",
-	); err != nil {
-		// Some libest builds report a non-zero exit when the server
-		// returns a profile-disabled 404; map that to a Skip so the
-		// suite stays green when the e2e profile hasn't enabled
-		// SERVER_KEYGEN. The error message contains "404" in either case.
-		if strings.Contains(err.Error(), "404") {
-			t.Skip("server-keygen disabled on the e2e EST profile (HTTP 404). Enable via CERTCTL_EST_PROFILE_E2E_SERVER_KEYGEN_ENABLED=true in docker-compose.test.yml.")
-		}
-		t.Fatalf("serverkeygen: %v", err)
-	}
-
-	// Assert the key part was written. estclient writes the private
-	// key to a deterministic filename when --serverkeygen is set;
-	// exact name depends on libest version, so we glob.
-	stdout, _, err := dockerExec(ctx, libestContainer, "sh", "-c",
-		"ls /config/est/ | grep -E '\\.(key|pkey|p8)$' | head -1")
-	if err != nil || strings.TrimSpace(stdout) == "" {
-		t.Errorf("server-keygen response did not write a key file: stdout=%q err=%v", stdout, err)
-	}
-}
-
-// TestEST_LibESTClient_RateLimited_Integration drives N+1 enrollments
-// from the same (CN, source-IP) pair to trip the per-principal
-// sliding-window rate limiter. The 4th enrollment (default cap=3
-// matches Intune's PerDeviceRateLimiter default) MUST fail with a
-// 429 response.
-//
-// The test relies on the e2e profile being configured with
-// RATE_LIMIT_PER_PRINCIPAL_24H=3 so the cap is testable in a
-// reasonable test window.
-func TestEST_LibESTClient_RateLimited_Integration(t *testing.T) {
-	requireESTSidecar(t)
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
-	defer cancel()
-
-	commonName := "device-ratelimit-001.example.com"
-	allowed := 3
-	for i := 1; i <= allowed; i++ {
-		if _, err := runEstclient(ctx, t,
-			"-e",
-			"--common-name", commonName,
-			"-o", "/config/est",
-		); err != nil {
-			t.Fatalf("enroll #%d should have succeeded: %v", i, err)
-		}
-	}
-	// (allowed+1)-th attempt MUST be rate-limited.
-	out, err := runEstclient(ctx, t,
-		"-e",
-		"--common-name", commonName,
-		"-o", "/config/est",
-	)
-	if err == nil {
-		t.Fatalf("enroll #%d should have been rate-limited, but succeeded: %q", allowed+1, out)
-	}
-	// estclient surfaces the HTTP status in stderr; the test wrapper
-	// captures both streams in the err message.
-	if !strings.Contains(err.Error(), "429") && !strings.Contains(err.Error(), "Too Many") {
-		t.Errorf("enroll #%d failed but not with a 429-shaped error: %v", allowed+1, err)
-	}
-}
-
-// TestEST_LibESTClient_ChannelBinding_Integration drives the RFC 9266
-// tls-exporter binding path. libest's --tls-exporter flag (3.2.0+)
-// computes the binding client-side + embeds it as the
-// id-aa-est-tls-exporter CMC unsignedAttribute on the CSR.
-//
-// On the server side we expect the channel-binding gate to pass for
-// the matching binding + reject when we forge a wrong binding (libest
-// has no explicit "wrong binding" knob — the test exercises only the
-// passing path, and the rejection path is covered by the unit test
-// suite at internal/cms/channelbinding_test.go).
-func TestEST_LibESTClient_ChannelBinding_Integration(t *testing.T) {
-	requireESTSidecar(t)
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	if _, err := runEstclient(ctx, t,
-		"-e",
-		"--tls-exporter",
-		"--common-name", "device-binding-001.example.com",
-		"-o", "/config/est",
-	); err != nil {
-		// Libest builds without RFC 9266 support exit non-zero with
-		// "unknown option --tls-exporter". Surface as Skip so the
-		// suite stays informative on libest variants that lack it.
-		if strings.Contains(err.Error(), "unknown option") || strings.Contains(err.Error(), "invalid option") {
-			t.Skipf("libest build lacks --tls-exporter support: %v", err)
-		}
-		t.Fatalf("channel-binding enroll: %v", err)
-	}
-}
-
-// truncateHead returns the first n runes of s (or all of s if it's
-// shorter), used to keep error messages from dumping multi-MB cert
-// blobs into the test log.
-func truncateHead(s string, n int) string {
-	if len(s) <= n {
-		return s
-	}
-	return s[:n] + "...(truncated)"
-}
-
-// silenceUnused keeps imports live across libest builds that may
-// trigger a different code path. pem + x509 are both referenced by
-// the cert-parsing branch of the Enrollment_Integration test in
-// future expansions.
-var _ = pem.Decode
-var _ = x509.ParseCertificate

deploy/test/f5-mock-icontrol/Dockerfile

@@ -1,21 +0,0 @@
-# f5-mock-icontrol sidecar: in-tree Go server implementing the
-# subset of F5 iControl REST that the certctl F5 connector exercises.
-# Used by the deploy-hardening II Phase 10 vendor-edge tests as a
-# CI-friendly alternative to a real F5 BIG-IP appliance.
-#
-# Per H-001 guard: every FROM is digest-pinned. Operator re-pins
-# quarterly per docs/deployment-vendor-matrix.md.
-
-# golang:1.25.10-bookworm digest pinned per H-001.
-FROM golang:1.25.10-bookworm@sha256:e3a54b77385b4f8a31c1db4d12429ffb3718ea76865731a787c497755d409547 AS builder
-WORKDIR /src
-COPY deploy/test/f5-mock-icontrol/ ./
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags "-s -w" -o /out/f5-mock-icontrol .
-
-# debian:bookworm-slim digest pinned per H-001 (matches libest sidecar).
-FROM debian:bookworm-slim@sha256:5a2a80d11944804c01b8619bc967e31801ec39bf3257ab80b91070eb23625644
-RUN useradd --create-home --shell /bin/bash mockf5
-COPY --from=builder /out/f5-mock-icontrol /usr/local/bin/f5-mock-icontrol
-USER mockf5
-EXPOSE 443 8080
-ENTRYPOINT ["/usr/local/bin/f5-mock-icontrol"]

deploy/test/f5-mock-icontrol/go.mod

@@ -1,3 +0,0 @@
-module github.com/certctl-io/certctl/deploy/test/f5-mock-icontrol
-
-go 1.25.10

deploy/test/f5-mock-icontrol/main.go

@@ -1,320 +0,0 @@
-// Package main implements the f5-mock-icontrol sidecar — an in-tree
-// Go server that implements the subset of F5's iControl REST API
-// the certctl F5 connector exercises. Used by the deploy-hardening
-// II Phase 10 vendor-edge tests as a CI-friendly alternative to a
-// real F5 BIG-IP appliance.
-//
-// Per frozen decision 0.3 (deploy-hardening II): the operator-supplied
-// real F5 vagrant box documented in docs/connector-f5.md is the
-// validation tier above the mock. CI runs against this mock; paying-
-// customer validation runs against the real F5.
-//
-// Implements:
-//   - POST /mgmt/shared/authn/login (token-based auth)
-//   - POST /mgmt/shared/file-transfer/uploads/<filename> (multi-chunk)
-//   - POST /mgmt/tm/sys/crypto/cert (install cert)
-//   - POST /mgmt/tm/sys/crypto/key (install key)
-//   - POST /mgmt/tm/transaction (create txn)
-//   - POST /mgmt/tm/transaction/<txn-id> (commit txn)
-//   - PATCH /mgmt/tm/ltm/profile/client-ssl/<name> (update SSL profile)
-//   - GET /mgmt/tm/ltm/profile/client-ssl/<name> (read SSL profile)
-//   - DELETE /mgmt/tm/sys/crypto/cert/<name> (remove cert)
-//   - DELETE /mgmt/tm/sys/crypto/key/<name> (remove key)
-//
-// State: in-memory map per running process. Lost on container restart.
-// CI tests handle restarts by re-running the test (Authenticate +
-// install + transaction sequence is idempotent against a fresh state).
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"strings"
-	"sync"
-	"sync/atomic"
-)
-
-// state is the mock server's in-memory view of an F5 BIG-IP.
-type state struct {
-	mu sync.RWMutex
-	// uploads holds raw uploaded bytes keyed by filename.
-	uploads map[string][]byte
-	// certs holds installed cert metadata keyed by name.
-	certs map[string]map[string]any
-	// keys holds installed key metadata keyed by name.
-	keys map[string]map[string]any
-	// profiles holds client-ssl profile state keyed by full path
-	// (partition + name, e.g., "~Common~my-ssl-profile").
-	profiles map[string]map[string]any
-	// transactions holds open transactions keyed by ID.
-	transactions map[string][]map[string]any
-	// txnCounter mints fresh transaction IDs.
-	txnCounter atomic.Uint64
-	// authToken is the singleton bearer token issued at /authn/login.
-	// Real F5 issues per-session tokens; the mock issues one + accepts
-	// it forever (sufficient for CI test harness).
-	authToken string
-}
-
-func newState() *state {
-	return &state{
-		uploads:      make(map[string][]byte),
-		certs:        make(map[string]map[string]any),
-		keys:         make(map[string]map[string]any),
-		profiles:     make(map[string]map[string]any),
-		transactions: make(map[string][]map[string]any),
-		authToken:    "mock-bearer-token-do-not-use-in-prod",
-	}
-}
-
-func main() {
-	s := newState()
-	mux := http.NewServeMux()
-
-	mux.HandleFunc("/mgmt/shared/authn/login", s.handleLogin)
-	mux.HandleFunc("/mgmt/shared/file-transfer/uploads/", s.handleUpload)
-	mux.HandleFunc("/mgmt/tm/sys/crypto/cert", s.handleInstallCert)
-	mux.HandleFunc("/mgmt/tm/sys/crypto/cert/", s.handleDeleteCert)
-	mux.HandleFunc("/mgmt/tm/sys/crypto/key", s.handleInstallKey)
-	mux.HandleFunc("/mgmt/tm/sys/crypto/key/", s.handleDeleteKey)
-	mux.HandleFunc("/mgmt/tm/transaction", s.handleCreateTxn)
-	mux.HandleFunc("/mgmt/tm/transaction/", s.handleCommitTxn)
-	mux.HandleFunc("/mgmt/tm/ltm/profile/client-ssl/", s.handleProfile)
-	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("ok"))
-	})
-
-	log.Println("f5-mock-icontrol listening on :443 (HTTPS) and :8080 (HTTP)")
-	go func() {
-		if err := http.ListenAndServe(":8080", mux); err != nil {
-			log.Fatalf("HTTP listen: %v", err)
-		}
-	}()
-	// HTTPS uses a self-signed cert generated at startup. Real F5 has a
-	// system cert; we keep the mock simple by using a self-signed pair.
-	cert, key := selfSignedCert()
-	srv := &http.Server{Addr: ":443", Handler: mux}
-	if err := writeAndServeTLS(srv, cert, key); err != nil {
-		log.Fatalf("HTTPS listen: %v", err)
-	}
-}
-
-func (s *state) handleLogin(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	var req map[string]any
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, fmt.Sprintf("bad body: %v", err), http.StatusBadRequest)
-		return
-	}
-	// Real F5 validates username + password against TACACS+ / RADIUS /
-	// local user table. Mock accepts any non-empty credentials.
-	user, _ := req["username"].(string)
-	pass, _ := req["password"].(string)
-	if user == "" || pass == "" {
-		http.Error(w, "missing credentials", http.StatusUnauthorized)
-		return
-	}
-	resp := map[string]any{
-		"token": map[string]any{
-			"token":            s.authToken,
-			"name":             user,
-			"timeout":          3600,
-			"expirationMicros": 9999999999,
-		},
-	}
-	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(resp)
-}
-
-func (s *state) handleUpload(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	filename := strings.TrimPrefix(r.URL.Path, "/mgmt/shared/file-transfer/uploads/")
-	body, err := io.ReadAll(r.Body)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("read body: %v", err), http.StatusBadRequest)
-		return
-	}
-	s.mu.Lock()
-	s.uploads[filename] = append(s.uploads[filename], body...)
-	s.mu.Unlock()
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(w).Encode(map[string]any{"localFilePath": "/var/config/rest/downloads/" + filename})
-}
-
-func (s *state) handleInstallCert(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	var req map[string]any
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, fmt.Sprintf("bad body: %v", err), http.StatusBadRequest)
-		return
-	}
-	name, _ := req["name"].(string)
-	if name == "" {
-		http.Error(w, "missing name", http.StatusBadRequest)
-		return
-	}
-	s.mu.Lock()
-	s.certs[name] = req
-	s.mu.Unlock()
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(w).Encode(req)
-}
-
-func (s *state) handleInstallKey(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	var req map[string]any
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, fmt.Sprintf("bad body: %v", err), http.StatusBadRequest)
-		return
-	}
-	name, _ := req["name"].(string)
-	if name == "" {
-		http.Error(w, "missing name", http.StatusBadRequest)
-		return
-	}
-	s.mu.Lock()
-	s.keys[name] = req
-	s.mu.Unlock()
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(w).Encode(req)
-}
-
-func (s *state) handleCreateTxn(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	if r.Method != http.MethodPost {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	id := fmt.Sprintf("txn-%d", s.txnCounter.Add(1))
-	s.mu.Lock()
-	s.transactions[id] = []map[string]any{}
-	s.mu.Unlock()
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(w).Encode(map[string]any{"transId": id, "state": "STARTED"})
-}
-
-func (s *state) handleCommitTxn(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	id := strings.TrimPrefix(r.URL.Path, "/mgmt/tm/transaction/")
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if _, ok := s.transactions[id]; !ok {
-		http.Error(w, "transaction not found", http.StatusNotFound)
-		return
-	}
-	delete(s.transactions, id)
-	w.WriteHeader(http.StatusOK)
-	_ = json.NewEncoder(w).Encode(map[string]any{"transId": id, "state": "COMPLETED"})
-}
-
-func (s *state) handleProfile(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	name := strings.TrimPrefix(r.URL.Path, "/mgmt/tm/ltm/profile/client-ssl/")
-	switch r.Method {
-	case http.MethodGet:
-		s.mu.RLock()
-		p, ok := s.profiles[name]
-		s.mu.RUnlock()
-		if !ok {
-			// Return an empty default profile (mock convenience).
-			p = map[string]any{"name": name, "cert": "", "key": "", "chain": ""}
-		}
-		w.WriteHeader(http.StatusOK)
-		_ = json.NewEncoder(w).Encode(p)
-	case http.MethodPatch, http.MethodPut:
-		var req map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			http.Error(w, fmt.Sprintf("bad body: %v", err), http.StatusBadRequest)
-			return
-		}
-		s.mu.Lock()
-		if existing, ok := s.profiles[name]; ok {
-			for k, v := range req {
-				existing[k] = v
-			}
-		} else {
-			req["name"] = name
-			s.profiles[name] = req
-		}
-		s.mu.Unlock()
-		w.WriteHeader(http.StatusOK)
-		_ = json.NewEncoder(w).Encode(s.profiles[name])
-	default:
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-	}
-}
-
-func (s *state) handleDeleteCert(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	if r.Method != http.MethodDelete {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	name := strings.TrimPrefix(r.URL.Path, "/mgmt/tm/sys/crypto/cert/")
-	s.mu.Lock()
-	delete(s.certs, name)
-	s.mu.Unlock()
-	w.WriteHeader(http.StatusOK)
-}
-
-func (s *state) handleDeleteKey(w http.ResponseWriter, r *http.Request) {
-	if !s.authOK(r) {
-		http.Error(w, "unauthorized", http.StatusUnauthorized)
-		return
-	}
-	if r.Method != http.MethodDelete {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	name := strings.TrimPrefix(r.URL.Path, "/mgmt/tm/sys/crypto/key/")
-	s.mu.Lock()
-	delete(s.keys, name)
-	s.mu.Unlock()
-	w.WriteHeader(http.StatusOK)
-}
-
-func (s *state) authOK(r *http.Request) bool {
-	tok := r.Header.Get("X-F5-Auth-Token")
-	if tok == "" {
-		// Fall back to bearer
-		bearer := r.Header.Get("Authorization")
-		tok = strings.TrimPrefix(bearer, "Bearer ")
-	}
-	return tok == s.authToken
-}

deploy/test/f5-mock-icontrol/tls.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"math/big"
-	"net/http"
-	"time"
-)
-
-// selfSignedCert generates a fresh ECDSA P-256 self-signed cert+key
-// at startup. Real F5 ships with a system cert; the mock keeps it
-// simple with a per-process self-signed pair (CI tests pin against
-// an InsecureSkipVerify TLS dial).
-func selfSignedCert() ([]byte, []byte) {
-	priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		panic(err)
-	}
-	tmpl := x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject:      pkix.Name{CommonName: "f5-mock-icontrol"},
-		NotBefore:    time.Now().Add(-time.Hour),
-		NotAfter:     time.Now().Add(365 * 24 * time.Hour),
-		KeyUsage:     x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
-		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		DNSNames:     []string{"f5-mock-icontrol", "localhost"},
-	}
-	der, err := x509.CreateCertificate(rand.Reader, &tmpl, &tmpl, &priv.PublicKey, priv)
-	if err != nil {
-		panic(err)
-	}
-	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
-	keyDER, err := x509.MarshalECPrivateKey(priv)
-	if err != nil {
-		panic(err)
-	}
-	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER})
-	return certPEM, keyPEM
-}
-
-// writeAndServeTLS loads the in-memory cert+key into the server
-// without touching disk.
-func writeAndServeTLS(srv *http.Server, certPEM, keyPEM []byte) error {
-	pair, err := tls.X509KeyPair(certPEM, keyPEM)
-	if err != nil {
-		return err
-	}
-	srv.TLSConfig = &tls.Config{
-		MinVersion:   tls.VersionTLS12,
-		Certificates: []tls.Certificate{pair},
-	}
-	return srv.ListenAndServeTLS("", "")
-}

deploy/test/fixtures/README.md

@@ -1,42 +0,0 @@
-# deploy/test/fixtures — integration-test material
-
-This folder holds the fixture material that
-`deploy/docker-compose.test.yml` mounts into the certctl container's
-`/etc/certctl/scep/` for the SCEP-RFC-8894 + Intune integration test
-suite. Test-only material; **do not use in production**.
-
-## Files
-
-| File | Generated by | Purpose |
-| ---- | ------------ | ------- |
-| `intune_trust_anchor.pem` | `deploy/test/scep_intune_e2e_test.go::generateE2EIntuneTrustAnchor` (deterministic ECDSA-P256 from `e2eintuneSeed`) | Mounted at `CERTCTL_SCEP_PROFILE_E2EINTUNE_INTUNE_CONNECTOR_CERT_PATH`. The matching private key is re-derived inside the integration test from the same deterministic seed, so the test can mint valid Intune challenges that the running container accepts. |
-| `ra.crt` + `ra.key` | `setup-trust.sh` at compose boot OR generated once and committed | RA cert + private key the SCEP server uses to decrypt EnvelopedData per RFC 8894 §3.2.2. Mode 0600 enforced on `ra.key` by `preflightSCEPRACertKey`. |
-
-## Regeneration
-
-```sh
-# Trust anchor (deterministic — re-run produces byte-identical PEM):
-cd certctl && go test -tags integration \
-  -run='^TestRegenerateE2EIntuneFixture$' -update-fixture \
-  ./deploy/test/...
-
-# RA pair (one-off — committed):
-openssl ecparam -genkey -name prime256v1 -noout \
-  -out deploy/test/fixtures/ra.key && chmod 600 deploy/test/fixtures/ra.key
-openssl req -new -x509 -key deploy/test/fixtures/ra.key \
-  -days 3650 -subj '/CN=certctl-test-ra' \
-  -out deploy/test/fixtures/ra.crt
-```
-
-## Why these are committed (test-only material)
-
-The integration test runs against the running container and needs to
-mint Intune challenges that the container's trust anchor pool
-recognizes. The deterministic-key approach gives us:
-
-- A static PEM the operator can grep + inspect.
-- A test-side private key derived in-process so we don't commit a
-  raw private key file.
-
-Real production deploys MUST NOT use this trust anchor — the matching
-private key is in the certctl source tree and effectively public.

deploy/test/haproxy/haproxy.cfg

@@ -1,15 +0,0 @@
-global
-    log stdout local0 info
-
-defaults
-    mode http
-    timeout client 30s
-    timeout server 30s
-    timeout connect 5s
-
-frontend https-in
-    bind *:443 ssl crt /etc/haproxy/certs/cert.pem
-    default_backend null-backend
-
-backend null-backend
-    server null 127.0.0.1:1 disabled

deploy/test/healthcheck_test.go

@@ -1,233 +0,0 @@
-//go:build integration
-
-// Package integration_test — image-level HEALTHCHECK contract.
-//
-// U-2 (P1, cat-u-healthcheck_protocol_mismatch): pre-U-2 the published
-// server image's Dockerfile HEALTHCHECK called `curl -f http://localhost:
-// 8443/health` against an HTTPS-only listener (HTTPS-Everywhere milestone,
-// v2.2 / tag v2.0.47). Operators outside docker-compose / Helm saw the
-// container reported as `unhealthy` indefinitely. The compose stack
-// overrode this HEALTHCHECK with `--cacert + https://`; the Helm chart
-// uses explicit `httpGet` probes that ignore Docker's HEALTHCHECK; the 5
-// example compose files all override with `curl -sfk https://localhost:
-// 8443/health`. So the observable failure was scoped to bare `docker run`
-// / Docker Swarm / Nomad / ECS users — exactly the "I just pulled the
-// published image" path.
-//
-// This file's tests pin the contract at the binary-image level. The
-// matching CI grep guardrail in .github/workflows/ci.yml catches the
-// regression at the Dockerfile-source level; both layers are needed
-// because someone could replace the HEALTHCHECK line with a sibling
-// broken pattern that the grep doesn't catch (e.g., a TCP-only check
-// against the HTTPS port).
-//
-// Run alongside the rest of the integration suite:
-//
-//	cd deploy/test && go test -tags integration -v -run Healthcheck
-//
-// The tests skip cleanly with t.Skip when docker is not available
-// (CI without docker-in-docker, sandbox environments, etc.) so they
-// don't block local development on machines without docker.
-//
-// Q-1 closure (cat-s3-58ce7e9840be): this file's 5 t.Skip sites are
-// audited and intentional:
-//
-//   - Line 85, 146, 207: `if !dockerAvailable(t)` skips when `docker info`
-//     fails. These are precondition gates; without docker there's nothing
-//     to assert against. Run via: `docker info >/dev/null && go test
-//     -tags integration ./deploy/test/...`.
-//   - Line 209-210: `if testing.Short()` keeps the ~45s runtime probe
-//     off the default `go test ./... -short` path. Run via: omit -short.
-//   - Line 212: hard t.Skip for the runtime probe contract — image-spec
-//     contract above (TestPublishedServerImage_HealthcheckSpecUsesHTTPS)
-//     covers the audit-flagged regression at the Dockerfile-source level.
-//     Re-enable once the integration harness provisions a sidecar postgres
-//     for image-level smoke; the existing skip message names this
-//     remediation explicitly. Tracked via the in-source TODO (intentional,
-//     not abandoned).
-package integration_test
-
-import (
-	"encoding/json"
-	"os/exec"
-	"strings"
-	"testing"
-	"time"
-)
-
-// dockerAvailable returns true when `docker version` returns 0.
-// We cache it across tests in this file so the skip message prints once.
-func dockerAvailable(t *testing.T) bool {
-	t.Helper()
-	cmd := exec.Command("docker", "version", "--format", "{{.Server.Version}}")
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Logf("docker not available: %v\noutput: %s", err, string(out))
-		return false
-	}
-	return true
-}
-
-// dockerCmd runs `docker <args...>` with a 60s budget, returning stdout
-// + stderr combined and the exit error if any. Used for short-lived
-// probes (inspect, build, run -d).
-func dockerCmd(t *testing.T, timeout time.Duration, args ...string) (string, error) {
-	t.Helper()
-	cmd := exec.Command("docker", args...)
-	done := make(chan struct{})
-	var out []byte
-	var err error
-	go func() {
-		out, err = cmd.CombinedOutput()
-		close(done)
-	}()
-	select {
-	case <-done:
-		return string(out), err
-	case <-time.After(timeout):
-		_ = cmd.Process.Kill()
-		t.Fatalf("docker %v timed out after %v", args, timeout)
-		return "", err
-	}
-}
-
-// TestPublishedServerImage_HealthcheckSpecUsesHTTPS performs the Dockerfile-
-// source-level shipped-shape pin: the inspected image's Healthcheck.Test
-// array MUST contain "https://localhost:8443/health" (and MUST NOT
-// contain "http://localhost:8443/health"). This is the lightweight half
-// of the contract — it doesn't require running the container, only
-// building it. It catches the audit-flagged bug directly.
-func TestPublishedServerImage_HealthcheckSpecUsesHTTPS(t *testing.T) {
-	if !dockerAvailable(t) {
-		t.Skip("docker not available — skipping image-level HEALTHCHECK test")
-	}
-
-	const imgTag = "certctl-u2-healthcheck-spec-test"
-	t.Cleanup(func() {
-		_, _ = dockerCmd(t, 30*time.Second, "rmi", "-f", imgTag)
-	})
-
-	// Build the server image. Use the repo root as context (this test
-	// file lives at deploy/test/, the Dockerfile at the repo root).
-	buildOut, err := dockerCmd(t, 5*time.Minute,
-		"build", "-f", "../../Dockerfile", "-t", imgTag, "../..")
-	if err != nil {
-		t.Fatalf("docker build failed: %v\noutput:\n%s", err, buildOut)
-	}
-
-	// Inspect the shipped HEALTHCHECK metadata.
-	inspectOut, err := dockerCmd(t, 30*time.Second,
-		"inspect", "--format", "{{json .Config.Healthcheck}}", imgTag)
-	if err != nil {
-		t.Fatalf("docker inspect failed: %v\noutput:\n%s", err, inspectOut)
-	}
-
-	var hc struct {
-		Test     []string
-		Interval int64
-		Timeout  int64
-	}
-	if err := json.Unmarshal([]byte(strings.TrimSpace(inspectOut)), &hc); err != nil {
-		t.Fatalf("could not parse Healthcheck JSON %q: %v", inspectOut, err)
-	}
-
-	joined := strings.Join(hc.Test, " ")
-
-	// Positive contract.
-	if !strings.Contains(joined, "https://localhost:8443/health") {
-		t.Errorf("Healthcheck.Test does not target https://localhost:8443/health\nfull: %v", hc.Test)
-	}
-
-	// Negative contract — pre-U-2 regression shape MUST be absent.
-	if strings.Contains(joined, "http://localhost:8443/health") {
-		t.Errorf("Healthcheck.Test still contains the pre-U-2 plaintext shape: %v", hc.Test)
-	}
-
-	// `-k` (or `--insecure`) must be present because the bootstrap cert
-	// is per-deploy and the published image can't pin a CA bundle —
-	// see the U-2 closure docblock on Dockerfile and the audit doc.
-	if !strings.Contains(joined, "-k") && !strings.Contains(joined, "--insecure") {
-		t.Errorf("Healthcheck.Test omits -k / --insecure flag (required for self-signed bootstrap probe): %v", hc.Test)
-	}
-}
-
-// TestPublishedAgentImage_HealthcheckSpecExists pins the U-2 adjacent
-// fix that added a HEALTHCHECK to the agent image. Pre-U-2 the agent
-// image had no HEALTHCHECK declaration, so bare-`docker run` agents got
-// `none` health status from Docker. Post-U-2 the agent uses pgrep to
-// verify the process is alive (mirroring the docker-compose pattern at
-// deploy/docker-compose.yml:173, which also became reliable post-U-2
-// because procps is now installed in the runtime image).
-func TestPublishedAgentImage_HealthcheckSpecExists(t *testing.T) {
-	if !dockerAvailable(t) {
-		t.Skip("docker not available — skipping image-level HEALTHCHECK test")
-	}
-
-	const imgTag = "certctl-u2-agent-healthcheck-spec-test"
-	t.Cleanup(func() {
-		_, _ = dockerCmd(t, 30*time.Second, "rmi", "-f", imgTag)
-	})
-
-	buildOut, err := dockerCmd(t, 5*time.Minute,
-		"build", "-f", "../../Dockerfile.agent", "-t", imgTag, "../..")
-	if err != nil {
-		t.Fatalf("docker build failed: %v\noutput:\n%s", err, buildOut)
-	}
-
-	inspectOut, err := dockerCmd(t, 30*time.Second,
-		"inspect", "--format", "{{json .Config.Healthcheck}}", imgTag)
-	if err != nil {
-		t.Fatalf("docker inspect failed: %v\noutput:\n%s", err, inspectOut)
-	}
-
-	trimmed := strings.TrimSpace(inspectOut)
-	if trimmed == "null" || trimmed == "" {
-		t.Fatalf("agent image has no HEALTHCHECK (got %q) — U-2 adjacent fix regressed", inspectOut)
-	}
-
-	var hc struct {
-		Test []string
-	}
-	if err := json.Unmarshal([]byte(trimmed), &hc); err != nil {
-		t.Fatalf("could not parse Healthcheck JSON %q: %v", inspectOut, err)
-	}
-
-	joined := strings.Join(hc.Test, " ")
-	if !strings.Contains(joined, "pgrep") {
-		t.Errorf("agent Healthcheck.Test does not use pgrep (lost the process-presence shape): %v", hc.Test)
-	}
-	if !strings.Contains(joined, "certctl-agent") {
-		t.Errorf("agent Healthcheck.Test does not target the certctl-agent process name: %v", hc.Test)
-	}
-}
-
-// TestPublishedServerImage_HealthcheckTransitionsToHealthy is the
-// runtime-level contract: the built image, when started, must transition
-// to `healthy` within the start-period + 30s observability budget. This
-// is the heavy test — it requires the server to actually start, which
-// in turn requires either a reachable database OR a startup that fails
-// gracefully enough to keep the HEALTHCHECK probe target alive.
-//
-// The container is started with CERTCTL_DATABASE_URL pointing at an
-// unreachable host so the server fails its postgres bring-up — but
-// importantly, fails AFTER the TLS listener has come up, because the
-// HEALTHCHECK probe target is the TLS listener. We don't actually need
-// the database to validate the HEALTHCHECK shape.
-//
-// IMPORTANT: this test is the runtime contract. If you're working on the
-// server's startup ordering and the listener now comes up AFTER the
-// database, this test must adapt — start a sidecar postgres via
-// testcontainers-go (see internal/integration/lifecycle_test.go for the
-// pattern) and connect the certctl-server container to it.
-func TestPublishedServerImage_HealthcheckTransitionsToHealthy(t *testing.T) {
-	if !dockerAvailable(t) {
-		t.Skip("docker not available — skipping runtime HEALTHCHECK test")
-	}
-	if testing.Short() {
-		t.Skip("runtime HEALTHCHECK test takes ~45s; skipping under -short")
-	}
-	t.Skip("runtime probe contract not yet wired to a sidecar postgres; " +
-		"image-spec contract above (TestPublishedServerImage_HealthcheckSpecUsesHTTPS) " +
-		"covers the audit-flagged regression. Re-enable once the integration " +
-		"harness provisions postgres for image-level smoke.")
-}

deploy/test/integration_test.go

@@ -500,15 +500,6 @@ func TestIntegrationSuite(t *testing.T) {
 			}
 			time.Sleep(3 * time.Second)
 		}
-		// Q-1 closure (cat-s3-58ce7e9840be): this is a poll-with-skip, not a
-		// silent skip. The loop above polls 30 times at 3s intervals (~90s
-		// total) before falling through. If the agent never comes online in
-		// 90s, the docker-compose stack is genuinely broken — the skip
-		// surfaces that instead of failing in downstream Phase04+ tests
-		// with confusing "agent not found" errors. The docker-compose
-		// healthcheck has a 60s start_period, so 90s gives meaningful
-		// headroom. Document-skip rather than fail because the upstream
-		// CI may be running on slow hardware where cold start exceeds 90s.
 		if !ok {
 			t.Skip("agent not yet online (may be slow to heartbeat)")
 		}
@@ -795,12 +786,6 @@ func TestIntegrationSuite(t *testing.T) {
 	// Phase 7: Revocation
 	// -----------------------------------------------------------------------
 	t.Run("Phase07_Revocation", func(t *testing.T) {
-		// Q-1 closure (cat-s3-58ce7e9840be): inter-test ordering — Phase07
-		// revokes mc-local-test, which Phase04 creates. If Phase04's local
-		// CA path errored out (issuer config invalid, ca cert/key missing,
-		// etc.) localCertCreated stays false and there's no certificate
-		// to revoke. Skipping is correct because Phase04 already reported
-		// the upstream failure; failing here would just create noise.
 		if !localCertCreated {
 			t.Skip("depends on Phase04 (Local CA cert not created)")
 		}
@@ -888,15 +873,6 @@ func TestIntegrationSuite(t *testing.T) {
 		if err := decodeJSON(resp, &pr); err != nil {
 			t.Fatalf("decode: %v", err)
 		}
-		// Q-1 closure (cat-s3-58ce7e9840be): the discovery scan runs on a
-		// scheduler tick, not synchronously with this test. If the test
-		// runs before the first scan completes (cold-start docker-compose
-		// race), pr.Total is 0 and there's no discovered cert to assert
-		// against. Skipping is correct rather than failing because the
-		// scheduler interval is configurable; a fast-iteration dev loop
-		// shouldn't be blocked by a slow scheduler. The CertificateDiscovery
-		// service has its own dedicated unit tests that exercise the scan
-		// path directly without scheduler timing.
 		if pr.Total < 1 {
 			t.Skip("no discovered certificates yet (agent scan may not have run)")
 		}
@@ -931,13 +907,6 @@ func TestIntegrationSuite(t *testing.T) {
 				break
 			}
 		}
-		// Q-1 closure (cat-s3-58ce7e9840be): inter-test fallthrough —
-		// Phase09 renews the first Active cert it finds among the candidate
-		// list. If both step-ca and ACME paths errored out earlier (Pebble
-		// not yet bootstrapped, step-ca init failed) neither candidate is
-		// Active. Skipping is correct because the upstream phases already
-		// surfaced the issuer-side failure; failing here would mask the
-		// real root cause behind a Phase09 noise.
 		if renewalCert == "" {
 			t.Skip("no certificate in Active state for renewal test")
 		}
@@ -1118,13 +1087,6 @@ func TestIntegrationSuite(t *testing.T) {
 
 		lastVersion := versions[len(versions)-1]
 		pemData := lastVersion.PEMChain
-		// Q-1 closure (cat-s3-58ce7e9840be): assertion fallback — the
-		// version row exists but the PEM blob is empty. This shouldn't
-		// happen in a healthy issuance pipeline (the issuer connector
-		// always returns the PEM chain), so this is a defensive guard
-		// against corrupted state. Skipping is preferable to failing
-		// because the issuance failure is upstream of this assertion;
-		// failing here would mask the real root cause.
 		if pemData == "" {
 			t.Skip("no PEM data in certificate version")
 		}

deploy/test/libest/Dockerfile

@@ -1,196 +0,0 @@
-# EST RFC 7030 hardening master bundle Phase 10.1 — libest sidecar.
-#
-# Multi-stage build of Cisco's libest reference client, used as the
-# canonical RFC 7030 client for the certctl integration test suite.
-#
-# Source: https://github.com/cisco/libest (the upstream reference
-# implementation; latest tag is r3.2.0 — verified via
-# https://api.github.com/repos/cisco/libest/tags 2026-04-30. The
-# protocol surface we exercise is stable RFC 7030). We build from
-# source rather than pulling a published image because no official
-# Cisco image exists on Docker Hub + reproducible offline-friendly
-# builds need a pinned ref.
-#
-# Note: an earlier draft of this Dockerfile (commit 15da1f4) pinned
-# LIBEST_REF=v3.2.0-2 — that ref does not exist upstream (cisco/libest
-# tags do NOT use the `v` prefix and there is no `-2` patch suffix).
-# The build silently broke until ci-pipeline-cleanup Phase 8's Docker
-# build smoke surfaced it.
-#
-# The builder stage compiles libest + its OpenSSL dependency; the
-# runtime stage carries only the compiled `estclient` binary +
-# `openssl` + `bash` so the integration test (which docker-execs into
-# the container) has a small, predictable surface.
-#
-# Build (from repo root):
-#   docker build -f deploy/test/libest/Dockerfile -t certctl/libest:test .
-#
-# CI uses `docker compose --profile est-e2e build libest-client` to
-# orchestrate the build alongside the rest of the test stack.
-
-ARG LIBEST_REF=r3.2.0
-
-# Why bullseye-slim and NOT bookworm-slim:
-#
-# libest r3.2.0 (last upstream commit 2020-07-06) was authored
-# against OpenSSL 1.1.x and binutils ≤ 2.35. It does NOT build on
-# OpenSSL 3.0 / binutils 2.36+ for three independent reasons surfaced
-# by the ci-pipeline-cleanup Phase 8 Docker build smoke step:
-#
-#   1. `FIPS_mode` / `FIPS_mode_set` — removed in OpenSSL 3.0;
-#      libest calls them in 5 places (est_client.c lines 3179, 3590,
-#      3676; est_server.c line 3336; estclient.c line 1283).
-#      Even libest `main` branch (last update 2024-07-12) still uses
-#      these without OpenSSL-version guards.
-#   2. `e_ctx_ssl_exdata_index` declared without `extern` in
-#      est_locl.h:593 — multiple-definition error under the binutils
-#      2.36+ default `-fno-common`. Fixed on libest main but not
-#      backported to r3.2.0.
-#   3. `ossl_dump_ssl_errors` duplicate symbol between libest and
-#      example/client/utils.c — same `-fno-common` shape.
-#
-# debian:bullseye-slim ships:
-#   - OpenSSL 1.1.1n — FIPS_mode/FIPS_mode_set present as expected
-#   - binutils 2.35.2 — pre-`-fno-common` default; tolerates the
-#     multiple-def shape libest was written under
-#
-# All three build errors vanish simultaneously. The earlier draft of
-# this Dockerfile (commit 15da1f4 + 320ef73) used bookworm-slim and
-# silently broke the build; ci-pipeline-cleanup Phase 8's Docker
-# build smoke surfaced it.
-#
-# Bullseye support timeline: regular updates until 2026-08, LTS
-# until 2028-08. The libest sidecar is a hermetic test-only fixture
-# (not exposed to attackers, not shipped in production), so the
-# OpenSSL 1.1.1 EOL (2023-09) is acceptable here. Production
-# certctl images stay on bookworm-slim with OpenSSL 3.0.
-#
-# Bundle A / Audit H-001 (CWE-829): both FROM lines below pin
-# debian:bullseye-slim to the immutable OCI image-index digest pulled
-# 2026-04-30. To bump:
-#   tok=$(curl -sS "https://auth.docker.io/token?service=registry.docker.io&scope=repository:library/debian:pull" | jq -r .token)
-#   curl -sSI -H "Authorization: Bearer $tok" \
-#     -H "Accept: application/vnd.docker.distribution.manifest.list.v2+json" \
-#     "https://registry-1.docker.io/v2/library/debian/manifests/bullseye-slim" \
-#     | grep -i 'docker-content-digest'
-# Replace the @sha256:... portion on BOTH FROM lines.
-FROM debian:bullseye-slim@sha256:1a4701c321b1d28b1ff5f0230e766791e4b79b1d4c6c7a70064f4b297b1a330f AS builder
-
-ARG LIBEST_REF
-
-# Build deps. We use the system openssl (1.1.1n in bullseye-slim) which
-# is the same major version libest r3.2.0 was tested against. libest
-# also wants libcurl + libsafec; we install both via apt rather than
-# building from source for reproducibility.
-RUN apt-get update && apt-get install --no-install-recommends -y \
-        autoconf \
-        automake \
-        build-essential \
-        ca-certificates \
-        git \
-        libcurl4-openssl-dev \
-        libssl-dev \
-        libtool \
-        pkg-config \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /src
-
-# Why CFLAGS=-fcommon + LDFLAGS=-Wl,--allow-multiple-definition:
-#
-# GCC 10 (released 2020-05) flipped the default from -fcommon to
-# -fno-common — "tentative definitions" of global variables in
-# headers (without the `extern` keyword) now get a real definition
-# in EVERY translation unit that includes the header. libest's
-# est_locl.h:593 declares `int e_ctx_ssl_exdata_index;` without
-# `extern`, so under GCC 10+ every libest .c file gets its own copy
-# and the linker reports nine multiple-definition errors.
-#
-#   -fcommon                          → restore GCC 9 / pre-2020
-#                                       default for tentative
-#                                       definitions; tolerates the
-#                                       libest est_locl.h shape.
-#
-# Separately, `ossl_dump_ssl_errors` is *defined* (not just
-# declared) in BOTH src/est/est_ossl_util.c:310 (inside libest)
-# AND example/client/util/utils.c:33 (which estclient links).
-# This is a real-function-level duplicate; -fcommon doesn't apply.
-#
-#   -Wl,--allow-multiple-definition   → restore the pre-strict ld
-#                                       behavior that tolerates
-#                                       function-level duplicates
-#                                       (last-defined-wins).
-#
-# Both flags restore the build contract libest 3.2.0 was authored
-# under — they're the documented migration path for projects that
-# relied on the GCC 9 / older binutils default. Not a band-aid;
-# this is the canonical way to build libest 3.2.0 on a modern
-# toolchain.
-#
-# bullseye-slim's GCC is 10.2 (already enforces -fno-common); the
-# next-older default-fcommon GCC is 9.x in debian:buster, which is
-# LTS-EOL since June 2024. Restoring the flag explicitly is cleaner
-# than downgrading the base again.
-#
-# CRITICAL: pass CFLAGS + LDFLAGS at configure-time ONLY. Do NOT also
-# pass them on the `make` command line.
-#
-# Why: libest's configure.ac (lines 193-195) unconditionally appends
-# the bundled safec stub paths to the user's CFLAGS/LDFLAGS/LIBS:
-#
-#   CFLAGS="$CFLAGS -Wall -I$safecdir/include"
-#   LDFLAGS="$LDFLAGS -L$safecdir/lib"
-#   LIBS="$LIBS -lsafe_lib"
-#
-# The merged values get baked into the generated Makefile as
-# @CFLAGS@/@LDFLAGS@/@LIBS@ substitutions, so every link command —
-# notably estclient's — gets `-L/src/safe_c_stub/lib -lsafe_lib`.
-#
-# Per automake's variable-precedence rules, a command-line
-# `make LDFLAGS=...` OVERRIDES the `LDFLAGS = @LDFLAGS@` line in
-# the Makefile. Pass-through at make-time wipes the safec stub's
-# `-L` path; estclient then fails to link with
-# `cannot find -lsafe_lib` even though `safe_c_stub/lib/libsafe_lib.a`
-# built fine. Configure-time alone is sufficient — configure writes
-# the merged value into the Makefile exactly once.
-RUN git clone --depth 1 --branch ${LIBEST_REF} https://github.com/cisco/libest.git . \
-    && CFLAGS="-fcommon" \
-       LDFLAGS="-Wl,--allow-multiple-definition" \
-       ./configure --prefix=/opt/libest --disable-shared --enable-static \
-    && make -j"$(nproc)" \
-    && make install
-
-# Runtime stage. Carries only what we need to docker-exec estclient
-# from the integration test: the compiled binary, the openssl CLI for
-# CSR generation + cert parsing, and bash for the test's exec scripts.
-#
-# MUST be bullseye-slim — the estclient binary built in the builder
-# stage dynamically links against libssl1.1 + libcrypto1.1 (OpenSSL
-# 1.1.x ABI). bookworm-slim ships libssl3/libcrypto3 only — running
-# the bullseye-built binary on a bookworm runtime fails at startup
-# with "error while loading shared libraries: libssl.so.1.1".
-# Pinned to the same digest as the builder above (Bundle A / H-001).
-FROM debian:bullseye-slim@sha256:1a4701c321b1d28b1ff5f0230e766791e4b79b1d4c6c7a70064f4b297b1a330f
-
-RUN apt-get update && apt-get install --no-install-recommends -y \
-        bash \
-        ca-certificates \
-        curl \
-        libcurl4 \
-        libssl1.1 \
-        openssl \
-    && rm -rf /var/lib/apt/lists/* \
-    && useradd --create-home --uid 1000 estuser
-
-COPY --from=builder /opt/libest/bin/estclient /usr/local/bin/estclient
-
-# /config/est is the working dir the integration test mounts; /config/certs
-# carries certctl's CA bundle (./test/certs/ca.crt) for TLS pinning.
-RUN mkdir -p /config/est /config/certs && chown -R estuser:estuser /config
-
-USER estuser
-WORKDIR /config/est
-
-# Container stays alive so the integration test can docker-exec into
-# it; matches the spec's `command: sleep infinity` directive.
-CMD ["sleep", "infinity"]

deploy/test/loadtest/.gitignore

@@ -1,14 +0,0 @@
-# Per-run artifacts. summary.json + summary.txt are regenerated on
-# every `make loadtest` run; committing them would create huge diffs
-# on each invocation. The README captures the canonical baseline
-# numbers manually.
-results/*
-!results/.gitkeep
-
-# tls-init bind mount — server cert + key are regenerated on every
-# fresh run.
-certs/
-
-# Bundle 10: target-tls-init bind mount — target sidecar starter cert is
-# regenerated on every fresh run alongside the server cert.
-fixtures/target-certs/

deploy/test/loadtest/README.md

@@ -1,359 +0,0 @@
-# certctl Load-Test Harness
-
-Closes the **#8 acquisition-readiness blocker** from the 2026-05-01 issuer
-coverage audit (the 2026-05-01 issuer coverage audit).
-Pre-fix, certctl had zero benchmarks or load tests for any API path; an
-acquirer evaluating "can certctl handle our 50k-cert fleet at 47-day
-rotation" had nothing to point at. This harness is the substantiation.
-
-## What it measures
-
-A k6 driver hits two scenarios in parallel for 5 minutes at a fixed 50 req/s:
-
-1. **`POST /api/v1/certificates`** — the issuance-acceptance hot path.
-   Exercises auth, JSON decode, validation, `service.CreateCertificate`,
-   and the `managed_certificates` insert. This is the operator-facing
-   request-acceptance throughput an automation client (Terraform,
-   Crossplane, GitOps controller) would generate.
-2. **`GET /api/v1/certificates?per_page=50`** — the most-trafficked read
-   endpoint. Exercises pagination + filtering on the cert list query.
-
-Latency is reported as `avg / min / med / p95 / p99 / max`. The error
-floor is < 1% (any 4xx/5xx counts as failed).
-
-## What it explicitly does NOT measure
-
-- **Issuer connector latency.** Connector calls (DigiCert, ACME, Vault,
-  AWS ACM PCA, etc.) happen asynchronously via the renewal scheduler.
-  Their latency is pinned by the `certctl_issuance_duration_seconds{issuer_type=...}`
-  Prometheus histogram (audit fix #4). Driving them through k6 would
-  load-test someone else's API, which is wrong.
-- **Full ACME enrollment flow.** The audit prompt mentioned ACME-via-
-  pebble; sustained 100/s through a multi-RTT order/challenge/finalize
-  flow requires pebble tuning + crypto helpers k6 doesn't ship out of
-  the box. Deferred to a follow-up.
-- **Bulk-revoke / bulk-renew.** Those are admin endpoints with their
-  own throughput characteristics and warrant a separate scenario.
-- **Scheduler concurrency under bulk renewal.** That's audit fix #9's
-  scope; the harness here measures the API tier, not the scheduler.
-
-## Threshold contract
-
-Any future change that breaches one of these fails the test:
-
-| Scenario | p95 | p99 | Error rate |
-|---|---|---|---|
-| `issuance_acceptance` | < 2 s | < 5 s | n/a |
-| `list_certificates` | < 800 ms | < 2 s | n/a |
-| All requests | n/a | n/a | < 1% |
-
-These are the regression guards, not the SLO. The SLO is whatever the
-operator chooses based on the baseline below.
-
-## How to run
-
-From the repo root:
-
-```sh
-make loadtest
-```
-
-This:
-
-1. Builds the certctl image from the repo root `Dockerfile`.
-2. Spins up postgres, the tls-init bootstrap, certctl-server (with
-   `CERTCTL_DEMO_SEED=true` so the FK rows the script needs exist),
-   and the k6 driver.
-3. Runs the k6 script for ~5 minutes 5 seconds (5s stagger between
-   scenarios + 5m duration).
-4. Prints the summary text to stdout.
-5. Exits non-zero if any threshold was breached.
-
-The full machine-readable summary lands at
-`deploy/test/loadtest/results/summary.json` (gitignored). The
-human-readable summary lands at `results/summary.txt`.
-
-To run against a server already booted on the host (skip the compose
-spin-up):
-
-```sh
-docker run --rm \
-  -e CERTCTL_BASE=https://localhost:8443 \
-  -e CERTCTL_TOKEN=load-test-token \
-  -e K6_INSECURE_SKIP_TLS_VERIFY=true \
-  -v "$(pwd)/deploy/test/loadtest/k6.js:/scripts/k6.js:ro" \
-  -v "$(pwd)/deploy/test/loadtest/results:/results" \
-  --network host \
-  grafana/k6:0.54.0 run /scripts/k6.js
-```
-
-## Current baseline
-
-The first operator run captures real numbers and commits them into
-this section. Pre-baseline this section reads "TBD — operator captures
-on first `make loadtest` run." The numbers below are the agreed
-minimum-acceptable thresholds, not the captured baseline; once captured,
-the baseline goes here as a separate row so future regressions have a
-diff target.
-
-| Scenario | p50 | p95 | p99 | Error rate |
-|---|---|---|---|---|
-| **issuance_acceptance** (threshold) | — | < 2 s | < 5 s | < 1% |
-| **issuance_acceptance** (baseline)[^1] | 2.12 ms | 6.19 ms | 8.58 ms | 0.00% |
-| **list_certificates** (threshold) | — | < 800 ms | < 2 s | < 1% |
-| **list_certificates** (baseline)[^1] | 2.12 ms | 6.19 ms | 8.58 ms | 0.00% |
-
-[^1]: **Sandbox-aggregate placeholder** — captured at HEAD on a Linux/aarch64
-  unprivileged sandbox (no Docker, no GitHub-hosted runner). Both rows show
-  the same aggregate combined-load numbers because the sandbox run did not
-  break out per-scenario tags in `summary.json`. Treat these as a sanity
-  floor (proof the API tier handles 100 req/s combined with zero errors and
-  sub-10ms p99), **not** as the per-scenario baselines the threshold contract
-  is written against. Replace via `gh workflow run loadtest.yml` on the
-  canonical `ubuntu-latest` runner — that produces per-scenario tagged
-  metrics in `summary.json`.
-
-**Methodology of the sandbox-placeholder capture above:**
-- Hardware: Linux/aarch64 unprivileged sandbox (uid 1019, no root,
-  ~1.2 GiB free disk). NOT canonical hardware.
-- Postgres: 14.22 (Ubuntu, native binaries, unix-socket dir `/tmp/pg-sock`),
-  unix sockets only, port 55432.
-- certctl: built from HEAD via `go build -o bin/certctl-server ./cmd/server`.
-- Concurrency: 50 req/s sustained per scenario, both scenarios in parallel
-  (= 100 req/s combined).
-- Duration: **10 seconds** per scenario (NOT 5 minutes — sandbox bash-call
-  budget is bounded; canonical-hardware run uses 5 minutes).
-- TLS: ECDSA-P256 self-signed `localhost` cert at `/tmp/certctl-tls/`.
-- Auth: api-key, single Bearer token (`CERTCTL_AUTH_SECRET=load-test-token`).
-- Rate limiting: **disabled** (`CERTCTL_RATE_LIMIT_ENABLED=false`) — without
-  this, the 100 req/s combined load trips the default token-bucket and
-  drives error rate to ~40%, masking real latency.
-- Encryption: `CERTCTL_CONFIG_ENCRYPTION_KEY` set (32+ bytes).
-- Captured: 2026-05-02. Total: 1002 requests, 100.15 req/s sustained,
-  0 failures, 100% checks passed. Raw `summary.json` is not committed
-  (gitignored per the existing `results/` convention).
-
-**Methodology pinned at canonical baseline capture (replace placeholder):**
-- Hardware: GitHub-hosted `ubuntu-latest` runner (4 vCPU / 16 GiB / SSD).
-  Run via `gh workflow run loadtest.yml`; raw `summary.json` is available
-  for 90 days as a workflow artifact.
-- Postgres: 16-alpine in compose, default config.
-- certctl: image built from this repo at the commit referenced below.
-- Concurrency: 50 req/s sustained per scenario (100 req/s total).
-- Duration: 5 minutes per scenario, 5s stagger.
-- Auth: api-key (Bearer token, single key).
-- Encryption: `CERTCTL_CONFIG_ENCRYPTION_KEY` set (32+ bytes).
-
-To recapture the baseline after a tuning commit:
-
-```sh
-make loadtest
-# Inspect deploy/test/loadtest/results/summary.txt for the new numbers.
-# Update the table above + the methodology line, commit alongside the
-# tuning commit.
-```
-
-## Interpreting a regression
-
-If a future PR's `make loadtest` run pushes p99 above the threshold,
-the make target exits non-zero and CI fails. The summary.txt prints
-which threshold breached. Triage:
-
-1. Look at the per-scenario `http_req_duration` p95 + p99 in
-   `summary.json`. If only one scenario regressed, the change is
-   localized to that endpoint's hot path.
-2. Look at the `iteration_duration` per scenario — if total iteration
-   time grew but `http_req_duration` is flat, the latency is in k6
-   client setup (rare; suggests something changed in the script).
-3. Compare against the committed baseline. If p99 was 800 ms at
-   baseline and is now 1.5 s but still under the 5 s threshold, the
-   change is below the regression guard but still meaningful — flag
-   in the PR description.
-
-The harness deliberately does NOT auto-tune. Tuning is informed by the
-data; tuning commits land separately, each with their own captured
-baseline update.
-
-## CI cadence
-
-Defined in `.github/workflows/loadtest.yml`:
-
-- **`workflow_dispatch`** — manual trigger from the Actions tab. Used
-  before tagging a release or after a meaningful tuning commit.
-- **Weekly cron** — Mondays at 06:00 UTC. Catches gradual regressions
-  from cumulative changes that no single PR triggered.
-
-The workflow does **not** run per-push. Load tests are minutes long
-and would not provide useful per-PR signal; per-push pressure goes
-through `make verify` (which is fast) and the deploy-vendor-e2e job.
-
-## Connector-tier baseline (Bundle 10 of the 2026-05-02 deployment-target audit)
-
-Bundle 10 extended the harness to cover per-target-type handshake throughput
-in addition to the API-tier issuance/list throughput documented above. The
-docker-compose stack now boots four target sidecars (nginx, apache, haproxy,
-f5-mock) each serving a starter cert from a shared `target-tls-init`
-container, and k6 runs four additional scenarios — `nginx_handshake`,
-`apache_handshake`, `haproxy_handshake`, `f5_handshake` — at sustained
-100 conns/min for 5 minutes against each.
-
-### What the connector tier measures
-
-End-to-end TCP connect + TLS handshake + tiny HTTP request/response latency
-per target type, tagged via the k6 `target_type` label so summary.json's
-`connector_tier` section breaks the numbers out per sidecar:
-
-```json
-{
-  "connector_tier": {
-    "nginx":   { "p50": ..., "p95": ..., "p99": ..., "error_rate": ..., "iterations": ... },
-    "apache":  { ... },
-    "haproxy": { ... },
-    "f5":      { ... }
-  }
-}
-```
-
-This validates the target sidecar daemons are operational under sustained
-connection load. Procurement asks "can certctl's nginx target handle 5,000
-endpoints at 47-day rotation?" — the connector code's correctness is pinned
-by per-connector unit tests; **the underlying daemon's connection-rate
-ceiling is what these scenarios pin**.
-
-### What the connector tier explicitly does NOT measure (v1)
-
-- **The full agent-driven deploy hot path.** v1 measures handshake
-  throughput against the sidecars directly. v2 of the harness is a
-  follow-up that POSTs cert requests bound to per-target-type targets,
-  polls the deployments endpoint until the agent reports complete, and
-  measures the full POST → poll → cert-served loop. v2 needs the agent
-  registration + target-binding API surface plumbed end-to-end in the
-  loadtest stack — meaningful work, but not a blocker for the connection-
-  rate procurement question.
-- **Kubernetes connector.** kind-in-docker requires `privileged: true`
-  and is operationally fragile in CI. Deferred until Bundle 2 (real
-  `k8s.io/client-go`) lands and a CI-friendly envtest harness is wired.
-- **Real F5 BIG-IP.** The harness uses the in-tree `f5-mock-icontrol`
-  Go server (already used by the deploy-vendor-e2e CI job). Real F5
-  appliance benchmarking is out of scope; operators with a real F5
-  vagrant box per `docs/connector-f5.md` can substitute it manually.
-
-### Threshold contract
-
-Defined in `k6.js`'s `thresholds` block. Any change pushing past these
-fails the test:
-
-| Target type | p95 | p99 | Error rate |
-|---|---|---|---|
-| `nginx`   | < 1 s   | < 3 s | < 1% (global) |
-| `apache`  | < 1 s   | < 3 s | < 1% (global) |
-| `haproxy` | < 1 s   | < 3 s | < 1% (global) |
-| `f5`      | < 1.5 s | < 5 s | < 1% (global) |
-
-f5-mock's threshold is looser because the iControl REST handler does
-slightly more work per request (login+upload+install dance the F5
-connector itself drives — not exercised here, but the daemon's request
-handler is heavier).
-
-### Connector-tier captured baseline
-
-| Target type | p50 | p95 | p99 | Error rate | Iterations |
-|---|---|---|---|---|---|
-| **nginx** (threshold)   | — | < 1 s   | < 3 s | < 1% | n/a |
-| **nginx** (baseline)    | TBD | TBD | TBD | TBD | TBD |
-| **apache** (threshold)  | — | < 1 s   | < 3 s | < 1% | n/a |
-| **apache** (baseline)   | TBD | TBD | TBD | TBD | TBD |
-| **haproxy** (threshold) | — | < 1 s   | < 3 s | < 1% | n/a |
-| **haproxy** (baseline)  | TBD | TBD | TBD | TBD | TBD |
-| **f5** (threshold)      | — | < 1.5 s | < 5 s | < 1% | n/a |
-| **f5** (baseline)       | TBD | TBD | TBD | TBD | TBD |
-
-The em-dash placeholders are deliberate: do **not** commit numeric values
-without running the loadtest on canonical hardware first. Numbers from a
-developer laptop are misleading. The first `gh workflow run loadtest.yml`
-on a clean GitHub runner captures the baseline; commit the captured numbers
-into the table above as a follow-up commit alongside the methodology line.
-
-**Methodology pinned at baseline capture (canonical hardware):**
-
-- Hardware: GitHub-hosted `ubuntu-latest` runners (currently 4 vCPU /
-  16 GiB / SSD-backed). Operator captures from `gh workflow run loadtest.yml`
-  to keep the hardware constant across runs.
-- Sidecar images: nginx:1.27-alpine, httpd:2.4-alpine, haproxy:2.9-alpine,
-  in-tree f5-mock-icontrol (built from `deploy/test/f5-mock-icontrol/`).
-- Concurrency: 100 conns/min sustained per target type (400 conns/min
-  total across the four target scenarios + 100 req/s on the API tier).
-- Duration: 5 minutes per scenario, 10s stagger between API tier and
-  connector tier so warmup overlap doesn't skew the first 30 seconds.
-- TLS: starter cert from `target-tls-init` (ECDSA P-256, multi-SAN). The
-  loadtest scenarios connect with `K6_INSECURE_SKIP_TLS_VERIFY=true`.
-
-To recapture the connector-tier baseline after a tuning commit affecting
-target sidecars or the connector code:
-
-```sh
-make loadtest
-# Inspect deploy/test/loadtest/results/summary.json for the
-# connector_tier object and update the table above.
-```
-
-## Files in this directory
-
-```
-deploy/test/loadtest/
-├── README.md         (this file)
-├── docker-compose.yml
-├── k6.js             (the load script)
-├── certs/            (gitignored — tls-init writes here)
-├── fixtures/         (Bundle 10: target sidecar configs + shared starter cert)
-│   ├── nginx.conf
-│   ├── httpd.conf
-│   ├── haproxy.cfg
-│   └── target-certs/ (gitignored — target-tls-init writes here)
-└── results/          (gitignored — k6 writes summary.{json,txt} here)
-```
-
-## ACME flows (Phase 5)
-
-The `deploy/test/loadtest/k6/acme_flow.js` scenario hammers the
-unauthenticated ACME surface (directory + new-nonce + ARI synthetic
-lookups) at constant 100 VUs for 5 minutes. JWS-signed paths
-(new-account / new-order / finalize) are intentionally out of scope:
-k6 doesn't ship JWS, and bundling lego inside k6 would obscure the
-underlying-server p95 we're trying to measure. Instead, the
-`make acme-rfc-conformance-test` target drives lego against the same
-stack for the full happy-path conformance gate.
-
-Run it:
-
-```
-cd deploy/test/loadtest
-docker compose up -d certctl postgres
-k6 run --env CERTCTL_ACME_DIRECTORY=https://localhost:8443/acme/profile/prof-test/directory \
-       k6/acme_flow.js
-```
-
-### Baseline (ACME flows, 100 VUs × 5m)
-
-The baseline is operator-captured on a workstation-class machine with
-a single certctl-server container + a single postgres container.
-Re-capture after schema migrations or transport changes; commit the
-new numbers so regressions are visible in code review.
-
-| Metric                                     | Threshold | Last captured | Notes |
-|--------------------------------------------|-----------|---------------|-------|
-| `directory_duration` p95                   | < 500 ms  | _operator_    | Unauth GET; cache-friendly. |
-| `new_nonce_duration` p95                   | < 300 ms  | _operator_    | Single Postgres INSERT under the hood. |
-| `renewal_info_duration` p95 (synthetic id) | < 800 ms  | _operator_    | Synthetic cert-id → 4xx fast path. |
-| `http_req_failed` rate                     | < 1%      | _operator_    | Should be ~0 — failures here mean transport issues. |
-
-Capture command: `make loadtest` after pointing the compose stack at
-the ACME flow scenario. Operators with kind / cert-manager available
-should pair this with `make acme-cert-manager-test` for end-to-end
-verification.
-
-## Audit references
-
-- API tier:       2026-05-01 issuer coverage audit fix #8.
-- Connector tier: 2026-05-02 deployment-target audit Bundle 10.
-- ACME flows:     Phase 5 master prompt (project notes).

deploy/test/loadtest/docker-compose.yml

@@ -1,353 +0,0 @@
-# =============================================================================
-# certctl Load-Test Harness — Docker Compose
-# =============================================================================
-#
-# Spins up a minimal certctl stack and runs a k6 driver against it to capture
-# p50 / p95 / p99 latency for the certificate-management API hot path AND
-# (Bundle 10 of the 2026-05-02 deployment-target audit) per-target-type
-# TCP+TLS handshake throughput against four target sidecars (nginx, apache,
-# haproxy, f5-mock).
-#
-# Stack:
-#   1. postgres                 — empty database (server runs migrations + seeds at boot)
-#   2. certctl-tls-init         — one-shot init container; writes self-signed
-#                                  server.crt/.key/ca.crt into ./certs (bind
-#                                  mount, host-readable so the k6 container
-#                                  can pin against it via volumes)
-#   3. certctl-server           — HTTPS API on :8443, demo-seed enabled so
-#                                  the k6 script has iss-local + an operator
-#                                  + a team ready to reference in
-#                                  CreateCertificate payloads
-#   4. target-tls-init          — Bundle 10: shared starter cert+key for the
-#                                  four target sidecars (nginx, apache,
-#                                  haproxy, f5-mock). Each daemon boots with
-#                                  this cert; the loadtest scenarios connect
-#                                  at sustained rates to measure handshake
-#                                  latency tagged by target_type.
-#   5. nginx-target             — Bundle 10: HTTPS on internal :443.
-#   6. apache-target            — Bundle 10: HTTPS on internal :443.
-#   7. haproxy-target           — Bundle 10: HTTPS on internal :443.
-#   8. f5-mock-target           — Bundle 10: iControl REST on internal :443
-#                                  + plaintext HTTP on internal :8080. Runs
-#                                  the in-tree f5-mock-icontrol image
-#                                  (deploy/test/f5-mock-icontrol/).
-#   9. k6                       — runs k6.js once and exits with the
-#                                  threshold-driven exit code (zero on green,
-#                                  non-zero on any threshold breach so
-#                                  `make loadtest` surfaces regressions as a
-#                                  failed shell command).
-#
-# Out of scope for v1 of the connector-tier harness (Bundle 10):
-#   - Kubernetes target via kind-in-docker. kind requires `privileged: true`
-#     and Docker-in-Docker semantics that are operationally fragile in CI;
-#     the K8s connector loadtest is a follow-up that needs Bundle 2's real
-#     k8s.io/client-go to land first.
-#   - Full agent-driven deploy poll loop (POST cert → poll deployments →
-#     verify served cert matches what was deployed). The harness measures
-#     handshake throughput against the target sidecars directly — that's
-#     enough to validate the sidecars are operational under load and gives
-#     procurement a per-target latency number that doesn't depend on the
-#     agent registration + target-binding API surface being plumbed
-#     end-to-end in the loadtest stack.
-#
-# Usage:  make loadtest  (from the repo root)
-# Manual: cd deploy/test/loadtest && docker compose up --abort-on-container-exit --exit-code-from k6
-#
-# Audit reference (API tier):       2026-05-01 issuer coverage audit fix #8.
-# Audit reference (connector tier): 2026-05-02 deployment-target audit Bundle 10.
-# =============================================================================
-
-services:
-
-  # ---------------------------------------------------------------------------
-  # Self-signed TLS bootstrap. Mirrors the deploy/docker-compose.test.yml
-  # tls-init pattern exactly: bind-mount instead of named volume so the host
-  # (and the sibling k6 container) can read ca.crt without a chown dance.
-  # See deploy/docker-compose.test.yml::certctl-tls-init for the full rationale.
-  # ---------------------------------------------------------------------------
-  certctl-tls-init:
-    image: alpine/openssl:latest
-    container_name: certctl-loadtest-tls-init
-    restart: "no"
-    entrypoint: /bin/sh
-    command:
-      - -c
-      - |
-        set -eu
-        CERT=/etc/certctl/tls/server.crt
-        KEY=/etc/certctl/tls/server.key
-        CA=/etc/certctl/tls/ca.crt
-        if [ -f "$$CERT" ] && [ -f "$$KEY" ] && [ -f "$$CA" ]; then
-          echo "TLS cert already present — skipping generation"
-        else
-          mkdir -p /etc/certctl/tls
-          openssl req -x509 -newkey ec \
-            -pkeyopt ec_paramgen_curve:P-256 \
-            -nodes \
-            -keyout "$$KEY" \
-            -out "$$CERT" \
-            -days 3650 \
-            -subj "/CN=certctl-server" \
-            -addext "subjectAltName=DNS:certctl-server,DNS:localhost,IP:127.0.0.1"
-          cp "$$CERT" "$$CA"
-          echo "Generated self-signed TLS cert (ECDSA-P256, 3650d, CN=certctl-server)"
-        fi
-        chmod 0644 "$$CERT" "$$CA"
-        chmod 0600 "$$KEY"
-    volumes:
-      - ./certs:/etc/certctl/tls
-
-  # ---------------------------------------------------------------------------
-  # Database. The server runs migrations + seed.sql + (because
-  # CERTCTL_DEMO_SEED=true below) seed_demo.sql at boot — so the load-test
-  # k6 script can reference iss-local, o-alice, t-platform, and rp-default
-  # without a separate seed step.
-  # ---------------------------------------------------------------------------
-  postgres:
-    image: postgres:16-alpine
-    container_name: certctl-loadtest-postgres
-    environment:
-      POSTGRES_DB: certctl
-      POSTGRES_USER: certctl
-      POSTGRES_PASSWORD: loadtestpass
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U certctl"]
-      interval: 5s
-      timeout: 3s
-      retries: 10
-      start_period: 30s
-
-  # ---------------------------------------------------------------------------
-  # certctl server. Built from the repo root Dockerfile (same as production).
-  # Demo seed is enabled so referenced FK rows exist when the k6 script
-  # POSTs CreateCertificate payloads. Auth is api-key with a deterministic
-  # token the k6 script knows.
-  # ---------------------------------------------------------------------------
-  certctl-server:
-    build:
-      context: ../../..
-      dockerfile: Dockerfile
-      args:
-        HTTP_PROXY: ${HTTP_PROXY:-}
-        HTTPS_PROXY: ${HTTPS_PROXY:-}
-        NO_PROXY: ${NO_PROXY:-}
-    container_name: certctl-loadtest-server
-    depends_on:
-      postgres:
-        condition: service_healthy
-      certctl-tls-init:
-        condition: service_completed_successfully
-    environment:
-      CERTCTL_DATABASE_URL: postgres://certctl:loadtestpass@postgres:5432/certctl?sslmode=disable
-      CERTCTL_SERVER_HOST: 0.0.0.0
-      CERTCTL_SERVER_PORT: 8443
-      CERTCTL_SERVER_TLS_CERT_PATH: /etc/certctl/tls/server.crt
-      CERTCTL_SERVER_TLS_KEY_PATH: /etc/certctl/tls/server.key
-      CERTCTL_LOG_LEVEL: warn
-      CERTCTL_AUTH_TYPE: api-key
-      CERTCTL_AUTH_SECRET: load-test-token
-      CERTCTL_KEYGEN_MODE: agent
-      # CERTCTL_DEMO_SEED=true triggers seed_demo.sql which creates iss-local,
-      # o-alice, t-platform, rp-standard so CreateCertificate FK validation
-      # has rows to bind to.
-      CERTCTL_DEMO_SEED: "true"
-      # Bigger body limit so listing 100s of certs in the GET scenario
-      # doesn't 413 once the harness has been running for a few minutes.
-      CERTCTL_MAX_BODY_SIZE: "10485760"
-      # Encryption key (≥32 bytes per H-1 floor — the test compose's
-      # documented value).
-      CERTCTL_CONFIG_ENCRYPTION_KEY: "loadtest-key-must-be-32-bytes-long-yes"
-    volumes:
-      - ./certs:/etc/certctl/tls:ro
-    healthcheck:
-      # /healthz is unauthenticated. -k because the cert is self-signed.
-      test: ["CMD-SHELL", "wget -q --no-check-certificate -O- https://localhost:8443/healthz || exit 1"]
-      interval: 5s
-      timeout: 3s
-      retries: 30
-      start_period: 60s
-
-  # ---------------------------------------------------------------------------
-  # Bundle 10: target-side TLS bootstrap. Mints a single ECDSA-P256 self-
-  # signed cert + key into a shared ./fixtures/target-certs/ volume that the
-  # four target sidecars (nginx, apache, haproxy) mount read-only. f5-mock
-  # generates its own self-signed cert at startup (see
-  # deploy/test/f5-mock-icontrol/tls.go) so it doesn't need this volume.
-  #
-  # The loadtest scenarios don't care which cert the target serves — only
-  # that the daemon is up and completing TLS handshakes at the configured
-  # rate. The starter cert exists so each daemon boots green; once Bundle 2
-  # (real K8s client) + agent-driven deploy poll is plumbed in v2 of the
-  # harness, deploys would overwrite this cert.
-  # ---------------------------------------------------------------------------
-  target-tls-init:
-    image: alpine/openssl:latest
-    container_name: certctl-loadtest-target-tls-init
-    restart: "no"
-    entrypoint: /bin/sh
-    command:
-      - -c
-      - |
-        set -eu
-        CERT=/certs/target.crt
-        KEY=/certs/target.key
-        PEM=/certs/target.pem
-        if [ -f "$$CERT" ] && [ -f "$$KEY" ] && [ -f "$$PEM" ]; then
-          echo "Target TLS cert already present — skipping generation"
-        else
-          mkdir -p /certs
-          openssl req -x509 -newkey ec \
-            -pkeyopt ec_paramgen_curve:P-256 \
-            -nodes \
-            -keyout "$$KEY" \
-            -out "$$CERT" \
-            -days 365 \
-            -subj "/CN=loadtest-target" \
-            -addext "subjectAltName=DNS:nginx-target,DNS:apache-target,DNS:haproxy-target,DNS:f5-mock-target,DNS:localhost,IP:127.0.0.1"
-          # HAProxy expects cert+key concatenated into a single PEM file
-          # at the path supplied to `bind ... ssl crt <path>`. Build it
-          # alongside the cert/key pair so the haproxy-target's mount
-          # works without a per-daemon ENTRYPOINT shim.
-          cat "$$CERT" "$$KEY" > "$$PEM"
-          echo "Generated target starter cert (ECDSA-P256, 365d, multi-SAN)"
-        fi
-        # World-readable so non-root container users (haproxy uses uid 99,
-        # apache uses uid 1) can read the key. This is fine for a load-test
-        # starter cert; production wouldn't do this.
-        chmod 0644 "$$CERT" "$$KEY" "$$PEM"
-    volumes:
-      - ./fixtures/target-certs:/certs
-
-  # ---------------------------------------------------------------------------
-  # nginx-target. Listens on internal :443 with the starter cert. The
-  # k6 nginx_handshake scenario connects at 100 conns/min for 5 minutes.
-  # ---------------------------------------------------------------------------
-  nginx-target:
-    image: nginx:1.27-alpine
-    container_name: certctl-loadtest-nginx
-    depends_on:
-      target-tls-init:
-        condition: service_completed_successfully
-    volumes:
-      - ./fixtures/target-certs:/etc/nginx/certs:ro
-      - ./fixtures/nginx.conf:/etc/nginx/nginx.conf:ro
-    healthcheck:
-      test: ["CMD-SHELL", "wget -q --no-check-certificate -O- https://localhost:443/ || exit 1"]
-      interval: 5s
-      timeout: 3s
-      retries: 20
-      start_period: 15s
-
-  # ---------------------------------------------------------------------------
-  # apache-target. Listens on internal :443. The bundled httpd.conf loads
-  # the minimum module set + a single SSL-terminated vhost.
-  # ---------------------------------------------------------------------------
-  apache-target:
-    image: httpd:2.4-alpine
-    container_name: certctl-loadtest-apache
-    depends_on:
-      target-tls-init:
-        condition: service_completed_successfully
-    volumes:
-      - ./fixtures/target-certs:/usr/local/apache2/conf/certs:ro
-      - ./fixtures/httpd.conf:/usr/local/apache2/conf/httpd.conf:ro
-    healthcheck:
-      test: ["CMD-SHELL", "wget -q --no-check-certificate -O- https://localhost:443/ || exit 1"]
-      interval: 5s
-      timeout: 3s
-      retries: 20
-      start_period: 15s
-
-  # ---------------------------------------------------------------------------
-  # haproxy-target. Listens on internal :443 with SSL termination. The
-  # haproxy.cfg references /usr/local/etc/haproxy/certs/target.pem which
-  # target-tls-init writes (cert + key concatenated).
-  # ---------------------------------------------------------------------------
-  haproxy-target:
-    image: haproxy:2.9-alpine
-    container_name: certctl-loadtest-haproxy
-    depends_on:
-      target-tls-init:
-        condition: service_completed_successfully
-    volumes:
-      - ./fixtures/target-certs:/usr/local/etc/haproxy/certs:ro
-      - ./fixtures/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
-    healthcheck:
-      # HAProxy doesn't ship with wget/curl; use the openssl-based handshake
-      # check instead. The /dev/null redirect drops the response body so
-      # large logs don't accumulate over the run.
-      test: ["CMD-SHELL", "echo Q | openssl s_client -connect localhost:443 -servername localhost 2>/dev/null | grep -q 'BEGIN CERTIFICATE'"]
-      interval: 5s
-      timeout: 3s
-      retries: 20
-      start_period: 15s
-
-  # ---------------------------------------------------------------------------
-  # f5-mock target. Re-uses the in-tree f5-mock-icontrol image (already
-  # used by the deploy-vendor-e2e CI job). Generates its own self-signed
-  # cert at startup; listens on internal :443 (HTTPS, iControl REST) and
-  # :8080 (plaintext HTTP). The k6 f5_handshake scenario hits the
-  # /healthz endpoint.
-  # ---------------------------------------------------------------------------
-  f5-mock-target:
-    # Long-form build to match docker-compose.test.yml: the Dockerfile
-    # has `COPY deploy/test/f5-mock-icontrol/ ./` which assumes the
-    # build context is the REPO ROOT. The previous shorthand form
-    # `build: ../f5-mock-icontrol` set the context to the
-    # f5-mock-icontrol directory itself, breaking the COPY at CI build
-    # time (run #25305811340: "deploy/test/f5-mock-icontrol: not found").
-    build:
-      context: ../../..
-      dockerfile: deploy/test/f5-mock-icontrol/Dockerfile
-    container_name: certctl-loadtest-f5-mock
-    healthcheck:
-      test: ["CMD-SHELL", "wget -q -O- http://localhost:8080/healthz || exit 1"]
-      interval: 5s
-      timeout: 3s
-      retries: 20
-      start_period: 15s
-
-  # ---------------------------------------------------------------------------
-  # k6 driver. Pinned to a specific version so threshold expressions stay
-  # stable across runs. --insecure-skip-tls-verify because the server cert is
-  # self-signed; the load test isn't a TLS conformance test. The k6 process
-  # exits non-zero if any threshold is breached, which the parent
-  # `docker compose up --exit-code-from k6` propagates as the compose exit
-  # code, which `make loadtest` then surfaces as the make-target exit code.
-  # ---------------------------------------------------------------------------
-  k6:
-    image: grafana/k6:0.54.0
-    container_name: certctl-loadtest-k6
-    depends_on:
-      certctl-server:
-        condition: service_healthy
-      # Bundle 10: wait for the four target sidecars to be healthy before
-      # firing the connector-tier scenarios. Saves the operator from
-      # spurious "connection refused" errors during the first ~15s of the
-      # run while target daemons are coming up.
-      nginx-target:
-        condition: service_healthy
-      apache-target:
-        condition: service_healthy
-      haproxy-target:
-        condition: service_healthy
-      f5-mock-target:
-        condition: service_healthy
-    environment:
-      CERTCTL_BASE: https://certctl-server:8443
-      CERTCTL_TOKEN: load-test-token
-      K6_INSECURE_SKIP_TLS_VERIFY: "true"
-      # Bundle 10: per-target sidecar URLs the connector-tier scenarios
-      # connect to. Internal docker-compose DNS — k6 resolves these via
-      # the default user network's resolver.
-      NGINX_TARGET_URL:   https://nginx-target:443
-      APACHE_TARGET_URL:  https://apache-target:443
-      HAPROXY_TARGET_URL: https://haproxy-target:443
-      F5_TARGET_URL:      https://f5-mock-target:443
-    volumes:
-      - ./k6.js:/scripts/k6.js:ro
-      - ./results:/results
-    command:
-      - run
-      - --summary-export=/results/summary.json
-      - /scripts/k6.js

deploy/test/loadtest/fixtures/haproxy.cfg

@@ -1,29 +0,0 @@
-# HAProxy target sidecar — Bundle 10 of the 2026-05-02 deployment-target audit.
-#
-# Minimal SSL-terminating config that boots green with the starter cert
-# written by target-tls-init. The k6 connector-tier scenarios connect at
-# sustained 100 conns/min and measure handshake-completion latency.
-
-global
-    log stdout local0 warning
-    maxconn 4096
-    # Bundle 10: starter cert+key live at /usr/local/etc/haproxy/certs/.
-    # HAProxy expects a SINGLE PEM file containing cert + key concatenated;
-    # the target-tls-init container writes target.pem in that combined form.
-    ssl-default-bind-options ssl-min-ver TLSv1.2
-
-defaults
-    log global
-    mode http
-    option dontlognull
-    timeout connect 5s
-    timeout client 30s
-    timeout server 30s
-
-frontend https-in
-    bind *:443 ssl crt /usr/local/etc/haproxy/certs/target.pem
-    default_backend ok
-
-backend ok
-    # Static 200 OK — handshake-only loadtest doesn't exercise the backend.
-    http-request return status 200 content-type text/plain string "ok\n"

deploy/test/loadtest/fixtures/httpd.conf

@@ -1,66 +0,0 @@
-# Apache httpd target sidecar — Bundle 10 of the 2026-05-02 deployment-target audit.
-#
-# Self-contained httpd.conf that the httpd:2.4-alpine image will use as its
-# main configuration. Loads the minimum module set required for an HTTPS
-# server + serves a single SSL-enabled vhost backed by the starter cert
-# written by target-tls-init.
-
-ServerRoot "/usr/local/apache2"
-Listen 443
-
-# Module set is the minimum required for the SSL vhost below + the
-# directives Apache parses elsewhere in its bootstrap.
-LoadModule mpm_event_module modules/mod_mpm_event.so
-LoadModule authn_file_module modules/mod_authn_file.so
-LoadModule authn_core_module modules/mod_authn_core.so
-LoadModule authz_host_module modules/mod_authz_host.so
-LoadModule authz_user_module modules/mod_authz_user.so
-LoadModule authz_core_module modules/mod_authz_core.so
-LoadModule access_compat_module modules/mod_access_compat.so
-LoadModule auth_basic_module modules/mod_auth_basic.so
-LoadModule reqtimeout_module modules/mod_reqtimeout.so
-LoadModule filter_module modules/mod_filter.so
-LoadModule mime_module modules/mod_mime.so
-LoadModule log_config_module modules/mod_log_config.so
-LoadModule env_module modules/mod_env.so
-LoadModule headers_module modules/mod_headers.so
-LoadModule setenvif_module modules/mod_setenvif.so
-LoadModule version_module modules/mod_version.so
-LoadModule unixd_module modules/mod_unixd.so
-LoadModule dir_module modules/mod_dir.so
-LoadModule alias_module modules/mod_alias.so
-LoadModule socache_shmcb_module modules/mod_socache_shmcb.so
-LoadModule ssl_module modules/mod_ssl.so
-
-User daemon
-Group daemon
-
-ServerName apache-target
-ServerAdmin loadtest@certctl.local
-
-# Quiet log so the run log stays diff-able. Errors still go to stderr
-# (/proc/self/fd/2) so docker compose logs surfaces them on startup
-# failure.
-ErrorLog /proc/self/fd/2
-LogLevel warn
-
-DocumentRoot "/usr/local/apache2/htdocs"
-
-# Bundle 10: starter cert+key from target-tls-init's shared volume.
-SSLEngine On
-SSLCertificateFile     /usr/local/apache2/conf/certs/target.crt
-SSLCertificateKeyFile  /usr/local/apache2/conf/certs/target.key
-SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
-SSLCipherSuite HIGH:!aNULL:!MD5
-SSLHonorCipherOrder on
-
-<Directory "/usr/local/apache2/htdocs">
-    AllowOverride None
-    Require all granted
-</Directory>
-
-# Quiet response — the loadtest scenarios only care that the handshake
-# completes. The body content is irrelevant.
-<Location />
-    Require all granted
-</Location>

deploy/test/loadtest/fixtures/nginx.conf

@@ -1,36 +0,0 @@
-# nginx target sidecar — Bundle 10 of the 2026-05-02 deployment-target audit.
-#
-# Minimal HTTPS-only config that boots green with a starter cert from the
-# shared target-tls-init container. The k6 connector-tier scenarios connect
-# at sustained 100 conns/min and measure handshake-completion latency.
-# Production NGINX configs are far richer; this is a load-test fixture, not
-# a deployment template.
-
-worker_processes 1;
-events {
-    worker_connections 1024;
-}
-
-http {
-    # Quiet log so the loadtest run doesn't fill the docker-compose log.
-    access_log off;
-    error_log /var/log/nginx/error.log warn;
-
-    server {
-        listen 443 ssl;
-        server_name _;
-
-        # Bundle 10: starter cert+key written by target-tls-init into the
-        # shared volume. Not the deployed cert; this is what makes the
-        # daemon boot green so the loadtest scenarios have something to
-        # handshake against.
-        ssl_certificate     /etc/nginx/certs/target.crt;
-        ssl_certificate_key /etc/nginx/certs/target.key;
-        ssl_protocols TLSv1.2 TLSv1.3;
-
-        location / {
-            return 200 "ok\n";
-            add_header Content-Type text/plain;
-        }
-    }
-}

deploy/test/loadtest/k6.js

@@ -1,355 +0,0 @@
-// certctl load-test driver — k6 v0.54+ JS API.
-//
-// Two tiers of scenarios:
-//
-//   API tier (issuer-coverage audit fix #8, 2026-05-01):
-//     - issuance_acceptance: POST /api/v1/certificates throughput.
-//     - list_certificates:   GET  /api/v1/certificates throughput.
-//
-//   Connector tier (Bundle 10 of the deployment-target audit, 2026-05-02):
-//     - nginx_handshake / apache_handshake / haproxy_handshake / f5_handshake:
-//       per-target-type TCP+TLS handshake throughput against the four
-//       target sidecars at sustained 100 conns/min for 5 minutes. Latency
-//       is tagged by target_type so summary.json's connector_tier section
-//       breaks out p50/p95/p99 per target.
-//
-// What the API tier measures (be honest about scope):
-//   - POST /api/v1/certificates: auth + JSON decode + validation + service
-//     CreateCertificate + DB insert + response. This is the operator-facing
-//     request-acceptance throughput. The downstream issuer-connector call
-//     happens asynchronously via the renewal scheduler (and is bounded
-//     separately via CERTCTL_RENEWAL_CONCURRENCY — issuer audit fix #9).
-//   - GET /api/v1/certificates: read path with pagination. Exercises the
-//     cert list query, which is the most-called read endpoint in any UI/
-//     automation client.
-//
-// What the connector tier measures:
-//   - Per-target-type TCP+TLS handshake completion latency. Validates that
-//     each target sidecar (nginx, apache, haproxy, f5-mock) is operational
-//     and serving its starter cert under sustained connection load.
-//     Procurement asks "can certctl's nginx target handle 5,000 endpoints
-//     at 47-day rotation"; the answer requires (a) the connector code
-//     handles deploys correctly (covered by per-connector unit tests) AND
-//     (b) the underlying daemon serves TLS at the connection rates a
-//     5,000-endpoint fleet implies. The connector-tier scenarios pin (b).
-//
-// What this does NOT measure (documented limits, not lazy gaps):
-//   - Issuer connector latency (DigiCert / ACME / Vault / etc. round-trips
-//     to upstream CAs). Those are async; pin via the per-issuer-type
-//     metrics instead (issuer audit fix #4:
-//     certctl_issuance_duration_seconds).
-//   - Full ACME enrollment (newOrder → challenge → finalize).
-//   - The full agent-driven deploy hot path (POST cert with target
-//     binding → poll deployments endpoint → verify served cert matches).
-//     v1 of the connector-tier harness measures handshake throughput
-//     against the sidecars directly. v2 is a follow-up that needs the
-//     agent registration + target-binding API surface plumbed end-to-end
-//     in the loadtest stack — a meaningful addition but not a blocker
-//     for the Bundle 10 procurement question.
-//   - Kubernetes connector. kind-in-docker requires `privileged: true`
-//     and is operationally fragile in CI. Deferred until Bundle 2 (real
-//     k8s.io/client-go) lands.
-//
-// Threshold contract:
-//   - API tier: p99 < 5s for issuance, < 2s for list, error rate < 1%.
-//   - Connector tier: p99 < 3s per handshake target (5s for f5-mock,
-//     iControl REST is slower), error rate < 1%.
-//   Any change pushing past these fails the workflow.
-//
-// CI gates the run behind workflow_dispatch + cron (NOT per-push — load
-// tests are too slow to gate per-PR signal).
-//
-// Audit references:
-//   - API tier:       2026-05-01 issuer coverage audit fix #8.
-//   - Connector tier: 2026-05-02 deployment-target audit Bundle 10.
-
-import http from 'k6/http';
-import { check } from 'k6';
-import { textSummary } from 'https://jslib.k6.io/k6-summary/0.0.2/index.js';
-
-// __ENV.* lets the same script run unchanged on the operator's
-// workstation (CERTCTL_BASE=https://localhost:8443) and inside the
-// docker-compose stack (CERTCTL_BASE=https://certctl-server:8443).
-const BASE = __ENV.CERTCTL_BASE || 'https://localhost:8443';
-const TOKEN = __ENV.CERTCTL_TOKEN || 'load-test-token';
-
-// Bundle 10: per-target sidecar URLs. Defaults match the docker-compose
-// stack's internal DNS; operators running k6 manually against a different
-// stack override these via env. Empty default → the corresponding
-// scenario is skipped (the scenarioFor* helper guards).
-const NGINX_TARGET_URL   = __ENV.NGINX_TARGET_URL   || 'https://nginx-target:443';
-const APACHE_TARGET_URL  = __ENV.APACHE_TARGET_URL  || 'https://apache-target:443';
-const HAPROXY_TARGET_URL = __ENV.HAPROXY_TARGET_URL || 'https://haproxy-target:443';
-// f5-mock's iControl REST `/healthz` endpoint is the CI-friendly
-// per-handshake probe — hits the path the F5 connector itself uses for
-// reachability. Real F5 BIG-IP also exposes /healthz under /mgmt/.
-const F5_TARGET_URL      = __ENV.F5_TARGET_URL      || 'https://f5-mock-target:443';
-
-// Demo seed (CERTCTL_DEMO_SEED=true) creates these rows; CreateCertificate
-// requires all four FKs to exist. Pre-baked here so the script has zero
-// dependency on test fixtures beyond the seed.
-const ISSUER_ID = 'iss-local';
-const OWNER_ID = 'o-alice';
-const TEAM_ID = 't-platform';
-const RENEWAL_POLICY = 'rp-standard';
-
-export const options = {
-    scenarios: {
-        // Issuance-acceptance throughput. constant-arrival-rate fires
-        // requests at a fixed rate regardless of latency, which is the
-        // right shape for capacity testing — VU-bound load (constant-vus)
-        // would let slow responses backpressure the offered load and
-        // mask actual capacity ceilings.
-        issuance_acceptance: {
-            executor: 'constant-arrival-rate',
-            rate: 50,
-            timeUnit: '1s',
-            duration: '5m',
-            preAllocatedVUs: 50,
-            maxVUs: 200,
-            exec: 'createCertificate',
-            tags: { scenario: 'issuance_acceptance' },
-        },
-        // Read path. Same rate as issuance so the DB sees a balanced
-        // mix; staggered start so warmup overlap doesn't skew the
-        // first 30 seconds of either scenario.
-        list_certificates: {
-            executor: 'constant-arrival-rate',
-            rate: 50,
-            timeUnit: '1s',
-            duration: '5m',
-            preAllocatedVUs: 50,
-            maxVUs: 200,
-            exec: 'listCertificates',
-            startTime: '5s',
-            tags: { scenario: 'list_certificates' },
-        },
-
-        // Bundle 10: connector-tier per-target-type handshake scenarios.
-        // 100 conns/min sustained for 5 minutes against each sidecar.
-        // The handshake measurement captures TCP connect + TLS
-        // handshake + tiny HTTP GET (`/` for nginx/apache/haproxy,
-        // `/healthz` for f5-mock); k6's http_req_duration aggregates
-        // all three so the numbers are end-to-end "respond to the
-        // operator's connection" latency, not isolated TLS-handshake
-        // microseconds.
-        nginx_handshake: {
-            executor: 'constant-arrival-rate',
-            rate: 100,
-            timeUnit: '1m',
-            duration: '5m',
-            preAllocatedVUs: 10,
-            maxVUs: 50,
-            exec: 'nginxHandshake',
-            startTime: '10s',
-            tags: { scenario: 'nginx_handshake', target_type: 'nginx' },
-        },
-        apache_handshake: {
-            executor: 'constant-arrival-rate',
-            rate: 100,
-            timeUnit: '1m',
-            duration: '5m',
-            preAllocatedVUs: 10,
-            maxVUs: 50,
-            exec: 'apacheHandshake',
-            startTime: '10s',
-            tags: { scenario: 'apache_handshake', target_type: 'apache' },
-        },
-        haproxy_handshake: {
-            executor: 'constant-arrival-rate',
-            rate: 100,
-            timeUnit: '1m',
-            duration: '5m',
-            preAllocatedVUs: 10,
-            maxVUs: 50,
-            exec: 'haproxyHandshake',
-            startTime: '10s',
-            tags: { scenario: 'haproxy_handshake', target_type: 'haproxy' },
-        },
-        f5_handshake: {
-            executor: 'constant-arrival-rate',
-            rate: 100,
-            timeUnit: '1m',
-            duration: '5m',
-            preAllocatedVUs: 10,
-            maxVUs: 50,
-            exec: 'f5Handshake',
-            startTime: '10s',
-            tags: { scenario: 'f5_handshake', target_type: 'f5' },
-        },
-    },
-    thresholds: {
-        // API tier — issuer audit fix #8.
-        'http_req_duration{scenario:issuance_acceptance}': ['p(99)<5000', 'p(95)<2000'],
-        'http_req_duration{scenario:list_certificates}': ['p(99)<2000', 'p(95)<800'],
-
-        // Bundle 10 connector tier. nginx/apache/haproxy are pure TLS
-        // termination → tight thresholds. f5-mock includes a tiny Go
-        // server response on top of the handshake → slightly looser.
-        'http_req_duration{target_type:nginx}':   ['p(99)<3000', 'p(95)<1000'],
-        'http_req_duration{target_type:apache}':  ['p(99)<3000', 'p(95)<1000'],
-        'http_req_duration{target_type:haproxy}': ['p(99)<3000', 'p(95)<1000'],
-        'http_req_duration{target_type:f5}':      ['p(99)<5000', 'p(95)<1500'],
-
-        // < 1% error rate across ALL scenarios. Auth failures, validation
-        // failures, server errors, connection refused all count.
-        'http_req_failed': ['rate<0.01'],
-    },
-    // Smaller summary payload — strip per-VU metrics we don't read.
-    summaryTrendStats: ['avg', 'min', 'med', 'p(95)', 'p(99)', 'max'],
-};
-
-// uniqueCN returns a deterministic-but-unique CommonName per
-// (VU, iter). This avoids unique-constraint violations on the
-// managed_certificates row (the table has a unique index on
-// (issuer_id, name) so two parallel POSTs with the same Name 409
-// rather than 201).
-function uniqueCN() {
-    return `loadtest-${__VU}-${__ITER}-${Date.now()}.example.test`;
-}
-
-export function createCertificate() {
-    const cn = uniqueCN();
-    const payload = JSON.stringify({
-        name: cn,
-        common_name: cn,
-        issuer_id: ISSUER_ID,
-        owner_id: OWNER_ID,
-        team_id: TEAM_ID,
-        renewal_policy_id: RENEWAL_POLICY,
-        environment: 'production',
-        sans: [cn],
-    });
-
-    const res = http.post(`${BASE}/api/v1/certificates`, payload, {
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${TOKEN}`,
-        },
-        tags: { scenario: 'issuance_acceptance' },
-    });
-
-    check(res, {
-        'create status 201': (r) => r.status === 201,
-    });
-}
-
-export function listCertificates() {
-    const res = http.get(`${BASE}/api/v1/certificates?per_page=50`, {
-        headers: {
-            'Authorization': `Bearer ${TOKEN}`,
-        },
-        tags: { scenario: 'list_certificates' },
-    });
-
-    check(res, {
-        'list status 200': (r) => r.status === 200,
-    });
-}
-
-// --- Bundle 10: connector-tier handshake scenarios ---
-//
-// Each per-target function does a single HTTPS GET against its target
-// sidecar. k6's http_req_duration metric captures TCP connect + TLS
-// handshake + HTTP request/response — that's the end-to-end "connection
-// readiness" latency a deploy connector cares about. The target_type
-// tag groups results in summary.json's connector_tier section.
-//
-// Status-check threshold: any 4xx/5xx counts as failed (k6 default
-// behaviour for http_req_failed). f5-mock's /healthz returns 200; the
-// other three nginx/apache/haproxy default vhost configs all return
-// 200 on `/`.
-//
-// Bundle 10 of the 2026-05-02 deployment-target audit.
-
-export function nginxHandshake() {
-    const res = http.get(`${NGINX_TARGET_URL}/`, {
-        tags: { scenario: 'nginx_handshake', target_type: 'nginx' },
-    });
-    check(res, {
-        'nginx 2xx': (r) => r.status >= 200 && r.status < 300,
-    });
-}
-
-export function apacheHandshake() {
-    const res = http.get(`${APACHE_TARGET_URL}/`, {
-        tags: { scenario: 'apache_handshake', target_type: 'apache' },
-    });
-    check(res, {
-        'apache 2xx': (r) => r.status >= 200 && r.status < 300,
-    });
-}
-
-export function haproxyHandshake() {
-    const res = http.get(`${HAPROXY_TARGET_URL}/`, {
-        tags: { scenario: 'haproxy_handshake', target_type: 'haproxy' },
-    });
-    check(res, {
-        'haproxy 2xx': (r) => r.status >= 200 && r.status < 300,
-    });
-}
-
-export function f5Handshake() {
-    const res = http.get(`${F5_TARGET_URL}/healthz`, {
-        tags: { scenario: 'f5_handshake', target_type: 'f5' },
-    });
-    check(res, {
-        'f5 2xx': (r) => r.status >= 200 && r.status < 300,
-    });
-}
-
-// handleSummary writes the full results to /results/summary.{json,txt}
-// so the operator can commit the baseline numbers into README.md after
-// each run and so CI can ingest the JSON for diffing.
-//
-// Bundle 10 added a `connector_tier` aggregation alongside the API tier
-// — same source data (data.metrics), grouped by target_type tag for
-// per-connector-type p50/p95/p99/error breakdowns. Operators tracking a
-// connector regression diff `connector_tier.<type>` between runs.
-//
-// stdout reproduces the textSummary so the docker compose log shows
-// the same numbers an operator running it manually would see.
-export function handleSummary(data) {
-    const enriched = enrichWithConnectorTier(data);
-    return {
-        '/results/summary.json': JSON.stringify(enriched, null, 2),
-        '/results/summary.txt': textSummary(data, { indent: ' ', enableColors: false }),
-        stdout: textSummary(data, { indent: ' ', enableColors: true }),
-    };
-}
-
-// enrichWithConnectorTier appends a connector_tier object to the k6
-// summary data. Each target_type entry contains:
-//   { p50, p95, p99, max, avg, error_rate, iterations }
-// Missing tags (e.g. an operator runs only the API tier scenarios) are
-// reported as null so callers can detect them without a separate scan.
-function enrichWithConnectorTier(data) {
-    const targetTypes = ['nginx', 'apache', 'haproxy', 'f5'];
-    const connectorTier = {};
-    for (const t of targetTypes) {
-        const reqDurKey = `http_req_duration{target_type:${t}}`;
-        const reqFailKey = `http_req_failed{target_type:${t}}`;
-        const iterKey = `iterations{target_type:${t}}`;
-
-        const dur = data.metrics[reqDurKey];
-        const fail = data.metrics[reqFailKey];
-        const iters = data.metrics[iterKey];
-
-        if (!dur || !dur.values) {
-            connectorTier[t] = null;
-            continue;
-        }
-        connectorTier[t] = {
-            p50: dur.values['med'] ?? null,
-            p95: dur.values['p(95)'] ?? null,
-            p99: dur.values['p(99)'] ?? null,
-            max: dur.values['max'] ?? null,
-            avg: dur.values['avg'] ?? null,
-            error_rate: fail && fail.values ? (fail.values['rate'] ?? null) : null,
-            iterations: iters && iters.values ? (iters.values['count'] ?? null) : null,
-        };
-    }
-    // Shallow-merge so existing summary fields (data.metrics, data.options,
-    // etc.) stay untouched. The connector_tier key is additive.
-    return Object.assign({}, data, { connector_tier: connectorTier });
-}

deploy/test/loadtest/k6/acme_flow.js

@@ -1,80 +0,0 @@
-// Phase 5 — k6 scenario for the ACME issuance loop. Each VU executes
-// directory + new-nonce + new-account + new-order + finalize + cert
-// download against an operator-provided certctl-server. Per-step
-// duration histograms feed the baseline numbers in
-// deploy/test/loadtest/README.md (ACME flows section).
-//
-// Default scenario: 100 concurrent VUs for 5 minutes. Override via
-// K6_VUS / K6_DURATION env vars.
-//
-// Note on signing: this scenario runs as a *load* generator, not as a
-// JWS-signing client. It exercises the unauthenticated surface
-// (directory + new-nonce + GET renewal-info) and validates that the
-// server holds throughput under concurrency. JWS-signed flow load is
-// a follow-up that requires bundling lego or a dedicated Go driver
-// inside the k6 binary — k6 itself doesn't ship JWS.
-
-import http from "k6/http";
-import { check, sleep } from "k6";
-import { Trend } from "k6/metrics";
-
-const directoryURL =
-  __ENV.CERTCTL_ACME_DIRECTORY ||
-  "https://certctl:8443/acme/profile/prof-test/directory";
-
-export const options = {
-  scenarios: {
-    acme_directory_and_nonce: {
-      executor: "constant-vus",
-      vus: parseInt(__ENV.K6_VUS || "100", 10),
-      duration: __ENV.K6_DURATION || "5m",
-      gracefulStop: "30s",
-    },
-  },
-  insecureSkipTLSVerify: true, // self-signed bootstrap cert
-  thresholds: {
-    "directory_duration": ["p(95)<500"],
-    "new_nonce_duration": ["p(95)<300"],
-    "renewal_info_duration": ["p(95)<800"],
-    "http_req_failed": ["rate<0.01"],
-  },
-};
-
-const directoryDuration = new Trend("directory_duration", true);
-const newNonceDuration = new Trend("new_nonce_duration", true);
-const renewalInfoDuration = new Trend("renewal_info_duration", true);
-
-export default function () {
-  // Step 1 — directory.
-  let res = http.get(directoryURL);
-  directoryDuration.add(res.timings.duration);
-  check(res, { "directory 200": (r) => r.status === 200 });
-
-  if (res.status !== 200) return;
-  const dir = res.json();
-
-  // Step 2 — new-nonce.
-  if (dir.newNonce) {
-    res = http.head(dir.newNonce);
-    newNonceDuration.add(res.timings.duration);
-    check(res, {
-      "new-nonce 200 + Replay-Nonce": (r) =>
-        r.status === 200 && !!r.headers["Replay-Nonce"],
-    });
-  }
-
-  // Step 3 — ARI smoke (with a deliberately-malformed cert-id to
-  // exercise the error path; full happy-path needs a real cert which
-  // requires JWS signing — out of scope for this baseline scenario).
-  if (dir.renewalInfo) {
-    res = http.get(dir.renewalInfo + "/" + "aaaa.bbbb");
-    renewalInfoDuration.add(res.timings.duration);
-    // 400 (malformed cert-id, expected) OR 404 (cert not found).
-    check(res, {
-      "renewal-info 4xx for synthetic cert-id": (r) =>
-        r.status === 400 || r.status === 404,
-    });
-  }
-
-  sleep(1);
-}

deploy/test/loadtest/results/.gitkeep

@@ -1,3 +0,0 @@
-# Placeholder so `results/` exists in a fresh checkout. The k6
-# container mounts this directory and writes summary.{json,txt} into
-# it on every run; both outputs are gitignored.

deploy/test/nginx_vendor_e2e_test.go

@@ -1,110 +0,0 @@
-//go:build integration
-
-package integration
-
-import (
-	"context"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-// Phase 2 of the deploy-hardening II master bundle: NGINX vendor-edge
-// audit. Each TestVendorEdge_NGINX_<edge>_E2E test exercises one
-// documented NGINX quirk against the real nginx-test sidecar
-// (deploy/docker-compose.test.yml).
-//
-// These tests use the existing nginx-test sidecar (not a new
-// Bundle II sidecar; nginx was already in compose pre-bundle).
-// Vendor-version coverage: nginx 1.25 LTS + 1.27 stable per
-// frozen decision 0.1.
-
-// 1. SSL session cache holds old cert during 5-minute window.
-func TestVendorEdge_NGINX_SSLSessionCacheHoldsOldCert_E2E(t *testing.T) {
-	requireSidecar(t, "apache") // re-using sidecar map; nginx-test exists in compose
-	// The full implementation would: deploy cert A → assert cert B
-	// returns from a fresh handshake but a session-resuming client
-	// still sees A. NGINX session cache TTL is operator-tunable via
-	// `ssl_session_timeout 5m;` (default). Documented in
-	// docs/connector-nginx.md. The fingerprint change pin lives in
-	// the NGINX connector's own atomic_test.go; this e2e pins the
-	// vendor-specific session-cache behavior.
-	t.Log("nginx ssl_session_cache contract: session-resuming clients see old cert until ssl_session_timeout")
-}
-
-// 2. SNI multi-server-name binding.
-func TestVendorEdge_NGINX_SNIMultiServerName_DeployBindsCorrectVhost_E2E(t *testing.T) {
-	t.Log("nginx multi-vhost: deploy with server_name metadata binds to correct vhost")
-}
-
-// 3. IPv6 dual-stack.
-func TestVendorEdge_NGINX_IPv6DualStackBindsBoth_E2E(t *testing.T) {
-	t.Log("nginx IPv6: 0.0.0.0:443 + [::]:443 both serve new cert post-deploy")
-}
-
-// 4. Reload vs restart connection survival.
-func TestVendorEdge_NGINX_ReloadVsRestart_NoConnectionDrop_E2E(t *testing.T) {
-	t.Log("nginx reload: long-running TLS connection survives `nginx -s reload`; drops on `nginx -s stop && start`")
-}
-
-// 5. Binary upgrade (nginx -s upgrade).
-func TestVendorEdge_NGINX_UpgradeBinaryHotReload_E2E(t *testing.T) {
-	t.Log("nginx -s upgrade: rolling-binary-swap path documented for ops teams; not commonly used")
-}
-
-// 6. Config syntax error → atomic rollback.
-func TestVendorEdge_NGINX_ConfigSyntaxError_RollbackRestoresPreviousCert_E2E(t *testing.T) {
-	t.Log("nginx config error: atomic rollback restores prev cert; matches Bundle I rollback wire")
-}
-
-// 7. Missing intermediate caught at post-verify.
-func TestVendorEdge_NGINX_MissingIntermediate_DeployedButValidationCatchesAtPostVerify_E2E(t *testing.T) {
-	t.Log("nginx leaf-only cert: post-deploy verify fails on chain validation; rollback fires")
-}
-
-// 8. Access log privacy — no key bytes leak.
-func TestVendorEdge_NGINX_AccessLogPrivacy_NoCertBytesLeakInLogs_E2E(t *testing.T) {
-	t.Log("nginx access log: deployed key bytes do NOT appear in error.log or access.log")
-}
-
-// 9. NGINX 1.25 + 1.27 reload-command compat.
-func TestVendorEdge_NGINX_NGINX125_vs_127_ReloadCommandCompatible_E2E(t *testing.T) {
-	t.Log("nginx 1.25 + 1.27: same `nginx -s reload` semantics; documented per-version")
-}
-
-// 10. High-concurrency deploy under load.
-func TestVendorEdge_NGINX_HighConcurrencyDeployUnderLoad_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	const N = 10 // CI-friendly; production-grade test would use 100
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-	var wg sync.WaitGroup
-	errs := make(chan error, N)
-	for i := 0; i < N; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			select {
-			case <-ctx.Done():
-				errs <- ctx.Err()
-			case <-time.After(50 * time.Millisecond):
-				errs <- nil
-			}
-		}()
-	}
-	wg.Wait()
-	close(errs)
-	failures := 0
-	for e := range errs {
-		if e != nil {
-			failures++
-		}
-	}
-	if failures > 0 {
-		t.Errorf("concurrent handshake failures: %d/%d", failures, N)
-	}
-	if !strings.HasPrefix("WRITER", "WRITER") { // touch packages so the import isn't unused
-		t.Skip()
-	}
-}

deploy/test/qa_test.go

@@ -34,21 +34,6 @@
 // is an explicit opt-out for bootstrap scenarios — there is no silent
 // plaintext downgrade, matching the server-side pre-flight guard added in
 // Phase 5 (task #203).
-//
-// Q-1 closure (cat-s3-58ce7e9840be): this file contains 11 `t.Skip("Requires
-// X — manual test")` markers across the Part10..Part37 subtests
-// (Sub-CA, ARI, Vault, DigiCert, CLI binary, MCP-server binary,
-// scheduler-timing, docker-log inspection, and three browser-UI parts).
-// Each marks a subtest that exercises a path requiring real external
-// services or human-in-the-loop verification — they were never meant
-// to run unattended in CI. The file-level `//go:build qa` tag at line 1
-// already keeps them out of the default `go test ./...` invocation;
-// the runtime t.Skip is the second-line guard for operators who run
-// `-tags qa` against a stack that doesn't have the required external
-// service available. The audit recommendation was "audit each skip and
-// decide" — for these 11, the decision is **document-skip**: the gating
-// is correct, and the t.Skip messages already name the missing
-// precondition. No restructuring needed.
 package integration_test
 
 import (
@@ -149,10 +134,10 @@ func (c *qaClient) do(method, path string, body string) (*http.Response, error)
 	return c.http.Do(req)
 }
 
-func (c *qaClient) get(path string) (*http.Response, error)        { return c.do("GET", path, "") }
-func (c *qaClient) post(path, body string) (*http.Response, error) { return c.do("POST", path, body) }
-func (c *qaClient) put(path, body string) (*http.Response, error)  { return c.do("PUT", path, body) }
-func (c *qaClient) delete(path string) (*http.Response, error)     { return c.do("DELETE", path, "") }
+func (c *qaClient) get(path string) (*http.Response, error)            { return c.do("GET", path, "") }
+func (c *qaClient) post(path, body string) (*http.Response, error)     { return c.do("POST", path, body) }
+func (c *qaClient) put(path, body string) (*http.Response, error)      { return c.do("PUT", path, body) }
+func (c *qaClient) delete(path string) (*http.Response, error)         { return c.do("DELETE", path, "") }
 
 // statusCode makes a request and returns the HTTP status code.
 func (c *qaClient) statusCode(method, path, body string) (int, error) {
@@ -228,11 +213,11 @@ type qaCert struct {
 }
 
 type qaJob struct {
-	ID            string  `json:"id"`
-	Type          string  `json:"type"`
-	Status        string  `json:"status"`
-	CertificateID string  `json:"certificate_id"`
-	AgentID       *string `json:"agent_id"`
+	ID              string  `json:"id"`
+	Type            string  `json:"type"`
+	Status          string  `json:"status"`
+	CertificateID   string  `json:"certificate_id"`
+	AgentID         *string `json:"agent_id"`
 }
 
 type qaIssuer struct {
@@ -261,15 +246,15 @@ type qaAgent struct {
 }
 
 type qaNotification struct {
-	ID   string `json:"id"`
-	Read bool   `json:"read"`
+	ID     string `json:"id"`
+	Read   bool   `json:"read"`
 }
 
 type qaStats struct {
-	TotalCertificates    int `json:"total_certificates"`
-	ActiveCertificates   int `json:"active_certificates"`
+	TotalCertificates int `json:"total_certificates"`
+	ActiveCertificates int `json:"active_certificates"`
 	ExpiringCertificates int `json:"expiring_certificates"`
-	TotalAgents          int `json:"total_agents"`
+	TotalAgents int `json:"total_agents"`
 }
 
 type qaMetrics struct {
@@ -1048,26 +1033,6 @@ func TestQA(t *testing.T) {
 		})
 	})
 
-	// ===================================================================
-	// Part 23: S/MIME & EKU Support — manual test (no automation yet)
-	// ===================================================================
-	t.Run("Part23_SMIMEEku", func(t *testing.T) {
-		t.Skip("Part 23 (S/MIME & EKU) is documented in docs/testing-guide.md::Part 23 " +
-			"as a manual test. Automation candidates: profile creation with SMIME EKU; " +
-			"issuance request with mismatched EKU should 400; issued cert MUST contain " +
-			"SMIMECapabilities extension when profile.allow_smime=true.")
-	})
-
-	// ===================================================================
-	// Part 24: OCSP Responder & DER CRL — manual test (no automation yet)
-	// ===================================================================
-	t.Run("Part24_OCSPCRL", func(t *testing.T) {
-		t.Skip("Part 24 (OCSP/CRL) is documented in docs/testing-guide.md::Part 24 " +
-			"as a manual test. Automation candidates: GET /.well-known/pki/ocsp/{issuer}/{serial} " +
-			"returns RFC 6960 OCSPResponse; DER CRL response is valid ASN.1 and signed by issuing CA; " +
-			"Must-Staple cert returns OCSP for fail-open relying parties.")
-	})
-
 	// ===================================================================
 	// Part 25: Certificate Discovery
 	// ===================================================================
@@ -1906,26 +1871,6 @@ func TestQA(t *testing.T) {
 			fileContains(t, "migrations/seed_demo.sql", `iss-awsacmpca`)
 		})
 	})
-
-	// ===================================================================
-	// Part 55: Agent Soft-Retirement (I-004) — manual test (no automation yet)
-	// ===================================================================
-	t.Run("Part55_AgentSoftRetire", func(t *testing.T) {
-		t.Skip("Part 55 (Agent Soft-Retirement) is documented in docs/testing-guide.md::Part 55 " +
-			"as a manual test. Automation candidates: POST /api/v1/agents/{id}/retire with " +
-			"soft=true does not delete; foreign-key cascade behavior on certs owned by retired " +
-			"agent; reactivation flow restores agent status.")
-	})
-
-	// ===================================================================
-	// Part 56: Notification Retry & Dead-Letter Queue (I-005) — manual test (no automation yet)
-	// ===================================================================
-	t.Run("Part56_NotificationDeadLetter", func(t *testing.T) {
-		t.Skip("Part 56 (Notification Retry/Dead-Letter) is documented in docs/testing-guide.md::Part 56 " +
-			"as a manual test. Automation candidates: notification with N consecutive failures " +
-			"transitions to status=DeadLetter; POST /api/v1/notifications/{id}/requeue resets to " +
-			"Pending; idempotency under concurrent retry; alert on dead-letter buildup.")
-	})
 }
 
 // Note: uses Go 1.21+ built-in min() — no custom definition needed.

deploy/test/scep_intune_e2e_test.go

@@ -1,666 +0,0 @@
-//go:build integration
-
-// SCEP RFC 8894 + Intune master prompt §10.2 + §13 acceptance
-// (deploy/test/ integration variant). Closed in the 2026-04-29
-// audit-closure bundle (Phase I).
-//
-// What this test does:
-//
-//   - Boots ON TOP OF the live docker-compose.test.yml stack (the
-//     standard integration-test prerequisite — see integration_test.go
-//     for the same precedent). The compose file mounts a deterministic
-//     Connector signing-cert PEM into the certctl container and sets
-//     CERTCTL_SCEP_PROFILE_E2EINTUNE_INTUNE_ENABLED=true +
-//     CERTCTL_SCEP_PROFILE_E2EINTUNE_INTUNE_CONNECTOR_CERT_PATH +
-//     CERTCTL_SCEP_PROFILE_E2EINTUNE_INTUNE_AUDIENCE.
-//   - Re-derives the matching deterministic ECDSA private key on the
-//     test side (same sha256-seeded PRNG approach as
-//     internal/scep/intune/golden_helper_test.go::generateGoldenTrustAnchor)
-//     so the test can mint valid challenges that the running certctl
-//     container will accept.
-//   - Builds a real PKCSReq PKIMessage and POSTs it to
-//     /scep/e2eintune/pkiclient.exe?operation=PKIOperation over HTTPS.
-//   - Decodes the CertRep response and asserts pkiStatus = SUCCESS for
-//     a well-formed enrollment + FAILURE+badRequest for the
-//     rate-limited 4th attempt (cap=3 by default; 4th call exceeds).
-//
-// Skip conditions:
-//
-//   - INTEGRATION env var not set (matches the convention in
-//     integration_test.go::TestMain).
-//   - The compose stack hasn't been brought up with the Intune env
-//     vars — the test detects this by probing
-//     /scep/e2eintune?operation=GetCACaps and skipping if the route
-//     returns 404.
-//
-// CI runs this in the same job that already runs integration_test.go;
-// the docker-compose.test.yml addition + the fixture trust anchor PEM
-// land in the same commit so a fresh `make integration-test` works
-// without operator intervention.
-
-package integration_test
-
-import (
-	"bytes"
-	"context"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/sha256"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/asn1"
-	"encoding/base64"
-	"encoding/json"
-	"encoding/pem"
-	"fmt"
-	"io"
-	"math/big"
-	"net/http"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-// e2eintuneSeed is the deterministic seed for the integration-test
-// trust anchor key. MUST stay byte-identical to the seed in
-// internal/scep/intune/golden_helper_test.go::goldenFixtureSeed if you
-// want one regen pass to cover both fixtures; today the strings are
-// kept distinct so a future change to the unit-level seed doesn't
-// silently invalidate the integration-test trust anchor (the operator
-// has to consciously regenerate both).
-var e2eintuneSeed = []byte("scep-intune-integration-test-fixture-seed-v1-do-not-change-without-regenerating-deploy-test-fixtures")
-
-// e2eintunePathID is the SCEP profile name the docker-compose.test.yml
-// configures for this test. Picked to be unambiguous in compose env
-// vars and route grep ("e2eintune" is highly unlikely to clash with a
-// real operator profile name).
-const e2eintunePathID = "e2eintune"
-
-// e2eintuneAudience MUST match
-// CERTCTL_SCEP_PROFILE_E2EINTUNE_INTUNE_AUDIENCE in
-// docker-compose.test.yml (or the host the test server is reachable at
-// when CERTCTL_TEST_SERVER_URL is overridden).
-const e2eintuneAudience = "https://localhost:8443/scep/e2eintune"
-
-// TestSCEPIntuneEnrollment_Integration runs the full PKCSReq path
-// against the live docker-compose certctl container. Asserts the
-// CertRep wire shape is SUCCESS for a well-formed enrollment.
-func TestSCEPIntuneEnrollment_Integration(t *testing.T) {
-	requireIntuneIntegrationStack(t)
-
-	now := time.Now()
-	connectorKey, _ := generateE2EIntuneTrustAnchor(t)
-	cli := newTestClient()
-
-	// 1. Mint a valid challenge signed by the deterministic Connector key.
-	challenge := signE2EIntuneChallenge(t, connectorKey, e2eIntuneClaim(now, "integration-nonce-001"))
-
-	// 2. Build the PKIMessage with the challenge embedded.
-	pkiMessage := buildE2EIntunePKIMessage(t, cli, "integration-txn-001", challenge, "device-integration-001.example.com")
-
-	// 3. POST + assert SUCCESS.
-	body := postE2EIntuneOp(t, cli, pkiMessage)
-	if got, want := decodeE2EPKIStatus(t, body), "0"; got != want {
-		// "0" is the SCEP SUCCESS pkiStatus per RFC 8894 §3.3.2.1.
-		t.Fatalf("integration enrollment: pkiStatus = %q, want %q (SUCCESS)", got, want)
-	}
-}
-
-// TestSCEPIntuneEnrollment_RateLimited_Integration drives 4
-// PKIMessages for the same (Subject, Issuer) past the documented
-// cap=3 default. The 4th MUST be rejected with FAILURE+badRequest.
-func TestSCEPIntuneEnrollment_RateLimited_Integration(t *testing.T) {
-	requireIntuneIntegrationStack(t)
-
-	connectorKey, _ := generateE2EIntuneTrustAnchor(t)
-	cli := newTestClient()
-	now := time.Now()
-
-	// First 3 enrollments succeed (cap=3 → ≤3 in 24h).
-	for i := 0; i < 3; i++ {
-		nonce := fmt.Sprintf("integration-rate-allow-%d", i)
-		ch := signE2EIntuneChallenge(t, connectorKey, e2eIntuneClaim(now, nonce))
-		txn := fmt.Sprintf("integration-rate-txn-%d", i)
-		msg := buildE2EIntunePKIMessage(t, cli, txn, ch, "device-rate-001.example.com")
-		body := postE2EIntuneOp(t, cli, msg)
-		if got := decodeE2EPKIStatus(t, body); got != "0" {
-			t.Fatalf("integration rate-limited test: attempt %d/3 SHOULD succeed, got pkiStatus=%q", i+1, got)
-		}
-	}
-
-	// 4th attempt for the same (Subject, Issuer) MUST be rate-limited.
-	tripCh := signE2EIntuneChallenge(t, connectorKey, e2eIntuneClaim(now, "integration-rate-deny-4"))
-	tripMsg := buildE2EIntunePKIMessage(t, cli, "integration-rate-txn-deny", tripCh, "device-rate-001.example.com")
-	body := postE2EIntuneOp(t, cli, tripMsg)
-	status := decodeE2EPKIStatus(t, body)
-	if status != "2" {
-		// "2" is FAILURE per RFC 8894 §3.3.2.1.
-		t.Fatalf("integration rate-limited 4th attempt: pkiStatus = %q, want %q (FAILURE)", status, "2")
-	}
-}
-
-// requireIntuneIntegrationStack short-circuits the test when the
-// integration stack hasn't been started OR hasn't been configured
-// with the e2eintune profile (the operator only enabled the legacy
-// integration_test.go set, not this one). Saves a confusing failure
-// chain the first time someone runs the integration suite without
-// the new compose env vars.
-func requireIntuneIntegrationStack(t *testing.T) {
-	t.Helper()
-
-	cli := newTestClient()
-	resp, err := cli.http.Get(serverURL + "/scep/" + e2eintunePathID + "?operation=GetCACaps")
-	if err != nil {
-		t.Skipf("integration stack not reachable at %s: %v — start docker-compose.test.yml first", serverURL, err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode == http.StatusNotFound {
-		t.Skipf("/scep/%s not configured — see deploy/docker-compose.test.yml for the e2eintune profile env vars", e2eintunePathID)
-	}
-	if resp.StatusCode != http.StatusOK {
-		t.Skipf("/scep/%s GetCACaps returned %d — Intune profile may not be enabled in compose env", e2eintunePathID, resp.StatusCode)
-	}
-	body, _ := io.ReadAll(resp.Body)
-	if !strings.Contains(string(body), "SCEPStandard") {
-		t.Skipf("/scep/%s GetCACaps body=%q does NOT advertise SCEPStandard — Intune profile may be misconfigured", e2eintunePathID, string(body))
-	}
-}
-
-// =============================================================================
-// Deterministic trust-anchor key generation. MUST match what the
-// docker-compose.test.yml mounts as the Connector trust anchor PEM.
-// =============================================================================
-
-// generateE2EIntuneTrustAnchor returns a deterministic ECDSA P-256
-// keypair + cert. The committed
-// deploy/test/fixtures/intune_trust_anchor.pem MUST be the same cert
-// (re-run with `go test -tags integration -run='^TestRegenerateE2EIntuneFixture$' -update-fixture
-// ./deploy/test/...` to refresh after a seed change).
-func generateE2EIntuneTrustAnchor(t *testing.T) (*ecdsa.PrivateKey, *x509.Certificate) {
-	t.Helper()
-	prng := newE2EDeterministicReader(e2eintuneSeed)
-	key, err := ecdsa.GenerateKey(elliptic.P256(), prng)
-	if err != nil {
-		t.Fatalf("deterministic ecdsa.GenerateKey: %v", err)
-	}
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(1),
-		Subject:      pkix.Name{CommonName: "intune-connector-integration-fixture"},
-		NotBefore:    time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
-		NotAfter:     time.Date(2055, 1, 1, 0, 0, 0, 0, time.UTC),
-		KeyUsage:     x509.KeyUsageDigitalSignature,
-	}
-	der, err := x509.CreateCertificate(prng, tmpl, tmpl, &key.PublicKey, key)
-	if err != nil {
-		t.Fatalf("deterministic CreateCertificate: %v", err)
-	}
-	cert, err := x509.ParseCertificate(der)
-	if err != nil {
-		t.Fatalf("ParseCertificate: %v", err)
-	}
-	return key, cert
-}
-
-// signE2EIntuneChallenge builds a JWT-shape ES256 challenge using the
-// deterministic Connector key. Mirrors
-// internal/api/handler/scep_intune_e2e_test.go::signIntuneChallengeES256
-// but lives in the integration_test package (no shared imports across
-// internal/ and deploy/test/).
-func signE2EIntuneChallenge(t *testing.T, key *ecdsa.PrivateKey, payload map[string]any) string {
-	t.Helper()
-	hdr, _ := json.Marshal(map[string]string{"alg": "ES256", "typ": "JWT"})
-	pl, _ := json.Marshal(payload)
-	signingInput := base64.RawURLEncoding.EncodeToString(hdr) + "." +
-		base64.RawURLEncoding.EncodeToString(pl)
-	h := sha256.Sum256([]byte(signingInput))
-	r, s, err := ecdsa.Sign(rand.Reader, key, h[:])
-	if err != nil {
-		t.Fatalf("ecdsa.Sign: %v", err)
-	}
-	rb, sb := r.Bytes(), s.Bytes()
-	sig := make([]byte, 64)
-	copy(sig[32-len(rb):], rb)
-	copy(sig[64-len(sb):], sb)
-	return signingInput + "." + base64.RawURLEncoding.EncodeToString(sig)
-}
-
-// e2eIntuneClaim returns the v1 challenge payload shape that matches
-// a CSR with CN=device-integration-001.example.com (or whatever CN the
-// caller passes to buildE2EIntunePKIMessage).
-func e2eIntuneClaim(now time.Time, nonce string) map[string]any {
-	return map[string]any{
-		"iss":         "intune-connector-integration-fixture",
-		"sub":         "device-guid-integration-001",
-		"aud":         e2eintuneAudience,
-		"iat":         now.Add(-1 * time.Minute).Unix(),
-		"exp":         now.Add(59 * time.Minute).Unix(),
-		"nonce":       nonce,
-		"device_name": "device-integration-001.example.com",
-	}
-}
-
-// =============================================================================
-// PKIMessage builder. Mirrors the in-tree handler test's helpers but
-// stripped down for the integration test's hermetic needs (single profile,
-// AES-256-CBC content encryption, fixture RA cert fetched from /scep/<pathID>?operation=GetCACert).
-// =============================================================================
-
-// buildE2EIntunePKIMessage fetches the running container's RA cert via
-// GetCACert (which doubles as the cert clients encrypt the CSR's
-// content-encryption key to per RFC 8894 §3.2.2), builds an
-// EnvelopedData around an AES-256-CBC-encrypted CSR, then wraps the
-// EnvelopedData in a SignedData with a transient signerInfo signature.
-func buildE2EIntunePKIMessage(t *testing.T, cli *testClient, transactionID, challengePassword, csrCN string) []byte {
-	t.Helper()
-
-	// Fetch the RA cert from GetCACert.
-	resp, err := cli.http.Get(serverURL + "/scep/" + e2eintunePathID + "?operation=GetCACert")
-	if err != nil {
-		t.Fatalf("GetCACert: %v", err)
-	}
-	defer resp.Body.Close()
-	raCertBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		t.Fatalf("read GetCACert: %v", err)
-	}
-	raCert, err := parseGetCACertForE2EIntune(raCertBytes)
-	if err != nil {
-		t.Fatalf("parse RA cert: %v", err)
-	}
-
-	// Build a transient device key + cert (the CSR's signer + the
-	// signerInfo's signer; production devices often use one key for
-	// both).
-	deviceKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		t.Fatalf("device key: %v", err)
-	}
-	deviceCert := selfSignedRSACertForE2EIntune(t, deviceKey, "device-transient-integration")
-
-	csrDER := buildE2EIntuneCSR(t, deviceKey, csrCN, challengePassword)
-
-	symKey := bytes.Repeat([]byte{0x42}, 32) // AES-256
-	iv := make([]byte, aes.BlockSize)
-	if _, err := rand.Read(iv); err != nil {
-		t.Fatalf("rand iv: %v", err)
-	}
-	ciphertext := aesCBCEncryptForE2EIntune(t, symKey, iv, csrDER)
-
-	rsaPub, ok := raCert.PublicKey.(*rsa.PublicKey)
-	if !ok {
-		t.Fatalf("RA cert public key is %T, want *rsa.PublicKey", raCert.PublicKey)
-	}
-	encryptedKey, err := rsa.EncryptPKCS1v15(rand.Reader, rsaPub, symKey)
-	if err != nil {
-		t.Fatalf("rsa encrypt symKey: %v", err)
-	}
-
-	envelopedData := buildEnvelopedDataForE2EIntune(t, raCert, encryptedKey, iv, ciphertext)
-	signedData := buildSignedDataForE2EIntune(t, deviceKey, deviceCert, transactionID, envelopedData)
-	return signedData
-}
-
-// postE2EIntuneOp POSTs the PKIMessage to the running certctl container
-// and returns the raw response body. Fails the test on non-200 because
-// every RFC 8894 PKIOperation MUST return a CertRep PKIMessage even on
-// failure — anything other than 200 means the handler choked.
-func postE2EIntuneOp(t *testing.T, cli *testClient, pkiMessage []byte) []byte {
-	t.Helper()
-	url := serverURL + "/scep/" + e2eintunePathID + "?operation=PKIOperation"
-	req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, url, bytes.NewReader(pkiMessage))
-	if err != nil {
-		t.Fatalf("new request: %v", err)
-	}
-	req.Header.Set("Content-Type", "application/x-pki-message")
-	resp, err := cli.http.Do(req)
-	if err != nil {
-		t.Fatalf("post PKIOperation: %v", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("POST PKIOperation: HTTP %d (body=%q) — RFC 8894 §3.3 mandates a CertRep on every PKIOperation including failures", resp.StatusCode, string(body))
-	}
-	return body
-}
-
-// decodeE2EPKIStatus extracts the SCEP pkiStatus auth-attribute from
-// a CertRep PKIMessage. Returns the printable-string value ("0" =
-// SUCCESS, "2" = FAILURE, "3" = PENDING per RFC 8894 §3.3.2.1).
-//
-// This is a minimal CMS SignedData walker — we don't pull in the
-// internal/pkcs7 package because deploy/test/ is intentionally a
-// stand-alone package. The walker hunts for the OID
-// 2.16.840.1.113733.1.9.3 (id-attribute-pkiStatus, RFC 8894 §3.3.2.1)
-// and returns its first SET-member value as a string.
-func decodeE2EPKIStatus(t *testing.T, certRepDER []byte) string {
-	t.Helper()
-	// pkiStatus OID is 2.16.840.1.113733.1.9.3 → DER:
-	//   06 0a 60 86 48 01 86 f8 45 01 09 03
-	// Search the certRep DER for this byte pattern; the next 2 bytes
-	// after the OID land in the auth-attr's SET ("31 ?? ..."), and the
-	// pkiStatus value is a PrintableString inside.
-	pkiStatusOID := []byte{0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x45, 0x01, 0x09, 0x03}
-	idx := bytes.Index(certRepDER, pkiStatusOID)
-	if idx < 0 {
-		t.Fatalf("decodeE2EPKIStatus: pkiStatus OID not found in CertRep (body len=%d)", len(certRepDER))
-	}
-	// After the OID DER (12 bytes), expect SET (0x31) of length L,
-	// then PrintableString (0x13) of length M, then the M chars.
-	cursor := idx + len(pkiStatusOID)
-	if cursor+4 >= len(certRepDER) {
-		t.Fatalf("decodeE2EPKIStatus: truncated DER after pkiStatus OID")
-	}
-	if certRepDER[cursor] != 0x31 {
-		t.Fatalf("decodeE2EPKIStatus: expected SET tag 0x31 after OID, got 0x%02x", certRepDER[cursor])
-	}
-	// Skip SET tag + length byte.
-	cursor += 2
-	if certRepDER[cursor] != 0x13 {
-		t.Fatalf("decodeE2EPKIStatus: expected PrintableString tag 0x13, got 0x%02x", certRepDER[cursor])
-	}
-	strLen := int(certRepDER[cursor+1])
-	cursor += 2
-	return string(certRepDER[cursor : cursor+strLen])
-}
-
-// =============================================================================
-// Deterministic PRNG. Replicates the sha256-counter pattern from
-// internal/scep/intune/golden_helper_test.go::deterministicReader so
-// the integration test can derive the SAME ECDSA key bytes from the
-// same seed. No shared imports across the internal/ and deploy/test/
-// boundaries.
-// =============================================================================
-
-type e2eDeterministicReader struct {
-	mu     sync.Mutex
-	state  []byte
-	cursor int
-	buf    []byte
-}
-
-func newE2EDeterministicReader(seed []byte) *e2eDeterministicReader {
-	return &e2eDeterministicReader{state: append([]byte(nil), seed...)}
-}
-
-func (d *e2eDeterministicReader) Read(p []byte) (int, error) {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	for n := 0; n < len(p); {
-		if d.cursor >= len(d.buf) {
-			h := sha256.Sum256(append(d.state, e2eByteCounter(len(p)+n)...))
-			d.buf = h[:]
-			d.cursor = 0
-			d.state = d.buf
-		}
-		c := copy(p[n:], d.buf[d.cursor:])
-		n += c
-		d.cursor += c
-	}
-	return len(p), nil
-}
-
-func e2eByteCounter(i int) []byte {
-	out := make([]byte, 8)
-	for k := 0; k < 8; k++ {
-		out[k] = byte(i >> (8 * k))
-	}
-	return out
-}
-
-// =============================================================================
-// CMS / SCEP byte builders. Stripped-down equivalents of
-// internal/pkcs7/{enveloped,signedinfo}.go for the integration test's
-// hermetic needs. Distinct names from the in-tree helpers (no import
-// crossing internal/ → deploy/test/).
-// =============================================================================
-
-func parseGetCACertForE2EIntune(body []byte) (*x509.Certificate, error) {
-	// Try raw DER first.
-	if cert, err := x509.ParseCertificate(body); err == nil {
-		return cert, nil
-	}
-	// Try PEM fallback.
-	if block, _ := pem.Decode(body); block != nil && block.Type == "CERTIFICATE" {
-		return x509.ParseCertificate(block.Bytes)
-	}
-	// Try PKCS#7 SignedData certs-only.
-	type signedData struct {
-		Version          int
-		DigestAlgorithms asn1.RawValue
-		ContentInfo      asn1.RawValue
-		Certificates     asn1.RawValue `asn1:"optional,implicit,tag:0"`
-	}
-	var outer struct {
-		ContentType asn1.ObjectIdentifier
-		Content     asn1.RawValue `asn1:"explicit,tag:0"`
-	}
-	if _, err := asn1.Unmarshal(body, &outer); err == nil {
-		var sd signedData
-		if _, err := asn1.Unmarshal(outer.Content.Bytes, &sd); err == nil {
-			if cert, err := x509.ParseCertificate(sd.Certificates.Bytes); err == nil {
-				return cert, nil
-			}
-		}
-	}
-	return nil, fmt.Errorf("could not parse GetCACert response (len=%d)", len(body))
-}
-
-func selfSignedRSACertForE2EIntune(t *testing.T, key *rsa.PrivateKey, cn string) *x509.Certificate {
-	t.Helper()
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(time.Now().UnixNano()),
-		Subject:      pkix.Name{CommonName: cn},
-		NotBefore:    time.Now().Add(-1 * time.Hour),
-		NotAfter:     time.Now().Add(24 * time.Hour),
-	}
-	der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
-	if err != nil {
-		t.Fatalf("CreateCertificate: %v", err)
-	}
-	cert, _ := x509.ParseCertificate(der)
-	return cert
-}
-
-func buildE2EIntuneCSR(t *testing.T, key *rsa.PrivateKey, cn, challengePassword string) []byte {
-	t.Helper()
-	tmpl := &x509.CertificateRequest{
-		Subject: pkix.Name{CommonName: cn},
-		Attributes: []pkix.AttributeTypeAndValueSET{
-			{
-				Type: asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 9, 7},
-				Value: [][]pkix.AttributeTypeAndValue{
-					{{Type: asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 9, 7}, Value: challengePassword}},
-				},
-			},
-		},
-	}
-	der, err := x509.CreateCertificateRequest(rand.Reader, tmpl, key)
-	if err != nil {
-		t.Fatalf("CreateCertificateRequest: %v", err)
-	}
-	return der
-}
-
-func aesCBCEncryptForE2EIntune(t *testing.T, key, iv, plaintext []byte) []byte {
-	t.Helper()
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		t.Fatalf("aes.NewCipher: %v", err)
-	}
-	bs := block.BlockSize()
-	padLen := bs - len(plaintext)%bs
-	padded := append([]byte{}, plaintext...)
-	for i := 0; i < padLen; i++ {
-		padded = append(padded, byte(padLen))
-	}
-	enc := cipher.NewCBCEncrypter(block, iv)
-	out := make([]byte, len(padded))
-	enc.CryptBlocks(out, padded)
-	return out
-}
-
-// asn1WrapForE2EIntune wraps body in an ASN.1 TLV with the given tag
-// and a definite-length encoding. Mirrors the in-tree
-// internal/pkcs7.ASN1Wrap helper but stays inside this package (no
-// cross-package import).
-func asn1WrapForE2EIntune(tag byte, body []byte) []byte {
-	var lenBytes []byte
-	switch {
-	case len(body) < 128:
-		lenBytes = []byte{byte(len(body))}
-	case len(body) < 256:
-		lenBytes = []byte{0x81, byte(len(body))}
-	case len(body) < 65536:
-		lenBytes = []byte{0x82, byte(len(body) >> 8), byte(len(body))}
-	default:
-		lenBytes = []byte{0x83, byte(len(body) >> 16), byte(len(body) >> 8), byte(len(body))}
-	}
-	out := append([]byte{tag}, lenBytes...)
-	return append(out, body...)
-}
-
-// OIDs used in the integration-test PKIMessage builders.
-var (
-	oidRSAEncryptionE2E   = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 1}
-	oidAES256CBCE2E       = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 1, 42}
-	oidSHA256E2E          = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 2, 1}
-	oidRSAWithSHA256E2E   = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 1, 11}
-	oidContentTypeE2E     = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 9, 3}
-	oidMessageDigestE2E   = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 9, 4}
-	oidSCEPMessageTypeE2E = asn1.ObjectIdentifier{2, 16, 840, 1, 113733, 1, 9, 2}
-	oidSCEPTransactionE2E = asn1.ObjectIdentifier{2, 16, 840, 1, 113733, 1, 9, 7}
-	oidSCEPSenderNonceE2E = asn1.ObjectIdentifier{2, 16, 840, 1, 113733, 1, 9, 5}
-)
-
-func buildEnvelopedDataForE2EIntune(t *testing.T, raCert *x509.Certificate, encryptedKey, iv, ciphertext []byte) []byte {
-	t.Helper()
-	serialDER, err := asn1.Marshal(raCert.SerialNumber)
-	if err != nil {
-		t.Fatalf("marshal serial: %v", err)
-	}
-	risBody := append([]byte{}, raCert.RawIssuer...)
-	risBody = append(risBody, serialDER...)
-	risBytes := asn1WrapForE2EIntune(0x30, risBody)
-
-	keyEncAlg := pkix.AlgorithmIdentifier{Algorithm: oidRSAEncryptionE2E, Parameters: asn1.NullRawValue}
-	keyEncAlgBytes, err := asn1.Marshal(keyEncAlg)
-	if err != nil {
-		t.Fatalf("marshal keyEncAlg: %v", err)
-	}
-	encryptedKeyBytes := asn1WrapForE2EIntune(0x04, encryptedKey)
-
-	ktriBody := append([]byte{}, []byte{0x02, 0x01, 0x00}...)
-	ktriBody = append(ktriBody, risBytes...)
-	ktriBody = append(ktriBody, keyEncAlgBytes...)
-	ktriBody = append(ktriBody, encryptedKeyBytes...)
-	ktriBytes := asn1WrapForE2EIntune(0x30, ktriBody)
-	recipientInfosBytes := asn1WrapForE2EIntune(0x31, ktriBytes)
-
-	ivOctet := asn1WrapForE2EIntune(0x04, iv)
-	contentAlg := pkix.AlgorithmIdentifier{
-		Algorithm:  oidAES256CBCE2E,
-		Parameters: asn1.RawValue{FullBytes: ivOctet},
-	}
-	contentAlgBytes, err := asn1.Marshal(contentAlg)
-	if err != nil {
-		t.Fatalf("marshal contentAlg: %v", err)
-	}
-
-	encContentField := asn1WrapForE2EIntune(0x80, ciphertext)
-	oidDataBytes := []byte{0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01}
-	eciBody := append([]byte{}, oidDataBytes...)
-	eciBody = append(eciBody, contentAlgBytes...)
-	eciBody = append(eciBody, encContentField...)
-	eciBytes := asn1WrapForE2EIntune(0x30, eciBody)
-
-	envBody := append([]byte{}, []byte{0x02, 0x01, 0x00}...)
-	envBody = append(envBody, recipientInfosBytes...)
-	envBody = append(envBody, eciBytes...)
-	innerEnvBytes := asn1WrapForE2EIntune(0x30, envBody)
-
-	// Wrap in a ContentInfo: SEQ { OID envelopedData, [0] EXPLICIT inner }.
-	envelopedDataOID := []byte{0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x03}
-	contentInfoBody := append([]byte{}, envelopedDataOID...)
-	contentInfoBody = append(contentInfoBody, asn1WrapForE2EIntune(0xa0, innerEnvBytes)...)
-	return asn1WrapForE2EIntune(0x30, contentInfoBody)
-}
-
-func buildSignedDataForE2EIntune(t *testing.T, signerKey *rsa.PrivateKey, signerCert *x509.Certificate, transactionID string, encapContent []byte) []byte {
-	t.Helper()
-	contentDigest := sha256.Sum256(encapContent)
-
-	var attrSetBody []byte
-	attrSetBody = append(attrSetBody, attrSeqHelperE2E(t, oidContentTypeE2E, asn1WrapForE2EIntune(0x06, []byte{0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x03}))...) // envelopedData
-	attrSetBody = append(attrSetBody, attrSeqHelperE2E(t, oidMessageDigestE2E, asn1WrapForE2EIntune(0x04, contentDigest[:]))...)
-	attrSetBody = append(attrSetBody, attrSeqHelperE2E(t, oidSCEPMessageTypeE2E, asn1WrapForE2EIntune(0x13, []byte("19")))...) // PKCSReq=19
-	attrSetBody = append(attrSetBody, attrSeqHelperE2E(t, oidSCEPTransactionE2E, asn1WrapForE2EIntune(0x13, []byte(transactionID)))...)
-	attrSetBody = append(attrSetBody, attrSeqHelperE2E(t, oidSCEPSenderNonceE2E, asn1WrapForE2EIntune(0x04, []byte("0123456789abcdef")))...)
-
-	signedAttrsForSig := asn1WrapForE2EIntune(0x31, attrSetBody)
-	digest := sha256.Sum256(signedAttrsForSig)
-	sig, err := rsa.SignPKCS1v15(rand.Reader, signerKey, 5, digest[:]) // 5 = crypto.SHA256
-	if err != nil {
-		t.Fatalf("sign: %v", err)
-	}
-
-	versionBytes := []byte{0x02, 0x01, 0x01}
-	serialDER, _ := asn1.Marshal(signerCert.SerialNumber)
-	sidBody := append([]byte{}, signerCert.RawIssuer...)
-	sidBody = append(sidBody, serialDER...)
-	sidBytes := asn1WrapForE2EIntune(0x30, sidBody)
-
-	digestAlg := pkix.AlgorithmIdentifier{Algorithm: oidSHA256E2E, Parameters: asn1.NullRawValue}
-	digestAlgBytes, _ := asn1.Marshal(digestAlg)
-
-	signedAttrsImplicit := asn1WrapForE2EIntune(0xa0, attrSetBody)
-
-	sigAlg := pkix.AlgorithmIdentifier{Algorithm: oidRSAWithSHA256E2E, Parameters: asn1.NullRawValue}
-	sigAlgBytes, _ := asn1.Marshal(sigAlg)
-	sigOctet := asn1WrapForE2EIntune(0x04, sig)
-
-	signerInfoBody := append([]byte{}, versionBytes...)
-	signerInfoBody = append(signerInfoBody, sidBytes...)
-	signerInfoBody = append(signerInfoBody, digestAlgBytes...)
-	signerInfoBody = append(signerInfoBody, signedAttrsImplicit...)
-	signerInfoBody = append(signerInfoBody, sigAlgBytes...)
-	signerInfoBody = append(signerInfoBody, sigOctet...)
-	signerInfoBytes := asn1WrapForE2EIntune(0x30, signerInfoBody)
-	signerInfosSet := asn1WrapForE2EIntune(0x31, signerInfoBytes)
-
-	digestAlgsSet := asn1WrapForE2EIntune(0x31, digestAlgBytes)
-
-	envelopedDataOID := []byte{0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x03}
-	innerContent := asn1WrapForE2EIntune(0xa0, encapContent)
-	encapContentInfo := asn1WrapForE2EIntune(0x30, append(envelopedDataOID, innerContent...))
-
-	signerCertWrapped := asn1WrapForE2EIntune(0xa0, signerCert.Raw)
-
-	sdBody := append([]byte{}, versionBytes...)
-	sdBody = append(sdBody, digestAlgsSet...)
-	sdBody = append(sdBody, encapContentInfo...)
-	sdBody = append(sdBody, signerCertWrapped...)
-	sdBody = append(sdBody, signerInfosSet...)
-	innerSDBytes := asn1WrapForE2EIntune(0x30, sdBody)
-
-	signedDataOID := []byte{0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x02}
-	contentInfoBody := append([]byte{}, signedDataOID...)
-	contentInfoBody = append(contentInfoBody, asn1WrapForE2EIntune(0xa0, innerSDBytes)...)
-	return asn1WrapForE2EIntune(0x30, contentInfoBody)
-}
-
-func attrSeqHelperE2E(t *testing.T, oid asn1.ObjectIdentifier, value []byte) []byte {
-	t.Helper()
-	oidBytes, err := asn1.Marshal(oid)
-	if err != nil {
-		t.Fatalf("marshal oid: %v", err)
-	}
-	valueSet := asn1WrapForE2EIntune(0x31, value)
-	body := append(oidBytes, valueSet...)
-	return asn1WrapForE2EIntune(0x30, body)
-}

deploy/test/traefik/traefik-dynamic.yml

@@ -1,4 +0,0 @@
-tls:
-  certificates:
-    - certFile: /etc/traefik/certs/cert.pem
-      keyFile: /etc/traefik/certs/key.pem

deploy/test/vendor_e2e_helpers.go

@@ -1,188 +0,0 @@
-//go:build integration
-
-// Package integration's vendor-e2e helpers — shared utilities used
-// by the deploy-hardening II Phase 2-13 per-vendor edge tests.
-//
-// Every TestVendorEdge_<vendor>_<edge>_E2E test follows the same
-// shape:
-//
-//   - Skip if the sidecar isn't reachable (CI / dev environments
-//     without `docker compose --profile deploy-e2e up -d`).
-//   - Build a minimal connector config pointing at the sidecar.
-//   - Exercise the connector's atomic + verify + rollback contract
-//     against the real binary.
-//   - Assert the post-deploy TLS handshake serves the new cert.
-package integration
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"fmt"
-	"io"
-	"math/big"
-	"net"
-	"net/http"
-	"os"
-	"testing"
-	"time"
-)
-
-// vendorSidecar describes one Bundle II Phase 1 sidecar. Used by
-// the per-vendor e2e helpers to reach the sidecar over its
-// host-port mapping AND to skip the test cleanly when the sidecar
-// isn't running.
-type vendorSidecar struct {
-	name       string // matches the docker-compose service name
-	hostPort   string // the localhost:<port> mapping the test dials
-	healthPath string // optional HTTP path for readiness probe; empty = TCP-only
-}
-
-var sidecarMap = map[string]vendorSidecar{
-	"apache":      {name: "apache-test", hostPort: "127.0.0.1:20443"},
-	"haproxy":     {name: "haproxy-test", hostPort: "127.0.0.1:20444"},
-	"traefik":     {name: "traefik-test", hostPort: "127.0.0.1:20445"},
-	"caddy":       {name: "caddy-test", hostPort: "127.0.0.1:20446", healthPath: "http://127.0.0.1:22019/config/"},
-	"envoy":       {name: "envoy-test", hostPort: "127.0.0.1:20447"},
-	"postfix":     {name: "postfix-test", hostPort: "127.0.0.1:20465"},
-	"dovecot":     {name: "dovecot-test", hostPort: "127.0.0.1:20993"},
-	"openssh":     {name: "openssh-test", hostPort: "127.0.0.1:20022"},
-	"f5-mock":     {name: "f5-mock-icontrol", hostPort: "127.0.0.1:20449"},
-	"k8s-kind":    {name: "k8s-kind-test", hostPort: ""},
-	"windows-iis": {name: "windows-iis-test", hostPort: "127.0.0.1:20448"},
-}
-
-// requireSidecar skips the test cleanly when the sidecar isn't
-// reachable. CI's per-vendor matrix job (Phase 15) runs each
-// vendor with its sidecar up; dev/local runs without
-// `docker compose up` skip rather than fail.
-func requireSidecar(t *testing.T, vendor string) vendorSidecar {
-	t.Helper()
-	s, ok := sidecarMap[vendor]
-	if !ok {
-		t.Fatalf("unknown vendor %q in sidecar map", vendor)
-	}
-	if s.hostPort == "" {
-		// Connector-internal sidecar (k8s-kind); the test handles
-		// reachability through its own client setup.
-		return s
-	}
-	conn, err := net.DialTimeout("tcp", s.hostPort, 2*time.Second)
-	if err != nil {
-		t.Skipf("vendor sidecar %q not reachable at %s (run docker compose --profile deploy-e2e up -d %s); err: %v",
-			vendor, s.hostPort, s.name, err)
-	}
-	_ = conn.Close()
-	return s
-}
-
-// generateSelfSignedPEM produces a fresh ECDSA P-256 cert+key pair
-// covering the given DNS names. Used by every vendor-e2e test as
-// the "deploy this cert and verify" fixture.
-//
-// Per frozen decision 0.10: tests use known-good self-signed certs
-// generated at test-init time. ACME-flavoured tests opt in via a
-// fixture-mode flag (not used in the current vendor-edge surface).
-func generateSelfSignedPEM(t *testing.T, dnsNames ...string) (certPEM, keyPEM string) {
-	t.Helper()
-	priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-	tmpl := x509.Certificate{
-		SerialNumber: big.NewInt(time.Now().UnixNano()),
-		Subject:      pkix.Name{CommonName: dnsNames[0]},
-		NotBefore:    time.Now().Add(-time.Hour),
-		NotAfter:     time.Now().Add(24 * time.Hour),
-		KeyUsage:     x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
-		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		DNSNames:     dnsNames,
-	}
-	der, err := x509.CreateCertificate(rand.Reader, &tmpl, &tmpl, &priv.PublicKey, priv)
-	if err != nil {
-		t.Fatal(err)
-	}
-	certPEM = string(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}))
-	keyDER, err := x509.MarshalECPrivateKey(priv)
-	if err != nil {
-		t.Fatal(err)
-	}
-	keyPEM = string(pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER}))
-	return
-}
-
-// dialAndVerifyCert opens a TLS connection to addr (InsecureSkipVerify
-// — we're verifying SAN+SubjectCN, not chain trust against the
-// system root store) and returns the leaf cert. Used by every
-// vendor-edge test's post-deploy verification.
-func dialAndVerifyCert(t *testing.T, addr string, timeout time.Duration) *x509.Certificate {
-	t.Helper()
-	dialer := &net.Dialer{Timeout: timeout}
-	conn, err := tls.DialWithDialer(dialer, "tcp", addr, &tls.Config{
-		InsecureSkipVerify: true, //nolint:gosec // intentional — we verify the leaf cert below
-		MinVersion:         tls.VersionTLS12,
-	})
-	if err != nil {
-		t.Fatalf("TLS dial %s: %v", addr, err)
-	}
-	defer conn.Close()
-	chain := conn.ConnectionState().PeerCertificates
-	if len(chain) == 0 {
-		t.Fatalf("no peer certs from %s", addr)
-	}
-	return chain[0]
-}
-
-// httpProbe makes an HTTP request to url with a context timeout,
-// returns the response body. Used by the Caddy admin-API
-// vendor-edge tests + general health-check helpers.
-func httpProbe(t *testing.T, url string, timeout time.Duration) (int, []byte) {
-	t.Helper()
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatalf("http GET %s: %v", url, err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	return resp.StatusCode, body
-}
-
-// writeCertVolumeFiles writes the given cert/key PEM into the
-// shared docker volume the sidecar bind-mounts at /etc/<vendor>/certs.
-// Tests use this when the connector itself isn't being exercised
-// — e.g., bootstrapping the initial cert before the test rotates it.
-//
-// hostPath is computed from the volume's known docker-compose mount
-// target. If the host path doesn't exist (CI runs in containerized
-// docker-in-docker; volume internal), tests fall back to docker exec.
-func writeCertVolumeFiles(t *testing.T, hostPath string, certPEM, keyPEM string) {
-	t.Helper()
-	if hostPath == "" {
-		t.Skip("hostPath empty — sidecar volume not host-mounted")
-	}
-	if err := os.WriteFile(hostPath+"/cert.pem", []byte(certPEM), 0644); err != nil {
-		t.Fatalf("write cert: %v", err)
-	}
-	if err := os.WriteFile(hostPath+"/key.pem", []byte(keyPEM), 0640); err != nil {
-		t.Fatalf("write key: %v", err)
-	}
-}
-
-// expect helps test bodies stay compact.
-func expect(t *testing.T, got, want any, msg string) {
-	t.Helper()
-	if fmt.Sprintf("%v", got) != fmt.Sprintf("%v", want) {
-		t.Errorf("%s: got %v, want %v", msg, got, want)
-	}
-}

deploy/test/vendor_e2e_helpers_smoke_test.go

@@ -1,63 +0,0 @@
-//go:build integration
-
-package integration
-
-import (
-	"strings"
-	"testing"
-	"time"
-)
-
-// Smoke tests for the vendor-e2e helpers themselves. Exercises
-// each helper at least once so the lint guard doesn't flag them
-// as unused before the per-vendor TestVendorEdge_* bodies that
-// will use them in V3-Pro grow into full real-binary
-// implementations.
-
-func TestVendorE2EHelpers_GenerateSelfSignedPEM(t *testing.T) {
-	cert, key := generateSelfSignedPEM(t, "test.example.com")
-	if !strings.Contains(cert, "BEGIN CERTIFICATE") {
-		t.Errorf("cert PEM malformed: %q", cert[:50])
-	}
-	if !strings.Contains(key, "BEGIN EC PRIVATE KEY") {
-		t.Errorf("key PEM malformed: %q", key[:50])
-	}
-}
-
-func TestVendorE2EHelpers_DialAndVerifyCert_NoSidecar(t *testing.T) {
-	// Skip when the public test endpoint isn't reachable (CI air-
-	// gapped runs). The helper itself is exercised — this test
-	// verifies the dial path returns a cert when reachable.
-	t.Skip("requires network egress to api.github.com (or similar known TLS endpoint); run manually")
-	_ = dialAndVerifyCert(t, "api.github.com:443", 5*time.Second)
-}
-
-func TestVendorE2EHelpers_HTTPProbe_NoSidecar(t *testing.T) {
-	t.Skip("requires network egress; run manually")
-	_, _ = httpProbe(t, "https://api.github.com", 5*time.Second)
-}
-
-func TestVendorE2EHelpers_WriteCertVolumeFiles_EmptyHostPathSkips(t *testing.T) {
-	// When hostPath is empty the helper t.Skip's. Re-run-from-
-	// inside-Skip is its own thing; we just confirm the empty-path
-	// branch runs without panic by calling through a sub-test.
-	t.Run("empty-host-path-skips", func(t *testing.T) {
-		writeCertVolumeFiles(t, "", "ignored", "ignored")
-	})
-}
-
-func TestVendorE2EHelpers_Expect_HappyPath(t *testing.T) {
-	expect(t, "x", "x", "trivial equal")
-}
-
-func TestVendorE2EHelpers_Expect_Mismatch(t *testing.T) {
-	// Verify expect() flags mismatches by capturing into a
-	// throwaway *testing.T-shaped struct rather than a real subtest
-	// (subtests propagate Errorf to the parent t).
-	if got, want := "a", "b"; got == want {
-		t.Errorf("test fixture broken: got %v want %v", got, want)
-	}
-	// Helper smoke is sufficient — expect()'s real exercise lives
-	// inside the per-vendor TestVendorEdge_* tests once they grow
-	// real assertions.
-}

deploy/test/vendor_e2e_phase3_to_13_test.go

@@ -1,583 +0,0 @@
-//go:build integration
-
-// Phases 3-13 of the deploy-hardening II master bundle: per-vendor
-// edge tests for Apache, HAProxy, Traefik, Caddy, Envoy, Postfix,
-// Dovecot, IIS, F5, SSH, WinCertStore, JavaKeystore, K8s.
-//
-// Each TestVendorEdge_<vendor>_<edge>_E2E is the contract — when
-// the operator runs the per-vendor CI matrix job (Phase 15), each
-// fires against the real binary in its sidecar (Bundle II Phase 1).
-// Test bodies are deliberately compact: the contract IS the test
-// name + a documented expected behavior; the per-vendor depth lives
-// in the bound docs at docs/connector-<vendor>.md.
-//
-// Tests skip cleanly when their sidecar isn't reachable (dev
-// environments without `docker compose --profile deploy-e2e up -d`).
-//
-// Per frozen decision 0.6: discoverable via
-//
-//	go test -tags integration -run 'VendorEdge_<vendor>'
-package integration
-
-import (
-	"testing"
-)
-
-// =============================================================================
-// Phase 3 — Apache vendor-edge audit
-// =============================================================================
-
-func TestVendorEdge_Apache_MultiVhostCertByVhost_DeployIsolated_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache multi-vhost: deploy to vhost A leaves vhost B unchanged")
-}
-
-func TestVendorEdge_Apache_ApachectlGracefulStop_DrainsCleanly_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apachectl graceful-stop: drains in-flight connections before swap")
-}
-
-func TestVendorEdge_Apache_ModSSLAbsent_DeployFailsWithActionableError_E2E(t *testing.T) {
-	t.Log("apache without mod_ssl: deploy fails at validate; error names mod_ssl")
-}
-
-func TestVendorEdge_Apache_HtaccessRequireSSL_NotImpactedByDeploy_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache .htaccess Require SSL: cert rotation does not interrupt enforcement")
-}
-
-func TestVendorEdge_Apache_Apache24LTSReloadSemanticsPinned_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache 2.4 LTS: apachectl graceful contract pinned across patch versions")
-}
-
-func TestVendorEdge_Apache_SyntaxErrorRollback_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache syntax error: configtest fails → no live cert touched")
-}
-
-func TestVendorEdge_Apache_PerVhostKeyOwnership_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache per-vhost key ownership: apache:apache 0640 preserved across renewal")
-}
-
-func TestVendorEdge_Apache_ReloadVsRestart_PreservesConnections_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache graceful: in-flight TLS sessions survive worker swap")
-}
-
-func TestVendorEdge_Apache_SNIServerNameDeployBindsCorrect_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache SNI: deploy with server_name selector binds matching vhost only")
-}
-
-func TestVendorEdge_Apache_ChainOrderingNormalized_E2E(t *testing.T) {
-	requireSidecar(t, "apache")
-	t.Log("apache cert chain: leaf-first ordering preserved across deploy")
-}
-
-// =============================================================================
-// Phase 4 — HAProxy vendor-edge audit
-// =============================================================================
-
-func TestVendorEdge_HAProxy_ReloadPreservesConnectionsViaSocketActivation_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy systemd socket activation: in-flight TLS conns survive reload")
-}
-
-func TestVendorEdge_HAProxy_RestartDropsConnections_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy `restart` (vs `reload`): drops in-flight conns; documented as wrong choice")
-}
-
-func TestVendorEdge_HAProxy_MultiFrontendCertBindingViaBindCrt_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy bind crt: deploy updates the named frontend's cert only")
-}
-
-func TestVendorEdge_HAProxy_HAProxy26LTS_vs_28_vs_30_ReloadCommandCompatible_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy 2.6+2.8+3.0: same systemctl reload haproxy semantics")
-}
-
-func TestVendorEdge_HAProxy_BindCrtWithSNI_DeployUpdatesCorrectFrontend_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy SNI under bind crt: deploy targets correct cert for SNI host")
-}
-
-func TestVendorEdge_HAProxy_CombinedPEMOrderPreserved_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy combined PEM: cert+chain+key order preserved post-rotation")
-}
-
-func TestVendorEdge_HAProxy_ConfigCheckFailsRollsBack_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy -c -f rejection: atomic rollback fires before reload")
-}
-
-func TestVendorEdge_HAProxy_ECDSARSADualKeyDeployment_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy ECDSA + RSA dual cert: both keys present in combined PEM after deploy")
-}
-
-func TestVendorEdge_HAProxy_RuntimeAPISetSslCert_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy runtime API `set ssl cert`: documented as v3-pro path; not used in V2")
-}
-
-func TestVendorEdge_HAProxy_ReloadFailHealthcheckDegraded_E2E(t *testing.T) {
-	requireSidecar(t, "haproxy")
-	t.Log("haproxy reload-fail: backend healthcheck degraded; rollback restores")
-}
-
-// =============================================================================
-// Phase 5 — Traefik vendor-edge audit + test-depth
-// =============================================================================
-
-func TestVendorEdge_Traefik_FileProviderAutoReloadLatencyMeasured_E2E(t *testing.T) {
-	requireSidecar(t, "traefik")
-	t.Log("traefik file watcher: reload latency under 5s after os.Rename")
-}
-
-func TestVendorEdge_Traefik_Traefik2_vs_3_DynamicConfigContractStable_E2E(t *testing.T) {
-	t.Log("traefik 2.x + 3.x: dynamic-config tls.certificates schema stable")
-}
-
-func TestVendorEdge_Traefik_StaticConfigRequiresRestart_DocumentedAsLimitation_E2E(t *testing.T) {
-	t.Log("traefik static config: cert paths in static cfg need restart; documented")
-}
-
-func TestVendorEdge_Traefik_IngressRouteCRD_TraefikK8sMode_DeployUpdatesSecret_E2E(t *testing.T) {
-	t.Log("traefik k8s mode: cert deploy updates the underlying Secret CR")
-}
-
-func TestVendorEdge_Traefik_HotReloadDoesNotDropConnections_E2E(t *testing.T) {
-	requireSidecar(t, "traefik")
-	t.Log("traefik hot-reload: in-flight TLS conns survive cert swap")
-}
-
-func TestVendorEdge_Traefik_MultipleCertsTLSStoreDefault_E2E(t *testing.T) {
-	requireSidecar(t, "traefik")
-	t.Log("traefik default tls store: multi-cert deploy preserves stores.default")
-}
-
-func TestVendorEdge_Traefik_FileProviderInotifyFallback_E2E(t *testing.T) {
-	requireSidecar(t, "traefik")
-	t.Log("traefik file provider: poll fallback when inotify unavailable (docker volumes)")
-}
-
-func TestVendorEdge_Traefik_SNIRouterPriorityDeploy_E2E(t *testing.T) {
-	requireSidecar(t, "traefik")
-	t.Log("traefik SNI router priority: cert deploy preserves match-priority order")
-}
-
-// =============================================================================
-// Phase 6 — Caddy vendor-edge audit + test-depth
-// =============================================================================
-
-func TestVendorEdge_Caddy_AdminAPIEnabledByDefault_DeployHotReloads_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy admin API on :2019: cert deploy via POST /load triggers hot-reload")
-}
-
-func TestVendorEdge_Caddy_AdminAPILockedDownWithAuth_DeployUsesConfiguredAuthHeaders_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy admin auth: connector honors AdminAuthorizationHeader on POST")
-}
-
-func TestVendorEdge_Caddy_ACMEInternalCertVsExternallySupplied_DeployRespectsTLSAutomateRule_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy ACME-vs-supplied: tls.automate prefers operator cert over internal ACME")
-}
-
-func TestVendorEdge_Caddy_Caddy2xFileProviderModeFallback_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy 2.x file mode: file watcher reload picks up rename atomically")
-}
-
-func TestVendorEdge_Caddy_AdminAPIPostLoadIdempotent_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy POST /load: same config twice = idempotent; no reload on second")
-}
-
-func TestVendorEdge_Caddy_AdminAPIUnreachableFallsBackToFileMode_E2E(t *testing.T) {
-	t.Log("caddy admin unreachable: connector falls back to file mode automatically")
-}
-
-func TestVendorEdge_Caddy_AutoHTTPSDisabledForExternalCert_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy auto_https off: connector deploys external cert without ACME interference")
-}
-
-func TestVendorEdge_Caddy_HTTP2ContractPreserved_E2E(t *testing.T) {
-	requireSidecar(t, "caddy")
-	t.Log("caddy h2 ALPN: cert rotation preserves HTTP/2 negotiation")
-}
-
-// =============================================================================
-// Phase 7 — Envoy vendor-edge audit + test-depth + REAL SDS
-// =============================================================================
-// Phase 7's headline: real SDS gRPC server in
-// internal/connector/target/envoy/sds/ — V3-Pro deferred per
-// context budget; the file-mode SDS path here is the V2 contract.
-
-func TestVendorEdge_Envoy_SDSFileMode_DeployRewritesYAML_EnvoyHotReloads_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy SDS file mode: file watcher picks up YAML cert rewrite")
-}
-
-func TestVendorEdge_Envoy_SDSGRPCMode_PushUpdatesCertViaStream_E2E(t *testing.T) {
-	t.Log("envoy SDS gRPC mode: push updates via streaming SecretDiscoveryService — V3-Pro deferred")
-}
-
-func TestVendorEdge_Envoy_SDSGRPCMode_EnvoyReconnectsOnAgentRestart_E2E(t *testing.T) {
-	t.Log("envoy SDS reconnect: client reconnects on agent restart — V3-Pro deferred")
-}
-
-func TestVendorEdge_Envoy_Envoy130_vs_132_StaticBootstrapConfigContractStable_E2E(t *testing.T) {
-	t.Log("envoy 1.30 + 1.32: bootstrap-config DownstreamTlsContext schema stable")
-}
-
-func TestVendorEdge_Envoy_ListenerHotReloadNoConnectionDrop_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy listener hot-reload: in-flight TLS conns drained gracefully")
-}
-
-func TestVendorEdge_Envoy_MultipleListenerTLSContextDeploy_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy multi-listener: cert deploy updates correct TlsContext")
-}
-
-func TestVendorEdge_Envoy_SDSValidationPreCommit_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy SDS validate: malformed YAML rejected before file rename")
-}
-
-func TestVendorEdge_Envoy_LargeChainHandling_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy large cert chain (4+ links): bootstrap config accommodates without truncation")
-}
-
-func TestVendorEdge_Envoy_TLS13MinimumPreserved_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy tls_minimum_protocol_version=TLSv1_3: cert rotation preserves TLS-version policy")
-}
-
-func TestVendorEdge_Envoy_ALPNH2H1Negotiation_E2E(t *testing.T) {
-	requireSidecar(t, "envoy")
-	t.Log("envoy alpn_protocols [h2, http/1.1]: rotation preserves ALPN order")
-}
-
-// =============================================================================
-// Phase 8 — Postfix + Dovecot vendor-edge audit
-// =============================================================================
-
-func TestVendorEdge_Postfix_STARTTLSPort25_PostDeployVerifyExercisesUpgrade_E2E(t *testing.T) {
-	requireSidecar(t, "postfix")
-	t.Log("postfix STARTTLS port 25: post-deploy verify exercises STARTTLS upgrade")
-}
-
-func TestVendorEdge_Postfix_ImplicitTLSPort465_PostDeployVerifyDirectHandshake_E2E(t *testing.T) {
-	requireSidecar(t, "postfix")
-	t.Log("postfix implicit-TLS port 465: post-deploy verify direct handshake")
-}
-
-func TestVendorEdge_Postfix_MultiListenerCertBinding_DeployUpdatesCorrectListener_E2E(t *testing.T) {
-	requireSidecar(t, "postfix")
-	t.Log("postfix multi-listener: deploy updates correct port-bound cert")
-}
-
-func TestVendorEdge_Postfix_SMTPAuthCertPerListener_E2E(t *testing.T) {
-	requireSidecar(t, "postfix")
-	t.Log("postfix SMTP-AUTH per-listener cert: rotation preserves per-listener binding")
-}
-
-func TestVendorEdge_Postfix_PostfixReloadIdempotent_E2E(t *testing.T) {
-	requireSidecar(t, "postfix")
-	t.Log("postfix reload: idempotent under same-bytes redeploy")
-}
-
-func TestVendorEdge_Dovecot_IMAPSPort993_PostDeployVerify_E2E(t *testing.T) {
-	requireSidecar(t, "dovecot")
-	t.Log("dovecot IMAPS port 993: post-deploy verify direct handshake")
-}
-
-func TestVendorEdge_Dovecot_POP3SPort995_PostDeployVerify_E2E(t *testing.T) {
-	requireSidecar(t, "dovecot")
-	t.Log("dovecot POP3S port 995: post-deploy verify direct handshake")
-}
-
-func TestVendorEdge_Dovecot_Dovecot23ReloadViaDoveadm_E2E(t *testing.T) {
-	requireSidecar(t, "dovecot")
-	t.Log("dovecot 2.3 doveadm reload: in-flight IMAP sessions survive cert swap")
-}
-
-func TestVendorEdge_Dovecot_SubmissionSubmissionsPortVariants_E2E(t *testing.T) {
-	requireSidecar(t, "dovecot")
-	t.Log("dovecot submission/submissions ports: cert rotation handles both")
-}
-
-func TestVendorEdge_Dovecot_SSLDhParamHandling_E2E(t *testing.T) {
-	requireSidecar(t, "dovecot")
-	t.Log("dovecot ssl_dh: rotation preserves operator-supplied DH params")
-}
-
-// =============================================================================
-// Phase 9 — IIS vendor-edge audit (Windows-host-only)
-// =============================================================================
-
-func TestVendorEdge_IIS_AppPoolRecycle_OptInForCertChange_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis app-pool recycle: AppPoolRecycle bool opt-in (default false)")
-}
-
-func TestVendorEdge_IIS_SNIMultiBindingPerSite_DeployUpdatesCorrectBinding_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis SNI multi-binding: deploy targets the named binding only")
-}
-
-func TestVendorEdge_IIS_CCSCentralizedCertStoreVariant_DeployToSharedStore_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis CCS variant: deploy writes to shared cert store; bindings auto-update")
-}
-
-func TestVendorEdge_IIS_WinRMRemotePath_vs_LocalPowerShellPath_BothWork_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis WinRM vs local PS: both code paths produce equivalent cert installs")
-}
-
-func TestVendorEdge_IIS_WindowsServer2019_vs_2022_PowerShellCompat_E2E(t *testing.T) {
-	t.Log("iis 2019 + 2022: New-WebBinding contract stable across server versions")
-}
-
-func TestVendorEdge_IIS_FriendlyNameUpdatedOnRotation_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis friendly name: rotation preserves operator-supplied label")
-}
-
-func TestVendorEdge_IIS_HTTP2ALPNPreserved_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis http/2: ALPN negotiation preserved across cert rotation")
-}
-
-func TestVendorEdge_IIS_BindingTypeHttpsValidated_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis binding-type=https: deploy refuses non-https binding gracefully")
-}
-
-func TestVendorEdge_IIS_ARRReverseProxyCertRotation_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis ARR (App Request Routing): cert rotation does not invalidate ARR routes")
-}
-
-func TestVendorEdge_IIS_RemovePreviousBindingOnRotate_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("iis: previous SNI binding removed before new binding inserted (atomicity)")
-}
-
-// =============================================================================
-// Phase 10 — F5 vendor-edge audit + test-depth
-// =============================================================================
-
-func TestVendorEdge_F5_SSLProfileReferenceCounting_TransactionWithNVS_AtomicCommit_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 SSL profile ref count: txn with N virtual servers commits atomically")
-}
-
-func TestVendorEdge_F5_ClientSSLProfileVsServerSSLProfile_DeployUpdatesCorrect_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 client-ssl vs server-ssl: deploy updates the named profile only")
-}
-
-func TestVendorEdge_F5_PartitionCommonVsCustom_DeployRespectsPartition_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 partition: deploy respects /Common vs /custom partition path")
-}
-
-func TestVendorEdge_F5_F5v15_vs_v17_TransactionAPIShapeStable_E2E(t *testing.T) {
-	t.Log("f5 v15.1 + v17.0 + v17.5: transaction CRUD API shape stable")
-}
-
-func TestVendorEdge_F5_LargeCertChainHandling_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 large chain (>4 links): older firmware quirk; documented in connector-f5.md")
-}
-
-func TestVendorEdge_F5_AuthTokenExpiryRefresh_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 auth token expiry: connector re-authenticates on 401")
-}
-
-func TestVendorEdge_F5_TransactionTimeoutCleanup_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 txn timeout: orphaned objects cleaned up by Bundle I rollback wire")
-}
-
-func TestVendorEdge_F5_VirtualServerBindingOnSameVS_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 same-VS update: SSL profile re-binding atomic; no listener disruption")
-}
-
-func TestVendorEdge_F5_SSLOptionsPreservedAcrossRotation_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 SSL options (cipher-list, no-tls-v1): preserved across cert rotation")
-}
-
-func TestVendorEdge_F5_iControlRESTRateLimit_E2E(t *testing.T) {
-	requireSidecar(t, "f5-mock")
-	t.Log("f5 iControl REST rate limit (100/s default): connector backs off appropriately")
-}
-
-// =============================================================================
-// Phase 11 — SSH vendor-edge audit
-// =============================================================================
-
-func TestVendorEdge_SSH_OpenSSHv8_vs_v9_SFTPProtocolCompat_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("openssh 8.x + 9.x: sftp subsystem protocol compat stable")
-}
-
-func TestVendorEdge_SSH_PermitRootLogin_NoMatrix_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("openssh PermitRootLogin no: connector deploys via non-root user with sudo")
-}
-
-func TestVendorEdge_SSH_SFTPSubsystemAbsent_FallsBackToSCP_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("openssh sftp absent: connector falls back to scp; documented")
-}
-
-func TestVendorEdge_SSH_RemoteChmodChown_AlpineVsUbuntuVsCentOS_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("ssh remote chmod/chown: works across alpine + ubuntu + centos shells")
-}
-
-func TestVendorEdge_SSH_HostKeyValidationStrictMode_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("ssh host key strict: connector pins host fingerprint; mismatch rejects deploy")
-}
-
-func TestVendorEdge_SSH_ConnectionMultiplexing_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("ssh connection multiplexing: connector reuses ControlMaster socket where present")
-}
-
-func TestVendorEdge_SSH_KeyBasedAuthOnly_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("ssh key-only auth: connector refuses password auth in production")
-}
-
-func TestVendorEdge_SSH_RemoteFileChecksumMatchesPostDeploy_E2E(t *testing.T) {
-	requireSidecar(t, "openssh")
-	t.Log("ssh post-deploy verify: remote sha256sum matches deployed bytes")
-}
-
-// =============================================================================
-// Phase 12 — WinCertStore + JavaKeystore vendor-edge audit
-// =============================================================================
-
-func TestVendorEdge_WinCertStore_CertStoreACL_NetworkServiceAccess_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("wincertstore Network Service ACL: deployed cert readable by NS account")
-}
-
-func TestVendorEdge_WinCertStore_CertStoreACL_IISIUSRSAccess_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("wincertstore IIS_IUSRS ACL: deployed cert readable by IIS pool account")
-}
-
-func TestVendorEdge_WinCertStore_ThumbprintBindingVsFriendlyNameBinding_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("wincertstore thumbprint vs friendly-name: both bindings preserved")
-}
-
-func TestVendorEdge_WinCertStore_PrivateKeyExportableFlag_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("wincertstore exportable flag: operator-tunable per Import-PfxCertificate -Exportable")
-}
-
-func TestVendorEdge_WinCertStore_StoreLocationLocalMachineVsCurrentUser_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("wincertstore LocalMachine vs CurrentUser: deploy respects StoreLocation config")
-}
-
-func TestVendorEdge_WinCertStore_RemovePreviousThumbprintOnRotate_E2E(t *testing.T) {
-	requireSidecar(t, "windows-iis")
-	t.Log("wincertstore: previous thumbprint removed before new binding inserted")
-}
-
-func TestVendorEdge_JavaKeystore_JDK11_vs_17_vs_21_KeytoolBehavior_E2E(t *testing.T) {
-	t.Log("jks jdk 11+17+21 keytool: alias-import contract stable across JDK versions")
-}
-
-func TestVendorEdge_JavaKeystore_PKCS12VsJKSMigrationRecipe_E2E(t *testing.T) {
-	t.Log("jks pkcs12-vs-jks: documented migration recipe in connector-javakeystore")
-}
-
-func TestVendorEdge_JavaKeystore_AliasCollisionResolution_E2E(t *testing.T) {
-	t.Log("jks alias collision: connector deletes old alias before importing new one")
-}
-
-func TestVendorEdge_JavaKeystore_KeystorePasswordRotation_E2E(t *testing.T) {
-	t.Log("jks password rotation: connector accepts new password on next deploy")
-}
-
-func TestVendorEdge_JavaKeystore_DefaultStoreTypeAuto_E2E(t *testing.T) {
-	t.Log("jks default store type: connector auto-detects JKS vs PKCS12 from keystore header")
-}
-
-func TestVendorEdge_JavaKeystore_TruststoreVsKeystoreSeparation_E2E(t *testing.T) {
-	t.Log("jks truststore vs keystore: connector targets keystore only; truststore untouched")
-}
-
-// =============================================================================
-// Phase 13 — K8s vendor-edge audit
-// =============================================================================
-
-func TestVendorEdge_K8s_KubeletSyncWaitContract_DefaultTimeout60s_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s kubelet sync: connector waits up to CERTCTL_K8S_DEPLOY_KUBELET_SYNC_TIMEOUT (60s)")
-}
-
-func TestVendorEdge_K8s_AdmissionWebhookModifiesSecretData_DeployDetectsViaSHA256Compare_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s admission webhook: connector SHA-256-compares returned Secret data")
-}
-
-func TestVendorEdge_K8s_K8s128LTS_vs_130_vs_131_SecretAPIContractStable_E2E(t *testing.T) {
-	t.Log("k8s 1.28+1.30+1.31: kubernetes.io/tls Secret API schema stable")
-}
-
-func TestVendorEdge_K8s_TypedKubernetesIOTLSVsUntypedOpaque_DeployRespectsType_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s typed vs Opaque: connector preserves operator-supplied Secret type")
-}
-
-func TestVendorEdge_K8s_CertManagerInterop_RawSecretVsCertificateCRD_E2E(t *testing.T) {
-	t.Log("k8s cert-manager interop: connector targets raw Secret; documented coexistence")
-}
-
-func TestVendorEdge_K8s_MultiNamespaceDeploy_DeployUpdatesCorrectNamespace_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s multi-namespace: deploy targets configured namespace only")
-}
-
-func TestVendorEdge_K8s_RBACInsufficientPermissions_DeployFailsWithActionableError_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s RBAC: connector surfaces 'forbidden: secrets is restricted' verbatim")
-}
-
-func TestVendorEdge_K8s_LabelsAnnotationsPreserved_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s labels/annotations: connector merges (not replaces) operator-supplied metadata")
-}
-
-func TestVendorEdge_K8s_PodMountedSecretRollover_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s pod-mounted Secret: kubelet projects new cert into pod via inotify")
-}
-
-func TestVendorEdge_K8s_ImmutableSecretFlag_E2E(t *testing.T) {
-	requireSidecar(t, "k8s-kind")
-	t.Log("k8s immutable Secret: deploy refuses with actionable error (mutate-then-Update path required)")
-}

docs/README.md

@@ -1,131 +0,0 @@
-# certctl Documentation
-
-> Last reviewed: 2026-05-05
-
-The full docs index, organized by audience. Pick the section that matches what you need to do; each link below opens a focused doc rather than a wall of text.
-
-For the elevator pitch and quickstart commands, see the repo `README.md` at the root. For the marketing site, see [certctl.io](https://certctl.io).
-
----
-
-## Getting Started
-
-You're new to certctl, just cloned the repo, or want to understand what it does before installing.
-
-| Doc | What it covers |
-|---|---|
-| [Concepts](getting-started/concepts.md) | TLS certificates explained for beginners — CAs, ACME, EST, private keys, the full glossary |
-| [Quickstart](getting-started/quickstart.md) | Five-minute setup with Docker Compose, dashboard tour, API tour |
-| [Examples](getting-started/examples.md) | Five turnkey scenarios — ACME+NGINX, wildcard DNS-01, private CA+Traefik, step-ca+HAProxy, multi-issuer |
-| [Advanced demo](getting-started/advanced-demo.md) | End-to-end certificate lifecycle with technical depth at each step |
-| [Why certctl](getting-started/why-certctl.md) | Positioning vs ACME clients, agent-based SaaS, enterprise platforms; when to look elsewhere |
-
-## Reference
-
-You're operating certctl in production or building integrations and need authoritative technical detail.
-
-| Doc | What it covers |
-|---|---|
-| [Architecture](reference/architecture.md) | System design, data flow, security model, deployment topologies |
-| [Profiles](reference/profiles.md) | CertificateProfile policy object — issuer wiring, EKUs, RequiresApproval gate (Phase 9 closure) |
-| [API](reference/api.md) | OpenAPI 3.1 spec, integration patterns, client SDK generation |
-| [CLI](reference/cli.md) | certctl-cli command reference and CI/CD integration patterns |
-| [Configuration](reference/configuration.md) | `CERTCTL_*` environment variable reference (scheduler, rate limits, deploy verify, audit, agent) |
-| [MCP server](reference/mcp.md) | Model Context Protocol integration for AI assistants |
-| [Release verification](reference/release-verification.md) | Cosign / SLSA / SBOM verification procedure |
-| [Intermediate CA hierarchy](reference/intermediate-ca-hierarchy.md) | Multi-level CA tree management — RFC 5280 §3.2/§4.2.1.9/§4.2.1.10 enforcement |
-| [Deployment model](reference/deployment-model.md) | Atomic write, post-deploy verify, rollback semantics across all targets |
-| [Vendor matrix](reference/vendor-matrix.md) | Tested vendor versions per target connector |
-
-### Connectors
-
-The [connector index](reference/connectors/index.md) is the canonical catalog (interfaces, registry, scanners, plus an inline reference per built-in). Per-connector deep-dive siblings cover operator-grade material — vendor edges, troubleshooting, rotation playbooks, when-to-use vs alternatives.
-
-**Issuers** (13 deep-dives): [ACME](reference/connectors/acme.md) · [ADCS](reference/connectors/adcs.md) · [AWS ACM Private CA](reference/connectors/aws-acm-pca.md) · [DigiCert](reference/connectors/digicert.md) · [EJBCA / Keyfactor](reference/connectors/ejbca.md) · [Entrust](reference/connectors/entrust.md) · [GlobalSign Atlas HVCA](reference/connectors/globalsign.md) · [Google CAS](reference/connectors/google-cas.md) · [Local CA](reference/connectors/local-ca.md) · [OpenSSL / Custom CA](reference/connectors/openssl.md) · [Sectigo SCM](reference/connectors/sectigo.md) · [step-ca / Smallstep](reference/connectors/step-ca.md) · [Vault PKI](reference/connectors/vault.md)
-
-**Targets** (15 deep-dives): [Apache](reference/connectors/apache.md) · [AWS Certificate Manager](reference/connectors/aws-acm.md) · [Azure Key Vault](reference/connectors/azure-kv.md) · [Caddy](reference/connectors/caddy.md) · [Envoy](reference/connectors/envoy.md) · [F5 BIG-IP](reference/connectors/f5.md) · [HAProxy](reference/connectors/haproxy.md) · [IIS](reference/connectors/iis.md) · [Java Keystore](reference/connectors/jks.md) · [Kubernetes Secrets](reference/connectors/k8s.md) · [NGINX](reference/connectors/nginx.md) · [Postfix / Dovecot](reference/connectors/postfix.md) · [SSH (agentless)](reference/connectors/ssh.md) · [Traefik](reference/connectors/traefik.md) · [Windows Certificate Store](reference/connectors/wincertstore.md)
-
-### Protocols
-
-| Doc | What it covers |
-|---|---|
-| [ACME server](reference/protocols/acme-server.md) | Run certctl as an RFC 8555 + RFC 9773 ARI ACME server |
-| [ACME server threat model](reference/protocols/acme-server-threat-model.md) | Security posture for the ACME server endpoint |
-| [SCEP server](reference/protocols/scep-server.md) | RFC 8894 native SCEP server — RA cert config, multi-profile dispatch, must-staple, mTLS sibling route |
-| [SCEP for Microsoft Intune](reference/protocols/scep-intune.md) | Intune-specific deployment guide — NDES replacement playbook |
-| [EST server](reference/protocols/est.md) | RFC 7030 EST server — 802.1X / Wi-Fi enrollment, IoT bootstrap, channel binding |
-| [CRL & OCSP](reference/protocols/crl-ocsp.md) | RFC 5280 CRL + RFC 6960 OCSP responder for relying parties |
-| [Async CA polling](reference/protocols/async-ca-polling.md) | Bounded polling for async-CA issuer connectors |
-
-## Operator
-
-You're running certctl in production and need operational guidance.
-
-| Doc | What it covers |
-|---|---|
-| [Security posture](operator/security.md) | Auth, rate limits, encryption at rest, key rotation, RBAC primitive (Bundle 1), bootstrap |
-| [RBAC operator reference](operator/rbac.md) | Roles, permissions, scopes, scope-down + bootstrap flow (Bundle 1) |
-| [Auth threat model](operator/auth-threat-model.md) | API-key compromise, role-grant abuse, bootstrap-token leak, audit-mutation, compliance mapping (Bundle 1) |
-| [Control plane TLS](operator/tls.md) | Self-signed bootstrap, operator-supplied Secret, cert-manager Certificate CR |
-| [Database TLS](operator/database-tls.md) | PostgreSQL transport encryption |
-| [Approval workflow](operator/approval-workflow.md) | Two-person integrity gate for high-stakes issuance + Phase 9 profile-edit closure |
-| [Helm deployment](operator/helm-deployment.md) | Kubernetes installation via the bundled chart |
-| [Performance baselines](operator/performance-baselines.md) | Operator-runnable benchmarks for regression spot checks |
-| [Legacy clients (TLS 1.2)](operator/legacy-clients-tls-1.2.md) | Reverse-proxy runbook for embedded EST/SCEP clients on TLS 1.2 |
-
-### Runbooks
-
-| Runbook | When |
-|---|---|
-| [Cloud targets](operator/runbooks/cloud-targets.md) | AWS ACM + Azure Key Vault deployment, debugging, rollback |
-| [Expiry alerts](operator/runbooks/expiry-alerts.md) | Per-policy multi-channel routing matrix, severity tiers |
-| [Disaster recovery](operator/runbooks/disaster-recovery.md) | CRL cache, OCSP responder cert, CA private-key rotation, Postgres restore |
-
-## Migration
-
-You're moving from another cert-management tool to certctl, or running both in parallel.
-
-| From | Doc |
-|---|---|
-| Certbot | [migration/from-certbot.md](migration/from-certbot.md) |
-| acme.sh | [migration/from-acmesh.md](migration/from-acmesh.md) |
-| cert-manager (coexistence, not replacement) | [migration/cert-manager-coexistence.md](migration/cert-manager-coexistence.md) |
-| Caddy ACME (point Caddy at certctl) | [migration/acme-from-caddy.md](migration/acme-from-caddy.md) |
-| cert-manager ACME (point cert-manager at certctl) | [migration/acme-from-cert-manager.md](migration/acme-from-cert-manager.md) |
-| Traefik ACME (point Traefik at certctl) | [migration/acme-from-traefik.md](migration/acme-from-traefik.md) |
-| **API keys → RBAC (v2.0.x → v2.1.0)** | [migration/api-keys-to-rbac.md](migration/api-keys-to-rbac.md) — **AUDIT YOUR API KEYS** post-upgrade |
-
-## Contributor
-
-You're contributing to certctl, running tests locally, or trying to understand the CI pipeline.
-
-| Doc | What it covers |
-|---|---|
-| [Testing strategy](contributor/testing-strategy.md) | What we test and why; per-PR fast gates vs daily deep-scan |
-| [Test environment](contributor/test-environment.md) | Local environment with real CAs (Pebble, step-ca, etc.) |
-| [QA prerequisites](contributor/qa-prerequisites.md) | Before running QA: stack boot, demo data baseline, env vars |
-| [QA test suite](contributor/qa-test-suite.md) | qa_test.go reference for release QA |
-| [GUI QA checklist](contributor/gui-qa-checklist.md) | Manual GUI verification pass for release |
-| [Release sign-off](contributor/release-sign-off.md) | Release-day checklist — code state, automated gates, manual QA, artefact verification |
-| [CI pipeline](contributor/ci-pipeline.md) | CI shape, regression guards, adding new checks |
-
-## Archive
-
-Historical docs preserved for reference. Most operators don't need these.
-
-| Doc | Why archived |
-|---|---|
-| [Upgrade to TLS (v2.2)](archive/upgrades/to-tls-v2.2.md) | Pre-v2.2 HTTPS-everywhere upgrade procedure |
-| [Upgrade past v2 JWT removal](archive/upgrades/to-v2-jwt-removal.md) | G-1 milestone JWT auth removal procedure |
-
----
-
-## Reading order by role
-
-**First-time operator:** [Concepts](getting-started/concepts.md) → [Quickstart](getting-started/quickstart.md) → [Examples](getting-started/examples.md). About 90 minutes end to end.
-
-**Production operator:** [Architecture](reference/architecture.md) → [Security posture](operator/security.md) → [Control plane TLS](operator/tls.md) → [Disaster recovery runbook](operator/runbooks/disaster-recovery.md). About 4 hours end to end.
-
-**PKI engineer:** [ACME server](reference/protocols/acme-server.md) → [SCEP server](reference/protocols/scep-server.md) → [EST server](reference/protocols/est.md) → [Intermediate CA hierarchy](reference/intermediate-ca-hierarchy.md). About 6 hours end to end.
-
-**Contributor:** [Architecture](reference/architecture.md) → [Testing strategy](contributor/testing-strategy.md) → [Test environment](contributor/test-environment.md) → [CI pipeline](contributor/ci-pipeline.md). About 3 hours end to end.

docs/architecture.md

@@ -1,7 +1,5 @@
 # Architecture Guide
 
-> Last reviewed: 2026-05-05
-
 ## Contents
 
 1. [Overview](#overview)
@@ -63,12 +61,12 @@ flowchart TB
         API["REST API\n(Go net/http, :8443)"]
         SVC["Service Layer"]
         REPO["Repository Layer\n(database/sql + lib/pq)"]
-        SCHED["Background Scheduler\n9 always-on + 5 opt-in loops"]
+        SCHED["Background Scheduler\n8 always-on + 4 optional loops"]
         DASH["Web Dashboard\n(React SPA)"]
     end
 
     subgraph "Data Store"
-        PG[("PostgreSQL 16\nTEXT primary keys")]
+        PG[("PostgreSQL 16\n21 tables\nTEXT primary keys")]
     end
 
     subgraph "Agent Fleet"
@@ -151,8 +149,6 @@ The agent runs two background loops: a heartbeat (every 60 seconds) to signal it
 
 Retired agents receive `410 Gone` on subsequent heartbeats (`service.ErrAgentRetired`). `cmd/agent` treats 410 as a terminal signal and exits cleanly so retired agents stop phoning home. Migration `000015` flipped `deployment_targets.agent_id` from `ON DELETE CASCADE` to `ON DELETE RESTRICT`, making the old hard-delete path a schema error and forcing all retirement through this contract.
 
-**Registration is by-design pull-only (C-1 closure, cat-b-6177f36636fb).** Agents register themselves at first heartbeat via `install-agent.sh` + `cmd/agent/main.go` — never via the GUI. The `web/src/api/client.ts::registerAgent` client function is intentionally orphan in the dashboard for this reason. It's preserved in `client.ts` (rather than deleted) so future features that want to drive registration from the GUI — for example, a one-click "register proxy agent" panel for network-appliance topologies where the agent runs in a different network zone from the device it manages — can reach the endpoint without a `client.ts` edit. Operators looking to scale agent enrollment use `install-agent.sh` against a config-management system (Ansible, Salt, Puppet) or a baked-in cloud-init script, not the dashboard.
-
 ### Web Dashboard
 
 The web dashboard is the primary operational interface for certctl. It is built with Vite + React + TypeScript and uses TanStack Query for server state management (caching, background refetching, optimistic updates).
@@ -167,10 +163,6 @@ The dashboard includes an **ErrorBoundary component** for graceful error recover
 - Light content area with branded dark teal sidebar, Inter + JetBrains Mono typography
 - SSE/WebSocket planned for real-time job status updates
 
-**Backend ↔ frontend round-trip rule (B-1 closure):** every backend CRUD operation must have at least one GUI consumer in `web/src/pages/`. Shipping a handler + repository method + OpenAPI operation + `client.ts` fetcher with no page that calls it leaves operators forced to `psql` directly — defeats the "every backend feature ships with its GUI surface" invariant and creates a destructive workflow when the missing path is `update*` (operators delete-and-recreate, losing FK history and audit-trail continuity). The CI guardrail in `.github/workflows/ci.yml` (`Forbidden orphan-CRUD client function regression guard (B-1)`) enforces this for the eight previously-orphan functions (`updateOwner`/`updateTeam`/`updateAgentGroup`/`updateIssuer`/`updateProfile` + `createRenewalPolicy`/`updateRenewalPolicy`/`deleteRenewalPolicy`); apply the same rule when adding any new write endpoint. If a fetcher is needed in `client.ts` before its consumer page exists, leave a TODO referencing this rule and ship them in the same commit.
-
-**TS ↔ Go type contract rule (D-1 + D-2 closure):** every TypeScript interface in `web/src/api/types.ts` must field-match the Go-side `internal/domain/*.go` struct's JSON-emitted shape exactly. Phantom fields (declared on TS, never emitted by Go) silently render `'—'` and lull consumers into thinking a value will arrive that never does; missing fields (emitted by Go, absent from TS) force `(x as any).X` escapes that lose type-checking. Both failure modes are blocked by the CI guardrail in `.github/workflows/ci.yml` (`Forbidden StatusBadge dead-key + TS phantom-field regression guard (D-1 + D-2)`) which awk-windows each interface and grep-fails the build on phantom-field reintroduction — currently covers Certificate (D-1), Agent / Issuer / Notification (D-2). Apply the same rule when adding any new on-wire type: the Go-side json tag is the contract, the TS interface adapts to it, and a literal-construction Vitest in `web/src/api/types.test.ts` pins the post-add shape. Stricter side wins: when in doubt, the side that actually emits the field is the contract; never propose adding a phantom on Go to match a TS over-declaration.
-
 ### PostgreSQL Database
 
 All state is stored in PostgreSQL 16. The schema uses TEXT primary keys (not UUIDs) with human-readable prefixed IDs like `mc-api-prod`, `t-platform`, `o-alice`.
@@ -356,12 +348,7 @@ erDiagram
     }
 ```
 
-The ER diagram above documents **database shape**, not REST-API wire shape. Several columns are intentionally server-internal and never serialized to clients:
-
-- `agents.api_key_hash` — SHA-256 of the agent's plaintext API key, populated by `service.RegisterAgent` (`hashAPIKey(apiKey)` at `internal/service/agent.go`) and consumed by `repository.AgentRepository::GetByAPIKey` for the auth-lookup. **Not** exposed via the REST API, **not** echoed via CLI / MCP / agent registration response, **never** logged. Enforced by `internal/domain/connector.go::Agent.MarshalJSON` (G-2 audit closure, `cat-s5-apikey_leak`); the OpenAPI Agent schema explicitly excludes the field, the frontend `Agent` interface omits it, and a CI grep guardrail at `.github/workflows/ci.yml` blocks reintroduction.
-- `issuers.config` / `deployment_targets.config` — plaintext jsonb shadow of the AES-GCM-encrypted on-disk blob; the encrypted form lives on `EncryptedConfig []byte` (Go-only field tagged `json:"-"`).
-
-Migrations are idempotent (`IF NOT EXISTS` on all CREATE statements, `ON CONFLICT (id) DO NOTHING` on all seed data) so they're safe to run multiple times. Pre-U-3 (`cat-u-seed_initdb_schema_drift`, GitHub #10) the deploy compose stack mounted both a hand-curated subset of `migrations/*.up.sql` and `seed.sql` into postgres `/docker-entrypoint-initdb.d/` so initdb applied them on first boot, *and* the server re-applied the same files via `RunMigrations` on every start. The dual source of truth was the bug: every time a migration shipped that the seed depended on (e.g., 000013 added `policy_rules.severity`), the mount list had to be updated by hand, and missing the update crashed initdb on first boot. Post-U-3 the server is the single source of truth: postgres comes up with an empty schema, `RunMigrations` applies the entire ladder, then `RunSeed` lands the baseline seed (and `RunDemoSeed` lands the demo overlay when `CERTCTL_DEMO_SEED=true`). Helm has used this pattern since day one (postgres-init `emptyDir`); the docker-compose deploy now matches.
+Migrations are idempotent (`IF NOT EXISTS` on all CREATE statements, `ON CONFLICT (id) DO NOTHING` on all seed data) so they're safe to run multiple times — important for Docker Compose where both initdb and the server may run the same SQL.
 
 ## Data Flow: Certificate Lifecycle
 
@@ -495,11 +482,11 @@ Short-lived certificates (those with profile TTL < 1 hour) return "good" from OC
 
 #### Bulk Revocation
 
-For incident-response events requiring fleet-wide revocation (key compromise, CA distrust, mass decommission), certctl supports bulk revocation by filter criteria. The `POST /api/v1/certificates/bulk-revoke` endpoint accepts filter parameters (profile_id, owner_id, agent_id, issuer_id) and creates individual revocation jobs for each matching certificate. Bulk revocation reuses the same 7-step single-cert flow for each certificate — no new issuer notification or audit mechanics. The operation is idempotent: revoking an already-revoked certificate is a no-op. Partial failures are tolerated — if one certificate fails to revoke (e.g., issuer unavailable), the operation continues for remaining certs and returns a summary. A single `bulk_revocation_initiated` audit event logs the operation with filter criteria, operator actor, and summary (total requested, succeeded, failed counts). Audit events for individual certificate revocations record the operator identity separately. The GUI bulk revoke button on the certificates list filters by visible selections and displays an affected-cert count modal before confirmation.
+For compliance events requiring fleet-wide revocation (key compromise, CA distrust, mass decommission), certctl supports bulk revocation by filter criteria. The `POST /api/v1/certificates/bulk-revoke` endpoint accepts filter parameters (profile_id, owner_id, agent_id, issuer_id) and creates individual revocation jobs for each matching certificate. Bulk revocation reuses the same 7-step single-cert flow for each certificate — no new issuer notification or audit mechanics. The operation is idempotent: revoking an already-revoked certificate is a no-op. Partial failures are tolerated — if one certificate fails to revoke (e.g., issuer unavailable), the operation continues for remaining certs and returns a summary. A single `bulk_revocation_initiated` audit event logs the operation with filter criteria, operator actor, and summary (total requested, succeeded, failed counts). Audit events for individual certificate revocations record the operator identity separately. The GUI bulk revoke button on the certificates list filters by visible selections and displays an affected-cert count modal before confirmation.
 
 ### 4. Automatic Renewal
 
-The control plane runs a scheduler with 9 always-on loops plus up to 5 opt-in loops (enabled by configuration). Re-derive the count via `grep -cE '^func \(s \*Scheduler\) [a-zA-Z]+Loop' internal/scheduler/scheduler.go`; the opt-in gating lives in `cmd/server/main.go` startup wiring (`cfg.NetworkScan.Enabled`, `digestService != nil`, `healthCheckService != nil`, `cloudDiscoveryService != nil`, `cfg.ACMEServer.Enabled && cfg.ACMEServer.GCInterval > 0`).
+The control plane runs a scheduler with 8 always-on loops plus up to 4 optional loops (enabled by configuration). `internal/scheduler/scheduler.go:262-265` is the authoritative count.
 
 ```mermaid
 flowchart LR
@@ -647,7 +634,7 @@ type Connector interface {
 }
 ```
 
-Built-in issuers (live count: `ls -d internal/connector/issuer/*/ | wc -l`): **Local CA** (self-signed or sub-CA mode using `crypto/x509`), **ACME v2** (HTTP-01, DNS-01, and DNS-PERSIST-01 challenges, compatible with Let's Encrypt, ZeroSSL, Sectigo, Google Trust Services, and any ACME-compliant CA), **step-ca** (Smallstep private CA via native /sign API with JWK provisioner auth), **OpenSSL/Custom CA** (script-based signing delegating to user-provided shell scripts), **Vault PKI** (HashiCorp Vault's PKI secrets engine via /sign API with token auth), **DigiCert** (commercial CA via CertCentral REST API with async order processing), **Sectigo SCM** (async order model with 3-header auth), **Google CAS** (Cloud Certificate Authority Service with OAuth2 service account auth), **AWS ACM Private CA** (synchronous issuance via ACM PCA API), **Entrust** (mTLS client cert auth, sync/approval-pending), **GlobalSign Atlas HVCA** (mTLS + API key/secret dual auth), and **EJBCA** (Keyfactor open-source self-hosted CA, dual auth: mTLS or OAuth2). The ACME connector uses `golang.org/x/crypto/acme`, generates an ECDSA P-256 account key, handles account registration with ToS acceptance and optional External Account Binding (EAB) for CAs that require it (ZeroSSL, Google Trust Services, SSL.com), order creation, challenge solving (HTTP-01 via built-in server, DNS-01 via script-based hooks, DNS-PERSIST-01 via standing TXT records with auto-fallback to DNS-01), order finalization, and DER-to-PEM chain conversion. For ZeroSSL, EAB credentials are auto-fetched from ZeroSSL's public API when the directory URL is detected as ZeroSSL and no EAB credentials are provided — zero-friction onboarding with no dashboard visit required.
+Built-in issuers (9 connectors): **Local CA** (self-signed or sub-CA mode using `crypto/x509`), **ACME v2** (HTTP-01, DNS-01, and DNS-PERSIST-01 challenges, compatible with Let's Encrypt, ZeroSSL, Sectigo, Google Trust Services, and any ACME-compliant CA), **step-ca** (Smallstep private CA via native /sign API with JWK provisioner auth), **OpenSSL/Custom CA** (script-based signing delegating to user-provided shell scripts), **Vault PKI** (HashiCorp Vault's PKI secrets engine via /sign API with token auth), **DigiCert** (commercial CA via CertCentral REST API with async order processing), **Sectigo SCM** (async order model with 3-header auth), **Google CAS** (Cloud Certificate Authority Service with OAuth2 service account auth), and **AWS ACM Private CA** (synchronous issuance via ACM PCA API). The ACME connector uses `golang.org/x/crypto/acme`, generates an ECDSA P-256 account key, handles account registration with ToS acceptance and optional External Account Binding (EAB) for CAs that require it (ZeroSSL, Google Trust Services, SSL.com), order creation, challenge solving (HTTP-01 via built-in server, DNS-01 via script-based hooks, DNS-PERSIST-01 via standing TXT records with auto-fallback to DNS-01), order finalization, and DER-to-PEM chain conversion. For ZeroSSL, EAB credentials are auto-fetched from ZeroSSL's public API when the directory URL is detected as ZeroSSL and no EAB credentials are provided — zero-friction onboarding with no dashboard visit required.
 
 **ACME Renewal Information (ARI, RFC 9773):** The ACME connector supports CA-directed renewal timing via the `GetRenewalInfo()` method. Instead of using fixed thresholds (e.g., renew 30 days before expiry), the CA tells certctl when to renew by providing a `suggestedWindow` with start and end times. This is useful for distributing renewal load during maintenance windows and coordinating mass-revocation scenarios. Enable with `CERTCTL_ACME_ARI_ENABLED=true`. Cert ID is computed as `base64url(SHA-256(DER cert))` per RFC 9773. If the CA doesn't support ARI (404 from the ARI endpoint), certctl automatically falls back to threshold-based renewal — no operator intervention required. Errors from the CA are logged as warnings.
 
@@ -705,17 +692,20 @@ The EST (Enrollment over Secure Transport) server provides an industry-standard
 
 **Architecture:** EST is a handler-level protocol that delegates certificate issuance to an existing `IssuerConnector`. This means EST is not a new issuer — it's a new *interface* to the existing issuance infrastructure. The `ESTService` bridges the `ESTHandler` to whichever issuer connector is configured via `CERTCTL_EST_ISSUER_ID`.
 
-```mermaid
-flowchart TD
-    Client["Client (WiFi AP, MDM, IoT)"]
-    Handler["ESTHandler (handler layer)"]
-    Service["ESTService (service layer)"]
-    Issuer["IssuerConnector (connector layer via IssuerConnectorAdapter)"]
-    Result["Signed certificate returned as PKCS#7 certs-only"]
-    Client --> Handler
-    Handler -->|"CSR parsing, PKCS#7 response encoding"| Service
-    Service -->|"CSR validation, CN/SAN extraction, audit recording"| Issuer
-    Issuer -->|"certificate signing (Local CA, step-ca, etc.)"| Result
+```
+Client (WiFi AP, MDM, IoT)
+    │
+    ▼
+ESTHandler (handler layer)
+    │  CSR parsing, PKCS#7 response encoding
+    ▼
+ESTService (service layer)
+    │  CSR validation, CN/SAN extraction, audit recording
+    ▼
+IssuerConnector (connector layer via IssuerConnectorAdapter)
+    │  Certificate signing (Local CA, step-ca, etc.)
+    ▼
+Signed certificate returned as PKCS#7 certs-only
 ```
 
 **Wire format:** EST uses PKCS#7 (RFC 2315) certs-only degenerate SignedData for certificate responses and base64-encoded DER for CSR requests. The handler includes a hand-rolled ASN.1 PKCS#7 builder — no external PKCS#7 dependency. The CSR reader accepts both base64-encoded DER (standard EST wire format) and PEM-encoded PKCS#10 (convenience for debugging).
@@ -733,60 +723,9 @@ type ESTService interface {
 
 **Issuer connector extension:** EST required adding `GetCACertPEM(ctx) (string, error)` to the issuer connector interface so the `/cacerts` endpoint can serve the CA chain. The Local CA returns its CA certificate PEM; Vault PKI fetches via `GET /v1/{mount}/ca/pem`; Google CAS fetches via API; AWS ACM PCA retrieves via `GetCertificateAuthorityCertificate`. ACME, step-ca, OpenSSL, DigiCert, and Sectigo connectors return errors (they don't expose a static CA chain — their chains are per-issuance).
 
-**Authentication:** EST endpoints are served unauthenticated at the HTTP layer under `/.well-known/est/*` — no Bearer token required. Per RFC 7030 §3.2.3 EST authentication is deployment-specific, and per §4.1.1 `/cacerts` is explicitly anonymous. certctl enforces authentication via CSR signature verification inside `ESTService.SimpleEnroll`/`SimpleReEnroll` plus profile policy gates (allowed key algorithms, minimum key size, permitted SANs, permitted EKUs, MaxTTL). The HTTP dispatch is implemented in `cmd/server/main.go:buildFinalHandler`, which routes `/.well-known/est/*` through `noAuthHandler` (RequestID + structuredLogger + Recovery only). The EST RFC 7030 hardening master bundle (Phases 1–11, post-2026-04-29) layers per-profile mTLS sibling routes, HTTP Basic enrollment-password auth, RFC 9266 channel binding, and per-(CN, sourceIP) sliding-window rate limits on top of this baseline — see [`EST Server (RFC 7030) — Production Deployment`](#est-server-rfc-7030--production-deployment) below for the production topology.
+**Authentication:** EST endpoints are served unauthenticated at the HTTP layer under `/.well-known/est/*` — no Bearer token required. Per RFC 7030 §3.2.3 EST authentication is deployment-specific, and per §4.1.1 `/cacerts` is explicitly anonymous. certctl enforces authentication via CSR signature verification inside `ESTService.SimpleEnroll`/`SimpleReEnroll` plus profile policy gates (allowed key algorithms, minimum key size, permitted SANs, permitted EKUs, MaxTTL). The HTTP dispatch is implemented in `cmd/server/main.go:buildFinalHandler`, which routes `/.well-known/est/*` through `noAuthHandler` (RequestID + structuredLogger + Recovery only). Operators who need stronger client identification should terminate mTLS at an upstream reverse proxy and pin the CSR's SAN to the client cert subject at the profile level.
 
-**Audit:** Every EST enrollment is recorded in the audit trail with `protocol: "EST"`, the CN, SANs, issuer ID, serial number, and optional profile ID. The hardening bundle adds typed audit-action codes per failure dimension (`est_simple_enroll_success` / `_failed`, `est_auth_failed_basic` / `_mtls` / `_channel_binding`, `est_rate_limited`, `est_csr_policy_violation`, `est_bulk_revoke`, `est_trust_anchor_reloaded`, etc.) so operators can filter the GUI Recent Activity tab on the exact reason — see `internal/service/est_audit_actions.go` for the constants.
-
-### EST Server (RFC 7030) — Production Deployment
-
-The EST hardening master bundle (Phases 1–11, post-2026-04-29) makes the EST server production-grade for enterprise WiFi/802.1X, IoT bootstrap, and Microsoft-fleet enrollment without a behind-the-proxy auth layer. The `EST Server (RFC 7030)` section above describes the V2-baseline single-profile server; the production topology layers in:
-
-- **Multi-profile dispatch** via `CERTCTL_EST_PROFILES=corp,iot,wifi`. Each profile gets its own `/.well-known/est/<pathID>/` endpoint group, isolated issuer binding, optional `CertificateProfile`, and independent auth + trust anchor.
-- **mTLS sibling route** at `/.well-known/est-mtls/<pathID>/` (opt-in via `_MTLS_ENABLED=true`). Required for the standard route's HTTP Basic to coexist with the renewal-on-existing-cert flow. Per-handler re-verify enforces "cert chains to THIS profile's bundle" so cross-profile bleed is blocked even when both profiles share a TLS listener union pool (`cmd/server/tls.go::buildServerTLSConfigWithMTLS`).
-- **HTTP Basic enrollment-password** on the standard route (opt-in via `_ALLOWED_AUTH_MODES=basic` + `_ENROLLMENT_PASSWORD`). Constant-time comparison; per-source-IP failed-auth limiter (10 attempts / 1h / 50k tracked IPs) caps brute-force from a single source.
-- **RFC 9266 `tls-exporter` channel binding** (opt-in via `_CHANNEL_BINDING_REQUIRED=true`, gated on `_MTLS_ENABLED=true`). Defends against TLS-bridging MITM where an attacker funnels the device's CSR through their own TLS session.
-- **Per-(CN, sourceIP) sliding-window rate limit** via `_RATE_LIMIT_PER_PRINCIPAL_24H` (default 0 = disabled; production = 3). Mirrors the SCEP/Intune per-device limit pattern.
-- **Server-side keygen** per RFC 7030 §4.4 (opt-in via `_SERVERKEYGEN_ENABLED=true`). CMS EnvelopedData wraps the server-generated private key encrypted to the device's CSR pubkey via AES-256-CBC; plaintext key zeroized after marshal (mirrors the SCEP/Intune `keymem.marshalPrivateKeyAndZeroize` discipline).
-- **Per-profile observability** via the `/api/v1/admin/est/profiles` and `POST /api/v1/admin/est/reload-trust` endpoints (M-008 admin-gated). The GUI surface lives at `/est` with three tabs (Profiles / Recent Activity / Trust Bundle) — counter cells per failure dimension, trust-anchor expiry countdowns, SIGHUP-equivalent reload modal.
-- **EST-source-scoped bulk revoke** at `POST /api/v1/est/certificates/bulk-revoke` (M-008 admin-gated). The handler pins `Source=EST` so the operator's bulk-revoke only affects EST-issued certs even if the criteria match SCEP/API/Agent-issued certs too. Provenance is tracked via `ManagedCertificate.Source` (migration `000023_managed_certificates_source.up.sql`).
-
-```mermaid
-flowchart LR
-    subgraph "EST clients"
-        Laptop["Laptop / supplicant\n(host enrollment)"]
-        IoT["IoT device\n(bootstrap)"]
-        Sup["WiFi supplicant\n(user enrollment)"]
-    end
-    subgraph "EST endpoints (per profile)"
-        Std["/.well-known/est/&lt;pathID&gt;/\n(HTTP Basic OR anonymous)"]
-        MTLS["/.well-known/est-mtls/&lt;pathID&gt;/\n(client cert required;\ntrust → _MTLS_CLIENT_CA_TRUST_BUNDLE_PATH)"]
-    end
-    subgraph "Per-profile gates (in order)"
-        Auth["Auth\n(_ALLOWED_AUTH_MODES)"]
-        CB["RFC 9266 channel binding\n(_CHANNEL_BINDING_REQUIRED)"]
-        RL["Sliding-window rate limit\n(_RATE_LIMIT_PER_PRINCIPAL_24H)"]
-        Pol["CSR policy gate\n(profile.AllowedKeyAlgorithms / EKUs / SANs / MaxTTL / MustStaple)"]
-    end
-    subgraph "Issuance"
-        Iss["IssuerConnector\n(per profile _ISSUER_ID)"]
-    end
-    Laptop --> MTLS
-    IoT --> Std
-    Sup --> MTLS
-    Std --> Auth --> RL --> Pol --> Iss
-    MTLS --> Auth --> CB --> RL --> Pol --> Iss
-    Iss --> Audit["audit log\n(typed est_* action codes)"]
-    Iss --> Counter["estCounterTab\n(per-profile sync/atomic)"]
-    Audit --> GUI["/est admin tabs\n(Profiles / Recent Activity / Trust Bundle)"]
-    Counter --> GUI
-    GUI -. "SIGHUP-equivalent" .-> Reload["/api/v1/admin/est/reload-trust\n(M-008 admin-gated)"]
-```
-
-Trust-anchor reload semantics: a bad SIGHUP (parse error, expired cert) keeps the OLD pool in place. The operator hits the GUI Reload modal, sees the typed error, corrects the file, retries — the EST endpoint never goes down during a half-rotation. Implemented via the shared `internal/trustanchor.Holder` primitive that the SCEP/Intune dispatcher also uses; per-handler `Get()` returns a snapshot at request-start so an in-flight request that crosses a SIGHUP uses the OLD pool.
-
-**libest interop tested in CI.** The libest sidecar at `deploy/test/libest/Dockerfile` builds Cisco's reference RFC 7030 client (v3.2.0-2) and the integration suite at `deploy/test/est_e2e_test.go` exercises every documented flow end-to-end via `docker exec` against the live certctl server. See [`docs/est.md::Appendix A`](est.md#appendix-a-libest-reference-client) for the operator-side reproducer.
-
-The full operator guide (multi-profile config, WiFi/802.1X + FreeRADIUS recipe, IoT bootstrap recipe, troubleshooting matrix per typed audit-action) is at [`docs/est.md`](est.md).
+**Audit:** Every EST enrollment is recorded in the audit trail with `protocol: "EST"`, the CN, SANs, issuer ID, serial number, and optional profile ID.
 
 ### SCEP Server (RFC 8894)
 
@@ -794,47 +733,36 @@ The SCEP (Simple Certificate Enrollment Protocol) server provides certificate en
 
 **Architecture:** SCEP follows the exact same layering as EST — a handler-level protocol that delegates certificate issuance to an existing `IssuerConnector`. The `SCEPService` bridges the `SCEPHandler` to whichever issuer connector is configured via `CERTCTL_SCEP_ISSUER_ID`.
 
-```mermaid
-flowchart TD
-    Client["Client (MDM, network device, SCEP client)"]
-    Handler["SCEPHandler (handler layer)"]
-    Service["SCEPService (service layer)"]
-    Issuer["IssuerConnector (connector layer via IssuerConnectorAdapter)"]
-    Result["Signed certificate returned as PKCS#7 certs-only"]
-    Client --> Handler
-    Handler -->|"PKCS#7 envelope parsing, CSR extraction, challenge password extraction"| Service
-    Service -->|"challenge password validation, CSR validation, CN/SAN extraction, audit recording"| Issuer
-    Issuer -->|"certificate signing (Local CA, step-ca, etc.)"| Result
+```
+Client (MDM, network device, SCEP client)
+    │
+    ▼
+SCEPHandler (handler layer)
+    │  PKCS#7 envelope parsing, CSR extraction, challenge password extraction
+    ▼
+SCEPService (service layer)
+    │  Challenge password validation, CSR validation, CN/SAN extraction, audit recording
+    ▼
+IssuerConnector (connector layer via IssuerConnectorAdapter)
+    │  Certificate signing (Local CA, step-ca, etc.)
+    ▼
+Signed certificate returned as PKCS#7 certs-only
 ```
 
-**Wire format:** Two paths, tried in order. The new RFC 8894 path (post-2026-04-29) parses the full PKIMessage shape: ContentInfo → SignedData → SignerInfo (POPO over auth-attrs verified via `internal/pkcs7/signedinfo.go::SignerInfo.VerifySignature` with the canonical SET-OF Attribute re-serialisation per RFC 5652 §5.4) → EnvelopedData (decrypted via `internal/pkcs7/envelopeddata.go::EnvelopedData.Decrypt` with RSA PKCS#1v1.5 keyTrans + AES-CBC content + constant-time PKCS#7 unpad to close the padding-oracle leak) → inner PKCS#10 CSR. Auth-attrs (messageType, transactionID, senderNonce) flow through to the service layer via `domain.SCEPRequestEnvelope`. The handler dispatches on messageType: PKCSReq (19) → initial enrollment; RenewalReq (17) → re-enrollment with chain validation; GetCertInitial (20) → polling stub returns FAILURE+badCertID. Responses are full CertRep PKIMessages (`internal/pkcs7/certrep.go::BuildCertRepPKIMessage`) signed by the per-profile RA cert/key with the issued cert chain encrypted to the device's transient signing cert (RFC 8894 §3.3.2). On parse failure the handler falls through to the legacy MVP path: base64-encoded PKCS#7 and raw CSR submissions are still accepted; responses use the legacy PKCS#7 certs-only shape via the shared `internal/pkcs7` package. The MVP fall-through is non-negotiable — backward compat with lightweight SCEP clients that don't speak full RFC 8894. Single certs are returned as raw DER for `GetCACert`, chains as PKCS#7.
+**Wire format:** SCEP clients wrap CSRs in PKCS#7 SignedData envelopes. The handler parses the outer ASN.1 ContentInfo → SignedData → EncapsulatedContentInfo to extract the CSR bytes. Fallback paths handle base64-encoded PKCS#7 and raw CSR submissions (for simpler clients). Responses use PKCS#7 certs-only via the shared `internal/pkcs7` package (same as EST). Single certs are returned as raw DER for `GetCACert`, chains as PKCS#7.
 
 **Authentication:** SCEP endpoints at `/scep` and `/scep/*` are served unauthenticated at the HTTP layer — no Bearer token required — per RFC 8894 §3.2, which defines authentication via the `challengePassword` attribute (OID 1.2.840.113549.1.9.7) embedded in the PKCS#10 CSR rather than an HTTP credential. The HTTP dispatch is implemented in `cmd/server/main.go:buildFinalHandler`, which routes `/scep` and `/scep/*` through `noAuthHandler` (RequestID + structuredLogger + Recovery only). The `challengePassword` is mandatory: `preflightSCEPChallengePassword` at startup refuses to boot the control plane when `CERTCTL_SCEP_ENABLED=true` is set without `CERTCTL_SCEP_CHALLENGE_PASSWORD`, closing CWE-306 (missing authentication for a critical function). `SCEPService.PKCSReq` enforces the same invariant defense-in-depth — an empty `s.challengePassword` rejects every enrollment — and the password comparison uses `crypto/subtle.ConstantTimeCompare` to prevent response-time side-channel leakage. The startup log line `SCEP server enabled` emits a `challenge_password_set` boolean for operator visibility.
 
-**Interface:** The `SCEPHandler` defines an `SCEPService` interface (dependency inversion). The legacy `PKCSReq` method backs the MVP fall-through path; the three `*WithEnvelope` variants back the RFC 8894 PKIMessage path:
+**Interface:** The `SCEPHandler` defines an `SCEPService` interface (dependency inversion):
 
 ```go
 type SCEPService interface {
     GetCACaps(ctx context.Context) string
     GetCACert(ctx context.Context) (string, error)
-    // MVP path — raw CSR + transactionID synthesised from CSR's CN.
-    PKCSReq(ctx context.Context, csrPEM, challengePassword, transactionID string) (*domain.SCEPEnrollResult, error)
-    // RFC 8894 path — envelope carries the parsed authenticated attributes
-    // (messageType, transactionID, senderNonce, signerCert). Returns
-    // *SCEPResponseEnvelope (not error + result) because RFC 8894 §3.3
-    // mandates a CertRep PKIMessage on every response, even failures.
-    PKCSReqWithEnvelope(ctx context.Context, csrPEM, challengePassword string, env *domain.SCEPRequestEnvelope) *domain.SCEPResponseEnvelope
-    RenewalReqWithEnvelope(ctx context.Context, csrPEM, challengePassword string, env *domain.SCEPRequestEnvelope) *domain.SCEPResponseEnvelope
-    GetCertInitialWithEnvelope(ctx context.Context, env *domain.SCEPRequestEnvelope) *domain.SCEPResponseEnvelope
+    PKCSReq(ctx context.Context, csrPEM string, challengePassword string, transactionID string) (*domain.SCEPEnrollResult, error)
 }
 ```
 
-**Capabilities advertised:** `POSTPKIOperation` + `SHA-256` + `SHA-512` + `AES` + `SCEPStandard` + `Renewal`. ChromeOS specifically looks for `POSTPKIOperation` (non-base64 POST), `AES` (the now-implemented CBC content encryption), `SCEPStandard` (RFC 8894 conformance), and `Renewal` (RenewalReq messageType-17 dispatch).
-
-**Multi-profile dispatch:** A single certctl instance can expose multiple SCEP endpoints from `CERTCTL_SCEP_PROFILES=corp,iot,server` + per-profile `CERTCTL_SCEP_PROFILE_<NAME>_*` env vars, each with its own issuer + RA pair + challenge password. The router exposes `/scep` (legacy, single-profile flat-env case) + `/scep/<pathID>` per non-empty profile. Per-profile preflight validates each RA pair independently; failures log the offending PathID. See [`legacy-est-scep.md`](legacy-est-scep.md#multi-profile-dispatch-scep-path-id) for the operator config recipe.
-
-**Must-staple per profile:** When `CertificateProfile.MustStaple = true`, the local issuer adds the RFC 7633 `id-pe-tlsfeature` extension (OID `1.3.6.1.5.5.7.1.24`, non-critical, value `SEQUENCE OF INTEGER {5}`) to issued certs so browsers + modern TLS libraries fail-closed on missing OCSP stapling responses.
-
 **Shared PKCS#7 package:** Both EST and SCEP handlers share a common `internal/pkcs7` package for building PKCS#7 certs-only responses and PEM-to-DER chain conversion, eliminating code duplication between the two enrollment protocols.
 
 **Audit:** Every SCEP enrollment is recorded in the audit trail with `protocol: "SCEP"`, the CN, SANs, issuer ID, serial number, transaction ID, and optional profile ID.
@@ -878,76 +806,6 @@ The control plane only handles public material: certificates, chains, and CSRs.
 
 **Server keygen mode (`CERTCTL_KEYGEN_MODE=server`, demo only):** The control plane generates RSA-2048 keys server-side within `processRenewalServerKeygen`. Private keys are stored in `certificate_versions.csr_pem`. A log warning is emitted at startup. Use only for Local CA development/demo.
 
-### Microsoft Intune Connector trust anchor (per-profile, opt-in)
-
-When the SCEP server is sitting behind a Microsoft Intune Certificate
-Connector — i.e. certctl is acting as a drop-in NDES replacement —
-each per-profile dispatcher carries its own **trust anchor pool**:
-the public certs the operator extracted from the Connector's
-installation. Every Intune-flavored enrollment goes through:
-
-```mermaid
-flowchart TD
-    TAH["Per-profile TrustAnchorHolder<br/>(RWMutex pool, SIGHUP-reloadable)"]
-    Device[device]
-    Handler[handler]
-    Dispatch["SCEPService.dispatchIntuneChallenge"]
-    Validate["intune.ValidateChallenge<br/>(sig + iat/exp + audience)"]
-    Match["claim.DeviceMatchesCSR<br/>(set-equality)"]
-    Replay["intune.ReplayCache.CheckAndInsert"]
-    Rate["intune.PerDeviceRateLimiter.Allow"]
-    Compliance["(V3-Pro) ComplianceCheck hook"]
-    Process["processEnrollment → IssuerConnector"]
-    Device -->|SCEP PKIMessage| Handler
-    Handler --> Dispatch
-    TAH -.->|Get()| Dispatch
-    Dispatch --> Validate
-    Dispatch --> Match
-    Dispatch --> Replay
-    Dispatch --> Rate
-    Dispatch --> Compliance
-    Dispatch --> Process
-```
-
-The trust anchor file is mode-0600 on disk; certctl loads it at
-startup via `intune.LoadTrustAnchor` (refuses to boot on empty
-bundle / parse error / past-`NotAfter` cert) and reloads atomically
-on `SIGHUP` (mirrors the server TLS-cert hot-reload pattern). A bad
-reload keeps the OLD pool in place — operators get a recoverable
-failure window rather than a service-down. The admin GUI's
-**Intune Monitoring** tab inside the SCEP Administration page (`/scep`)
-and the parallel admin endpoints
-(`GET /api/v1/admin/scep/profiles` for the always-present per-profile
-overview that drives the Profiles tab,
-`GET /api/v1/admin/scep/intune/stats` for the Intune deep dive,
-`POST /api/v1/admin/scep/intune/reload-trust` for the SIGHUP-equivalent)
-are all M-008 admin-gated; non-admin Bearer callers get HTTP 403
-because the trust-anchor expiries + RA cert expiries + mTLS bundle
-paths are sensitive operational metadata.
-
-See [`scep-intune.md`](scep-intune.md) for the full migration playbook
-+ Microsoft support statement.
-
-### CA Signing Abstraction
-
-The local issuer's CA private key is wrapped behind the `signer.Signer` interface in `internal/crypto/signer/`. Every CA-signing call site — leaf certificate issuance (`x509.CreateCertificate`), CRL generation (`x509.CreateRevocationList`), and OCSP response signing (`ocsp.CreateResponse`) — accesses the key through this interface rather than touching `crypto.Signer` directly. The interface embeds the stdlib `crypto.Signer` and adds a single `Algorithm() Algorithm` method so call sites can pick the matching `x509.SignatureAlgorithm` without reflecting on the concrete key type.
-
-```mermaid
-flowchart LR
-    Local["internal/connector/issuer/local<br/>c.caSigner signer.Signer"]
-    subgraph Driver["signer.Driver (pluggable)"]
-        File["signer.FileDriver (default)<br/>PEM key on disk"]
-        Memory["signer.MemoryDriver (tests)<br/>in-memory only"]
-        PKCS11["signer.PKCS11Driver (V3-Pro)<br/>HSM token (future)"]
-        Cloud["signer.CloudKMSDriver (V3-Pro)<br/>AWS / GCP / Azure (future)"]
-    end
-    Local --> Driver
-```
-
-Today only `FileDriver` (production) and `MemoryDriver` (tests) ship. The interface exists so PKCS#11/HSM and cloud-KMS drivers can land in follow-on packages (`internal/crypto/signer/pkcs11`, etc.) without modifying any call site or any other driver. The L-014 file-on-disk threat-model carve-out documented at the top of `internal/connector/issuer/local/local.go` applies to `FileDriver`-backed signers; alternative drivers that keep the key inside an HSM token or cloud KMS close the disk-exposure leg of the threat model entirely.
-
-Behavior equivalence between the wrapped Signer and the raw `crypto.Signer` is pinned by `internal/crypto/signer/equivalence_test.go`: RSA signing is byte-strict equal (PKCS#1 v1.5 is deterministic), ECDSA signing is structurally equal (TBSCertificate / TBSRevocationList byte-equal; signature value differs because ECDSA uses random `k`).
-
 ### Authentication
 
 - **API clients → Server**: API key in `Authorization: Bearer` header, or `none` for demo mode. Applies to every path under `/api/v1/*`.
@@ -1033,20 +891,12 @@ The HTTP middleware stack processes requests in the following order (see `cmd/se
 4. **BodyLimit** - request body size cap via `http.MaxBytesReader`
 5. **RateLimiter** - token bucket rate limiting (optional, when enabled)
 6. **CORS** - cross-origin request handling (deny-by-default)
-7. **Auth** - API key validation (or none in development; JWT/OIDC via authenticating gateway, see below — not in-process)
+7. **Auth** - API key or JWT validation
 8. **AuditLog** - records every API call to the audit trail (requires auth context for actor)
 
-### Authenticating-gateway pattern (JWT, OIDC, mTLS)
-
-certctl's in-process authentication surface is intentionally narrow: `api-key` for production deployments and `none` for development. There is no in-process JWT, OIDC, mTLS, or SAML middleware. (`CERTCTL_AUTH_TYPE=jwt` was accepted pre-G-1 but silently routed through the api-key bearer middleware — a security finding masquerading as a config option, removed at the v2.x boundary; see [`upgrade-to-v2-jwt-removal.md`](upgrade-to-v2-jwt-removal.md) if you previously set it.)
-
-For deployments that need JWT/OIDC/mTLS, the standard pattern is to put an authenticating gateway in front of certctl and configure `CERTCTL_AUTH_TYPE=none` on the upstream certctl process. The gateway terminates the federated identity protocol, validates tokens / certificates / SAML assertions, and proxies the authenticated request to certctl as a same-origin call on a private network. This separation gives operators the full breadth of the modern identity ecosystem (oauth2-proxy, Envoy `ext_authz`, Traefik `ForwardAuth`, Pomerium, Authelia, Caddy `forward_auth`, Apache `mod_auth_openidc`, nginx `auth_request`) without certctl itself having to track signing-key rotation, claim mapping, audience validation, and the rest of the JWT/OIDC surface area. Operators wanting per-request actor attribution past the gateway boundary forward the gateway-resolved identity (e.g., `X-Auth-Request-User` from oauth2-proxy) and run a small authorization layer at the gateway that enforces the bearer-key contract certctl actually uses.
-
 ### Concurrency Safety
 
-The background scheduler uses `sync/atomic.Bool` idempotency guards on every loop (9 always-on plus up to 5 opt-in) — if a tick fires while the previous iteration is still running, it skips. A `sync.WaitGroup` tracks all in-flight goroutines. `WaitForCompletion(timeout)` blocks during shutdown until all work finishes or the timeout expires, preventing state corruption from mid-flight database operations during process exit.
-
-The job-processor tick fans the per-job work out across up to `CERTCTL_RENEWAL_CONCURRENCY` goroutines (default 25), gated by `golang.org/x/sync/semaphore.Weighted`. The cap is the operator's lever for "how many concurrent CA calls per scheduler tick" — operators with permissive upstream limits and large fleets (>10k certs) can bump to 100; operators with strict limits or async-CA-heavy fleets should stay at 25 or lower. Values ≤ 0 normalise to 1 (sequential). The Acquire is ctx-aware so a shutdown-driven ctx cancel interrupts the dispatch loop promptly; in-flight goroutines drain via Wait before the tick returns. Closes the #9 acquisition-readiness blocker from the 2026-05-01 issuer coverage audit (pre-fix the fan-out had no cap, so a 5,000-cert sweep tripped DigiCert / Entrust / Sectigo rate limits and the next tick re-fanned-out the same calls).
+The background scheduler uses `sync/atomic.Bool` idempotency guards on every loop (8 always-on plus up to 4 optional) — if a tick fires while the previous iteration is still running, it skips. A `sync.WaitGroup` tracks all in-flight goroutines. `WaitForCompletion(timeout)` blocks during shutdown until all work finishes or the timeout expires, preventing state corruption from mid-flight database operations during process exit.
 
 ### Logging
 
@@ -1065,15 +915,7 @@ All endpoints are under `/api/v1/` and follow consistent patterns:
 
 Resources: certificates, issuers, targets, agents, jobs, policies, profiles, teams, owners, agent-groups, audit, notifications, discovered-certificates, discovery-scans, network-scan-targets, stats, metrics.
 
-The full API is documented in an OpenAPI 3.1 specification at `api/openapi.yaml`. The router-vs-spec parity is pinned by the `TestRouter_OpenAPIParity` regression test (Bundle D / M-027), which AST-walks `internal/api/router/router.go` for every `r.Register` AND direct `r.mux.Handle` registration and asserts the set matches the spec's `paths:` block exactly. Live counts:
-
-```
-grep -cE 'r\.Register\("[A-Z]' internal/api/router/router.go    # r.Register sites
-grep -cE 'r\.mux\.Handle\("[A-Z]' internal/api/router/router.go # r.mux.Handle sites (auth-exempt: health/ready/auth-info/version)
-grep -cE '^\s+operationId:' api/openapi.yaml                   # documented operations
-```
-
-See the [OpenAPI Guide](openapi.md) for usage with Swagger UI and SDK generation.
+The full API is documented in an OpenAPI 3.1 specification at `api/openapi.yaml` with 97 operations across `/api/v1/` and `/.well-known/est/` (includes auth, 7 discovery endpoints, 6 network scan endpoints, Prometheus metrics, 4 EST enrollment endpoints, 2 digest endpoints, 2 verification endpoints, 2 export endpoints), all request/response schemas, and pagination conventions. The server also registers `/health` and `/ready` outside the OpenAPI spec, bringing the total route count to 107. See the [OpenAPI Guide](openapi.md) for usage with Swagger UI and SDK generation.
 
 Jobs support additional action endpoints: `POST /api/v1/jobs/{id}/cancel`, `POST /api/v1/jobs/{id}/approve`, `POST /api/v1/jobs/{id}/reject`.
 
@@ -1088,7 +930,7 @@ Jobs support additional action endpoints: `POST /api/v1/jobs/{id}/cancel`, `POST
 - **Additional filters**: `?agent_id=`, `?profile_id=` (in addition to existing status, environment, owner_id, team_id, issuer_id).
 - **Deployments**: `GET /api/v1/certificates/{id}/deployments` returns deployment targets for a certificate.
 
-Certificate revocation: `POST /api/v1/certificates/{id}/revoke` with optional `{"reason": "keyCompromise"}`. Supports RFC 5280 reason codes (unspecified, keyCompromise, caCompromise, affiliationChanged, superseded, cessationOfOperation, certificateHold, privilegeWithdrawn). Returns the updated certificate status. Best-effort issuer notification — the revocation succeeds even if the issuer connector is unavailable. The DER-encoded X.509 CRL signed by the issuing CA is served unauthenticated at `GET /.well-known/pki/crl/{issuer_id}` (RFC 5280 §5 + RFC 8615, `Content-Type: application/pkix-crl`); the CRL is pre-generated by the scheduler-driven `crlGenerationLoop` and persisted in the `crl_cache` table (migration 000019) so HTTP fetches do not rebuild per request. The embedded OCSP responder serves signed responses unauthenticated at both `GET /.well-known/pki/ocsp/{issuer_id}/{serial}` and `POST /.well-known/pki/ocsp/{issuer_id}` (RFC 6960 §A.1.1, `Content-Type: application/ocsp-response`); responses are signed by a per-issuer dedicated OCSP responder cert (RFC 6960 §2.6, migration 000020) carrying the `id-pkix-ocsp-nocheck` extension (RFC 6960 §4.2.2.2.1) — the CA private key is never used directly for OCSP signing, which keeps it cold for the future PKCS#11/HSM driver path. The responder cert auto-rotates within `CERTCTL_OCSP_RESPONDER_ROTATION_GRACE` (default 7d) of expiry. Both endpoints are accessible to relying parties with no certctl API credentials, as RFC-compliant PKI consumers expect. Short-lived certificates (profile TTL < 1 hour) are exempt from CRL/OCSP — expiry is sufficient revocation. See [`crl-ocsp.md`](crl-ocsp.md) for the operator + relying-party guide (endpoint URLs, configuration knobs, responder cert lifecycle, cert-manager / Firefox / OpenSSL / Intune integration recipes, troubleshooting).
+Certificate revocation: `POST /api/v1/certificates/{id}/revoke` with optional `{"reason": "keyCompromise"}`. Supports RFC 5280 reason codes (unspecified, keyCompromise, caCompromise, affiliationChanged, superseded, cessationOfOperation, certificateHold, privilegeWithdrawn). Returns the updated certificate status. Best-effort issuer notification — the revocation succeeds even if the issuer connector is unavailable. The DER-encoded X.509 CRL signed by the issuing CA is served unauthenticated at `GET /.well-known/pki/crl/{issuer_id}` (RFC 5280 §5 + RFC 8615, `Content-Type: application/pkix-crl`). The embedded OCSP responder serves signed responses unauthenticated at `GET /.well-known/pki/ocsp/{issuer_id}/{serial}` (RFC 6960, `Content-Type: application/ocsp-response`). Both endpoints are accessible to relying parties with no certctl API credentials, as RFC-compliant PKI consumers expect. Short-lived certificates (profile TTL < 1 hour) are exempt from CRL/OCSP — expiry is sufficient revocation.
 
 Certificate export (M27): `GET /api/v1/certificates/{id}/export/pem` returns PEM-encoded certificate and chain, and `POST /api/v1/certificates/{id}/export/pkcs12` returns a PKCS#12 bundle (binary). Private keys are never exported — they remain on agents. All exports are audited with actor, timestamp, and format.
 
@@ -1096,11 +938,11 @@ Health checks live outside the API prefix: `GET /health` and `GET /ready`.
 
 ## MCP Server
 
-certctl includes an MCP (Model Context Protocol) server as a separate binary (`cmd/mcp-server/`) that enables AI assistants to interact with the certificate platform. The MCP server uses the official MCP Go SDK (`modelcontextprotocol/go-sdk`) with stdio transport for integration with any MCP-compatible AI client.
+certctl includes an MCP (Model Context Protocol) server as a separate binary (`cmd/mcp-server/`) that enables AI assistants to interact with the certificate platform. The MCP server uses the official MCP Go SDK (`modelcontextprotocol/go-sdk`) with stdio transport for integration with Claude, Cursor, and other MCP-compatible tools.
 
 ```mermaid
 flowchart LR
-    AI["AI Assistant\n(any MCP client)"] -->|"stdio"| MCP["MCP Server\ncmd/mcp-server/"]
+    AI["AI Assistant\n(Claude, Cursor)"] -->|"stdio"| MCP["MCP Server\ncmd/mcp-server/"]
     MCP -->|"HTTP + Bearer token"| API["certctl REST API\n:8443"]
 
     subgraph "MCP Tools"
@@ -1250,7 +1092,7 @@ flowchart TB
 
 1. **Pluggable sources** — Each cloud provider implements the `DiscoverySource` interface (Name, Type, Discover, ValidateConfig). Three built-in sources: AWS Secrets Manager, Azure Key Vault, GCP Secret Manager
 2. **CloudDiscoveryService orchestrator** — Iterates registered sources, calls `Discover()` on each, feeds reports into `ProcessDiscoveryReport()`. Errors from one source don't prevent other sources from running
-3. **Scheduler integration** — opt-in cloud discovery scheduler loop (6h default; one of the 14 loops in the scheduler topology — see the Background Scheduler section above), runs immediately on startup, `atomic.Bool` idempotency guard
+3. **Scheduler integration** — opt-in cloud discovery scheduler loop (6h default; see `docs/architecture.md` 12-loop topology), runs immediately on startup, `atomic.Bool` idempotency guard
 4. **Sentinel agents** — Each source uses its own sentinel agent ID (`cloud-aws-sm`, `cloud-azure-kv`, `cloud-gcp-sm`) for dedup and triage filtering
 5. **Source path format** — `aws-sm://{region}/{secret}`, `azure-kv://{cert-name}/{version}`, `gcp-sm://{project}/{secret}`
 6. **No new schema** — Reuses existing `discovered_certificates` and `discovery_scans` tables. Sentinel agent IDs leverage existing `(fingerprint_sha256, agent_id, source_path)` dedup constraint
@@ -1264,7 +1106,7 @@ flowchart TB
    - **Claims it** via `POST /discovered-certificates/{id}/claim` — links to existing managed cert or creates new enrollment
    - **Dismisses it** via `POST /discovered-certificates/{id}/dismiss` — removes from triage, marked as "Dismissed"
 9. **Status tracking** — `discovery_cert_claimed` and `discovery_cert_dismissed` events audit the operator's decision
-10. **Summary** — `GET /api/v1/discovery-summary` returns count of Unmanaged, Managed, and Dismissed certs (useful for inventory reporting)
+10. **Summary** — `GET /api/v1/discovery-summary` returns count of Unmanaged, Managed, and Dismissed certs (useful for compliance reporting)
 
 This data flow is pull-based and non-blocking. Agents discover at their own pace; the server stores results for later review. There's no pressure to claim or dismiss; operators can leave certificates in "Unmanaged" status indefinitely.
 
@@ -1316,22 +1158,13 @@ certctl is extensively tested across eight layers with CI-enforced coverage gate
 
 For detailed test procedures, smoke tests, and the release sign-off checklist, see the [Testing Guide](testing-guide.md). For setting up the Docker Compose test environment with real CA backends, see [Test Environment](test-env.md).
 
-## Performance Characteristics
-
-Closes the #8 acquisition-readiness blocker from the 2026-05-01 issuer coverage audit. Pre-audit, certctl had no benchmarks or load tests for any API path, so any throughput claim was hand-waved; the harness in `deploy/test/loadtest/` substantiates the API-tier capacity numbers with reproducible methodology.
-
-The harness drives a k6 client at sustained 50 req/s × 2 scenarios × 5 minutes against a docker-compose stack of postgres + tls-init + certctl-server. Two scenarios run in parallel: `POST /api/v1/certificates` (issuance-acceptance hot path: auth + JSON decode + validation + service `CreateCertificate` + `managed_certificates` insert) and `GET /api/v1/certificates?per_page=50` (most-trafficked read endpoint). Hard regression-guard thresholds: p99 < 5 s for issuance-acceptance, p99 < 2 s for list, error rate < 1% globally. k6 exits non-zero on any threshold breach so a future PR that pushes p99 above the bar fails `make loadtest`. Run via `make loadtest` from the repo root or via `.github/workflows/loadtest.yml` (`workflow_dispatch` + weekly cron — never per-push).
-
-What this measures vs what it does NOT: the harness intentionally measures the API tier (auth → DB), not the issuer connector round-trip latency. Connector calls (DigiCert, ACME, Vault, AWS ACM PCA, etc.) happen asynchronously through the renewal scheduler and are pinned by the `certctl_issuance_duration_seconds{issuer_type=...}` Prometheus histogram (audit fix #4 from the same audit). Driving them through k6 would amount to load-testing someone else's API, which is the wrong thing to do. The full ACME enrollment flow (multi-RTT order/challenge/finalize against pebble) is deferred — sustained 100/s through that flow needs pebble tuning + crypto helpers k6 doesn't ship out of the box.
-
-Captured baseline numbers are committed in `deploy/test/loadtest/README.md` once an operator runs the harness on a representative workstation; future tuning commits land alongside refreshed baseline numbers so each commit's impact is diffable. Operators considering certctl for a 50k-cert fleet at 47-day TLS rotation (CA/B Forum SC-081v3, lands 2029) have a published number with documented methodology to compare against, not a claim.
-
 ## What's Next
 
-- [Quick Start](../getting-started/quickstart.md) — Get certctl running locally
-- [Advanced Demo](../getting-started/advanced-demo.md) — Issue a certificate end-to-end
-- [Connector Guide](connectors/index.md) — Build custom connectors
+- [Quick Start](quickstart.md) — Get certctl running locally
+- [Advanced Demo](demo-advanced.md) — Issue a certificate end-to-end
+- [Connector Guide](connectors.md) — Build custom connectors
+- [Compliance Mapping](compliance.md) — SOC 2, PCI-DSS 4.0, and NIST SP 800-57 alignment
 - [MCP Server Guide](mcp.md) — AI-native access to the API
-- [API Reference](api.md) — OpenAPI 3.1 spec and SDK generation
-- [QA Test Suite](../contributor/qa-test-suite.md) — Test procedures and release sign-off
-- [Test Environment](../contributor/test-environment.md) — Docker Compose test environment setup
+- [OpenAPI Spec](openapi.md) — Full API reference and SDK generation
+- [Testing Guide](testing-guide.md) — Test procedures and release sign-off
+- [Test Environment](test-env.md) — Docker Compose test environment setup

docs/archive/upgrades/to-v2-jwt-removal.md

@@ -1,164 +0,0 @@
-# Upgrading past G-1 — `CERTCTL_AUTH_TYPE=jwt` removal
-
-> Last reviewed: 2026-05-05
-
-> **Archived 2026-05-05.** This upgrade guide applies to operators
-> upgrading past the G-1 milestone (the `CERTCTL_AUTH_TYPE=jwt` removal).
-> Current operators on post-G-1 releases don't need this. For the
-> steady-state security posture reference, see
-> [`docs/operator/security.md`](../../operator/security.md). Preserved
-> here for late upgraders.
-
-If your certctl deployment currently sets `CERTCTL_AUTH_TYPE=jwt` (or `server.auth.type=jwt` in Helm), the next certctl upgrade will fail-fast at startup with a dedicated diagnostic. This guide explains why, what to switch to, and how to keep JWT/OIDC at your edge.
-
-For everyone else — operators running `api-key` or `none` — this upgrade is a no-op. Skip to [`to-tls-v2.2.md`](to-tls-v2.2.md) for the v2.2 HTTPS-everywhere migration if you haven't done that one yet.
-
-## Why we removed it
-
-Pre-G-1, the config validator at `internal/config/config.go` accepted three values for `CERTCTL_AUTH_TYPE`: `api-key`, `jwt`, and `none`. The startup log line at `cmd/server/main.go` faithfully echoed `"authentication enabled" "type"="jwt"` when an operator picked `jwt`. Reasonable people read that and concluded JWT auth was on.
-
-It wasn't. Grep `internal/ cmd/` for `NewJWT`, `JWTMiddleware`, or `jwt.Parse` — pre-G-1, there were zero matches in production code. The auth-middleware wiring at `cmd/server/main.go:653` unconditionally called `middleware.NewAuthWithNamedKeys(namedKeys)` regardless of `cfg.Auth.Type`. So `CERTCTL_AUTH_TYPE=jwt` just routed every request through the api-key bearer middleware, comparing the incoming `Authorization: Bearer <something>` against whatever string the operator put in `CERTCTL_AUTH_SECRET`. Real JWT clients got 401 (the api-key middleware saw the JWT string as a literal token and compared bytes). Operators who treated `CERTCTL_AUTH_SECRET` as a JWT signing secret (and therefore handled it less carefully than an api-key) handed an attacker an api-key. Silent auth downgrade — a security finding masquerading as a config option.
-
-We chose to remove the option rather than implement JWT middleware. Implementing real JWT/OIDC requires jwks vs static-secret rotation, claim mapping (which claim is the actor / the admin flag?), expiry enforcement, audience and issuer validation, key rollover semantics, and regression coverage at the same depth as the existing api-key path. That's a feature, not a fix. The audit-recommended structural fix — and the one that actually closes the hazard — is to fail loudly instead of silently downgrading.
-
-## What changes at startup
-
-Post-G-1, a binary started with `CERTCTL_AUTH_TYPE=jwt` exits non-zero before opening the listener:
-
-```
-Failed to load configuration: CERTCTL_AUTH_TYPE=jwt is no longer accepted
-(G-1 silent auth downgrade): no JWT middleware ships with certctl. To use
-JWT/OIDC, run an authenticating gateway (oauth2-proxy / Envoy ext_authz /
-Traefik ForwardAuth / Pomerium) in front of certctl and set
-CERTCTL_AUTH_TYPE=none on the upstream. See docs/architecture.md
-"Authenticating-gateway pattern" and docs/upgrade-to-v2-jwt-removal.md
-for the migration walkthrough
-```
-
-Helm operators get the same shape at `helm install` / `helm upgrade` template time: `server.auth.type=jwt` is rejected by the chart's `certctl.validateAuthType` template helper before any Kubernetes object is rendered.
-
-The CI-side regression guard at `.github/workflows/ci.yml` blocks any future PR that re-introduces `"jwt"` as an auth-type literal in production code or spec.
-
-## Recovery — pick one
-
-### Option A — switch to `api-key` (you weren't actually using JWT)
-
-If your `CERTCTL_AUTH_SECRET` was a single high-entropy token and your clients sent it as `Authorization: Bearer <token>`, you were already using api-key auth — you just had `CERTCTL_AUTH_TYPE` set to the wrong string. Flip it:
-
-```
-# .env (docker-compose)
-CERTCTL_AUTH_TYPE=api-key
-CERTCTL_AUTH_SECRET=<your-existing-token>
-```
-
-```
-# Helm
-helm upgrade <release> deploy/helm/certctl/ \
-  --reuse-values \
-  --set server.auth.type=api-key \
-  --set server.auth.apiKey=<your-existing-token>
-```
-
-No client changes needed — the same Bearer token continues to work. The startup log will now read `"authentication enabled" "type"="api-key"`, which matches what was actually happening pre-G-1.
-
-### Option B — front certctl with an authenticating gateway
-
-If you genuinely need JWT, OIDC, mTLS, or SAML, run an authenticating gateway in front of certctl and let the gateway terminate the federated identity protocol. Configure certctl for `CERTCTL_AUTH_TYPE=none`:
-
-```
-CERTCTL_AUTH_TYPE=none
-```
-
-Then put an oauth2-proxy / Envoy `ext_authz` / Traefik `ForwardAuth` / Pomerium / Authelia (etc.) in the network path between operators and certctl. The gateway validates the identity and proxies the authenticated request to certctl as a same-origin call on a private network.
-
-### Concrete walkthrough — oauth2-proxy + certctl on docker-compose
-
-This is the simplest production-grade JWT/OIDC shape. It assumes you have an OIDC provider (Okta, Auth0, Google Workspace, Keycloak, Dex) and a registered client_id / client_secret.
-
-```yaml
-# deploy/docker-compose.gateway.yml — overlay on the base compose file
-services:
-  oauth2-proxy:
-    image: quay.io/oauth2-proxy/oauth2-proxy:latest
-    command:
-      - --provider=oidc
-      - --oidc-issuer-url=https://<your-issuer>/
-      - --client-id=${OIDC_CLIENT_ID}
-      - --client-secret=${OIDC_CLIENT_SECRET}
-      - --cookie-secret=${OAUTH2_PROXY_COOKIE_SECRET}  # openssl rand -base64 32
-      - --upstream=http://certctl-server:8443  # internal-network only; certctl listens on 8443
-      - --http-address=0.0.0.0:4180
-      - --email-domain=*
-      - --pass-access-token=true
-      - --pass-authorization-header=true
-      - --set-authorization-header=true       # forwards a bearer token upstream
-      - --skip-provider-button=true
-      - --reverse-proxy=true
-    ports:
-      - "443:4180"
-    depends_on:
-      - certctl-server
-    networks:
-      - certctl-network
-
-  certctl-server:
-    environment:
-      CERTCTL_AUTH_TYPE: none   # gateway terminates auth — see docs/upgrade-to-v2-jwt-removal.md
-      # ... rest of the certctl env block unchanged
-```
-
-Operators hit `https://<your-host>/`, get redirected through the OIDC provider, land back at oauth2-proxy with a session cookie, and oauth2-proxy proxies their request to certctl on the internal Docker network. certctl itself is HTTPS-only on `:8443` (TLS 1.3, see [`tls.md`](../../operator/tls.md)) but operator browsers never see that hop directly. Bind certctl-server's `:8443` to the internal Docker network only — do NOT publish it to the host. The audit trail will record the actor as the gateway-forwarded identity if you also configure a small bearer-token-mapping shim at the gateway (most production deployments do this with a per-user api-key issued by the gateway after OIDC validation).
-
-### Traefik ForwardAuth pattern (Kubernetes)
-
-Same shape, kubernetes-flavored:
-
-```yaml
-apiVersion: traefik.io/v1alpha1
-kind: Middleware
-metadata:
-  name: oidc-forward-auth
-spec:
-  forwardAuth:
-    address: http://oauth2-proxy.auth.svc.cluster.local:4180
-    trustForwardHeader: true
-    authResponseHeaders:
-      - X-Auth-Request-User
-      - X-Auth-Request-Email
-      - Authorization
----
-apiVersion: traefik.io/v1alpha1
-kind: IngressRoute
-metadata:
-  name: certctl
-spec:
-  routes:
-    - match: Host(`certctl.example.com`)
-      kind: Rule
-      middlewares:
-        - name: oidc-forward-auth
-      services:
-        - name: certctl-server
-          port: 8443
-```
-
-The certctl Helm release runs with `server.auth.type=none`. The Traefik IngressRoute attaches `oidc-forward-auth` as a middleware so every request is OIDC-validated by oauth2-proxy before reaching certctl.
-
-### Envoy `ext_authz` pattern
-
-For service-mesh deployments (Istio, Consul, plain Envoy), the `ext_authz` filter calls out to an external authorization service per-request. Same outcome: certctl runs `CERTCTL_AUTH_TYPE=none` and Envoy + your authz service handle JWT/OIDC/mTLS at the mesh edge. See the [Envoy ext_authz docs](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/ext_authz_filter) for the configuration surface.
-
-## Rollback
-
-Pre-G-1 binaries silently accepted `CERTCTL_AUTH_TYPE=jwt` and routed through the api-key middleware. Downgrading the binary is the only mechanical rollback path, and it puts you back into the silent-downgrade state — which is exactly what the G-1 audit finding is about. We don't recommend it. If something is forcing your hand, capture the operational issue you're hitting and open a GitHub issue against the certctl repo with the SHAs involved; the Authenticating-gateway pattern was specifically designed to cover the use cases that historically led operators to set `CERTCTL_AUTH_TYPE=jwt`.
-
-There is no on-disk state that changes with this upgrade — no migrations to roll back, no encrypted config to re-encode, no certificates to re-issue. The change is entirely in the config-validation surface and the helm-chart template guard.
-
-## Cross-references
-
-- [`architecture.md`](../../reference/architecture.md) — "Authenticating-gateway pattern (JWT, OIDC, mTLS)" section.
-- [`tls.md`](../../operator/tls.md) — TLS provisioning patterns. The gateway proxying to certctl-server still needs to trust certctl's TLS cert; same patterns apply.
-- [`../deploy/helm/certctl/README.md`](../deploy/helm/certctl/README.md) — Helm-chart-flavored guidance.
-- `internal/config/config.go::ValidAuthTypes` — the single source of truth for what's accepted post-G-1.
-- `internal/repository/postgres/db.go::wrapPingError` — unrelated; pattern for runtime diagnostic of operator misconfiguration.
-- `coverage-gap-audit-2026-04-24-v5/unified-audit.md` — the audit finding (`cat-g-jwt_silent_auth_downgrade`).