infra: observability, backups, guardrails, and deployment hardening (#1376)

* docs: add infrastructure roadmap plan

Records the verified recommendations from an infrastructure review in three
tracks: raising the single-instance ceiling, cheap seams for a possible
multi-instance future, and ops hygiene. Includes explicit anti-recommendations
and sequencing. Security-sensitive detail is intentionally excluded per
docs/security.md.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* feat(server): real health checks and saturation metrics

/api/v1/metrics now exposes signals that were already computed in memory but
never surfaced: reconnect replay tier hits, event-persister counters, SQLite
writer-pool wait stats, aggregate per-client backpressure counters (including
previously invisible low-priority drops), and permission-cache hit/miss.

/health now returns a real verdict: hub dispatch-loop liveness, a bounded
database ping, and a free-disk check, returning 503 with a subsystem reason
when degraded. Checks are cached so the unauthenticated endpoint cannot
amplify load. The hub's panic breaker now exits the process so a supervisor
can restart it, instead of leaving broadcast delivery silently dead while
clients still appear online.

OTel instruments that were declared but never recorded are now wired
(ws_active_connections, ws_broadcast_latency_seconds, ws_messages_total,
ws_events_dropped_total, voice gauges) or removed (db_query_duration_seconds).
Also corrects the docs/api.md description of broadcast_drops, which counts
hub-queue overflow, not client send-queue overflow.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* feat(server): implement scheduled backups, retention, and backup verification

The backup_schedule and backup_retention settings have existed in the admin
panel and API since the initial schema but were never read by any code. The
15-minute maintenance loop now enforces them: a scheduled backup is taken
when the newest backup on disk is older than the schedule interval (manual
backups reset the clock), and retention prunes backups older than the
configured days while always keeping the newest one.

Backups are now verified with PRAGMA integrity_check immediately after
VACUUM INTO (a failed backup is removed rather than listed as restorable)
and again before a restore may overwrite the live database. A failed VACUUM
INTO also cleans up its partial output file — but never a pre-existing one.

The backup directory is configurable via a new backup.dir key (default
data/backups) so operators can point backups at another disk or an off-host
mount, mirroring the SetDatabasePath plumb.

Restore-handler tests now use real SQLite fixtures (the integrity gate
correctly refuses text files) with the mid-copy failure injected through a
test-only copy hook. Also adds audited gosec suppressions to the Windows
disk-free syscall added in the previous commit, which the Windows lint leg
flagged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* feat(server): capacity and failure-mode guardrails

- server.max_ws_connections: optional cap on concurrent WebSocket clients,
  checked before the upgrade with a 503 + Retry-After; rejections are counted
  and exposed as ws_conn_rejects in /api/v1/metrics.
- Single-process database lock: an OS-level advisory lock (flock / exclusive
  handle) beside the SQLite file makes a second server process fail fast with
  a clear message instead of silently fighting the first over process-local
  state. A bounded retry covers the self-update/restore restart handoff, and
  the lock mechanism failing (e.g. network filesystems) only warns.
- Disk-space awareness: boot-time warnings for the data and backup volumes,
  plus a disk_free_mb metrics field, via a small cross-platform diskutil
  package (already used by /health).
- Upload storage failures: storage.Save now marks server-side filesystem
  failures with a sentinel (storage.ErrIO); handlers return 507 for those
  instead of blaming the client with a 400, and the emoji route stops echoing
  raw storage errors (which embed absolute paths) into responses.
- Unknown config keys now warn at startup — a typo like admin_alowed_cidrs
  previously kept the default silently while the operator believed the
  setting changed. Never fatal: newer servers tolerate older configs.
- Admin settings honesty: the three stored-but-inert settings (server_icon,
  max_upload_bytes, voice_quality) are shown read-only with a note pointing
  at the real config.yaml keys, instead of pretending to apply.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* perf(db): write-path efficiency and capacity knobs

- channel_focus/mark_read now skip the read-state UPSERT when the stored row
  already matches (same last_message_id, no mentions) — refocus events fire
  at up to 10/s/user and every no-op write still occupied the single SQLite
  writer connection. The extra existence check runs on the reader pool, which
  doesn't serialize. Same shape as the session-touch throttle.
- DeleteExpiredSessions is now sargable: migration 031 normalizes legacy
  expiry formats to the RFC3339-Z layout the server writes and indexes
  expires_at, replacing the strftime full-table scan that ran on the writer
  every 15 minutes.
- Boot-time ANALYZE runs only when a migration actually applied; unchanged
  schemas get the cheap PRAGMA optimize instead (which also covers
  crash-restarts that never reached the shutdown optimize).
- The read/write SQL router gets a table-driven test with explicit expected
  values (INSERT ... RETURNING must hit the writer despite being :one).
- New knobs, all defaulting to current behavior: database.max_readers,
  security.auth_rate_limit_multiplier (for shared-NAT communities),
  event_persistence.replay_ring_size and replay_cold_limit.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* fix(server): shutdown lifecycle ordering

- The event pruner and maintenance loop are now joined (bounded) before the
  database closes: bgCtx cancellation used to run AFTER database.Close via
  LIFO defers, contradicting its own comment, and neither goroutine was ever
  waited on — a mid-tick scheduled backup or prune could still hold the
  writer while the pool tore down. StartEventPruner returns a done channel
  with the same join contract EventPersister.Stop already had.
- srv.Shutdown now runs before hub.GracefulStop, so in-flight HTTP handlers'
  broadcasts still reach a live hub and the event persister instead of
  vanishing from the replay/event store across a restart. Shutdown does not
  wait on hijacked WebSocket connections, so the swap adds no delay.
- GracefulStopContext threads the 30s shutdown budget into the hub: the 5s
  client-notice window (matching the countdown clients are shown) ends early
  when the budget expires, and is skipped entirely when nobody is connected —
  early-return startup paths and idle servers no longer sleep 5s for an
  audience of zero.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* build(deploy): systemd unit, compose hardening, boot-smoked releases, CI polish

- deploy/owncord.service: hardened systemd unit template with the two
  verified caveats encoded (install dir stays writable for self-update under
  ProtectSystem=strict; CAP_NET_BIND_SERVICE for ACME's :80), plus a
  'Linux (systemd)' deployment docs section — the Linux service story was
  previously 'Docker or nothing'.
- New 'Reverse Proxy Topology' docs section with a working nginx snippet and
  the correct signaling-vs-media distinction: /livekit/* is already proxied
  by the server, only WebRTC media ports must be directly reachable.
- docker-compose: log rotation, commented resource limits, and a healthcheck
  backed by a new 'chatserver healthcheck' subcommand (the distroless image
  has no shell) that probes /health without config side effects.
- release.yml: a concurrency group (queue, never cancel), and boot-smoke
  gates — the freshly built server binaries and the Docker image are cold
  booted and probed healthy BEFORE anything is signed or pushed. The release
  feed drives signed self-updates, so a binary that compiles but dies on
  boot previously would have shipped itself to every auto-updating instance.
- ci.yml: client-check/client-tests move to ubuntu with the reasoning
  recorded (no win32 code paths, LF enforced repo-wide); admin-e2e gets a
  written graduation criterion instead of an open-ended non-blocking status.
- docs: Tailscale guide notes the CGNAT range vs the default admin CIDRs;
  architecture overview records presence/voice state as the fifth
  single-instance blocker and the macOS client scope decision.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* perf(server): measured load tooling, narrowed invalidation, presence coalescing, storage and CIDR seams

- Fix scripts/k6/ws-load.js against the real wire protocol: envelope-wrapped
  frames, correct message types (typing_start, presence_update), the correct
  /api/v1/ws path, and thresholds that fail a run where nobody authenticated
  or went ready — the script had drifted to pre-envelope framing and reported
  100% green while every auth failed on the first frame. A new
  workflow_dispatch-only load-baseline workflow boots a real server, seeds
  users through the setup/invite APIs, runs the script, and uploads the k6
  summary plus a metrics snapshot for before/after comparison.
- Role-scoped channel-override changes now evict only the affected role's
  members from the permission cache (fail-safe: unreadable member list still
  flushes everything). InvalidateAll here repopulated every connected user —
  two reads each — synchronously inside the admin request via
  RefreshChannelVisibility, a stampede that scaled with total population
  rather than the role's size. Same pattern the per-user override endpoints
  already used.
- Connect/disconnect presence broadcasts now pass through a 300ms latest-wins
  coalescer (QueuePresence): each un-coalesced presence change is a sequenced
  global broadcast (an O(clients) fan-out under seqMu), so a reconnect storm
  fired O(users) of them from the connect critical path. A flap inside the
  window collapses to its final state; the wire format, seq ordering, and
  replay behaviour are unchanged, and the delivery path (BroadcastPresence)
  is untouched.
- Storage seam: api handlers now consume a FileStore interface (consumer-side,
  same pattern as service.Store) with Open returning a seekable storage.File —
  writing down the contract (range-request seeks included) an alternative
  backend would have to meet, without building one.
- The metrics surfaces and the LiveKit webhook/health endpoints get their own
  allowlist keys (metrics_allowed_cidrs, livekit_webhook_allowed_cidrs, both
  defaulting to admin_allowed_cidrs), so a central Prometheus scraper or an
  externally-hosted LiveKit no longer requires widening the admin panel's
  perimeter. Startup now also warns when admin_allowed_cidrs is customized
  while trusted_proxies is empty — behind a proxy or container network the
  check would otherwise compare the proxy's private address, not the client's.
- The container healthcheck probe now PINS the server's own certificate from
  disk (VerifyConnection, exact-match) instead of skipping TLS verification,
  addressing the CodeQL finding on the previous commit; WebPKI verification
  is used when no local cert exists (ACME).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* fix(server): address self-review findings on the hardening branch

Seven fixes from a high-effort review of the full branch diff:

- healthcheck CLI now works under tls.mode acme: it overrides ServerName
  with the configured domain for WebPKI verification instead of pinning a
  cert that doesn't exist (or is stale) in that mode. Previously an ACME
  deployment's container healthcheck failed forever.
- /health pings the READER pool (new db.PingRead): the writer ping queued
  behind a scheduled backup's VACUUM INTO and reported the server degraded
  for the whole backup — which an autoheal watchdog would turn into a
  nightly mid-backup restart.
- /health runs its cached checks under context.WithoutCancel so a probe
  that disconnects mid-request cannot poison the shared cache with a false
  degraded verdict for the next 5 seconds.
- The token CLI uses a new db.OpenShared that skips the single-process
  lock: minting a token against a running server is safe under WAL and was
  a documented workflow the lock had broken.
- The per-user TOTP failure cap is no longer scaled by
  security.auth_rate_limit_multiplier — that knob exists for per-IP limits;
  scaling the only cross-IP brute-force defence multiplied an attacker's
  distributed guess budget. Mirrors the unscaled per-user login threshold.
- A direct presence_update now drops the user's queued entry in the
  connect/disconnect coalescer, so a stale connect-time presence can no
  longer flush 300ms later over the user's fresher chosen status.
- The scheduled-backup filename collision loop breaks on any stat error
  and bounds its suffix probing, instead of spinning the maintenance
  goroutine forever on a persistent EACCES.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

* test(admin): real SQLite fixture for the merged Close-failure restore test

TestHandleRestoreBackup_RestartsWhenCloseFails arrived from main (#1375)
with a plain-text backup fixture; this branch's restore handler verifies
backups with integrity_check before touching the live database, so the text
fixture was (correctly) refused with 400 before the Close-failure branch
under test was reached. Use a real backup via BackupToSafe, matching the
other restore tests.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RtDNHSYWwPKArL8MsRdbj

---------

Co-authored-by: Claude <noreply@anthropic.com>

.github/workflows/ci.yml

@@ -109,9 +109,14 @@ jobs:
           working-directory: Server/
           verify: false
 
+  # ubuntu-latest deliberately: the client TS code has zero win32-conditional
+  # paths (no process.platform / path.sep branches in src or the unit suites),
+  # prettier pins endOfLine: lf and .gitattributes forces eol=lf, so a Windows
+  # runner adds queue time without adding coverage. Windows-specific behavior
+  # is covered where it exists: rust-tests and the tauri-build matrix.
   client-check:
     name: Client Static Checks
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
     defaults:
       run:
         working-directory: Client/tauri-client/
@@ -165,9 +170,11 @@ jobs:
   # Unit tests live in their own job so a suite failure is visible as exactly one
   # failing check instead of masking the static gates above. The suite is GREEN
   # and must stay green — never "fix" a failing test by editing its assertions.
+  # ubuntu-latest for the same reason as client-check above: jsdom-only vitest
+  # with no platform-conditional code under test.
   client-tests:
     name: Client Unit Tests
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
     defaults:
       run:
         working-directory: Client/tauri-client/
@@ -292,6 +299,12 @@ jobs:
   # channel CRUD, audit log and re-login — the one DC-04 surface the mocked
   # suites cannot reach. Non-blocking while it earns its soak, same
   # graduation convention client-e2e followed.
+  # GRADUATION CRITERION (recorded 2026-08-15): flip continue-on-error to
+  # false once the job has ~30 consecutive green runs on main with no
+  # infra-flake reruns — the same evidence bar client-e2e cleared (270+ green
+  # runs cited in docs/audit-2026-08-04-docs-and-coverage.md) scaled to this
+  # job's lower traffic. Check with: gh run list -w CI -b main --json
+  # conclusion | jq '[.[] | .conclusion] | index("failure")'.
   admin-e2e:
     name: Admin Panel E2E (real server, non-blocking)
     runs-on: ubuntu-latest

.github/workflows/load-baseline.yml

@@ -0,0 +1,131 @@
+# Manual WebSocket load baseline against a locally booted server.
+#
+# workflow_dispatch ONLY, and deliberately not part of the blocking CI matrix:
+# a perf run on shared runners is a flake source and a wall-clock tax the
+# 10-job/~15-min pipeline doesn't need. Run it before/after changes to the
+# hub, the write path, or the replay budget, and compare the uploaded
+# k6-summary.json + metrics snapshot between runs. Runner-grade hardware is
+# NOT a capacity promise for real deployments — treat results as relative
+# (before vs after), not absolute.
+name: Load Baseline
+
+on:
+  workflow_dispatch:
+    inputs:
+      users:
+        description: "Load-test users to register (max VUs in the script is 100)"
+        required: false
+        default: "100"
+
+permissions:
+  contents: read
+
+jobs:
+  k6-baseline:
+    name: k6 WebSocket baseline
+    runs-on: ubuntu-latest
+    timeout-minutes: 25
+    steps:
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
+
+      - uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
+        with:
+          go-version: "1.26"
+          cache-dependency-path: Server/go.sum
+
+      - name: Build server
+        working-directory: Server
+        env:
+          CGO_ENABLED: "0"
+        run: go build -o chatserver .
+
+      - name: Boot server
+        working-directory: Server
+        env:
+          # Registration/login are per-IP rate limited (3/min and 5/min by
+          # default) and every VU logs in from 127.0.0.1 — scale the auth
+          # limits up with the knob that exists for shared-IP scenarios.
+          OWNCORD_SECURITY_AUTH_RATE_LIMIT_MULTIPLIER: "100"
+        run: |
+          mkdir -p "$RUNNER_TEMP/loadtest"
+          cp chatserver "$RUNNER_TEMP/loadtest/"
+          cd "$RUNNER_TEMP/loadtest"
+          ./chatserver > server.log 2>&1 &
+          echo $! > server.pid
+          for _ in $(seq 1 30); do
+            sleep 1
+            if ./chatserver healthcheck; then exit 0; fi
+          done
+          echo "::error::server never became healthy"
+          tail -50 server.log
+          exit 1
+
+      - name: Seed owner, channel, and load-test users
+        working-directory: Server
+        run: |
+          BASE=https://127.0.0.1:8443
+          TOKEN=$(curl -sk -X POST "$BASE/admin/api/setup" \
+            -H 'Content-Type: application/json' \
+            -d '{"username":"loadadmin","password":"LoadTest123!Admin"}' | jq -r .token)
+          [ -n "$TOKEN" ] && [ "$TOKEN" != "null" ] || { echo "::error::setup failed"; exit 1; }
+
+          CHANNEL_ID=$(curl -sk -X POST "$BASE/admin/api/channels" \
+            -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
+            -d '{"name":"loadtest","type":"text"}' | jq -r .id)
+          [ -n "$CHANNEL_ID" ] && [ "$CHANNEL_ID" != "null" ] || { echo "::error::channel create failed"; exit 1; }
+          echo "CHANNEL_ID=$CHANNEL_ID" >> "$GITHUB_ENV"
+          echo "ADMIN_TOKEN=$TOKEN" >> "$GITHUB_ENV"
+
+          INVITE=$(curl -sk -X POST "$BASE/api/v1/invites" \
+            -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
+            -d '{"max_uses":0}' | jq -r .code)
+          [ -n "$INVITE" ] && [ "$INVITE" != "null" ] || { echo "::error::invite create failed"; exit 1; }
+
+          USERS="${{ inputs.users }}"
+          for i in $(seq 1 "${USERS:-100}"); do
+            code=$(curl -sk -o /dev/null -w '%{http_code}' -X POST "$BASE/api/v1/auth/register" \
+              -H 'Content-Type: application/json' \
+              -d "{\"username\":\"loadtest$i\",\"password\":\"LoadTest123!\",\"invite_code\":\"$INVITE\"}")
+            if [ "$code" != "200" ] && [ "$code" != "201" ]; then
+              echo "::error::registering loadtest$i failed with $code"
+              exit 1
+            fi
+          done
+
+      - name: Install k6
+        run: |
+          curl -fsSL https://dl.k6.io/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/k6-archive-keyring.gpg
+          echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
+          sudo apt-get update -qq && sudo apt-get install -y k6
+
+      - name: Run k6 baseline
+        working-directory: Server/scripts/k6
+        env:
+          K6_WS_URL: wss://127.0.0.1:8443/api/v1/ws
+          K6_HTTP_URL: https://127.0.0.1:8443
+          K6_CHANNEL_ID: ${{ env.CHANNEL_ID }}
+        run: |
+          mkdir -p reports
+          k6 run --insecure-skip-tls-verify ws-load.js
+
+      - name: Snapshot server metrics
+        if: always()
+        run: |
+          curl -sk https://127.0.0.1:8443/api/v1/metrics | tee "$RUNNER_TEMP/loadtest/metrics-after.json" || true
+
+      - name: Stop server
+        if: always()
+        run: |
+          kill "$(cat "$RUNNER_TEMP/loadtest/server.pid")" 2>/dev/null || true
+          sleep 3
+
+      - name: Upload results
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: k6-baseline
+          path: |
+            Server/scripts/k6/reports/k6-summary.json
+            ${{ runner.temp }}/loadtest/metrics-after.json
+            ${{ runner.temp }}/loadtest/server.log
+          retention-days: 30

.github/workflows/release.yml

@@ -5,6 +5,15 @@ on:
     tags:
       - "v*"
 
+# A deleted-and-re-pushed tag (it has happened — see the checksum note in the
+# publish job) must not race two publish runs: `gh release create` fails
+# loudly on the second run, but the ghcr :latest push does not, and which run
+# wins it would be arbitrary. Queue, never cancel — a half-cancelled release
+# is worse than a slow one.
+concurrency:
+  group: release-${{ github.ref_name }}
+  cancel-in-progress: false
+
 jobs:
   # The v1.1.0-alpha.4 release shipped clients still versioned 1.1.0-alpha.3
   # because the client manifests weren't bumped before tagging — deployed
@@ -223,6 +232,40 @@ jobs:
           CGO_ENABLED: "0"
         run: go build -o chatserver -ldflags "-s -w -X main.version=$VERSION" .
 
+      # Boot-smoke the EXACT artifact that ships: this feed drives the signed
+      # self-update, so a binary that compiles but dies on boot would deploy
+      # itself to every auto-updating instance. CI's tests exercise the same
+      # commit but never this build (release ldflags, CGO_ENABLED=0) and never
+      # execute the produced binary. First run writes config.yaml, generates a
+      # self-signed cert, migrates a fresh SQLite DB — a real cold boot.
+      - name: Boot-smoke server binary
+        shell: bash
+        working-directory: Server
+        run: |
+          SMOKE_DIR="$RUNNER_TEMP/owncord-smoke"
+          mkdir -p "$SMOKE_DIR"
+          cd "$SMOKE_DIR"
+          BIN="$GITHUB_WORKSPACE/Server/chatserver"
+          [ -f "$GITHUB_WORKSPACE/Server/chatserver.exe" ] && BIN="$GITHUB_WORKSPACE/Server/chatserver.exe"
+          "$BIN" &
+          SERVER_PID=$!
+          ok=0
+          for _ in $(seq 1 30); do
+            sleep 1
+            if ! kill -0 "$SERVER_PID" 2>/dev/null; then
+              echo "::error::server process exited during boot smoke"
+              exit 1
+            fi
+            if "$BIN" healthcheck; then ok=1; break; fi
+          done
+          kill "$SERVER_PID" 2>/dev/null || true
+          wait "$SERVER_PID" 2>/dev/null || true
+          if [ "$ok" != "1" ]; then
+            echo "::error::server never reported healthy within 30s"
+            exit 1
+          fi
+          echo "boot smoke passed"
+
       - name: Create tar.gz (Linux)
         if: matrix.os == 'ubuntu-latest'
         working-directory: Server
@@ -378,6 +421,39 @@ jobs:
             type=semver,pattern={{major}}.{{minor}}
             type=raw,value=latest
 
+      # Build locally first so the image can be boot-smoked BEFORE anything
+      # is pushed — a pushed :latest that dies on boot deploys itself to every
+      # `docker compose pull` upgrade.
+      - name: Build image (local, for smoke test)
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
+        with:
+          context: Server/
+          load: true
+          build-args: VERSION=${{ env.VERSION }}
+          tags: owncord-smoke:candidate
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Boot-smoke Docker image
+        run: |
+          docker run -d --name owncord-smoke owncord-smoke:candidate
+          ok=0
+          for _ in $(seq 1 30); do
+            sleep 1
+            if [ "$(docker inspect -f '{{.State.Running}}' owncord-smoke)" != "true" ]; then
+              echo "::error::container exited during boot smoke"
+              docker logs owncord-smoke
+              exit 1
+            fi
+            if docker exec owncord-smoke /chatserver healthcheck; then ok=1; break; fi
+          done
+          docker logs owncord-smoke
+          docker rm -f owncord-smoke
+          if [ "$ok" != "1" ]; then
+            echo "::error::container never reported healthy within 30s"
+            exit 1
+          fi
+
       - name: Build and push
         uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
         with: