fix(routing): select concrete free model groups

.github/workflows/opencode-hourly-loop.yml

@@ -51,7 +51,6 @@ jobs:
   loop:
     name: Run OpenCode maintenance agent through the local gateway
     runs-on: ubuntu-latest
-    timeout-minutes: 55
     permissions:
       contents: write # required for reviewed branch fixes; scoped to this job
       pull-requests: write
@@ -68,29 +67,35 @@ jobs:
       NVIDIA_NIM_API_KEY_SUB: ${{ secrets.NVIDIA_NIM_API_KEY_SUB }}
     steps:
       - name: Checkout repository
+        timeout-minutes: 5
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # actions/checkout@v7
         with:
           persist-credentials: true # the agent needs to push fixes/branches
 
       - name: Set up Python
+        timeout-minutes: 5
         uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # actions/setup-python@v6
         with:
           python-version: "3.12"
 
       - name: Set up Node for the OpenCode CLI
+        timeout-minutes: 5
         uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # actions/setup-node@v4
         with:
           node-version: "22"
 
       - name: Install pinned runtime dependencies
+        timeout-minutes: 10
         run: python -m pip install --require-hashes -r requirements.lock
 
       - name: Install OpenCode CLI
+        timeout-minutes: 10
         run: |
           npm ci --ignore-scripts
           node scripts/ci/install_locked_opencode.mjs
 
       - name: Generate ephemeral loopback gateway token
+        timeout-minutes: 1
         run: |
           gateway_token=$(python -c 'import secrets; print(secrets.token_urlsafe(32))')
           echo "::add-mask::$gateway_token"
@@ -106,17 +111,24 @@ jobs:
             --auth-token-key CONTEXTUAL_ORCHESTRATOR_TOKEN \
             --host 127.0.0.1 --port 8000 \
             > /tmp/gateway.log 2>&1 &
-          for _attempt in $(seq 1 30); do
+          gateway_pid=$!
+          while :; do
             if curl -fsS -H "Authorization: Bearer ${CONTEXTUAL_ORCHESTRATOR_TOKEN}" \
               http://127.0.0.1:8000/healthz >/dev/null 2>&1; then
               echo "gateway ready"
               exit 0
             fi
+            if ! kill -0 "$gateway_pid" 2>/dev/null; then
+              wait "$gateway_pid" || true
+              echo "::error::gateway exited before becoming healthy"
+              tail -50 /tmp/gateway.log
+              exit 1
+            fi
             sleep 2
           done
-          echo "::error::gateway did not become healthy"; tail -50 /tmp/gateway.log; exit 1
 
       - name: Point OpenCode at the local gateway
+        timeout-minutes: 1
         run: |
           set -euo pipefail
           umask 077
@@ -142,6 +154,7 @@ jobs:
           JSON
 
       - name: Build trusted same-repository PR allowlist
+        timeout-minutes: 5
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
@@ -157,5 +170,6 @@ jobs:
             "$(cat .github/opencode/hourly-loop-prompt.md)"
 
       - name: Dump gateway log on failure
+        timeout-minutes: 5
         if: failure()
         run: tail -100 /tmp/gateway.log

CHANGELOG.d/endpoint-race-callback-settlement.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Endpoint race observer failures now settle the manually managed `Future` exactly once instead of leaving an unbounded race in a permanent `RUNNING` state. This preserves the prior executor-backed exception semantics while retaining daemon-owned race workers that cannot block interpreter shutdown. Regression coverage exercises callback failures after both successful and failed provider attempts with `deadline_seconds=None`.

CHANGELOG.d/openrouter-not-evidence-only.md

@@ -0,0 +1 @@
+Stopped treating OpenRouter as a whole-account, ZDR-motivated serving exclusion. `PROVIDER_MODEL_SOURCES`'s `openrouter` entry no longer sets `evidence_only=True`: ZDR eligibility is a route/model-level property, never grounds to block an entire provider account from serving, and OpenRouter was the one provider source with genuinely reliable native pricing/`is_free` evidence, so excluding it directly caused `orchestrator/free`'s previously-documented structural emptiness (ADR 0041). Also fixed a backwards side effect of the old flag: `_apply_discovered_model_evidence` could never mark OpenRouter's own rows `zdr_capable=True` even when they exactly matched OpenRouter's own declared ZDR feed. The provider-neutral evidence-application contract from PR #901 (OpenRouter's feed also crediting matching rows from every other provider) is unchanged. Since OpenRouter can multiplex one model id across several backing providers, `ModelClient` now pins every OpenRouter request made under an active `zdr_only` scope with OpenRouter's own documented `"provider": {"zdr": true}` request-time enforcement, applied at the shared `_send`/`_stream_send`/`_send_raw` transport chokepoints, and at the async Batch API path (`_batch_run`) via the same helper on each uploaded JSONL request body.

CHANGELOG.d/provider-embedding-daemon-worker-pool.md

@@ -0,0 +1,5 @@
+### Fixed
+
+- `ProviderEmbeddingBatchBackend` (`batch_routing.py`) no longer drives its durable job queue through a `concurrent.futures.ThreadPoolExecutor`. That executor's worker threads register with `concurrent.futures.thread`'s own interpreter-exit hook, which unconditionally joins every still-running worker at shutdown regardless of daemon status; combined with this org's default no-deadline `ModelClient.timeout=None` policy, a provider embedding runner that never returned would block process shutdown forever even after `close()`. A private `_DaemonWorkerPool` — a fixed-size pool of `threading.Thread(daemon=True)` workers pulling from a queue, exposing the same `submit()`/`shutdown()` surface — replaces it at every construction site while every durability/claim/recovery/publish guarantee is unchanged. Regression coverage runs a hung provider embedding runner in a separate interpreter and confirms normal process exit after `close()`.
+- `_DaemonWorkerPool.submit()` now fails closed with `RuntimeError` once `shutdown()` has run, matching `ThreadPoolExecutor.submit`'s closed-pool contract, instead of silently queuing a task behind the shutdown sentinels where no worker would ever pick it up.
+- `_DaemonWorkerPool.shutdown()` now closes admission (`self._shutdown = True`) atomically under `_workers_lock` before draining the queue or queuing stop sentinels, instead of draining first. Previously a `submit()` that landed between the drain and the flag being set could enqueue work that survived `cancel_futures=True` and later ran on a worker despite the cancellation. `shutdown()` remains idempotent (a repeated call skips re-draining/re-queuing and only joins the already-captured workers).