fix(strix): recognize orchestrator/auto in is_contextual_orchestrator_model

.github/workflows/opencode-review.yml

@@ -197,7 +197,6 @@ jobs:
           fi
 
       - name: Enforce Cloudflare Pingora edge policy
-        if: ${{ github.event_name == 'pull_request_target' }}
         env:
           GITHUB_TOKEN: ${{ github.token }}
           TARGET_REPOSITORY: ${{ github.event.pull_request.base.repo.full_name || github.repository }}

CHANGELOG.md

@@ -5,6 +5,9 @@ this file. The format follows Keep a Changelog, and versioned releases follow
 Semantic Versioning where the repository publishes a release.
 
 ## [Unreleased]
+- Keep the required OpenCode bootstrap's Pingora policy step unconditional
+  within its pull-request-only workflow, so the static bootstrap contract does
+  not depend on event payload fields.
 - Skip trusted base Python lock materialization for exact-head reviews with no
   Python source or dependency-manifest changes, while preserving the
   fail-closed wheel-only path when Python coverage is relevant.
@@ -18,6 +21,9 @@ Semantic Versioning where the repository publishes a release.
   existing `orchestrator/free` route or the provider-diverse
   `orchestrator/auto` route. This provides a fail-closed two-phase migration
   path without admitting direct-provider model identifiers.
+- Normalize an optional `contextual-orchestrator/` provider prefix before
+  qualifying the Strix sidecar child model, preventing invalid double-prefixed
+  gateway model ids.
 - Give stacked pull requests a separately bounded organization-sweep
   OpenCode dispatch budget, so default-branch review traffic cannot leave a
   stacked PR at `OpenCode review absent` without changing the protected merge

docs/product-technical-gap-baseline.md

@@ -396,6 +396,67 @@ flowchart LR
   or typed provider result. A green event handler that skips the LLM call is not
   acceptance evidence.
 
+## 2026-08-30 org-wide Strix `orchestrator/auto` recognition gap
+
+- Root cause found for the identical `Strix Security Scan/strix: failure —
+  Default-branch repository_dispatch Strix evidence failed` seen across many
+  unrelated open PRs (#1414, #789, #1382, #1276, and others): #1401 (commit
+  `e94f1d12`) renamed Strix's primary contextual-orchestrator model from
+  `orchestrator/free` to `orchestrator/auto` throughout `strix.yml` and its
+  contract tests, but left `scripts/ci/strix_quick_gate.sh`'s
+  `is_contextual_orchestrator_model()` recognizing only the old
+  `orchestrator/free` spelling. `resolved_llm_api_base_for_model()` then
+  treated `orchestrator/auto` as a non-gateway model and rejected the pinned
+  loopback sidecar base (`http://127.0.0.1:18080/v1`) under its https-only
+  check, exiting 2 with `LLM_API_BASE must be an https URL when configured`
+  before any scan could start. This did not fail #1401's own CI because
+  `pull_request_target` required workflows run the *base* branch's trusted
+  workflow file (pre-rename at the time); the new-workflow/old-gate-script
+  mismatch became observable only on PRs opened after #1401 merged into
+  `main` — the same trusted-workflow-deadlock shape #1401 itself broke.
+- Fix opened as `.github` PR #1421
+  (`fix/strix-orchestrator-auto-model-recognition`): teaches
+  `is_contextual_orchestrator_model()` both pool spellings
+  (`CONTEXTUAL_ORCHESTRATOR_POOL` supports `free` and `auto`; the gateway's
+  `TaskOrchestrator.AUTO_MODEL` / `FREE_MODEL` are real, distinct sentinels),
+  makes `child_model_for_api_base()` qualify the child-process model from the
+  actually-resolved `$model` instead of a hardcoded `openai/orchestrator/free`
+  literal, stripping an optional `contextual-orchestrator/` provider prefix so
+  LiteLLM receives exactly one `openai/` prefix, and refreshes two
+  `STRIX_PROVIDER_UNAVAILABLE` log lines to name the real primary model. Adds a mirrored `orchestrator/auto` scenario to
+  `scripts/ci/test_strix_quick_gate.sh` and a new Python regression in
+  `tests/test_strix_openai_fallback_api_base.py`. Full suite: 1,874 passed, 1
+  skipped (pre-existing); interrogate 100%. This PR's own Strix check is
+  expected to reproduce the exact bug it fixes until it merges, for the same
+  base-branch-trust-boundary reason described above; not yet merged this
+  cycle — left for human/admin merge or the next hourly pass once other
+  required checks and OpenCode review land clean.
+- `.github` PR #1233 (`fix/organization-loop-oidc-fallback`) had drifted to a
+  real `mergeable_state: dirty` (not just the Strix failure above): `main`
+  had advanced past its last merge-main commit. Merged current `main` in,
+  resolved one additive `CHANGELOG.md` conflict, reran the full suite (1,876
+  passed, 1 skipped) plus interrogate (100%), and pushed to the existing head
+  — now `mergeable_state: blocked` (conflict-free, awaiting checks/review).
+- Of the three mechanical Action-version-pin PRs named for recheck: #1274
+  (CodeQL v4.37.7) was superseded by #1307 already on `main` (v4.37.8) —
+  merging it would have downgraded the pin, so it was closed as superseded.
+  #1275 (Scorecard v2.4.4) and #1276 (OSV-Scanner v2.5.1) were both still
+  needed and both had real `dirty` merge conflicts against current `main`
+  (same drift pattern as #1233, unrelated to Strix); both were merged with
+  current `main`, revalidated (full suite green, interrogate 100%, target
+  Action pin confirmed post-merge), and pushed — both now `blocked` rather
+  than `dirty`.
+- #789 and #1382 also show `mergeable_state: dirty` against current `main`
+  but are large, complex, long-running PRs (49 and 76 commits respectively,
+  wide diffs); left unresolved this cycle rather than rushing a conflict
+  resolution on that scale — candidates for a dedicated future pass.
+- One pre-existing, unrelated finding surfaced while validating the above:
+  `coverage report` shows a stable 99% (`scripts/ci/pingora_edge_policy.py`
+  line 274, an apparently-unreachable >3,000-file pagination guard clause) on
+  unmodified `main` itself, independent of anything touched this cycle. Not
+  fixed here (out of scope for the Strix investigation); worth a follow-up
+  pass since this repo's coverage gate is nominally 100%-required.
+
 ## 5. 실행 루프와 고객의 다음 행동
 
 각 hourly pass는 아래 순서를 유지한다.

scripts/ci/strix_quick_gate.sh

@@ -322,7 +322,8 @@ is_vertex_model() {
 
 is_contextual_orchestrator_model() {
 	case "$1" in
-	orchestrator/free | contextual-orchestrator/orchestrator/free)
+	orchestrator/free | contextual-orchestrator/orchestrator/free | \
+		orchestrator/auto | contextual-orchestrator/orchestrator/auto)
 		return 0
 		;;
 	*)
@@ -2562,11 +2563,20 @@ child_model_for_api_base() {
 
 	# LiteLLM requires an explicit provider prefix even when the gateway is an
 	# OpenAI-compatible local endpoint. Keep the public gateway model name, but
-	# qualify only the child process model so the request still carries
-	# orchestrator/free to contextual-orchestrator.
+	# qualify only the child process model so the request still carries the
+	# resolved orchestrator pool (orchestrator/free or orchestrator/auto) to
+	# contextual-orchestrator. Echoing $model (rather than hardcoding one pool
+	# name) keeps this in sync with whichever pool CONTEXTUAL_ORCHESTRATOR_POOL
+	# actually selected -- see contextual_orchestrator/orchestrator.py's
+	# TaskOrchestrator.AUTO_MODEL / FREE_MODEL sentinels, which the gateway
+	# itself distinguishes by this exact string. is_contextual_orchestrator_model
+	# also accepts the contextual-orchestrator/-prefixed spellings, so strip that
+	# prefix before qualifying -- otherwise the gateway receives
+	# openai/contextual-orchestrator/orchestrator/<pool>, which doesn't match
+	# either sentinel.
 	if is_contextual_orchestrator_model "$model" &&
 		is_contextual_orchestrator_api_base "$llm_api_base_value"; then
-		printf '%s\n' 'openai/orchestrator/free'
+		printf 'openai/%s\n' "${model#contextual-orchestrator/}"
 		return 0
 	fi
 
@@ -4303,7 +4313,7 @@ run_current_target_scan() {
 	local strict_primary_provider_fallback=0
 	if [ "$INFRA_ERROR_DETECTED" -eq 1 ] && provider_signal_fail_closed_enabled; then
 		if is_contextual_orchestrator_model "$PRIMARY_MODEL"; then
-			echo "STRIX_PROVIDER_UNAVAILABLE: contextual-orchestrator/orchestrator/free exhausted; the gateway owns provider discovery and failover." >&2
+			echo "STRIX_PROVIDER_UNAVAILABLE: contextual-orchestrator/$PRIMARY_MODEL exhausted; the gateway owns provider discovery and failover." >&2
 			return 1
 		elif is_model_retryable_error "$PRIMARY_MODEL" && has_distinct_fallback_model_for_model "$PRIMARY_MODEL"; then
 			strict_primary_provider_fallback=1
@@ -4345,7 +4355,7 @@ run_current_target_scan() {
 		return 1
 	fi
 	if is_contextual_orchestrator_model "$PRIMARY_MODEL"; then
-		echo "STRIX_PROVIDER_UNAVAILABLE: contextual-orchestrator/orchestrator/free exhausted; no external fallback is permitted." >&2
+		echo "STRIX_PROVIDER_UNAVAILABLE: contextual-orchestrator/$PRIMARY_MODEL exhausted; no external fallback is permitted." >&2
 		return 1
 	fi
 

scripts/ci/test_strix_quick_gate.sh

@@ -3334,6 +3334,30 @@ success|runtime-env-forwarding|custom-openai-compatible-preserves-effort|vertex-
 		echo "scan ok through contextual-orchestrator gateway"
 		exit 0
 		;;
+	contextual-orchestrator-gateway-model-qualification-auto)
+		if [ "${STRIX_LLM:-}" != "openai/orchestrator/auto" ]; then
+			echo "gateway auto-pool model was not provider-qualified for LiteLLM" >&2
+			exit 10
+		fi
+		if [ "${LLM_API_BASE:-}" != "http://127.0.0.1:18080/v1" ]; then
+			echo "gateway API base was not preserved" >&2
+			exit 11
+		fi
+		echo "scan ok through contextual-orchestrator gateway"
+		exit 0
+		;;
+	contextual-orchestrator-gateway-model-qualification-auto-prefixed)
+		if [ "${STRIX_LLM:-}" != "openai/orchestrator/auto" ]; then
+			echo "provider-prefixed gateway auto-pool model was not stripped before qualifying for LiteLLM" >&2
+			exit 10
+		fi
+		if [ "${LLM_API_BASE:-}" != "http://127.0.0.1:18080/v1" ]; then
+			echo "gateway API base was not preserved" >&2
+			exit 11
+		fi
+		echo "scan ok through contextual-orchestrator gateway"
+		exit 0
+		;;
 	scan-working-directory-isolated)
 		if [ "$PWD" = "$target_path" ] || [[ "$PWD" == "$target_path"/* ]]; then
 			echo "Error: Strix process inherited the untrusted scan target as cwd" >&2
@@ -6105,6 +6129,30 @@ run_filtered_gate_case_if_requested() {
 			"contextual_orchestrator" \
 			"http://127.0.0.1:18080/v1"
 		;;
+	contextual-orchestrator-gateway-model-qualification-auto)
+		run_gate_case "contextual-orchestrator-gateway-model-qualification-auto" \
+			"orchestrator/auto" \
+			"" \
+			"0" \
+			"scan ok through contextual-orchestrator gateway" \
+			"1" \
+			"openai/orchestrator/auto" \
+			"http://127.0.0.1:18080/v1" \
+			"contextual_orchestrator" \
+			"http://127.0.0.1:18080/v1"
+		;;
+	contextual-orchestrator-gateway-model-qualification-auto-prefixed)
+		run_gate_case "contextual-orchestrator-gateway-model-qualification-auto-prefixed" \
+			"contextual-orchestrator/orchestrator/auto" \
+			"" \
+			"0" \
+			"scan ok through contextual-orchestrator gateway" \
+			"1" \
+			"openai/orchestrator/auto" \
+			"http://127.0.0.1:18080/v1" \
+			"contextual_orchestrator" \
+			"http://127.0.0.1:18080/v1"
+		;;
 	pr-rust-workspace-context)
 		run_gate_case "pr-rust-workspace-context" \
 			"openai/gpt-4o-mini" \
@@ -9806,6 +9854,28 @@ run_gate_case "contextual-orchestrator-gateway-model-qualification" \
 	"contextual_orchestrator" \
 	"http://127.0.0.1:18080/v1"
 
+run_gate_case "contextual-orchestrator-gateway-model-qualification-auto" \
+	"orchestrator/auto" \
+	"" \
+	"0" \
+	"scan ok through contextual-orchestrator gateway" \
+	"1" \
+	"openai/orchestrator/auto" \
+	"http://127.0.0.1:18080/v1" \
+	"contextual_orchestrator" \
+	"http://127.0.0.1:18080/v1"
+
+run_gate_case "contextual-orchestrator-gateway-model-qualification-auto-prefixed" \
+	"contextual-orchestrator/orchestrator/auto" \
+	"" \
+	"0" \
+	"scan ok through contextual-orchestrator gateway" \
+	"1" \
+	"openai/orchestrator/auto" \
+	"http://127.0.0.1:18080/v1" \
+	"contextual_orchestrator" \
+	"http://127.0.0.1:18080/v1"
+
 run_gate_case "success-with-critical-report" \
 	"vertex_ai/ready-primary" \
 	"" \

tests/test_pingora_edge_policy.py

@@ -295,6 +295,25 @@ def test_changed_file_pagination_bound_is_fail_closed() -> None:
         policy._load_changed_files("api", "a/b", 1, "x", lambda _url, _token: page)
 
 
+def test_changed_file_pagination_loop_bound_fails_closed() -> None:
+    """A claimed full page cannot bypass the hard pagination loop bound."""
+
+    class ClaimedFullPage(list[dict[str, object]]):
+        """Model a malformed adapter that reports a full page without entries."""
+
+        def __len__(self) -> int:
+            return 100
+
+    with pytest.raises(policy.PolicyError, match="3,000"):
+        policy._load_changed_files(
+            "api",
+            "a/b",
+            1,
+            "x",
+            lambda _url, _token: ClaimedFullPage(),
+        )
+
+
 def test_changed_file_pagination_accepts_the_inclusive_bound() -> None:
     """Exactly 3,000 changed files are accepted only after an empty next page."""
 

tests/test_pingora_edge_workflow_contract.py

@@ -40,7 +40,8 @@ def test_required_workflow_enforces_pingora_without_executing_pr_content() -> No
     assert '[ -L "$trusted_source_dir/$EXPECTED_FILE" ]' in text
     assert '[ ! -f "$trusted_source_dir/scripts/ci/pingora_edge_policy.py" ]' in text
     assert '[ -L "$trusted_source_dir/scripts/ci/pingora_edge_policy.py" ]' in text
-    assert "if: ${{ github.event_name == 'pull_request_target' }}" in text
+    assert "pull_request_target:" in text
+    assert "if: ${{ github.event_name == 'pull_request_target' }}" not in text
     assert text.index("Verify immutable central policy source") < text.index(
         "Enforce Cloudflare Pingora edge policy"
     )

tests/test_strix_openai_fallback_api_base.py

@@ -145,6 +145,44 @@ def _resolve_api_base(env: dict[str, str], model: str) -> tuple[int, str]:
     return completed.returncode, completed.stdout.strip()
 
 
+def _child_model(env_model: str, api_base: str) -> tuple[int, str]:
+    """Execute the production child-model qualifier for one gateway model."""
+
+    gate_source = STRIX_GATE.read_text(encoding="utf-8")
+    helper_names = (
+        "is_contextual_orchestrator_model",
+        "is_contextual_orchestrator_api_base",
+        "is_github_models_api_base",
+    )
+    helper_sources = [
+        _function_block(gate_source, name)
+        for name in helper_names
+    ]
+    child_source = _function_block(gate_source, "child_model_for_api_base")
+    completed = subprocess.run(
+        [
+            "bash",
+            "-c",
+            "\n".join(
+                [
+                    "set -euo pipefail",
+                    *helper_sources,
+                    child_source,
+                    'child_model_for_api_base "$1" "$2"',
+                ]
+            ),
+            "strix-child-model",
+            env_model,
+            api_base,
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        env={"PATH": "/usr/bin:/bin:/usr/local/bin"},
+    )
+    return completed.returncode, completed.stdout.strip()
+
+
 class ExplicitOpenAIFallbackRouting(unittest.TestCase):
     """Direct-OpenAI fallbacks must not inherit the primary provider base."""
 
@@ -247,6 +285,31 @@ def test_invalid_https_override_is_configuration_failure(self) -> None:
         self.assertEqual(rc, 2)
 
 
+class ContextualOrchestratorChildModel(unittest.TestCase):
+    """Gateway child models must preserve the actual orchestrator pool name."""
+
+    def test_provider_prefixed_gateway_model_is_not_double_qualified(self) -> None:
+        """A provider-qualified model becomes exactly one OpenAI-qualified id."""
+
+        for model, expected in (
+            (
+                "contextual-orchestrator/orchestrator/auto",
+                "openai/orchestrator/auto",
+            ),
+            (
+                "contextual-orchestrator/orchestrator/free",
+                "openai/orchestrator/free",
+            ),
+        ):
+            with self.subTest(model=model):
+                rc, child_model = _child_model(
+                    model,
+                    "http://127.0.0.1:18080/v1",
+                )
+                self.assertEqual(rc, 0)
+                self.assertEqual(child_model, expected)
+
+
 class WorkflowUsesContextualOrchestrator(unittest.TestCase):
     """The required workflow must expose only the local gateway route."""
 
@@ -284,6 +347,30 @@ def test_workflow_gateway_base_is_the_only_http_exception(self) -> None:
         )
         self.assertEqual(rc, 2)
 
+    def test_workflow_gateway_base_accepts_auto_pool_model(self) -> None:
+        """The auto pool (CONTEXTUAL_ORCHESTRATOR_POOL=auto) is a recognized
+        contextual-orchestrator model, not just the legacy free pool.
+
+        Regression for the #1401 rename (orchestrator/free -> orchestrator/auto
+        in strix.yml) that left is_contextual_orchestrator_model() only
+        recognizing the old free-pool spelling, which made every PR-scoped
+        Strix scan fail its https-only LLM_API_BASE check against the pinned
+        http://127.0.0.1:18080 loopback sidecar.
+        """
+
+        rc, api_base = _resolve_api_base(
+            {"LLM_API_BASE_FILE": "http://127.0.0.1:18080/v1"},
+            "orchestrator/auto",
+        )
+        self.assertEqual(rc, 0)
+        self.assertEqual(api_base, "http://127.0.0.1:18080/v1")
+
+        rc, _ = _resolve_api_base(
+            {"LLM_API_BASE_FILE": "http://127.0.0.1:18081/v1"},
+            "orchestrator/auto",
+        )
+        self.assertEqual(rc, 2)
+
     def test_manual_status_job_has_status_write_permission(self) -> None:
         """OIDC target-app exchange may request the target commit status scope."""