release: v0.50.4 [skip ci]

Co-authored-by: oblachno Admin <admin@oblachno.oblachno.fyi>

.env.example

@@ -1,6 +1,19 @@
-# Gitea API token (required for CI scripts that interact with Gitea)
+# Role-based Gitea API tokens.
+# Each token serves a specific role. For small teams the developer and CI
+# tokens may belong to the same user, but the reviewer token MUST belong to a
+# different Gitea user than the PR author so Gitea accepts approval reviews.
 # Create at: https://git.oblachno.oblachno.fyi/user/settings/applications
-CI_GITEA_TOKEN=
+
+# Developer token — used by local tooling: create-task, create-pr, setup, etc.
+DEVELOPER_GITEA_API_TOKEN=
+
+# CI token — used by CI workflows and scripts that do not post approvals.
+# Legacy CI_GITEA_TOKEN is also accepted.
+CI_GITEA_API_TOKEN=
+
+# Reviewer token — used by the auto-merge workflow to post APPROVE reviews.
+# This must be a different Gitea user from the developer/CI user.
+REVIEWER_GITEA_API_TOKEN=
 
 # Vikunja API token (required for post-merge task updates)
 # Create at: https://work.oblachno.oblachno.fyi/settings/tokens

.gitea/workflows/build-images.yml

@@ -10,9 +10,11 @@ name: Build Images
 #   to PyPI, so the image always has the latest released version.
 # - Manually via workflow_dispatch
 #
+# Consolidated into 2 jobs (from 3):
+#   build-and-push (includes release-commit detection) ──→ cleanup
+#
 # The workflow builds 3 tier images in sequence:
 #   ci-base → ci-quality → ci-full
-#
 # Each tier builds FROM the previous one, so they must be built in order.
 # After pushing, a cleanup job removes old versions (keeps last 2 + latest).
 
@@ -28,9 +30,14 @@ concurrency:
   cancel-in-progress: false
 
 jobs:
-  detect-type:
+  build-and-push:
     runs-on: docker
-    timeout-minutes: 5
+    container:
+      image: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
+      credentials:
+        username: ${{ vars.CI_GITEA_USERNAME }}
+        password: ${{ secrets.CI_GITEA_API_TOKEN }}
+    timeout-minutes: 30
     outputs:
       is-release: ${{ steps.check.outputs.is-release }}
     steps:
@@ -38,7 +45,9 @@ jobs:
         with:
           fetch-depth: 1
       - name: Set up environment
-        run: make setup-ci
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: make setup-release
       - name: Check if this is a release commit
         id: check
         env:
@@ -46,34 +55,26 @@ jobs:
         run: |
           . .venv/bin/activate
           python3 -m devx.ci.detect_release_commit
-
-  build-and-push:
-    needs: [detect-type]
-    if: >-
-      needs.detect-type.outputs.is-release == 'false' && (
-        github.event_name == 'workflow_dispatch' ||
-        (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
-      )
-    runs-on: docker
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up environment
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-        run: make setup-release
       - name: Docker registry login
+        if: >-
+          github.event_name == 'workflow_dispatch' ||
+          (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success' && steps.check.outputs.is-release == 'false')
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           CI_GITEA_USERNAME: ${{ vars.CI_GITEA_USERNAME }}
         run: |
           . .venv/bin/activate
-          echo "$CI_GITEA_TOKEN" | docker login git.oblachno.oblachno.fyi -u "$CI_GITEA_USERNAME" --password-stdin
+          _TOKEN="$CI_GITEA_API_TOKEN"
+          [ -z "$_TOKEN" ] && _TOKEN="$DEVELOPER_GITEA_API_TOKEN"
+          [ -z "$_TOKEN" ] && _TOKEN="$CI_GITEA_TOKEN"
+          if [ -z "$_TOKEN" ]; then echo "Gitea API token not set — skipping Docker login"; exit 1; fi
+          echo "$_TOKEN" | docker login git.oblachno.oblachno.fyi -u "$CI_GITEA_USERNAME" --password-stdin
       - name: Build and push tier images
+        if: >-
+          github.event_name == 'workflow_dispatch' ||
+          (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success' && steps.check.outputs.is-release == 'false')
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           CI_GITEA_USERNAME: ${{ vars.CI_GITEA_USERNAME }}
           PYTHONPATH: src
         run: |
@@ -103,7 +104,7 @@ jobs:
       - name: Notify on failure
         if: failure()
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           PYTHONPATH: src
         run: |
           . .venv/bin/activate 2>/dev/null || true
@@ -119,16 +120,23 @@ jobs:
     needs: [build-and-push]
     if: always() && needs.build-and-push.result == 'success'
     runs-on: docker
+    container:
+      image: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
+      credentials:
+        username: ${{ vars.CI_GITEA_USERNAME }}
+        password: ${{ secrets.CI_GITEA_API_TOKEN }}
     timeout-minutes: 10
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 1
       - name: Set up environment
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
         run: make setup-ci
       - name: Clean up old image versions
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           PYTHONPATH: src
         run: |
           . .venv/bin/activate

.gitea/workflows/ci.yml

@@ -5,18 +5,39 @@ on:
     types: [opened, synchronize]
   workflow_dispatch:
 
+env:
+  PIP_BREAK_SYSTEM_PACKAGES: "1"
+  PYTHONPATH: src
+  CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+  CI_GITEA_USERNAME: ${{ vars.CI_GITEA_USERNAME }}
+
 jobs:
-  quality:
+  # Single validation job that merges: quality, detect-changes,
+  # release-dry-run, pr-review, and pre-merge-check.
+  # Uses ci-full image (has git-cliff for release-dry-run).
+  # Saves ~4x checkout+setup overhead vs 5 separate jobs.
+  validate:
     runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-quality:latest
-    timeout-minutes: 10
+    container:
+      image: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
+      credentials:
+        username: ${{ vars.CI_GITEA_USERNAME }}
+        password: ${{ secrets.CI_GITEA_API_TOKEN }}
+    timeout-minutes: 15
     defaults:
       run:
         shell: bash
+    outputs:
+      user-facing-changed: ${{ steps.detect.outputs.user-facing-changed }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Set up environment
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
         run: make setup-image
+      # --- quality steps ---
       - name: Lint all
         run: |
           . .venv/bin/activate 2>/dev/null || true
@@ -27,39 +48,18 @@ jobs:
           . .venv/bin/activate 2>/dev/null || true
           make pytest-cov
       - name: Check unit test speed
-        env:
-          PYTHONPATH: src
         run: |
           . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.tools.check_test_speed --max-seconds 6 --max-single-seconds 0.5
-      - name: Documentation coverage check
+          python3 -m devx.tools.check_test_speed --max-seconds 15 --max-single-seconds 0.5
+      - name: Documentation gate (coverage + stale refs + lint + version refs + prose)
         env:
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.ci.doc_coverage --fail-on-missing
-      - name: Documentation lint check
-        env:
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.ci.lint_docs --root .
-      - name: Documentation version reference check
-        env:
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.tools.check_doc_versions --root .
-      - name: Vale prose lint check
-        env:
-          PYTHONPATH: src
+          DEVX_DOC_COVERAGE_STRICT: "1"
+          DEVX_VALE_LEVEL: warning
         run: |
           . .venv/bin/activate 2>/dev/null || true
           export PATH="$HOME/.local/bin:$PATH"
-          vale --minAlertLevel=error docs/ AGENTS.md README.md
+          make devx-docs-check
       - name: Translation completeness check
-        env:
-          PYTHONPATH: src
         run: |
           . .venv/bin/activate 2>/dev/null || true
           python3 -m devx.ci.check_translations
@@ -80,94 +80,75 @@ jobs:
           else
             echo "act_runner not found — skipping workflow dry-run (static lint still passed)"
           fi
-
-  detect-changes:
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        shell: bash
-    outputs:
-      user-facing-changed: ${{ steps.detect.outputs.user-facing-changed }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up environment
-        run: make setup-image
+      # --- detect-changes step ---
       - name: Detect changed paths
         id: detect
-        env:
-          PYTHONPATH: src
         run: |
           . .venv/bin/activate 2>/dev/null || true
           python3 -m devx.ci.classify_changes \
             --base "origin/master" \
             --head "${{ github.event.pull_request.head.sha || github.sha }}" \
             --github-output
-
-  release-dry-run:
-    needs: [quality, detect-changes]
-    if: needs.detect-changes.outputs.user-facing-changed == 'true'
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up environment
+      # --- validate-pr + pr-review steps (PR only) ---
+      - name: Validate auto-merge preconditions
+        if: github.event_name == 'pull_request'
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-        run: make setup-image
+          VIKUNJA_TOKEN: ${{ secrets.VIKUNJA_TOKEN }}
+          DEVX_VIKUNJA_PROJECT_ID: "8"
+          HEAD_REF: ${{ github.head_ref }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          REPOSITORY: ${{ github.repository }}
+          PR_NUMBER: ${{ github.event.number }}
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          python3 -m devx.ci.check_auto_merge_ready \
+            --branch "$HEAD_REF" \
+            --pr-title "$PR_TITLE" \
+            --repo "$REPOSITORY" \
+            --pr-number "$PR_NUMBER"
+      - name: Run automated PR review
+        if: github.event_name == 'pull_request'
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          set -euo pipefail
+          python3 -m devx.ci.pr_review \
+            "${{ github.event.number }}" \
+            "${{ github.repository }}"
+      # --- release-dry-run step (conditional) ---
       - name: Release dry-run validation
-        env:
-          PYTHONPATH: src
+        if: steps.detect.outputs.user-facing-changed == 'true'
         run: |
           . .venv/bin/activate 2>/dev/null || true
           export PATH="$HOME/.local/bin:$PATH"
           python3 -m devx.ci.release --dry-run
-
-  pr-review:
-    if: github.event_name == 'pull_request'
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up environment
-        run: make setup-image
-      - name: Run automated PR review
+      - name: Notify on failure
+        if: failure()
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
         run: |
-          set -euo pipefail
           . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.ci.pr_review \
-            "${{ github.event.number }}" \
-            "${{ github.repository }}"
+          export PATH="$HOME/.local/bin:$PATH"
+          python3 -m devx.ci.notify_failure \
+            --repo "${{ github.repository }}" \
+            --run-id "${{ github.run_id }}" \
+            --workflow "ci/validate" \
+            --commit "${{ github.sha }}" \
+            --auto-login
 
   auto-merge:
-    # Auto-merge runs after all CI checks pass. It reads the task ID
+    # Auto-merge runs after validate passes. It reads the task ID
     # from the branch name, validates the PR title, and squash-merges.
-    # Uses always() so it runs even when detect-changes skips (no user-facing changes).
-    needs: [quality, detect-changes, pr-review, release-dry-run]
+    needs: [validate]
     if: >-
       always() &&
       github.event_name == 'pull_request' &&
-      needs.quality.result == 'success' &&
-      needs.pr-review.result == 'success' &&
-      (needs.release-dry-run.result == 'success' || needs.release-dry-run.result == 'skipped')
+      needs.validate.result == 'success'
     runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
+    container:
+      image: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
+      credentials:
+        username: ${{ vars.CI_GITEA_USERNAME }}
+        password: ${{ secrets.CI_GITEA_API_TOKEN }}
     timeout-minutes: 10
     defaults:
       run:
@@ -176,15 +157,17 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.CI_GITEA_TOKEN }}
+          token: ${{ secrets.CI_GITEA_API_TOKEN }}
       - name: Set up environment
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
         run: make setup-image
       - name: Post approval review
         env:
-          CI_GITEA_TOKEN: ${{ secrets.REVIEW_GITEA_TOKEN }}
+          REVIEWER_GITEA_API_TOKEN: ${{ secrets.REVIEWER_GITEA_API_TOKEN }}
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           PR_NUMBER: ${{ github.event.number }}
           REPOSITORY: ${{ github.repository }}
-          PYTHONPATH: src
         run: |
           . .venv/bin/activate 2>/dev/null || true
           python3 -m devx.ci.pr_review \
@@ -193,13 +176,12 @@ jobs:
             --event APPROVE \
             --checklist-confirmed \
             --checklist-categories 1,2,3,4,5,6,7,8,9,10,11,12,13 \
-            --body "Auto-approved: all CI checks passed (quality, pr-review, release-dry-run)."
+            --body "Auto-approved: all CI checks passed (validate job)."
       - name: Squash merge with task ID
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           VIKUNJA_TOKEN: ${{ secrets.VIKUNJA_TOKEN }}
           DEVX_VIKUNJA_PROJECT_ID: "8"
-          PYTHONPATH: src
           HEAD_REF: ${{ github.head_ref }}
           PR_TITLE: ${{ github.event.pull_request.title }}
           REPOSITORY: ${{ github.repository }}

.gitea/workflows/post-merge.yml

@@ -1,216 +1,116 @@
 name: Post-merge
 
-# Runs on every push to master. A single workflow with conditional jobs
-# for release, publish, wiki sync, badges, and Vikunja task updates.
+# Runs on every push to master (after CI workflow merges a PR).
+# Consolidated into 2 jobs (from 7) to reduce runner overhead:
+#   detect-and-configure ──→ release-and-maintain
 #
-# Job dependency graph:
+# Job 1: detect release commit, validate commit msg, configure repo
+#        (branch protection, labels).
+# Job 2: release + publish + sync-wiki + vikunja + badges.
+#        Individual steps are conditional on job 1 outputs.
 #
-#   detect-type ──┬── validate-commit-msg (skip if release commit)
-#                 ├── release (skip if release commit)
-#                 │   └── publish (needs release — builds & publishes to PyPI)
-#                 ├── badges (needs release — ALWAYS runs, waits for release
-#                 │           so version badge picks up new __version__)
-#                 ├── configure-repo (independent — skip if release commit)
-#                 ├── sync-wiki (skip if release commit — runs for ALL merges)
-#                 └── vikunja (skip if release commit — runs for ALL merges)
-#
-# sync-wiki and vikunja run for ALL non-release commits, not just when
-# release succeeds. This ensures the wiki and task tracker are updated
-# even for infrastructure-only changes (docs, CI config, etc.).
-#
-# The badges job uses `if: always()` and needs `release` so it waits for
-# the release job to complete (whether it ran or was skipped). This ensures
-# the version badge always reflects the latest __version__ on master.
-# Badges run on every push to master, including release commits.
+# The badges step always runs (even on release commits) so version
+# badge picks up the new __version__. It runs last so it sees the
+# new version if release created one.
 #
 # When release creates a "release: vX.Y.Z" commit and tag, the publish
-# job (which depends on release) builds and publishes the package to the
-# Gitea PyPI registry. The release commit's post-merge run still updates
-# badges (version badge picks up the new version). Other jobs skip.
+# step builds and publishes the package to the Gitea PyPI registry.
+# The release commit's post-merge run still updates badges. Other
+# steps (sync-wiki, vikunja) skip on release commits.
 
 on:
   push:
     branches: [master]
 
+concurrency:
+  group: post-merge-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PIP_BREAK_SYSTEM_PACKAGES: "1"
+  PYTHONPATH: src
+  CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+  CI_GITEA_USERNAME: ${{ vars.CI_GITEA_USERNAME }}
+
 jobs:
-  detect-type:
+  detect-and-configure:
     runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
+    container:
+      image: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
+      credentials:
+        username: ${{ vars.CI_GITEA_USERNAME }}
+        password: ${{ secrets.CI_GITEA_API_TOKEN }}
     timeout-minutes: 10
     defaults:
       run:
         shell: bash
     outputs:
       is-release: ${{ steps.check.outputs.is-release }}
+      is-automated: ${{ steps.check.outputs.is-automated }}
+      user-facing-changed: ${{ steps.detect.outputs.user-facing-changed }}
     steps:
       - uses: actions/checkout@v4
         with:
-          fetch-depth: 1
+          fetch-depth: 0
       - name: Set up environment
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
         run: make setup-image
+      - name: Ensure branch protection and labels
+        env:
+          DEVX_REPO_NAME: devx
+          DEVX_REPO_OWNER: oblachno-oss
+          DEVX_STATUS_CHECKS: "CI / validate (pull_request)"
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          python3 -m devx.tools.configure_repo
       - name: Check if this is a release commit
         id: check
-        env:
-          PYTHONPATH: src
         run: |
           . .venv/bin/activate 2>/dev/null || true
           python3 -m devx.ci.detect_release_commit
-
-  validate-commit-msg:
-    needs: [detect-type]
-    if: needs.detect-type.outputs.is-release == 'false'
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
-    timeout-minutes: 5
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 1
-      - name: Set up environment
-        run: make setup-image
       - name: Validate latest commit message
-        env:
-          PYTHONPATH: src
+        if: steps.check.outputs.is-automated == 'false'
         run: |
           . .venv/bin/activate 2>/dev/null || true
           git log -1 --format=%B > commit-msg.txt
           python3 -m devx.ci.validate_commit_msg commit-msg.txt --branch master
           rm -f commit-msg.txt
+      - name: Detect changed paths
+        id: detect
+        if: steps.check.outputs.is-release == 'false'
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          python3 -m devx.ci.classify_changes \
+            --base "HEAD~1" \
+            --head "HEAD" \
+            --github-output
+      - name: Notify on failure
+        if: failure()
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          export PATH="$HOME/.local/bin:$PATH"
+          python3 -m devx.ci.notify_failure \
+            --repo "${{ github.repository }}" \
+            --run-id "${{ github.run_id }}" \
+            --workflow "post-merge/detect-and-configure" \
+            --commit "${{ github.sha }}" \
+            --auto-login
 
-  release:
-    needs: [detect-type]
-    if: needs.detect-type.outputs.is-release == 'false'
+  release-and-maintain:
+    needs: [detect-and-configure]
+    if: always() && needs.detect-and-configure.result == 'success'
     runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
+    container:
+      image: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
+      credentials:
+        username: ${{ vars.CI_GITEA_USERNAME }}
+        password: ${{ secrets.CI_GITEA_API_TOKEN }}
     timeout-minutes: 15
-    defaults:
-      run:
-        shell: bash
     outputs:
       tag: ${{ steps.release-tag.outputs.tag }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.CI_GITEA_TOKEN }}
-      - name: Set up environment
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-        run: make setup-image
-      - name: Configure git
-        run: |
-          git config user.name "devx-ci-bot"
-          git config user.email "devx-ci-bot@oblachno.fyi"
-      - name: Run release
-        id: release-tag
-        env:
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.release
-      - name: Notify on failure
-        if: failure()
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.notify_failure \
-            --repo "${{ github.repository }}" \
-            --run-id "${{ github.run_id }}" \
-            --workflow "post-merge/release" \
-            --commit "${{ github.sha }}" \
-            --auto-login
-
-  publish:
-    needs: [release]
-    if: needs.release.outputs.tag != ''
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          ref: ${{ needs.release.outputs.tag }}
-      - name: Set up environment
-        run: make setup-image EXTRAS=release
-      - name: Build and publish release
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.publish "${{ needs.release.outputs.tag }}" "${{ github.repository }}" --auto-login
-      - name: Notify on failure
-        if: failure()
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.notify_failure \
-            --repo "${{ github.repository }}" \
-            --run-id "${{ github.run_id }}" \
-            --workflow "post-merge/publish" \
-            --commit "${{ github.sha }}" \
-            --auto-login
-
-  sync-wiki:
-    needs: [detect-type]
-    if: needs.detect-type.outputs.is-release == 'false'
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
-    timeout-minutes: 15
-    concurrency:
-      group: sync-wiki-${{ github.repository }}
-      cancel-in-progress: false
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up environment
-        run: make setup-image
-      - name: Sync documentation to wiki
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.ci.sync_wiki --repo "${{ github.repository }}" --verify
-      - name: Notify on failure
-        if: failure()
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.notify_failure \
-            --repo "${{ github.repository }}" \
-            --run-id "${{ github.run_id }}" \
-            --workflow "post-merge/sync-wiki" \
-            --commit "${{ github.sha }}" \
-            --auto-login
-
-  badges:
-    needs: [detect-type, release]
-    if: always()
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-quality:latest
-    timeout-minutes: 10
     defaults:
       run:
         shell: bash
@@ -219,102 +119,76 @@ jobs:
         with:
           fetch-depth: 0
           ref: master
-          token: ${{ secrets.CI_GITEA_TOKEN }}
-      - name: Fetch latest master
-        run: |
-          git fetch origin master
-          git reset --hard origin/master
+          token: ${{ secrets.CI_GITEA_API_TOKEN }}
       - name: Set up environment
-        run: make setup-image
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: make setup-image EXTRAS=release
+      - name: Configure git
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: |
+          git config user.name "devx-ci-bot"
+          git config user.email "devx-ci-bot@oblachno.fyi"
+          git remote set-url origin "https://devx-ci-bot:${CI_GITEA_API_TOKEN}@git.oblachno.oblachno.fyi/oblachno-oss/devx.git"
+      # --- release + publish (only if user-facing changes, not a release commit) ---
+      - name: Run release
+        id: release-tag
+        if: needs.detect-and-configure.outputs.is-release == 'false' && needs.detect-and-configure.outputs.user-facing-changed == 'true'
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          export PATH="$HOME/.local/bin:$PATH"
+          python3 -m devx.ci.release
+      - name: Build and publish release
+        if: steps.release-tag.outputs.tag != ''
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          export PATH="$HOME/.local/bin:$PATH"
+          git fetch --tags
+          git checkout "${{ steps.release-tag.outputs.tag }}"
+          python3 -m devx.ci.publish "${{ steps.release-tag.outputs.tag }}" "${{ github.repository }}" --auto-login
+      # --- sync-wiki + vikunja (skip on automated/release commits) ---
+      - name: Sync documentation to wiki
+        if: needs.detect-and-configure.outputs.is-automated == 'false'
+        env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          python3 -m devx.ci.sync_wiki --repo "${{ github.repository }}" --verify
+      - name: Update Vikunja task
+        if: needs.detect-and-configure.outputs.is-automated == 'false'
+        env:
+          VIKUNJA_TOKEN: ${{ secrets.VIKUNJA_TOKEN }}
+          DEVX_VIKUNJA_PROJECT_ID: "8"
+        run: |
+          . .venv/bin/activate 2>/dev/null || true
+          python3 -m devx.ci.post_merge --git-sha "${{ github.sha }}"
+      # --- badges (always run — even on release commits) ---
       - name: Generate and push badges
         env:
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
           PRE_COMMIT_ALLOW_NO_CONFIG: "1"
         run: |
           . .venv/bin/activate 2>/dev/null || true
+          export PATH="$HOME/.local/bin:$PATH"
+          # Fetch latest master to pick up any release commit that was pushed
+          git fetch origin master
+          git reset --hard origin/master
           python3 -m devx.ci.push_badges
       - name: Notify on failure
         if: failure()
         env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.notify_failure \
-            --repo "${{ github.repository }}" \
-            --run-id "${{ github.run_id }}" \
-            --workflow "post-merge/badges" \
-            --commit "${{ github.sha }}" \
-            --auto-login
-
-  vikunja:
-    needs: [detect-type]
-    if: needs.detect-type.outputs.is-release == 'false'
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Set up environment
-        run: make setup-image
-      - name: Update Vikunja task
-        env:
-          VIKUNJA_TOKEN: ${{ secrets.VIKUNJA_TOKEN }}
-          DEVX_VIKUNJA_PROJECT_ID: "8"
-          PYTHONPATH: src
+          CI_GITEA_API_TOKEN: ${{ secrets.CI_GITEA_API_TOKEN }}
         run: |
           . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.ci.post_merge --git-sha "${{ github.sha }}"
-      - name: Notify on failure
-        if: failure()
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
           export PATH="$HOME/.local/bin:$PATH"
           python3 -m devx.ci.notify_failure \
             --repo "${{ github.repository }}" \
             --run-id "${{ github.run_id }}" \
-            --workflow "post-merge/vikunja" \
-            --commit "${{ github.sha }}" \
-            --auto-login
-
-  configure-repo:
-    needs: [detect-type]
-    if: needs.detect-type.outputs.is-release == 'false'
-    runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-base:latest
-    timeout-minutes: 10
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up environment
-        run: make setup-image
-      - name: Ensure branch protection and labels
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-          DEVX_REPO_NAME: devx
-          DEVX_REPO_OWNER: oblachno-oss
-        run: |
-          . .venv/bin/activate 2>/dev/null || true
-          python3 -m devx.tools.configure_repo
-      - name: Notify on failure
-        if: failure()
-        env:
-          CI_GITEA_TOKEN: ${{ secrets.CI_GITEA_TOKEN }}
-          PYTHONPATH: src
-        run: |
-          export PATH="$HOME/.local/bin:$PATH"
-          python3 -m devx.ci.notify_failure \
-            --repo "${{ github.repository }}" \
-            --run-id "${{ github.run_id }}" \
-            --workflow "post-merge/configure-repo" \
+            --workflow "post-merge/release-and-maintain" \
             --commit "${{ github.sha }}" \
             --auto-login

.pre-commit-config.yaml

@@ -59,7 +59,7 @@ repos:
 
       - id: check-test-speed
         name: unit test speed check
-        entry: .venv/bin/python -m devx.tools.check_test_speed --max-seconds 6 --max-single-seconds 0.5
+        entry: .venv/bin/python -m devx.tools.check_test_speed --max-seconds 15 --max-single-seconds 0.5
         language: system
         types: [python]
         pass_filenames: false
@@ -73,18 +73,12 @@ repos:
         pass_filenames: false
         stages: [pre-commit]
 
-      - id: doc-coverage
-        name: documentation coverage check
-        entry: env PYTHONPATH=src .venv/bin/python -m devx.ci.doc_coverage --fail-on-missing
-        language: system
-        pass_filenames: false
-        stages: [pre-commit]
-
-      - id: lint-docs
-        name: documentation lint check
-        entry: env PYTHONPATH=src .venv/bin/python -m devx.ci.lint_docs --root .
+      - id: docs-check
+        name: documentation gate (coverage + stale refs + lint + version refs + prose)
+        entry: bash -c 'PYTHONPATH=src DEVX_DOC_COVERAGE_STRICT=1 DEVX_VALE_LEVEL=warning make devx-docs-check'
         language: system
         pass_filenames: false
+        always_run: true
         stages: [pre-commit]
 
       - id: pytest-cov

.vale.ini

@@ -32,14 +32,17 @@ write-good.E-Prime = NO
 write-good.So = NO
 write-good.ThereIs = NO
 write-good.TooWordy = NO
+write-good.Passive = NO
 
 # Vale defaults — spelling catches too many technical terms
 Vale.Terms = NO
 Vale.Repetition = NO
 Vale.Spelling = NO
 
-# Readability — warnings only, technical docs are naturally complex
+# Readability — technical docs are naturally complex, downgrade to suggestions
 Readability.FleschReadingEase = suggestion
+Readability.FleschKincaid = suggestion
+Readability.AutomatedReadability = suggestion
 Readability.ColemanLiau = suggestion
 Readability.LIX = suggestion
 Readability.GunningFog = suggestion

.vale/styles/Google/Anthropomorphism.yml

@@ -0,0 +1,12 @@
+extends: existence
+message: "Don't attribute human qualities to software or hardware ('%s')."
+link: https://developers.google.com/style/anthropomorphism
+level: suggestion
+ignorecase: true
+# Limited to the two verbs the guide itself names. Broader lists (wants, knows,
+# thinks) can't tell a software subject from a human one: on a 950-file corpus
+# they produced 8 false positives ('the customer wants', 'your audience knows')
+# for every 2 real ones.
+tokens:
+  - sees
+  - tells

.vale/styles/Google/Colons.yml

@@ -1,8 +1,13 @@
 extends: existence
 message: "'%s' should be in lowercase."
 link: 'https://developers.google.com/style/colons'
-nonword: true
 level: warning
 scope: sentence
+# The match is the word itself, not ': X', and `nonword` is off. Both are
+# required for a project Vocab to work: Vale compares accept.txt entries
+# against the matched text, and `nonword: true` opts out of that entirely.
+# So a proper noun after a colon can be exempted by adding it to accept.txt.
+# The guide's other exemption, notice labels, is handled by the lookbehinds;
+# headings are already excluded by `scope: sentence`. See issue #20.
 tokens:
-  - '(?<!:[^ ]+?):\s[A-Z]'
+  - '(?<!Note: )(?<!Caution: )(?<!Warning: )(?<!Success: )(?<=:\s)[A-Z]\w+'

.vale/styles/Google/DateFormat.yml

@@ -6,4 +6,4 @@ level: error
 nonword: true
 tokens:
   - '\d{1,2}(?:\.|/)\d{1,2}(?:\.|/)\d{4}'
-  - '\d{1,2} (?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)|May|Jun(?:e)|Jul(?:y)|Aug(?:ust)|Sep(?:tember)?|Oct(?:ober)|Nov(?:ember)?|Dec(?:ember)?) \d{4}'
+  - '\d{1,2} (?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?) \d{4}'

.vale/styles/Google/ExcessiveClaims.yml

@@ -0,0 +1,14 @@
+extends: existence
+message: "Avoid the unverifiable claim '%s'."
+link: https://developers.google.com/style/excessive-claims
+level: suggestion
+ignorecase: true
+# The guide also names 'never', 'always', and 'ensure', but in technical writing
+# those are usually legitimate instructions ('never commit secrets') rather than
+# product claims: they accounted for 125 of 142 hits on a 950-file corpus.
+# 'best practices' is a fixed term, not a superlative.
+tokens:
+  - 'best(?! practices?)'
+  - simplest
+  - fastest
+  - guarantees?

.vale/styles/Google/FirstPerson.yml

@@ -3,11 +3,13 @@ message: "Avoid first-person pronouns such as '%s'."
 link: 'https://developers.google.com/style/pronouns#personal-pronouns'
 ignorecase: true
 level: warning
-nonword: true
+# The 'I' tokens use lookaround rather than consuming the surrounding
+# whitespace. Matching ' I ' made the alert span cover both spaces, which shows
+# up as a too-wide underline in editors, and read as "such as ' I '". Dropping
+# `nonword` also lets a project Vocab apply, which it can't when set. See PR #50.
 tokens:
-  - (?:^|\s)I\s
-  - (?:^|\s)I,\s
-  - \bI'm\b
+  - '(?<=^|\s)I(?=[\s,])'
+  - "\\bI'm\\b"
   - \bme\b
   - \bmy\b
   - \bmine\b

.vale/styles/Google/Headings.yml

@@ -4,8 +4,11 @@ link: "https://developers.google.com/style/capitalization#capitalization-in-titl
 level: warning
 scope: heading
 match: $sentence
-indicators:
-  - ":"
+# No `indicators: [":"]` here. That makes Vale require a capital after a colon,
+# which is the Microsoft convention this rule was originally copied from. This
+# guide says the opposite: "the first word after a colon is generally
+# lowercase" (developers.google.com/style/colons), and Colons.yml enforces
+# exactly that. See issue #58.
 exceptions:
   - Azure
   - CLI

.vale/styles/Google/Jargon.yml

@@ -0,0 +1,13 @@
+extends: existence
+message: "Avoid the jargon '%s'."
+link: https://developers.google.com/style/jargon
+level: suggestion
+ignorecase: true
+# The guide also cites 'solution', 'support', and 'workload' as overloaded
+# terms, but those have ordinary technical meanings and accounted for every hit
+# on a 950-file corpus, so only the unambiguous figurative terms are listed.
+tokens:
+  - break-glass
+  - camel ?case
+  - out-of-the-box
+  - swim ?lane

.vale/styles/Google/Latin.yml

@@ -6,6 +6,10 @@ level: error
 nonword: true
 action:
   name: replace
+# The delimiter is a lookahead so the replacement doesn't swallow the comma or
+# space that follows (issue #18). `$` is included so the abbreviation is still
+# caught at the end of a heading, table cell, or block, which accounted for 8
+# of 10 occurrences on a 950-file corpus.
 swap:
-  '\b(?:eg|e\.g\.)(?=[\s,;])': for example
-  '\b(?:ie|i\.e\.)(?=[\s,;])': that is
+  '\b(?:eg|e\.g\.)(?=[\s,;]|$)': for example
+  '\b(?:ie|i\.e\.)(?=[\s,;]|$)': that is

.vale/styles/Google/OxfordComma.yml

@@ -3,5 +3,26 @@ message: "Use the Oxford comma in '%s'."
 link: 'https://developers.google.com/style/commas'
 scope: sentence
 level: warning
+nonword: true
+# List items may be several words long, not just one. Four guards keep the
+# false-positive rate down:
+#
+#   1. The comma can't be the one closing a fronted subordinate clause
+#      ('When your alarm rings, you turn it off and tumble out of bed.') --
+#      that comma separates clauses, not list items. Only the first comma of
+#      such a sentence is exempt, so 'When it rains, apples, pears or bananas
+#      get wet.' is still caught.
+#   2. The item can't open with a clause-introducer (', which ...',
+#      ', specifically ...').
+#   3. The item can't open with a subject pronoun followed by a verb, which
+#      marks a compound predicate rather than a list ('..., you walk to the
+#      fridge and get a snack.'). A pronoun directly followed by 'and'/'or'
+#      is a real list item, so ', you and me.' still matches.
+#   4. Neither item may contain an auxiliary verb, which is another compound
+#      predicate signal (', it has some downsides and is officially
+#      discouraged.').
+#
+# The trailing anchor allows end-of-scope so list fragments ('Apples, pears
+# or bananas') are still caught.
 tokens:
-  - '(?:[^,]+,){1,}\s\w+\s(?:and|or)'
+  - '(?<!^(?i:when|whenever|while|if|unless|until|although|though|because|since|after|before|once|whereas|whether|as)\b[^,]{0,80}),\s(?!(?:which|who|whom|whose|that|where|when|while|because|since|although|though|if|unless|so|but|and|or|however|therefore|thus|specifically|especially|namely|then|take|see|note|consider|make|use|either|neither)\b)(?!(?i:i|you|we|they|he|she|it)\s+(?!(?:and|or)\b))(?:(?!\b(?:is|are|was|were|has|have|had|be|been|being|will|would|can|could|should|may|might|must|do|does|did)\b)\w+ ){0,4}\w+ (?:and|or) (?:(?!\b(?:is|are|was|were|has|have|had|be|been|being|will|would|can|could|should|may|might|must|do|does|did)\b)\w+ ){0,4}\w+(?:[.?!]|$)'

.vale/styles/Google/Parens.yml

@@ -3,5 +3,13 @@ message: "Use parentheses judiciously."
 link: 'https://developers.google.com/style/parentheses'
 nonword: true
 level: suggestion
+# `[^)]` rather than `.+`: a greedy match ran from the first '(' on a line to
+# the last ')', so 'Text (one) and more (two).' produced a single alert
+# covering everything between them. See issue #30.
+# A bare 3-5 letter acronym is skipped: Acronyms.yml requires acronyms to be
+# defined as 'Spelled Out Term (ACRONYM)', so flagging those parentheses would
+# put the two rules in direct conflict. The acronym has to be the whole
+# parenthetical — '(NASA rocket program)' is an ordinary aside and still
+# flags. Length matches the {3,5} in Acronyms.yml. See PR #59.
 tokens:
-  - '\(.+\)'
+  - '\((?![A-Z]{3,5}\))[^)]+\)'

.vale/styles/Google/Timeless.yml

@@ -0,0 +1,13 @@
+extends: existence
+message: "Avoid time-based words like '%s' in product documentation."
+link: https://developers.google.com/style/timeless-documentation
+level: suggestion
+ignorecase: true
+# The guide also names 'now' and 'new', but both have common senses that aren't
+# time-anchored ('create a new project'): adding them took a 950-file corpus of
+# technical documentation from 14 hits to 117. 'recently' is left out too — every
+# hit in that corpus was the UI idiom 'recently used'.
+tokens:
+  - currently
+  - latest
+  - soon

.vale/styles/Google/Units.yml

@@ -4,5 +4,7 @@ link: "https://developers.google.com/style/units-of-measure"
 nonword: true
 level: error
 tokens:
-  - \b\d+(?:B|kB|MB|GB|TB)
-  - \b\d+(?:ns|ms|s|min|h|d)
+  - '\b\d+(?:B|kB|MB|GB|TB)\b'
+  - '\b\d+(?:ns|ms|min|h|d)\b'
+  # Seconds are split out so a decade ('1990s') isn't read as a unit.
+  - '\b\d+s\b(?<!\b(?:19|20)\d\ds\b)'

.vale/styles/Google/WordList.yml

@@ -2,79 +2,28 @@ extends: substitution
 message: "Use '%s' instead of '%s'."
 link: "https://developers.google.com/style/word-list"
 level: warning
+# Case matters here: each key's own capitalization is what's being corrected,
+# so ignorecase would make these match their own replacements. The rest of the
+# word list lives in WordListCase.yml.
 ignorecase: false
 action:
   name: replace
 swap:
-  "(?:API Console|dev|developer) key": API key
-  "(?:cell ?phone|smart ?phone)": phone|mobile phone
-  "(?:dev|developer|APIs) console": API console
-  "(?:e-mail|Email|E-mail)": email
-  "(?:file ?path|path ?name)": path
-  "(?:kill|terminate|abort)": stop|exit|cancel|end
-  "(?:OAuth ?2|Oauth)": OAuth 2.0
-  "(?:ok|Okay)": OK|okay
-  "(?:WiFi|wifi)": Wi-Fi
-  '[\.]+apk': APK
-  '3\-D': 3D
-  'Google (?:I\-O|IO)': Google I/O
-  "tap (?:&|and) hold": touch & hold
-  "un(?:check|select)": clear
-  above: preceding
-  account name: username
-  action bar: app bar
-  admin: administrator
   Ajax: AJAX
-  a\.k\.a|aka: or|also known as
   Android device: Android-powered device
   android: Android
   API explorer: APIs Explorer
-  application: app
-  approx\.: approximately
   authN: authentication
   authZ: authorization
-  autoupdate: automatically update
-  cellular data: mobile data
-  cellular network: mobile network
-  chapter: documents|pages|sections
-  check box: checkbox
   CLI: command-line tool
-  click on: click|click in
   Cloud: Google Cloud Platform|GCP
   Container Engine: Kubernetes Engine
-  content type: media type
-  curated roles: predefined roles
-  data are: data is
   Developers Console: Google API Console|API Console
-  disabled?: turn off|off
-  ephemeral IP address: ephemeral external IP address
-  fewer data: less data
-  file name: filename
-  firewalls: firewall rules
-  functionality: capability|feature
   Google account: Google Account
   Google accounts: Google Accounts
   Googling: search with Google
-  grayed-out: unavailable
   HTTPs: HTTPS
-  in order to: to
-  ingest: import|load
   k8s: Kubernetes
-  long press: touch & hold
-  network IP address: internal IP address
-  omnibox: address bar
-  open-source: open source
-  overview screen: recents screen
-  regex: regular expression
   SHA1: SHA-1|HAS-SHA1
-  sign into: sign in to
-  sign-?on: single sign-on
-  static IP address: static external IP address
-  stylesheet: style sheet
-  synch: sync
-  tablename: table name
-  tablet: device
-  touch: tap
   url: URL
-  vs\.: versus
   World Wide Web: web

.vale/styles/Google/WordListCase.yml

@@ -0,0 +1,68 @@
+extends: substitution
+message: "Use '%s' instead of '%s'."
+link: "https://developers.google.com/style/word-list"
+level: warning
+# The case-insensitive half of the word list, so sentence-initial use is caught
+# ('Touch the screen', not only 'touch the screen'). Entries that must stay
+# case-sensitive are in WordList.yml.
+ignorecase: true
+action:
+  name: replace
+swap:
+  "(?:API Console|dev|developer) key": API key
+  "(?:cell ?phone|smart ?phone)": phone|mobile phone
+  "(?:dev|developer|APIs) console": API console
+  "(?:e-mail|Email|E-mail)": email
+  "(?:file ?path|path ?name)": path
+  "(?:kill|terminate|abort)": stop|exit|cancel|end
+  # Longest form first: with the shortest alternative leading, 'OAuth 2' matched
+  # only 'OAuth', so applying the suggestion produced 'OAuth 2.0 2'. The rule is
+  # already case-insensitive, so the inline (?i) is redundant. See issue #41.
+  '\bOauth2\.0\b|\bOAuth ?2\b(?!\.0)|\bOauth\b(?! ?2)': OAuth 2.0
+  "(?:ok|Okay)": OK|okay
+  "(?:WiFi|wifi)": Wi-Fi
+  '[\.]+apk': APK
+  '3\-D': 3D
+  'Google (?:I\-O|IO)': Google I/O
+  "tap (?:&|and) hold": touch & hold
+  "un(?:check|select)": clear
+  above: preceding
+  account name: username
+  action bar: app bar
+  admin: administrator
+  a\.k\.a|aka: or|also known as
+  application: app
+  approx\.: approximately
+  autoupdate: automatically update
+  cellular data: mobile data
+  cellular network: mobile network
+  chapter: documents|pages|sections
+  check box: checkbox
+  click on: click|click in
+  content type: media type
+  curated roles: predefined roles
+  data are: data is
+  disabled?: turn off|off
+  ephemeral IP address: ephemeral external IP address
+  fewer data: less data
+  file name: filename
+  firewalls: firewall rules
+  functionality: capability|feature
+  grayed-out: unavailable
+  in order to: to
+  ingest: import|load
+  long press: touch & hold
+  network IP address: internal IP address
+  omnibox: address bar
+  open-source: open source
+  overview screen: recents screen
+  regex: regular expression
+  sign into: sign in to
+  '(?<!single )sign-?on': single sign-on
+  static IP address: static external IP address
+  stylesheet: style sheet
+  synch: sync
+  tablename: table name
+  tablet: device
+  'touch(?! ?(?:&|and) hold)': tap
+  vs\.: versus

.vale/styles/devx/CodeBlockLanguage.yml

@@ -3,4 +3,4 @@ message: "Unlabeled code block — add a language tag (```bash, ```yaml, etc.)"
 level: warning
 scope: raw
 raw:
-  - '(?s)```\n(?!.*```)'
+  - '(?ms)^\n```\n.*?^```\s*$'

.vale/styles/write-good/README.md

@@ -2,7 +2,7 @@ Based on [write-good](https://github.com/btford/write-good).
 
 > Naive linter for English prose for developers who can't write good and wanna learn to do other stuff good too.
 
-```text
+```
 The MIT License (MIT)
 
 Copyright (c) 2014 Brian Ford

AGENTS.md

@@ -28,6 +28,11 @@ make workflow-check  # workflow-lint + workflow-dryrun
 make devx-check-doc-versions  # Verify docs version refs match __version__
 make devx-vale       # Run Vale prose linter on docs and README
 make clean           # Remove caches, build artifacts, coverage data
+make check-workflow-artifact-deps  # Verify artifact download jobs depend on upload jobs
+make check-workflow-tofu-init      # Verify tofu-state jobs have a tofu-init step
+make check-docker-init             # Check Docker Compose services with healthchecks have init: true
+make check-ansible-set-fact-to-json  # Check set_fact tasks don't misuse to_json
+make check-alert-rules             # Validate Prometheus alert rules with promtool
 ```
 
 `make setup` automatically installs all development tools:
@@ -50,7 +55,7 @@ Workflow YAML files (`.gitea/workflows/*.yml`) are verified with two tools:
 
 Both run via `make workflow-check` and are part of `make lint-all`.
 The pre-commit hook runs actionlint automatically when workflow files change.
-The CI `quality` job runs `make setup-quality` then `make lint-all`.
+The CI `validate` job runs `make setup-image` then `make lint-all`.
 CI also runs a best-effort `make workflow-dryrun` step (skipped if act_runner is not installed in the CI Docker image).
 
 ## Architecture
@@ -71,7 +76,7 @@ src/devx/
 ├── translations.json    # Translation strings (en, bg, de, pl, ru, zh)
 ├── ci/                  # CI/CD automation modules (run by workflows)
 │   ├── release.py       # Automated versioning, tagging, changelog
-│   ├── publish.py       # Build and publish to Gitea PyPI registry (--skip-build for non-Python repos)
+│   ├── publish.py       # Build, publish to Gitea PyPI registry, create Gitea release (with retry)
 │   ├── auto_merge.py    # Squash-merge PRs with task ID validation
 │   ├── check_auto_merge_ready.py  # Pre-merge validation gate (branch, PR title, Vikunja, behind-master)
 │   ├── _shared.py      # Shared utilities (get_latest_tag)
@@ -88,7 +93,14 @@ src/devx/
 │   ├── integration_guard.py # Run pytest with cross-runner fail-fast
 │   ├── check_translations.py  # Translation completeness check
 │   ├── doc_coverage.py  # Documentation coverage check
-│   └── lint_docs.py  # Documentation linter (structure, links, headings, code blocks, orphans)
+│   ├── lint_docs.py  # Documentation linter (structure, links, headings, code blocks, orphans)
+│   ├── validate_deploy_ref.py  # Validate git tag for deployments (--github-output)
+│   ├── record_deployed_tag.py  # Record deployed tag to Gitea repo variable
+│   ├── cancel_superseded_runs.py  # Cancel in-flight CI runs for the same PR branch
+│   ├── check_workflow_artifact_deps.py  # Verify artifact download jobs depend on upload jobs
+│   ├── check_workflow_tofu_init.py  # Verify tofu-state jobs have a tofu-init step
+│   ├── discover_runners.py  # Deprecated wrapper → molecule/discover_runners
+│   └── wait_for_checks.py  # Poll Gitea Actions for job completion (replaces inline shell polling)
 ├── tools/               # Developer tooling modules (run locally or by CI)
 │   ├── setup.py         # Environment setup (venv, deps, hooks)
 │   ├── install_tools.py # Install actionlint, git-cliff, act_runner, tea, hadolint, vale
@@ -111,13 +123,40 @@ src/devx/
 │   ├── pr_logs.py           # Fetch logs for failed CI jobs
 │   ├── pr_label.py          # Add labels to PRs (idempotent)
 │   ├── pre_push_check.py    # Validate Vikunja task existence before push
+│   ├── check_docker_init.py  # Check Docker Compose services with healthchecks have init: true
+│   ├── check_ansible_set_fact_to_json.py  # Thin wrapper → ansible_checks/set_fact_to_json
+│   ├── check_alert_rules.py  # Validate Prometheus alert rules with promtool
+│   ├── check_ansible_no_log.py  # Thin wrapper → ansible_checks/no_log
+│   ├── check_ansible_patterns.py  # Thin wrapper → ansible_checks/patterns
+│   ├── check_jinja_expr.py  # Thin wrapper → ansible_checks/jinja_expr
+│   ├── check_ansible_no_state_absent_on_db.py  # Thin wrapper → ansible_checks/no_state_absent_on_db
+│   ├── ansible_checks/     # Composable Ansible check subpackage (canonical implementations)
+│   │   ├── _shared.py      # AnsibleFileFinder, AnsibleYAMLParser, ViolationReporter
+│   │   ├── no_log.py       # Check missing no_log on secret-handling tasks
+│   │   ├── patterns.py     # Detect dangerous failure-masking patterns
+│   │   ├── set_fact_to_json.py  # Check set_fact tasks don't misuse to_json
+│   │   ├── no_state_absent_on_db.py  # Prevent state:absent on DB paths
+│   │   └── jinja_expr.py   # Validate Jinja2 expressions in Ansible files
 │   └── _shared.py           # Shared tool utilities
 ├── opentofu.py          # OpenTofu output helpers (get_tofu_output, get_tofu_vm_ip, get_tofu_vm_field)
+├── utils/               # Shared utilities (reusable across projects)
+│   ├── api.py            # API response helpers (is_truthy, is_falsy) + APIClient base class
+│   ├── ssh.py            # SSH exec + wait_for_ssh (pure-Python socket check)
+│   ├── crypto.py         # Secret generation (shell-safe passwords)
+│   ├── vault.py          # Ansible vault encrypt/decrypt helpers
+│   ├── network.py        # HTTP connectivity check + wait_for_ssh
+│   ├── confirm.py        # Typed confirmation validation for destructive ops
+│   ├── json_registry.py  # File-locked JSON registry for local state
+│   ├── step_tracker.py   # Multi-step operation tracking with reports
+│   ├── logging.py        # XDG-compliant logging configuration
+│   ├── ui.py             # say() — unified click.echo + logging output
+│   └── jinja.py          # Jinja2 environment helpers + Ansible-compatible filters
 └── molecule/            # Optional molecule testing helpers (for Ansible projects)
-    ├── discover_runners.py    # Dynamic Gitea runner discovery
+    ├── discover_runners.py    # Dynamic Gitea runner discovery (canonical; ci/discover_runners is a deprecated wrapper)
     ├── distribute_molecule.py # Distribute molecule scenarios across runners (LPT scheduling, --roles-root for multi-role)
     ├── molecule_ci_guard.py   # Run molecule with cross-runner fail-fast (--roles-root)
     ├── molecule_all.py        # Run all molecule scenarios locally
+    ├── molecule_changed.py    # Detect which Ansible roles changed and output molecule scenarios
     ├── start_docker.py        # Ensure Docker daemon is running for molecule tests
     └── platforms.py           # Supported molecule platforms
 ```
@@ -136,18 +175,24 @@ Every change to master goes through this workflow. No exceptions.
 ### Branch Protection (Required Gitea Settings)
 
 Branch protection and labels are automatically configured by
-`python -m devx.tools.configure_repo`, which runs as a `configure-repo` job in
-the post-merge workflow on every push to master.
+`python -m devx.tools.configure_repo`, which runs as a step in the
+`detect-and-configure` job in the post-merge workflow on every push to master.
 
 The following rules are enforced for `master`:
 - **Require pull request**: No direct pushes to master
 - **Require approval review**: At least 1 `APPROVE` review before merge
-- **Require status checks**: CI quality must pass
+- **Require status checks**: CI validate must pass
 - **Block force pushes**: No history rewriting on master
 
 ### 1. Create Vikunja Task
 Create a task in Vikunja to get a `DEVX-N` identifier.
 
+**IMPORTANT:** The task title must NOT include the `DEVX-N:` prefix.
+The `make create-pr` and `check_auto_merge_ready` commands automatically
+prepend `DEVX-N: ` to the Vikunja task title when forming the PR title.
+If the Vikunja task title already includes the prefix, the PR title will
+have a double prefix and auto-merge validation will fail.
+
 ### 2. Create Branch
 ```bash
 git checkout master && git pull
@@ -174,8 +219,9 @@ docs: update README
 
 ### 6. Review the PR
 
-**Automated review (CI `pr-review` job):** Every PR triggers an automated
-review via `python -m devx.ci.pr_review`. This job posts a review with
+**Automated review (CI `validate` job):** Every PR triggers an automated
+review via `python -m devx.ci.pr_review` as a step in the `validate` job.
+This posts a review with
 `COMMENT` (no issues) or `REQUEST_CHANGES` (issues found):
 
 - Architecture compliance (no subprocess in CLI, no hardcoded URLs)
@@ -198,7 +244,7 @@ Once all checklist items are verified and comments are addressed, approve
 the PR. Then add the `ready-to-merge` label. The auto-merge workflow will:
 1. **Validate** PR title format (`DEVX-N: <vikunja task title>`) and match against Vikunja task title
 2. **Check** that at least one substantive APPROVE review exists
-3. Wait for all CI checks to pass (including the `pr-review` job)
+3. Wait for all CI checks to pass (including the `validate` job)
 4. Squash-merge with title: `DEVX-N: <conventional commit message>`
 5. The post-merge workflow marks the Vikunja task as done
 6. The release workflow automatically versions, tags, and publishes
@@ -209,36 +255,27 @@ the PR. Then add the `ready-to-merge` label. The auto-merge workflow will:
 ### Automated Release Pipeline
 
 After a PR is merged to master, the **post-merge workflow**
-(`.gitea/workflows/post-merge.yml`) runs automatically:
+(`.gitea/workflows/post-merge.yml`) runs automatically. Consolidated
+into 2 jobs (from 7) to reduce runner overhead:
 
-1. **detect-type** — Checks if the commit is a regular merge or a
-   release commit (`release: vX.Y.Z`). All subsequent jobs skip for
-   release commits (except badges).
+1. **detect-and-configure** — Configures repo (branch protection, labels),
+   detects release commit, validates commit message. Outputs `is-release`
+   and `is-automated` for the next job.
 
-2. **release** — Runs `python -m devx.ci.release` which:
-   - Checks for user-facing changes via `python -m devx.ci.classify_changes`
-   - Uses **git-cliff** to calculate the next semver version from conventional commits
-   - Updates `__version__` in `src/devx/__init__.py` (single source of truth)
-   - Updates `CHANGELOG.md` with the new version section
-   - Runs `make lint-ruff` and `make pytest-cov` to verify the release is healthy
-   - Commits with `release: vX.Y.Z [skip ci]` prefix
-   - Creates an annotated tag `vX.Y.Z` on the release commit
-   - Pushes both the commit and tag to master
-
-3. **sync-wiki** — Syncs documentation to the Gitea wiki. Runs for ALL
-   non-release commits (not just when release succeeds), so docs-only
-   changes still update the wiki.
-
-4. **badges** — Generates and pushes quality badge SVGs to the `badges` branch.
-   Uses `if: always()` so it runs on every push, including release commits.
-
-5. **vikunja** — Marks the corresponding Vikunja task as done. Runs for ALL
-   non-release commits (not just when release succeeds), so infrastructure-only
-   changes still update the task tracker.
-
-6. **publish** — Runs after release succeeds (needs: release). Builds and
-   publishes the package to the Gitea PyPI registry. Gets the tag from the
-   release job's `tag` output (written via `GITHUB_OUTPUT`).
+2. **release-and-maintain** — Runs all post-merge maintenance as
+   conditional steps:
+   - **release** (if not a release commit) — Runs `python -m devx.ci.release`
+     which checks for user-facing changes via `classify_changes`, uses
+     git-cliff for semver, updates `__version__`, updates `CHANGELOG.md`,
+     runs lint+tests, commits with `release: vX.Y.Z [skip ci]`, creates
+     annotated tag, pushes to master.
+   - **publish** (if release created a tag) — Builds and publishes the
+     package to the Gitea PyPI registry. Checks out the release tag
+     within the same job.
+   - **sync-wiki** (if not automated) — Syncs documentation to the Gitea wiki.
+   - **vikunja** (if not automated) — Marks the corresponding Vikunja task as done.
+   - **badges** (always) — Generates and pushes quality badge SVGs to the
+     `badges` branch. Fetches latest master first to pick up release commits.
 
 ### Smart CI: User-Facing vs Workflow-Only Changes
 
@@ -300,6 +337,20 @@ by `python -m devx.tools.install_tools` and configured by
 - `create_pr()` / `merge_pr()` / `review_pr()` — Pull request operations
 - `create_release()` / `list_releases()` — Release management
 
+**`devx.gitea_cli.configure_tea_login()`** — Configures tea login in
+containerized CI environments where `make setup` was not called. Used by
+`publish.py` (`--auto-login`) and `notify_failure.py` (`--auto-login`).
+Raises `TeaCLIError` if login configuration fails — this prevents cryptic
+"no available login" errors from subsequent tea commands.
+
+**Error handling**: `TeaCLI._run()` includes both stdout and stderr in
+`TeaCLIError` messages, because `tea` writes some errors (for example,
+"no available login") to stdout, not stderr.
+
+**Release creation retry**: `publish.py` retries Gitea release creation
+up to 3 times with exponential backoff (2s, 4s) on transient failures.
+"Already exists" errors are treated as success (idempotent).
+
 ### git-cliff Commit Preprocessing
 
 Merge commits on master have the format `DEVX-N: <conventional commit>`. The
@@ -344,12 +395,11 @@ dependency is skipped, even if the condition explicitly allows
 
 ```yaml
 auto-merge:
-  needs: [quality, detect-changes, pr-review, molecule-tests]
+  needs: [validate, molecule-tests]
   if: >-
     always() &&
     github.event_name == 'pull_request' &&
-    needs.quality.result == 'success' &&
-    needs.pr-review.result == 'success' &&
+    needs.validate.result == 'success' &&
     (needs.molecule-tests.result == 'success' || needs.molecule-tests.result == 'skipped')
 ```
 
@@ -398,7 +448,7 @@ system loads `.env` automatically via `python-dotenv`.
 
 ### pyproject.toml [tool.devx] Configuration
 
-In addition to `DEVX_` env vars, several devx tools read configuration from
+In addition to `DEVX_` env vars, many devx tools read configuration from
 the `[tool.devx]` section in `pyproject.toml`. This allows per-project
 customization without environment variables.
 
@@ -487,9 +537,9 @@ to eliminate the 40-120s setup tax on every CI job:
 
 | Image | Contains | Used by jobs |
 |-------|----------|-------------|
-| `ci-base-latest` | Python 3.12 + devx[ci] + tea | detect-changes, detect-type, validate-commit-msg, pr-review, auto-merge, sync-wiki, vikunja, configure-repo |
-| `ci-quality-latest` | ci-base + devx[lint] + actionlint + checkmake + hadolint | quality, badges |
-| `ci-full-latest` | ci-quality + devx[release,molecule,deploy] + git-cliff + OpenTofu | release, publish, release-dry-run, molecule-tests, deploy jobs |
+| `ci-base-latest` | Python 3.12 + devx[ci] + tea | auto-merge, detect-and-configure |
+| `ci-quality-latest` | ci-base + devx[lint] + actionlint + checkmake + hadolint | (badges in release-and-maintain uses ci-full) |
+| `ci-full-latest` | ci-quality + devx[release,molecule,deploy] + git-cliff + OpenTofu | validate, release-and-maintain, molecule-tests, build-and-push |
 
 **Build process** (in `build-images.yml` workflow):
 1. `ci-base` builds FROM `gitea/runner-images:ubuntu-latest`
@@ -502,9 +552,9 @@ Each image is tagged `latest` and pushed to
 **Using images in workflows**:
 ```yaml
 jobs:
-  quality:
+  validate:
     runs-on: docker
-    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-quality:latest
+    container: git.oblachno.oblachno.fyi/oblachno-oss/runner-images/ci-full:latest
     steps:
       - uses: actions/checkout@v4
       - name: Set up environment
@@ -586,7 +636,7 @@ the user should not need to specify which profile to use.
 
 | Profile | Purpose |
 |---------|---------|
-| `ci-investigator` | Investigate CI failures (quality, release, publish, wiki sync, image build) |
+| `ci-investigator` | Investigate CI failures (validate, release-and-maintain, build-images) |
 | `dep-upgrader` | Python dependency upgrades in pyproject.toml with dep-doc validation |
 | `docker-image-builder` | Build/push/cleanup 3-tier runner images (ci-base, ci-quality, ci-full) |
 | `doc-sync-specialist` | Doc coverage, doc linting, wiki sync integrity |
@@ -596,7 +646,7 @@ the user should not need to specify which profile to use.
 
 | Trigger | Profile | Mode |
 |---------|---------|------|
-| CI run failure (quality, release, publish, sync-wiki, build-images) | `ci-investigator` | Background |
+| CI run failure (validate, release-and-maintain, build-images) | `ci-investigator` | Background |
 | PR ready for review | `pr-reviewer` | Foreground |
 | Dependency upgrade requested | `dep-upgrader` | Background |
 | Docker image build/push needed | `docker-image-builder` | Background |
@@ -610,7 +660,7 @@ the user should not need to specify which profile to use.
 2. **Background by default, foreground when blocking.**
 3. **Provide full context in the prompt** — subagents don't inherit conversation history.
 4. **One subagent per concern.** Chain: investigate → fix in main session → review.
-5. **Don't delegate trivial work** (<30s, <50 lines of context).
+5. **Don't delegate minor work** (<30s, <50 lines of context).
 6. **Compact after subagent returns.**
 7. **Never skip delegation to save time** — it keeps main context small.
 

CHANGELOG.md

@@ -2,6 +2,289 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.50.4] - 2026-08-12
+
+### Bug Fixes
+
+- Add tenacity retry to install_tools._download for transient network failures
+
+## [0.50.3] - 2026-08-12
+
+### Refactor
+
+- Extract wait_for_checks, consolidate ansible_checks, deprecate ci/discover_runners
+
+## [0.50.2] - 2026-08-12
+
+### Bug Fixes
+
+- Run molecule destroy on test failure to clean up containers
+
+## [0.50.1] - 2026-08-12
+
+### Bug Fixes
+
+- Configure git remote with CI token for post-merge push
+
+## [0.50.0] - 2026-08-12
+
+### Features
+
+- Sync missing features from v0.49.x line to master
+## [0.49.5] - 2026-08-07
+
+### Performance
+
+- Skip dep resolution in setup-image with --no-deps
+## [0.49.4] - 2026-08-07
+
+### Bug Fixes
+
+- Add container.credentials for private registry auth
+## [0.49.3] - 2026-08-07
+
+### Bug Fixes
+
+- Retry ansible-galaxy collection install on transient timeouts
+## [0.49.2] - 2026-08-07
+
+### Bug Fixes
+
+- Add fallback URL for tea download
+## [0.49.1] - 2026-08-07
+
+### Bug Fixes
+
+- Add container images to build-images workflow
+## [0.49.0] - 2026-08-07
+
+### Features
+
+- Add --include-roles and --exclude-roles to distribute_molecule
+## [0.48.0] - 2026-07-22
+
+### Features
+
+- Extract reusable components from infra and grm into devx
+
+## [0.49.5] - 2026-08-07
+
+### Performance
+
+- Skip dep resolution in setup-image with --no-deps
+
+## [0.49.4] - 2026-08-07
+
+### Bug Fixes
+
+- Add container.credentials for private registry auth
+
+## [0.49.3] - 2026-08-07
+
+### Bug Fixes
+
+- Retry ansible-galaxy collection install on transient timeouts
+
+## [0.49.2] - 2026-08-07
+
+### Bug Fixes
+
+- Add fallback URL for tea download
+
+## [0.49.1] - 2026-08-07
+
+### Bug Fixes
+
+- Add container images to build-images workflow
+
+## [0.49.0] - 2026-08-07
+
+### Features
+
+- Add --include-roles and --exclude-roles to distribute_molecule
+## [0.48.0] - 2026-07-22
+
+### Features
+
+- Extract reusable components from infra and grm into devx
+
+## [0.48.0] - 2026-07-22
+
+### Features
+
+- Extract reusable components from infra and grm into devx
+
+## [Unreleased]
+
+### Features
+
+- Extract reusable components from infra and grm into devx:
+  - `devx.utils.ui.say()` — unified click.echo + logging output
+  - `devx.utils.api.APIClient` — base HTTP API client class with retry logic
+  - `devx.utils.jinja` — Jinja2 environment helpers with Ansible-compatible filters
+  - `devx.i18n.configure_i18n()` — configurable `lang_env_var` and `translations_path_env_var`
+  - `devx.ci.cancel_superseded_runs` — cancel in-flight CI runs for the same PR branch
+  - `devx.ci.check_workflow_artifact_deps` — verify artifact download jobs depend on upload jobs
+  - `devx.ci.check_workflow_tofu_init` — verify tofu-state jobs have a tofu-init step
+  - `devx.tools.check_docker_init` — check Docker Compose services with healthchecks have init: true
+  - `devx.tools.check_ansible_set_fact_to_json` — check set_fact tasks don't misuse to_json
+  - `devx.tools.check_alert_rules` — validate Prometheus alert rules with promtool
+- Add `jinja2` and `pyyaml` as core dependencies (previously in `deploy` extras only)
+- Register new CLI commands: `devx ci cancel-superseded-runs`, `devx ci check-workflow-artifact-deps`,
+  `devx ci check-workflow-tofu-init`, `devx tools check-docker-init`,
+  `devx tools check-ansible-set-fact-to-json`, `devx tools check-alert-rules`
+- Add Makefile targets for all new check tools
+
+## [0.47.3] - 2026-07-17
+
+### Bug Fixes
+
+- Bake promtool into ci-full image, add download timeout, speed up tests
+
+## [0.47.2] - 2026-07-17
+
+### Bug Fixes
+
+- Add retry logic to TeaCLI for transient HTTP errors (502/503/504/429)
+
+## [0.47.1] - 2026-07-16
+
+### Bug Fixes
+
+- Tea CLI login failure handling, error messages, release retry
+
+## [0.47.0] - 2026-07-14
+
+### Features
+
+- Add promtool to install_tools for alert rule validation
+
+## [0.46.0] - 2026-07-14
+
+### Features
+
+- Make check_test_isolation configurable via pyproject.toml
+
+## [0.45.1] - 2026-07-14
+
+### Bug Fixes
+
+- URL-encode package names and versions in clean_images API calls
+
+## [0.45.0] - 2026-07-14
+
+### Features
+
+- Add IO_INTERNAL_CALLS to check_test_isolation
+
+## [0.44.2] - 2026-07-14
+
+### Bug Fixes
+
+- Use legacy Docker builder to avoid Gitea registry 403
+
+## [0.44.1] - 2026-07-14
+
+### Bug Fixes
+
+- Disable Docker buildx provenance attestation
+
+## [0.44.0] - 2026-07-13
+
+### Features
+
+- Add fix_pr_title module and update_pr API method
+
+## [0.43.0] - 2026-07-13
+
+### Features
+
+- Add get_customer_vm_ip and get_observability_vm_ip to I/O check
+
+## [0.42.0] - 2026-07-13
+
+### Features
+
+- Add I/O function isolation check and skip integration tests
+
+## [0.41.2] - 2026-07-13
+
+### Bug Fixes
+
+- Auto-discover molecule root instead of hardcoding gitea-runner
+
+## [0.41.1] - 2026-07-13
+
+### Bug Fixes
+
+- Check_test_isolation accepts multiple --test-path values
+
+## [0.41.0] - 2026-07-13
+
+### Features
+
+- Test isolation pytest plugin, shift-left quality gates, dep upgrades
+
+## [0.40.1] - 2026-07-12
+
+### Bug Fixes
+
+- Fall back to CI token when reviewer self-approval is rejected
+
+## [0.40.0] - 2026-07-11
+
+### Features
+
+- Detect double-prefix in Vikunja task title during pre-merge validation
+
+## [0.39.0] - 2026-07-09
+
+### Features
+
+- Extract shared utilities from infra and grm into devx
+
+## [0.38.0] - 2026-07-08
+
+### Features
+
+- Introduce role-based Gitea API token environment variables
+
+## [0.37.0] - 2026-07-07
+
+### Features
+
+- Consolidate docs checks into devx-docs-check target
+
+## [0.36.2] - 2026-07-07
+
+### Bug Fixes
+
+- GiteaClient.set_repo_variable uses PUT instead of PATCH
+
+## [0.36.1] - 2026-07-07
+
+### Bug Fixes
+
+- Preserve .badges/ dir during git clean in push_badges
+
+## [0.36.0] - 2026-07-07
+
+### Features
+
+- Add GiteaClient repo variable methods and parallelize pytest-cov
+
+## [0.35.7] - 2026-07-06
+
+### Bug Fixes
+
+- Use Gitea wiki dash-marker filename convention
+
+## [0.35.6] - 2026-07-06
+
+### Bug Fixes
+
+- Add delay before wiki verification to avoid race condition
+
 ## [0.35.5] - 2026-07-06
 
 ### Bug Fixes

Makefile

@@ -1,4 +1,5 @@
 .PHONY: all setup setup-ci setup-quality setup-release setup-image install update lint lint-all lint-dockerfiles test test-unit pytest-cov clean install-tools install-hooks activate-scripts checkmake check-mutable-globals check-dep-docs check-test-speed build-images push-images build-images-dry-run clean-images
+.PHONY: check-workflow-artifact-deps check-workflow-tofu-init check-docker-init check-ansible-set-fact-to-json check-alert-rules
 
 PYTHON := python3
 VENV := .venv
@@ -65,7 +66,7 @@ setup-release: $(VENV)/bin/activate .env
 # an older devx.mak that doesn't yet define devx-setup-image. Consumer repos
 # (grm, infra) can safely alias to devx-setup-image since they install devx from PyPI.
 setup-image:
-	@if [ -d /opt/venv ]; then ln -sf /opt/venv $(VENV); . $(VENV)/bin/activate && pip install --no-cache-dir -e . 2>/dev/null; \
+	@if [ -d /opt/venv ]; then ln -sf /opt/venv $(VENV); . $(VENV)/bin/activate && pip install --no-cache-dir --no-deps -e . 2>/dev/null; \
 	else echo "[setup-image] /opt/venv not found — falling back to setup-ci"; $(MAKE) setup-ci; fi
 
 install-hooks:
@@ -81,7 +82,7 @@ install-tools: $(VENV)/bin/activate
 .PHONY: lint-ruff lint-format typecheck lint-bandit lint-deps lint
 .PHONY: workflow-lint workflow-dryrun workflow-dryrun-safe workflow-check
 .PHONY: notify-failure checkmake check-mutable-globals check-dep-docs
-.PHONY: check-test-speed check-test-coverage check-docs
+.PHONY: check-test-speed check-test-coverage check-docs check-test-isolation check-translations
 .PHONY: create-task create-pr push-with-pr git-push rebase pr-rebase
 .PHONY: lint-all lint-dockerfiles
 lint-ruff: devx-lint-ruff
@@ -99,6 +100,8 @@ checkmake: devx-checkmake
 check-mutable-globals: devx-check-mutable-globals
 check-dep-docs: devx-check-dep-docs
 check-test-speed: devx-check-test-speed
+check-test-isolation: devx-check-test-isolation
+check-translations: devx-check-translations
 check-test-coverage: devx-check-test-coverage
 check-docs: devx-check-docs
 create-task: devx-create-task
@@ -111,6 +114,31 @@ pr-rebase: devx-pr-rebase
 lint-all: lint workflow-lint lint-dockerfiles
 	@echo "[lint-all] All linting checks passed."
 
+# ── Workflow / Ansible / Docker check tools ─────────────────────────────────
+# Generic check tools ported from infra. These targets are no-ops in devx
+# itself (no .gitea/workflows or ansible/ directory) but provide the
+# canonical entry points for consumer repos that include devx.mak.
+
+check-workflow-artifact-deps:
+	@$(BIN)/python -m devx.ci.check_workflow_artifact_deps || \
+		echo "[check-workflow-artifact-deps] No workflows directory found — skipping."
+
+check-workflow-tofu-init:
+	@$(BIN)/python -m devx.ci.check_workflow_tofu_init || \
+		echo "[check-workflow-tofu-init] No workflows directory found — skipping."
+
+check-docker-init:
+	@$(BIN)/python -m devx.tools.check_docker_init || \
+		echo "[check-docker-init] No ansible templates found — skipping."
+
+check-ansible-set-fact-to-json:
+	@$(BIN)/python -m devx.tools.check_ansible_set_fact_to_json || \
+		echo "[check-ansible-set-fact-to-json] No ansible directory found — skipping."
+
+check-alert-rules:
+	@$(BIN)/python -m devx.tools.check_alert_rules --template-path ansible/roles/observability/templates || \
+		echo "[check-alert-rules] No alert-rules template found — skipping."
+
 # Note: Not aliased to devx-lint-dockerfiles for the same reason as setup-image —
 # devx's own CI images may have an older devx.mak. Consumer repos can safely alias.
 lint-dockerfiles:

README.md

@@ -12,16 +12,16 @@ opinionated CI/CD pipeline: conventional commits, automated versioning via
 git-cliff, squash-merge automation, Vikunja task tracking, wiki sync, and
 quality badges.
 
-> An open-source project from **Oblachno** (облачно means *cloudy* in Bulgarian).
+> An open source project from **Oblachno** (облачно means *cloudy* in Bulgarian).
 
 [![CI](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions/workflows/ci.yml/badge.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
 [![License: GPL-3.0](https://img.shields.io/badge/license-GPL--3.0-blue)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/src/branch/master/LICENSE)
-[![Coverage](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/coverage.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
-[![Tests](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/tests.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
-[![Docs](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/docs.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/wiki)
-[![Code Quality](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/quality.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
-[![Version](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/version.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/releases)
-[![Python](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/python.svg)](https://www.python.org/downloads/)
+[![Coverage](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/coverage.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
+[![Tests](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/tests.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
+[![Docs](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/docs.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/wiki)
+[![Code Quality](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/quality.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
+[![Version](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/version.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/releases)
+[![Python](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/python.svg)](https://www.python.org/downloads/)
 
 ## Why devx?
 
@@ -87,7 +87,7 @@ extra index and list devx in your dependencies:
 ```toml
 [project]
 dependencies = [
-    "devx>=0.35.5",
+    "devx>=0.50.4",
 ]
 
 [tool.pip]
@@ -101,8 +101,8 @@ pip install -e .
 ```
 
 > **Note:** If your project requires a specific devx version, pin it in
-> `dependencies` (for example, `"devx==0.35.5"`) or use a version constraint
-> (for example, `"devx>=0.35.5,<0.36"`).
+> `dependencies` (for example, `"devx==0.50.4"`) or use a version constraint
+> (for example, `"devx>=0.50.4,<0.51"`).
 
 ### Optional extras
 
@@ -226,10 +226,6 @@ python -m devx.molecule.distribute_molecule --runner-index 1 --max-runners 3
 python -m devx.molecule.distribute_molecule --list              # list all scenarios
 python -m devx.molecule.distribute_molecule --list-platforms    # list platforms
 
-# Run molecule tests with cross-runner fail-fast
-python -m devx.molecule.molecule_ci_guard pair1 pair2
-python -m devx.molecule.molecule_ci_guard --roles-root ansible/roles pair1 pair2
-
 # Run all molecule scenarios locally (sequential)
 python -m devx.molecule.molecule_all
 python -m devx.molecule.molecule_all --bin .venv/bin
@@ -303,7 +299,6 @@ devx --version
 | `devx molecule all` | Run all molecule scenarios on all supported platforms |
 | `devx molecule discover-runners` | Discover available Gitea Actions runners |
 | `devx molecule distribute` | Distribute molecule test pairs across parallel runners |
-| `devx molecule guard` | Run molecule tests with CI failure polling |
 
 See [CLI Commands](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/wiki/CLI-Commands)
 in the wiki for full command documentation with examples.
@@ -372,7 +367,7 @@ infrastructure = []
 
 # Files that would default to user-facing but are actually infrastructure
 infrastructure_overrides = [
-    "src/myproject/__init__.py",  # only contains __version__
+    "src/myproject/__init__.py",  # example only — only contains __version__
 ]
 
 # Safety override for broad infrastructure patterns

docker/ci-full/Dockerfile

@@ -20,11 +20,6 @@ COPY . /tmp/devx
 RUN pip install --no-cache-dir /tmp/devx[release,molecule,deploy] \
     && rm -rf /tmp/devx
 
-# Install git-cliff (changelog generator for release job)
-RUN python3 -m devx.tools.install_tools --tool git-cliff
-
-# Install OpenTofu (for infra deploy jobs)
-RUN ARCH=$(uname -m | sed 's/x86_64/amd64/') \
-    && VERSION=1.12.3 \
-    && curl -fsSL "https://github.com/opentofu/opentofu/releases/download/v${VERSION}/tofu_${VERSION}_$(uname -s | tr '[:upper:]' '[:lower:]')_${ARCH}.tar.gz" \
-    | tar -xz -C /usr/local/bin tofu
+# Install git-cliff (changelog generator for release job), OpenTofu (for infra deploy jobs),
+# and promtool (Prometheus rule validator — used by every infra CI run for alert validation)
+RUN python3 -m devx.tools.install_tools --tool git-cliff --tool tofu --tool promtool

docker/ci-quality/Dockerfile

@@ -13,10 +13,5 @@ RUN pip install --no-cache-dir /tmp/devx[lint] \
     && rm -rf /tmp/devx
 
 # Install CI/CD binary tools
-RUN python3 -m devx.tools.install_tools --tool actionlint \
+RUN python3 -m devx.tools.install_tools --tool actionlint --tool vale --tool hadolint \
     && python3 -m devx.tools.install_checkmake
-
-# Install hadolint (Dockerfile linter)
-RUN curl -fsSL "https://github.com/hadolint/hadolint/releases/download/v2.12.0/hadolint-Linux-x86_64" \
-    -o /usr/local/bin/hadolint \
-    && chmod +x /usr/local/bin/hadolint

docs/decisions/0001-test-isolation-pytest-plugin-and-shift-left-quality-gates.md

@@ -0,0 +1,173 @@
+# ADR-0001: Test Isolation Pytest Plugin and Shift-Left Quality Gates
+
+Date: 2026-07-13
+Status: Accepted
+
+## Context
+
+Unit tests in devx were slow (10s+) and getting slower. Investigation
+revealed two root causes:
+
+1. **Unpatched subprocess calls** — test functions calling
+   `subprocess.run`, `update_doc_versions`, or `run_cmd` without
+   `@patch` decorators, causing real subprocess execution during tests.
+2. **Excessive iterations** — statistical tests with 1000-iteration
+   loops that should use property-based testing or smaller samples.
+
+These issues were discovered manually by profiling with
+`pytest --durations=0`. There was no automated check to prevent
+regressions — new tests could introduce the same patterns and slow
+down the suite again.
+
+Additionally, translation completeness checks
+(`devx.ci.check_translations`) only ran in CI, not locally. Developers
+discovered missing translations at CI time, wasting round-trips.
+
+## Decision
+
+### 1. Test Isolation as a Pytest Plugin (pytest11 entry point)
+
+Implement the test isolation check as a **pytest plugin** registered
+via the `pytest11` entry point in `pyproject.toml`:
+
+```toml
+[project.entry-points.pytest11]
+devx_test_isolation = "devx.tools.check_test_isolation"
+```
+
+This makes the check **transparent and always-on** — every `pytest`
+invocation in any repo with devx installed automatically runs the
+static analysis. No extra Makefile target or CI step needed.
+
+The plugin (`devx.tools.check_test_isolation`) statically analyzes
+test files during `pytest_collection_finish` and **fails the test run**
+on any hard violation:
+
+- **unpatched-subprocess**: `subprocess.run/call/Popen/check_call/check_output`
+  called in a test function without `@patch` or `with patch(...)`
+- **unpatched-sleep**: `time.sleep` called without `@patch`
+- **unpatched-helper**: known subprocess-spawning helpers
+  (`update_doc_versions`, `run_cmd`, `run_tests`) called without
+  `@patch` (and without patching their internal dependencies)
+- **excessive-iterations**: `for _ in range(N)` where N > 100
+- **heavy-module-import**: `httpx`, `ansible`, etc. imported at module
+  level in test files, slowing collection for all tests
+- **reload-without-cleanup**: `importlib.reload()` called an odd number
+  of times, leaving module state modified
+
+Transitive-subprocess findings (via call-graph analysis) are reported
+as **advisories** — the static analysis can't predict early exits or
+runtime branch conditions, so the runtime audit is authoritative.
+
+The plugin also wraps `subprocess.run` at runtime to catch real
+subprocess calls that leak through transitive call paths (for example
+`CliRunner.invoke(main)` → `main()` → `update_doc_versions()` →
+`subprocess.run()`). If a test spawns a real subprocess without
+`@patch`, the test fails.
+
+A standalone CLI (`python -m devx.tools.check_test_isolation`) is also
+provided for CI gates and pre-commit hooks where pytest isn't run.
+
+### 2. Shift-Left Quality Gates in `make lint`
+
+Add `devx-check-translations` and `devx-check-test-isolation` to the
+`devx-lint` target in `devx.mak`. This means `make lint` now runs:
+
+- ruff check + format
+- pyright typecheck
+- bandit security scan
+- **translation completeness** (missing keys, dead keys, missing languages)
+- **test isolation** (unpatched subprocess, time.sleep, excessive loops)
+
+These were previously CI-only checks. Running them in `make lint`
+catches issues at the developer's machine, not in CI.
+
+### 3. Pre-commit Hook Coverage
+
+Update the pre-commit hook to run all three shift-left checks:
+test speed, translation completeness, and test isolation. This
+catches issues even earlier than `make lint` — before the commit
+is even created.
+
+## Consequences
+
+### Positive
+
+- **Automatic enforcement**: The pytest plugin runs on every `pytest`
+  invocation across devx, grm, and infra — no per-repo configuration
+  needed. New tests with unpatched subprocess calls fail immediately.
+- **Shift-left**: Translation gaps and test isolation violations are
+  caught locally (pre-commit / `make lint`) instead of in CI.
+- **Fast feedback**: Static analysis adds <0.1s to test runs; runtime
+  subprocess audit adds negligible overhead (wrapper checks a
+  thread-local flag).
+- **Transitive detection**: The call-graph BFS traces
+  `CliRunner.invoke(main)` → `main()` → `update_doc_versions()` →
+  `subprocess.run()`, catching indirect subprocess leaks that direct
+  analysis misses. The runtime audit provides authoritative enforcement.
+- **No false positives**: The call graph correctly recognizes that
+  patching `run_cmd` makes `run_tests` (which calls `run_cmd`) safe,
+  and class methods are excluded to avoid false positives when classes
+  like `TeaCLI` are patched.
+
+### Negative
+
+- **Coverage instrumentation gap**: The pytest plugin module is loaded
+  before coverage starts, so module-level code (decorators, class
+  definitions) appears uncovered. Mitigated by `-p no:devx_test_isolation`
+  in devx's own `pyproject.toml` `addopts` and `# pragma: no cover` on
+  plugin hook functions.
+- **Static analysis limitations**: The call-graph BFS can't predict
+  runtime branch conditions or early exits — a test that patches
+  `shutil.which` to return `None` may skip the subprocess path
+  entirely, but the static analysis still reports it. Transitive
+  findings are advisories (exit 0) for this reason; the runtime audit
+  is authoritative.
+- **Translation burden**: Every new `_()` call in source requires
+  adding 6 language translations. This is by design (all supported
+  languages must be complete) but adds friction for quick prototypes.
+
+## Implementation Details
+
+### Pytest Plugin Discovery
+
+The `pytest11` entry point is the standard mechanism for pytest
+plugins. When devx is installed (via pip), pytest auto-discovers
+the plugin. No `conftest.py` or `pytest_plugins` declaration needed
+in consumer repos.
+
+### Disabling the Plugin
+
+- `--no-test-isolation` flag: disables static analysis and runtime
+  subprocess audit for a single run
+- `-p no:devx_test_isolation` in `addopts`: disables for a repo
+  (used in devx's own `pyproject.toml` for coverage reasons)
+
+### Call-Graph Analysis
+
+The `CallGraph` class parses all `.py` files under `src/` and builds
+a map of function → called functions. When a test calls
+`CliRunner.invoke(target)`, a BFS traces the call graph from `target`
+to find all reachable functions. Class methods are excluded from the
+call graph to avoid false positives when classes are patched (for example
+`@patch("...TeaCLI")` mocks all methods). The BFS respects `@patch`
+decorators — if a function is patched, traversal stops at that node.
+
+### Runtime Subprocess Audit
+
+The `_SubprocessAudit` singleton wraps `subprocess.run`, `call`,
+`check_call`, `check_output`, and `Popen` with thread-local
+recording wrappers. During each non-integration test, the wrapper
+records calls; if any are recorded (that is the test didn't `@patch`
+subprocess), the test fails. The wrappers check a thread-local flag,
+so inactive audits have zero overhead beyond the flag check.
+
+### Known Subprocess Helpers
+
+The `KNOWN_SUBPROCESS_HELPERS` dict maps function names to
+descriptions. `HELPER_INTERNAL_CALLS` maps each helper to the
+function names it internally calls, enabling transitive safety
+checks for direct calls in test functions. The call-graph BFS
+handles transitive detection for `CliRunner.invoke` targets. Both
+are defined in `check_test_isolation.py` and can be extended as
+new subprocess-spawning helpers are added to devx.

docs/decisions/0002-ansible-check-consolidation-and-wait-for-checks.md

@@ -0,0 +1,108 @@
+# ADR-0002: Ansible Check Tool Consolidation and wait_for_checks Extraction
+
+Date: 2026-08-12
+Status: Accepted
+
+## Context
+
+The devx package had two categories of code duplication and inline
+workflow logic that were hard to test and maintain:
+
+### 1. Ansible Check Tools — Duplicated Boilerplate
+
+Five Ansible check tools (`check_ansible_no_log`,
+`check_ansible_patterns`, `check_ansible_set_fact_to_json`,
+`check_ansible_no_state_absent_on_db`, `check_jinja_expr`) each
+implemented their own file discovery, YAML parsing, task iteration, and
+violation reporting logic. While the check logic differed, the
+supporting infrastructure was copy-pasted across all five modules:
+
+- `find_task_files()` — glob YAML files, skip molecule
+- YAML multi-document parsing with error handling
+- Task iteration (bare lists, play dicts with `tasks`/`pre_tasks`/`post_tasks`/`handlers`, nested `block` tasks)
+- Violation formatting (`path:line — message`)
+
+This made it difficult to add new checks (each new tool repeated the
+boilerplate) and risky to change shared behavior (fixes had to be
+applied to all five modules independently).
+
+### 2. Inline Job Polling in Workflow YAML
+
+The `grm` repository's `ci.yml` workflow contained ~25 lines of inline
+shell + Python polling logic to wait for the `molecule-tests` job to
+complete before the auto-merge step. This logic:
+
+- Was not testable (embedded in workflow YAML)
+- Duplicated the Gitea API client pattern already used elsewhere
+- Had no timeout handling, no error reporting, no retry logic
+- Could not be reused by other repositories
+
+### 3. Duplicate discover_runners Modules
+
+`devx.ci.discover_runners` and `devx.molecule.discover_runners` were
+near-identical modules. The `ci/` version had better error logging
+(warnings on non-200 responses, 403 suppression for instance-level
+queries), while the `molecule/` version silently swallowed errors.
+Both were imported by different workflows, making it unclear which was
+canonical.
+
+## Decision
+
+### 1. Composable `ansible_checks/` Subpackage
+
+Consolidate the five Ansible check tools into a
+`devx.tools.ansible_checks/` subpackage with shared utilities:
+
+- `_shared.py` — `AnsibleFileFinder`, `AnsibleYAMLParser`,
+  `ViolationReporter` classes providing composable helpers
+- `no_log.py`, `patterns.py`, `set_fact_to_json.py`,
+  `no_state_absent_on_db.py`, `jinja_expr.py` — canonical check
+  implementations using the shared utilities
+
+The old modules (`check_ansible_*.py`, `check_jinja_expr.py`) remain as
+**thin backward-compat wrappers** that re-export the canonical
+implementation and preserve the CLI entry point. This avoids breaking
+existing Makefile targets and workflow references.
+
+**Composition over inheritance**: each check module picks the helpers it
+needs. Tools that don't parse YAML (for example line-based scanners) can skip
+`AnsibleYAMLParser` entirely.
+
+### 2. Extracted `wait_for_checks` Module
+
+Extract the inline polling logic into `devx.ci.wait_for_checks`:
+
+- Polls the Gitea API for job completion status
+- Configurable job name prefix, timeout, poll interval
+- Exit codes: 0 (success), 1 (failure), 2 (timeout), 3 (API error)
+- `--require-success/--no-require-success` flag for flexibility
+- 100% test coverage with mocked API responses
+
+This replaces the inline shell polling in `grm` `ci.yml` with a
+reusable, testable Python module.
+
+### 3. Deprecated `ci/discover_runners` Wrapper
+
+Merge the `ci/discover_runners` implementation (with its better error
+logging) into `molecule/discover_runners` as the canonical version.
+Make `ci/discover_runners` a deprecated wrapper that:
+
+- Re-exports all public symbols from `molecule.discover_runners`
+- Emits a `DeprecationWarning` when run as `__main__`
+- Preserves backward compatibility for existing workflow references
+
+New code should import from `devx.molecule.discover_runners` directly.
+
+## Consequences
+
+- **New checks are easier to write**: import `_shared` helpers, implement
+  only the check-specific logic
+- **Shared behavior can be fixed in one place**: file discovery, YAML
+  parsing, violation formatting
+- **Workflow polling is testable**: `wait_for_checks` has 26 unit tests
+  covering success, failure, timeout, and API error scenarios
+- **Backward compatibility preserved**: all existing Makefile targets,
+  workflow references, and test imports continue to work via wrappers
+- **Migration path is gradual**: new code uses the subpackage; old code
+  can migrate at its own pace; wrappers can be removed in a future
+  release once all references are updated

docs/index.md

@@ -8,16 +8,16 @@ parallel test distribution, and more into a single installable package.
 It was extracted from the [GRM](https://git.oblachno.oblachno.fyi/oblachno-oss/grm)
 project to be reusable across all oblachno-oss repositories.
 
-> An open-source project from **Oblachno** (облачно means *cloudy* in Bulgarian).
+> An open source project from **Oblachno** (облачно means *cloudy* in Bulgarian).
 
 [![CI](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions/workflows/ci.yml/badge.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
 [![License: GPL-3.0](https://img.shields.io/badge/license-GPL--3.0-blue)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/src/branch/master/LICENSE)
-[![Coverage](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/coverage.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
-[![Tests](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/tests.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
-[![Docs](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/docs.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/wiki)
-[![Code Quality](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/quality.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
-[![Version](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/version.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/releases)
-[![Python](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/40fbd801952eefafe3876bef53a09d217267f810/python.svg)](https://www.python.org/downloads/)
+[![Coverage](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/coverage.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
+[![Tests](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/tests.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
+[![Docs](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/docs.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/wiki)
+[![Code Quality](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/quality.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/actions)
+[![Version](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/version.svg)](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/releases)
+[![Python](https://git.oblachno.oblachno.fyi/oblachno-oss/devx/raw/commit/1b620bc1ac52cad884e501093d4fba5d3968ce67/python.svg)](https://www.python.org/downloads/)
 
 ## Overview
 
@@ -74,14 +74,14 @@ Add devx to your `pyproject.toml` dependencies and configure the registry:
 ```toml
 [project]
 dependencies = [
-    "devx>=0.35.5",
+    "devx>=0.50.4",
 ]
 
 [tool.pip]
 extra-index-url = "https://git.oblachno.oblachno.fyi/api/packages/oblachno-oss/pypi/simple"
 ```
 
-Pin a specific version if needed: `"devx==0.35.5"` or `"devx>=0.35.5,<0.36"`.
+Pin a specific version if needed: `"devx==0.50.4"` or `"devx>=0.50.4,<0.51"`.
 
 ### Optional extras
 
@@ -104,8 +104,8 @@ devx is a self-contained Python package under `src/devx/`:
 - **Dev tools** (`devx.tools`) — setup, install_tools, check_test_speed,
   configure_repo, generate_badges, generate_cliff_config, install_checkmake
 - **Molecule tools** (`devx.molecule`) — Optional, for projects with Ansible
-  roles: distribute_molecule, molecule_ci_guard, molecule_all, discover_runners,
-  start_docker, platforms
+  roles: distribute_molecule, molecule_all, discover_runners, start_docker,
+  platforms
 
 See [Architecture](Architecture) for the full package structure, module
 descriptions, design principles, and data flow diagrams.
@@ -132,7 +132,7 @@ devx provides a `devx` CLI with three command groups:
 
 - `devx ci <command>` — CI/CD automation (17 commands)
 - `devx tools <command>` — Developer tools (9 commands)
-- `devx molecule <command>` — Molecule testing (4 commands, optional)
+- `devx molecule <command>` — Molecule testing (3 commands, optional)
 
 See [CLI Commands](CLI-Commands) for full command documentation with examples.
 

docs/mapping.json

@@ -3,5 +3,7 @@
   "user/getting-started.md": "Getting-Started",
   "user/cli-commands.md": "CLI-Commands",
   "tech/architecture.md": "Architecture",
-  "tech/ci-cd-workflow.md": "CI-CD-Workflow"
+  "tech/ci-cd-workflow.md": "CI-CD-Workflow",
+  "decisions/0001-test-isolation-pytest-plugin-and-shift-left-quality-gates.md": "ADR-0001-Test-Isolation",
+  "decisions/0002-ansible-check-consolidation-and-wait-for-checks.md": "ADR-0002-Ansible-Check-Consolidation"
 }

docs/retrospectives/2026-07-12-self-approval-fallback-and-ci-consolidation.md

@@ -0,0 +1,158 @@
+# Retrospective: Self-Approval Fallback and CI Consolidation
+
+## Date
+2026-07-12
+
+## Context
+The devx package (reusable CI/CD tools) underwent two significant
+changes during this period: workflow consolidation (DEVX-126) and the
+self-approval fallback fix (DEVX-127). The self-approval bug was the
+last remaining blocker for end-to-end automated CI/CD across all
+oblachno repos. This retrospective covers devx v0.40.0 through v0.40.1.
+
+## Scope
+
+PRs: DEVX-125 (double-prefix detection), DEVX-126 (CI consolidation),
+DEVX-127 (self-approval fallback). ~16 commits including release/badge
+churn.
+
+## Timeline of Key Failures
+
+| Run   | Issue                                        | Fix Commit |
+|--------|----------------------------------------------|------------|
+| infra #2562 | Self-approval rejected (403)           | `d035b62` |
+| devx CI | Auto-merge review body too short (< 20 chars) | `fc613d4` |
+| devx CI | test_setup flaky due to PIP_BREAK_SYSTEM_PACKAGES | `043f259` |
+| devx CI | Missing translations for self-approval messages | `0d8c7f5` |
+
+## What Served Us Well
+
+- **Test-driven fix for pr_review.py.** The self-approval fallback was
+  implemented with full test coverage before being deployed. Tests
+  covered both the fallback-available and fallback-unavailable paths,
+  ensuring the code was correct before it hit CI.
+- **i18n enforcement caught missing translations.** The translation
+  completeness check flagged the new self-approval error messages that
+  were added without corresponding translation entries. This prevented
+  untranslated strings from reaching production.
+- **Consolidated CI workflow.** DEVX-126 merged 7 separate CI jobs into
+  a single `validate` job, reducing runner overhead and eliminating
+  inter-job dependency issues. The consolidation pattern was then
+  applied to grm and infra.
+- **Conventional commit enforcement.** The `validate_commit_msg` check
+  caught a double-prefix in the Vikunja task title (DEVX-125), which
+  would have caused auto-merge validation failures downstream.
+
+## What Slowed Us Down
+
+### 1. Self-Approval Bug Not Caught Earlier (1 infra CI failure)
+
+The `pr_review.py` script used the `REVIEWER_GITEA_API_TOKEN` for
+APPROVE events. When the token belonged to the PR author, Gitea
+rejected the self-approval with 403. This was only discovered when the
+infra PR CI run #2562 failed — the devx CI had passed because devx PRs
+were reviewed by a different user.
+
+**Root cause:** No test simulated the self-approval rejection scenario.
+The tests mocked the Gitea API to always return 200 for review
+submissions.
+
+**Time wasted:** ~2 hours (cross-repo investigation + fix + test).
+
+**Fix:** Added fallback to `CI_GITEA_API_TOKEN` when the reviewer token
+is rejected with self-approval. The fallback is transparent — the
+script logs a warning and retries with the CI token.
+
+**Lesson:** Test API interactions against all HTTP error codes the
+external system can return, not only the happy path. For Gitea, this
+includes 403 (self-approval), 409 (conflict), and 422 (validation).
+
+### 2. Auto-Merge Review Body Length Check (1 CI failure)
+
+The auto-merge validation requires APPROVE review bodies to be > 20
+chars (to prevent perfunctory approvals). The automated review posted
+by `pr_review.py` had a body of exactly 17 chars, failing the check.
+
+**Root cause:** The review body was a generic "Automated review passed"
+message that was too short. The length check was added to prevent
+rubber-stamping by human reviewers, but it also affected automated
+reviews.
+
+**Time wasted:** ~1 CI run.
+
+**Fix:** Expanded the automated review body to include a summary of
+checked categories, ensuring it exceeds 20 chars.
+
+**Lesson:** Automated reviews need substantive bodies too. The length
+check doesn't distinguish between human and automated reviewers.
+
+### 3. test_setup Flaky Due to Environment Variable (1 CI failure)
+
+`test_setup.py` failed intermittently because `PIP_BREAK_SYSTEM_PACKAGES`
+was set in the CI environment but not in local tests. The test didn't
+isolate itself from the environment variable.
+
+**Root cause:** The test assumed a clean environment but CI sets
+`PIP_BREAK_SYSTEM_PACKAGES=1` globally. The test's behavior changed
+based on this env var.
+
+**Time wasted:** ~1 CI run.
+
+**Fix:** Isolated the test from the env var using `monkeypatch.delenv`.
+
+**Lesson:** Tests that interact with environment-dependent behavior
+should explicitly set or unset the relevant env vars, not assume
+defaults.
+
+### 4. Missing Translations for New Messages (1 CI failure)
+
+The self-approval fallback added new user-facing messages (warning
+about token fallback) but didn't add translations for all supported
+languages. The translation completeness check caught this.
+
+**Root cause:** New `click.echo()` calls were added with `_()` wrappers
+but the translation JSON wasn't updated.
+
+**Time wasted:** ~1 CI run.
+
+**Fix:** Added translations for all new messages in `translations.json`.
+
+**Lesson:** When adding new `_()` wrapped strings, update
+`translations.json` in the same commit. The i18n check is strict —
+100% completeness is required.
+
+## Improvements Implemented
+
+### 1. Self-Approval Fallback (HIGH impact)
+
+`pr_review.py` now falls back to `CI_GITEA_API_TOKEN` for APPROVE
+events when the reviewer token is rejected as self-approval. This
+unblocked auto-merge across all three repos.
+
+### 2. Double-Prefix Detection (MEDIUM impact)
+
+`check_auto_merge_ready.py` now detects and rejects Vikunja task titles
+that include the identifier prefix (for example, "DEVX-127: Fix").
+The validator adds the prefix automatically, so a double prefix would
+fail validation.
+
+### 3. CI Workflow Consolidation (MEDIUM impact)
+
+Merged 7 separate CI jobs into a single `validate` job, reducing runner
+overhead by ~5 min per CI run and eliminating inter-job dependency
+issues.
+
+## Action Items for Future Sessions
+
+1. **Test API interactions against all relevant HTTP error codes.**
+   Don't only test the happy path. For Gitea: 200, 201, 204, 403, 404,
+   409, 422.
+2. **Update translations in the same commit as new `_()` strings.**
+   The i18n check will fail otherwise.
+3. **Isolate tests from environment variables.** Use `monkeypatch.setenv`
+   or `monkeypatch.delenv` for any env var the test's behavior depends on.
+4. **Ensure automated review bodies are substantive (> 20 chars).**
+   Include a summary of checked categories.
+5. **When adding fallback logic, test both the fallback-available and
+   fallback-unavailable paths.** Both must be covered for 100% branch
+   coverage.

docs/tech/architecture.md

@@ -33,7 +33,8 @@ src/devx/
 │   ├── notify_failure.py    # Create Gitea issues on CI failures
 │   ├── distribute_files.py  # Distribute files across parallel runners
 │   ├── integration_guard.py # Run pytest with cross-runner fail-fast
-│   ├── discover_runners.py  # Dynamic Gitea runner discovery
+│   ├── discover_runners.py  # Deprecated wrapper → molecule/discover_runners
+│   ├── wait_for_checks.py  # Poll Gitea Actions for job completion
 │   ├── check_translations.py  # Translation completeness check
 │   └── doc_coverage.py      # Documentation coverage check
 ├── tools/                   # Developer tooling modules (run locally or by CI)
@@ -41,13 +42,14 @@ src/devx/
 │   ├── setup.py             # Environment setup (venv, deps, hooks, tea login)
 │   ├── install_tools.py     # Install actionlint, git-cliff, act_runner, tea
 │   ├── check_test_speed.py  # Measure unit test execution time
+│   ├── check_test_isolation.py  # Pytest plugin: detect un-hermetic test patterns
 │   ├── configure_repo.py    # Branch protection and label setup
 │   ├── generate_badges.py   # Badge SVG generation
 │   ├── generate_cliff_config.py  # Generate cliff.toml with correct prefix
 │   └── install_checkmake.py # Install checkmake (Makefile linter)
 └── molecule/                # Optional molecule testing helpers (Ansible projects)
     ├── __init__.py
-    ├── discover_runners.py      # Dynamic Gitea runner discovery
+    ├── discover_runners.py      # Dynamic Gitea runner discovery (canonical)
     ├── distribute_molecule.py   # Distribute scenarios across runners
     ├── molecule_ci_guard.py     # Run molecule with cross-runner fail-fast
     ├── molecule_all.py          # Run all molecule scenarios locally
@@ -86,11 +88,11 @@ overridden via environment variables with the `DEVX_` prefix. Provides:
 
 - `GITEA_API_URL` / `VIKUNJA_API_URL` — API endpoints
 - `REPO_OWNER` — repository owner (must be set per-project)
-- `TASK_PREFIX` / `TASK_ID_RE` — task ID prefix and regex (for example, `DEVX-N`)
+- `TASK_PREFIX` / `TASK_ID_RE` — task ID prefix and regular expression (for example, `DEVX-N`)
 - `VIKUNJA_PROJECT_ID` — Vikunja project for task tracking
 - `DEFAULT_TIMEOUT`, `DEFAULT_PER_PAGE` — HTTP client defaults
 - `MAX_RETRIES`, `RETRY_BACKOFF_BASE`, `RETRY_STATUS_CODES` — retry config
-- `CONVENTIONAL_RE` — conventional commit format regex
+- `CONVENTIONAL_RE` — conventional commit format regular expression
 
 ### `exceptions.py`
 
@@ -108,7 +110,7 @@ wraps user-facing strings for translation.
 
 Projects can extend translations by setting `DEVX_TRANSLATIONS_PATH` to a
 custom JSON file. Keys from the project's file are merged on top of devx's
-built-in translations, allowing projects to override or add keys without
+built-in translations, allowing projects to override, or add keys without
 modifying the package.
 
 ### `api_clients.py`
@@ -122,7 +124,9 @@ exponential backoff (2s, 4s, 8s).
 - Labels (list, create, add to issues)
 - Issues (create, list)
 - Pull requests (get commits, merge, create review)
-- Releases (list)
+- Releases (list, create idempotent)
+- Actions (list runs, list jobs, get job logs)
+- Actions variables (get, set idempotent)
 - Wiki pages (list, fetch, create, update, delete)
 
 **`VikunjaClient`** — Vikunja REST API wrapper:
@@ -168,7 +172,7 @@ from `devx.api_clients`, `devx.config`, `devx.gitea_cli`, and `devx.i18n`.
 
 Automated release using git-cliff. Calculates the next semver version from
 conventional commits since the last tag, updates `__version__` in
-`__init__.py` and `CHANGELOG.md`, runs lint and tests to verify the release
+`__init__.py` and `CHANGELOG.md`, runs lint, and tests to verify the release
 is healthy, commits with `release: vX.Y.Z [skip ci]`, creates an annotated
 tag, and pushes both to master.
 
@@ -282,13 +286,24 @@ Click commands from `cli.py` and verifies each has documentation in
 `architecture.md` and CI scripts in `ci-cd-workflow.md`. Supports
 `--fail-on-missing` to enforce 100% coverage.
 
-### `discover_runners.py`
+### `discover_runners.py` (deprecated wrapper)
+
+> **Deprecated:** Use `devx.molecule.discover_runners` instead. This
+> module is a thin wrapper that re-exports the canonical implementation.
 
 Discovers available Gitea Actions runners at three levels: repository,
-organization, and instance (admin). Falls back to the `MOLECULE_RUNNERS` repo
+organization, and instance (administrator). Falls back to the `MOLECULE_RUNNERS` repo
 variable or `DEFAULT_MAX_RUNNERS` (3). Outputs runner count or a JSON index
 array for use as a dynamic matrix in Gitea Actions.
 
+### `wait_for_checks.py`
+
+Polls the Gitea Actions API for job completion status. Used by auto-merge
+jobs that need to wait for parallel jobs (for example molecule-tests) before
+proceeding. Replaces inline shell polling in workflow YAML with a
+reusable, testable Python module. Exit codes: 0 (success), 1 (job
+failure), 2 (timeout), 3 (API error or no matching jobs).
+
 ### `distribute_files.py`
 
 Distributes files matching a glob pattern across N parallel runners
@@ -309,7 +324,7 @@ from `devx.api_clients`, `devx.config`, and `devx.gitea_cli`.
 ### `setup.py`
 
 Project setup: installs Python dependencies (editable mode with extras),
-Ansible Galaxy collections (if `ansible/requirements.yml` exists), pre-commit
+Ansible Galaxy collections (if `ansible/requirements.yml` exists in the target repo), pre-commit
 hooks (pre-commit, commit-msg, pre-push), and configures the `tea` CLI login
 profile from `.env`. Supports `--extras` to specify dependency groups,
 `--no-pre-commit` to skip hook installation, and `--no-tea-login` to skip tea
@@ -327,7 +342,16 @@ Supports `--tool` to install specific tools and `--list` to show status.
 Runs unit tests and enforces execution-time budgets. Two quality gates:
 total suite time must not exceed `--max-seconds` (default: 10s), and no
 individual test may exceed `--max-single-seconds` (default: 0.5s, 0 to
-disable). Runs `make test-unit` with `PYTEST_ADDOPTS=--durations=0`.
+off). Runs `make test-unit` with `PYTEST_ADDOPTS=--durations=0`.
+
+### `check_test_isolation.py`
+
+Pytest plugin (auto-discovered via `pytest11` entry point) that
+statically analyzes test files for un-hermetic patterns causing slow
+or flaky tests: unpatched `subprocess.run`/`time.sleep` calls, known
+subprocess-spawning helpers called without `@patch`, and excessive
+loop iterations (>100). Also available as a standalone CLI for CI
+gates and pre-commit hooks. See ADR-0001 for design rationale.
 
 ### `configure_repo.py`
 
@@ -335,7 +359,7 @@ Configures repository branch protection and labels via the Gitea REST API.
 Sets up master branch protection (required status checks, block on rejected
 reviews, block on outdated branch) and creates standard labels. Status check
 contexts are read from `DEVX_STATUS_CHECKS` or default to
-`CI / quality (pull_request)`.
+`CI / validate (pull_request)`.
 
 ### `generate_badges.py`
 
@@ -384,8 +408,13 @@ Intended for local development; CI uses the parallel matrix instead.
 
 ### `molecule/discover_runners.py`
 
-Discovers available Gitea Actions runners for molecule tests. Same logic as
-`devx.ci.discover_runners` but intended for molecule-specific workflows.
+Discovers available Gitea Actions runners for molecule tests. This is the
+canonical implementation; `devx.ci.discover_runners` is a deprecated wrapper
+that re-exports from this module. Queries runners at repository,
+organization, and instance (administrator) levels, with warnings logged
+to stderr on non-200 responses (except 403 on instance-level, which is
+expected without admin scope). Falls back to `MOLECULE_RUNNERS` env var
+or `DEFAULT_MAX_RUNNERS` (3).
 
 ### `start_docker.py`
 
@@ -454,13 +483,14 @@ Developer pushes and creates PR (title: "DEVX-N: <vikunja task title>")
     ▼
 CI workflow (ci.yml) triggers:
     │
-    ├── quality (lint, tests, coverage, test speed, doc coverage,
-    │            translation check, dependency scan, workflow dry-run)
-    │
-    ├── detect-changes (classify_changes.py → user-facing or workflow-only)
-    │       └── if user-facing → release-dry-run (release.py --dry-run)
-    │
-    ├── pr-review (pr_review.py → posts COMMENT or REQUEST_CHANGES)
+    ├── validate (single job: quality + detect-changes +
+    │            release-dry-run + pr-review + pre-merge validation)
+    │       ├── quality steps (lint, tests, coverage, test speed, doc coverage,
+    │       │                 translation check, dependency scan, workflow dry-run)
+    │       ├── detect-changes (classify_changes.py → user-facing or workflow-only)
+    │       │       └── if user-facing → release-dry-run (release.py --dry-run)
+    │       ├── pre-merge validation (check_auto_merge_ready.py)
+    │       └── pr-review (pr_review.py → posts COMMENT or REQUEST_CHANGES)
     │
     └── auto-merge (auto_merge.py)
             ├── validate PR title format
@@ -481,50 +511,54 @@ Push to master (squash-merge commit: "DEVX-N <conventional commit>")
     ▼
 Post-merge workflow (post-merge.yml) triggers:
     │
-    ├── detect-type (detect_release_commit.py)
-    │       └── is-release? → skip all jobs except badges
+    ├── detect-and-configure (single job)
+    │       ├── configure-repo (configure_repo.py)
+    │       ├── detect-type (detect_release_commit.py)
+    │       │       └── is-release? → skip all steps except badges
+    │       └── validate-commit-msg (validate_commit_msg.py --branch master)
     │
-    ├── validate-commit-msg (validate_commit_msg.py --branch master)
-    │
-    ├── release (release.py)
-    │       ├── classify_changes.py → skip if workflow-only
-    │       ├── git-cliff → calculate next version
-    │       ├── update __version__ in __init__.py
-    │       ├── update CHANGELOG.md
-    │       ├── run make lint-ruff && make pytest-cov
-    │       ├── commit "release: vX.Y.Z [skip ci]"
-    │       ├── create annotated tag vX.Y.Z
-    │       └── push commit + tag to master
-    │               │
-    │               ▼
-    │       Tag push triggers publish workflow (see below)
-    │
-    ├── sync-wiki (sync_wiki.py --strict)
-    │       └── sync docs/ to Gitea wiki with integrity check
-    │
-    ├── badges (push_badges.py) [ALWAYS runs, even on release commits]
-    │       ├── fetch latest master
-    │       ├── generate_badges.py → SVG files
-    │       ├── push to orphan badges branch
-    │       └── update README.md + docs/index.md with cache-busting URLs
-    │
-    ├── vikunja (post_merge.py)
-    │       ├── extract task ID from commit message
-    │       ├── mark Vikunja task as done
-    │       └── post comment with merge SHA
-    │
-    └── configure-repo (configure_repo.py)
-            └── ensure branch protection and labels
+    └── release-and-maintain (needs detect-and-configure)
+            ├── release (release.py) [skip if release commit or workflow-only]
+            │       ├── classify_changes.py → skip if workflow-only
+            │       ├── git-cliff → calculate next version
+            │       ├── update __version__ in __init__.py
+            │       ├── update CHANGELOG.md
+            │       ├── run make lint-ruff && make pytest-cov
+            │       ├── commit "release: vX.Y.Z [skip ci]"
+            │       ├── create annotated tag vX.Y.Z
+            │       └── push commit + tag to master
+            │               │
+            │               ▼
+            │       publish (publish.py) [if release created a tag]
+            │               ├── build package (python -m build)
+            │               ├── publish to Gitea PyPI registry (twine upload)
+            │               │   OR publish to standard PyPI (if PYPI_TOKEN set)
+            │               │   OR skip publish (if --skip-build)
+            │               └── create Gitea release with git-cliff notes
+            │
+            ├── sync-wiki (sync_wiki.py --strict) [skip if automated]
+            │       └── sync docs/ to Gitea wiki with integrity check
+            │
+            ├── vikunja (post_merge.py) [skip if automated]
+            │       ├── extract task ID from commit message
+            │       ├── mark Vikunja task as done
+            │       └── post comment with merge SHA
+            │
+            └── badges (push_badges.py) [ALWAYS runs, even on release commits]
+                    ├── fetch latest master
+                    ├── generate_badges.py → SVG files
+                    ├── push to orphan badges branch
+                    └── update README.md + docs/index.md with cache-busting URLs
 ```
 
 ### Publish flow
 
 ```text
-Tag push (vX.Y.Z) triggers publish workflow (publish.yml):
+Within release-and-maintain job (after release step creates a tag):
     │
-    ▼
     ├── install build, twine, git-cliff, tea
     ├── configure tea login
+    ├── checkout release tag
     │
     └── publish (publish.py)
             ├── build package (python -m build)

docs/tech/ci-cd-workflow.md

@@ -1,32 +1,29 @@
 # CI/CD Workflow
 
-devx uses Gitea Actions for CI/CD automation. Three workflows implement a
-complete pipeline: pull request validation, post-merge release automation, and
-tag-triggered publishing.
+devx uses Gitea Actions for CI/CD automation. Two workflows implement a
+complete pipeline: pull request validation and post-merge release
+automation (including publishing).
 
 ## Workflow overview
 
 ```text
 PR opened/synchronized ──► CI (ci.yml)
-    │                         ├── quality
-    │                         ├── detect-changes
-    │                         ├── release-dry-run (if user-facing)
-    │                         ├── pr-review
+    │                         ├── validate (quality + detect-changes +
+    │                         │              release-dry-run + pr-review +
+    │                         │              pre-merge validation)
     │                         └── auto-merge ──► squash-merge to master
     │                                              │
     ▼                                              ▼
 Push to master ──► Post-merge (post-merge.yml)
-                     ├── detect-type
-                     ├── validate-commit-msg
-                     ├── release ──► tag vX.Y.Z
-                     ├── sync-wiki        │
-                     ├── badges           │
-                     ├── vikunja          │
-                     └── configure-repo   │
-                                          │
-                                          ▼
-Tag push (v*) ──► Publish (publish.yml)
-                     └── publish ──► Gitea PyPI registry + Gitea release
+                     ├── detect-and-configure (detect-type +
+                     │                          validate-commit-msg +
+                     │                          configure-repo)
+                     └── release-and-maintain
+                          ├── release ──► tag vX.Y.Z
+                          ├── publish ──► Gitea PyPI registry + Gitea release
+                          ├── sync-wiki
+                          ├── vikunja
+                          └── badges (always runs)
 ```
 
 ## CI workflow (`ci.yml`)
@@ -35,9 +32,15 @@ Runs on pull requests (opened and synchronize) and manual dispatch.
 
 ### Jobs
 
-#### `quality`
+#### `validate`
 
-The main quality gate. Runs on every PR:
+The single validation job. Consolidates the former `quality`,
+`detect-changes`, `release-dry-run`, `pr-review`, and `pre-merge-check`
+jobs into one job to save checkout+setup overhead. Runs on every PR.
+
+**Quality steps**
+
+The main quality gate:
 
 1. **Lint all** — ruff check, ruff format check, pyright, bandit, actionlint
    (via `make lint-all`)
@@ -52,21 +55,21 @@ The main quality gate. Runs on every PR:
 7. **Workflow dry-run validation** — `make workflow-dryrun` via act_runner
    (best-effort, skipped if act_runner is not installed)
 
-#### `detect-changes`
+**`detect-changes` step**
 
 Classifies changes between `origin/master` and the PR head as user-facing or
 workflow-only using `python -m devx.ci.classify_changes --github-output`.
 Writes `user-facing-changed=true|false` to the job output for use by
-downstream jobs.
+downstream steps.
 
-#### `release-dry-run`
+**`release-dry-run` step**
 
-Depends on `quality` and `detect-changes`. Only runs if user-facing changes
-are detected. Runs `python -m devx.ci.release --dry-run` to validate that
-the release script can calculate the next version and generate the changelog
-without making changes. Non-blocking (uses `|| true`).
+Only runs if the detect-changes step detected user-facing changes. Runs
+`python -m devx.ci.release --dry-run` to validate that the release script
+can calculate the next version and generate the changelog without making
+changes. Non-blocking (uses `|| true`).
 
-#### `pr-review`
+**`pr-review` step**
 
 Runs on every pull request. Executes `python -m devx.ci.pr_review` with the
 PR number and repository. Fetches the PR diff via the Gitea API and runs
@@ -87,11 +90,24 @@ Checks performed:
 7. Test coverage — source changes must include test updates
 8. Commit conventions — conventional commit format on PR commits
 
+**Pre-merge validation step**
+
+Runs on every pull request. Executes
+`python -m devx.ci.check_auto_merge_ready` with the branch name, PR title,
+repository, and PR number. Validates auto-merge preconditions before the
+`auto-merge` job runs:
+
+1. **Branch name** — must contain a valid task ID (for example,
+   `DEVX-12-fix-foo` → `DEVX-12`)
+2. **PR title format** — must be `{PREFIX}-N: <vikunja task title>`
+3. **Vikunja task** — must exist and the title must match the PR title
+4. **Branch state** — must not be behind master
+
 #### `auto-merge`
 
-Depends on `quality`, `detect-changes`, and `pr-review`. The final job in the
-CI workflow. Runs `python -m devx.ci.auto_merge` with the branch name, PR
-title, repository, and PR number:
+Depends on `validate`. The final job in the CI workflow. Runs
+`python -m devx.ci.auto_merge` with the branch name, PR title, repository,
+and PR number:
 
 1. **Read task ID** from branch name (for example, `DEVX-12-fix-foo` → `DEVX-12`)
 2. **Validate PR title format** — must be `{PREFIX}-N: <vikunja task title>`
@@ -107,8 +123,9 @@ The merge commit push to master triggers the post-merge workflow.
 
 ### Smart CI: user-facing vs workflow-only changes
 
-Not all changes require a new release. The `detect-changes` job classifies
-changes using `python -m devx.ci.classify_changes`:
+Not all changes require a new release. The `detect-changes` step in the
+`validate` job classifies changes using
+`python -m devx.ci.classify_changes`:
 
 **Workflow-only paths** (infrastructure — no release needed):
 - `.gitea/**` — Gitea Actions workflows
@@ -137,55 +154,90 @@ Rule priority (first match wins):
 
 ## Post-merge workflow (`post-merge.yml`)
 
-Runs on every push to master. A single workflow with conditional jobs
-replaces separate workflows for release, wiki sync, badges, and Vikunja task
-updates.
+Runs on every push to master. Consolidated into 2 jobs (from 7) to reduce
+runner overhead: `detect-and-configure` (detect-type + validate-commit-msg +
+configure-repo) and `release-and-maintain` (release + publish + sync-wiki +
+badges + vikunja). Individual steps within `release-and-maintain` are
+conditional on the `detect-and-configure` job's outputs.
 
 ### Job dependency graph
 
 ```text
-detect-type ──┬── validate-commit-msg (skip if release commit)
-              ├── release (skip if release commit)
-              │       │
-              │       ├── sync-wiki (needs release)
-              │       ├── badges (needs release, ALWAYS runs)
-              │       └── vikunja (needs release)
-              └── configure-repo (independent, skip if release commit)
+detect-and-configure
+    ├── configure-repo (independent, skip if release commit)
+    ├── detect-type → is-release? is-automated?
+    └── validate-commit-msg (skip if release commit)
+            │
+            ▼
+release-and-maintain (needs detect-and-configure)
+    ├── release (skip if release commit or workflow-only)
+    │       └── publish (if release created a tag)
+    ├── sync-wiki (skip if automated)
+    ├── vikunja (skip if automated)
+    └── badges (always runs)
 ```
 
-`sync-wiki` and `vikunja` depend on `release` succeeding so that the wiki and
-task tracker are only updated when the code is actually released. If release
-fails, they are skipped to avoid leaving the wiki or Vikunja in an
-inconsistent state.
+`sync-wiki` and `vikunja` run only on non-automated commits (that is, real PR
+merges) so that the wiki and task tracker are only updated when a human
+change lands. They skip on release commits and automated commits.
 
-The `badges` job uses `if: always()` with no is-release condition so it runs
-on every push to master, including release commits. This ensures badges
-(tests, coverage, version, etc.) are always current.
+The `badges` step always runs (even on release commits) so badges (tests,
+coverage, version, etc.) are always current. It runs last so it picks up
+any version bump the release step created.
 
 When `release` creates a `release: vX.Y.Z` commit, the release commit's
 post-merge run still updates badges (the version badge picks up the new
-version). Other jobs skip. The tag push triggers `publish.yml`.
+version). Other steps skip. The `publish` step builds and publishes the
+package to the Gitea PyPI registry within the same `release-and-maintain`
+job (it checks out the release tag).
 
 ### Post-merge jobs
 
-#### `detect-type`
+#### `detect-and-configure`
+
+The first post-merge job. Consolidates the former `detect-type`,
+`validate-commit-msg`, and `configure-repo` jobs. Outputs `is-release`,
+`is-automated`, and `user-facing-changed` for the `release-and-maintain`
+job.
+
+**`detect-type` step**
 
 Checks if the latest commit is a release commit (`release: vX.Y.Z [skip ci]`)
 using `python -m devx.ci.detect_release_commit`. Writes `is-release=true` or
-`is-release=false` to the job output. All subsequent jobs use this to
-conditionally skip for release commits.
+`is-release=false` (and `is-automated`) to the job output. The
+`release-and-maintain` job uses these to conditionally skip steps for
+release commits.
 
-#### `validate-commit-msg`
+**`validate-commit-msg` step**
 
-Depends on `detect-type`. Skips for release commits. Validates the latest
-commit message using `python -m devx.ci.validate_commit_msg --branch master`.
-On master, commits must follow `{PREFIX}-N: <conventional commit>` format
-(added by auto-merge).
+Skips for release/automated commits. Validates the latest commit message
+using `python -m devx.ci.validate_commit_msg --branch master`. On master,
+commits must follow `{PREFIX}-N: <conventional commit>` format (added by
+auto-merge).
 
-#### `release`
+**`configure-repo` step**
 
-Depends on `detect-type`. Skips for release commits. The core release
-automation job. Runs `python -m devx.ci.release`:
+Ensures branch protection and labels are configured using
+`python -m devx.tools.configure_repo --repo <name> --owner <owner>`:
+
+- Sets up master branch protection (required status checks, block on rejected
+  reviews, block on outdated branch)
+- Creates standard labels
+- Status check contexts read from `DEVX_STATUS_CHECKS` or default to
+  `CI / validate (pull_request)`
+
+On failure, the `notify_failure` step creates a Gitea issue.
+
+#### `release-and-maintain`
+
+Depends on `detect-and-configure`. The second post-merge job. Consolidates
+the former `release`, `publish`, `sync-wiki`, `badges`, and `vikunja` jobs.
+Individual steps are conditional on the `detect-and-configure` job's outputs.
+
+**`release` step**
+
+Skips for release commits and workflow-only changes. The core release
+automation step. Runs `python -m devx.ci.release`:
 
 1. **Classify changes** — calls `classify_changes.py` to check for user-facing
    changes. If only infrastructure files changed, exits without releasing.
@@ -225,11 +277,10 @@ tag/version/commit alignment.
 On failure, the `notify_failure` step creates a Gitea issue via
 `python -m devx.ci.notify_failure`.
 
-#### `sync-wiki`
+**`sync-wiki` step**
 
-Depends on `detect-type` and `release`. Skips for release commits. Syncs
-documentation from `docs/` to the Gitea wiki using
-`python -m devx.ci.sync_wiki --repo <owner/repo> --strict`:
+Skips for automated commits. Syncs documentation from `docs/` to the Gitea
+wiki using `python -m devx.ci.sync_wiki --repo <owner/repo> --strict`:
 
 1. Reads `docs/mapping.json` to map file paths to wiki page titles
 2. Lists existing wiki pages via the Gitea API
@@ -243,15 +294,14 @@ deleted).
 
 On failure, the `notify_failure` step creates a Gitea issue.
 
-#### `badges`
+**`badges` step**
 
-Depends on `detect-type` and `release`. Uses `if: always()` so it runs on
-every push to master, including release commits. Generates and pushes quality
-badges using `python -m devx.ci.push_badges`:
+Always runs (even on release commits). Generates and pushes quality badges
+using `python -m devx.ci.push_badges`:
 
 1. **Fetch latest master** — `git fetch origin master && git reset --hard
    origin/master` (ensures the version badge reflects the current state,
-   even if the release job just pushed a new version)
+   even if the release step recently pushed a new version)
 2. **Generate badges** — calls `devx.tools.generate_badges` which runs
    pytest-cov, doc-coverage, lint checks, and version extraction, then writes
    SVG files: `coverage.svg`, `tests.svg`, `docs.svg`, `quality.svg`,
@@ -268,11 +318,10 @@ and waits 10s between attempts).
 
 On failure, the `notify_failure` step creates a Gitea issue.
 
-#### `vikunja`
+**`vikunja` step**
 
-Depends on `detect-type` and `release`. Skips for release commits. Updates
-the Vikunja task after a merge using `python -m devx.ci.post_merge --git-sha
-<sha>`:
+Skips for automated commits. Updates the Vikunja task after a merge using
+`python -m devx.ci.post_merge --git-sha <sha>`:
 
 1. Extracts the task ID from the first line of the commit message
 2. Marks the corresponding Vikunja task as done
@@ -280,26 +329,11 @@ the Vikunja task after a merge using `python -m devx.ci.post_merge --git-sha
 
 On failure, the `notify_failure` step creates a Gitea issue.
 
-#### `configure-repo`
+**`publish` step**
 
-Depends on `detect-type`. Skips for release commits. Ensures branch
-protection and labels are configured using
-`python -m devx.tools.configure_repo --repo <name> --owner <owner>`:
-
-- Sets up master branch protection (required status checks, block on rejected
-  reviews, block on outdated branch)
-- Creates standard labels
-- Status check contexts read from `DEVX_STATUS_CHECKS` or default to
-  `CI / quality (pull_request)`
-
-On failure, the `notify_failure` step creates a Gitea issue.
-
-## Publish workflow (`publish.yml`)
-
-Runs on tag pushes matching `v*`. Triggered by the `release` job in the
-post-merge workflow when it creates and pushes a new version tag.
-
-### Job: `publish`
+Only runs if the `release` step created a tag. Builds and publishes the
+package within the same `release-and-maintain` job (checks out the release
+tag). Runs `python -m devx.ci.publish <tag> <owner/repo>`:
 
 1. **Install dependencies** — build, twine, requests, python-dotenv, click,
    and the project itself
@@ -518,25 +552,29 @@ The complete release process from PR to published package:
 1. **PR merged** — `auto-merge` squash-merges the PR to master with
    `{PREFIX}-N <conventional commit>` title
 2. **Post-merge triggers** — the merge push triggers `post-merge.yml`
-3. **detect-type** — confirms the commit is not a release commit
-4. **release** — `release.py` calculates the next version, updates files,
-   runs tests, commits `release: vX.Y.Z [skip ci]`, creates tag `vX.Y.Z`,
-   and pushes to master
-5. **Tag push triggers publish** — the tag push triggers `publish.yml`
-6. **publish** — `publish.py` builds the package, publishes to the Gitea PyPI
-   registry, and creates a Gitea release with git-cliff notes
-7. **sync-wiki** — documentation is synced to the Gitea wiki
-8. **badges** — quality badges are regenerated and pushed to the `badges`
-   branch; README and docs/index.md are updated with cache-busting URLs
-9. **vikunja** — the corresponding Vikunja task is marked as done
-10. **configure-repo** — branch protection and labels are ensured
+3. **detect-and-configure** — detects release commit, validates commit
+   message, and ensures branch protection/labels
+4. **release** (step in `release-and-maintain`) — `release.py` calculates
+   the next version, updates files, runs tests, commits
+   `release: vX.Y.Z [skip ci]`, creates tag `vX.Y.Z`, and pushes to master
+5. **publish** (step in `release-and-maintain`) — `publish.py` builds the
+   package, publishes to the Gitea PyPI registry, and creates a Gitea
+   release with git-cliff notes (checks out the release tag within the
+   same job)
+6. **sync-wiki** (step in `release-and-maintain`) — documentation is synced
+   to the Gitea wiki
+7. **vikunja** (step in `release-and-maintain`) — the corresponding Vikunja
+   task is marked as done
+8. **badges** (step in `release-and-maintain`) — quality badges are
+   regenerated and pushed to the `badges` branch; README and docs/index.md
+   are updated with cache-busting URLs
 
-The release commit's post-merge run skips all jobs except `badges` (which
+The release commit's post-merge run skips all steps except `badges` (which
 picks up the new version number). This prevents infinite loops.
 
 ## Failure handling
 
-Every job in the post-merge and publish workflows has a `notify_failure` step
+Every job in the CI and post-merge workflows has a `notify_failure` step
 that runs `if: failure()`. This creates a Gitea issue with the workflow name,
 run ID, and commit SHA, ensuring failures that would otherwise go unnoticed
 in the Actions tab are surfaced as issues. The issue is created via the tea

docs/user/cli-commands.md

@@ -83,9 +83,14 @@ devx ci detect-release-commit
 
 ### `devx ci discover-runners`
 
+> **Deprecated:** Use `devx molecule discover-runners` instead. This
+> command is a thin wrapper that re-exports the canonical implementation
+> from `devx.molecule.discover_runners`. It will be removed in a future
+> release.
+
 Discover available Gitea Actions runners for dynamic job distribution.
 Queries the Gitea API for registered runners at repository, organization, and
-instance (admin) levels. Falls back to `MOLECULE_RUNNERS` repo variable or
+instance (administrator) levels. Falls back to `MOLECULE_RUNNERS` repo variable or
 `DEFAULT_MAX_RUNNERS` (3).
 
 ```bash
@@ -315,6 +320,82 @@ devx ci validate-commit-msg commit-msg.txt --branch master
 Options:
 - `--branch <branch>` — override branch detection (for CI use)
 
+### `devx ci wait-for-checks`
+
+Wait for Gitea Actions jobs to complete by polling the API. Used by
+auto-merge jobs that need to wait for parallel jobs (for example molecule-tests)
+before proceeding. Replaces inline shell polling in workflow YAML with
+a reusable, testable Python module.
+
+Exit codes:
+- `0` — all matching jobs completed successfully
+- `1` — one or more matching jobs failed (when `--require-success` is set)
+- `2` — timeout reached before all jobs completed
+- `3` — API error or no matching jobs found
+
+```bash
+devx ci wait-for-checks --job-name molecule-tests --repo oblachno-oss/grm
+devx ci wait-for-checks --job-name molecule-tests --timeout 1200 --poll-interval 10
+devx ci wait-for-checks --job-name molecule-tests --no-require-success
+```
+
+Options:
+- `--job-name <prefix>` — job name prefix to match (required)
+- `--repo <owner/name>` — repository (default: `$GITHUB_REPOSITORY`)
+- `--timeout <seconds>` — max wait time (default: 1200 = 20 min)
+- `--poll-interval <seconds>` — seconds between polls (default: 10)
+- `--require-success / --no-require-success` — exit 1 if a job failed (default: yes)
+
+### `devx ci cancel-superseded-runs`
+
+Cancel in-flight CI runs for the same PR branch when a new push triggers
+a new run. Uses the Gitea Actions API to list running pull_request runs
+and cancel those with a lower run ID on the same branch.
+
+```bash
+devx ci cancel-superseded-runs \
+    --repo "$REPOSITORY" \
+    --current-run-id "$GITHUB_RUN_ID" \
+    --head-branch "$HEAD_REF"
+```
+
+Options:
+- `--repo <owner/repo>` — repository (required)
+- `--current-run-id <id>` — current run ID, not cancelled (required)
+- `--head-branch <branch>` — PR head branch name (required)
+- `--dry-run` — list superseded runs without cancelling
+- `--base-url <url>` — Gitea base URL (default: `GITEA_API_URL` env var)
+
+### `devx ci check-workflow-artifact-deps`
+
+Verify that workflow jobs downloading artifacts depend on the uploading
+job. Prevents the class of bug where a download job runs in parallel
+with the upload job and fails because the artifact isn't available yet.
+
+```bash
+devx ci check-workflow-artifact-deps
+devx ci check-workflow-artifact-deps --workflow .gitea/workflows/ci.yml
+```
+
+Options:
+- `--workflow <path>` — check a specific workflow file
+- `--workflows-dir <path>` — override workflows directory
+
+### `devx ci check-workflow-tofu-init`
+
+Verify that workflow jobs using tofu state (tofu output/plan/apply or
+scripts that call them) have a tofu-init step in the same job.
+
+```bash
+devx ci check-workflow-tofu-init
+devx ci check-workflow-tofu-init --workflow .gitea/workflows/deploy.yml
+```
+
+Options:
+- `--workflow <path>` — check a specific workflow file
+- `--workflows-dir <path>` — override workflows directory
+- `--state-script <name>` — add a script that uses tofu state (repeatable)
+
 ## Tools Commands
 
 ### `devx tools check-test-speed`
@@ -323,7 +404,7 @@ Run unit tests and enforce execution-time budgets. Two quality gates:
 
 - **Total suite time** must not exceed `--max-seconds` (default: 10s)
 - **Per-test time** — no individual test may exceed `--max-single-seconds`
-  (default: 0.5s, 0 to disable)
+  (default: 0.5s, 0 to turn off)
 
 Runs `make test-unit` with `PYTEST_ADDOPTS=--durations=0` so pytest emits
 per-test timing lines.
@@ -334,6 +415,44 @@ devx tools check-test-speed --max-seconds 10
 devx tools check-test-speed --max-seconds 4 --max-single-seconds 0.5
 ```
 
+### `devx tools check-test-isolation`
+
+Statically analyze test files for un-hermetic patterns that cause slow
+or flaky tests. Also available as a **pytest plugin** (auto-discovered
+via the `pytest11` entry point when devx is installed — runs
+automatically on every `pytest` invocation and **fails on violations**).
+
+Detected patterns (hard errors — exit non-zero):
+
+- **unpatched-subprocess**: `subprocess.run/call/Popen/check_call/check_output`
+  called in a test function without `@patch` or `with patch(...)`
+- **unpatched-sleep**: `time.sleep` called without `@patch`
+- **unpatched-helper**: known subprocess-spawning helpers (`update_doc_versions`,
+  `run_cmd`, `run_tests`) called without `@patch` or patching their internal deps
+- **excessive-iterations**: `for _ in range(N)` where N > 100
+- **heavy-module-import**: `httpx`, `ansible`, etc. imported at module level
+- **reload-without-cleanup**: `importlib.reload()` called an odd number of times
+
+Advisory patterns (exit 0 — runtime audit is authoritative):
+
+- **transitive-subprocess**: `CliRunner.invoke(target)` where `target`
+  transitively calls `subprocess.run` without being patched. Detected via
+  static call-graph analysis. The runtime subprocess audit catches actual
+  leaks — if a real subprocess runs without `@patch`, the test fails.
+
+```bash
+devx tools check-test-isolation
+devx tools check-test-isolation --test-path tests/
+devx tools check-test-isolation --categories unpatched-subprocess,transitive-subprocess
+devx tools check-test-isolation --max-loop-iterations 50
+devx tools check-test-isolation --src-dir src/
+```
+
+Pytest plugin options (automatic when devx is installed):
+
+- `--no-test-isolation` — turn off static analysis and runtime subprocess audit
+- `--test-isolation-max-loop N` — max iterations per loop (default: 100)
+
 ### `devx tools configure-repo`
 
 Configure repository: branch protection and labels via the Gitea REST API.
@@ -376,7 +495,7 @@ devx tools generate-cliff-config --prefix GRM --force  # overwrite existing
 Options:
 - `--prefix <prefix>` — task ID prefix (default: `DEVX_TASK_PREFIX` env var
   or `DEVX`)
-- `--output <file>` — output file path (default: `cliff.toml`)
+- `--output <file>` — output path (default: `cliff.toml`)
 - `--force` — overwrite existing file
 
 ### `devx tools install-checkmake`
@@ -405,7 +524,7 @@ devx tools install-tools --list             # list status
 ### `devx tools setup`
 
 Project setup: install Python dependencies (editable mode with extras),
-Ansible Galaxy collections (if `ansible/requirements.yml` exists), pre-commit
+Ansible Galaxy collections (if `ansible/requirements.yml` exists in the target repo), pre-commit
 hooks (pre-commit, commit-msg, pre-push), and configure the tea CLI login
 profile from `.env`.
 
@@ -450,6 +569,56 @@ devx tools pr-rebase                       # auto-detect PR from current branch
 Options (pass after `--`):
 - `--pr <N>` — PR number (auto-detected from current branch if omitted)
 
+### `devx tools check-docker-init`
+
+Check that Docker Compose services with healthchecks have `init: true`.
+Without `init: true`, CMD-SHELL healthchecks spawn child processes that
+become zombies when PID 1 doesn't reap them.
+
+```bash
+devx tools check-docker-init
+devx tools check-docker-init --path path/to/docker-compose.yml.j2
+```
+
+Options:
+- `--path <path>` — check a specific file or directory
+- `--templates-dir <path>` — override templates directory (default: `ansible/roles/`)
+
+### `devx tools check-ansible-set-fact-to-json`
+
+Check that Ansible `set_fact` tasks don't misuse `| to_json`. Using
+`to_json` in `set_fact` converts native Python types to JSON strings,
+causing iteration bugs (for example, iterating over characters instead
+of list items).
+
+```bash
+devx tools check-ansible-set-fact-to-json
+devx tools check-ansible-set-fact-to-json --path path/to/playbook.yml
+```
+
+Options:
+- `--path <path>` — check a specific file or directory
+- `--ansible-dir <path>` — override ansible directories (repeatable)
+
+### `devx tools check-alert-rules`
+
+Validate rendered Prometheus alert rules with `promtool check rules`.
+Renders a Jinja2 template with test values and validates the output.
+Skips (exits 0) if promtool is not on PATH.
+
+```bash
+devx tools check-alert-rules \
+    --template-path ansible/roles/observability/templates
+devx tools check-alert-rules \
+    --template-path ansible/roles/observability/templates \
+    --var grafana_base_url=https://grafana.example.com
+```
+
+Options:
+- `--template-path <path>` — path to templates directory (required)
+- `--template-name <name>` — template filename (default: `alert-rules.yml.j2`)
+- `--var key=value` — template variables (repeatable)
+
 ## Molecule Commands
 
 Molecule commands require the `molecule` extra (`pip install devx[molecule]`).

docs/user/getting-started.md

@@ -48,12 +48,12 @@ Add devx to your `pyproject.toml`:
 ```toml
 [project]
 dependencies = [
-    "devx>=0.35.5",
+    "devx>=0.50.4",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "devx>=0.35.5",
+    "devx>=0.50.4",
 ]
 ```
 

hooks/pre-commit

@@ -1,7 +1,15 @@
 #!/usr/bin/env bash
-# pre-commit hook: fail if unit tests are too slow.
-# Checks both total suite time (10s) and per-test time (0.5s).
-# Aligned with CI (ci.yml uses same thresholds).
+# pre-commit hook: fast local quality gates that shift-left CI checks.
+# Runs test speed, translation completeness, and test isolation checks.
+# All of these run in CI — failing here saves a round-trip.
 set -e
 export PYTHONPATH=src
+
+# Test speed: total suite < 4s, individual tests < 0.5s
 python3 -m devx.tools.check_test_speed --max-seconds 4 --max-single-seconds 0.5
+
+# Translation completeness: missing keys, dead keys, missing languages
+python3 -m devx.ci.check_translations
+
+# Test isolation: unpatched subprocess/time.sleep in test functions
+python3 -m devx.tools.check_test_isolation --test-path tests/

pyproject.toml

@@ -20,11 +20,19 @@ dependencies = [
     "python-dotenv==1.2.2",
     "click==8.4.2",
     "tenacity==9.1.4",  # retry logic for GiteaClient/VikunjaClient
+    "jinja2==3.1.6",  # template rendering (devx.utils.jinja, check_alert_rules)
+    "pyyaml==6.0.3",  # YAML parsing (workflow checks, ansible checks)
 ]
 
 [project.scripts]
 devx = "devx.cli:cli"
 
+# Pytest plugin — auto-discovered by pytest when devx is installed.
+# Runs static analysis on test files during every pytest invocation
+# to detect un-hermetic patterns (unpatched subprocess, time.sleep, etc.)
+[project.entry-points.pytest11]
+devx_test_isolation = "devx.tools.check_test_isolation"
+
 [tool.setuptools.dynamic]
 version = {attr = "devx.__version__"}
 
@@ -37,7 +45,7 @@ ci = [
 ]
 # Lint and type-checking tools (quality job, badge generation)
 lint = [
-    "ruff==0.15.20",
+    "ruff==0.15.21",
     "pyright==1.1.411",
     "bandit==1.9.4",
     "pip-audit==2.10.1",
@@ -45,29 +53,32 @@ lint = [
 ]
 # Release tools (build + publish to PyPI/Gitea registry)
 release = [
-    "build==1.5.0",
+    "build==1.5.1",
     "twine==6.2.0",
 ]
 # Molecule testing (for projects with Ansible roles)
 molecule = [
-    "molecule==26.4.0",
+    "molecule==26.6.0",
     "molecule-docker==2.1.0",
-    "ansible-lint==26.4.0",
+    "ansible-lint==26.6.0",
     "ansible-core==2.21.1",
 ]
 # Deploy tools (for infra staging/production deployments)
+# Versions aligned with infra's pyproject.toml to avoid reinstalls on every CI job.
+# bcrypt and PyJWT are infra deps not in devx core — included here so the CI
+# image has them and setup-image can use --no-deps (skip dep resolution).
 deploy = [
     "ansible-core==2.21.1",
-    "boto3==1.43.36",
+    "boto3==1.43.44",
     "docker==7.1.0",
-    "jinja2==3.1.6",
-    "pyyaml==6.0.3",
-    "cryptography==49.0.0",
+    "cryptography==50.0.0",
+    "bcrypt==5.0.0",
+    "PyJWT==2.13.0",
 ]
 # Full dev environment (local development)
 dev = [
     "devx[ci,lint,release,molecule]",
-    "build==1.5.0",
+    "build==1.5.1",
     "twine==6.2.0",
 ]
 
@@ -80,11 +91,25 @@ devx = ["translations.json", "make/*.mak"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["src"]
-addopts = "--cov=src/devx --cov-report=term-missing --cov-fail-under=100"
+addopts = "--cov=src/devx --cov-report=term-missing --cov-fail-under=100 -p no:devx_test_isolation"
 markers = [
     "integration: marks tests as integration tests (not counted in coverage)",
 ]
 
+[tool.coverage.run]
+# The test isolation pytest plugin (check_test_isolation.py) is loaded
+# by pytest before coverage instrumentation starts. Coverage config below
+# excludes decorator lines and pragma-marked code from the coverage check.
+branch = false
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if __name__ == .__main__",
+    # Click decorator lines are executed at import time, before coverage
+    "@click\\.command|@click\\.option|@click\\.argument",
+]
+
 [tool.ruff]
 target-version = "py312"
 line-length = 120
@@ -121,6 +146,12 @@ vikunja_project_id = 8
 repo_owner = "oblachno-oss"
 repo_name = "devx"
 
+[tool.devx.check_agent_docs]
+skip_ref_prefixes = [
+    "src/myproject/",
+    "ansible/requirements.yml",
+]
+
 #   3. infrastructure (DEFAULT_INFRASTRUCTURE + project-specific patterns)
 #   4. Default: user-facing (safe)
 [tool.devx.classify]

src/devx/__init__.py

@@ -1,3 +1,3 @@
 """devx — reusable development and CI/CD tools for oblachno-oss projects."""
 
-__version__ = "0.35.5"
+__version__ = "0.50.4"

src/devx/api_clients.py

@@ -224,6 +224,16 @@ class GiteaClient:
         r = self._request("GET", f"/pulls/{pr_number}")
         return r.json()
 
+    def update_pr(self, pr_number: str | int, fields: dict[str, Any]) -> dict[str, Any]:
+        """Update a pull request (e.g. title, body, state).
+
+        Args:
+            pr_number: PR number.
+            fields: Dict of fields to update (e.g. {"title": "new title"}).
+        """
+        r = self._request("PATCH", f"/pulls/{pr_number}", json=fields)
+        return r.json()
+
     def create_pr(self, title: str, head: str, base: str = "master", body: str = "") -> dict[str, Any]:
         """Create a pull request and return the PR dict.
 
@@ -372,6 +382,36 @@ class GiteaClient:
         r = self._request("GET", f"/actions/jobs/{job_id}/logs")
         return r.text
 
+    # -- actions variables (repo-level) --
+
+    def get_repo_variable(self, name: str) -> str | None:
+        """Read a Gitea Actions repository variable.
+
+        Returns the variable value, or ``None`` if the variable is not set.
+        Raises :class:`APIError` on other HTTP errors.
+        """
+        try:
+            r = self._request("GET", f"/actions/variables/{name}")
+            return r.json().get("value")
+        except APIError as e:
+            if e.status == 404:
+                return None
+            raise
+
+    def set_repo_variable(self, name: str, value: str) -> None:
+        """Create or update a Gitea Actions repository variable (idempotent).
+
+        Tries PUT first (update); if the variable doesn't exist (404),
+        creates it via POST. Gitea 1.26.x does not support PATCH for
+        action variables.
+        """
+        try:
+            self._request("PUT", f"/actions/variables/{name}", json={"value": value})
+        except APIError as e:
+            if e.status != 404:
+                raise
+            self._request("POST", f"/actions/variables/{name}", json={"value": value})
+
 
 class VikunjaClient:
     """Low-level Vikunja REST API client with connection pooling."""

src/devx/ci/auto_merge.py

@@ -17,10 +17,9 @@ This allows the PR title to be a human-friendly Vikunja task title
 while the squashed commit follows conventional commits.
 
 Usage:
-  CI_GITEA_TOKEN=<token> python3 -m devx.ci.auto_merge <branch> <pr_title> <repo> <pr_number>
+  CI_GITEA_API_TOKEN=<token> VIKUNJA_TOKEN=<token> python3 -m devx.ci.auto_merge <branch> <pr_title> <repo> <pr_number>
 """
 
-import os
 import re
 from pathlib import Path
 from typing import Any
@@ -40,6 +39,7 @@ from devx.config import (
 )
 from devx.exceptions import APIError
 from devx.i18n import _
+from devx.tokens import get_ci_token, get_vikunja_token
 
 # Strip leading task ID prefix (e.g. "DEVX-12: " or "OBL-INFRA-364: ") from commit subjects.
 _TASK_ID_PREFIX_RE = re.compile(rf"^{TASK_PREFIX}-\d+:\s*")
@@ -115,9 +115,12 @@ def get_vikunja_task_title(task_id: str) -> str:
 
     Raises ClickException if VIKUNJA_TOKEN is not set or the task is not found.
     """
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("VIKUNJA_TOKEN is not set. This is required in CI to validate PR titles."))
+    try:
+        token = get_vikunja_token()
+    except click.ClickException:
+        raise click.ClickException(
+            _("VIKUNJA_TOKEN is not set. This is required in CI to validate PR titles.")
+        ) from None
     client = VikunjaClient(VIKUNJA_API_URL, token)
     page = 1
     while True:
@@ -197,9 +200,10 @@ def extract_conventional_msg(commits: list[dict[str, Any]]) -> str:
 @click.argument("repo")
 @click.argument("pr_number")
 def main(branch: str, pr_title: str, repo: str, pr_number: str) -> None:
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set."))
+    try:
+        token = get_ci_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set.")) from None
 
     # Validate PR number is an integer
     try:

src/devx/ci/cancel_superseded_runs.py

@@ -0,0 +1,185 @@
+"""Cancel superseded CI runs for the same PR.
+
+When a new push to a PR branch triggers a new CI run, any in-flight
+runs for the same PR are wasting runner time. This script cancels
+all but the latest running CI run for each PR branch.
+
+Uses the Gitea Actions API:
+  GET  /repos/{owner}/{repo}/actions/runs?status=in_progress&event=pull_request
+  POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel
+
+Usage::
+
+  # CI (cancels superseded runs for the current PR):
+  python -m devx.ci.cancel_superseded_runs \\
+      --repo "$REPOSITORY" \\
+      --current-run-id "$GITHUB_RUN_ID" \\
+      --head-branch "$HEAD_REF"
+
+  # Dry-run (lists what would be cancelled without cancelling):
+  python -m devx.ci.cancel_superseded_runs \\
+      --repo "$REPOSITORY" \\
+      --current-run-id "$GITHUB_RUN_ID" \\
+      --head-branch "$HEAD_REF" \\
+      --dry-run
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+_HTTP_NO_CONTENT = 204
+_HTTP_NOT_FOUND = 404
+_HTTP_BAD_REQUEST = 400
+_PAGE_SIZE = 50
+
+
+def _log(msg: str) -> None:
+    """Log to stderr."""
+    print(f"[cancel-superseded] {msg}", file=sys.stderr, flush=True)
+
+
+def _api_request(
+    method: str,
+    path: str,
+    token: str,
+    base_url: str,
+    body: dict | None = None,
+) -> dict | list:
+    """Make a Gitea API request."""
+    url = f"{base_url}/api/v1{path}"
+    headers = {
+        "Authorization": f"token {token}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+    data = json.dumps(body).encode() if body else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:  # nosec B310 — authenticated API request to known Gitea instance
+            if resp.status == _HTTP_NO_CONTENT:
+                return {}
+            return json.loads(resp.read().decode())
+    except urllib.error.HTTPError as e:
+        _log(f"API error {e.code} on {method} {path}: {e.read().decode()[:200]}")
+        raise
+    except urllib.error.URLError as e:
+        _log(f"URL error on {method} {path}: {e}")
+        raise
+
+
+def list_running_runs(repo: str, token: str, base_url: str) -> list[dict]:
+    """List all running CI runs for pull_request events."""
+    runs: list[dict] = []
+    page = 1
+    while True:
+        result = _api_request(
+            "GET",
+            f"/repos/{repo}/actions/runs?status=in_progress&event=pull_request&page={page}&limit=50",
+            token,
+            base_url,
+        )
+        # Gitea returns {"workflow_runs": [...], "total_count": N}
+        page_runs = result["workflow_runs"] if isinstance(result, dict) else result
+        if not page_runs:
+            break
+        runs.extend(page_runs)
+        if len(page_runs) < _PAGE_SIZE:
+            break
+        page += 1
+    return runs
+
+
+def cancel_run(repo: str, run_id: int, token: str, base_url: str) -> bool:
+    """Cancel a CI run. Returns True on success."""
+    try:
+        _api_request(
+            "POST",
+            f"/repos/{repo}/actions/runs/{run_id}/cancel",
+            token,
+            base_url,
+        )
+    except (urllib.error.HTTPError, urllib.error.URLError):
+        return False
+    return True
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Cancel superseded CI runs for the same PR.")
+    parser.add_argument("--repo", required=True, help="owner/repo")
+    parser.add_argument("--current-run-id", required=True, help="Current run ID (not cancelled)")
+    parser.add_argument("--head-branch", required=True, help="PR head branch name")
+    parser.add_argument("--dry-run", action="store_true", help="List without cancelling")
+    parser.add_argument(
+        "--base-url",
+        default=os.environ.get("GITEA_API_URL", "https://git.oblachno.oblachno.fyi"),
+        help="Gitea base URL",
+    )
+    args = parser.parse_args()
+
+    token = os.environ.get("CI_GITEA_API_TOKEN") or os.environ.get("CI_GITEA_TOKEN")
+    if not token:
+        _log("No CI_GITEA_API_TOKEN or CI_GITEA_TOKEN set — skipping")
+        return 0
+
+    current_run_id = int(args.current_run_id)
+
+    _log(f"Listing running PR runs for {args.repo}...")
+    try:
+        runs = list_running_runs(args.repo, token, args.base_url)
+    except urllib.error.HTTPError as e:
+        if e.code in (_HTTP_NOT_FOUND, _HTTP_BAD_REQUEST):
+            _log(
+                f"Actions runs API not usable (HTTP {e.code}) — "
+                f"Gitea {args.base_url} may not support this endpoint or status filter. "
+                f"Skipping cancel-superseded (non-fatal)."
+            )
+            return 0
+        raise
+    _log(f"Found {len(runs)} running PR runs")
+
+    # Group by head_branch — only cancel runs for the SAME branch
+    # that are older than the current run
+    same_branch_runs = [
+        r
+        for r in runs
+        if r.get("head_branch") == args.head_branch
+        and int(r.get("id", 0)) != current_run_id
+        and int(r.get("id", 0)) < current_run_id
+    ]
+
+    if not same_branch_runs:
+        _log(f"No superseded runs for branch {args.head_branch}")
+        return 0
+
+    _log(f"Found {len(same_branch_runs)} superseded run(s) for branch {args.head_branch}:")
+    for r in same_branch_runs:
+        run_id = r.get("id")
+        created = r.get("created_at", "?")
+        _log(f"  Run #{run_id} (created: {created})")
+
+    if args.dry_run:
+        _log("[dry-run] Would cancel the above runs")
+        return 0
+
+    cancelled = 0
+    for r in same_branch_runs:
+        run_id = int(r["id"])
+        _log(f"Cancelling run #{run_id}...")
+        if cancel_run(args.repo, run_id, token, args.base_url):
+            cancelled += 1
+            _log(f"  Cancelled run #{run_id}")
+        else:
+            _log(f"  Failed to cancel run #{run_id}")
+
+    _log(f"Cancelled {cancelled}/{len(same_branch_runs)} superseded runs")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

src/devx/ci/check_auto_merge_ready.py

@@ -15,7 +15,7 @@ Exit code 1 = NOT ready — fix issues before pushing.
 
 Usage::
 
-  # CI (with VIKUNJA_TOKEN and CI_GITEA_TOKEN):
+  # CI (with VIKUNJA_TOKEN and CI_GITEA_API_TOKEN):
   python3 -m devx.ci.check_auto_merge_ready \\
       --branch "$HEAD_REF" \\
       --pr-title "$PR_TITLE" \\
@@ -34,13 +34,12 @@ skipped (with a warning) — this allows local pre-push hooks to run
 without CI secrets.  In CI, the token is always set and the check is
 mandatory.
 
-If ``CI_GITEA_TOKEN`` is not set and ``--pr-number`` is not provided, only
+If ``CI_GITEA_API_TOKEN`` is not set and ``--pr-number`` is not provided, only
 branch-name and PR-title-format checks run (local mode).
 """
 
 from __future__ import annotations
 
-import os
 import subprocess  # nosec B404
 
 import click
@@ -55,6 +54,7 @@ from devx.config import (
 )
 from devx.exceptions import APIError
 from devx.i18n import _
+from devx.tokens import get_ci_token, get_vikunja_token
 
 load_dotenv()
 
@@ -99,10 +99,13 @@ def is_branch_behind_master(branch: str) -> bool:
 def get_pr_title_from_gitea(repo: str, pr_number: int) -> str | None:
     """Fetch the PR title from the Gitea API.
 
-    Returns ``None`` if ``CI_GITEA_TOKEN`` is not set or the PR cannot be fetched.
+    Returns ``None`` if no token is set or the PR cannot be fetched.
     """
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token or "/" not in repo:
+    try:
+        token = get_ci_token()
+    except click.ClickException:
+        return None
+    if "/" not in repo:
         return None
     owner, repo_name = repo.split("/", 1)
     client = GiteaClient(GITEA_API_URL, token, owner, repo_name)
@@ -120,8 +123,9 @@ def get_vikunja_title_optional(task_id: str) -> str | None:
     raise when ``VIKUNJA_TOKEN`` is missing — it returns ``None`` so the
     caller can skip the check in local mode.
     """
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
+    try:
+        token = get_vikunja_token()
+    except click.ClickException:
         return None
     client = VikunjaClient(VIKUNJA_API_URL, token)
     from devx.config import DEFAULT_PER_PAGE
@@ -221,7 +225,11 @@ def cli(
     if not skip_vikunja:
         vikunja_title = get_vikunja_title_optional(task_id)
         if vikunja_title is None:
-            token_set = bool(os.environ.get("VIKUNJA_TOKEN", ""))
+            try:
+                get_vikunja_token()
+                token_set = True
+            except click.ClickException:
+                token_set = False
             if token_set:
                 errors.append(
                     _(
@@ -233,17 +241,33 @@ def cli(
             else:
                 click.echo("[pre-merge-check] WARNING: VIKUNJA_TOKEN not set — skipping Vikunja title match check.")
         else:
-            expected = f"{task_id}: {vikunja_title}"
-            if pr_title != expected:
+            # Defensive check: warn if the Vikunja task title already includes
+            # the task ID prefix. The expected PR title is
+            # f"{task_id}: {vikunja_title}" — if vikunja_title already starts
+            # with "{task_id}:", the PR title will have a double prefix.
+            if vikunja_title.startswith(f"{task_id}:"):
                 errors.append(
                     _(
-                        "PR title does not match Vikunja task title.\n  Expected: {expected}\n  Got:      {title}",
-                        expected=expected,
-                        title=pr_title,
+                        "Vikunja task title '{title}' starts with '{prefix}:'. "
+                        "The task title should NOT include the '{prefix}' prefix — "
+                        "it is automatically added to the PR title. "
+                        "Update the Vikunja task title to remove the prefix.",
+                        title=vikunja_title,
+                        prefix=task_id,
                     ),
                 )
             else:
-                click.echo(f"[pre-merge-check] Vikunja title match OK: {expected}")
+                expected = f"{task_id}: {vikunja_title}"
+                if pr_title != expected:
+                    errors.append(
+                        _(
+                            "PR title does not match Vikunja task title.\n  Expected: {expected}\n  Got:      {title}",
+                            expected=expected,
+                            title=pr_title,
+                        ),
+                    )
+                else:
+                    click.echo(f"[pre-merge-check] Vikunja title match OK: {expected}")
 
     # 6. Branch behind master (skip if --skip-behind-check)
     if not skip_behind_check:
@@ -261,6 +285,26 @@ def cli(
         click.echo("=" * 60, err=True)
         for e in errors:
             click.echo(f"  - {e}", err=True)
+
+        # Remediation hints for the most common failure: PR title format
+        title_errors = [
+            e for e in errors if "PR title must follow format" in str(e) or "PR title task ID mismatch" in str(e)
+        ]
+        if title_errors and pr_number is not None and repo is not None:
+            click.echo("", err=True)
+            click.echo("REMEDIATION:", err=True)
+            click.echo(
+                _(
+                    "  Fix the PR title with:\n"
+                    "    python3 -m devx.ci.fix_pr_title --repo {repo} --pr-number {pr}\n"
+                    "  Or manually set the PR title to: '{expected}'",
+                    repo=repo,
+                    pr=pr_number,
+                    expected=f"{task_id}: <Vikunja task title>",
+                ),
+                err=True,
+            )
+
         raise click.ClickException(_("Pre-merge validation failed."))
 
     click.echo("[pre-merge-check] All auto-merge preconditions satisfied.")

src/devx/ci/check_translations.py

@@ -185,6 +185,7 @@ def main(translations: tuple[Path, ...], source_dir: str | None) -> None:
         # Try common locations
         candidates = [
             root / "src" / "devx" / "translations.json",
+            root / "src" / "grm" / "translations.json",
         ]
         # Also search for any translations.json in src/
         for match in root.glob("src/*/translations.json"):

src/devx/ci/check_workflow_artifact_deps.py

@@ -0,0 +1,163 @@
+"""Check that workflow jobs downloading artifacts depend on the uploading job.
+
+This prevents the class of bug where a job downloads an artifact produced by
+another job but does not declare that job in its ``needs`` list. When both
+jobs run in parallel, the download fails because the artifact hasn't been
+uploaded yet.
+
+The check scans all workflow YAML files for:
+  - ``gitea-upload-artifact`` / ``actions/upload-artifact`` steps
+  - ``gitea-download-artifact`` / ``actions/download-artifact`` steps
+
+For each download, it finds the job(s) that upload an artifact with a
+matching name and verifies that at least one uploading job is in the
+downloading job's ``needs`` list.
+
+Artifact names with ``${{ ... }}`` expressions are matched literally
+(both sides use the same expression, so they resolve to the same value
+at runtime).
+
+Usage::
+
+    python -m devx.ci.check_workflow_artifact_deps
+    python -m devx.ci.check_workflow_artifact_deps --workflow .gitea/workflows/ci.yml
+
+Exit code 0 if all artifact dependencies are satisfied, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+import yaml
+
+REPO_ROOT = Path.cwd()
+WORKFLOWS_DIR = REPO_ROOT / ".gitea" / "workflows"
+
+UPLOAD_ACTIONS = ("upload-artifact",)
+DOWNLOAD_ACTIONS = ("download-artifact",)
+
+
+def _is_artifact_action(uses: str, action_types: tuple[str, ...]) -> bool:
+    """Check if a step's ``uses`` field references an artifact action."""
+    if not uses:
+        return False
+    uses_lower = uses.lower()
+    return any(action in uses_lower for action in action_types)
+
+
+def _extract_artifact_info(workflow: dict) -> tuple[dict[str, list[str]], list[tuple[str, str, str]]]:
+    """Extract artifact upload and download info from a workflow.
+
+    Returns:
+        uploads: Mapping of artifact_name → list of job names that upload it.
+        downloads: List of (job_name, artifact_name, step_name) tuples.
+    """
+    uploads: dict[str, list[str]] = {}
+    downloads: list[tuple[str, str, str]] = []
+
+    jobs = workflow.get("jobs", {})
+    for job_name, job_def in jobs.items():
+        for step in job_def.get("steps", []):
+            uses = step.get("uses", "")
+            with_data = step.get("with", {})
+            artifact_name = with_data.get("name", "")
+            step_name = step.get("name", "")
+
+            if _is_artifact_action(uses, UPLOAD_ACTIONS):
+                if artifact_name:
+                    uploads.setdefault(artifact_name, []).append(job_name)
+            elif _is_artifact_action(uses, DOWNLOAD_ACTIONS) and artifact_name:
+                downloads.append((job_name, artifact_name, step_name))
+
+    return uploads, downloads
+
+
+def _check_workflow(filepath: Path) -> list[str]:
+    """Check a single workflow file for missing artifact dependencies.
+
+    Returns a list of error messages (empty if all OK).
+    """
+    errors: list[str] = []
+    content = filepath.read_text(encoding="utf-8")
+    try:
+        workflow = yaml.safe_load(content)
+    except yaml.YAMLError as exc:
+        return [f"{filepath}: cannot parse YAML: {exc}"]
+
+    if not isinstance(workflow, dict):
+        return [f"{filepath}: not a valid workflow (expected dict)"]
+
+    uploads, downloads = _extract_artifact_info(workflow)
+    jobs = workflow.get("jobs", {})
+
+    for dl_job, artifact_name, step_name in downloads:
+        uploading_jobs = uploads.get(artifact_name, [])
+        if not uploading_jobs:
+            # Artifact not uploaded in this workflow — may come from an
+            # external source (e.g., S3). Skip.
+            continue
+
+        dl_job_def = jobs.get(dl_job, {})
+        needs_raw = dl_job_def.get("needs", [])
+        needs = {needs_raw} if isinstance(needs_raw, str) else set(needs_raw or [])
+
+        # Check if any uploading job is in the download job's needs
+        if not any(uploader in needs for uploader in uploading_jobs):
+            # Check if the download step has continue-on-error: true
+            # (valid guard when the uploading job may be skipped due to
+            # Gitea Actions' needs skip behavior — the download will
+            # fail gracefully if the artifact doesn't exist).
+            dl_steps = dl_job_def.get("steps", [])
+            step_def = next((s for s in dl_steps if s.get("name", "") == step_name), {})
+            if step_def.get("continue-on-error") is True:
+                continue
+
+            uploaders_str = ", ".join(sorted(uploading_jobs))
+            errors.append(
+                f"{filepath.name}::{dl_job}: step '{step_name}' downloads "
+                f"artifact '{artifact_name}' produced by job(s) "
+                f"[{uploaders_str}] but none are in its 'needs' list "
+                f"(current needs: {sorted(needs) or 'none'}). "
+                f"Add the uploading job to 'needs' or guard the download "
+                f"with an if: condition checking the upload job's result."
+            )
+
+    return errors
+
+
+@click.command()
+@click.option(
+    "--workflow",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific workflow file (default: all in .gitea/workflows/).",
+)
+@click.option(
+    "--workflows-dir",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+    help="Override the workflows directory (default: .gitea/workflows/).",
+)
+def main(workflow: Path | None, workflows_dir: Path | None) -> None:
+    """Check that artifact download jobs depend on upload jobs."""
+    wdir = workflows_dir or WORKFLOWS_DIR
+    files = [workflow] if workflow else sorted(wdir.glob("*.yml"))
+
+    all_errors: list[str] = []
+    for f in files:
+        errors = _check_workflow(f)
+        all_errors.extend(errors)
+
+    if all_errors:
+        click.echo("[check-workflow-artifact-deps] FAIL: missing artifact dependencies found:")
+        for err in all_errors:
+            click.echo(f"  - {err}")
+        sys.exit(1)
+    else:
+        click.echo("[check-workflow-artifact-deps] OK: all artifact downloads have upload jobs in needs.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/ci/check_workflow_tofu_init.py

@@ -0,0 +1,145 @@
+"""Check that workflow jobs using tofu state have a tofu-init step.
+
+This prevents the class of bug where a job runs ``tofu output`` or calls
+a script that uses tofu state without first running ``tofu init``,
+causing "Required plugins are not installed" errors.
+
+The check scans all workflow YAML files for jobs that:
+  - Call scripts that use ``tofu output`` (configurable via --state-scripts)
+  - Call ``tofu output`` directly
+  - Call ``tofu plan`` or ``tofu apply`` directly
+
+For each such job, it verifies the same job has a ``tofu-init`` step,
+either:
+  - Directly via ``tofu init`` in a step's run command
+  - Via ``create_staging_deployment.py --phase tofu-init``
+  - Via ``create_production_deployment.py --phase tofu-init``
+
+Usage::
+
+    python -m devx.ci.check_workflow_tofu_init
+    python -m devx.ci.check_workflow_tofu_init --workflow .gitea/workflows/deploy.yml
+
+Exit code 0 if all jobs have tofu-init, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+import yaml
+
+REPO_ROOT = Path.cwd()
+WORKFLOWS_DIR = REPO_ROOT / ".gitea" / "workflows"
+
+# Scripts that call `tofu output`, `tofu plan`, or `tofu apply` internally.
+# If a job calls any of these, it must have a tofu-init step.
+# NOTE: destroy_orphans.py reads terraform.tfstate directly from disk
+# (does not invoke `tofu output`), so it does NOT need tofu-init.
+DEFAULT_TOFU_STATE_SCRIPTS: set[str] = {
+    "preflight_deploy.py",
+}
+
+# Commands that directly use tofu state (must be preceded by tofu init).
+TOFU_STATE_COMMANDS = ("tofu output", "tofu plan", "tofu apply", "tofu show")
+
+# Commands that initialize tofu (counted as tofu-init steps).
+TOFU_INIT_COMMANDS = (
+    "tofu init",
+    "--phase tofu-init",
+    "tofu-init",
+)
+
+
+def _check_workflow(filepath: Path, state_scripts: set[str]) -> list[str]:
+    """Check a single workflow file for missing tofu-init steps.
+
+    Returns a list of error messages (empty if all OK).
+    """
+    errors: list[str] = []
+    content = filepath.read_text(encoding="utf-8")
+    try:
+        workflow = yaml.safe_load(content)
+    except yaml.YAMLError as exc:
+        return [f"{filepath}: cannot parse YAML: {exc}"]
+
+    jobs = workflow.get("jobs", {})
+    for job_name, job_def in jobs.items():
+        steps = job_def.get("steps", [])
+        if not steps:
+            continue
+
+        uses_tofu_state = False
+        has_tofu_init = False
+
+        for step in steps:
+            run_cmd = step.get("run", "")
+            if not run_cmd:
+                continue
+            # Check if this step uses tofu state
+            for script in state_scripts:
+                if script in run_cmd:
+                    uses_tofu_state = True
+            for cmd in TOFU_STATE_COMMANDS:
+                if cmd in run_cmd:
+                    uses_tofu_state = True
+            # Check if this step initializes tofu
+            for cmd in TOFU_INIT_COMMANDS:
+                if cmd in run_cmd:
+                    has_tofu_init = True
+
+        if uses_tofu_state and not has_tofu_init:
+            errors.append(
+                f"{filepath.name}::{job_name}: uses tofu state "
+                f"(tofu output/plan/apply or {state_scripts}) "
+                f"but has no tofu-init step. Add a step running "
+                f"'create_*_deployment.py --phase tofu-init' before "
+                f"the first tofu state access."
+            )
+
+    return errors
+
+
+@click.command()
+@click.option(
+    "--workflow",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific workflow file (default: all in .gitea/workflows/).",
+)
+@click.option(
+    "--workflows-dir",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+    help="Override the workflows directory (default: .gitea/workflows/).",
+)
+@click.option(
+    "--state-script",
+    "state_scripts",
+    multiple=True,
+    default=None,
+    help="Add a script name that uses tofu state (can be repeated). Overrides the default list if any are specified.",
+)
+def main(workflow: Path | None, workflows_dir: Path | None, state_scripts: tuple[str, ...]) -> None:
+    """Check that workflow jobs using tofu state have a tofu-init step."""
+    scripts = set(state_scripts) if state_scripts else DEFAULT_TOFU_STATE_SCRIPTS
+    wdir = workflows_dir or WORKFLOWS_DIR
+    files = [workflow] if workflow else sorted(wdir.glob("*.yml"))
+
+    all_errors: list[str] = []
+    for f in files:
+        errors = _check_workflow(f, scripts)
+        all_errors.extend(errors)
+
+    if all_errors:
+        click.echo("[check-workflow-tofu-init] FAIL: missing tofu-init steps found:")
+        for err in all_errors:
+            click.echo(f"  - {err}")
+        sys.exit(1)
+    else:
+        click.echo("[check-workflow-tofu-init] OK: all tofu-state jobs have tofu-init.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/ci/discover_runners.py

@@ -1,19 +1,18 @@
 #!/usr/bin/env python3
 """Discover available Gitea Actions runners for dynamic job distribution.
 
-Queries the Gitea API for registered runners at three levels:
-  1. Repository level: GET /repos/{owner}/{repo}/actions/runners
-  2. Organization level: GET /orgs/{org}/actions/runners
-  3. Instance (admin) level: GET /admin/actions/runners
+.. deprecated:: Phase 1c
+    Use :mod:`devx.molecule.discover_runners` instead. This module is a
+    thin wrapper that re-exports the canonical implementation from
+    :mod:`devx.molecule.discover_runners` for backward compatibility
+    with existing workflow references and Makefile targets.
 
-Falls back to the ``MOLECULE_RUNNERS`` repo variable or environment
-variable, then to ``DEFAULT_MAX_RUNNERS`` (3).
-
-Outputs:
-  - ``--count``: prints the number of available runners
-  - ``--indices``: prints a JSON array [0, 1, ..., N-1] for use as a
-    dynamic matrix in Gitea Actions
-  - (default): prints both as ``count=N`` and ``indices=[0,1,...]``
+    The canonical implementation lives in
+    :mod:`devx.molecule.discover_runners` because runner discovery is
+    primarily used by the molecule test distribution pipeline. CI
+    workflows that still reference ``python -m devx.ci.discover_runners``
+    will continue to work via this wrapper, but new code should import
+    from :mod:`devx.molecule.discover_runners` directly.
 
 Usage:
   python3 -m devx.ci.discover_runners --owner oblachno-oss --repo devx
@@ -23,168 +22,28 @@ Usage:
 
 from __future__ import annotations
 
-import json
-import os
+import sys
+import warnings
 
-import click
-import requests
-
-from devx.config import GITEA_API_URL, REPO_NAME, REPO_OWNER
-from devx.i18n import _
-
-DEFAULT_MAX_RUNNERS = 3
-
-
-def query_runners(api_url: str, token: str, owner: str, repo: str) -> int:
-    """Query the Gitea API for registered runners at all levels.
-
-    Returns the total count of active runners.  If the API call fails
-    (e.g., no admin access for instance-level runners), falls back to
-    what we can see.  Fallbacks are logged to stderr for debugging.
-    """
-    headers = {"Authorization": f"token {token}"}
-    total = 0
-
-    # 1. Repository-level runners
-    try:
-        r = requests.get(
-            f"{api_url}/repos/{owner}/{repo}/actions/runners",
-            headers=headers,
-            timeout=10,
-        )
-        if r.status_code == 200:
-            data = r.json()
-            total += data.get("total_count", 0)
-        else:
-            click.echo(_("Warning: repo-level runners query returned HTTP {status}", status=r.status_code), err=True)
-    except (requests.RequestException, ValueError) as e:
-        click.echo(_("Warning: repo-level runners query failed: {error}", error=e), err=True)
-
-    # 2. Organization-level runners
-    try:
-        r = requests.get(
-            f"{api_url}/orgs/{owner}/actions/runners",
-            headers=headers,
-            timeout=10,
-        )
-        if r.status_code == 200:
-            data = r.json()
-            total += data.get("total_count", 0)
-        else:
-            click.echo(_("Warning: org-level runners query returned HTTP {status}", status=r.status_code), err=True)
-    except (requests.RequestException, ValueError) as e:
-        click.echo(_("Warning: org-level runners query failed: {error}", error=e), err=True)
-
-    # 3. Instance-level runners (requires admin scope)
-    try:
-        r = requests.get(
-            f"{api_url}/admin/actions/runners",
-            headers=headers,
-            timeout=10,
-        )
-        if r.status_code == 200:
-            data = r.json()
-            total += data.get("total_count", 0)
-        elif r.status_code != 403:  # 403 is expected without admin scope
-            click.echo(
-                _("Warning: instance-level runners query returned HTTP {status}", status=r.status_code),
-                err=True,
-            )
-    except (requests.RequestException, ValueError) as e:
-        click.echo(_("Warning: instance-level runners query failed: {error}", error=e), err=True)
-
-    return total
-
-
-def get_runner_count(api_url: str, token: str, owner: str, repo: str) -> int:
-    """Determine the number of available runners.
-
-    Tries the Gitea API first, then falls back to env vars, then default.
-    """
-    # Try API query if we have a token
-    if token:
-        api_count = query_runners(api_url, token, owner, repo)
-        if api_count > 0:
-            return api_count
-
-    # Fall back to MOLECULE_RUNNERS env var (set by CI from repo variable)
-    env_count = os.environ.get("MOLECULE_RUNNERS")
-    if env_count:
-        try:
-            count = int(env_count)
-            if count > 0:
-                return count
-        except ValueError:
-            pass
-
-    # Fall back to default
-    return DEFAULT_MAX_RUNNERS
-
-
-def generate_indices(count: int) -> list[str]:
-    """Generate a list of runner indices ["1", "2", ..., "N"].
-
-    Uses 1-based string indices because Gitea Actions renders
-    integer 0 and string "0" as empty in ${{ matrix.runner-index }}
-    expressions, causing --runner-index to be passed without a value.
-    The distribute_molecule.py script converts these back to 0-based
-    internally.
-    """
-    return [str(i + 1) for i in range(count)]
-
-
-@click.command()
-@click.option("--owner", default=None, help="Repository owner (for API query).")
-@click.option("--repo", default=None, help="Repository name (for API query).")
-@click.option("--count", "output_count", is_flag=True, help="Output only the count.")
-@click.option("--indices", "output_indices", is_flag=True, help="Output only the JSON indices array.")
-@click.option(
-    "--github-output",
-    "github_output",
-    is_flag=True,
-    default=False,
-    help="Write results to $GITHUB_OUTPUT file (for CI workflow steps).",
+from devx.molecule.discover_runners import (  # noqa: F401 — re-exported for backward compat
+    DEFAULT_MAX_RUNNERS,
+    generate_indices,
+    get_runner_count,
+    main,
+    query_runners,
 )
-def main(
-    owner: str | None,
-    repo: str | None,
-    output_count: bool,
-    output_indices: bool,
-    github_output: bool,
-) -> None:
-    token = os.environ.get("CI_GITEA_TOKEN", "")
 
-    if owner is None:
-        owner = os.environ.get("DEVX_REPO_OWNER", "") or REPO_OWNER
-    if repo is None:
-        repo = os.environ.get("DEVX_REPO_NAME", "") or REPO_NAME
+_DEPRECATION_MSG = (
+    "devx.ci.discover_runners is deprecated; use devx.molecule.discover_runners instead. "
+    "This wrapper will be removed in a future release."
+)
 
-    count = get_runner_count(GITEA_API_URL, token, owner, repo)
-    indices = generate_indices(count)
 
-    if github_output:
-        gh_output = os.environ.get("GITHUB_OUTPUT")
-        if not gh_output:
-            raise click.ClickException("GITHUB_OUTPUT environment variable is not set")
-        with open(gh_output, "a", encoding="utf-8") as f:  # noqa: PTH123
-            f.write(f"runner-count={count}\n")
-            f.write(f"runner-indices={json.dumps(indices)}\n")
-        click.echo(_("Runner count: {count}", count=count))
-        click.echo(_("Runner indices: {indices}", indices=indices))
-        return
-
-    if output_count:
-        click.echo(str(count))
-        return
-
-    if output_indices:
-        click.echo(json.dumps(indices))
-        return
-
-    # Default: output both as key=value pairs for CI consumption
-    click.echo(_("count={count}", count=count))
-    click.echo(_("indices={indices}", indices=json.dumps(indices)))
+def _emit_deprecation_warning() -> None:
+    """Emit a DeprecationWarning when this module is imported for CLI use."""
+    warnings.warn(_DEPRECATION_MSG, DeprecationWarning, stacklevel=2)
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main()
+    _emit_deprecation_warning()
+    sys.exit(main())

src/devx/ci/doc_coverage.py

@@ -21,6 +21,7 @@ from pathlib import Path
 
 import click
 
+from devx.config import _load_pyproject_devx
 from devx.i18n import _
 
 # Default to the current working directory (consuming repo's root)
@@ -71,12 +72,30 @@ def extract_cli_commands(source_dir: Path) -> list[str]:
     # Matches @cli.command, @ci.command, @tools.command, @molecule.command
     for match in re.finditer(r"@\w+\.command\b", content):
         # Check for explicit name="..." in the decorator arguments
-        decorator_end = content.find(")", match.start())
+        # Use a balanced paren search to find the end of the decorator
+        # (handles nested parens like @cli.command(help=_("...")))
+        depth = 0
+        decorator_end = match.start()
+        for i in range(match.start(), len(content)):
+            if content[i] == "(":
+                depth += 1
+            elif content[i] == ")":
+                depth -= 1
+                if depth == 0:
+                    decorator_end = i
+                    break
         decorator_text = content[match.start() : decorator_end + 1]
-        name_match = re.search(r'["\']([^"\']+)["\']', decorator_text)
+        # Look for explicit name="..." parameter (not help=, not other kwargs)
+        name_match = re.search(r'\bname\s*=\s*["\']([^"\']+)["\']', decorator_text)
         if name_match:
             commands.append(name_match.group(1))
             continue
+        # Look for a positional string argument (e.g. @cli.command("my-cmd"))
+        # but skip if the only strings are in help= or other keyword args
+        positional_match = re.search(r'@\w+\.command\s*\(\s*["\']([^"\']+)["\']', decorator_text)
+        if positional_match:
+            commands.append(positional_match.group(1))
+            continue
         # Find the next def statement after this decorator
         after = content[decorator_end:]
         def_match = re.search(r"def\s+(\w+)\s*\(", after)
@@ -106,16 +125,38 @@ def check_module_documented(module: str, docs_content: str) -> bool:
 @click.command()
 @click.option("--docs-dir", default=None, help="Path to the docs directory (default: ./docs).")
 @click.option("--source-dir", default=None, help="Path to the source directory (default: auto-detect from src/).")
+@click.option(
+    "--ci-scripts-dir",
+    default=None,
+    help=(
+        "Path to CI scripts directory (default: auto-detect from src/ci/). "
+        "Set to empty string to skip CI script checks."
+    ),
+)
 @click.option(
     "--fail-on-missing",
     is_flag=True,
     default=False,
     help="Exit with non-zero status if any documentation is missing.",
 )
-def main(docs_dir: str | None, source_dir: str | None, fail_on_missing: bool) -> None:
+def main(docs_dir: str | None, source_dir: str | None, ci_scripts_dir: str | None, fail_on_missing: bool) -> None:
     root = Path.cwd()
     docs_path = Path(docs_dir) if docs_dir else root / "docs"
 
+    # Read [tool.devx.doc_coverage] config from pyproject.toml
+    devx_cfg = _load_pyproject_devx()
+    doc_cov_cfg_raw: object = devx_cfg.get("doc_coverage", {}) if isinstance(devx_cfg, dict) else {}
+    doc_cov_cfg: dict[str, object] = doc_cov_cfg_raw if isinstance(doc_cov_cfg_raw, dict) else {}
+
+    # CLI args override config; config overrides defaults
+    if ci_scripts_dir is None and "ci_scripts_dir" in doc_cov_cfg:
+        ci_scripts_dir = str(doc_cov_cfg["ci_scripts_dir"])
+    if docs_dir is None and "docs_dir" in doc_cov_cfg:
+        docs_dir = str(doc_cov_cfg["docs_dir"])
+        docs_path = Path(docs_dir)
+    if source_dir is None and "source_dir" in doc_cov_cfg:
+        source_dir = str(doc_cov_cfg["source_dir"])
+
     # Auto-detect source directory
     if source_dir:
         src_path = Path(source_dir)
@@ -166,13 +207,27 @@ def main(docs_dir: str | None, source_dir: str | None, fail_on_missing: bool) ->
             missing.append(f"Module: {module}")
 
     # Check CI scripts in ci-cd-workflow.md
-    # Auto-detect CI scripts from ci/ subdirectory
+    # Auto-detect CI scripts from ci/ subdirectory, or use explicit config
     click.echo(_("\nChecking CI script documentation in ci-cd-workflow.md..."))
-    ci_dir = src_path / "ci" if src_path.name != "ci" else src_path
-    if ci_dir.exists():
-        detected_scripts = sorted(f.name for f in ci_dir.glob("*.py") if f.name != "__init__.py")
+    if ci_scripts_dir is not None:
+        # Explicit config — empty string means skip CI script checks
+        if ci_scripts_dir == "":
+            detected_scripts = []
+        else:
+            ci_dir = Path(ci_scripts_dir)
+            if ci_dir.exists():
+                detected_scripts = sorted(f.name for f in ci_dir.glob("*.py") if f.name != "__init__.py")
+            else:
+                detected_scripts = []
     else:
-        detected_scripts = REQUIRED_SCRIPTS
+        # Auto-detect from src_path/ci/
+        ci_dir = src_path / "ci" if src_path.name != "ci" else src_path
+        if ci_dir.exists():
+            detected_scripts = sorted(f.name for f in ci_dir.glob("*.py") if f.name != "__init__.py")
+        else:
+            # No ci/ directory found — skip CI script checks rather than falling back
+            # to REQUIRED_SCRIPTS (which is devx-specific)
+            detected_scripts = []
     total += len(detected_scripts)
     ci_docs = ci_cd_file.read_text() if ci_cd_file.exists() else ""
     for script in detected_scripts:

src/devx/ci/fix_pr_title.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Auto-fix PR title to follow the ``{PREFIX}-N: <title>`` convention.
+
+Reads the task ID from the branch name, fetches the Vikunja task title,
+and updates the PR title via the Gitea API.
+
+Exit codes:
+  0 = PR title updated (or already correct)
+  1 = Error (missing token, PR not found, etc.)
+
+Usage::
+
+    python3 -m devx.ci.fix_pr_title --repo owner/repo --pr-number 123
+    python3 -m devx.ci.fix_pr_title --repo owner/repo --branch DEVX-256-fix-foo --pr-number 123
+"""
+
+from __future__ import annotations
+
+import click
+from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
+
+from devx.api_clients import GiteaClient
+from devx.ci.auto_merge import extract_task_id
+from devx.ci.check_auto_merge_ready import get_vikunja_title_optional
+from devx.config import (
+    GITEA_API_URL,
+    TASK_PREFIX,
+)
+from devx.exceptions import APIError
+from devx.i18n import _
+from devx.tokens import get_ci_token
+
+load_dotenv()
+
+
+@click.command()
+@click.option("--repo", required=True, help=_("Repository in owner/name format"))
+@click.option("--pr-number", type=int, required=True, help=_("PR number to fix"))
+@click.option("--branch", default=None, help=_("Branch name (auto-fetched from PR if not given)"))
+@click.option("--dry-run", is_flag=True, help=_("Show what would change without updating"))
+def cli(repo: str, pr_number: int, branch: str | None, dry_run: bool) -> None:
+    """Fix PR title to follow the ``{PREFIX}-N: <title>`` convention."""
+    if "/" not in repo:
+        raise click.ClickException(_("Repo must be in 'owner/name' format, got: {repo}", repo=repo))
+    owner, repo_name = repo.split("/", 1)
+
+    # 1. Get CI token
+    try:
+        token = get_ci_token()
+    except click.ClickException as exc:
+        raise click.ClickException(_("CI_GITEA_API_TOKEN not set: {error}", error=str(exc))) from exc
+
+    client = GiteaClient(GITEA_API_URL, token, owner, repo_name)
+
+    # 2. Fetch PR
+    try:
+        pr = client.get_pr(pr_number)
+    except APIError as exc:
+        raise click.ClickException(_("Failed to fetch PR #{pr}: {error}", pr=pr_number, error=str(exc))) from exc
+
+    current_title = str(pr.get("title", ""))
+    if not branch:
+        branch = str(pr.get("head", {}).get("ref", ""))
+        if not branch:
+            raise click.ClickException(_("Could not determine branch name from PR #{pr}", pr=pr_number))
+
+    click.echo(f"[fix-pr-title] Branch: {branch}")
+    click.echo(f"[fix-pr-title] Current PR title: {current_title}")
+
+    # 3. Extract task ID from branch
+    task_id = extract_task_id(branch)
+    if not task_id:
+        raise click.ClickException(
+            _(
+                "No task ID found in branch '{branch}'. Expected format: {prefix}-N-description.",
+                branch=branch,
+                prefix=TASK_PREFIX,
+            )
+        )
+
+    click.echo(f"[fix-pr-title] Task ID: {task_id}")
+
+    # 4. Get Vikunja task title
+    vikunja_title = get_vikunja_title_optional(task_id)
+    if vikunja_title is None:
+        # Fallback: strip common prefixes from current title
+        # (e.g. "fix: ...", "feat: ...", "refactor: ...")
+        import re
+
+        stripped = re.sub(
+            r"^(fix|feat|refactor|chore|docs|test|ci|build|perf|style|revert)(\(.+?\))?!?:\s*", "", current_title
+        )
+        # Also strip any leading task ID prefix
+        stripped = re.sub(rf"^{TASK_PREFIX}-\d+:\s*", "", stripped)
+        vikunja_title = stripped if stripped else current_title
+        click.echo(f"[fix-pr-title] WARNING: Vikunja task not found — using stripped title: {vikunja_title}")
+    else:
+        click.echo(f"[fix-pr-title] Vikunja title: {vikunja_title}")
+
+    # 5. Build new title
+    # Defensive: strip task ID prefix from Vikunja title if present
+    if vikunja_title.startswith(f"{task_id}:"):
+        vikunja_title = vikunja_title[len(f"{task_id}:") :].strip()
+
+    new_title = f"{task_id}: {vikunja_title}"
+
+    if current_title == new_title:
+        click.echo(f"[fix-pr-title] PR title already correct: {new_title}")
+        return
+
+    click.echo(f"[fix-pr-title] New PR title: {new_title}")
+
+    if dry_run:
+        click.echo("[fix-pr-title] Dry run — not updating PR.")
+        return
+
+    # 6. Update PR title
+    try:
+        client.update_pr(pr_number, {"title": new_title})
+    except APIError as exc:
+        raise click.ClickException(_("Failed to update PR #{pr}: {error}", pr=pr_number, error=str(exc))) from exc
+
+    click.echo(f"[fix-pr-title] PR #{pr_number} title updated to: {new_title}")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    cli()  # pragma: no cover

src/devx/ci/integration_guard.py

@@ -17,7 +17,7 @@ Usage::
 
 Environment variables:
     GITEA_URL           Base URL of the Gitea instance.
-    CI_GITEA_TOKEN      API token with repo access.
+    CI_GITEA_API_TOKEN  API token with repo access (CI_GITEA_TOKEN accepted for legacy).
     RUN_ID              Workflow run ID (GITHUB_RUN_ID).
     JOB_NAME            Base job name (GITHUB_JOB), e.g. "integration-tests".
     MATRIX_INDEX        Current matrix index (runner-index).
@@ -41,6 +41,7 @@ from devx.i18n import _
 from devx.molecule.molecule_ci_guard import (
     poll_for_other_failures,
 )
+from devx.tokens import get_ci_token
 
 POLL_INTERVAL = 10
 
@@ -50,7 +51,10 @@ POLL_INTERVAL = 10
 def cli(pytest_args: tuple[str, ...]) -> None:
     """Run pytest with cross-runner failure detection."""
     gitea_url = os.environ.get("GITEA_URL", "")
-    token = os.environ.get("CI_GITEA_TOKEN", "")
+    try:
+        token = get_ci_token()
+    except click.ClickException:
+        token = None
     run_id = int(os.environ.get("RUN_ID", "0"))
     job_name = os.environ.get("JOB_NAME", "integration-tests")
     current_index = int(os.environ.get("MATRIX_INDEX", "0"))

src/devx/ci/notify_failure.py

@@ -6,7 +6,7 @@ otherwise go unnoticed in the Actions tab. Uses the ``tea`` Gitea CLI
 for issue creation — tea must be installed and configured.
 
 Usage:
-  CI_GITEA_TOKEN=<token> python3 -m devx.ci.notify_failure \
+  CI_GITEA_API_TOKEN=<token> python3 -m devx.ci.notify_failure \
     --repo <owner/repo> \
     --run-id <run_id> \
     --workflow <workflow_name> \
@@ -14,14 +14,13 @@ Usage:
     --auto-login
 
 With ``--auto-login``, the script configures the tea CLI login profile
-from ``CI_GITEA_TOKEN`` and ``DEVX_GITEA_API_URL`` before creating the issue,
+from the CI API token and ``DEVX_GITEA_API_URL`` before creating the issue,
 eliminating the need for a separate ``tea login add`` step in the workflow.
 """
 
 from __future__ import annotations
 
 import logging
-import os
 
 import click
 from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
@@ -29,6 +28,7 @@ from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnk
 from devx.config import GITEA_API_URL
 from devx.gitea_cli import TeaCLI, TeaCLIError, configure_tea_login
 from devx.i18n import _
+from devx.tokens import get_ci_token
 
 load_dotenv()
 
@@ -74,9 +74,10 @@ def _create_issue_via_tea(repo: str, title: str, body: str) -> int:
     help="Configure tea CLI login from CI_GITEA_TOKEN before creating the issue.",
 )
 def main(repo: str, run_id: str, workflow: str, commit: str, auto_login: bool) -> None:
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set."))
+    try:
+        get_ci_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set.")) from None
 
     if auto_login:
         configure_tea_login()

src/devx/ci/post_merge.py

@@ -5,7 +5,6 @@ Usage:
   VIKUNJA_TOKEN=<token> python3 -m devx.ci.post_merge <commit_msg> [--commit-sha <sha>]
 """
 
-import os
 import re
 import subprocess  # nosec B404
 
@@ -17,6 +16,7 @@ from devx.ci._shared import extract_task_id as _extract_task_id
 from devx.config import DEFAULT_PER_PAGE, TASK_PREFIX, VIKUNJA_API_URL, VIKUNJA_PROJECT_ID
 from devx.exceptions import APIError
 from devx.i18n import _
+from devx.tokens import get_vikunja_token
 
 load_dotenv()
 
@@ -127,9 +127,10 @@ def main(commit_msg: str | None, commit_sha: str, from_git: bool, git_sha: str)
             commit_sha = _get_git_commit_sha()
     if not commit_msg:
         raise click.ClickException("commit_msg argument is required (or use --from-git or --git-sha)")
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("ERROR: VIKUNJA_TOKEN is not set."))
+    try:
+        token = get_vikunja_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: VIKUNJA_TOKEN is not set.")) from None
 
     task_id = extract_task_id(commit_msg)
     if not task_id:

src/devx/ci/pr_review.py

@@ -17,7 +17,7 @@ Checks performed:
   8. Commit conventions — conventional commit format on branch commits
 
 Usage:
-  CI_GITEA_TOKEN=<token> python3 -m devx.ci.pr_review <pr_number> <owner/repo>
+  CI_GITEA_API_TOKEN=<token> [REVIEWER_GITEA_API_TOKEN=<token>] python3 -m devx.ci.pr_review <pr_number> <owner/repo>
 """
 
 from __future__ import annotations
@@ -34,6 +34,7 @@ from devx.api_clients import GiteaClient
 from devx.config import GITEA_API_URL
 from devx.exceptions import APIError
 from devx.i18n import _
+from devx.tokens import get_ci_token, get_reviewer_token
 
 load_dotenv()
 
@@ -548,8 +549,14 @@ def _post_manual_review(
     checklist_confirmed: bool,
     checklist_categories: str | None,
     dry_run: bool,
+    owner: str | None = None,
+    repo_name: str | None = None,
 ) -> None:
-    """Post a manual review with validation for APPROVE events."""
+    """Post a manual review with validation for APPROVE events.
+
+    When self-approval is rejected (reviewer token belongs to PR author),
+    falls back to the CI token (different user) if available.
+    """
     if not body or len(body) < 50:
         raise click.ClickException(_("Review body must be at least 50 characters."))
 
@@ -585,8 +592,20 @@ def _post_manual_review(
         review = client.create_review(pr_number, event=event, body=body)
     except APIError as e:
         if "approve" in e.message.lower() or "422" in str(e.status):
-            click.echo(_("Note: Self-approval not allowed. Posting COMMENT instead."))
-            review = client.create_review(pr_number, event="COMMENT", body=body)
+            # Self-approval not allowed (reviewer token belongs to PR author).
+            # Fall back to CI token (different user) if available.
+            ci_token = os.environ.get("CI_GITEA_API_TOKEN", "").strip()
+            if ci_token and owner and repo_name:
+                click.echo(_("Note: Self-approval not allowed with reviewer token. Retrying with CI token."))
+                ci_client = GiteaClient(GITEA_API_URL, ci_token, owner, repo_name)
+                try:
+                    review = ci_client.create_review(pr_number, event=event, body=body)
+                except APIError:
+                    click.echo(_("Note: CI token also cannot approve. Posting COMMENT instead."))
+                    review = client.create_review(pr_number, event="COMMENT", body=body)
+            else:
+                click.echo(_("Note: Self-approval not allowed. Posting COMMENT instead."))
+                review = client.create_review(pr_number, event="COMMENT", body=body)
         else:
             raise
     review_id = review.get("id", "?")
@@ -636,15 +655,26 @@ def main(
     Without --event: runs automated checks and posts COMMENT/REQUEST_CHANGES.
     With --event: posts a manual review (skips automated checks).
     """
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set."))
+    try:
+        token = get_reviewer_token() if (event and event.upper() == "APPROVE") else get_ci_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set.")) from None
 
     owner, repo_name = repo.split("/")
     client = GiteaClient(GITEA_API_URL, token, owner, repo_name)
 
     if event is not None:
-        _post_manual_review(client, pr_number, event.upper(), body, checklist_confirmed, checklist_categories, dry_run)
+        _post_manual_review(
+            client,
+            pr_number,
+            event.upper(),
+            body,
+            checklist_confirmed,
+            checklist_categories,
+            dry_run,
+            owner=owner,
+            repo_name=repo_name,
+        )
         return
 
     result = run_review(client, pr_number)

src/devx/ci/publish.py

@@ -4,19 +4,23 @@
 Uses git-cliff to generate the release notes from conventional commits.
 Uses the ``tea`` Gitea CLI for release creation.
 
+Gitea release creation is retried up to 3 times with exponential backoff
+(2s, 4s) to handle transient failures (network timeouts, 5xx errors).
+If the release already exists, it is treated as success (idempotent).
+
 Publishing destinations (checked in order):
   1. **Gitea PyPI registry** — if ``--registry-url`` is given (or
      ``DEVX_PYPI_REGISTRY_URL`` env var is set, or ``GITEA_API_URL``
      is converted to a packages URL). Uses ``twine upload
      --repository-url <url> -u <token> -p <token>`` with the
-     ``CI_GITEA_TOKEN`` as both username and password.
+     CI API token as both username and password.
   2. **Standard PyPI** — if ``PYPI_TOKEN`` is set. Uses the standard
      ``twine upload -u __token__ -p <token>`` flow.
   3. **Skip** — if neither is configured, only the Gitea release is created.
 
 Usage:
-  CI_GITEA_TOKEN=<token> [PYPI_TOKEN=<token>] python3 -m devx.ci.publish <tag> <repo>
-  CI_GITEA_TOKEN=<token> python3 -m devx.ci.publish <tag> <repo> --registry-url https://git.example.com/api/packages/owner/pypi
+  CI_GITEA_API_TOKEN=<token> [PYPI_TOKEN=<token>] python3 -m devx.ci.publish <tag> <repo>
+  CI_GITEA_API_TOKEN=<token> python3 -m devx.ci.publish <tag> <repo> --registry-url https://git.example.com/api/packages/owner/pypi
 """
 
 import os
@@ -27,10 +31,12 @@ from pathlib import Path
 
 import click
 from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
+from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
 
 from devx.config import GITEA_API_URL, REPO_OWNER
 from devx.gitea_cli import TeaCLI, TeaCLIError, configure_tea_login
 from devx.i18n import _
+from devx.tokens import get_ci_token
 
 load_dotenv()
 
@@ -253,9 +259,10 @@ def main(
 
     if not tag:
         raise click.ClickException(_("Tag is required (or use --from-tag)."))
-    gitea_token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not gitea_token:
-        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set."))
+    try:
+        gitea_token = get_ci_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set.")) from None
 
     pypi_token = os.environ.get("PYPI_TOKEN", "")
 
@@ -310,13 +317,7 @@ def main(
 
     release_body = generate_release_notes(tag)
 
-    try:
-        tea.create_release(repo, tag=tag, title=tag, body=release_body)
-    except TeaCLIError as e:
-        if "already" in str(e).lower() and "release" in str(e).lower():
-            click.echo(_("Gitea release {tag} already exists — skipping creation.", tag=tag))
-            return
-        raise click.ClickException(_("Release creation failed: {error}", error=str(e))) from None
+    _create_release_with_retry(tea, repo, tag, release_body)
 
     click.echo(
         _(
@@ -326,5 +327,36 @@ def main(
     )
 
 
+def _create_release_with_retry(tea: TeaCLI, repo: str, tag: str, release_body: str) -> None:
+    """Create a Gitea release with retry for transient failures.
+
+    Retries up to 3 times with exponential backoff (2s, 4s) on TeaCLIError
+    unless the error indicates the release already exists (which is treated
+    as success). This handles transient issues like network timeouts, Gitea
+    rate limiting, or temporary 5xx errors that caused CI run #2822 to fail.
+    """
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=2, min=2, max=10),
+        retry=retry_if_exception_type(TeaCLIError),
+        reraise=True,
+    )
+    def _attempt() -> None:
+        try:
+            tea.create_release(repo, tag=tag, title=tag, body=release_body)
+        except TeaCLIError as e:
+            error_str = str(e).lower()
+            if "already" in error_str and "release" in error_str:
+                click.echo(_("Gitea release {tag} already exists — skipping creation.", tag=tag))
+                return
+            raise
+
+    try:
+        _attempt()
+    except TeaCLIError as e:
+        raise click.ClickException(_("Release creation failed: {error}", error=str(e))) from None
+
+
 if __name__ == "__main__":  # pragma: no cover
     main()

src/devx/ci/push_badges.py

@@ -93,8 +93,8 @@ def push_to_badges_branch(badges_dir: str) -> str:
     _run(["git", "config", "user.email", "actions@oblachno.fyi"])  # nosec B607
     _run(["git", "checkout", "--orphan", "badges"])  # nosec B607
     _run(["git", "rm", "-rf", "."])  # nosec B607
-    # Remove untracked files/dirs left behind (e.g. .badges/ from generate_badges)
-    _run(["git", "clean", "-fdx", "-e", ".git"])  # nosec B607
+    # Remove untracked files/dirs left behind, but preserve .badges/ for copy below
+    _run(["git", "clean", "-fdx", "-e", ".git", "-e", badges_dir])  # nosec B607
 
     # Copy badge files to root
     for svg in Path(badges_dir).glob("*.svg"):

src/devx/ci/record_deployed_tag.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Record the deployed git tag for a given environment.
+
+Writes the tag to a Gitea repository variable so it can be queried
+later via the Gitea API or ``devx.ci.get_deployed_tag``.
+
+Usage::
+
+    python -m devx.ci.record_deployed_tag --env production --tag v0.28.1
+    python -m devx.ci.record_deployed_tag --env staging --tag master-abc1234
+"""
+
+from __future__ import annotations
+
+import sys
+
+import click
+
+from devx.api_clients import GiteaClient
+from devx.config import GITEA_API_URL, REPO_NAME, REPO_OWNER
+from devx.i18n import _
+from devx.tokens import get_ci_token
+
+
+@click.command()
+@click.option(
+    "--env",
+    "env_name",
+    type=click.Choice(["staging", "production"]),
+    required=True,
+)
+@click.option("--tag", required=True, help=_("Git tag or ref that was deployed"))
+def main(env_name: str, tag: str) -> None:
+    """Record the deployed tag for the given environment."""
+    try:
+        token = get_ci_token()
+    except click.ClickException as exc:
+        click.echo(f"Error: {exc.message}", err=True)
+        sys.exit(1)
+
+    var_name = f"{env_name.upper()}_DEPLOY_TAG"
+    client = GiteaClient(GITEA_API_URL, token, REPO_OWNER, REPO_NAME)
+    client.set_repo_variable(var_name, tag)
+    click.echo(f"Recorded {var_name} = {tag}")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/ci/release.py

@@ -29,7 +29,7 @@ version.  This prevents duplicate release commits (a common issue when CI
 checkouts don't fetch tags) and ensures tag/version/commit alignment.
 
 Usage:
-  CI_GITEA_TOKEN=<token> python3 -m devx.ci.release [--dry-run] [--skip-tests]
+  CI_GITEA_API_TOKEN=<token> python3 -m devx.ci.release [--dry-run] [--skip-tests]
   python3 -m devx.ci.release --verify   # Check tag/version/release alignment
 """
 

src/devx/ci/sync_wiki.py

@@ -21,7 +21,7 @@ Link transformations:
 - Anchor-only links (``#section``) are preserved
 
 Usage:
-  CI_GITEA_TOKEN=<token> python3 -m devx.ci.sync_wiki [--dry-run] [--repo owner/repo]
+  CI_GITEA_API_TOKEN=<token> python3 -m devx.ci.sync_wiki [--dry-run] [--repo owner/repo]
 """
 
 from __future__ import annotations
@@ -31,14 +31,16 @@ import os
 import re
 import subprocess  # nosec B404
 import tempfile
+import time
 from pathlib import Path
-from urllib.parse import urlparse
+from urllib.parse import quote, urlparse
 
 import click
 from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
 
 from devx.config import GITEA_API_URL, REPO_NAME, REPO_OWNER
 from devx.i18n import _
+from devx.tokens import get_ci_token
 
 load_dotenv()
 
@@ -49,6 +51,23 @@ MAPPING_FILE = DOCS_DIR / "mapping.json"
 _LINK_RE = re.compile(r"\[([^\]]*)\]\(([^)]+)\)")
 
 
+def wiki_filename(page_title: str) -> str:
+    """Convert a wiki page title to its Gitea wiki filename.
+
+    Gitea uses a "dash marker" (``.-``) suffix to distinguish literal dashes
+    from space-to-dash conversions.  See Gitea's ``services/wiki/wiki_path.go``.
+
+    - "Architecture" (no dashes) → ``Architecture.md``
+    - "Getting-Started" (has dashes) → ``Getting-Started.-.md``
+    - "Home" (no dashes) → ``Home.md``
+    """
+    name = page_title.replace(" ", "-")
+    if "-" in name:
+        name += ".-"
+    name += ".md"
+    return quote(name, safe="")
+
+
 def load_mapping() -> dict[str, str]:
     """Load the file-to-wiki-page mapping from mapping.json."""
     with open(MAPPING_FILE, encoding="utf-8") as f:
@@ -170,16 +189,15 @@ def sync_files(
         # Transform links
         transformed = transform_links(content)
 
-        # Wiki filename: use the page title with spaces → underscores
-        # Gitea wiki uses the page title as filename (spaces become dashes)
-        wiki_filename = page_title.replace(" ", "-") + ".md"
-        expected_files.add(wiki_filename)
+        # Wiki filename: Gitea uses a dash-marker convention for titles with dashes
+        fname = wiki_filename(page_title)
+        expected_files.add(fname)
 
         if not dry_run:
-            dest = wiki_dir / wiki_filename
+            dest = wiki_dir / fname
             dest.write_text(transformed, encoding="utf-8")
         synced += 1
-        click.echo(_("  Synced: {title} → {file}", title=page_title, file=wiki_filename))
+        click.echo(_("  Synced: {title} → {file}", title=page_title, file=fname))
 
     # Prune stale pages (in wiki but not in mapping)
     pruned = 0
@@ -234,7 +252,7 @@ def commit_and_push(wiki_dir: Path, wiki_url: str, dry_run: bool) -> bool:
 
     # Push
     result = subprocess.run(  # nosec
-        ["git", "push", wiki_url, "HEAD:master"],
+        ["git", "push", "--force", wiki_url, "HEAD:master"],
         cwd=wiki_dir,
         capture_output=True,
         text=True,
@@ -257,9 +275,10 @@ def commit_and_push(wiki_dir: Path, wiki_url: str, dry_run: bool) -> bool:
 )
 def main(dry_run: bool, repo: str | None, verify: bool) -> None:
     """Sync documentation to the Gitea wiki via Git."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set."))
+    try:
+        token = get_ci_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set.")) from None
 
     if repo is None:
         owner = os.environ.get("DEVX_REPO_OWNER", "") or REPO_OWNER
@@ -309,6 +328,9 @@ def main(dry_run: bool, repo: str | None, verify: bool) -> None:
 
         # Verification
         if verify and not dry_run:
+            if pushed:
+                click.echo(_("Waiting 5s for Gitea to process pushed commits..."))
+                time.sleep(5)
             click.echo(_("\nVerifying wiki pages..."))
             # Re-clone to verify
             verify_dir = Path(tmpdir) / "verify"
@@ -317,8 +339,8 @@ def main(dry_run: bool, repo: str | None, verify: bool) -> None:
                 raise click.ClickException(_("Wiki verification failed — could not clone wiki"))
             failures = 0
             for _file_path, page_title in sorted(mapping.items()):
-                wiki_filename = page_title.replace(" ", "-") + ".md"
-                if (verify_dir / wiki_filename).exists():
+                fname = wiki_filename(page_title)
+                if (verify_dir / fname).exists():
                     click.echo(_("  OK: {title}", title=page_title))
                 else:
                     click.echo(_("  FAIL: {title} — page not found in wiki!", title=page_title))

src/devx/ci/validate_deploy_ref.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Resolve and validate the git tag to deploy.
+
+Shared between staging and production deployments.  Ensures a concrete
+git tag is used — never a moving branch ref — so deployments are
+reproducible and rollback-friendly.
+
+Usage in workflows::
+
+    # Production (tag required)
+    python -m devx.ci.validate_deploy_ref --tag "$TAG" --github-output
+
+    # Staging force-deploy (tag required)
+    python -m devx.ci.validate_deploy_ref --tag "$TAG" --github-output
+
+    # Staging PR-triggered (PR SHA is already concrete, no tag needed)
+    python -m devx.ci.validate_deploy_ref --allow-empty --github-output
+
+Writes ``deploy-ref=<tag>`` to ``$GITHUB_OUTPUT`` when ``--github-output``
+is passed, otherwise prints the ref to stdout.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess  # nosec B404
+import sys
+
+import click
+
+from devx.i18n import _
+
+
+@click.command()
+@click.option("--tag", default="", help=_("Git tag to deploy (e.g. v0.28.1)."))
+@click.option(
+    "--allow-empty",
+    is_flag=True,
+    help=_("Allow empty tag (PR mode where SHA is concrete)."),
+)
+@click.option(
+    "--github-output",
+    is_flag=True,
+    help=_("Write deploy-ref to $GITHUB_OUTPUT file."),
+)
+def main(tag: str, allow_empty: bool, github_output: bool) -> None:
+    """Resolve and validate the deploy ref, exiting non-zero on failure."""
+    if not tag:
+        if not allow_empty:
+            click.echo(
+                "::error::No tag specified. Deployments require a concrete git tag "
+                "(e.g. v0.28.1). Use --allow-empty only for PR-triggered staging deploys "
+                "where the checkout SHA is already concrete.",
+                err=True,
+            )
+            sys.exit(1)
+        ref = ""
+        click.echo("No tag specified — using checkout ref (PR mode).")
+    else:
+        result = subprocess.run(  # nosec B603, B607
+            ["git", "rev-parse", "-q", "--verify", f"refs/tags/{tag}"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            click.echo(f"::error::Tag '{tag}' does not exist in the repository.", err=True)
+            sys.exit(1)
+        ref = tag
+        commit = result.stdout.strip()[:8]
+        click.echo(f"Deploying tag: {tag} (commit {commit})")
+
+    if github_output:
+        github_output_path = os.environ.get("GITHUB_OUTPUT")
+        if not github_output_path:
+            click.echo("::error::GITHUB_OUTPUT environment variable not set.", err=True)
+            sys.exit(1)
+        with open(github_output_path, "a") as f:
+            f.write(f"deploy-ref={ref}\n")
+    else:
+        click.echo(ref)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/ci/wait_for_checks.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""Wait for Gitea Actions jobs to complete.
+
+Polls the Gitea API for job completion status. Used by auto-merge
+jobs that need to wait for molecule-tests or other parallel jobs
+before proceeding.
+
+Exits:
+  0 — all matching jobs completed successfully
+  1 — one or more matching jobs failed
+  2 — timeout reached before all jobs completed
+  3 — API error or job not found
+
+Usage:
+  python3 -m devx.ci.wait_for_checks \\
+    --job-name molecule-tests \\
+    --repo oblachno-oss/grm \\
+    --timeout 1200 \\
+    --poll-interval 10
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+
+import click
+import requests
+
+from devx.config import GITEA_API_URL
+from devx.i18n import _
+from devx.tokens import get_ci_token
+
+
+def query_job_status(api_url: str, token: str, repo: str, job_name_prefix: str) -> list[dict]:
+    """Query the Gitea API for the status of jobs matching *job_name_prefix*.
+
+    Fetches the most recent pull_request runs (up to 3) and inspects
+    their jobs. Returns a list of ``{"name": str, "status": str,
+    "conclusion": str | None}`` dicts for jobs whose name starts with
+    *job_name_prefix*. On API errors, logs a warning to stderr and
+    returns an empty list — callers treat this as "no information yet"
+    and retry on the next poll.
+    """
+    headers = {"Authorization": f"token {token}"}
+    matches: list[dict] = []
+    try:
+        r = requests.get(
+            f"{api_url}/repos/{repo}/actions/runs",
+            headers=headers,
+            params={"limit": 5, "event": "pull_request"},
+            timeout=10,
+        )
+        if r.status_code != 200:
+            click.echo(
+                _("Warning: actions runs query returned HTTP {status}", status=r.status_code),
+                err=True,
+            )
+            return []
+        runs = r.json()
+        if isinstance(runs, dict):
+            runs = runs.get("runs", [])
+    except (requests.RequestException, ValueError) as e:
+        click.echo(_("Warning: actions runs query failed: {error}", error=e), err=True)
+        return []
+
+    for run in runs[:3]:
+        run_id = run.get("id")
+        if run_id is None:
+            continue
+        try:
+            jr = requests.get(
+                f"{api_url}/repos/{repo}/actions/runs/{run_id}/jobs",
+                headers=headers,
+                timeout=10,
+            )
+            if jr.status_code != 200:
+                click.echo(
+                    _(
+                        "Warning: jobs query for run {run_id} returned HTTP {status}",
+                        run_id=run_id,
+                        status=jr.status_code,
+                    ),
+                    err=True,
+                )
+                continue
+            jobs = jr.json()
+            if isinstance(jobs, dict):
+                jobs = jobs.get("jobs", [])
+        except (requests.RequestException, ValueError) as e:
+            click.echo(
+                _("Warning: jobs query for run {run_id} failed: {error}", run_id=run_id, error=e),
+                err=True,
+            )
+            continue
+        for job in jobs:
+            name = job.get("name", "")
+            if name.startswith(job_name_prefix):
+                matches.append(
+                    {
+                        "name": name,
+                        "status": job.get("status", "unknown"),
+                        "conclusion": job.get("conclusion"),
+                    }
+                )
+    return matches
+
+
+def poll_until_complete(
+    api_url: str,
+    token: str,
+    repo: str,
+    job_name: str,
+    timeout: int,
+    interval: int,
+    require_success: bool = True,
+) -> int:
+    """Poll *query_job_status* until all matching jobs complete or *timeout*.
+
+    Returns:
+      0 — all matching jobs completed successfully (or any completed, when
+          *require_success* is False)
+      1 — at least one matching job completed with a non-success conclusion
+          (only when *require_success* is True)
+      2 — *timeout* reached before all matching jobs completed
+      3 — no matching jobs found at all within *timeout*
+    """
+    deadline = time.monotonic() + timeout
+    found_any = False
+
+    while time.monotonic() < deadline:
+        jobs = query_job_status(api_url, token, repo, job_name)
+        if jobs:
+            found_any = True
+            all_completed = all(j["status"] == "completed" for j in jobs)
+            if all_completed:
+                if require_success and any(j["conclusion"] != "success" for j in jobs):
+                    click.echo(
+                        _("Job(s) completed with non-success conclusion: {jobs}", jobs=jobs),
+                        err=True,
+                    )
+                    return 1
+                click.echo(_("All matching jobs completed successfully: {jobs}", jobs=jobs))
+                return 0
+        # Not all completed (or no jobs yet) — sleep and retry.
+        time.sleep(min(interval, max(0, deadline - time.monotonic())))
+
+    if not found_any:
+        click.echo(_("No matching jobs found for prefix '{prefix}' within timeout.", prefix=job_name), err=True)
+        return 3
+    click.echo(_("Timeout reached waiting for jobs matching '{prefix}'.", prefix=job_name), err=True)
+    return 2
+
+
+@click.command()
+@click.option("--job-name", required=True, help="Job name prefix to match (e.g. 'molecule-tests').")
+@click.option(
+    "--repo",
+    default=None,
+    help="Repository as owner/name (default: $GITHUB_REPOSITORY env var).",
+)
+@click.option("--timeout", type=int, default=1200, help="Max seconds to wait (default: 1200 = 20 min).")
+@click.option("--poll-interval", "interval", type=int, default=10, help="Seconds between polls (default: 10).")
+@click.option(
+    "--require-success/--no-require-success",
+    default=True,
+    help="Exit 1 if a matched job failed (default: yes).",
+)
+def main(job_name: str, repo: str | None, timeout: int, interval: int, require_success: bool) -> None:
+    """Wait for Gitea Actions jobs matching --job-name to complete."""
+    if repo is None:
+        repo = os.environ.get("GITHUB_REPOSITORY", "")
+    if not repo or "/" not in repo:
+        raise click.ClickException(_("--repo is required (or set GITHUB_REPOSITORY=owner/name)"))
+    if timeout <= 0:
+        raise click.ClickException(_("--timeout must be positive"))
+    if interval <= 0:
+        raise click.ClickException(_("--poll-interval must be positive"))
+
+    try:
+        token = get_ci_token()
+    except click.ClickException as e:
+        click.echo(str(e), err=True)
+        sys.exit(3)
+
+    click.echo(
+        _(
+            "Waiting for jobs matching '{prefix}' in {repo} (timeout={timeout}s, interval={interval}s)",
+            prefix=job_name,
+            repo=repo,
+            timeout=timeout,
+            interval=interval,
+        )
+    )
+    code = poll_until_complete(
+        GITEA_API_URL,
+        token,
+        repo,
+        job_name,
+        timeout,
+        interval,
+        require_success=require_success,
+    )
+    sys.exit(code)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/cli.py

@@ -158,6 +158,13 @@ def ci_validate_commit_msg(args: tuple[str, ...]) -> None:
     _run_module("devx.ci.validate_commit_msg", list(args))
 
 
+@ci.command("wait-for-checks")
+@click.argument("args", nargs=-1)
+def ci_wait_for_checks(args: tuple[str, ...]) -> None:
+    """Wait for Gitea Actions jobs to complete (polls API)."""
+    _run_module("devx.ci.wait_for_checks", list(args))
+
+
 @ci.command("distribute-files")
 @click.argument("args", nargs=-1)
 def ci_distribute_files(args: tuple[str, ...]) -> None:
@@ -172,6 +179,27 @@ def ci_integration_guard(args: tuple[str, ...]) -> None:
     _run_module("devx.ci.integration_guard", list(args))
 
 
+@ci.command("cancel-superseded-runs")
+@click.argument("args", nargs=-1)
+def ci_cancel_superseded_runs(args: tuple[str, ...]) -> None:
+    """Cancel superseded CI runs for the same PR branch."""
+    _run_module("devx.ci.cancel_superseded_runs", list(args))
+
+
+@ci.command("check-workflow-artifact-deps")
+@click.argument("args", nargs=-1)
+def ci_check_workflow_artifact_deps(args: tuple[str, ...]) -> None:
+    """Check that artifact download jobs depend on upload jobs."""
+    _run_module("devx.ci.check_workflow_artifact_deps", list(args))
+
+
+@ci.command("check-workflow-tofu-init")
+@click.argument("args", nargs=-1)
+def ci_check_workflow_tofu_init(args: tuple[str, ...]) -> None:
+    """Check that workflow jobs using tofu state have a tofu-init step."""
+    _run_module("devx.ci.check_workflow_tofu_init", list(args))
+
+
 @cli.group()
 def tools() -> None:
     """Development tool commands."""
@@ -240,6 +268,27 @@ def tools_pr_rebase(args: tuple[str, ...]) -> None:
     _run_module("devx.tools.pr_rebase", list(args))
 
 
+@tools.command("check-docker-init")
+@click.argument("args", nargs=-1)
+def tools_check_docker_init(args: tuple[str, ...]) -> None:
+    """Check that Docker Compose services with healthchecks have init: true."""
+    _run_module("devx.tools.check_docker_init", list(args))
+
+
+@tools.command("check-ansible-set-fact-to-json")
+@click.argument("args", nargs=-1)
+def tools_check_ansible_set_fact_to_json(args: tuple[str, ...]) -> None:
+    """Check that Ansible set_fact tasks don't misuse to_json."""
+    _run_module("devx.tools.check_ansible_set_fact_to_json", list(args))
+
+
+@tools.command("check-alert-rules")
+@click.argument("args", nargs=-1)
+def tools_check_alert_rules(args: tuple[str, ...]) -> None:
+    """Validate rendered Prometheus alert rules with promtool."""
+    _run_module("devx.tools.check_alert_rules", list(args))
+
+
 @cli.group()
 def molecule() -> None:
     """Molecule testing commands (requires devx[molecule])."""

src/devx/gitea_cli.py

@@ -40,26 +40,45 @@ Usage::
 from __future__ import annotations
 
 import json
-import os
+import logging
 import shutil
 import subprocess  # nosec B404
 from typing import Any
 
 import click
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
 
-from devx.config import GITEA_API_URL
+from devx.config import GITEA_API_URL, MAX_RETRIES, RETRY_BACKOFF_BASE, RETRY_STATUS_CODES
 from devx.i18n import _
+from devx.tokens import get_ci_token
+
+logger = logging.getLogger("gitea_cli")
 
 
 class TeaCLIError(Exception):
     """Raised when a tea CLI command fails."""
 
 
+class _TransientTeaError(TeaCLIError):
+    """Tea CLI error caused by a transient HTTP status (502/503/504/429)."""
+
+
 def configure_tea_login(login_name: str = "devx") -> None:
-    """Configure tea CLI login from CI_GITEA_TOKEN and DEVX_GITEA_API_URL.
+    """Configure tea CLI login from CI_GITEA_API_TOKEN and DEVX_GITEA_API_URL.
 
     Idempotent: if a login with the same name already exists, it is not re-added.
-    Skips silently if tea is not installed or CI_GITEA_TOKEN is not set.
+    Skips silently if tea is not installed or no token is set.
+
+    Raises ``TeaCLIError`` if the login add or default command fails. This is
+    critical because subsequent tea commands (e.g. ``releases create``) will
+    fail with a cryptic "no available login" error if the login was not
+    configured successfully.
 
     Used by CI scripts (publish, notify_failure) that need tea login but
     run in containerized environments where ``make setup`` was not called.
@@ -69,8 +88,9 @@ def configure_tea_login(login_name: str = "devx") -> None:
         click.echo(_("tea not installed — skipping login configuration."))
         return
 
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
+    try:
+        token = get_ci_token()
+    except click.ClickException:
         click.echo(_("CI_GITEA_TOKEN not set — skipping login configuration."))
         return
 
@@ -87,18 +107,31 @@ def configure_tea_login(login_name: str = "devx") -> None:
         return
 
     click.echo(_("Configuring tea login '{name}' for {url}...", name=login_name, url=gitea_url))
-    subprocess.run(  # nosec B603
+    add_result = subprocess.run(  # nosec B603
         [tea_bin, "login", "add", "--name", login_name, "--url", gitea_url, "--token", token],
         capture_output=True,
         text=True,
         check=False,
     )
-    subprocess.run(  # nosec B603
+    if add_result.returncode != 0:
+        raise TeaCLIError(
+            f"tea login add failed (rc={add_result.returncode})\n"
+            f"stdout: {add_result.stdout.strip()}\n"
+            f"stderr: {add_result.stderr.strip()}"
+        )
+
+    default_result = subprocess.run(  # nosec B603
         [tea_bin, "login", "default", login_name],
         capture_output=True,
         text=True,
         check=False,
     )
+    if default_result.returncode != 0:
+        raise TeaCLIError(
+            f"tea login default failed (rc={default_result.returncode})\n"
+            f"stdout: {default_result.stdout.strip()}\n"
+            f"stderr: {default_result.stderr.strip()}"
+        )
 
 
 class TeaCLI:
@@ -121,6 +154,10 @@ class TeaCLI:
     def _run(self, args: list[str], json_output: bool = True) -> str:
         """Run a tea command and return stdout.
 
+        Retries up to ``MAX_RETRIES`` times on transient HTTP errors
+        (502/503/504/429) detected in stderr/stdout, with exponential
+        backoff. Non-transient errors fail immediately.
+
         Args:
             args: Command arguments (without the leading ``tea``).
             json_output: If True, append ``--output json`` to the command.
@@ -129,25 +166,50 @@ class TeaCLI:
             stdout as a string.
 
         Raises:
-            TeaCLIError: If the command fails.
+            TeaCLIError: If the command fails after retries are exhausted.
         """
         cmd = [self._tea, *args]
         if json_output:
             cmd.extend(["--output", "json"])
+
+        def _execute() -> str:
+            try:
+                result = subprocess.run(  # nosec B603
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+            except FileNotFoundError as e:
+                raise TeaCLIError(f"tea binary not found ('{self._tea}'). Install tea or add it to PATH.") from e
+            if result.returncode != 0:
+                parts = [
+                    f"tea command failed (rc={result.returncode}): {' '.join(args)}",
+                    f"stdout: {result.stdout.strip()}" if result.stdout.strip() else "",
+                    f"stderr: {result.stderr.strip()}" if result.stderr.strip() else "",
+                ]
+                msg = "\n".join(p for p in parts if p)
+                combined = f"{result.stdout} {result.stderr}".lower()
+                if any(str(code) in combined for code in RETRY_STATUS_CODES):
+                    raise _TransientTeaError(msg)
+                raise TeaCLIError(msg)
+            return result.stdout.strip()
+
+        retry_decorator = retry(
+            stop=stop_after_attempt(MAX_RETRIES),
+            wait=wait_exponential(
+                multiplier=RETRY_BACKOFF_BASE,
+                min=RETRY_BACKOFF_BASE,
+                max=RETRY_BACKOFF_BASE**MAX_RETRIES,
+            ),
+            retry=retry_if_exception_type(_TransientTeaError),
+            before_sleep=before_sleep_log(logger, logging.WARNING),
+            reraise=True,
+        )
         try:
-            result = subprocess.run(  # nosec B603
-                cmd,
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-        except FileNotFoundError as e:
-            raise TeaCLIError(f"tea binary not found ('{self._tea}'). Install tea or add it to PATH.") from e
-        if result.returncode != 0:
-            raise TeaCLIError(
-                f"tea command failed (rc={result.returncode}): {' '.join(args)}\nstderr: {result.stderr.strip()}"
-            )
-        return result.stdout.strip()
+            return retry_decorator(_execute)()
+        except _TransientTeaError as e:
+            raise TeaCLIError(str(e)) from e
 
     def _run_raw(self, args: list[str]) -> str:
         """Run a tea command without JSON output and return stdout."""

src/devx/i18n.py

@@ -6,6 +6,10 @@ Supported: en, bg, de, ru, zh, pl.
 Projects can extend translations by setting DEVX_TRANSLATIONS_PATH to a
 JSON file with additional keys. Keys from the project's file are merged
 on top of devx's built-in translations.
+
+Projects that use different env var names (e.g. GRM_LANG instead of
+DEVX_LANG) can call :func:`configure_i18n` at import time to override
+the defaults.
 """
 
 from __future__ import annotations
@@ -14,15 +18,39 @@ import json
 import os
 from pathlib import Path
 
+# Configurable env var names — projects can override via configure_i18n()
+_lang_env_var = "DEVX_LANG"
+_translations_path_env_var = "DEVX_TRANSLATIONS_PATH"
+
 # Load built-in translations
 _BUILTIN_TRANSLATIONS: dict[str, dict[str, str]] = json.loads(
     (Path(__file__).parent / "translations.json").read_text(encoding="utf-8")
 )
 
 
+def configure_i18n(
+    *,
+    lang_env_var: str = "DEVX_LANG",
+    translations_path_env_var: str = "DEVX_TRANSLATIONS_PATH",
+) -> None:
+    """Override the env var names used for language and translations path.
+
+    This allows downstream projects (e.g. grm) to use their own env var
+    names (e.g. ``GRM_LANG``) while still using devx's i18n system.
+
+    Args:
+        lang_env_var: Environment variable name for language selection.
+        translations_path_env_var: Environment variable name for the
+            path to a JSON file with project-specific translations.
+    """
+    global _lang_env_var, _translations_path_env_var
+    _lang_env_var = lang_env_var
+    _translations_path_env_var = translations_path_env_var
+
+
 def _load_project_translations() -> dict[str, dict[str, str]]:
-    """Load project-specific translations from DEVX_TRANSLATIONS_PATH if set."""
-    path = os.getenv("DEVX_TRANSLATIONS_PATH")
+    """Load project-specific translations from the configured env var if set."""
+    path = os.getenv(_translations_path_env_var)
     if not path:
         return {}
     p = Path(path)
@@ -41,10 +69,11 @@ TRANSLATIONS: dict[str, dict[str, str]] = {**_BUILTIN_TRANSLATIONS, **_load_proj
 def _(key: str, **kwargs: object) -> str:
     """Return a translated string for the given key.
 
-    Translation is opt-in via the ``DEVX_LANG`` environment variable.
-    If unset, English is always returned regardless of system locale.
+    Translation is opt-in via the configured language environment variable
+    (default ``DEVX_LANG``). If unset, English is always returned regardless
+    of system locale.
     """
-    lang = os.getenv("DEVX_LANG", "en")
+    lang = os.getenv(_lang_env_var, "en")
     if lang not in ("en", "bg", "de", "ru", "zh", "pl"):
         lang = "en"
     template = TRANSLATIONS.get(key, {}).get(lang, key)

src/devx/make/devx.mak

@@ -39,6 +39,9 @@
 #   DEVX_GITEA_PYPI_ORG  — Gitea PyPI org (default: oblachno-oss)
 #   DEVX_ACTIONLINT_CFG  — actionlint config file (default: .gitea/actionlint.yaml)
 #   DEVX_WORKFLOW_DIR    — workflow directory (default: .gitea/workflows)
+#   DEVX_DOC_COVERAGE_STRICT — fail on missing docs (default: 0)
+#   DEVX_DOC_VERSIONS_PKG    — package name for version ref checks (default: auto)
+#   DEVX_VALE_LEVEL          — vale alert threshold (default: warning)
 
 DEVX_PYTHON ?= python3
 DEVX_PR_BASE ?= master
@@ -52,15 +55,18 @@ DEVX_GITEA_PYPI_ORG ?= oblachno-oss
 DEVX_ACTIONLINT_CFG ?= .gitea/actionlint.yaml
 DEVX_WORKFLOW_DIR ?= .gitea/workflows
 DEVX_DOCKERFILE_PATHS ?= docker
+DEVX_VALE_LEVEL ?= warning
 
 # PIP_INSTALL — helper to run pip with Gitea private PyPI registry configured.
 # Usage: $(DEVX_PIP_INSTALL) install -e '.[ci,lint]'
 # CI_GITEA_USERNAME can be set in .env, as an env var, or as a Make variable.
 # Projects can alias: PIP_INSTALL = $(DEVX_PIP_INSTALL)
-DEVX_PIP_INSTALL := if [ -z "$$CI_GITEA_TOKEN" ]; then . ./.env 2>/dev/null; fi; \
-	CI_GITEA_TOKEN="$$CI_GITEA_TOKEN"; \
+DEVX_PIP_INSTALL := if [ -z "$$CI_GITEA_API_TOKEN" ] && [ -z "$$DEVELOPER_GITEA_API_TOKEN" ] && [ -z "$$CI_GITEA_TOKEN" ]; then . ./.env 2>/dev/null; fi; \
+	_TOKEN="$$CI_GITEA_API_TOKEN"; \
+	[ -z "$$_TOKEN" ] && _TOKEN="$$DEVELOPER_GITEA_API_TOKEN"; \
+	[ -z "$$_TOKEN" ] && _TOKEN="$$CI_GITEA_TOKEN"; \
 	_PYPI_USER="$${CI_GITEA_USERNAME:-emil}"; \
-	if [ -n "$$CI_GITEA_TOKEN" ] && [ -n "$$_PYPI_USER" ]; then export PIP_EXTRA_INDEX_URL="https://$$_PYPI_USER:$$CI_GITEA_TOKEN@$(DEVX_GITEA_PYPI_HOST)/api/packages/$(DEVX_GITEA_PYPI_ORG)/pypi/simple/"; fi; \
+	if [ -n "$$_TOKEN" ] && [ -n "$$_PYPI_USER" ]; then export PIP_EXTRA_INDEX_URL="https://$$_PYPI_USER:$$_TOKEN@$(DEVX_GITEA_PYPI_HOST)/api/packages/$(DEVX_GITEA_PYPI_ORG)/pypi/simple/"; fi; \
 	$(DEVX_BIN)/pip
 
 # ── Virtual environment management ────────────────────────────────────────────
@@ -109,7 +115,7 @@ devx-ensure-venv:
 .PHONY: devx-notify-failure devx-install-hooks devx-activate-scripts devx-venv devx-ensure-venv
 .PHONY: devx-lint-ruff devx-lint-format devx-typecheck devx-lint-bandit devx-lint-deps devx-lint
 .PHONY: devx-clean devx-pre-push
-.PHONY: devx-check-mutable-globals devx-check-dep-docs devx-check-test-coverage devx-check-docs devx-check-test-speed devx-check-doc-versions devx-vale
+.PHONY: devx-check-mutable-globals devx-check-dep-docs devx-check-test-coverage devx-check-docs devx-check-test-speed devx-check-test-isolation devx-check-translations devx-check-doc-versions devx-vale
 .PHONY: devx-check-api-identity-checks devx-setup-ssh-key
 .PHONY: devx-test-unit devx-pytest-cov
 .PHONY: devx-setup-image devx-lint-dockerfiles
@@ -192,12 +198,14 @@ devx-pr-rebase:
 # ── Environment setup ─────────────────────────────────────────────────────────
 
 # Configure Gitea private PyPI registry so pip can find devx and other
-# private packages. In CI, CI_GITEA_TOKEN is set as a secret. Locally, it's in .env.
+# private packages. In CI, CI_GITEA_API_TOKEN is set as a secret. Locally, DEVELOPER_GITEA_API_TOKEN or CI_GITEA_TOKEN can be used.
 devx-configure-gitea-pypi:
-	@if [ -z "$$CI_GITEA_TOKEN" ]; then . ./.env 2>/dev/null; fi; \
-	CI_GITEA_TOKEN="$$CI_GITEA_TOKEN"; \
-	if [ -z "$$CI_GITEA_TOKEN" ]; then echo "[configure-gitea-pypi] CI_GITEA_TOKEN not set — skipping (devx must be on public PyPI)"; exit 0; fi; \
-	echo "[configure-gitea-pypi] Gitea PyPI registry configured (CI_GITEA_TOKEN present)."
+	@if [ -z "$$CI_GITEA_API_TOKEN" ] && [ -z "$$DEVELOPER_GITEA_API_TOKEN" ] && [ -z "$$CI_GITEA_TOKEN" ]; then . ./.env 2>/dev/null; fi; \
+	_TOKEN="$$CI_GITEA_API_TOKEN"; \
+	[ -z "$$_TOKEN" ] && _TOKEN="$$DEVELOPER_GITEA_API_TOKEN"; \
+	[ -z "$$_TOKEN" ] && _TOKEN="$$CI_GITEA_TOKEN"; \
+	if [ -z "$$_TOKEN" ]; then echo "[configure-gitea-pypi] Gitea API token not set — skipping (devx must be on public PyPI)"; exit 0; fi; \
+	echo "[configure-gitea-pypi] Gitea PyPI registry configured (token present)."
 
 # Create .env from .env.example if it doesn't exist
 devx-env:
@@ -264,7 +272,7 @@ devx-workflow-check: devx-workflow-lint devx-workflow-dryrun
 
 # Notify on CI failure — creates a Gitea issue via devx.ci.notify_failure.
 # Usage: make devx-notify-failure WORKFLOW=post-merge/release
-# Requires: CI_GITEA_TOKEN, GITHUB_REPOSITORY, GITHUB_RUN_ID, GITHUB_SHA
+# Requires: CI_GITEA_API_TOKEN, GITHUB_REPOSITORY, GITHUB_RUN_ID, GITHUB_SHA
 devx-notify-failure:
 	@. $(DEVX_VENV)/bin/activate 2>/dev/null || true; \
 	export PATH="$(HOME)/.local/bin:$$PATH"; \
@@ -295,16 +303,16 @@ devx-lint-deps:
 	@PIPAPI_PYTHON_LOCATION=$$(pwd)/$(DEVX_VENV)/bin/python \
 		$(DEVX_BIN)/pip-audit --desc --skip-editable 2>&1 || true
 
-devx-lint: devx-lint-ruff devx-lint-format devx-typecheck devx-lint-bandit
+devx-lint: devx-lint-ruff devx-lint-format devx-typecheck devx-lint-bandit devx-check-translations devx-check-test-isolation
 	@echo "[devx-lint] Linting checks passed."
 
 # ── Testing ───────────────────────────────────────────────────────────────────
 
 devx-test-unit:
-	@$(DEVX_BIN)/pytest $(DEVX_TEST_PATHS) -q --no-cov
+	@$(DEVX_BIN)/pytest $(DEVX_TEST_PATHS) -q --no-cov -n 8
 
 devx-pytest-cov:
-	@$(DEVX_BIN)/pytest $(DEVX_TEST_PATHS) -v --cov=$(DEVX_COV_PKG) --cov-report=term-missing --cov-fail-under=100
+	@$(DEVX_BIN)/pytest $(DEVX_TEST_PATHS) -n auto --cov=$(DEVX_COV_PKG) --cov-report=term-missing --cov-fail-under=100
 
 # ── Quality checks ────────────────────────────────────────────────────────────
 
@@ -328,15 +336,63 @@ devx-check-docs:
 devx-check-doc-versions:
 	@$(DEVX_PYTHON) -m devx.tools.check_doc_versions --root .
 
-# Run Vale prose linter on docs and README
+# Documentation coverage — checks that all modules/scripts/CLI commands
+# are documented. Fails if any are missing when DEVX_DOC_COVERAGE_STRICT=1.
+devx-doc-coverage:
+	@$(DEVX_PYTHON) -m devx.ci.doc_coverage $(if $(filter 1,$(DEVX_DOC_COVERAGE_STRICT)),--fail-on-missing)
+
+# All-in-one documentation gate: coverage + stale refs + structural lint +
+# version refs + prose lint. Use in CI and pre-commit as a single step
+# instead of 5+ separate steps.
+#
+# Configuration via environment variables (set in Makefile before include
+# or in CI env):
+#   DEVX_DOC_COVERAGE_STRICT=1  — fail on missing docs (recommended)
+#   DEVX_DOC_VERSIONS_PKG=<pkg> — enable version ref checks for a named package
+#   DEVX_VALE_LEVEL=<level>     — vale alert threshold (error, warning, suggestion)
+#                                  default: warning (catches weasel words, unlabeled
+#                                  code blocks, etc. — not just spelling errors)
+devx-docs-check: devx-doc-coverage devx-check-docs
+	@$(DEVX_PYTHON) -m devx.ci.lint_docs --root .
+	@if [ -n "$(DEVX_DOC_VERSIONS_PKG)" ]; then \
+		$(DEVX_PYTHON) -m devx.tools.check_doc_versions --root . --package $(DEVX_DOC_VERSIONS_PKG); \
+	elif $(DEVX_PYTHON) -c "import importlib.util,sys; sys.exit(0 if any(importlib.util.find_spec(p) for p in ['devx','grm','oblachno_infra']) else 1)" 2>/dev/null; then \
+		$(DEVX_PYTHON) -m devx.tools.check_doc_versions --root . 2>/dev/null || true; \
+	fi
+	@export PATH="$$HOME/.local/bin:$$PATH" && \
+		if ! command -v vale >/dev/null 2>&1; then \
+			echo "[devx-docs-check] vale not installed — skipping prose lint (install with 'make install-tools')"; \
+		else \
+			vale sync >/dev/null 2>&1 || true; \
+			vale --minAlertLevel=$(DEVX_VALE_LEVEL) docs/ AGENTS.md README.md; \
+		fi
+
+# Run Vale prose linter on docs and README (skips if vale not installed)
+# Legacy target — use devx-docs-check for the full documentation gate.
 devx-vale:
 	@export PATH="$$HOME/.local/bin:$$PATH" && \
-		vale --minAlertLevel=error docs/ AGENTS.md README.md
+		if ! command -v vale >/dev/null 2>&1; then \
+			echo "[devx-vale] vale not installed — skipping (install with 'make install-tools')"; \
+		else \
+			vale --minAlertLevel=error docs/ AGENTS.md README.md; \
+		fi
 
 # Verify test suite timing
 devx-check-test-speed:
 	@$(DEVX_PYTHON) -m devx.tools.check_test_speed
 
+# Check test files for un-hermetic patterns (unpatched subprocess, time.sleep, etc.)
+# This is also automatically enforced by the pytest plugin (pytest11 entry point).
+# Use this target for CI gates or pre-commit hooks.
+devx-check-test-isolation:
+	@$(DEVX_PYTHON) -m devx.tools.check_test_isolation $(addprefix --test-path ,$(DEVX_TEST_PATHS))
+
+# Check translation files for missing keys, dead keys, and missing languages.
+# Runs automatically as part of devx-lint to shift-left translation issues
+# (fail locally instead of in CI).
+devx-check-translations:
+	@$(DEVX_PYTHON) -m devx.ci.check_translations
+
 # Scan integration tests for unsafe is True/is False identity checks
 devx-check-api-identity-checks:
 	@$(DEVX_PYTHON) -m devx.tools.check_api_identity_checks

src/devx/molecule/discover_runners.py

@@ -30,6 +30,8 @@ import click
 import requests
 
 from devx.config import GITEA_API_URL, REPO_NAME, REPO_OWNER
+from devx.i18n import _
+from devx.tokens import get_ci_token
 
 DEFAULT_MAX_RUNNERS = 3
 
@@ -39,7 +41,7 @@ def query_runners(api_url: str, token: str, owner: str, repo: str) -> int:
 
     Returns the total count of active runners.  If the API call fails
     (e.g., no admin access for instance-level runners), falls back to
-    what we can see.
+    what we can see.  Fallbacks are logged to stderr for debugging.
     """
     headers = {"Authorization": f"token {token}"}
     total = 0
@@ -54,8 +56,10 @@ def query_runners(api_url: str, token: str, owner: str, repo: str) -> int:
         if r.status_code == 200:
             data = r.json()
             total += data.get("total_count", 0)
-    except (requests.RequestException, ValueError):
-        pass
+        else:
+            click.echo(_("Warning: repo-level runners query returned HTTP {status}", status=r.status_code), err=True)
+    except (requests.RequestException, ValueError) as e:
+        click.echo(_("Warning: repo-level runners query failed: {error}", error=e), err=True)
 
     # 2. Organization-level runners
     try:
@@ -67,8 +71,10 @@ def query_runners(api_url: str, token: str, owner: str, repo: str) -> int:
         if r.status_code == 200:
             data = r.json()
             total += data.get("total_count", 0)
-    except (requests.RequestException, ValueError):
-        pass
+        else:
+            click.echo(_("Warning: org-level runners query returned HTTP {status}", status=r.status_code), err=True)
+    except (requests.RequestException, ValueError) as e:
+        click.echo(_("Warning: org-level runners query failed: {error}", error=e), err=True)
 
     # 3. Instance-level runners (requires admin scope)
     try:
@@ -80,13 +86,18 @@ def query_runners(api_url: str, token: str, owner: str, repo: str) -> int:
         if r.status_code == 200:
             data = r.json()
             total += data.get("total_count", 0)
-    except (requests.RequestException, ValueError):
-        pass
+        elif r.status_code != 403:  # 403 is expected without admin scope
+            click.echo(
+                _("Warning: instance-level runners query returned HTTP {status}", status=r.status_code),
+                err=True,
+            )
+    except (requests.RequestException, ValueError) as e:
+        click.echo(_("Warning: instance-level runners query failed: {error}", error=e), err=True)
 
     return total
 
 
-def get_runner_count(api_url: str, token: str, owner: str, repo: str) -> int:
+def get_runner_count(api_url: str, token: str | None, owner: str, repo: str) -> int:
     """Determine the number of available runners.
 
     Tries the Gitea API first, then falls back to env vars, then default.
@@ -142,7 +153,10 @@ def main(
     output_indices: bool,
     github_output: bool,
 ) -> None:
-    token = os.environ.get("CI_GITEA_TOKEN", "")
+    try:
+        token = get_ci_token()
+    except click.ClickException:
+        token = None
 
     if owner is None:
         owner = os.environ.get("DEVX_REPO_OWNER", "") or REPO_OWNER
@@ -159,8 +173,8 @@ def main(
         with open(gh_output, "a", encoding="utf-8") as f:  # noqa: PTH123
             f.write(f"runner-count={count}\n")
             f.write(f"runner-indices={json.dumps(indices)}\n")
-        click.echo(f"Runner count: {count}")
-        click.echo(f"Runner indices: {indices}")
+        click.echo(_("Runner count: {count}", count=count))
+        click.echo(_("Runner indices: {indices}", indices=indices))
         return
 
     if output_count:
@@ -172,8 +186,8 @@ def main(
         return
 
     # Default: output both as key=value pairs for CI consumption
-    click.echo(f"count={count}")
-    click.echo(f"indices={json.dumps(indices)}")
+    click.echo(_("count={count}", count=count))
+    click.echo(_("indices={indices}", indices=json.dumps(indices)))
 
 
 if __name__ == "__main__":  # pragma: no cover

src/devx/molecule/distribute_molecule.py

@@ -30,10 +30,24 @@ from devx.i18n import _
 from devx.molecule.platforms import PLATFORMS, load_platforms
 
 DEFAULT_MAX_RUNNERS = 3
-MOLECULE_ROOT = Path("ansible/roles/gitea-runner/molecule")
 DEFAULT_ROLES_ROOT = Path("ansible/roles")
 
 
+def _default_molecule_root() -> Path:
+    """Auto-discover the single molecule directory under ansible/roles/.
+
+    If exactly one role has a molecule/ subdirectory, return it.
+    Otherwise, fall back to the first role with a molecule/ directory.
+    """
+    roles_root = DEFAULT_ROLES_ROOT
+    if not roles_root.is_dir():
+        return roles_root / "gitea_runner" / "molecule"  # sensible default for error message
+    mol_dirs = sorted(d / "molecule" for d in roles_root.iterdir() if (d / "molecule").is_dir())
+    if mol_dirs:
+        return mol_dirs[0]
+    return roles_root / "molecule"  # will produce a clear "not found" error
+
+
 @dataclass(frozen=True)
 class TestPair:
     """A (scenario, platform) combination to test."""
@@ -83,28 +97,43 @@ class MultiRoleTestPair:
 def discover_scenarios(root: Path | None = None) -> list[str]:
     """Return sorted list of molecule scenario directory names."""
     if root is None:
-        root = MOLECULE_ROOT
+        root = _default_molecule_root()
     if not root.is_dir():
         raise click.ClickException(_("Molecule directory not found: {path}", path=str(root)))
     scenarios = [d.name for d in root.iterdir() if d.is_dir() and not d.name.startswith("_") and d.name != "common"]
     return sorted(scenarios)
 
 
-def discover_multi_role_scenarios(roles_root: Path | None = None) -> list[tuple[str, str]]:
+def discover_multi_role_scenarios(
+    roles_root: Path | None = None,
+    include_roles: list[str] | None = None,
+    exclude_roles: list[str] | None = None,
+) -> list[tuple[str, str]]:
     """Discover (role, scenario) pairs across all roles under *roles_root*.
 
     Scans ``roles_root/*/molecule/*/`` for scenario directories, skipping
     ``common`` and directories starting with ``_``. Returns a sorted list of
     ``(role_name, scenario_name)`` tuples.
+
+    If *include_roles* is given, only roles whose name is in the list are
+    returned. If *exclude_roles* is given, roles whose name is in the list
+    are skipped. Both filters are case-insensitive.
     """
     if roles_root is None:
         roles_root = DEFAULT_ROLES_ROOT
     if not roles_root.is_dir():
         raise click.ClickException(_("Roles directory not found: {path}", path=str(roles_root)))
+    include_set = {r.lower() for r in include_roles} if include_roles else None
+    exclude_set = {r.lower() for r in exclude_roles} if exclude_roles else None
     pairs: list[tuple[str, str]] = []
     for role_dir in sorted(roles_root.iterdir()):
         if not role_dir.is_dir():
             continue
+        role_name = role_dir.name
+        if include_set is not None and role_name.lower() not in include_set:
+            continue
+        if exclude_set is not None and role_name.lower() in exclude_set:
+            continue
         mol_dir = role_dir / "molecule"
         if not mol_dir.is_dir():
             continue
@@ -318,7 +347,7 @@ def _write_github_env(key: str, value: str) -> None:
     "--molecule-root",
     type=click.Path(exists=True, file_okay=False, path_type=Path),
     default=None,
-    help="Custom molecule directory (single-role mode). Default: ansible/roles/gitea-runner/molecule.",
+    help="Custom molecule directory (single-role mode). Default: auto-discovered under ansible/roles/*/molecule.",
 )
 @click.option(
     "--roles-root",
@@ -334,6 +363,24 @@ def _write_github_env(key: str, value: str) -> None:
     help="JSON file with custom platform list (each entry: name, image, command). "
     "Overrides the default platform matrix. Useful for projects with custom test images.",
 )
+@click.option(
+    "--include-roles",
+    "include_roles",
+    type=str,
+    default=None,
+    help="Comma-separated list of role names to include (multi-role mode only). "
+    "Only scenarios from these roles are distributed. Case-insensitive. "
+    "Example: --include-roles docker_base,crowdsec,disk_cleanup,app_hardening",
+)
+@click.option(
+    "--exclude-roles",
+    "exclude_roles",
+    type=str,
+    default=None,
+    help="Comma-separated list of role names to exclude (multi-role mode only). "
+    "Scenarios from these roles are skipped. Case-insensitive. "
+    "Example: --exclude-roles docker_base,crowdsec,disk_cleanup,app_hardening",
+)
 def cli(
     runner_index: int | None,
     max_runners: int,
@@ -344,11 +391,18 @@ def cli(
     molecule_root: Path | None,
     roles_root: Path | None,
     platforms_file: Path | None,
+    include_roles: str | None,
+    exclude_roles: str | None,
 ) -> None:
     platforms = load_platforms(platforms_file)
+    # Parse role filters
+    include_list = [r.strip() for r in include_roles.split(",")] if include_roles else None
+    exclude_list = [r.strip() for r in exclude_roles.split(",")] if exclude_roles else None
     # Multi-role mode: discover (role, scenario) pairs across all roles
     if roles_root is not None:
-        role_scenarios = discover_multi_role_scenarios(roles_root)
+        role_scenarios = discover_multi_role_scenarios(
+            roles_root, include_roles=include_list, exclude_roles=exclude_list
+        )
         if list_all:
             for role, scenario in role_scenarios:
                 click.echo(f"{role}|{scenario}")

src/devx/molecule/molecule_all.py

@@ -21,7 +21,20 @@ import click
 
 from devx.molecule.platforms import PLATFORMS
 
-ROLE_DIR = Path("ansible/roles/gitea-runner")
+DEFAULT_ROLES_ROOT = Path("ansible/roles")
+
+
+def _default_role_dir() -> Path:
+    """Auto-discover the single role directory with molecule scenarios."""
+    roles_root = DEFAULT_ROLES_ROOT
+    if not roles_root.is_dir():
+        return roles_root / "gitea_runner"  # sensible default for error message
+    role_dirs = sorted(d for d in roles_root.iterdir() if (d / "molecule").is_dir())
+    if role_dirs:
+        return role_dirs[0]
+    return roles_root / "role"  # will produce a clear error
+
+
 SCENARIOS = ["default", "multi-instance", "lifecycle", "template-content", "deregister", "update"]
 
 
@@ -72,15 +85,16 @@ def main(bin_dir: str) -> None:
     if not Path(molecule_bin).exists():
         raise click.ClickException(f"molecule not found at {molecule_bin}. Run 'make setup' first.")
 
-    if not ROLE_DIR.exists():
-        raise click.ClickException(f"Role directory not found: {ROLE_DIR}")
+    role_dir = _default_role_dir()
+    if not role_dir.exists():
+        raise click.ClickException(f"Role directory not found: {role_dir}")
 
     base_env = dict(os.environ)
     base_env["ANSIBLE_ALLOW_BROKEN_CONDITIONALS"] = "true"
     base_env["ANSIBLE_INJECT_INVOCATION"] = "1"
 
     for platform in PLATFORMS:
-        rc = _run_platform(molecule_bin, platform, ROLE_DIR, SCENARIOS, base_env)
+        rc = _run_platform(molecule_bin, platform, role_dir, SCENARIOS, base_env)
         if rc != 0:
             click.echo(f"FAILED on platform {platform['name']}", err=True)
             sys.exit(rc)

src/devx/molecule/molecule_changed.py

@@ -0,0 +1,158 @@
+"""Detect which Ansible roles changed and output their molecule scenarios.
+
+Usage::
+
+    python -m devx.molecule.molecule_changed --print-targets
+    python -m devx.molecule.molecule_changed --base origin/master --print-roles
+
+Outputs the list of make targets (e.g. molecule-docker-base) for roles
+that have changed files vs the base ref. Used by ``make molecule-changed``
+to run only the molecule scenarios affected by the current diff.
+
+Role-to-target mapping is derived from the directory structure:
+  ansible/roles/<role>/  →  molecule-<role>
+
+For roles with multiple scenarios (e.g. app_container has customer-apps,
+nextcloud, postgres-upgrade, simple-app), the base target runs all
+scenarios for that role.
+
+Playbooks that change also trigger molecule for the roles they include.
+Shared infrastructure changes (ansible.cfg, requirements.yml, molecule/)
+trigger all scenarios.
+"""
+
+from __future__ import annotations
+
+import subprocess  # nosec B404 — used to run git, a trusted binary
+from pathlib import Path
+
+import click
+
+REPO_ROOT = Path.cwd()
+
+# Map role names to make targets.
+ROLE_TARGET_MAP: dict[str, str] = {
+    "app_container": "molecule-app-container",
+    "app_hardening": "molecule-app-hardening",
+    "crowdsec": "molecule-crowdsec",
+    "disk_cleanup": "molecule-disk-cleanup",
+    "docker_base": "molecule-docker-base",
+    "observability": "molecule-observability",
+    "restore": "molecule-restore",
+    "sso_config": "molecule-sso-config",
+    "storage": "molecule-storage",
+    "zitadel": "molecule-zitadel",
+}
+
+# Playbooks that map to molecule scenarios (via roles they include).
+PLAYBOOK_ROLE_MAP: dict[str, list[str]] = {
+    "ansible/playbooks/deploy-observability.yml": ["observability", "docker_base", "zitadel", "crowdsec"],
+    "ansible/playbooks/deploy-customer.yml": ["app_container", "docker_base", "app_hardening", "sso_config"],
+    "ansible/playbooks/configure-oidc.yml": ["sso_config", "app_container"],
+    "ansible/playbooks/prepare-vms.yml": ["docker_base", "app_hardening", "storage", "disk_cleanup", "crowdsec"],
+}
+
+# Shared infrastructure that affects all molecule tests.
+SHARED_PATHS = (
+    "ansible/ansible.cfg",
+    "ansible/requirements.yml",
+    "ansible/molecule/",
+)
+
+# Minimum path parts for a role file: ansible/roles/<role> (3 parts).
+# Files inside the role have more parts, but we only need the role name.
+_MIN_ROLE_PATH_PARTS = 3
+
+
+def _run_git(args: list[str]) -> str:  # pragma: no cover
+    """Run a git command and return stdout."""
+    result = subprocess.run(  # nosec
+        ["git", *args],
+        cwd=REPO_ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return result.stdout
+
+
+def get_changed_files(base: str) -> list[str]:
+    """Get list of changed files vs base ref."""
+    for ref in [base, "master"]:
+        output = _run_git(["diff", "--name-only", f"{ref}...HEAD"])
+        if output.strip():
+            return sorted(output.strip().splitlines())
+    return []
+
+
+def detect_changed_roles(changed_files: list[str]) -> set[str]:
+    """Detect which roles have changed files."""
+    roles: set[str] = set()
+
+    for filepath in changed_files:
+        # Check if file is in a role directory
+        if filepath.startswith("ansible/roles/"):
+            parts = filepath.split("/")
+            if len(parts) >= _MIN_ROLE_PATH_PARTS:
+                roles.add(parts[2])
+
+        # Check if file is a playbook that maps to roles
+        if filepath in PLAYBOOK_ROLE_MAP:
+            roles.update(PLAYBOOK_ROLE_MAP[filepath])
+
+        # Check shared infrastructure — triggers all roles
+        for shared in SHARED_PATHS:
+            if filepath.startswith(shared):
+                return set(ROLE_TARGET_MAP.keys())
+
+    return roles
+
+
+def roles_to_targets(roles: set[str]) -> list[str]:
+    """Convert role names to make targets."""
+    targets = []
+    for role in sorted(roles):
+        target = ROLE_TARGET_MAP.get(role)
+        if target:
+            targets.append(target)
+    return targets
+
+
+@click.command()
+@click.option(
+    "--base",
+    default="origin/master",
+    help="Base ref to compare against (default: origin/master).",
+)
+@click.option(
+    "--print-targets",
+    is_flag=True,
+    help="Print make targets (e.g. molecule-docker-base).",
+)
+@click.option(
+    "--print-roles",
+    is_flag=True,
+    help="Print role names (default if no --print-targets).",
+)
+def main(base: str, print_targets: bool, print_roles: bool) -> None:
+    """Detect which Ansible roles changed and output molecule scenarios."""
+    changed_files = get_changed_files(base)
+    if not changed_files:
+        click.echo("No changed files detected.", err=True)
+        return
+
+    roles = detect_changed_roles(changed_files)
+    if not roles:
+        click.echo("No molecule scenarios affected by changes.", err=True)
+        return
+
+    if print_targets:
+        for target in roles_to_targets(roles):
+            click.echo(target)
+    else:
+        for role in sorted(roles):
+            click.echo(role)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/molecule/molecule_ci_guard.py

@@ -22,7 +22,7 @@ Usage::
 
 Environment variables:
     GITEA_URL           Base URL of the Gitea instance.
-    CI_GITEA_TOKEN      API token with repo access.
+    CI_GITEA_API_TOKEN  API token with repo access (CI_GITEA_TOKEN accepted for legacy).
     RUN_ID              Workflow run ID (GITHUB_RUN_ID).
     JOB_NAME            Base job name (GITHUB_JOB), e.g. "molecule-tests".
     MATRIX_INDEX        Current matrix index (runner-index).
@@ -45,6 +45,7 @@ import requests
 
 from devx.config import REPO_NAME, REPO_OWNER
 from devx.i18n import _
+from devx.tokens import get_ci_token
 
 POLL_INTERVAL = 10
 
@@ -144,13 +145,19 @@ def resolve_role_dir(role: str, roles_root: Path | None, repo_root: Path) -> Pat
     """Resolve the working directory for a molecule pair.
 
     For multi-role pairs (role non-empty), uses ``roles_root/role``.
-    For single-role pairs, uses ``repo_root/ansible/roles/gitea-runner``.
+    For single-role pairs, auto-discovers the first role with a molecule/
+    subdirectory under ``repo_root/ansible/roles/``.
     """
     if role:
         if roles_root is None:
             roles_root = repo_root / "ansible" / "roles"
         return roles_root / role
-    return repo_root / "ansible" / "roles" / "gitea-runner"
+    roles_dir = repo_root / "ansible" / "roles"
+    if roles_dir.is_dir():
+        role_dirs = sorted(d for d in roles_dir.iterdir() if (d / "molecule").is_dir())
+        if role_dirs:
+            return role_dirs[0]
+    return roles_dir / "role"  # will produce a clear "not found" error
 
 
 @click.command()
@@ -164,7 +171,10 @@ def resolve_role_dir(role: str, roles_root: Path | None, repo_root: Path) -> Pat
 def cli(pairs: tuple[str, ...], roles_root: Path | None) -> None:
     """Run molecule pairs sequentially, stop if another CI runner fails."""
     gitea_url = os.environ.get("GITEA_URL", "")
-    token = os.environ.get("CI_GITEA_TOKEN", "")
+    try:
+        token = get_ci_token()
+    except click.ClickException:
+        token = None
     run_id = int(os.environ.get("RUN_ID", "0"))
     job_name = os.environ.get("JOB_NAME", "molecule-tests")
     current_index = int(os.environ.get("MATRIX_INDEX", "0"))
@@ -236,18 +246,62 @@ def cli(pairs: tuple[str, ...], roles_root: Path | None) -> None:
                             with contextlib.suppress(ProcessLookupError):
                                 os.killpg(os.getpgid(process.pid), signal.SIGKILL)
                             process.wait()
+                        # Clean up containers left behind by the killed test.
+                        click.echo(_("Cleaning up: running molecule destroy for {scenario}", scenario=scenario))
+                        destroy_cmd = ["molecule", "destroy"]
+                        if scenario != "default":
+                            destroy_cmd.extend(["-s", scenario])
+                        with contextlib.suppress(subprocess.SubprocessError, OSError):
+                            subprocess.run(  # nosec B603, B607
+                                destroy_cmd,
+                                cwd=str(cwd),
+                                env=env,
+                                check=False,
+                                capture_output=True,
+                                timeout=120,
+                            )
                         sys.exit(1)
                     time.sleep(1)
             except KeyboardInterrupt:
                 with contextlib.suppress(ProcessLookupError):
                     os.killpg(os.getpgid(process.pid), signal.SIGTERM)
                 process.wait()
+                # Clean up containers left behind by the interrupted test.
+                click.echo(_("Cleaning up: running molecule destroy for {scenario}", scenario=scenario))
+                destroy_cmd = ["molecule", "destroy"]
+                if scenario != "default":
+                    destroy_cmd.extend(["-s", scenario])
+                with contextlib.suppress(subprocess.SubprocessError, OSError):
+                    subprocess.run(  # nosec B603, B607
+                        destroy_cmd,
+                        cwd=str(cwd),
+                        env=env,
+                        check=False,
+                        capture_output=True,
+                        timeout=120,
+                    )
                 sys.exit(1)
 
             rc = process.returncode
 
             if rc != 0:
                 click.echo(_("FAILED: {pair} exited with code {code}", pair=pair, code=rc))
+                # Run molecule destroy to clean up containers left behind by the
+                # failed test. Without this, containers stay running and accumulate
+                # on the runner, consuming disk/memory and degrading CI performance.
+                click.echo(_("Cleaning up: running molecule destroy for {scenario}", scenario=scenario))
+                destroy_cmd = ["molecule", "destroy"]
+                if scenario != "default":
+                    destroy_cmd.extend(["-s", scenario])
+                with contextlib.suppress(subprocess.SubprocessError, OSError):
+                    subprocess.run(  # nosec B603, B607
+                        destroy_cmd,
+                        cwd=str(cwd),
+                        env=env,
+                        check=False,
+                        capture_output=True,
+                        timeout=120,
+                    )
                 sys.exit(rc)
 
             click.echo(_("PASSED: {pair}", pair=pair))

src/devx/tokens.py

@@ -0,0 +1,76 @@
+"""Token resolution helpers for devx tools.
+
+Centralizes Gitea/Vikunja token discovery with role-based environment
+variable names and backwards compatibility with the legacy
+``CI_GITEA_TOKEN`` / ``REVIEW_GITEA_TOKEN`` naming convention.
+
+Roles:
+- ``CI_GITEA_API_TOKEN``: CI workflows (read actions, post status, merge, etc.)
+- ``REVIEWER_GITEA_API_TOKEN``: PR approval reviews (must be a different user
+  from the PR author for Gitea to accept the review as an approval)
+- ``DEVELOPER_GITEA_API_TOKEN``: local development tools (create-task,
+  create-pr, setup, etc.)
+
+Fallbacks:
+- New role names are checked first.
+- Legacy names (``CI_GITEA_TOKEN``, ``REVIEW_GITEA_TOKEN``) are accepted for
+  backwards compatibility.
+- If no role-specific token is set, the generic CI tokens are tried last.
+"""
+
+from __future__ import annotations
+
+import os
+
+import click
+
+from devx.i18n import _
+
+# Token environment variable names, in lookup priority order.
+CI_TOKEN_NAMES = ["CI_GITEA_API_TOKEN", "CI_GITEA_TOKEN"]
+REVIEWER_TOKEN_NAMES = [
+    "REVIEWER_GITEA_API_TOKEN",
+    # Legacy name used before role-based tokens.
+    "REVIEW_GITEA_TOKEN",
+    *CI_TOKEN_NAMES,
+]
+DEVELOPER_TOKEN_NAMES = ["DEVELOPER_GITEA_API_TOKEN", *CI_TOKEN_NAMES]
+
+VIKUNJA_TOKEN_NAMES = ["VIKUNJA_TOKEN"]
+
+
+def get_token(*names: str) -> str:
+    """Return the first non-empty value from the listed environment variables.
+
+    Raises a ``click.ClickException`` if none of the listed variables are set.
+    """
+    for name in names:
+        token = os.environ.get(name, "").strip()
+        if token:
+            return token
+    raise click.ClickException(
+        _(
+            "Gitea API token not set. Set one of: {names}",
+            names=", ".join(names),
+        )
+    )
+
+
+def get_ci_token() -> str:
+    """Resolve the CI Gitea API token."""
+    return get_token(*CI_TOKEN_NAMES)
+
+
+def get_reviewer_token() -> str:
+    """Resolve the reviewer Gitea API token used for PR approvals."""
+    return get_token(*REVIEWER_TOKEN_NAMES)
+
+
+def get_developer_token() -> str:
+    """Resolve the developer Gitea API token used for local tooling."""
+    return get_token(*DEVELOPER_TOKEN_NAMES)
+
+
+def get_vikunja_token() -> str:
+    """Resolve the Vikunja API token."""
+    return get_token(*VIKUNJA_TOKEN_NAMES)

src/devx/tools/_shared.py

@@ -8,6 +8,8 @@ import subprocess  # nosec B404
 
 import click
 
+from devx.tokens import get_developer_token
+
 
 def arch_string() -> str:
     """Return the architecture string used by release assets.
@@ -45,8 +47,9 @@ def detect_pr_number() -> int | None:
     if branch == "HEAD":
         return None
 
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
+    try:
+        token = get_developer_token()
+    except click.ClickException:
         return None
 
     owner = os.environ.get("DEVX_REPO_OWNER", "")

src/devx/tools/ansible_checks/__init__.py

@@ -0,0 +1,34 @@
+"""Ansible check tools — composable validators for Ansible playbooks and roles.
+
+Each check module exports a ``check_*`` function that returns a list of
+violation strings. The shared utilities in :mod:`devx.tools.ansible_checks._shared`
+handle file discovery, YAML parsing, and violation reporting.
+
+The old entry points (``devx.tools.check_ansible_*``, ``devx.tools.check_jinja_expr``)
+remain as thin wrappers for backward compatibility with existing Makefile
+targets and workflow references.
+"""
+
+from devx.tools.ansible_checks._shared import (
+    DEFAULT_ANSIBLE_DIRS,
+    AnsibleFileFinder,
+    AnsibleYAMLParser,
+    ViolationReporter,
+)
+from devx.tools.ansible_checks.jinja_expr import check_jinja_expr
+from devx.tools.ansible_checks.no_log import check_no_log
+from devx.tools.ansible_checks.no_state_absent_on_db import check_no_state_absent_on_db
+from devx.tools.ansible_checks.patterns import check_patterns
+from devx.tools.ansible_checks.set_fact_to_json import check_set_fact_to_json
+
+__all__ = [
+    "DEFAULT_ANSIBLE_DIRS",
+    "AnsibleFileFinder",
+    "AnsibleYAMLParser",
+    "ViolationReporter",
+    "check_jinja_expr",
+    "check_no_log",
+    "check_no_state_absent_on_db",
+    "check_patterns",
+    "check_set_fact_to_json",
+]

src/devx/tools/ansible_checks/_shared.py

@@ -0,0 +1,178 @@
+"""Shared utilities for Ansible check tools.
+
+Provides composable helpers for file discovery, YAML parsing, and
+violation reporting used by the modules in :mod:`devx.tools.ansible_checks`.
+
+Composition over inheritance: each check module picks the helpers it
+needs. Tools that don't parse YAML (e.g. line-based scanners) can skip
+:class:`AnsibleYAMLParser` entirely.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Final
+
+import click
+import yaml
+
+from devx.i18n import _
+
+#: Default Ansible directories scanned by checks that accept ``--ansible-dir``.
+#: Immutable tuple (not a list) to avoid module-level mutable globals.
+DEFAULT_ANSIBLE_DIRS: Final[tuple[str, ...]] = ("ansible/roles", "ansible/playbooks")
+
+
+class AnsibleFileFinder:
+    """File discovery helpers for Ansible YAML files."""
+
+    @staticmethod
+    def find_task_files(base: Path, skip_molecule: bool = True) -> list[Path]:
+        """Find all YAML files under *base*, recursively.
+
+        If *base* is a single YAML file, returns ``[base]``. If *base* is
+        not a file or directory, returns ``[]``. When *skip_molecule* is
+        True, files with ``molecule`` in their path parts are excluded.
+        """
+        if base.is_file() and base.suffix in (".yml", ".yaml"):
+            return [base]
+        if not base.is_dir():
+            return []
+        files: list[Path] = []
+        for f in sorted(base.rglob("*.yml")) + sorted(base.rglob("*.yaml")):
+            if skip_molecule and "molecule" in f.parts:
+                continue
+            files.append(f)
+        return files
+
+    @staticmethod
+    def find_yaml_files(base: Path, skip_molecule: bool = True) -> list[Path]:
+        """Find YAML files under *base* using ``glob`` (non-recursive rglob).
+
+        Unlike :meth:`find_task_files`, this uses ``base.glob("**/*.yml")``
+        and does not check the suffix when *base* is a single file (any
+        file is accepted). Used by the Jinja expression checker which
+        scans all YAML files including defaults/handlers.
+        """
+        if base.is_file():
+            return [base]
+        files: list[Path] = []
+        for pattern in ("**/*.yml", "**/*.yaml"):
+            files.extend(base.glob(pattern))
+        if skip_molecule:
+            return [f for f in files if "molecule" not in f.parts]
+        return files
+
+    @staticmethod
+    def find_task_and_playbook_files(base: Path, skip_molecule: bool = True) -> list[Path]:
+        """Find task files (``tasks/*.yml``) and playbook files (``playbooks/*.yml``).
+
+        Used by the no_log checker which scans role task files and
+        top-level playbook files. When *skip_molecule* is True, molecule
+        scenario files are excluded.
+        """
+        task_files = list(base.rglob("tasks/*.yml")) + list(base.rglob("tasks/*.yaml"))
+        task_files += list(base.glob("playbooks/*.yml")) + list(base.glob("playbooks/*.yaml"))
+        if skip_molecule:
+            task_files = [f for f in task_files if "molecule" not in f.parts]
+        return sorted(task_files)
+
+
+class AnsibleYAMLParser:
+    """YAML parsing helpers for Ansible files."""
+
+    @staticmethod
+    def parse_file(content: str) -> list[dict]:
+        """Parse multi-document YAML from *content*.
+
+        Returns a list of non-None documents. On ``YAMLError`` or
+        ``OSError``, returns an empty list (the caller skips the file).
+        """
+        try:
+            docs = list(yaml.safe_load_all(content))
+        except (yaml.YAMLError, OSError):
+            return []
+        return [d for d in docs if d]
+
+    @staticmethod
+    def iter_tasks(doc: dict | list) -> Iterator[tuple[dict, int]]:
+        """Yield ``(task_dict, line_number)`` tuples from a YAML document.
+
+        Handles:
+        - Bare task lists (role tasks files): ``[task1, task2, ...]``
+        - Play dicts with ``hosts`` key: iterates ``tasks``,
+          ``pre_tasks``, ``post_tasks``, ``handlers`` sections
+        - Nested ``block`` tasks
+
+        The line number is the 1-based index within the task section
+        (not the file line number — callers use it for display only).
+        """
+        if isinstance(doc, list):
+            for i, item in enumerate(doc):
+                if isinstance(item, dict):
+                    if any(k in item for k in ("tasks", "pre_tasks", "post_tasks", "handlers")):
+                        yield from AnsibleYAMLParser._iter_play_sections(item)
+                    else:
+                        yield item, i + 1
+                        block = item.get("block")
+                        if isinstance(block, list):
+                            for j, bt in enumerate(block):
+                                if isinstance(bt, dict):
+                                    yield bt, i + j + 1
+        elif isinstance(doc, dict):
+            yield from AnsibleYAMLParser._iter_play_sections(doc)
+
+    @staticmethod
+    def _iter_play_sections(doc: dict) -> Iterator[tuple[dict, int]]:
+        """Yield tasks from play sections (tasks, pre_tasks, post_tasks, handlers)."""
+        for section_key in ("tasks", "pre_tasks", "post_tasks", "handlers"):
+            section = doc.get(section_key)
+            if isinstance(section, list):
+                for i, task in enumerate(section):
+                    if isinstance(task, dict):
+                        yield task, i + 1
+                        block = task.get("block")
+                        if isinstance(block, list):
+                            for j, bt in enumerate(block):
+                                if isinstance(bt, dict):
+                                    yield bt, i + j + 1
+
+
+class ViolationReporter:
+    """Standardized violation formatting and reporting."""
+
+    @staticmethod
+    def format_violation(
+        filepath: Path,
+        repo_root: Path,
+        line_num: int | None,
+        message: str,
+    ) -> str:
+        """Format a violation as ``"{relative_path}:{line_num} — message"``.
+
+        Falls back to the full path if *filepath* is not relative to
+        *repo_root*. When *line_num* is None, omits the line number.
+        """
+        try:
+            display_path = filepath.relative_to(repo_root)
+        except ValueError:
+            display_path = filepath
+        if line_num is not None:
+            return f"{display_path}:{line_num} — {message}"
+        return f"{display_path} — {message}"
+
+    @staticmethod
+    def report(violations: list[str], tool_name: str) -> None:
+        """Print violations and exit with the appropriate code.
+
+        Prints ``[{tool_name}] FAIL`` or ``[{tool_name}] OK`` and exits
+        1 if violations are non-empty, 0 otherwise.
+        """
+        if violations:
+            click.echo(_("[{tool}] FAIL: {count} violation(s) found.", tool=tool_name, count=len(violations)))
+            for v in violations:
+                click.echo(f"  - {v}")
+            sys.exit(1)
+        click.echo(_("[{tool}] OK: no violations found.", tool=tool_name))

src/devx/tools/ansible_checks/jinja_expr.py

@@ -0,0 +1,226 @@
+"""Validate Jinja2 expressions in Ansible files by rendering them.
+
+Extracted from :mod:`devx.tools.check_jinja_expr` as part of the
+Ansible check tool consolidation. The old module remains as a thin
+wrapper for backward compatibility.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from jinja2 import Environment
+from jinja2.exceptions import TemplateSyntaxError, UndefinedError
+
+from devx.tools.ansible_checks._shared import AnsibleFileFinder, ViolationReporter
+
+REPO_ROOT = Path.cwd()
+
+MOCK_CONTEXT: dict[str, object] = {
+    "now": lambda fmt=None: (
+        "2026-01-01T00:00:00+00:00"
+        if fmt
+        else type(
+            "Now",
+            (),
+            {
+                "timestamp": lambda self: 1735689600.0,
+                "strftime": lambda self, fmt: "2026-01-01T00:00:00+00:00",
+            },
+        )()
+    ),
+    "ansible_date_time": {
+        "iso8601": "2026-01-01T00:00:00+00:00",
+        "epoch": "1735689600",
+    },
+    "ansible_facts": {
+        "service_mgr": "systemd",
+        "architecture": "x86_64",
+        "distribution_release": "noble",
+        "virtualization_type": "none",
+        "interfaces": ["eth0", "lo"],
+        "hostname": "test-host",
+    },
+    "ansible_host": "10.0.0.1",
+    "env": "staging",
+    "environment": "staging",
+    "customer_id": "test",
+    "zitadel_domain": "zitadel.test",
+    "_env_name": "staging",
+    "_observability_data_root": "/opt",
+    "skip_zitadel_stack": False,
+    "skip_htpasswd": False,
+    "skip_observability_stack": False,
+    "backup_enabled": True,
+    "app_filter": "",
+    "app_domain": "test.example.com",
+    "oidc_client_id": "test-client-id",
+    "oidc_client_secret": "test-secret",  # nosec B105 — mock value for Jinja rendering, not a real secret
+    "s3_backup_bucket": "test-bucket",
+    "s3_endpoint": "https://s3.test",
+    "s3_access_key": "test-key",
+    "s3_secret_key": "test-secret",  # nosec B105 — mock value for Jinja rendering, not a real secret
+}
+
+EXPR_PATTERN = re.compile(r"\{\{(.*?)\}\}", re.DOTALL)
+
+
+def _default_ansible_dirs() -> list[Path]:
+    """Return the default directories to scan for Ansible files."""
+    return [
+        REPO_ROOT / "ansible" / "playbooks",
+        REPO_ROOT / "ansible" / "roles",
+    ]
+
+
+def _find_yaml_files(path: Path) -> list[Path]:
+    """Find Ansible YAML files (tasks, playbooks, handlers) in a path."""
+    return AnsibleFileFinder.find_yaml_files(path, skip_molecule=True)
+
+
+def _extract_expressions(content: str) -> list[str]:
+    """Extract Jinja expressions from file content."""
+    expressions = []
+    for match in EXPR_PATTERN.finditer(content):
+        raw = match.group(1)
+        if "\n" in raw:
+            continue
+        expr = raw.strip()
+        if not expr or expr.startswith("%") or len(expr) <= 1:
+            continue
+        if expr.startswith(".") or "println" in expr:
+            continue
+        if ".State." in expr or ".NetworkSettings." in expr:
+            continue
+        if expr.count("(") != expr.count(")"):
+            continue
+        if expr.count("{") != expr.count("}"):
+            continue
+        if expr.count("[") != expr.count("]"):
+            continue
+        expressions.append(expr)
+    return expressions
+
+
+def _render_expression(expr: str) -> tuple[bool, str]:
+    """Try to render a Jinja expression. Returns (success, error_msg)."""
+    try:
+        env = Environment(autoescape=False, keep_trailing_newline=True)  # nosec B701 — Ansible Jinja, not web-facing  # noqa: S701
+
+        def _strftime(string_format: str, second: float | None = None, utc: bool = False) -> str:
+            if isinstance(string_format, (int, float)) and isinstance(second, str) and "%" in second:
+                raise ValueError(  # noqa: TRY301
+                    "Invalid value for epoch value — strftime filter arguments "
+                    "are reversed. The format string must be the piped value: "
+                    "'%format%' | strftime(epoch), not epoch | strftime('%format%')"
+                )
+            return str(string_format)
+
+        env.filters["strftime"] = _strftime
+        env.filters["b64decode"] = lambda x: x
+        env.filters["b64encode"] = lambda x: x
+        env.filters["regex_replace"] = lambda x, pattern, replacement="": x
+        env.filters["int"] = lambda x, default=0: (
+            int(x) if isinstance(x, (int, float, str)) and str(x).lstrip("-").isdigit() else default
+        )
+        env.filters["bool"] = bool
+        env.filters["basename"] = lambda x: str(x).rsplit("/", 1)[-1]
+        env.filters["dirname"] = lambda x: str(x).rsplit("/", 1)[0] if "/" in str(x) else "."
+        env.filters["combine"] = lambda *args, **kwargs: args[0]
+        env.filters["from_json"] = lambda x: x
+        env.filters["to_json"] = lambda x: x
+        env.filters["ternary"] = lambda x, true_val, false_val=None: true_val if x else false_val
+        env.filters["dict2items"] = lambda x: [
+            {"key": k, "value": v} for k, v in (x.items() if isinstance(x, dict) else [])
+        ]
+        env.filters["map"] = lambda x, attribute=None: x
+        env.filters["default"] = lambda x, default_value="", boolean=False: x if x else default_value
+        env.filters["from_yaml"] = lambda x: x
+        env.filters["difference"] = lambda x, y: x
+        env.filters["join"] = lambda x, sep="": sep.join(str(i) for i in (x if isinstance(x, list) else [x]))
+        env.filters["list"] = lambda x: list(x) if isinstance(x, (list, tuple)) else [x]
+        env.filters["length"] = lambda x: len(x) if hasattr(x, "__len__") else 0
+        env.filters["items"] = lambda x: list(x.items()) if isinstance(x, dict) else []
+        env.filters["first"] = lambda x: x[0] if isinstance(x, (list, str)) and x else x
+        env.filters["last"] = lambda x: x[-1] if isinstance(x, (list, str)) and x else x
+        env.filters["upper"] = lambda x: str(x).upper()
+        env.filters["lower"] = lambda x: str(x).lower()
+        env.filters["replace"] = lambda x, old, new: str(x).replace(old, new)
+        env.filters["split"] = lambda x, sep=None: str(x).split(sep) if sep else str(x).split()
+        env.filters["trim"] = lambda x: str(x).strip()
+        env.filters["sort"] = lambda x: sorted(x) if isinstance(x, list) else x
+        env.filters["unique"] = lambda x: list(set(x)) if isinstance(x, list) else x
+        env.filters["count"] = lambda x: len(x) if hasattr(x, "__len__") else 0
+        env.filters["float"] = lambda x, default=0.0: (
+            float(x) if isinstance(x, (int, float, str)) and str(x).replace(".", "").lstrip("-").isdigit() else default
+        )
+        env.filters["string"] = str
+        env.filters["indent"] = lambda x, width=4: str(x)
+        env.filters["to_nice_json"] = str
+        env.filters["to_nice_yaml"] = str
+        env.filters["from_yaml_all"] = lambda x: x
+        env.filters["groupby"] = lambda x: x
+        env.filters["dictsort"] = lambda x: list(x.items()) if isinstance(x, dict) else []
+        env.filters["max"] = lambda x: max(x) if isinstance(x, list) and x else x
+        env.filters["min"] = lambda x: min(x) if isinstance(x, list) and x else x
+        env.filters["reverse"] = lambda x: list(reversed(x)) if isinstance(x, list) else x
+        env.filters["flatten"] = lambda x: x
+        env.filters["product"] = lambda x: x
+        env.filters["zip"] = lambda x: x
+        env.filters["subelements"] = lambda x: x
+        env.filters["json_query"] = lambda x: x
+        env.filters["type_debug"] = lambda x: type(x).__name__
+        env.globals["lookup"] = lambda *args, **kwargs: ""
+        env.globals["query"] = lambda *args, **kwargs: []
+
+        template = env.from_string("{{ " + expr + " }}")
+        result = template.render(**MOCK_CONTEXT)
+    except TemplateSyntaxError as e:
+        return False, f"Syntax error: {e.message}"
+    except UndefinedError as e:
+        return True, f"Skipped (undefined: {e})"
+    except Exception as e:
+        error_msg = str(e)
+        if "Invalid value for epoch" in error_msg:
+            return False, f"strftime filter argument error: {error_msg}"
+        return True, f"Skipped ({type(e).__name__}: {error_msg})"
+    else:
+        return True, result
+
+
+def _check_file(filepath: Path, repo_root: Path) -> list[str]:
+    """Check all Jinja expressions in a file. Returns list of violations."""
+    violations = []
+    content = filepath.read_text()
+    expressions = _extract_expressions(content)
+    for expr in expressions:
+        success, msg = _render_expression(expr)
+        if not success:
+            display_path = ViolationReporter.format_violation(filepath, repo_root, None, "")
+            display_path = display_path.removesuffix(" — ")
+            violations.append(f"{display_path}: `{{{{ {expr} }}}}` — {msg}")
+    return violations
+
+
+def check_jinja_expr(path: Path | None, ansible_dirs: list[Path] | None = None) -> list[str]:
+    """Validate Jinja2 expressions in Ansible files.
+
+    Args:
+        path: Specific file or directory to check. If None, *ansible_dirs*
+            is used.
+        ansible_dirs: Directories to scan when *path* is None.
+
+    Returns:
+        List of violation messages (empty if all renderable expressions pass).
+    """
+    if path:
+        files = _find_yaml_files(path)
+    else:
+        files: list[Path] = []
+        for d in ansible_dirs or _default_ansible_dirs():
+            files.extend(_find_yaml_files(d))
+    all_violations: list[str] = []
+    for f in files:
+        all_violations.extend(_check_file(f, REPO_ROOT))
+    return all_violations

src/devx/tools/ansible_checks/no_log.py

@@ -0,0 +1,128 @@
+"""Check Ansible tasks for missing no_log on secret-handling tasks.
+
+Extracted from :mod:`devx.tools.check_ansible_no_log` as part of the
+Ansible check tool consolidation. The old module remains as a thin
+wrapper for backward compatibility.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from devx.tools.ansible_checks._shared import AnsibleFileFinder, AnsibleYAMLParser
+
+# Patterns that indicate a task is handling secrets.
+SECRET_PATTERNS = [
+    re.compile(r"\{\{[^}]*_secrets\.", re.IGNORECASE),
+    re.compile(r"\{\{[^}]*password", re.IGNORECASE),
+    re.compile(r"\{\{[^}]*_secret\b", re.IGNORECASE),
+    re.compile(r"\{\{[^}]*api_key", re.IGNORECASE),
+    re.compile(r"\{\{[^}]*(?:vault_token|auth_token|access_token|bot_token)", re.IGNORECASE),
+]
+
+TASK_VALUE_KEYS = {
+    "shell",
+    "command",
+    "ansible.builtin.shell",
+    "ansible.builtin.command",
+    "ansible.builtin.template",
+    "ansible.builtin.copy",
+    "ansible.builtin.debug",
+    "template",
+    "copy",
+    "debug",
+    "cmd",
+    "msg",
+    "content",
+}
+
+NON_VALUE_KEYS = {
+    "name",
+    "when",
+    "loop",
+    "loop_control",
+    "changed_when",
+    "failed_when",
+    "no_log",
+    "register",
+    "tags",
+    "vars",
+    "become",
+    "become_user",
+    "delegate_to",
+    "run_once",
+    "environment",
+    "with_items",
+    "with_dict",
+    "with_list",
+}
+
+
+def _contains_secret(value: object) -> bool:
+    """Recursively check if a value contains secret-like variable references."""
+    if isinstance(value, str):
+        return any(p.search(value) for p in SECRET_PATTERNS)
+    if isinstance(value, dict):
+        return any(_contains_secret(v) for v in value.values())
+    if isinstance(value, list):
+        return any(_contains_secret(item) for item in value)
+    return False
+
+
+def _has_no_log(task: dict) -> bool:
+    """Check if a task has no_log set to a non-False value."""
+    no_log = task.get("no_log", False)
+    return no_log is not False and no_log is not None
+
+
+def _check_task(task: dict, file_path: Path, task_num: int) -> list[str]:
+    """Check a single task for missing no_log on secret values."""
+    violations: list[str] = []
+    if _has_no_log(task):
+        return violations
+    has_secrets = False
+    for key, value in task.items():
+        if key in NON_VALUE_KEYS:
+            continue
+        if _contains_secret(value):
+            has_secrets = True
+            break
+    if has_secrets:
+        task_name = task.get("name", "<unnamed>")
+        violations.append(
+            f"{file_path}:{task_num}: Task '{task_name}' references secrets "
+            f"but has no no_log. Add `no_log: true` or "
+            f'`no_log: "{{{{ not (debug_mode | default(false) | bool) }}}}"` '
+            f"to prevent credential leakage in Ansible output."
+        )
+    return violations
+
+
+def check_no_log(path: Path, ansible_dirs: list[Path] | None = None) -> list[str]:
+    """Check all Ansible task files for missing no_log on secret-handling tasks.
+
+    Args:
+        path: The base directory to scan (or a specific file).
+        ansible_dirs: Unused — kept for API symmetry with other checks.
+            The no_log checker scans *path* directly.
+
+    Returns:
+        List of violation messages (empty if all OK).
+    """
+    all_violations: list[str] = []
+    task_files = AnsibleFileFinder.find_task_and_playbook_files(path)
+    for task_file in task_files:
+        try:
+            content = task_file.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        docs = AnsibleYAMLParser.parse_file(content)
+        for doc in docs:
+            for task, task_num in AnsibleYAMLParser.iter_tasks(doc):
+                all_violations.extend(_check_task(task, task_file, task_num))
+    return all_violations
+
+
+# Backward-compat alias for the old public function name.
+check_directory = check_no_log

src/devx/tools/ansible_checks/no_state_absent_on_db.py

@@ -0,0 +1,100 @@
+"""Check Ansible tasks for ``state: absent`` on database data directories.
+
+Extracted from :mod:`devx.tools.check_ansible_no_state_absent_on_db` as
+part of the Ansible check tool consolidation. The old module remains as
+a thin wrapper for backward compatibility.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from devx.tools.ansible_checks._shared import AnsibleFileFinder, ViolationReporter
+
+REPO_ROOT = Path.cwd()
+
+DB_PATH_PATTERNS = (
+    re.compile(r"postgres/zitadel-db", re.IGNORECASE),
+    re.compile(r"postgres/\w+-db", re.IGNORECASE),
+    re.compile(r"/var/lib/postgresql/data", re.IGNORECASE),
+    re.compile(r"/var/lib/postgresql/data/\w+-db", re.IGNORECASE),
+)
+
+DESTRUCTIVE_PATTERNS = (
+    re.compile(r"state:\s*absent", re.IGNORECASE),
+    re.compile(r"rm\s+-rf.*\bdb\b", re.IGNORECASE),
+)
+
+ALLOWED_CONTEXT_KEYWORDS = (
+    "upgrade-postgres",
+    "PG_VERSION",
+    "pg_version",
+)
+
+ALLOW_MARKER = "lint:allow-state-absent"
+
+
+def _find_task_files(base: Path) -> list[Path]:
+    """Find all YAML task files under a base directory, skipping molecule."""
+    return AnsibleFileFinder.find_task_files(base, skip_molecule=True)
+
+
+def _check_file(filepath: Path, repo_root: Path) -> list[str]:
+    """Check a YAML file for state: absent on DB data directory paths."""
+    try:
+        content = filepath.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return []
+    if not any(p.search(content) for p in DB_PATH_PATTERNS):
+        return []
+    display_path = ViolationReporter.format_violation(filepath, repo_root, None, "")
+    display_path = display_path.removesuffix(" — ")
+    violations: list[str] = []
+    lines = content.splitlines()
+    for i, line in enumerate(lines):
+        for db_pattern in DB_PATH_PATTERNS:
+            if not db_pattern.search(line):
+                continue
+            context_start = max(0, i - 5)
+            context_end = min(len(lines), i + 6)
+            context = "\n".join(lines[context_start:context_end])
+            if any(kw in context for kw in ALLOWED_CONTEXT_KEYWORDS):
+                continue
+            if ALLOW_MARKER in context:
+                continue
+            for dp in DESTRUCTIVE_PATTERNS:
+                if dp.search(context):
+                    violations.append(
+                        f"{display_path}:{i + 1} — destructive operation "
+                        f"({dp.pattern!r}) near DB data directory path "
+                        f"({db_pattern.pattern!r}). "
+                        f"Database directories must never be wiped automatically (ADR-0028). "
+                        f"If this is legitimate (e.g. PG upgrade), add "
+                        f"#{ALLOW_MARKER} to the task."
+                    )
+                    break
+    return violations
+
+
+def check_no_state_absent_on_db(path: Path | None, ansible_dirs: list[Path] | None = None) -> list[str]:
+    """Check that no Ansible task uses state: absent on a DB data directory.
+
+    Args:
+        path: Specific file or directory to check. If None, *ansible_dirs*
+            is used.
+        ansible_dirs: Directories to scan when *path* is None.
+
+    Returns:
+        List of violation messages (empty if clean).
+    """
+    if path:
+        files = _find_task_files(path)
+    else:
+        files: list[Path] = []
+        for d in ansible_dirs or []:
+            files.extend(_find_task_files(d))
+    all_violations: list[str] = []
+    for f in files:
+        all_violations.extend(_check_file(f, REPO_ROOT))
+    return all_violations

src/devx/tools/ansible_checks/patterns.py

@@ -0,0 +1,226 @@
+"""Check Ansible tasks for dangerous patterns that mask failures.
+
+Extracted from :mod:`devx.tools.check_ansible_patterns` as part of the
+Ansible check tool consolidation. The old module remains as a thin
+wrapper for backward compatibility.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from devx.tools.ansible_checks._shared import AnsibleFileFinder, AnsibleYAMLParser
+
+REPO_ROOT = Path.cwd()
+
+# Comment marker to explicitly allow a pattern on a specific task
+ALLOW_MARKER = "lint:allow-failure-masking"
+
+# Patterns that mask failures when used in shell/command tasks
+OR_TRUE_PATTERN = re.compile(r"\|\|\s*true\b", re.IGNORECASE)
+REDIRECT_DEVNULL_PATTERN = re.compile(r"2>/dev/null")
+
+# Module keys that accept shell/command strings
+SHELL_MODULE_KEYS = frozenset(
+    {
+        "shell",
+        "command",
+        "ansible.builtin.shell",
+        "ansible.builtin.command",
+        "cmd",
+        "ansible.builtin.raw",
+        "raw",
+    }
+)
+
+# Task keys whose values might contain shell commands
+COMMAND_VALUE_KEYS = frozenset(
+    {
+        "shell",
+        "command",
+        "ansible.builtin.shell",
+        "ansible.builtin.command",
+        "cmd",
+        "raw",
+        "ansible.builtin.raw",
+    }
+)
+
+LEGITIMATE_COMMAND_PREFIXES = (
+    "docker rm",
+    "docker stop",
+    "docker rmi",
+    "docker network rm",
+    "docker volume rm",
+    "pkill",
+    "kill",
+    "journalctl --vacuum",
+    "apt-get clean",
+    "apt-get autoremove",
+    "docker image prune",
+    "docker container prune",
+    "docker volume prune",
+    "docker builder prune",
+    "find / -name",
+    "chmod",
+    "rm -f",
+    "docker network connect",
+    "curl.*api/v2/admin/tsdb/snapshot",
+)
+
+LEGITIMATE_TASK_NAME_KEYWORDS = (
+    "remove",
+    "cleanup",
+    "clean up",
+    "prune",
+    "purge",
+    "disconnect",
+    "stop",
+    "kill",
+    "strip suid",
+    "suid",
+    "vacuum",
+    "ensure.*absent",
+    "may not exist",
+    "if exists",
+    "optional",
+    "best effort",
+    "no-op",
+    "noop",
+    "idempotent",
+    "sync",
+)
+
+CRITICAL_TASK_KEYWORDS = (
+    "password",
+    "secret",
+    "provision",
+    "oidc",
+)
+
+LEGITIMATE_FAILED_WHEN_KEYWORDS = (
+    "stop",
+    "start",
+    "check",
+    "wait",
+    "migrate",
+    "restart",
+    "rebuild",
+    "restore",
+    "remove",
+    "cleanup",
+    "sync",
+    "download",
+    "extract",
+    "verify",
+)
+
+
+def _is_legitimate_or_true(command_str: str, task_name: str) -> bool:
+    """Check if a || true in a command is in a legitimate context."""
+    name_lower = task_name.lower()
+    if any(re.search(kw, name_lower) for kw in LEGITIMATE_TASK_NAME_KEYWORDS):
+        return True
+    cmd_lower = command_str.lower()
+    return any(re.search(prefix, cmd_lower) for prefix in LEGITIMATE_COMMAND_PREFIXES)
+
+
+def _is_legitimate_devnull(command_str: str, task_name: str) -> bool:
+    """Check if a 2>/dev/null in a command is in a legitimate context."""
+    return _is_legitimate_or_true(command_str, task_name)
+
+
+def _check_task(task: dict, filepath: Path, task_num: int, repo_root: Path) -> list[str]:
+    """Check a single task for dangerous failure-masking patterns."""
+    violations: list[str] = []
+    try:
+        display_path = filepath.relative_to(repo_root)
+    except ValueError:
+        display_path = filepath
+    task_name = task.get("name", "<unnamed>")
+    if ALLOW_MARKER in task_name:
+        return violations
+    for key in COMMAND_VALUE_KEYS:
+        value = task.get(key)
+        if value is None:
+            continue
+        value_str = str(value)
+        if OR_TRUE_PATTERN.search(value_str) and not _is_legitimate_or_true(value_str, task_name):
+            violations.append(
+                f"{display_path}:{task_num} — task '{task_name}' uses "
+                f"'|| true' in {key} which may mask real failures. "
+                f"If this is a cleanup/idempotency operation, rename the "
+                f"task to include 'remove'/'cleanup'/'prune' or add "
+                f"#{ALLOW_MARKER} to the task."
+            )
+    failed_when = task.get("failed_when")
+    if failed_when is False:
+        name_lower = task_name.lower()
+        is_legitimate = any(kw in name_lower for kw in LEGITIMATE_FAILED_WHEN_KEYWORDS)
+        if not is_legitimate:
+            for kw in CRITICAL_TASK_KEYWORDS:
+                if kw in name_lower:
+                    violations.append(
+                        f"{display_path}:{task_num} — critical task '{task_name}' "
+                        f"has failed_when: false, which masks failures on "
+                        f"a {kw}-related operation. Remove failed_when: false "
+                        f"or add #{ALLOW_MARKER} if masking is intentional."
+                    )
+                    break
+    return violations
+
+
+def _check_file(filepath: Path, repo_root: Path) -> list[str]:
+    """Check a YAML file for dangerous failure-masking patterns."""
+    try:
+        content = filepath.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return []
+    if not (
+        OR_TRUE_PATTERN.search(content) or "failed_when: false" in content or REDIRECT_DEVNULL_PATTERN.search(content)
+    ):
+        return []
+    has_allow_marker = ALLOW_MARKER in content
+    docs = AnsibleYAMLParser.parse_file(content)
+    violations: list[str] = []
+    for doc in docs:
+        for task, task_num in AnsibleYAMLParser.iter_tasks(doc):
+            violations.extend(_check_task(task, filepath, task_num, repo_root))
+    if has_allow_marker:
+        violations = []
+    return violations
+
+
+def _check_tasks(doc: dict, filepath: Path, errors: list[str], repo_root: Path) -> None:
+    """Check top-level tasks and nested task sections in a playbook doc."""
+    for task, task_num in AnsibleYAMLParser._iter_play_sections(doc):
+        errors.extend(_check_task(task, filepath, task_num, repo_root))
+
+
+def _find_task_files(base: Path) -> list[Path]:
+    """Find all YAML task files under a base directory, skipping molecule."""
+    return AnsibleFileFinder.find_task_files(base, skip_molecule=True)
+
+
+def check_patterns(path: Path | None, ansible_dirs: list[Path] | None = None) -> list[str]:
+    """Check Ansible tasks for dangerous failure-masking patterns.
+
+    Args:
+        path: Specific file or directory to check. If None, *ansible_dirs*
+            is used.
+        ansible_dirs: Directories to scan when *path* is None.
+
+    Returns:
+        List of violation messages (empty if clean).
+    """
+    if path:
+        files = _find_task_files(path)
+    else:
+        files: list[Path] = []
+        for d in ansible_dirs or []:
+            files.extend(_find_task_files(d))
+    all_violations: list[str] = []
+    for f in files:
+        all_violations.extend(_check_file(f, REPO_ROOT))
+    return all_violations

src/devx/tools/ansible_checks/set_fact_to_json.py

@@ -0,0 +1,134 @@
+"""Check that Ansible ``set_fact`` tasks don't misuse ``| to_json``.
+
+Extracted from :mod:`devx.tools.check_ansible_set_fact_to_json` as part
+of the Ansible check tool consolidation. The old module remains as a
+thin wrapper for backward compatibility.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from devx.tools.ansible_checks._shared import AnsibleFileFinder, ViolationReporter
+
+REPO_ROOT = Path.cwd()
+
+TO_JSON_FILTERS = ("| to_json", "| to_nice_json", "|to_json", "|to_nice_json")
+
+
+def _find_task_files(base: Path) -> list[Path]:
+    """Find all YAML task files under a base directory."""
+    return AnsibleFileFinder.find_task_files(base, skip_molecule=False)
+
+
+def _check_file(filepath: Path, repo_root: Path) -> list[str]:
+    """Check a single YAML file for set_fact + to_json misuse."""
+    errors: list[str] = []
+    try:
+        content = filepath.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return errors
+    try:
+        docs = list(yaml.safe_load_all(content))
+    except yaml.YAMLError as exc:
+        return [f"{filepath}: cannot parse YAML: {exc}"]
+    for doc in docs:
+        if isinstance(doc, list):
+            for item in doc:
+                if isinstance(item, dict):
+                    if any(k in item for k in ("tasks", "pre_tasks", "post_tasks", "handlers", "roles")):
+                        _check_tasks(item, filepath, errors, repo_root)
+                    else:
+                        _check_task(item, filepath, errors, repo_root)
+                        block = item.get("block")
+                        if isinstance(block, list):
+                            _check_task_list(block, filepath, errors, repo_root)
+        elif isinstance(doc, dict):
+            _check_tasks(doc, filepath, errors, repo_root)
+    return errors
+
+
+def _check_tasks(doc: dict, filepath: Path, errors: list[str], repo_root: Path) -> None:
+    """Check top-level tasks and nested task sections in a playbook doc."""
+    tasks = doc.get("tasks")
+    if isinstance(tasks, list):
+        _check_task_list(tasks, filepath, errors, repo_root)
+    for role_key in ("pre_tasks", "post_tasks", "handlers"):
+        section = doc.get(role_key)
+        if isinstance(section, list):
+            _check_task_list(section, filepath, errors, repo_root)
+    roles = doc.get("roles")
+    if isinstance(roles, list):
+        for role_entry in roles:
+            if isinstance(role_entry, dict):
+                role_tasks = role_entry.get("tasks")
+                if isinstance(role_tasks, list):
+                    _check_task_list(role_tasks, filepath, errors, repo_root)
+
+
+def _check_task_list(tasks: list, filepath: Path, errors: list[str], repo_root: Path) -> None:
+    """Check a list of task definitions for set_fact + to_json."""
+    for task in tasks:
+        if not isinstance(task, dict):
+            continue
+        _check_task(task, filepath, errors, repo_root)
+        block = task.get("block")
+        if isinstance(block, list):
+            _check_task_list(block, filepath, errors, repo_root)
+
+
+def _check_task(task: dict, filepath: Path, errors: list[str], repo_root: Path) -> None:
+    """Check a single task for set_fact + to_json misuse."""
+    has_set_fact = False
+    for key in task:
+        if key in {"set_fact", "ansible.builtin.set_fact"}:
+            has_set_fact = True
+            break
+    if not has_set_fact:
+        return
+    set_fact_body = task.get("set_fact") or task.get("ansible.builtin.set_fact")
+    if not isinstance(set_fact_body, dict):
+        return
+    task_name = task.get("name", "(unnamed)")
+    for fact_name, fact_value in set_fact_body.items():
+        if fact_name in ("cacheable",):
+            continue
+        value_str = str(fact_value)
+        for filter_pattern in TO_JSON_FILTERS:
+            if filter_pattern in value_str:
+                display_path = ViolationReporter.format_violation(filepath, repo_root, None, "")
+                display_path = display_path.removesuffix(" — ")
+                errors.append(
+                    f"{display_path}: task '{task_name}' "
+                    f"sets fact '{fact_name}' with '{filter_pattern.strip()}' "
+                    f"— this converts native Python types to JSON strings. "
+                    f"Remove the filter to preserve the native type, or use "
+                    f"'| from_json' in the consuming task if the string "
+                    f"representation is intentional."
+                )
+                break
+
+
+def check_set_fact_to_json(path: Path | None, ansible_dirs: list[Path] | None = None) -> list[str]:
+    """Check that set_fact tasks don't misuse to_json.
+
+    Args:
+        path: Specific file or directory to check. If None, *ansible_dirs*
+            is used.
+        ansible_dirs: Directories to scan when *path* is None.
+
+    Returns:
+        List of error messages (empty if all OK).
+    """
+    if path:
+        files = _find_task_files(path)
+    else:
+        files: list[Path] = []
+        for d in ansible_dirs or []:
+            files.extend(_find_task_files(d))
+    all_errors: list[str] = []
+    for f in files:
+        all_errors.extend(_check_file(f, REPO_ROOT))
+    return all_errors

src/devx/tools/build_image.py

@@ -34,8 +34,8 @@ The manifest file is a JSON list of dicts, each with:
     - ``context``: build context directory (optional, defaults to repo root)
     - ``tags``: list of tags (optional, defaults to ``["latest"]``)
 
-Registry authentication uses ``CI_GITEA_TOKEN`` and ``CI_GITEA_USERNAME``
-environment variables, matching the existing CI workflow patterns.
+Registry authentication uses ``CI_GITEA_API_TOKEN`` (or legacy ``CI_GITEA_TOKEN``)
+and ``CI_GITEA_USERNAME`` environment variables, matching the existing CI workflow patterns.
 """
 
 from __future__ import annotations
@@ -49,6 +49,7 @@ from pathlib import Path
 import click
 
 from devx.i18n import _
+from devx.tokens import get_developer_token
 
 
 @dataclass
@@ -173,9 +174,12 @@ def build_image(
         return True
 
     click.echo(f"Building {spec.name} ({len(full_tags)} tag(s))...")
+    # Use legacy builder (DOCKER_BUILDKIT=0) to avoid OCI-format manifest
+    # blobs (attestation, config) that the Gitea registry rejects with 403.
     result = subprocess.run(  # nosec B603
         cmd,
         check=False,
+        env={**os.environ, "DOCKER_BUILDKIT": "0"},
     )
     if result.returncode != 0:
         click.echo(_("Build failed for {name}", name=spec.name), err=True)
@@ -221,9 +225,12 @@ def push_image(
 
 def _get_registry_creds() -> tuple[str, str]:
     """Get registry credentials from environment variables."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        token = None
     username = os.environ.get("CI_GITEA_USERNAME", "")
-    return username, token
+    return username, token or ""
 
 
 @click.command()

src/devx/tools/check_alert_rules.py

@@ -0,0 +1,86 @@
+"""Validate Prometheus alert rules with promtool check rules.
+
+Renders an alert-rules Jinja2 template with test values and validates
+the output with ``promtool check rules``. Exits 0 if valid, non-zero
+otherwise. Skips (exits 0) if promtool is not on PATH.
+
+Usage::
+
+    python -m devx.tools.check_alert_rules \\
+        --template-path ansible/roles/observability/templates \\
+        --template-name alert-rules.yml.j2
+
+    # With extra template variables:
+    python -m devx.tools.check_alert_rules \\
+        --template-path ansible/roles/observability/templates \\
+        --template-name alert-rules.yml.j2 \\
+        --var grafana_base_url=https://grafana.test.example.com
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess  # nosec B404 — used to run promtool, a trusted binary
+import sys
+import tempfile
+from pathlib import Path
+
+import click
+
+from devx.utils.jinja import make_env, render_template
+
+
+@click.command()
+@click.option(
+    "--template-path",
+    type=click.Path(exists=True, path_type=Path),
+    required=True,
+    help="Path to the directory containing the Jinja2 template.",
+)
+@click.option(
+    "--template-name",
+    default="alert-rules.yml.j2",
+    help="Name of the Jinja2 template file to render.",
+)
+@click.option(
+    "--var",
+    "template_vars",
+    multiple=True,
+    help="Template variables in key=value format (can be repeated). "
+    "Example: --var grafana_base_url=https://grafana.example.com",
+)
+def main(template_path: Path, template_name: str, template_vars: tuple[str, ...]) -> None:
+    """Validate rendered alert rules with promtool."""
+    if not shutil.which("promtool"):
+        click.echo("promtool not found in PATH — skipping alert rules validation")
+        return
+
+    # Parse template variables
+    kwargs: dict[str, str] = {}
+    for v in template_vars:
+        if "=" in v:
+            key, value = v.split("=", 1)
+            kwargs[key] = value
+
+    env = make_env(str(template_path))
+    output = render_template(env, template_name, **kwargs)
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
+        f.write(output)
+        tmp_path = f.name
+
+    click.echo("[check-alert-rules] Validating rendered rules with promtool...")
+    result = subprocess.run(  # nosec
+        ["promtool", "check", "rules", tmp_path],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    click.echo(result.stdout, nl=False)
+    if result.returncode != 0:
+        click.echo(result.stderr, nl=False, err=True)
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_ansible_no_log.py

@@ -0,0 +1,71 @@
+"""Check Ansible tasks for missing no_log on secret-handling tasks.
+
+Thin wrapper around :mod:`devx.tools.ansible_checks.no_log` for
+backward compatibility. The check logic lives in the subpackage; this
+module preserves the CLI entry point and re-exports the internal
+helpers so existing tests and imports continue to work.
+
+Usage::
+
+    python -m devx.tools.check_ansible_no_log
+    python -m devx.tools.check_ansible_no_log --path ansible/roles/my_role
+    python -m devx.tools.check_ansible_no_log --ansible-dir ansible/roles
+
+Exit code 0 if all secret-handling tasks have no_log, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from devx.tools.ansible_checks.no_log import (
+    NON_VALUE_KEYS,  # noqa: F401
+    SECRET_PATTERNS,  # noqa: F401 — re-exported for backward compat
+    TASK_VALUE_KEYS,  # noqa: F401
+    _check_task,  # noqa: F401
+    _contains_secret,  # noqa: F401
+    _has_no_log,  # noqa: F401
+    check_directory,  # noqa: F401
+    check_no_log,  # noqa: F401
+)
+
+REPO_ROOT = Path.cwd()
+DEFAULT_ANSIBLE_DIR = REPO_ROOT / "ansible"
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific file or directory (default: ansible/).",
+)
+@click.option(
+    "--ansible-dir",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+    help="Override the default ansible directory (default: ansible/).",
+)
+def main(path: Path | None, ansible_dir: Path | None) -> None:
+    """Check that Ansible tasks handling secrets have no_log set."""
+    target = path or ansible_dir or DEFAULT_ANSIBLE_DIR
+    if not target.is_dir():
+        click.echo(f"Error: {target} is not a directory", err=True)
+        sys.exit(2)
+
+    violations = check_no_log(target)
+
+    if violations:
+        click.echo(f"Found {len(violations)} task(s) handling secrets without no_log:\n")
+        for v in violations:
+            click.echo(f"  {v}")
+        click.echo(f"\nTotal: {len(violations)} violation(s).")
+        sys.exit(1)
+
+    click.echo(f"[check-ansible-no-log] All secret-handling tasks have no_log. ({target})")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_ansible_no_state_absent_on_db.py

@@ -0,0 +1,72 @@
+"""Check Ansible tasks for ``state: absent`` on database data directories.
+
+Thin wrapper around
+:mod:`devx.tools.ansible_checks.no_state_absent_on_db` for backward
+compatibility. The check logic lives in the subpackage; this module
+preserves the CLI entry point and re-exports the internal helpers so
+existing tests and imports continue to work.
+
+Usage::
+
+    python -m devx.tools.check_ansible_no_state_absent_on_db
+    python -m devx.tools.check_ansible_no_state_absent_on_db --path ansible/roles/zitadel/tasks/main.yml
+
+Exit code 0 if no violations found, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from devx.tools.ansible_checks.no_state_absent_on_db import (
+    ALLOW_MARKER,  # noqa: F401 — re-exported for backward compat
+    ALLOWED_CONTEXT_KEYWORDS,  # noqa: F401
+    DB_PATH_PATTERNS,  # noqa: F401
+    DESTRUCTIVE_PATTERNS,  # noqa: F401
+    REPO_ROOT,
+    _check_file,  # noqa: F401
+    _find_task_files,  # noqa: F401
+    check_no_state_absent_on_db,  # noqa: F401
+)
+
+DEFAULT_ANSIBLE_DIRS: list[Path] = [
+    REPO_ROOT / "ansible" / "playbooks",
+    REPO_ROOT / "ansible" / "roles",
+]
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific file or directory (default: ansible/playbooks + ansible/roles).",
+)
+@click.option(
+    "--ansible-dir",
+    "ansible_dirs",
+    type=click.Path(exists=True, path_type=Path),
+    multiple=True,
+    default=None,
+    help="Override the default ansible directories (can be repeated). Defaults to ansible/playbooks and ansible/roles.",
+)
+def main(path: Path | None, ansible_dirs: tuple[Path, ...]) -> None:
+    """Check that no Ansible task uses state: absent on a DB data directory."""
+    dirs = list(ansible_dirs) if ansible_dirs else DEFAULT_ANSIBLE_DIRS
+    all_violations = check_no_state_absent_on_db(path) if path else check_no_state_absent_on_db(None, dirs)
+
+    if all_violations:
+        click.echo("[check-ansible-no-state-absent-on-db] FAIL: destructive operations on DB paths:")
+        for v in all_violations:
+            click.echo(f"  - {v}")
+        click.echo(f"\nTotal: {len(all_violations)} violation(s).")
+        click.echo("Database data directories must never be wiped automatically (ADR-0028).")
+        sys.exit(1)
+    else:
+        click.echo("[check-ansible-no-state-absent-on-db] OK: no destructive operations on DB paths.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_ansible_patterns.py

@@ -0,0 +1,79 @@
+"""Check Ansible tasks for dangerous patterns that mask failures.
+
+Thin wrapper around :mod:`devx.tools.ansible_checks.patterns` for
+backward compatibility. The check logic lives in the subpackage; this
+module preserves the CLI entry point and re-exports the internal
+helpers so existing tests and imports continue to work.
+
+Usage::
+
+    python -m devx.tools.check_ansible_patterns
+    python -m devx.tools.check_ansible_patterns --path ansible/roles/app_container/tasks/main.yml
+
+Exit code 0 if no violations found, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from devx.tools.ansible_checks.patterns import (
+    ALLOW_MARKER,  # noqa: F401 — re-exported for backward compat
+    COMMAND_VALUE_KEYS,  # noqa: F401
+    CRITICAL_TASK_KEYWORDS,  # noqa: F401
+    LEGITIMATE_COMMAND_PREFIXES,  # noqa: F401
+    LEGITIMATE_FAILED_WHEN_KEYWORDS,  # noqa: F401
+    LEGITIMATE_TASK_NAME_KEYWORDS,  # noqa: F401
+    OR_TRUE_PATTERN,  # noqa: F401
+    REDIRECT_DEVNULL_PATTERN,  # noqa: F401
+    REPO_ROOT,
+    SHELL_MODULE_KEYS,  # noqa: F401
+    _check_file,  # noqa: F401
+    _check_task,  # noqa: F401
+    _check_tasks,  # noqa: F401
+    _find_task_files,  # noqa: F401
+    _is_legitimate_devnull,  # noqa: F401
+    _is_legitimate_or_true,  # noqa: F401
+    check_patterns,  # noqa: F401
+)
+
+DEFAULT_ANSIBLE_DIRS: list[Path] = [
+    REPO_ROOT / "ansible" / "playbooks",
+    REPO_ROOT / "ansible" / "roles",
+]
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific file or directory (default: ansible/playbooks + ansible/roles).",
+)
+@click.option(
+    "--ansible-dir",
+    "ansible_dirs",
+    type=click.Path(exists=True, path_type=Path),
+    multiple=True,
+    default=None,
+    help="Override the default ansible directories (can be repeated). Defaults to ansible/playbooks and ansible/roles.",
+)
+def main(path: Path | None, ansible_dirs: tuple[Path, ...]) -> None:
+    """Check Ansible tasks for dangerous failure-masking patterns."""
+    dirs = list(ansible_dirs) if ansible_dirs else DEFAULT_ANSIBLE_DIRS
+    all_violations = check_patterns(path) if path else check_patterns(None, dirs)
+
+    if all_violations:
+        click.echo("[check-ansible-patterns] FAIL: dangerous failure-masking patterns found:")
+        for v in all_violations:
+            click.echo(f"  - {v}")
+        click.echo(f"\nTotal: {len(all_violations)} violation(s).")
+        sys.exit(1)
+    else:
+        click.echo("[check-ansible-patterns] OK: no dangerous failure-masking patterns.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_ansible_set_fact_to_json.py

@@ -0,0 +1,69 @@
+"""Check that Ansible ``set_fact`` tasks don't misuse ``| to_json``.
+
+Thin wrapper around :mod:`devx.tools.ansible_checks.set_fact_to_json`
+for backward compatibility. The check logic lives in the subpackage;
+this module preserves the CLI entry point and re-exports the internal
+helpers so existing tests and imports continue to work.
+
+Usage::
+
+    python -m devx.tools.check_ansible_set_fact_to_json
+    python -m devx.tools.check_ansible_set_fact_to_json --path ansible/playbooks/deploy.yml
+
+Exit code 0 if no misuses found, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from devx.tools.ansible_checks.set_fact_to_json import (
+    REPO_ROOT,
+    TO_JSON_FILTERS,  # noqa: F401 — re-exported for backward compat
+    _check_file,  # noqa: F401
+    _check_task,  # noqa: F401
+    _check_task_list,  # noqa: F401
+    _check_tasks,  # noqa: F401
+    _find_task_files,  # noqa: F401
+    check_set_fact_to_json,  # noqa: F401
+)
+
+DEFAULT_ANSIBLE_DIRS: list[Path] = [
+    REPO_ROOT / "ansible" / "playbooks",
+    REPO_ROOT / "ansible" / "roles",
+]
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific file or directory (default: ansible/playbooks + ansible/roles).",
+)
+@click.option(
+    "--ansible-dir",
+    "ansible_dirs",
+    type=click.Path(exists=True, path_type=Path),
+    multiple=True,
+    default=None,
+    help="Override the default ansible directories (can be repeated). Defaults to ansible/playbooks and ansible/roles.",
+)
+def main(path: Path | None, ansible_dirs: tuple[Path, ...]) -> None:
+    """Check that set_fact tasks don't misuse to_json."""
+    dirs = list(ansible_dirs) if ansible_dirs else DEFAULT_ANSIBLE_DIRS
+    all_errors = check_set_fact_to_json(path) if path else check_set_fact_to_json(None, dirs)
+
+    if all_errors:
+        click.echo("[check-ansible-set-fact-to-json] FAIL: set_fact with to_json found:")
+        for err in all_errors:
+            click.echo(f"  - {err}")
+        sys.exit(1)
+    else:
+        click.echo("[check-ansible-set-fact-to-json] OK: no set_fact tasks misuse to_json.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_docker_init.py

@@ -0,0 +1,166 @@
+"""Check that Docker Compose services with healthchecks have ``init: true``.
+
+This prevents zombie process accumulation on production VMs. Without
+``init: true``, Docker uses the container's PID 1 process to reap
+child processes. Many images (especially those using CMD-SHELL
+healthchecks with ``wget``) don't call ``wait()`` on children, causing
+zombies to accumulate.
+
+The check scans all Jinja2 docker-compose templates for services that
+have a ``healthcheck:`` key but no ``init: true`` key. Since the
+templates use Jinja2 syntax (not pure YAML), the check uses text-based
+parsing to identify service blocks and their properties.
+
+Usage::
+
+    python -m devx.tools.check_docker_init
+    python -m devx.tools.check_docker_init --path ansible/roles/observability/templates/docker-compose.yml.j2
+
+Exit code 0 if all services with healthchecks have init: true, 1 otherwise.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+import click
+
+REPO_ROOT = Path.cwd()
+DEFAULT_TEMPLATES_DIR = REPO_ROOT / "ansible" / "roles"
+
+
+def _find_compose_templates(base: Path) -> list[Path]:
+    """Find all Jinja2 docker-compose templates under a base directory."""
+    if base.is_file():
+        return [base]
+    if not base.is_dir():
+        return []
+    results: list[Path] = []
+    for pattern in ("*docker-compose*", "*compose*"):
+        results.extend(base.rglob(f"{pattern}.yml.j2"))
+        results.extend(base.rglob(f"{pattern}.yaml.j2"))
+    # Also check exporters-compose
+    results.extend(base.rglob("exporters-compose*.j2"))
+    # Deduplicate while preserving order
+    seen: set[Path] = set()
+    unique: list[Path] = []
+    for p in sorted(results):
+        if p not in seen:
+            seen.add(p)
+            unique.append(p)
+    return unique
+
+
+def _parse_services(content: str) -> dict[str, list[str]]:
+    """Parse service blocks from a docker-compose Jinja2 template.
+
+    Returns a mapping of service_name → list of lines in that service block.
+    """
+    lines = content.splitlines()
+    in_services = False
+    services: dict[str, list[str]] = {}
+    current_svc: str | None = None
+    current_lines: list[str] = []
+
+    for line in lines:
+        if line.startswith("services:"):
+            in_services = True
+            continue
+        if not in_services:
+            continue
+        # Top-level keys (networks:, volumes:) end the services section
+        if re.match(r"^(networks|volumes):\s*$", line):
+            if current_svc is not None:
+                services[current_svc] = current_lines
+            current_svc = None
+            in_services = False
+            continue
+        # Service definition: exactly 2-space indent, ends with :
+        # Service names can contain Jinja2 variables like {{ app_name }}
+        # or {{ app_name }}-db. Match: 2-space indent + non-whitespace
+        # chars (including {{ }}, -, _, .) + optional spaces inside {{ }} + :
+        m = re.match(r"^  (\{\{.*?\}\}[a-zA-Z0-9_-]*|[a-zA-Z0-9_().-]+):\s*$", line)
+        if m:
+            if current_svc is not None:
+                services[current_svc] = current_lines
+            current_svc = m.group(1)
+            current_lines = []
+        elif current_svc is not None:
+            current_lines.append(line)
+
+    if current_svc is not None:
+        services[current_svc] = current_lines
+
+    return services
+
+
+def _check_template(filepath: Path, repo_root: Path) -> list[str]:
+    """Check a single docker-compose template for missing init: true.
+
+    Returns a list of error messages (empty if all OK).
+    """
+    errors: list[str] = []
+    content = filepath.read_text(encoding="utf-8")
+
+    if "services:" not in content:
+        return errors
+
+    services = _parse_services(content)
+
+    for svc_name, svc_lines in services.items():
+        svc_text = "\n".join(svc_lines)
+        has_init = "init: true" in svc_text
+        has_healthcheck = "healthcheck:" in svc_text
+        # Skip services that are conditionally included (Jinja2 if blocks)
+        # but still check them — the healthcheck is inside the conditional
+        if has_healthcheck and not has_init:
+            try:
+                display_path = filepath.relative_to(repo_root)
+            except ValueError:
+                display_path = filepath
+            errors.append(
+                f"{display_path}: service '{svc_name}' has a healthcheck "
+                f"but no 'init: true'. Without init: true, CMD-SHELL "
+                f"healthchecks (wget, pgrep) spawn children that become "
+                f"zombies when PID 1 doesn't reap them. Add 'init: true' "
+                f"to enable Docker's built-in tini as PID 1."
+            )
+
+    return errors
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific file or directory (default: ansible/roles/).",
+)
+@click.option(
+    "--templates-dir",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+    help="Override the default templates directory (default: ansible/roles/).",
+)
+def main(path: Path | None, templates_dir: Path | None) -> None:
+    """Check that Docker Compose services with healthchecks have init: true."""
+    tdir = templates_dir or DEFAULT_TEMPLATES_DIR
+    files = _find_compose_templates(path) if path else _find_compose_templates(tdir)
+
+    all_errors: list[str] = []
+    for f in files:
+        errors = _check_template(f, tdir)
+        all_errors.extend(errors)
+
+    if all_errors:
+        click.echo("[check-docker-init] FAIL: services with healthchecks missing init: true:")
+        for err in all_errors:
+            click.echo(f"  - {err}")
+        sys.exit(1)
+    else:
+        click.echo("[check-docker-init] OK: all services with healthchecks have init: true.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_jinja_expr.py

@@ -0,0 +1,65 @@
+"""Validate Jinja2 expressions in Ansible files by rendering them.
+
+Thin wrapper around :mod:`devx.tools.ansible_checks.jinja_expr` for
+backward compatibility. The check logic lives in the subpackage; this
+module preserves the CLI entry point and re-exports the internal
+helpers so existing tests and imports continue to work.
+
+Usage::
+
+    python -m devx.tools.check_jinja_expr
+    python -m devx.tools.check_jinja_expr --path ansible/playbooks/deploy-observability.yml
+
+Exit code 0 if all renderable expressions pass, 1 if any fail.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from devx.tools.ansible_checks.jinja_expr import (
+    EXPR_PATTERN,  # noqa: F401 — re-exported for backward compat
+    MOCK_CONTEXT,  # noqa: F401
+    _check_file,  # noqa: F401
+    _default_ansible_dirs,  # noqa: F401
+    _extract_expressions,  # noqa: F401
+    _find_yaml_files,  # noqa: F401
+    _render_expression,  # noqa: F401
+    check_jinja_expr,  # noqa: F401
+)
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True, path_type=Path),
+    help="Check a specific file or directory (default: ansible/playbooks + ansible/roles).",
+)
+@click.option(
+    "--ansible-dir",
+    "ansible_dirs",
+    type=click.Path(exists=True, path_type=Path),
+    multiple=True,
+    default=None,
+    help="Override the default ansible directories (can be repeated). Defaults to ansible/playbooks and ansible/roles.",
+)
+def main(path: Path | None, ansible_dirs: tuple[Path, ...]) -> None:
+    """Validate Jinja2 expressions in Ansible files."""
+    dirs = list(ansible_dirs) if ansible_dirs else _default_ansible_dirs()
+    all_violations = check_jinja_expr(path) if path else check_jinja_expr(None, dirs)
+
+    if all_violations:
+        click.echo("[check-jinja-expr] FAIL: invalid Jinja expressions found:")
+        for v in all_violations:
+            click.echo(f"  - {v}")
+        click.echo("\nFix: test expressions with `ansible localhost -m debug -a 'msg={{ <expr> }}'`")
+        sys.exit(1)
+    else:
+        click.echo("[check-jinja-expr] OK: all Jinja expressions render correctly.")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

src/devx/tools/check_test_isolation.py

@@ -0,0 +1,1348 @@
+#!/usr/bin/env python3
+"""Static analysis to detect un-hermetic test patterns that cause slow or flaky tests.
+
+This module is used in two ways:
+
+1. **As a pytest plugin** (automatic — no configuration needed):
+   When devx is installed, pytest auto-discovers this plugin via the
+   ``pytest11`` entry point.  Every ``pytest`` run statically analyzes
+   test files for patterns that cause slow, non-deterministic, or
+   non-hermetic tests and **fails the test run** if any violations are found.
+
+   The plugin also wraps ``subprocess.run`` at runtime to catch real
+   subprocess calls that leak through transitive call paths (e.g.
+   ``CliRunner.invoke(main)`` → ``main()`` → ``update_doc_versions()``
+   → ``subprocess.run()``).  If a test spawns a real subprocess without
+   ``@patch``, the test fails.
+
+   To disable for a specific run: ``--no-test-isolation``.
+
+2. **As a standalone CLI** (for CI gates)::
+
+       python3 -m devx.tools.check_test_isolation [--test-path tests/]
+
+   Always exits non-zero on any hard violation. Transitive-subprocess
+   findings are reported as advisories (exit 0) since static analysis
+   can't predict early exits — the runtime audit is authoritative.
+
+Project-Specific Configuration
+-------------------------------
+
+Projects can extend the built-in rule sets via ``[tool.devx.check_test_isolation]``
+in ``pyproject.toml``.  Entries are merged on top of the defaults — they
+add to (not replace) the built-in rules::
+
+    [tool.devx.check_test_isolation]
+    # Functions known to do filesystem or network I/O
+    io_functions = { "my_func" = "reads config from disk", ... }
+    # Functions known to spawn subprocesses
+    subprocess_helpers = { "my_helper" = "calls subprocess.run", ... }
+    # Transitive deps: if a helper calls these, patching any of them is safe
+    helper_internal_calls = { "my_helper" = ["subprocess", "run_cmd"], ... }
+    # I/O function internal deps: patching any of these makes the call safe
+    io_internal_calls = { "my_func" = ["open", "yaml"], ... }
+    # Heavy modules slow to import at module level in test files
+    heavy_module_imports = { "mymodule" = 150.0, ... }
+
+Patterns detected:
+
+1. **Unpatched subprocess calls** — test functions that call
+   ``subprocess.run/call/Popen/check_call/check_output`` without a
+   corresponding ``@patch`` decorator or ``with patch(...)`` context manager.
+2. **Unpatched ``time.sleep``** — test functions that call ``time.sleep``
+   without patching it.
+3. **Unpatched known-subprocess-helpers** — functions known to spawn
+   subprocesses (e.g. ``update_doc_versions``) called without patching.
+4. **Unpatched I/O functions** — functions known to do filesystem or
+   network I/O (e.g. ``get_pat``, ``load_secrets``, ``requests.get``)
+   called without patching.
+5. **Excessive iteration loops** — ``for _ in range(N)`` where N > 100.
+6. **Module-level heavy imports** — importing ``httpx``, ``ansible``,
+   etc. at module level in test files slows collection for all tests.
+7. **``importlib.reload`` without cleanup** — reloading a module in a
+   test mutates global state.  Each reload must be paired with a
+   cleanup reload (or wrapped in try/finally) to restore defaults.
+8. **Transitive subprocess leaks** — ``CliRunner.invoke(target)`` where
+   ``target`` transitively calls ``subprocess.run`` without being patched.
+   Detected via static call-graph analysis (warning) AND runtime audit
+   (authoritative — fails the test if a real subprocess runs).
+"""
+
+from __future__ import annotations
+
+import ast
+import subprocess  # nosec B404
+import sys
+import threading
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import click
+
+from devx.config import _load_pyproject_devx
+from devx.i18n import _
+
+# ── Configuration ─────────────────────────────────────────────────────────────
+
+DEFAULT_MAX_LOOP_ITERATIONS = 100
+
+# Heavy modules that are slow to import (>50ms).  When imported at module
+# level in a test file, they slow down test collection for ALL tests.
+# Maps module name → approximate import time in milliseconds.
+# NOTE: ``requests`` is excluded because it's a core devx dependency —
+# it's loaded during collection regardless of whether test files import it.
+_DEFAULT_HEAVY_MODULE_IMPORTS: dict[str, float] = {
+    "httpx": 80.0,
+    "aiohttp": 120.0,
+    "docker": 90.0,
+    "kubernetes": 200.0,
+    "boto3": 250.0,
+    "botocore": 200.0,
+    "ansible": 300.0,
+    "molecule": 150.0,
+    "cv2": 400.0,
+    "numpy": 100.0,
+    "pandas": 200.0,
+    "matplotlib": 300.0,
+    "PIL": 80.0,
+    "Pillow": 80.0,
+    "sqlalchemy": 150.0,
+    "django": 200.0,
+    "flask": 80.0,
+    "fastapi": 100.0,
+    "pydantic": 60.0,
+}
+
+# Functions known to spawn subprocesses.  When a test calls any of these
+# without patching them, the real subprocess runs.
+# Maps function name → human-readable description.
+_DEFAULT_SUBPROCESS_HELPERS: dict[str, str] = {
+    "update_doc_versions": "calls subprocess.run to run check_doc_versions --fix",
+    "run_tests": "calls run_cmd to run make lint-ruff and make pytest-cov",
+    "run_cmd": "calls subprocess.run for shell commands",
+}
+
+# Functions known to do filesystem or network I/O that should be mocked in tests.
+# Maps function name → description of what I/O it does.
+# If a test calls one of these without a corresponding @patch, it's a violation.
+_DEFAULT_IO_FUNCTIONS: dict[str, str] = {  # nosec B105 — descriptions, not passwords
+    "get_pat": "reads ZITADEL PAT from filesystem/env (ZitadelAuth._iter_sources)",
+    "load_secrets": "reads YAML config file from disk",
+    "get_customer_secret": "reads customer-specific config from disk",
+    "get_customer_vm_ip": "queries Hetzner Cloud API for VM IP (network I/O)",
+    "get_observability_vm_ip": "queries Hetzner Cloud API for observability VM IP (network I/O)",
+    "requests.get": "performs HTTP GET to a real server",
+    "requests.post": "performs HTTP POST to a real server",
+    "requests.put": "performs HTTP PUT to a real server",
+    "requests.patch": "performs HTTP PATCH to a real server",
+    "requests.delete": "performs HTTP DELETE to a real server",
+    "urlopen": "performs HTTP request to a real server",
+    "httpx.get": "performs HTTP GET to a real server",
+    "httpx.post": "performs HTTP POST to a real server",
+}
+
+# Transitive dependencies: if a helper calls another helper that is patched,
+# the call is safe.  Maps helper → set of function names it internally calls.
+# If ANY of these are in the test's patches, the helper call is safe.
+_DEFAULT_HELPER_INTERNAL_CALLS: dict[str, set[str]] = {
+    "run_tests": {"run_cmd", "subprocess"},
+    "update_doc_versions": {"subprocess"},
+    "run_cmd": {"subprocess"},
+}
+
+# I/O function internal dependencies: if a test patches one of these
+# internal dependencies, the I/O function call is considered safe.
+# Maps I/O function name → set of internal function/method names it calls.
+_DEFAULT_IO_INTERNAL_CALLS: dict[str, set[str]] = {
+    "get_customer_vm_ip": {"get_tofu_output", "get_tofu_vm_ip", "subprocess"},
+    "get_observability_vm_ip": {"get_tofu_output", "get_tofu_vm_ip", "subprocess"},
+    "get_pat": {
+        "_iter_sources",
+        "_local_pat_path",
+        "_secrets_path",
+        "_read_secrets_pat",
+        "validate_pat",
+        "ZitadelAuth",
+        "load_secrets",
+        "os.environ",
+    },
+    "load_secrets": {"load_vault_yaml", "REPO_ROOT", "open", "yaml", "safe_load"},
+    "get_customer_secret": {"load_customer_secrets", "load_vault_yaml", "load_secrets", "REPO_ROOT", "open"},
+}
+
+
+def _load_test_isolation_config() -> None:
+    """Merge project-specific rules from ``[tool.devx.check_test_isolation]``.
+
+    Reads from pyproject.toml and merges with defaults. Project-specific
+    entries are added on top of (not replacing) the built-in defaults.
+
+    Supported keys::
+
+        [tool.devx.check_test_isolation]
+        io_functions = { "my_func" = "does network I/O", ... }
+        subprocess_helpers = { "my_helper" = "calls subprocess.run", ... }
+        helper_internal_calls = { "my_helper" = ["subprocess", "run_cmd"], ... }
+        io_internal_calls = { "my_func" = ["open", "yaml"], ... }
+        heavy_module_imports = { "mymodule" = 150.0, ... }
+    """
+    devx_cfg = _load_pyproject_devx()
+    cfg_raw = devx_cfg.get("check_test_isolation", {})
+    if not isinstance(cfg_raw, dict):
+        return
+    cfg: dict[str, object] = cfg_raw  # type: ignore[assignment]
+
+    # io_functions: {name: description}
+    io_extra = cfg.get("io_functions", {})
+    if isinstance(io_extra, dict):
+        for name, desc in io_extra.items():
+            if isinstance(name, str) and isinstance(desc, str):
+                KNOWN_IO_FUNCTIONS[name] = desc
+
+    # subprocess_helpers: {name: description}
+    sp_extra = cfg.get("subprocess_helpers", {})
+    if isinstance(sp_extra, dict):
+        for name, desc in sp_extra.items():
+            if isinstance(name, str) and isinstance(desc, str):
+                KNOWN_SUBPROCESS_HELPERS[name] = desc
+
+    # helper_internal_calls: {name: [deps]}
+    hic_extra = cfg.get("helper_internal_calls", {})
+    if isinstance(hic_extra, dict):
+        for name, deps in hic_extra.items():
+            if isinstance(name, str) and isinstance(deps, list):
+                deps_set = {str(d) for d in deps if isinstance(d, str)}
+                HELPER_INTERNAL_CALLS.setdefault(name, set()).update(deps_set)
+
+    # io_internal_calls: {name: [deps]}
+    iic_extra = cfg.get("io_internal_calls", {})
+    if isinstance(iic_extra, dict):
+        for name, deps in iic_extra.items():
+            if isinstance(name, str) and isinstance(deps, list):
+                deps_set = {str(d) for d in deps if isinstance(d, str)}
+                IO_INTERNAL_CALLS.setdefault(name, set()).update(deps_set)
+
+    # heavy_module_imports: {name: ms}
+    hmi_extra = cfg.get("heavy_module_imports", {})
+    if isinstance(hmi_extra, dict):
+        for name, ms in hmi_extra.items():
+            if isinstance(name, str) and isinstance(ms, (int, float)):
+                HEAVY_MODULE_IMPORTS[name] = float(ms)
+
+
+# Active rule sets — start with defaults, merged with project config at import.
+HEAVY_MODULE_IMPORTS: dict[str, float] = dict(_DEFAULT_HEAVY_MODULE_IMPORTS)
+KNOWN_SUBPROCESS_HELPERS: dict[str, str] = dict(_DEFAULT_SUBPROCESS_HELPERS)
+KNOWN_IO_FUNCTIONS: dict[str, str] = dict(_DEFAULT_IO_FUNCTIONS)
+HELPER_INTERNAL_CALLS: dict[str, set[str]] = {k: set(v) for k, v in _DEFAULT_HELPER_INTERNAL_CALLS.items()}
+IO_INTERNAL_CALLS: dict[str, set[str]] = {k: set(v) for k, v in _DEFAULT_IO_INTERNAL_CALLS.items()}
+
+# Merge project-specific configuration from pyproject.toml
+_load_test_isolation_config()
+
+# subprocess functions that the runtime audit wraps.
+_SUBPROCESS_FUNCS = ("run", "call", "check_call", "check_output", "Popen")
+
+
+# ── Runtime subprocess audit ──────────────────────────────────────────────────
+#
+# The static AST analyzer can only see direct calls in test functions.
+# It cannot trace transitive calls through CliRunner.invoke(main, ...)
+# → main() → update_doc_versions() → subprocess.run().
+#
+# The runtime audit wraps subprocess functions during test execution.
+# If a test does NOT @patch subprocess, the wrapper catches real calls.
+# If a test DOES @patch subprocess, the patch overrides our wrapper
+# (correct — the test is mocking it).
+
+
+class _SubprocessAudit:
+    """Thread-local audit tracker for real subprocess calls during tests."""
+
+    def __init__(self) -> None:
+        self._local = threading.local()
+        self._installed = False
+        self._originals: dict[str, object] = {}
+
+    def _ensure_installed(self) -> None:
+        """Install wrappers on subprocess module (once)."""
+        if self._installed:
+            return
+        for name in _SUBPROCESS_FUNCS:
+            original = getattr(subprocess, name, None)
+            if original is None:
+                continue
+            self._originals[name] = original
+            setattr(subprocess, name, self._make_wrapper(name, original))
+        self._installed = True
+
+    def _make_wrapper(self, name: str, original: object) -> object:
+        """Create a wrapper that records calls when auditing is active."""
+
+        def wrapper(*args: object, **kwargs: object) -> object:
+            calls = getattr(self._local, "calls", None)
+            if calls is not None:
+                # Extract command for diagnostics
+                cmd = args[0] if args else kwargs.get("args", "?")
+                if isinstance(cmd, (list, tuple)) and cmd:
+                    cmd_str = " ".join(str(c) for c in cmd[:4])
+                    if len(cmd) > 4:
+                        cmd_str += " ..."
+                else:
+                    cmd_str = str(cmd)
+                calls.append((name, cmd_str))
+            return original(*args, **kwargs)  # type: ignore[misc]
+
+        return wrapper
+
+    def start_test(self) -> None:
+        """Begin auditing subprocess calls for the current test."""
+        self._ensure_installed()
+        self._local.calls = []
+
+    def stop_test(self) -> list[tuple[str, str]]:
+        """Stop auditing and return recorded calls."""
+        calls = getattr(self._local, "calls", [])
+        self._local.calls = None
+        return calls
+
+
+# Singleton instance used by the pytest plugin
+_audit = _SubprocessAudit()
+
+
+# ── Data structures ───────────────────────────────────────────────────────────
+
+
+@dataclass
+class Violation:
+    """A single isolation violation found in a test file."""
+
+    file: Path
+    line: int
+    col: int
+    category: str
+    message: str
+
+    def format(self) -> str:
+        try:
+            rel = self.file.relative_to(Path.cwd())
+        except ValueError:
+            rel = self.file
+        return f"{rel}:{self.line}:{self.col}: [{self.category}] {self.message}"
+
+
+@dataclass
+class TestFunctionInfo:
+    """Information about a test function or method."""
+
+    name: str
+    node: ast.FunctionDef | ast.AsyncFunctionDef
+    patches: set[str] = field(default_factory=set)
+    class_patches: set[str] = field(default_factory=set)
+    is_test: bool = False
+
+
+# ── AST helpers ───────────────────────────────────────────────────────────────
+
+
+def _extract_patch_targets(node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef) -> set[str]:
+    """Extract @patch targets from decorators AND ``with patch(...)`` statements.
+
+    Detects:
+    - ``@patch("module.func")`` decorators
+    - ``with patch("module.func")`` context managers
+    - ``with patch.object(module, "func")`` context managers
+    - ``with patch("a"), patch("b")`` multiple patches
+    """
+    targets: set[str] = set()
+
+    def _process_patch_call(call: ast.Call) -> None:
+        """Extract target from a patch() or patch.object() call."""
+        func = call.func
+        # patch("module.func") — either bare `patch(...)` or `mock.patch(...)`
+        if (isinstance(func, ast.Name) and func.id == "patch") or (
+            isinstance(func, ast.Attribute) and func.attr == "patch"
+        ):
+            if call.args and isinstance(call.args[0], ast.Constant) and isinstance(call.args[0].value, str):
+                target = call.args[0].value
+                targets.add(target)
+                targets.add(target.rsplit(".", 1)[-1])
+        # patch.object(module, "func") — extract short name from 2nd arg
+        elif (
+            isinstance(func, ast.Attribute)
+            and func.attr == "object"
+            and isinstance(func.value, ast.Name)
+            and func.value.id == "patch"
+            and len(call.args) >= 2
+            and isinstance(call.args[1], ast.Constant)
+            and isinstance(call.args[1].value, str)
+            and call.args[0]
+            and isinstance(call.args[0], ast.Name)
+        ):
+            short = call.args[1].value
+            targets.add(short)
+            # We can't resolve the module alias here, but the short
+            # name is enough for patch matching in the call graph.
+
+    # 1. Extract from decorators
+    for decorator in node.decorator_list:
+        if isinstance(decorator, ast.Call):
+            _process_patch_call(decorator)
+
+    # 2. Extract from `with patch(...)` context managers in the body
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        for child in ast.walk(node):
+            if isinstance(child, ast.With):
+                for item in child.items:
+                    ctx = item.context_expr
+                    if isinstance(ctx, ast.Call):
+                        _process_patch_call(ctx)
+
+    return targets
+
+
+def _is_test_function(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    return node.name.startswith("test_")
+
+
+def _has_integration_marker(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if a test function has @pytest.mark.integration decorator."""
+    for decorator in node.decorator_list:
+        # @pytest.mark.integration  →  ast.Attribute(attr='integration')
+        if isinstance(decorator, ast.Attribute) and decorator.attr == "integration":
+            return True
+        # @pytest.mark.integration(...)  →  ast.Call(func=ast.Attribute(attr='integration'))
+        if isinstance(decorator, ast.Call):
+            func = decorator.func
+            if isinstance(func, ast.Attribute) and func.attr == "integration":
+                return True
+    return False
+
+
+def _get_called_name(node: ast.Call) -> str | None:
+    func = node.func
+    if isinstance(func, ast.Name):
+        return func.id
+    if isinstance(func, ast.Attribute):
+        return func.attr
+    return None
+
+
+def _get_full_called_name(node: ast.Call) -> str | None:
+    func = node.func
+    parts: list[str] = []
+    current = func
+    while isinstance(current, ast.Attribute):
+        parts.append(current.attr)
+        current = current.value
+    if isinstance(current, ast.Name):
+        parts.append(current.id)
+    parts.reverse()
+    if not parts:
+        return None
+    return ".".join(parts)
+
+
+def _get_range_count(node: ast.Call) -> int | None:
+    if not isinstance(node.func, ast.Name) or node.func.id != "range":
+        return None
+    if not node.args:
+        return None
+    # range(N) — single argument
+    if len(node.args) == 1:
+        arg = node.args[0]
+        if isinstance(arg, ast.Constant) and isinstance(arg.value, int):
+            return arg.value
+        return None
+    # range(start, stop) — two or more arguments
+    if len(node.args) >= 2:
+        stop = node.args[1]
+        if not isinstance(stop, ast.Constant) or not isinstance(stop.value, int):
+            return None
+        start = node.args[0]
+        if isinstance(start, ast.Constant) and isinstance(start.value, int):
+            return stop.value - start.value
+        # Non-constant start — assume 0
+        return stop.value
+    return None  # pragma: no cover
+
+
+# ── Call-graph builder ────────────────────────────────────────────────────────
+#
+# The static AST analyzer can only see direct calls in test functions.
+# It cannot trace transitive calls through CliRunner.invoke(main, ...)
+# → main() → update_doc_versions() → subprocess.run().
+#
+# The call-graph builder parses all source files in the package and builds
+# a map: function_name → set of function_names it calls.
+# When a test calls runner.invoke(target, ...), we trace the call graph
+# from target to find all reachable functions, then check if any of them
+# call subprocess.run (or other dangerous functions) without being patched.
+
+
+# Dangerous functions that should never run in unit tests.
+# Maps full call name → description.
+_DANGEROUS_CALLS: dict[str, str] = {
+    "subprocess.run": "spawns a real subprocess",
+    "subprocess.call": "spawns a real subprocess",
+    "subprocess.check_call": "spawns a real subprocess",
+    "subprocess.check_output": "spawns a real subprocess",
+    "subprocess.Popen": "spawns a real subprocess",
+}
+
+
+@dataclass
+class _FunctionNode:
+    """AST node for a function with its called names."""
+
+    name: str
+    module: str
+    calls: set[str]  # short names of functions called
+    subprocess_calls: set[str]  # dangerous subprocess calls made directly
+    io_calls: set[str]  # known I/O function calls made directly
+
+
+class CallGraph:
+    """Call graph built from source files in a package directory."""
+
+    def __init__(self, src_dir: Path) -> None:
+        self.src_dir = src_dir
+        # Maps "module.func" → _FunctionNode
+        self._nodes: dict[str, _FunctionNode] = {}
+        # Maps short name → list of full names (for resolution)
+        self._by_short: dict[str, list[str]] = {}
+        self._built = False
+
+    def _ensure_built(self) -> None:
+        if self._built:
+            return
+        self._build()
+        self._built = True
+
+    def _build(self) -> None:
+        """Parse all .py files under src_dir and build the call graph."""
+        for py_file in sorted(self.src_dir.rglob("*.py")):
+            try:
+                source = py_file.read_text()
+                tree = ast.parse(source, filename=str(py_file))
+            except (SyntaxError, UnicodeDecodeError):
+                continue
+            # Derive module name from path relative to src_dir
+            rel = py_file.relative_to(self.src_dir)
+            module_parts = list(rel.with_suffix("").parts)
+            if module_parts and module_parts[-1] == "__init__":
+                module_parts = module_parts[:-1]
+            module = ".".join(module_parts)
+            self._scan_module(tree, module)
+
+    def _scan_module(self, tree: ast.Module, module: str) -> None:
+        """Scan a module AST and register all top-level functions.
+
+        Methods defined inside classes are NOT registered — they are called
+        via objects (e.g. ``tea.create_issue()``) and resolving them by short
+        name alone causes false positives when the class is patched (e.g.
+        ``@patch("...TeaCLI")`` mocks all methods).
+        """
+        for node in tree.body:
+            self._scan_node(node, module)
+
+    def _scan_node(self, node: ast.AST, module: str) -> None:
+        """Recursively scan a node, registering non-method functions."""
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            self._register_function(node, module)
+            # Don't recurse into function bodies — nested functions are
+            # not callable by name from outside.
+            return
+        if isinstance(node, ast.ClassDef):
+            # Skip class body — methods are not registered.
+            return
+        # Recurse into other compound statements (if/for/try/with/etc.)
+        for child in ast.iter_child_nodes(node):
+            self._scan_node(child, module)
+
+    def _register_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef, module: str) -> None:
+        """Register a function and its direct calls in the call graph."""
+        full_name = f"{module}.{node.name}"
+        calls: set[str] = set()
+        subprocess_calls: set[str] = set()
+        io_calls: set[str] = set()
+
+        for child in ast.walk(node):
+            if isinstance(child, ast.Call):
+                full = _get_full_called_name(child)
+                short = _get_called_name(child)
+                if short:
+                    calls.add(short)
+                if full and full in _DANGEROUS_CALLS:
+                    subprocess_calls.add(full)
+                if short and short in KNOWN_IO_FUNCTIONS:
+                    io_calls.add(short)
+                # KNOWN_SUBPROCESS_HELPERS are intermediate functions (e.g.
+                # run_tests → run_cmd → subprocess.run).  They are already
+                # in *calls* so the BFS will traverse into them and find the
+                # actual subprocess call.  Adding them to *subprocess_calls*
+                # here would cause false positives when the helper itself is
+                # transitively patched (e.g. run_cmd is patched → run_tests
+                # is safe, but would still be reported).
+
+        fn_node = _FunctionNode(
+            name=node.name,
+            module=module,
+            calls=calls,
+            subprocess_calls=subprocess_calls,
+            io_calls=io_calls,
+        )
+        self._nodes[full_name] = fn_node
+        self._by_short.setdefault(node.name, []).append(full_name)
+
+    def find_reachable_dangerous(
+        self,
+        target_name: str,
+        patches: set[str],
+        max_depth: int = 10,
+        import_map: dict[str, str] | None = None,
+    ) -> list[tuple[str, str]]:
+        """Find all dangerous calls reachable from target_name that aren't patched.
+
+        Returns a list of (function_name, description) tuples for each
+        unpatched dangerous call found in the transitive closure.
+
+        If import_map is provided (mapping short names to fully-qualified
+        module paths), it's used to resolve the target precisely instead
+        of matching by short name alone.
+        """
+        self._ensure_built()
+
+        # Resolve target to full name(s)
+        # First try precise resolution via import_map
+        candidates: list[str] = []
+        if import_map and target_name in import_map:
+            full = import_map[target_name]
+            candidates = [full] if full in self._nodes else self._by_short.get(target_name, [])
+        elif target_name in self._nodes:
+            # Already a fully-qualified name (e.g. devx.tools.build_image.main)
+            candidates = [target_name]
+        else:
+            # Fall back to short name resolution
+            short = target_name.rsplit(".", 1)[-1]
+            candidates = self._by_short.get(short, [])
+
+        if not candidates:
+            return []
+
+        visited: set[str] = set()
+        dangerous: list[tuple[str, str]] = []
+        queue: list[tuple[str, int]] = [(c, 0) for c in candidates]
+
+        while queue:
+            full_name, depth = queue.pop(0)
+            if full_name in visited or depth > max_depth:
+                continue
+            visited.add(full_name)
+
+            node = self._nodes.get(full_name)
+            if node is None:
+                continue
+
+            # Check direct subprocess calls
+            for sc in node.subprocess_calls:
+                short = sc.rsplit(".", 1)[-1]
+                if not self._is_patched(sc, short, patches):
+                    desc = _DANGEROUS_CALLS.get(sc, "")
+                    dangerous.append((full_name, desc))
+
+            # Check direct IO calls
+            for io in node.io_calls:
+                if not self._is_patched(io, io, patches):
+                    desc = KNOWN_IO_FUNCTIONS.get(io, "")
+                    if desc:
+                        dangerous.append((full_name, desc))
+
+            # Enqueue called functions — skip if the called function is patched
+            for called_short in node.calls:
+                if self._is_patched(called_short, called_short, patches):
+                    continue
+                # Prefer same-module resolution, then fall back to short name
+                # only if there's a single global match (avoids false positives
+                # when multiple modules define functions with the same name).
+                same_module = f"{node.module}.{called_short}"
+                if same_module in self._nodes and same_module not in visited:
+                    queue.append((same_module, depth + 1))
+                else:
+                    matches = self._by_short.get(called_short, [])
+                    if len(matches) == 1 and matches[0] not in visited:
+                        queue.append((matches[0], depth + 1))
+
+        return dangerous
+
+    @staticmethod
+    def _is_patched(full: str, short: str, patches: set[str]) -> bool:
+        """Check if a function is covered by the test's @patch set."""
+        if short in patches or full in patches:
+            return True
+        # Check if any patch entry ends with ".short" (e.g. "subprocess.run"
+        # is patched by "devx.ci.release.subprocess.run").  Use exact
+        # endswith, not substring, to avoid "run" matching "run_cmd".
+        return any(p.endswith(f".{short}") or p == full for p in patches)
+
+
+# ── Analyzers ─────────────────────────────────────────────────────────────────
+
+
+class TestIsolationVisitor(ast.NodeVisitor):
+    """AST visitor that detects un-hermetic test patterns."""
+
+    def __init__(
+        self,
+        file_path: Path,
+        max_loop_iterations: int = DEFAULT_MAX_LOOP_ITERATIONS,
+        call_graph: CallGraph | None = None,
+    ):
+        self.file_path = file_path
+        self.max_loop_iterations = max_loop_iterations
+        self.call_graph = call_graph
+        self.violations: list[Violation] = []
+        self._current_function: TestFunctionInfo | None = None
+        self._current_class_patches: set[str] = set()
+        self._in_test_class = False
+        self._reload_calls: list[tuple[int, str | None]] = []
+        # Import map: short name → fully-qualified module.func
+        # e.g. {"main": "devx.ci.release.main"} for `from devx.ci.release import main`
+        self._import_map: dict[str, str] = {}
+
+    def visit_Import(self, node: ast.Import) -> None:
+        # Track imports for call-graph resolution
+        if self._current_function is None:
+            for alias in node.names:
+                name = alias.asname or alias.name
+                self._import_map[name] = alias.name
+        # Check for heavy module imports
+        if self._current_function is None:
+            for alias in node.names:
+                mod = alias.name.split(".")[0]
+                if mod in HEAVY_MODULE_IMPORTS:
+                    self.violations.append(
+                        Violation(
+                            file=self.file_path,
+                            line=node.lineno,
+                            col=node.col_offset,
+                            category="heavy-module-import",
+                            message=_(
+                                "Heavy import '{mod}' (~{ms:.0f}ms) at module level — "
+                                "this slows test collection for all tests. "
+                                "Move inside test functions or use lazy import.",
+                                mod=alias.name,
+                                ms=HEAVY_MODULE_IMPORTS[mod],
+                            ),
+                        )
+                    )
+        self.generic_visit(node)
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        # Track imports for call-graph resolution
+        if self._current_function is None and node.module:
+            for alias in node.names:
+                name = alias.asname or alias.name
+                self._import_map[name] = f"{node.module}.{alias.name}"
+        # Check for heavy module imports
+        if self._current_function is None and node.module:
+            mod = node.module.split(".")[0]
+            if mod in HEAVY_MODULE_IMPORTS:
+                self.violations.append(
+                    Violation(
+                        file=self.file_path,
+                        line=node.lineno,
+                        col=node.col_offset,
+                        category="heavy-module-import",
+                        message=_(
+                            "Heavy import '{mod}' (~{ms:.0f}ms) at module level — "
+                            "this slows test collection for all tests. "
+                            "Move inside test functions or use lazy import.",
+                            mod=node.module,
+                            ms=HEAVY_MODULE_IMPORTS[mod],
+                        ),
+                    )
+                )
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        old_class_patches = self._current_class_patches
+        old_in_test = self._in_test_class
+        self._current_class_patches = _extract_patch_targets(node)
+        self._in_test_class = node.name.startswith("Test")
+        self.generic_visit(node)
+        self._current_class_patches = old_class_patches
+        self._in_test_class = old_in_test
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self._visit_function(node)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        self._visit_function(node)
+
+    def _visit_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+        if not _is_test_function(node):
+            self.generic_visit(node)
+            return
+
+        # Skip integration tests — they intentionally do real I/O
+        if _has_integration_marker(node):
+            self.generic_visit(node)
+            return
+
+        patches = _extract_patch_targets(node)
+        info = TestFunctionInfo(
+            name=node.name,
+            node=node,
+            patches=patches,
+            class_patches=self._current_class_patches,
+            is_test=True,
+        )
+        old_func = self._current_function
+        old_reloads = self._reload_calls
+        self._current_function = info
+        self._reload_calls = []
+        self.generic_visit(node)
+        # Check 7: importlib.reload without cleanup
+        # Each reload mutates global module state.  An odd number of
+        # reloads means the module is left in a modified state.
+        if len(self._reload_calls) % 2 != 0:
+            first_line, mod_name = self._reload_calls[0]
+            self.violations.append(
+                Violation(
+                    file=self.file_path,
+                    line=first_line,
+                    col=0,
+                    category="reload-without-cleanup",
+                    message=_(
+                        "importlib.reload({mod}) called {n} time(s) in test '{test}' — "
+                        "odd count leaves module in modified state. "
+                        "Add a final reload to restore defaults or wrap in try/finally.",
+                        mod=mod_name or "module",
+                        n=len(self._reload_calls),
+                        test=info.name,
+                    ),
+                )
+            )
+        self._current_function = old_func
+        self._reload_calls = old_reloads
+
+    def visit_Call(self, node: ast.Call) -> None:
+        if self._current_function is None:
+            self.generic_visit(node)
+            return
+
+        full_name = _get_full_called_name(node)
+        short_name = _get_called_name(node)
+        all_patches = self._current_function.patches | self._current_function.class_patches
+
+        # Track importlib.reload calls for cleanup check
+        if full_name == "importlib.reload" or (short_name == "reload" and "reload" in all_patches):
+            mod_arg = node.args[0] if node.args else None
+            mod_name = None
+            if isinstance(mod_arg, ast.Name):
+                mod_name = mod_arg.id
+            elif isinstance(mod_arg, ast.Attribute):
+                mod_name = mod_arg.attr
+            self._reload_calls.append((node.lineno, mod_name))
+
+        # Check 1: subprocess.run / subprocess.call / subprocess.Popen etc.
+        if full_name and full_name.startswith("subprocess."):
+            method = full_name.split(".", 1)[1]
+            if method in ("run", "call", "Popen", "check_call", "check_output") and not any(
+                "subprocess" in p for p in all_patches
+            ):
+                self.violations.append(
+                    Violation(
+                        file=self.file_path,
+                        line=node.lineno,
+                        col=node.col_offset,
+                        category="unpatched-subprocess",
+                        message=_(
+                            "{call} called in test '{test}' without @patch — "
+                            "this spawns a real subprocess. Add "
+                            '@patch("<module>.subprocess.run") or patch the calling function.',
+                            call=full_name,
+                            test=self._current_function.name,
+                        ),
+                    )
+                )
+
+        # Check 2: time.sleep
+        if (
+            (full_name == "time.sleep" or (short_name == "sleep" and "sleep" not in all_patches))
+            and "sleep" not in all_patches
+            and "time.sleep" not in all_patches
+            and not any("sleep" in p for p in all_patches)
+        ):
+            self.violations.append(
+                Violation(
+                    file=self.file_path,
+                    line=node.lineno,
+                    col=node.col_offset,
+                    category="unpatched-sleep",
+                    message=_(
+                        "time.sleep called in test '{test}' without @patch — "
+                        "this causes real wall-clock delays. Add "
+                        '@patch("<module>.time.sleep").',
+                        test=self._current_function.name,
+                    ),
+                )
+            )
+
+        # Check 3: Known subprocess helpers
+        if short_name in KNOWN_SUBPROCESS_HELPERS and not (
+            short_name in all_patches
+            or any("subprocess" in p for p in all_patches)
+            or any(
+                dep in all_patches or any(dep in p for p in all_patches)
+                for dep in HELPER_INTERNAL_CALLS.get(short_name, set())
+            )
+        ):
+            self.violations.append(
+                Violation(
+                    file=self.file_path,
+                    line=node.lineno,
+                    col=node.col_offset,
+                    category="unpatched-helper",
+                    message=_(
+                        "{func} called in test '{test}' without @patch — "
+                        'this function {desc}. Add @patch("<module>.{func}").',
+                        func=short_name,
+                        test=self._current_function.name,
+                        desc=KNOWN_SUBPROCESS_HELPERS[short_name],
+                    ),
+                )
+            )
+
+        # Check 4: Known I/O functions (filesystem/network)
+        # Match by short name (e.g. "get_pat") or full name (e.g. "requests.get")
+        sn = short_name or ""
+        io_key = sn if sn in KNOWN_IO_FUNCTIONS else None
+        if io_key is None and full_name and full_name in KNOWN_IO_FUNCTIONS:
+            io_key = full_name
+        if io_key and not (
+            io_key in all_patches
+            or sn in all_patches
+            or any(io_key in p or sn in p for p in all_patches)
+            or any(p.endswith(f".{sn}") for p in all_patches)
+            or any(
+                dep in all_patches or any(dep in p for p in all_patches) for dep in IO_INTERNAL_CALLS.get(io_key, set())
+            )
+        ):
+            self.violations.append(
+                Violation(
+                    file=self.file_path,
+                    line=node.lineno,
+                    col=node.col_offset,
+                    category="unpatched-io",
+                    message=_(
+                        "{func} called in test '{test}' without @patch — "
+                        'this function {desc}. Add @patch("<module>.{func}").',
+                        func=io_key,
+                        test=self._current_function.name,
+                        desc=KNOWN_IO_FUNCTIONS[io_key],
+                    ),
+                )
+            )
+
+        # Check 8: CliRunner.invoke / runner.invoke — trace call graph
+        # Detect runner.invoke(target, ...) or CliRunner().invoke(target, ...)
+        if short_name == "invoke" and self.call_graph is not None and node.args:
+            target = node.args[0]
+            target_name: str | None = None
+            if isinstance(target, ast.Name):
+                target_name = target.id
+            elif isinstance(target, ast.Attribute):
+                # Handle module.func pattern (e.g. build_image.main)
+                # Resolve module prefix via import_map
+                if isinstance(target.value, ast.Name):
+                    mod_short = target.value.id
+                    mod_full = self._import_map.get(mod_short)
+                    target_name = f"{mod_full}.{target.attr}" if mod_full else target.attr
+                else:
+                    target_name = target.attr
+            if target_name:
+                dangerous = self.call_graph.find_reachable_dangerous(
+                    target_name, all_patches, import_map=self._import_map
+                )
+                if dangerous:
+                    # Deduplicate by function name
+                    seen: set[str] = set()
+                    unique: list[tuple[str, str]] = []
+                    for func, desc in dangerous:
+                        if func not in seen:
+                            seen.add(func)
+                            unique.append((func, desc))
+                    funcs_desc = "; ".join(f"{f} ({d})" for f, d in unique[:3])
+                    self.violations.append(
+                        Violation(
+                            file=self.file_path,
+                            line=node.lineno,
+                            col=node.col_offset,
+                            category="transitive-subprocess",
+                            message=_(
+                                "CliRunner.invoke({target}) in test '{test}' reaches "
+                                "unpatched dangerous functions: {funcs}. "
+                                "Add @patch for each or patch the calling function.",
+                                target=target_name,
+                                test=self._current_function.name,
+                                funcs=funcs_desc,
+                            ),
+                        )
+                    )
+
+        self.generic_visit(node)
+
+    def visit_For(self, node: ast.For) -> None:
+        if self._current_function is not None and isinstance(node.iter, ast.Call):
+            count = _get_range_count(node.iter)
+            if count is not None and count > self.max_loop_iterations:
+                self.violations.append(
+                    Violation(
+                        file=self.file_path,
+                        line=node.lineno,
+                        col=node.col_offset,
+                        category="excessive-iterations",
+                        message=_(
+                            "Loop with {count} iterations in test '{test}' — "
+                            "consider property-based testing (hypothesis) or reduce to <= {max} iterations.",
+                            count=count,
+                            test=self._current_function.name,
+                            max=self.max_loop_iterations,
+                        ),
+                    )
+                )
+        self.generic_visit(node)
+
+
+# ── File scanning (shared by CLI and pytest plugin) ──────────────────────────
+
+
+def find_test_files(test_path: Path) -> list[Path]:
+    """Find all Python test files under the given path."""
+    if test_path.is_file():
+        return [test_path] if test_path.suffix == ".py" else []
+    return sorted(test_path.rglob("test_*.py"))
+
+
+def analyze_file(
+    file_path: Path,
+    max_loop_iterations: int = DEFAULT_MAX_LOOP_ITERATIONS,
+    call_graph: CallGraph | None = None,
+) -> list[Violation]:
+    """Analyze a single test file for isolation violations.
+
+    Files in ``integration/`` directories are skipped — integration tests
+    intentionally do real I/O (subprocess, network, filesystem).
+    """
+    if "integration" in file_path.parts:
+        return []
+    try:
+        source = file_path.read_text()
+        tree = ast.parse(source, filename=str(file_path))
+    except SyntaxError as exc:
+        return [
+            Violation(
+                file=file_path,
+                line=exc.lineno or 0,
+                col=exc.offset or 0,
+                category="syntax-error",
+                message=f"Could not parse file: {exc}",
+            )
+        ]
+
+    visitor = TestIsolationVisitor(file_path, max_loop_iterations, call_graph)
+    visitor.visit(tree)
+    return visitor.violations
+
+
+def analyze_test_files(
+    test_path: Path,
+    max_loop_iterations: int = DEFAULT_MAX_LOOP_ITERATIONS,
+    categories: set[str] | None = None,
+    call_graph: CallGraph | None = None,
+) -> list[Violation]:
+    """Analyze all test files under test_path. Returns list of violations."""
+    test_files = find_test_files(test_path)
+    all_violations: list[Violation] = []
+    for file_path in test_files:
+        violations = analyze_file(file_path, max_loop_iterations, call_graph)
+        if categories:
+            violations = [v for v in violations if v.category in categories]
+        all_violations.extend(violations)
+    return all_violations
+
+
+# ── Pytest plugin ─────────────────────────────────────────────────────────────
+#
+# When devx is installed, pytest auto-discovers this plugin via the
+# `pytest11` entry point.  The plugin runs static analysis on every
+# test file during collection and **fails** on any violation.
+# It also wraps subprocess at runtime to catch transitive leaks.
+
+
+def pytest_addoption(parser):  # type: ignore[no-untyped-def]  # pragma: no cover
+    """Register pytest command-line options."""
+    parser.addoption(
+        "--no-test-isolation",
+        action="store_true",
+        default=False,
+        help="Disable test isolation static analysis and runtime subprocess audit.",
+    )
+    parser.addoption(
+        "--test-isolation-max-loop",
+        type=int,
+        default=DEFAULT_MAX_LOOP_ITERATIONS,
+        help=f"Max iterations allowed in a test loop (default: {DEFAULT_MAX_LOOP_ITERATIONS}).",
+    )
+
+
+def pytest_collection_finish(session):  # type: ignore[no-untyped-def]  # pragma: no cover
+    """Run static analysis after all test files are collected. Always strict."""
+    if session.config.getoption("--no-test-isolation"):
+        return
+
+    max_loop = session.config.getoption("--test-isolation-max-loop")
+
+    # Build call graph from source directory for transitive analysis
+    call_graph: CallGraph | None = None
+    for item in session.items:
+        fspath = Path(str(item.fspath))
+        for parent in fspath.parents:
+            src_dir = parent / "src"
+            if src_dir.is_dir():
+                call_graph = CallGraph(src_dir)
+                break
+        if call_graph is not None:
+            break
+
+    test_files: set[Path] = set()
+    for item in session.items:
+        test_files.add(Path(str(item.fspath)))
+
+    all_violations: list[Violation] = []
+    for file_path in sorted(test_files):
+        violations = analyze_file(file_path, max_loop, call_graph)
+        all_violations.extend(violations)
+
+    if not all_violations:
+        return
+
+    # transitive-subprocess is advisory (static can't predict early exits).
+    # All other categories are hard errors.
+    errors = [v for v in all_violations if v.category != "transitive-subprocess"]
+    transitive = [v for v in all_violations if v.category == "transitive-subprocess"]
+
+    if errors:
+        count = len(errors)
+        files = len({v.file for v in errors})
+        click.echo(
+            _(
+                "\nTest isolation check FAILED: {count} violation(s) in {files} file(s).\n",
+                count=count,
+                files=files,
+            ),
+            err=True,
+        )
+        for v in sorted(errors, key=lambda x: (str(x.file), x.line)):
+            click.echo(f"  {v.format()}", err=True)
+        click.echo(
+            _(
+                "Fix: add @patch decorators or with patch() context managers "
+                "for subprocess/time.sleep calls, or patch the calling function.\n"
+            ),
+            err=True,
+        )
+        import pytest
+
+        pytest.fail(
+            f"Test isolation: {count} violation(s) found. See output above.",
+            pytrace=False,
+        )
+
+    # transitive-subprocess warnings are advisory — runtime audit is authoritative
+    if transitive:
+        import warnings
+
+        for v in sorted(transitive, key=lambda x: (str(x.file), x.line)):
+            msg = f"Test isolation advisory: {v.format()}"
+            warnings.warn(msg, UserWarning, stacklevel=2)
+
+
+# ── Runtime subprocess audit hooks ────────────────────────────────────────────
+
+
+def _is_integration_test(item: object) -> bool:
+    """Check if a test item is an integration test."""
+    markers = getattr(item, "keywords", {})
+    if "integration" in markers:
+        return True
+    fspath = str(getattr(item, "fspath", ""))
+    return "integration" in fspath
+
+
+def pytest_runtest_setup(item: object) -> None:  # type: ignore[no-untyped-def]  # pragma: no cover
+    """Start subprocess audit for non-integration tests."""
+    config = getattr(item, "config", None)
+    if config is None:
+        return
+    if config.getoption("--no-test-isolation"):
+        return
+    if _is_integration_test(item):
+        return
+    _audit.start_test()
+
+
+def pytest_runtest_teardown(item: object, nextitem: object) -> None:  # type: ignore[no-untyped-def]  # pragma: no cover
+    """Fail test if real subprocess calls were made without @patch."""
+    config = getattr(item, "config", None)
+    if config is None:
+        return
+    if config.getoption("--no-test-isolation"):
+        return
+    if _is_integration_test(item):
+        return
+    calls = _audit.stop_test()
+    if not calls:
+        return
+
+    test_name = getattr(item, "name", str(item))
+    lines = [
+        _(
+            "Real subprocess call(s) detected in test '{test}' without @patch:",
+            test=test_name,
+        )
+    ]
+    for func_name, cmd in calls:
+        lines.append(f"  {func_name}({cmd})")
+    lines.append(_('Add @patch("subprocess.run") or patch the calling function to fix this.'))
+    msg = "\n".join(lines)
+
+    import pytest
+
+    pytest.fail(msg, pytrace=False)
+
+
+# ── Standalone CLI ────────────────────────────────────────────────────────────
+
+
+@click.command()
+@click.option(
+    "--test-path",
+    "test_paths",
+    type=click.Path(exists=True, path_type=Path),
+    multiple=True,
+    default=[Path("tests/")],
+    show_default=True,
+    help="Path to test directory or file to analyze (can be specified multiple times).",
+)
+@click.option(
+    "--max-loop-iterations",
+    type=int,
+    default=DEFAULT_MAX_LOOP_ITERATIONS,
+    show_default=True,
+    help="Maximum allowed iterations in a single test loop.",
+)
+@click.option(
+    "--categories",
+    type=str,
+    default="",
+    help="Comma-separated list of categories to check (default: all). "
+    "Available: unpatched-subprocess, unpatched-sleep, unpatched-helper, "
+    "excessive-iterations, heavy-module-import, reload-without-cleanup, "
+    "transitive-subprocess",
+)
+@click.option(
+    "--src-dir",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    default=None,
+    help="Source directory for call-graph analysis (auto-detected if omitted).",
+)
+def cli(
+    test_paths: tuple[Path, ...],
+    max_loop_iterations: int,
+    categories: str,
+    src_dir: Path | None,
+) -> None:
+    """Check test files for un-hermetic patterns that cause slow or flaky tests.
+
+    Always exits non-zero on any hard violation. Transitive-subprocess
+    findings are reported as advisories (exit 0) since static analysis
+    can't predict early exits — the runtime audit is authoritative.
+    """
+    allowed: set[str] | None = None
+    if categories:
+        allowed = {c.strip() for c in categories.split(",")}
+
+    # Build call graph for transitive subprocess detection
+    call_graph: CallGraph | None = None
+    if src_dir is not None:
+        call_graph = CallGraph(src_dir)
+    else:
+        for tp in test_paths:
+            for parent in Path(tp).resolve().parents:
+                candidate = parent / "src"
+                if candidate.is_dir():
+                    call_graph = CallGraph(candidate)
+                    break
+            if call_graph is not None:
+                break
+
+    all_violations: list[Violation] = []
+    total_files = 0
+    for test_path in test_paths:
+        violations = analyze_test_files(test_path, max_loop_iterations, allowed, call_graph)
+        all_violations.extend(violations)
+        total_files += len(find_test_files(test_path))
+
+    errors = [v for v in all_violations if v.category != "transitive-subprocess"]
+    advisories = [v for v in all_violations if v.category == "transitive-subprocess"]
+
+    if not errors and not advisories:
+        click.echo(
+            _("Test isolation check passed: {count} test files analyzed, no violations found.", count=total_files)
+        )
+        sys.exit(0)
+
+    if errors:
+        click.echo(
+            _(
+                "Test isolation check FAILED: {count} violation(s) in {files} file(s).",
+                count=len(errors),
+                files=len({v.file for v in errors}),
+            ),
+            err=True,
+        )
+        click.echo("")
+        for v in sorted(errors, key=lambda x: (str(x.file), x.line)):
+            click.echo(f"  {v.format()}", err=True)
+        click.echo("")
+        click.echo(
+            _(
+                "Fix: add @patch decorators or with patch() context managers "
+                "for subprocess/time.sleep calls, or patch the calling function."
+            ),
+            err=True,
+        )
+        sys.exit(1)
+
+    # Advisories only — exit 0 but print them
+    click.echo(
+        _(
+            "Test isolation check passed with {count} advisory warning(s) in {files} file(s).",
+            count=len(advisories),
+            files=len({v.file for v in advisories}),
+        )
+    )
+    click.echo(_("Transitive-subprocess advisories (runtime audit is authoritative):"))
+    for v in sorted(advisories, key=lambda x: (str(x.file), x.line))[:10]:
+        click.echo(f"  {v.format()}")
+    if len(advisories) > 10:
+        click.echo(f"  ... and {len(advisories) - 10} more")
+    sys.exit(0)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    cli()  # pragma: no cover

src/devx/tools/clean_images.py

@@ -5,6 +5,13 @@ Queries the Gitea API for all versions of a package (container type) and
 deletes all but the most recent N versions.  The ``latest`` tag is always
 preserved if present.
 
+.. note::
+    This tool only deletes package versions via the Gitea API. The underlying
+    blob files on the Gitea server's filesystem are NOT removed by this tool
+    (Gitea 1.26.x has no built-in garbage collection). The production VM's
+    daily cleanup script (``cleanup_gitea.py``) handles filesystem blob GC
+    by querying the database for referenced blobs and removing orphaned files.
+
 Usage::
 
     # Clean up ci-base images, keep last 2 versions
@@ -28,12 +35,11 @@ Usage::
         --keep 2 \\
         --dry-run
 
-Authentication uses ``CI_GITEA_TOKEN`` environment variable.
+Authentication uses ``CI_GITEA_API_TOKEN`` environment variable (or legacy ``CI_GITEA_TOKEN``).
 """
 
 from __future__ import annotations
 
-import os
 import time
 from typing import Any
 
@@ -42,6 +48,7 @@ import requests
 
 from devx.config import GITEA_API_URL, REPO_OWNER
 from devx.i18n import _
+from devx.tokens import get_developer_token
 
 
 def list_package_versions(
@@ -57,7 +64,10 @@ def list_package_versions(
     Returns a list of version dicts, each containing at least ``version``
     and ``created_at`` fields.
     """
-    url = f"{api_url}/packages/{owner}?type=container&name={name}"
+    from urllib.parse import quote
+
+    encoded_name = quote(name, safe="")
+    url = f"{api_url}/packages/{owner}?type=container&name={encoded_name}"
     headers = {"Authorization": f"token {token}"}
     all_versions: list[dict[str, Any]] = []
     page = 1
@@ -96,7 +106,11 @@ def delete_package_version(
 
     Returns True on success, False on failure.
     """
-    url = f"{api_url}/packages/{owner}/{package_type}/{name}/{version}"
+    from urllib.parse import quote
+
+    encoded_name = quote(name, safe="")
+    encoded_version = quote(version, safe="")
+    url = f"{api_url}/packages/{owner}/{package_type}/{encoded_name}/{encoded_version}"
     headers = {"Authorization": f"token {token}"}
     for attempt in range(max_retries):
         try:
@@ -187,9 +201,10 @@ def main(
     api_url: str | None,
 ) -> None:
     """Clean up old Docker image versions from a Gitea registry."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("CI_GITEA_TOKEN environment variable required"))
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("CI_GITEA_TOKEN environment variable required")) from None
     if not owner:
         owner = REPO_OWNER
     if not owner:

src/devx/tools/configure_repo.py

@@ -7,8 +7,8 @@ ci-improvement, doc-improvement, workflow-improvement) are created
 idempotently via ``ensure_label``.
 
 Usage:
-  CI_GITEA_TOKEN=<token> python3 -m devx.tools.configure_repo --repo my-repo
-  CI_GITEA_TOKEN=<token> python3 -m devx.tools.configure_repo --repo my-repo --owner my-org
+  DEVELOPER_GITEA_API_TOKEN=<token> python3 -m devx.tools.configure_repo --repo my-repo
+  DEVELOPER_GITEA_API_TOKEN=<token> python3 -m devx.tools.configure_repo --repo my-repo --owner my-org
 """
 
 from __future__ import annotations
@@ -23,6 +23,7 @@ from devx.api_clients import GiteaClient
 from devx.config import GITEA_API_URL, REPO_NAME, REPO_OWNER
 from devx.exceptions import APIError
 from devx.i18n import _
+from devx.tokens import get_developer_token
 
 
 def _default_status_checks() -> list[str]:
@@ -175,7 +176,10 @@ def configure_repo(
 )
 def main(repo: str | None, owner: str | None, branch: str, api_url: str | None) -> None:
     """Configure branch protection and repository settings via the Gitea API."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("ERROR: CI_GITEA_TOKEN is not set.")) from None
 
     if repo is None:
         repo = os.environ.get("DEVX_REPO_NAME", "") or REPO_NAME

src/devx/tools/create_pr.py

@@ -42,6 +42,7 @@ from devx.config import (
     VIKUNJA_PROJECT_ID,
 )
 from devx.i18n import _
+from devx.tokens import get_developer_token, get_vikunja_token
 
 load_dotenv()
 
@@ -72,9 +73,10 @@ def get_vikunja_task_title(task_id: str) -> str:
 
     Raises ClickException if VIKUNJA_TOKEN is not set or the task is not found.
     """
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("VIKUNJA_TOKEN is not set. Required to derive PR title."))
+    try:
+        token = get_vikunja_token()
+    except click.ClickException:
+        raise click.ClickException(_("VIKUNJA_TOKEN is not set. Required to derive PR title.")) from None
     client = VikunjaClient(VIKUNJA_API_URL, token)
     task = client.find_task_by_identifier(VIKUNJA_PROJECT_ID, task_id, per_page=DEFAULT_PER_PAGE)
     if not task:
@@ -118,9 +120,10 @@ def create_pr(
             ),
         )
 
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("CI_GITEA_TOKEN is not set. Required to create a PR."))
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("CI_GITEA_TOKEN is not set. Required to create a PR.")) from None
 
     vikunja_title = get_vikunja_task_title(task_id)
     pr_title = f"{task_id}: {vikunja_title}"

src/devx/tools/create_task.py

@@ -17,14 +17,13 @@ and ``DEVX_TASK_PREFIX`` environment variables (or ``.env``).
 
 from __future__ import annotations
 
-import os
-
 import click
 from dotenv import load_dotenv
 
 from devx.api_clients import VikunjaClient
 from devx.config import TASK_PREFIX, VIKUNJA_API_URL, VIKUNJA_PROJECT_ID
 from devx.i18n import _
+from devx.tokens import get_vikunja_token
 
 load_dotenv()
 
@@ -39,9 +38,10 @@ load_dotenv()
 @click.option("--project-id", type=int, default=None, help="Vikunja project ID (default: DEVX_VIKUNJA_PROJECT_ID).")
 def cli(title: str, description: str, project_id: int | None) -> None:
     """Create a Vikunja task and print its identifier."""
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("VIKUNJA_TOKEN is not set. Set it in .env or environment."))
+    try:
+        token = get_vikunja_token()
+    except click.ClickException:
+        raise click.ClickException(_("VIKUNJA_TOKEN is not set. Set it in .env or environment.")) from None
 
     pid = project_id if project_id is not None else VIKUNJA_PROJECT_ID
 

src/devx/tools/generate_badges.py

@@ -68,8 +68,8 @@ def detect_package_name(repo_root: Path) -> str | None:
     Looks for the first subdirectory under ``src/`` that contains
     an ``__init__.py`` file with ``__version__``.
 
-    Returns the package directory name (e.g., ``devx``) or ``None`` if
-    no package is found.
+    Returns the package directory name (e.g., ``devx``,
+    ``grm``) or ``None`` if no package is found.
     """
     src_dir = repo_root / "src"
     if not src_dir.is_dir():

src/devx/tools/install_tools.py

@@ -8,6 +8,7 @@ Handles installation of:
 - tea (Gitea CLI — official command-line tool for Gitea API operations)
 - hadolint (Dockerfile linter)
 - vale (prose linter for documentation quality)
+- promtool (Prometheus rule validator)
 
 Each tool is installed to ``~/.local/bin`` if not already on PATH.
 Idempotent: skips tools that are already available.
@@ -21,31 +22,52 @@ Usage::
 
 from __future__ import annotations
 
+import logging
 import os
 import platform
 import shutil
 import tarfile
 import tempfile
+import time
+import urllib.error
 import urllib.request
 from pathlib import Path
 
 import click
+from tenacity import (
+    Retrying,
+    before_sleep_log,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
 
 TARGET_DIR = Path.home() / ".local" / "bin"
 
+logger = logging.getLogger(__name__)
+
+# Retry configuration for transient network failures during download.
+# GitHub releases occasionally drops connections ("Remote end closed
+# connection without response"). Retrying with backoff before falling
+# through to the next fallback URL makes the build resilient to
+# momentary network blips.
+MAX_DOWNLOAD_RETRIES = 3
+
 ACTIONLINT_VERSION = "1.7.12"
 
-GIT_CLIFF_VERSION = "2.13.0"
+GIT_CLIFF_VERSION = "2.13.1"
 
 ACT_RUNNER_VERSION = "0.2.11"
 
-TEA_VERSION = "0.14.1"
+TEA_VERSION = "0.14.2"
 
-HADOLINT_VERSION = "2.12.0"
+HADOLINT_VERSION = "2.14.0"
 
 TOFU_VERSION = "1.12.3"
 
-VALE_VERSION = "3.12.0"
+VALE_VERSION = "3.15.1"
+
+PROMTOOL_VERSION = "3.5.5"
 
 
 def _arch() -> str:
@@ -61,9 +83,51 @@ def _ensure_target_dir() -> Path:
     return TARGET_DIR
 
 
-def _download(url: str, dest: Path) -> None:
-    """Download a file from ``url`` to ``dest``."""
-    urllib.request.urlretrieve(url, dest)  # nosec B310
+def _download(url: str, dest: Path, *, _sleep=None) -> None:
+    """Download a file from ``url`` to ``dest`` with retry and 60s timeout.
+
+    Retries up to ``MAX_DOWNLOAD_RETRIES`` times on transient network
+    errors (``URLError``, ``OSError`` from connection resets) using
+    exponential backoff. This handles momentary GitHub releases
+    connection drops that were causing CI image builds to fail.
+
+    The ``_sleep`` kwarg is for tests to avoid real sleeping; production
+    code should leave it as ``None`` (uses ``time.sleep``).
+    """
+    retrying = Retrying(
+        stop=stop_after_attempt(MAX_DOWNLOAD_RETRIES),
+        wait=wait_exponential(multiplier=2, min=2, max=10),
+        retry=retry_if_exception_type((urllib.error.URLError, OSError, ConnectionError)),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+        sleep=_sleep if _sleep is not None else time.sleep,
+        reraise=True,
+    )
+    retrying(_do_download, url, dest)
+
+
+def _do_download(url: str, dest: Path) -> None:
+    """Single download attempt — called by :func:`_download` retry wrapper."""
+    with urllib.request.urlopen(url, timeout=60) as resp, open(dest, "wb") as f:  # nosec B310
+        shutil.copyfileobj(resp, f)
+
+
+def _download_with_fallback(urls: list[str], binary_name: str) -> Path:
+    """Try downloading a binary from a list of URLs, falling back on failure.
+
+    Returns the path to the installed binary. Raises if all URLs fail.
+    """
+    target_dir = _ensure_target_dir()
+    dest = target_dir / binary_name
+    errors: list[str] = []
+    for url in urls:
+        try:
+            _download(url, dest)
+            dest.chmod(0o755)
+            return dest
+        except Exception as exc:  # noqa: BLE001
+            errors.append(f"{url}: {exc}")
+            click.echo(f"  {binary_name}: retrying — {exc}")
+    raise click.ClickException(f"Failed to download {binary_name} from all URLs: {'; '.join(errors)}")
 
 
 def _download_and_extract_tarball(url: str, binary_name: str) -> Path:
@@ -160,8 +224,13 @@ def install_tea() -> bool:
         click.echo("tea: already installed")
         return True
     arch = _arch()
-    url = f"https://dl.gitea.com/tea/{TEA_VERSION}/tea-{TEA_VERSION}-linux-{arch}"
-    dest = _download_binary(url, "tea")
+    # dl.gitea.com is the primary CDN, but it can return 403 from some networks.
+    # Fall back to the gitea.com release downloads URL.
+    urls = [
+        f"https://dl.gitea.com/tea/{TEA_VERSION}/tea-{TEA_VERSION}-linux-{arch}",
+        f"https://gitea.com/gitea/tea/releases/download/v{TEA_VERSION}/tea-{TEA_VERSION}-linux-{arch}",
+    ]
+    dest = _download_with_fallback(urls, "tea")
     click.echo(f"tea: installed to {dest}")
     return True
 
@@ -212,7 +281,26 @@ def install_vale() -> bool:
     return True
 
 
-TOOL_NAMES = ["actionlint", "git-cliff", "act_runner", "tea", "hadolint", "tofu", "vale"]
+def install_promtool() -> bool:
+    """Install promtool (Prometheus rule validator) if not already present.
+
+    Downloads the official Prometheus release tarball from GitHub and
+    extracts the ``promtool`` binary to ``~/.local/bin``.
+    """
+    if _is_installed("promtool"):
+        click.echo("promtool: already installed")
+        return True
+    arch = _arch()
+    url = (
+        f"https://github.com/prometheus/prometheus/releases/download/"
+        f"v{PROMTOOL_VERSION}/prometheus-{PROMTOOL_VERSION}.linux-{arch}.tar.gz"
+    )
+    dest = _download_and_extract_tarball(url, "promtool")
+    click.echo(f"promtool: installed to {dest}")
+    return True
+
+
+TOOL_NAMES = ["actionlint", "git-cliff", "act_runner", "tea", "hadolint", "tofu", "vale", "promtool"]
 
 
 def _install_tool(name: str) -> bool:
@@ -231,6 +319,8 @@ def _install_tool(name: str) -> bool:
         return install_tofu()
     if name == "vale":
         return install_vale()
+    if name == "promtool":
+        return install_promtool()
     raise click.ClickException(f"Unknown tool: {name}")
 
 

src/devx/tools/pr_label.py

@@ -22,14 +22,13 @@ The repository is auto-detected from ``DEVX_REPO_OWNER`` /
 
 from __future__ import annotations
 
-import os
-
 import click
 from dotenv import load_dotenv
 
 from devx.api_clients import GiteaClient
 from devx.config import GITEA_API_URL, REPO_OWNER
 from devx.i18n import _
+from devx.tokens import get_developer_token
 from devx.tools.create_pr import get_repo_name
 from devx.tools.pr_status import _get_current_branch_pr
 
@@ -48,9 +47,10 @@ def cli(
     repo: str | None,
 ) -> None:
     """Add one or more labels to a pull request (idempotent)."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("CI_GITEA_TOKEN is not set."))
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("CI_GITEA_TOKEN is not set.")) from None
 
     repo_owner = owner or REPO_OWNER
     if not repo_owner:

src/devx/tools/pr_logs.py

@@ -25,14 +25,13 @@ The repository is auto-detected from ``DEVX_REPO_OWNER`` /
 
 from __future__ import annotations
 
-import os
-
 import click
 from dotenv import load_dotenv
 
 from devx.api_clients import APIError, GiteaClient
 from devx.config import GITEA_API_URL, REPO_OWNER
 from devx.i18n import _
+from devx.tokens import get_developer_token
 from devx.tools.create_pr import get_repo_name
 from devx.tools.pr_status import _get_current_branch_pr
 
@@ -126,9 +125,10 @@ def cli(
     repo: str | None,
 ) -> None:
     """Fetch logs for failed CI jobs on a pull request."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("CI_GITEA_TOKEN is not set."))
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("CI_GITEA_TOKEN is not set.")) from None
 
     repo_owner = owner or REPO_OWNER
     if not repo_owner:

src/devx/tools/pr_rebase.py

@@ -32,6 +32,7 @@ from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnk
 from devx.api_clients import APIError, GiteaClient
 from devx.config import GITEA_API_URL
 from devx.i18n import _
+from devx.tokens import get_developer_token
 from devx.tools._shared import detect_pr_number
 
 
@@ -41,9 +42,10 @@ def main(pr: int | None) -> None:
     """Rebase a pull request's head branch onto master via Gitea API."""
     load_dotenv()
 
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("CI_GITEA_TOKEN is not set. Add it to .env or export it."))
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("CI_GITEA_TOKEN is not set. Add it to .env or export it.")) from None
 
     pr_num = pr or detect_pr_number()
     if not pr_num:

src/devx/tools/pr_status.py

@@ -24,7 +24,6 @@ The repository is auto-detected from ``DEVX_REPO_OWNER`` /
 
 from __future__ import annotations
 
-import os
 import subprocess  # nosec B404
 import time
 
@@ -34,6 +33,7 @@ from dotenv import load_dotenv
 from devx.api_clients import GiteaClient
 from devx.config import GITEA_API_URL, REPO_OWNER
 from devx.i18n import _
+from devx.tokens import get_developer_token
 from devx.tools.create_pr import get_repo_name
 
 load_dotenv()
@@ -139,9 +139,10 @@ def cli(
     repo: str | None,
 ) -> None:
     """Check CI status for a pull request or commit."""
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        raise click.ClickException(_("CI_GITEA_TOKEN is not set."))
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        raise click.ClickException(_("CI_GITEA_TOKEN is not set.")) from None
 
     repo_owner = owner or REPO_OWNER
     if not repo_owner:

src/devx/tools/pre_push_check.py

@@ -20,7 +20,6 @@ Exit codes:
 
 from __future__ import annotations
 
-import os
 import subprocess  # nosec B404
 
 import click
@@ -29,6 +28,7 @@ from dotenv import load_dotenv
 from devx.api_clients import VikunjaClient
 from devx.config import DEFAULT_PER_PAGE, TASK_ID_RE, TASK_PREFIX, VIKUNJA_API_URL, VIKUNJA_PROJECT_ID
 from devx.i18n import _
+from devx.tokens import get_vikunja_token
 
 load_dotenv()
 
@@ -55,8 +55,9 @@ def task_exists(task_id: str) -> bool:
 
     Returns ``False`` if VIKUNJA_TOKEN is not set (soft-fail in local mode).
     """
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
+    try:
+        token = get_vikunja_token()
+    except click.ClickException:
         return False
     client = VikunjaClient(VIKUNJA_API_URL, token)
     return client.find_task_by_identifier(VIKUNJA_PROJECT_ID, task_id, per_page=DEFAULT_PER_PAGE) is not None
@@ -84,8 +85,9 @@ def validate(branch: str) -> None:
             )
         )
 
-    token = os.environ.get("VIKUNJA_TOKEN", "")
-    if not token:
+    try:
+        get_vikunja_token()
+    except click.ClickException:
         click.echo(
             _(
                 "WARNING: VIKUNJA_TOKEN not set — skipping task existence check. "

src/devx/tools/setup.py

@@ -15,6 +15,9 @@ from pathlib import Path
 
 import click
 from dotenv import load_dotenv  # pyright: ignore[reportMissingImports,reportUnknownVariableType]
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from devx.tokens import get_developer_token
 
 load_dotenv()
 
@@ -54,29 +57,39 @@ def _install_pre_commit_hooks(bin_dir: str) -> None:
 
 
 def _install_ansible_collections(bin_dir: str) -> None:
-    """Install required Ansible Galaxy collections if requirements exist."""
+    """Install required Ansible Galaxy collections if requirements exist.
+
+    Retries up to 3 times with exponential backoff to handle transient
+    network timeouts when contacting galaxy.ansible.com.
+    """
     galaxy = shutil.which("ansible-galaxy") or str(Path(bin_dir) / "ansible-galaxy")
     requirements = Path("ansible/requirements.yml")
     if not requirements.exists():
         click.echo("  ansible/requirements.yml not found — skipping collections.")
         return
-    _run([galaxy, "collection", "install", "-r", str(requirements)])
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=2, min=2, max=10), reraise=True)
+    def _do_install() -> None:
+        _run([galaxy, "collection", "install", "-r", str(requirements)])
+
+    _do_install()
 
 
 def _configure_tea_login() -> None:
-    """Configure tea CLI login from .env if CI_GITEA_TOKEN is set.
+    """Configure tea CLI login from .env if a Gitea token is set.
 
     Idempotent: if a login with the same name already exists, it is not re-added.
-    Skips if tea is not installed or CI_GITEA_TOKEN is not set.
+    Skips if tea is not installed or no Gitea token is set.
     """
     tea_bin = shutil.which("tea")
     if tea_bin is None:
         click.echo("tea: not installed — run 'make install-tools' to install it.")
         return
 
-    token = os.environ.get("CI_GITEA_TOKEN", "")
-    if not token:
-        click.echo("tea: CI_GITEA_TOKEN not set — skipping login configuration.")
+    try:
+        token = get_developer_token()
+    except click.ClickException:
+        click.echo("tea: Gitea API token not set — skipping login configuration.")
         return
 
     api_url = os.environ.get("DEVX_GITEA_API_URL", "https://git.oblachno.oblachno.fyi/api/v1")