10 changed files with 62 additions and 1109 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -2,7 +2,7 @@ name: CI
 on: [push, pull_request]
 jobs:
  validate:
-    uses: molecule-ai/molecule-ci/.github/workflows/validate-workspace-template.yml@main
+    uses: Molecule-AI/molecule-ci/.github/workflows/validate-workspace-template.yml@main

  tests:
    name: Adapter unit tests
--- a/.github/workflows/publish-image.yml
+++ b/.github/workflows/publish-image.yml
@ -32,47 +32,14 @@ permissions:
  packages: write

 jobs:
-  # The `.runtime-version` file is the push-mode cascade signal post-
-  # 2026-05-06: when molecule-core/publish-runtime.yml ships a new
-  # version to PyPI, it does NOT call repository_dispatch (Gitea 1.22.6
-  # has no such endpoint — empirically verified molecule-core#20).
-  # Instead it git-pushes an updated `.runtime-version` to each template,
-  # which trips this workflow's `on: push: branches: [main]` trigger.
-  # This job reads that file and forwards the version to the reusable
-  # build workflow so the Dockerfile pip-installs the exact published
-  # version, not whatever requirements.txt currently bounds.
-  resolve-version:
-    runs-on: ubuntu-latest
-    timeout-minutes: 2
-    outputs:
-      version: ${{ steps.read.outputs.version }}
-    steps:
-      - uses: actions/checkout@v4
-      - id: read
-        run: |
-          if [ -f .runtime-version ]; then
-            v="$(head -n1 .runtime-version | tr -d '[:space:]')"
-            echo "version=$v" >> "$GITHUB_OUTPUT"
-            echo "resolved runtime version: $v"
-          else
-            echo "no .runtime-version file present — falling through to Dockerfile default"
-          fi
-
  publish:
-    needs: resolve-version
-    uses: molecule-ai/molecule-ci/.github/workflows/publish-template-image.yml@main
+    uses: Molecule-AI/molecule-ci/.github/workflows/publish-template-image.yml@main
    secrets: inherit
    with:
-      # Resolution chain (highest priority first):
-      #   1. client_payload.runtime_version — legacy GitHub
-      #      repository_dispatch path (will return if Gitea ever adds
-      #      the dispatch API; left in place for forward-compat).
-      #   2. inputs.runtime_version — manual workflow_dispatch run from
-      #      the Actions UI for ad-hoc rebuilds against a specific
-      #      version.
-      #   3. needs.resolve-version.outputs.version — the
-      #      `.runtime-version` file in this repo, written by
-      #      molecule-core/publish-runtime.yml's push-mode cascade.
-      #   4. '' — fall through to the Dockerfile default
-      #      (requirements.txt pin).
-      runtime_version: ${{ github.event.client_payload.runtime_version || inputs.runtime_version || needs.resolve-version.outputs.version || '' }}
+      # When the cascade fires, client_payload.runtime_version is the
+      # exact version PyPI just published. Forwarded to the reusable
+      # workflow as a docker --build-arg so the cache key changes
+      # per-version and pip install resolves freshly.
+      # On other events (push to main / manual without input), this is
+      # empty and the Dockerfile's default (requirements.txt pin) applies.
+      runtime_version: ${{ github.event.client_payload.runtime_version || inputs.runtime_version || '' }}
--- a/.github/workflows/secret-scan.yml
+++ b/.github/workflows/secret-scan.yml
@ -1,201 +1,22 @@
 name: Secret scan

-# Hard CI gate. Refuses any PR / push whose diff additions contain a
-# recognisable credential. Defense-in-depth for the #2090-class incident
-# (2026-04-24): GitHub's hosted Copilot Coding Agent leaked a ghs_*
-# installation token into tenant-proxy/package.json via `npm init`
-# slurping the URL from a token-embedded origin remote. We can't fix
-# upstream's clone hygiene, so we gate here.
+# Calls the canonical reusable workflow in molecule-core. Defense
+# against the #2090-class leak (a hosted-agent commit slipping a
+# credential-shaped string into a PR). Pattern set lives in
+# molecule-core so we do not maintain a parallel copy here.
 #
-# Inlined copy from molecule-ai/molecule-core/.github/workflows/secret-scan.yml.
-# Cross-repo workflow_call to a private repo doesn't fully work on Gitea 1.22.6
-# (workflow file fails parse-time at 0s with no logs); inline keeps the gate
-# functional until Gitea is upgraded or the canonical scanner moves to a public
-# repo. When that lands, this file reverts to the 3-line wrapper:
-#
-#   jobs:
-#     secret-scan:
-#       uses: Molecule-AI/molecule-core/.github/workflows/secret-scan.yml@staging
-#
-# Pin to @staging not @main — staging is the active default branch,
-# main lags via the staging-promotion workflow. Updates ride along
-# automatically on the next consumer workflow run.
-#
-# Same regex set as the runtime's bundled pre-commit hook
-# (molecule-ai-workspace-runtime: molecule_runtime/scripts/pre-commit-checks.sh).
-# Keep the two sides aligned when adding patterns.
+# Pinned to @staging because that is the active default branch on the
+# upstream repo (main lags behind via the staging-promotion workflow).
+# Updates ride along automatically as the upstream regex set evolves.

 on:
  pull_request:
    types: [opened, synchronize, reopened]
  push:
-    branches: [main, staging]
+    branches: [main, staging, master]
+  merge_group:
+    types: [checks_requested]

 jobs:
-  scan:
-    name: Scan diff for credential-shaped strings
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          fetch-depth: 2  # need previous commit to diff against on push events
-
-      # For pull_request events the diff base may be many commits behind
-      # HEAD and absent from the shallow clone. Fetch it explicitly.
-      - name: Fetch PR base SHA (pull_request events only)
-        if: github.event_name == 'pull_request'
-        run: git fetch --depth=1 origin ${{ github.event.pull_request.base.sha }}
-
-      # For merge_group events the queue's pre-merge ref is a commit on
-      # `gh-readonly-queue/...` whose parent is the queue's base_sha.
-      # That parent isn't part of the queue branch's shallow clone, so
-      # we fetch it explicitly. Without this the diff falls through to
-      # "no BASE → scan entire tree" mode and false-positives on legit
-      # test fixtures (e.g. canvas/src/lib/validation/__tests__/secret-formats.test.ts).
-
-      - name: Refuse if credential-shaped strings appear in diff additions
-        env:
-          # Plumb event-specific SHAs through env so the script doesn't
-          # need conditional `${{ ... }}` interpolation per event type.
-          # github.event.before/after only exist on push events;
-          # merge_group has its own base_sha/head_sha; pull_request has
-          # pull_request.base.sha / pull_request.head.sha.
-          PR_BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-          PUSH_BEFORE: ${{ github.event.before }}
-          PUSH_AFTER: ${{ github.event.after }}
-        run: |
-          # Pattern set covers GitHub family (the actual #2090 vector),
-          # Anthropic / OpenAI / Slack / AWS. Anchored on prefixes with low
-          # false-positive rates against agent-generated content. Mirror of
-          # molecule-ai-workspace-runtime/molecule_runtime/scripts/pre-commit-checks.sh
-          # — keep aligned.
-          SECRET_PATTERNS=(
-            'ghp_[A-Za-z0-9]{36,}'           # GitHub PAT (classic)
-            'ghs_[A-Za-z0-9]{36,}'           # GitHub App installation token
-            'gho_[A-Za-z0-9]{36,}'           # GitHub OAuth user-to-server
-            'ghu_[A-Za-z0-9]{36,}'           # GitHub OAuth user
-            'ghr_[A-Za-z0-9]{36,}'           # GitHub OAuth refresh
-            'github_pat_[A-Za-z0-9_]{82,}'   # GitHub fine-grained PAT
-            'sk-ant-[A-Za-z0-9_-]{40,}'      # Anthropic API key
-            'sk-proj-[A-Za-z0-9_-]{40,}'     # OpenAI project key
-            'sk-svcacct-[A-Za-z0-9_-]{40,}'  # OpenAI service-account key
-            'sk-cp-[A-Za-z0-9_-]{60,}'       # MiniMax API key (F1088 vector — caught only after the fact)
-            'xox[baprs]-[A-Za-z0-9-]{20,}'   # Slack tokens
-            'AKIA[0-9A-Z]{16}'               # AWS access key ID
-            'ASIA[0-9A-Z]{16}'               # AWS STS temp access key ID
-          )
-
-          # Determine the diff base. Each event type stores its SHAs in
-          # a different place — see the env block above.
-          case "${{ github.event_name }}" in
-            pull_request)
-              BASE="$PR_BASE_SHA"
-              HEAD="$PR_HEAD_SHA"
-              ;;
-            *)
-              BASE="$PUSH_BEFORE"
-              HEAD="$PUSH_AFTER"
-              ;;
-          esac
-
-          # On push events with shallow clones, BASE may be present in
-          # the event payload but absent from the local object DB
-          # (fetch-depth=2 doesn't always reach the previous commit
-          # across true merges). Try fetching it on demand. If the
-          # fetch fails — e.g. the SHA was force-overwritten — we fall
-          # through to the empty-BASE branch below, which scans the
-          # entire tree as if every file were new. Correct, just slow.
-          if [ -n "$BASE" ] && ! echo "$BASE" | grep -qE '^0+$'; then
-            if ! git cat-file -e "$BASE" 2>/dev/null; then
-              git fetch --depth=1 origin "$BASE" 2>/dev/null || true
-            fi
-          fi
-
-          # Files added or modified in this change.
-          if [ -z "$BASE" ] || echo "$BASE" | grep -qE '^0+$' || ! git cat-file -e "$BASE" 2>/dev/null; then
-            # New branch / no previous SHA / BASE unreachable — check the
-            # entire tree as added content. Slower, but correct on first
-            # push.
-            CHANGED=$(git ls-tree -r --name-only HEAD)
-            DIFF_RANGE=""
-          else
-            CHANGED=$(git diff --name-only --diff-filter=AM "$BASE" "$HEAD")
-            DIFF_RANGE="$BASE $HEAD"
-          fi
-
-          if [ -z "$CHANGED" ]; then
-            echo "No changed files to inspect."
-            exit 0
-          fi
-
-          # Self-exclude: this workflow file legitimately contains the
-          # pattern strings as regex literals. Without an exclude it would
-          # block its own merge.
-          SELF=".github/workflows/secret-scan.yml"
-
-          OFFENDING=""
-          # `while IFS= read -r` (not `for f in $CHANGED`) so filenames
-          # containing whitespace don't word-split silently — a path
-          # with a space would otherwise produce two iterations on
-          # tokens that aren't real filenames, breaking the
-          # self-exclude + diff lookup.
-          while IFS= read -r f; do
-            [ -z "$f" ] && continue
-            [ "$f" = "$SELF" ] && continue
-            if [ -n "$DIFF_RANGE" ]; then
-              ADDED=$(git diff --no-color --unified=0 "$BASE" "$HEAD" -- "$f" 2>/dev/null | grep -E '^\+[^+]' || true)
-            else
-              # No diff range (new branch first push) — scan the full file
-              # contents as if every line were new.
-              ADDED=$(cat "$f" 2>/dev/null || true)
-            fi
-            [ -z "$ADDED" ] && continue
-            for pattern in "${SECRET_PATTERNS[@]}"; do
-              if echo "$ADDED" | grep -qE "$pattern"; then
-                OFFENDING="${OFFENDING}${f} (matched: ${pattern})\n"
-                break
-              fi
-            done
-          done <<< "$CHANGED"
-
-          if [ -n "$OFFENDING" ]; then
-            echo "::error::Credential-shaped strings detected in diff additions:"
-            # `printf '%b' "$OFFENDING"` interprets backslash escapes
-            # (the literal `\n` we appended above becomes a newline)
-            # WITHOUT treating OFFENDING as a format string. Plain
-            # `printf "$OFFENDING"` is a format-string sink: a filename
-            # containing `%` would be interpreted as a conversion
-            # specifier, corrupting the error message (or printing
-            # `%(missing)` artifacts).
-            printf '%b' "$OFFENDING"
-            echo ""
-            echo "The actual matched values are NOT echoed here, deliberately —"
-            echo "round-tripping a leaked credential into CI logs widens the blast"
-            echo "radius (logs are searchable + retained)."
-            echo ""
-            echo "Recovery:"
-            echo "  1. Remove the secret from the file. Replace with an env var"
-            echo "     reference (e.g. \${{ secrets.GITHUB_TOKEN }} in workflows,"
-            echo "     process.env.X in code)."
-            echo "  2. If the credential was already pushed (this PR's commit"
-            echo "     history reaches a public ref), treat it as compromised —"
-            echo "     ROTATE it immediately, do not just remove it. The token"
-            echo "     remains valid in git history forever and may be in any"
-            echo "     log/cache that consumed this branch."
-            echo "  3. Force-push the cleaned commit (or stack a revert) and"
-            echo "     re-run CI."
-            echo ""
-            echo "If the match is a false positive (test fixture, docs example,"
-            echo "or this workflow's own regex literals): use a clearly-fake"
-            echo "placeholder like ghs_EXAMPLE_DO_NOT_USE that doesn't satisfy"
-            echo "the length suffix, OR add the file path to the SELF exclude"
-            echo "list in this workflow with a short reason."
-            echo ""
-            echo "Mirror of the regex set lives in the runtime's bundled"
-            echo "pre-commit hook (molecule-ai-workspace-runtime:"
-            echo "molecule_runtime/scripts/pre-commit-checks.sh) — keep aligned."
-            exit 1
-          fi
-
-          echo "✓ No credential-shaped strings in this change."
+  secret-scan:
+    uses: Molecule-AI/molecule-core/.github/workflows/secret-scan.yml@staging
--- a/.runtime-version
+++ b/.runtime-version
@ -1 +0,0 @@
-0.1.129
--- a/13
+++ b/13
@ -43,19 +43,6 @@ RUN pip install --no-cache-dir -r requirements.txt && \
 # Copy adapter code
 COPY adapter.py .
 COPY __init__.py .
-# Provider registry. The adapter's _load_providers walks 4 paths:
-#   1. /opt/adapter/config.yaml          — provisioner-managed canonical
-#   2. os.path.dirname(__file__)/config.yaml  — alongside adapter.py (this image)
-#   3. ${WORKSPACE_CONFIG_PATH}/config.yaml   — workspace per-instance overrides
-#   4. _BUILTIN_PROVIDERS                — oauth + anthropic-api only
-# On this image /opt/adapter/ is never populated by the platform
-# provisioner, so path 2 (/app/config.yaml) is the load-bearing one.
-# Without this COPY the file isn't in the image, all 3 file paths fail,
-# and _load_providers falls through to _BUILTIN_PROVIDERS — every
-# MiniMax/GLM/Kimi/DeepSeek model silently routes to anthropic-oauth →
-# "Not logged in. Please run /login" at first LLM call. Caused the
-# canary's 38h chronic red on 2026-05-07/08 (molecule-core#129).
-COPY config.yaml .
 # Adapter-specific executor — owned by THIS template (universal-runtime
 # refactor, molecule-core task #87). Lives alongside adapter.py so
 # Python's import system picks the local /app/claude_sdk_executor.py
--- a/adapter.py
+++ b/adapter.py
@ -147,118 +147,36 @@ def _normalize_provider(entry: dict):
    }


-# Canonical install path the platform provisioner is contracted to clone
-# the template repo into. Hardcoded so the adapter's config.yaml lookup
-# is invariant across Docker (mounted /app→/opt/adapter) and EC2-host
-# (cloned by molecule-controlplane's ec2.go) install paths — robust
-# against the site-packages copy that bit us 2026-05-04 11:08Z.
-_CANONICAL_ADAPTER_DIR = "/opt/adapter"
-
-# Adjacent-to-adapter.py path. Module-level so tests can monkeypatch it
-# to redirect the path-2 lookup at a controlled tmp dir. Production code
-# resolves this once at import time and never touches it again — same
-# semantics as before.
-_TEMPLATE_DIR = os.path.dirname(os.path.abspath(__file__))
-
-
 def _load_providers(config_path: str) -> tuple:
-    """Load the provider registry from the template's bundled config.yaml.
+    """Load the provider registry from /configs/config.yaml.

-    The providers list is a TEMPLATE concern — it describes which
-    models/auth-modes this runtime image supports — and ships in the
-    template's own config.yaml alongside adapter.py. The per-workspace
-    ``${WORKSPACE_CONFIG_PATH}/config.yaml`` (default ``/configs/``)
-    only contains workspace-specific overrides (model, runtime, skills,
-    prompt files) and does NOT carry a providers section.
+    The YAML's top-level ``providers:`` list is the canonical source —
+    canvas Config tab reads the same list to populate its Provider
+    dropdown so the UI and the adapter never disagree on what's
+    available. Falls back to ``_BUILTIN_PROVIDERS`` (oauth + anthropic-api)
+    if the file is missing, malformed, or has no providers section, so a
+    bare-bones workspace still boots with the historical defaults.

-    Two-step incident history:
-      • Pre-2026-05-04 09:00Z: only checked ``config_path``, fell back
-        to ``_BUILTIN_PROVIDERS`` (oauth + anthropic-api). Every
-        MiniMax / GLM / Kimi / DeepSeek model resolved to
-        ``anthropic-oauth`` and crashed at first LLM call with
-        "Not logged in. Please run /login". Fixed by adding a
-        template-bundled lookup using
-        ``os.path.dirname(os.path.abspath(__file__))``.
-      • 2026-05-04 11:08Z: that ``__file__`` lookup misses on EC2-host
-        installs because the provisioner copies adapter.py to
-        ``/opt/molecule-venv/lib/python3.12/site-packages/`` —
-        site-packages wins over PYTHONPATH=/opt/adapter (which the
-        host install doesn't set), so __file__ resolves to the venv
-        path WITHOUT an adjacent config.yaml. Same silent fallback
-        to anthropic-oauth + same "Not logged in" symptom.
-      • 2026-05-08 (#129): the multi-path lookup that fixed both of
-        the above was lost in a post-suspension migration cycle (the
-        Gitea main branch never carried the fix even though the
-        :latest image had it baked in from a prior build). Canary
-        chronic red for 38h before this commit restored the lookup.
-
-    Resolution order:
-      1. ``/opt/adapter/config.yaml`` — canonical provisioner-managed
-         install dir. Hardcoded because the platform contract is
-         "provisioner clones template repo into /opt/adapter"; this
-         is invariant across Docker (mounted /app→/opt/adapter) and
-         EC2-host (cloned by ec2.go) install paths. Robust against
-         site-packages copy.
-      2. Adjacent to ``adapter.__file__`` — works in dev/test where
-         the canonical path doesn't exist. Also covers the Docker
-         image's /app/config.yaml (bundled by Dockerfile #6).
-      3. Per-workspace ``${config_path}/config.yaml`` — fallback for
-         operator-shipped overrides on a private deployment that
-         wants a custom providers list.
-      4. ``_BUILTIN_PROVIDERS`` — oauth + anthropic-api defaults so a
-         bare-bones workspace still boots even with no config.yaml
-         anywhere.
-
-    Per-entry isolation: a single bad provider entry is dropped with
-    a warning; the rest of the registry survives.
+    Per-entry isolation: a single bad provider entry is dropped with a
+    warning; the rest of the registry survives. Used to be a generator
+    inside tuple(...) that propagated any AttributeError out and reverted
+    the whole registry to builtins — exactly the silent-fallback failure
+    mode this file's existence was meant to fix.
    """
-    canonical_yaml = os.path.join(_CANONICAL_ADAPTER_DIR, "config.yaml")
-    template_yaml = os.path.join(_TEMPLATE_DIR, "config.yaml")
-    workspace_yaml = os.path.join(config_path, "config.yaml")
-    # Deduplicate while preserving order — _CANONICAL_ADAPTER_DIR and
-    # the __file__ dir collide in dev/test (when imported from
-    # /opt/adapter directly), and workspace_yaml may also collide if
-    # config_path == /opt/adapter in tests.
-    seen = set()
-    candidates = []
-    for path in (canonical_yaml, template_yaml, workspace_yaml):
-        if path not in seen:
-            seen.add(path)
-            candidates.append(path)
-
-    raw = None
-    chosen_path = None
+    yaml_path = os.path.join(config_path, "config.yaml")
    try:
        import yaml  # transitive dep via molecule-ai-workspace-runtime
-    except ImportError:
-        logger.warning("providers: yaml import failed; using builtins")
+        with open(yaml_path, "r") as f:
+            data = yaml.safe_load(f) or {}
+    except FileNotFoundError:
+        logger.info("providers: %s not found, using builtin defaults", yaml_path)
+        return _BUILTIN_PROVIDERS
+    except Exception as exc:  # noqa: BLE001 — defensive: never block boot on YAML
+        logger.warning("providers: failed to load from %s (%s); using builtins", yaml_path, exc)
        return _BUILTIN_PROVIDERS

-    for yaml_path in candidates:
-        try:
-            with open(yaml_path, "r") as f:
-                data = yaml.safe_load(f) or {}
-        except FileNotFoundError:
-            logger.info("providers: %s not found, trying next candidate", yaml_path)
-            continue
-        except Exception as exc:  # noqa: BLE001 — defensive: never block boot on YAML
-            logger.warning(
-                "providers: failed to load from %s (%s); trying next candidate",
-                yaml_path, exc,
-            )
-            continue
-
-        candidate_raw = data.get("providers") if isinstance(data, dict) else None
-        if isinstance(candidate_raw, list) and candidate_raw:
-            raw = candidate_raw
-            chosen_path = yaml_path
-            break
-
-    if raw is None:
-        logger.info(
-            "providers: no providers section found in %s; using builtin defaults",
-            " or ".join(candidates),
-        )
+    raw = data.get("providers") if isinstance(data, dict) else None
+    if not isinstance(raw, list) or not raw:
        return _BUILTIN_PROVIDERS

    parsed = []
@ -272,121 +190,11 @@ def _load_providers(config_path: str) -> tuple:
            parsed.append(normalized)

    if not parsed:
-        logger.warning("providers: no valid entries in %s; using builtins", chosen_path)
+        logger.warning("providers: no valid entries in %s; using builtins", yaml_path)
        return _BUILTIN_PROVIDERS
-    logger.info("providers: loaded %d entries from %s", len(parsed), chosen_path)
    return tuple(parsed)


-# Aliases for `MODEL_PROVIDER` env values that should map to a registry
-# provider name. The persona env files use shorter / friendlier slugs
-# than the registry's canonical names — without this alias map a value
-# like ``MODEL_PROVIDER=claude-code`` would fall through to YAML-based
-# resolution and (when the YAML doesn't pin a provider) hit the
-# model-prefix matcher with the operator-picked MODEL, mis-routing a
-# lead workspace through MiniMax even though its CLAUDE_CODE_OAUTH_TOKEN
-# was clearly meant to be used.
-#
-# Maintain this list in sync with the persona env file convention:
-#   - ``claude-code``  → ``anthropic-oauth`` (Claude Code subscription path)
-#   - ``anthropic``    → ``anthropic-api``  (direct Anthropic API key)
-# Provider names already in the registry alias to themselves implicitly
-# (the ``in registry`` check catches them before this map is consulted).
-_PROVIDER_SLUG_ALIASES = {
-    "claude-code": "anthropic-oauth",
-    "anthropic": "anthropic-api",
-}
-
-
-def _resolve_model_and_provider_from_env(
-    yaml_model: str,
-    yaml_provider: str,
-    providers: tuple,
-) -> tuple:
-    """Reconcile model + provider from env vars vs YAML, with the persona-env
-    convention winning over the legacy ``MODEL_PROVIDER``-as-model-id usage.
-
-    The persona env files (``~/.molecule-ai/personas/<name>/env`` on the host,
-    sourced into each workspace container at provision time) declare TWO env
-    vars with distinct semantics:
-
-      * ``MODEL`` — the model id (e.g. ``MiniMax-M2.7-highspeed``, ``opus``).
-      * ``MODEL_PROVIDER`` — the provider slug (e.g. ``minimax``,
-        ``claude-code``, ``anthropic``).
-
-    The legacy ``workspace/config.py`` (in molecule-ai-workspace-runtime)
-    historically interpreted ``MODEL_PROVIDER`` as the *model id* — a name
-    chosen before there was a separate ``MODEL`` env var. When both env vars
-    are set with the persona convention, the legacy code reads
-    ``MODEL_PROVIDER=minimax`` into ``runtime_config.model``, which then
-    fails to match any registry prefix (``minimax-`` requires a hyphen
-    suffix) and silently falls through to providers[0] (``anthropic-oauth``).
-    OAuth-token-less workspaces then wedge at ``query.initialize()`` because
-    the claude CLI can't authenticate. This is the 2026-05-08 dev-tree
-    incident — 22/27 non-lead workspaces stuck in ``degraded``.
-
-    Resolution order (this function):
-      1. ``MODEL`` env var → picked_model. Authoritative when set; the
-         persona env always sets it alongside ``MODEL_PROVIDER`` so the
-         model id never has to be inferred.
-      2. ``MODEL_PROVIDER`` env var → explicit_provider, BUT only when the
-         value matches a known provider name in the registry. This guards
-         against the legacy case where some callers still set
-         ``MODEL_PROVIDER`` to a model id (e.g. canvas Save+Restart prior to
-         this fix). If the value isn't a registered provider name and YAML
-         didn't supply a model, treat it as a model id for back-compat.
-      3. YAML ``runtime_config.model`` / ``provider`` — used for any field
-         the env didn't supply. Carries the operator's canvas selection
-         on workspaces that haven't yet adopted the persona env shape.
-
-    Returns ``(picked_model, explicit_provider_name)``. Either may be
-    empty/None — the caller (``setup``) handles the empty cases via
-    ``_resolve_provider``'s registry fallback.
-    """
-    env_model = (os.environ.get("MODEL") or "").strip()
-    env_provider = (os.environ.get("MODEL_PROVIDER") or "").strip()
-    provider_names_lower = {p.get("name", "").lower() for p in providers}
-
-    # Detect whether MODEL_PROVIDER carries the persona-convention slug
-    # (provider name) vs. the legacy convention (model id). Persona-
-    # convention wins when the value matches a registered provider; we
-    # fall back to legacy interpretation only when it doesn't.
-    #
-    # First, apply the alias map so persona-friendly slugs like
-    # ``claude-code`` resolve to the canonical registry name
-    # ``anthropic-oauth``. Without this, a lead workspace's
-    # ``MODEL_PROVIDER=claude-code`` env would fall through to the model-
-    # prefix matcher, see ``MODEL=MiniMax-M2.7`` and mis-route to MiniMax
-    # even though the operator's intent (and the OAuth token they set)
-    # was the OAuth subscription path.
-    env_provider_resolved = _PROVIDER_SLUG_ALIASES.get(
-        env_provider.lower(), env_provider,
-    ) if env_provider else ""
-    env_provider_is_slug = (
-        bool(env_provider_resolved)
-        and env_provider_resolved.lower() in provider_names_lower
-    )
-
-    # Picked model resolution
-    if env_model:
-        picked_model = env_model
-    elif env_provider and not env_provider_is_slug:
-        # Legacy: MODEL_PROVIDER env carried the model id. Honor it so
-        # canvas Save+Restart workflows that predate this fix keep working.
-        picked_model = env_provider
-    else:
-        picked_model = yaml_model or ""
-
-    # Explicit provider resolution — env wins when it's a registered slug
-    # (after alias mapping), otherwise fall back to YAML.
-    if env_provider_is_slug:
-        explicit_provider = env_provider_resolved
-    else:
-        explicit_provider = yaml_provider or None
-
-    return picked_model, explicit_provider
-
-
 def _strip_provider_prefix(model: str) -> str:
    """Strip LangChain-style "<provider>:<model>" prefix from a model id.

@ -472,28 +280,13 @@ def _project_vendor_auth(provider: dict) -> None:
        return


-def _resolve_provider(
-    model: str,
-    providers: tuple,
-    explicit_provider: str = None,
-) -> dict:
+def _resolve_provider(model: str, providers: tuple) -> dict:
    """Return the provider entry matching this model id.

-    If ``explicit_provider`` is given (set via the ``provider:`` field in
-    workspace config.yaml or runtime_config), look up by name first. If the
-    named provider is not in the registry, RAISE ``ValueError`` with an
-    actionable message — silent fallback to ``providers[0]`` is the bug
-    that motivated #180 (workspace operator picks ``provider: minimax``
-    in the canvas Config tab, the adapter ignores it, the Claude SDK
-    silently keeps using ``CLAUDE_CODE_OAUTH_TOKEN`` and the operator has
-    no way to tell from the canvas that their provider switch did
-    nothing).
-
-    Without an explicit name: match is case-insensitive, prefix wins over
-    alias when both could apply, and unknown ids fall back to the first
-    provider in the registry (by convention, the OAuth/safest default —
-    ``anthropic-oauth`` in both _BUILTIN_PROVIDERS and the shipped
-    config.yaml).
+    Match is case-insensitive: prefix wins over alias when both could
+    apply. Unknown ids fall back to the first provider in the registry
+    (by convention, the OAuth/safest default — anthropic-oauth in both
+    _BUILTIN_PROVIDERS and the shipped config.yaml).

    Pre-condition: ``providers`` is non-empty. _load_providers always
    returns at least one entry (built-ins when YAML is missing or every
@ -505,44 +298,6 @@ def _resolve_provider(
            "_load_providers must always return at least one entry "
            "(falling back to _BUILTIN_PROVIDERS when needed)"
        )
-
-    # Explicit provider name takes precedence — fail fast if it's not in
-    # the registry. Anything else would silently route the operator's
-    # picked provider through the wrong auth/base_url path. The error
-    # message tells them exactly which two paths fix it.
-    if explicit_provider:
-        ep_lower = explicit_provider.lower()
-        for provider in providers:
-            if provider["name"].lower() == ep_lower:
-                return provider
-        names = ", ".join(p["name"] for p in providers)
-        raise ValueError(
-            f"claude-code adapter: workspace config picks "
-            f"provider='{explicit_provider}' but it is not in the "
-            f"providers registry.\n"
-            f"\n"
-            f"Known providers: {names}\n"
-            f"\n"
-            f"Two ways to fix:\n"
-            f"  (a) Add '{explicit_provider}' to /configs/config.yaml as a "
-            f"providers: entry. Required keys:\n"
-            f"        providers:\n"
-            f"          - name: {explicit_provider}\n"
-            f"            auth_mode: third_party_anthropic_compat\n"
-            f"            base_url: https://...   # provider's Anthropic-compat endpoint\n"
-            f"            auth_env: [{explicit_provider.upper()}_API_KEY]\n"
-            f"            model_prefixes: [...]\n"
-            f"  (b) Switch the workspace runtime template to one that "
-            f"natively supports {explicit_provider} (CrewAI, LangGraph, or "
-            f"DeepAgents read provider/model from runtime_config and route "
-            f"directly without needing an Anthropic-compat shim).\n"
-            f"\n"
-            f"Note: claude-code SDK speaks the Anthropic API protocol. "
-            f"Providers that only expose OpenAI-compatible endpoints "
-            f"(MiniMax, GLM, Kimi, DeepSeek native APIs) need either an "
-            f"Anthropic-compat proxy in front, or option (b)."
-        )
-
    if not model:
        return providers[0]
    m = model.lower()
@ -645,52 +400,9 @@ class ClaudeCodeAdapter(BaseAdapter):
        # validation + ANTHROPIC_BASE_URL routing from that single decision.
        rc = config.runtime_config
        if isinstance(rc, dict):
-            yaml_model = rc.get("model") or ""
-            yaml_provider_name = rc.get("provider") or ""
+            picked_model = rc.get("model") or "sonnet"
        else:
-            yaml_model = getattr(rc, "model", None) or ""
-            yaml_provider_name = getattr(rc, "provider", None) or ""
-
-        # Also honor the top-level `provider:` field in /configs/config.yaml.
-        # The canvas Config-tab Provider dropdown writes there (not into
-        # runtime_config) on some legacy paths. Either source is canonical;
-        # whichever is set wins. Root cause of #180: the adapter used to
-        # ignore both, silently routing every non-Anthropic provider pick
-        # through anthropic-oauth.
-        if not yaml_provider_name:
-            yaml_path = os.path.join(config.config_path, "config.yaml")
-            try:
-                import yaml  # transitive dep via molecule-ai-workspace-runtime
-                with open(yaml_path, "r") as f:
-                    data = yaml.safe_load(f) or {}
-                if isinstance(data, dict):
-                    val = data.get("provider")
-                    if isinstance(val, str) and val.strip():
-                        yaml_provider_name = val.strip()
-            except FileNotFoundError:
-                pass
-            except Exception as exc:  # noqa: BLE001 — defensive: never block boot
-                logger.warning(
-                    "providers: failed to read top-level provider: from %s (%s); "
-                    "falling back to model-based resolution",
-                    yaml_path, exc,
-                )
-
-        # Reconcile env vars (persona convention: MODEL=<id>,
-        # MODEL_PROVIDER=<slug>) against YAML. Env wins over YAML — the
-        # persona env files are the canonical per-agent provider mapping
-        # (Phase 2 mapping 2026-05-08), and the workspace-runtime wheel's
-        # legacy ``MODEL_PROVIDER``-as-model-id reading would otherwise
-        # silently route non-leads to providers[0] = anthropic-oauth.
-        # Documented in detail at _resolve_model_and_provider_from_env.
-        picked_model, explicit_provider_name = _resolve_model_and_provider_from_env(
-            yaml_model=yaml_model,
-            yaml_provider=yaml_provider_name,
-            providers=providers,
-        )
-        if not picked_model:
-            picked_model = "sonnet"
-
+            picked_model = getattr(rc, "model", None) or "sonnet"
        # NOTE: do NOT strip the provider prefix here. The pre-fix routing
        # behavior — `anthropic:claude-opus-4-7` falls through to
        # providers[0] (anthropic-oauth) when no model_prefixes match — is
@ -699,15 +411,7 @@ class ClaudeCodeAdapter(BaseAdapter):
        # `anthropic-api` provider and the CLI then hangs at `initialize`
        # because ANTHROPIC_API_KEY isn't set. The strip belongs only at
        # the CLI invocation site (create_executor below).
-        #
-        # Pass the explicit provider name through so _resolve_provider
-        # raises ValueError with an actionable message (instead of silently
-        # routing to providers[0]) when an operator picks a provider that
-        # isn't in the registry. See #180.
-        provider = _resolve_provider(
-            picked_model, providers,
-            explicit_provider=explicit_provider_name,
-        )
+        provider = _resolve_provider(picked_model, providers)
        auth_env_options = provider["auth_env"]

        # Project the per-vendor API key (MINIMAX_API_KEY, GLM_API_KEY,
@ -818,26 +522,9 @@ class ClaudeCodeAdapter(BaseAdapter):
        # RuntimeConfig dataclass. Read `model` defensively from either shape.
        rc = config.runtime_config
        if isinstance(rc, dict):
-            yaml_model = rc.get("model") or ""
-            yaml_provider = rc.get("provider") or ""
+            explicit_model = rc.get("model") or ""
        else:
-            yaml_model = getattr(rc, "model", None) or ""
-            yaml_provider = getattr(rc, "provider", None) or ""
-
-        # Reconcile against env vars (persona convention: MODEL=<id>,
-        # MODEL_PROVIDER=<slug>) using the same helper that ``setup`` uses,
-        # so the executor and the boot banner agree on the picked model.
-        # Without this, a workspace whose env says ``MODEL=MiniMax-M2.7``
-        # but whose runtime wheel pre-dates the persona-env fix would set
-        # runtime_config.model="minimax" (the slug, mistakenly read by the
-        # legacy ``MODEL_PROVIDER``-as-model-id path); this helper restores
-        # the correct model id before it reaches the SDK.
-        providers = _load_providers(config.config_path)
-        explicit_model, _ = _resolve_model_and_provider_from_env(
-            yaml_model=yaml_model,
-            yaml_provider=yaml_provider,
-            providers=providers,
-        )
+            explicit_model = getattr(rc, "model", None) or ""
        explicit_model = _strip_provider_prefix(explicit_model)

        # Pre-validation: detect the misconfiguration combo that drove the
@ -868,7 +555,7 @@ class ClaudeCodeAdapter(BaseAdapter):
                    "The default fallback ('sonnet') is an Anthropic-native "
                    "alias; non-Anthropic shims (MiniMax, OpenAI gateways, "
                    "etc.) won't recognize it and the SDK --print probe will "
-                    "hang for 30s before timing out. Fix: set MODEL "
+                    "hang for 30s before timing out. Fix: set MODEL_PROVIDER "
                    "as a workspace secret (canvas: Save+Restart with model "
                    "picked) or set runtime_config.model in /configs/config.yaml."
                )
--- a/tests/conftest.py
+++ b/tests/conftest.py
@ -1,89 +0,0 @@
-"""Shared pytest fixtures + import shims for the adapter test suite.
-
-`adapter.py` imports at module load:
-  - molecule_runtime.adapters.base (BaseAdapter, AdapterConfig, RuntimeCapabilities)
-  - molecule_runtime.plugins (lazy in setup(), but stubbed proactively)
-  - a2a.server.agent_execution (AgentExecutor)
-  - claude_sdk_executor (lazy in create_executor(), stubbed proactively)
-
-In production those arrive transitively via molecule-ai-workspace-runtime.
-The CI runner only installs `pytest pytest-asyncio pyyaml`, so the import
-chain would fail with ModuleNotFoundError before any test collects —
-exactly the failure that broke CI on the #180 fix branch (PR #4) and
-caused the merge wall to block on a green local but red Gitea CI.
-
-Putting the stub installer here (collected before any test module is
-imported, per pytest semantics) means every test file can do
-`from adapter import ...` at module top without a per-file boilerplate
-copy. It also forces a single shape for the stubs so two files can't
-silently disagree on whether `BaseAdapter` has
-`install_plugins_via_registry` (see test_adapter_prevalidate's
-async-setup tests, which need the method to exist on the parent class).
-"""
-
-import os
-import sys
-import types
-from dataclasses import dataclass
-from unittest.mock import MagicMock
-
-
-@dataclass
-class _StubRuntimeCapabilities:
-    provides_native_session: bool = False
-
-
-@dataclass
-class _StubAdapterConfig:
-    runtime_config: object = None
-    config_path: str = "/tmp/configs"
-    system_prompt: str = ""
-    heartbeat: object = None
-
-
-class _StubBaseAdapter:
-    async def install_plugins_via_registry(self, *_args, **_kwargs):
-        pass
-
-
-def _install_stubs() -> None:
-    """Install the smallest set of import shims that adapter.py needs."""
-    if "molecule_runtime" not in sys.modules:
-        mr = types.ModuleType("molecule_runtime")
-        mr.adapters = types.ModuleType("molecule_runtime.adapters")
-        mr.adapters.base = types.ModuleType("molecule_runtime.adapters.base")
-        mr.adapters.base.BaseAdapter = _StubBaseAdapter
-        mr.adapters.base.AdapterConfig = _StubAdapterConfig
-        mr.adapters.base.RuntimeCapabilities = _StubRuntimeCapabilities
-        mr.plugins = types.ModuleType("molecule_runtime.plugins")
-        mr.plugins.load_plugins = lambda **_kwargs: []
-        sys.modules["molecule_runtime"] = mr
-        sys.modules["molecule_runtime.adapters"] = mr.adapters
-        sys.modules["molecule_runtime.adapters.base"] = mr.adapters.base
-        sys.modules["molecule_runtime.plugins"] = mr.plugins
-    if "a2a" not in sys.modules:
-        a2a = types.ModuleType("a2a")
-        a2a.server = types.ModuleType("a2a.server")
-        a2a.server.agent_execution = types.ModuleType("a2a.server.agent_execution")
-        a2a.server.agent_execution.AgentExecutor = type("AgentExecutor", (), {})
-        sys.modules["a2a"] = a2a
-        sys.modules["a2a.server"] = a2a.server
-        sys.modules["a2a.server.agent_execution"] = a2a.server.agent_execution
-    if "claude_sdk_executor" not in sys.modules:
-        mod = types.ModuleType("claude_sdk_executor")
-        mod.ClaudeSDKExecutor = MagicMock(name="ClaudeSDKExecutor")
-        sys.modules["claude_sdk_executor"] = mod
-
-
-# Run at conftest import time — pytest collects conftest.py before any
-# test module, so the stubs are in sys.modules before `from adapter
-# import ...` ever executes.
-_install_stubs()
-
-# adapter.py lives in the parent dir of tests/ (template root). pytest's
-# `--import-mode=importlib` + tests/pytest.ini anchoring rootdir at
-# tests/ means the parent isn't on sys.path automatically. Add it here
-# once so every test file can do `from adapter import ...` cleanly.
-_PARENT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-if _PARENT_DIR not in sys.path:
-    sys.path.insert(0, _PARENT_DIR)
--- a/tests/test_adapter_prevalidate.py
+++ b/tests/test_adapter_prevalidate.py
@ -514,15 +514,8 @@ async def test_setup_auth_token_alone_satisfies_third_party_check(
 # ---- _load_providers / _resolve_provider unit tests ----


-def test_load_providers_returns_builtin_when_yaml_missing(tmp_path, monkeypatch):
-    """FileNotFoundError path returns the in-code defaults verbatim.
-
-    Monkeypatches the canonical + template paths to a non-existent dir
-    so only the workspace config_path is in scope. Without this, the
-    multi-path lookup picks up the repo-root config.yaml that ships
-    with the template (path 2 finds the bundled providers list and
-    returns it instead of falling through to builtins).
-    """
+def test_load_providers_returns_builtin_when_yaml_missing(tmp_path):
+    """FileNotFoundError path returns the in-code defaults verbatim."""
    _install_stubs()
    parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    if parent_dir not in sys.path:
@ -530,10 +523,6 @@ def test_load_providers_returns_builtin_when_yaml_missing(tmp_path, monkeypatch)
    sys.modules.pop("adapter", None)
    import adapter as adapter_module

-    nonexistent = str(tmp_path / "_isolate_canonical")
-    monkeypatch.setattr(adapter_module, "_CANONICAL_ADAPTER_DIR", nonexistent)
-    monkeypatch.setattr(adapter_module, "_TEMPLATE_DIR", nonexistent)
-
    result = adapter_module._load_providers(str(tmp_path))
    assert result == adapter_module._BUILTIN_PROVIDERS

@ -587,12 +576,8 @@ async def test_setup_routes_extra_providers(
    assert os.environ.get("ANTHROPIC_BASE_URL") == expected_url


-def test_load_providers_falls_back_on_malformed_yaml(tmp_path, caplog, monkeypatch):
-    """Malformed YAML → log warning + fallback (don't kill boot).
-
-    Isolated from the multi-path lookup by pinning canonical + template
-    dirs at a non-existent path; only the workspace config_path is read.
-    """
+def test_load_providers_falls_back_on_malformed_yaml(tmp_path, caplog):
+    """Malformed YAML → log warning + fallback (don't kill boot)."""
    _install_stubs()
    parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    if parent_dir not in sys.path:
@ -600,10 +585,6 @@ def test_load_providers_falls_back_on_malformed_yaml(tmp_path, caplog, monkeypat
    sys.modules.pop("adapter", None)
    import adapter as adapter_module

-    nonexistent = str(tmp_path / "_isolate_canonical")
-    monkeypatch.setattr(adapter_module, "_CANONICAL_ADAPTER_DIR", nonexistent)
-    monkeypatch.setattr(adapter_module, "_TEMPLATE_DIR", nonexistent)
-
    (tmp_path / "config.yaml").write_text("providers: [not valid yaml: {{{")

    import logging
@ -641,7 +622,7 @@ def test_resolve_provider_minimax_prefix_matches_minimax_provider():
    assert result2["name"] == "minimax"


-def test_load_providers_drops_bad_entry_keeps_rest(tmp_path, caplog, monkeypatch):
+def test_load_providers_drops_bad_entry_keeps_rest(tmp_path, caplog):
    """Per-entry isolation: one malformed entry shouldn't nuke the registry.

    Pre-fix: ``_load_providers`` built the registry via a generator inside
@ -653,9 +634,6 @@ def test_load_providers_drops_bad_entry_keeps_rest(tmp_path, caplog, monkeypatch

    Post-fix: per-entry try/except drops the bad entry with a warning,
    rest of the registry survives.
-
-    Isolated from the multi-path lookup so only the test's tmp config.yaml
-    is read.
    """
    _install_stubs()
    parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@ -664,10 +642,6 @@ def test_load_providers_drops_bad_entry_keeps_rest(tmp_path, caplog, monkeypatch
    sys.modules.pop("adapter", None)
    import adapter as adapter_module

-    nonexistent = str(tmp_path / "_isolate_canonical")
-    monkeypatch.setattr(adapter_module, "_CANONICAL_ADAPTER_DIR", nonexistent)
-    monkeypatch.setattr(adapter_module, "_TEMPLATE_DIR", nonexistent)
-
    yaml_with_typo = textwrap.dedent("""
        providers:
          - name: good-zai
@ -716,7 +690,7 @@ def test_load_providers_drops_bad_entry_keeps_rest(tmp_path, caplog, monkeypatch
    )


-def test_load_providers_string_as_prefix_does_not_split_into_chars(tmp_path, caplog, monkeypatch):
+def test_load_providers_string_as_prefix_does_not_split_into_chars(tmp_path, caplog):
    """A YAML field declared as list-of-strings but written as a bare
    string (operator forgot brackets) used to silently iterate over
    characters → ``('m','i','m','o','-')``. Post-fix: non-list value
@ -731,10 +705,6 @@ def test_load_providers_string_as_prefix_does_not_split_into_chars(tmp_path, cap
    sys.modules.pop("adapter", None)
    import adapter as adapter_module

-    nonexistent = str(tmp_path / "_isolate_canonical")
-    monkeypatch.setattr(adapter_module, "_CANONICAL_ADAPTER_DIR", nonexistent)
-    monkeypatch.setattr(adapter_module, "_TEMPLATE_DIR", nonexistent)
-
    yaml_str_prefix = textwrap.dedent("""
        providers:
          - name: typo-prefix
@ -753,7 +723,7 @@ def test_load_providers_string_as_prefix_does_not_split_into_chars(tmp_path, cap
    )


-def test_load_providers_drops_entry_without_name(tmp_path, caplog, monkeypatch):
+def test_load_providers_drops_entry_without_name(tmp_path, caplog):
    """An entry without ``name`` is operator error — no silent fallback
    to ``<unnamed>``. Drop the entry with a warning so the boot log
    surfaces the typo.
@ -765,10 +735,6 @@ def test_load_providers_drops_entry_without_name(tmp_path, caplog, monkeypatch):
    sys.modules.pop("adapter", None)
    import adapter as adapter_module

-    nonexistent = str(tmp_path / "_isolate_canonical")
-    monkeypatch.setattr(adapter_module, "_CANONICAL_ADAPTER_DIR", nonexistent)
-    monkeypatch.setattr(adapter_module, "_TEMPLATE_DIR", nonexistent)
-
    yaml_no_name = textwrap.dedent("""
        providers:
          - name: good
--- a/tests/test_env_model_provider_dispatch.py
+++ b/tests/test_env_model_provider_dispatch.py
@ -1,239 +0,0 @@
-"""Tests for ``_resolve_model_and_provider_from_env`` — the env-vs-YAML
-reconciliation that fixes the 2026-05-08 dev-tree wedge incident.
-
-Symptom: 22/27 non-lead workspaces (minimax tier) wedged on
-``Control request timeout: initialize`` because the runtime wheel's
-``workspace/config.py`` interpreted ``MODEL_PROVIDER=minimax`` as the
-*model id* instead of the provider slug. ``model="minimax"`` failed to
-match the ``minimax-`` registry prefix, fell through to providers[0]
-(anthropic-oauth), demanded ``CLAUDE_CODE_OAUTH_TOKEN`` (unset on
-non-leads), and the claude CLI hung at SDK init.
-
-The persona env files (``~/.molecule-ai/personas/<name>/env``) declare
-the new convention:
-  * ``MODEL`` — model id (e.g. ``MiniMax-M2.7-highspeed``)
-  * ``MODEL_PROVIDER`` — provider slug (e.g. ``minimax``)
-
-These tests cover the matrix of (env shape) × (YAML shape) so a future
-contributor can't silently regress the wedge fix.
-"""
-
-import pytest
-
-from adapter import (
-    _BUILTIN_PROVIDERS,
-    _resolve_model_and_provider_from_env,
-)
-
-
-# A registry that contains both anthropic-oauth (providers[0]) and
-# minimax/zai (third-party slugs) — matches the shipped config.yaml.
-_REGISTRY = _BUILTIN_PROVIDERS + (
-    {
-        "name": "minimax",
-        "auth_mode": "third_party_anthropic_compat",
-        "model_prefixes": ("minimax-",),
-        "model_aliases": (),
-        "base_url": "https://api.minimax.io/anthropic",
-        "auth_env": ("MINIMAX_API_KEY",),
-    },
-    {
-        "name": "zai",
-        "auth_mode": "third_party_anthropic_compat",
-        "model_prefixes": ("glm-",),
-        "model_aliases": (),
-        "base_url": "https://api.z.ai/api/anthropic",
-        "auth_env": ("GLM_API_KEY",),
-    },
-)
-
-
-def _clear_env(monkeypatch):
-    monkeypatch.delenv("MODEL", raising=False)
-    monkeypatch.delenv("MODEL_PROVIDER", raising=False)
-
-
-# ------------------------------------------------------------------
-# Persona env convention: MODEL=<id>, MODEL_PROVIDER=<slug>
-# ------------------------------------------------------------------
-
-def test_persona_env_minimax_resolves_correctly(monkeypatch):
-    """The 2026-05-08 wedge regression test: persona env shape must
-    yield model=MiniMax-M2.7-highspeed (not "minimax") and explicit
-    provider=minimax."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "MiniMax-M2.7-highspeed")
-    monkeypatch.setenv("MODEL_PROVIDER", "minimax")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "MiniMax-M2.7-highspeed"
-    assert provider == "minimax"
-
-
-def test_persona_env_lead_claude_code_resolves_correctly(monkeypatch):
-    """Lead persona env (MODEL=opus, MODEL_PROVIDER=claude-code) —
-    ``claude-code`` is the persona-friendly alias for the canonical
-    ``anthropic-oauth`` registry name. Must resolve via the alias map
-    so the lead boots through the OAuth subscription path even when
-    MODEL is a non-Anthropic model id (e.g. an operator who picked
-    MiniMax in canvas but whose persona env still pins claude-code)."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "opus")
-    monkeypatch.setenv("MODEL_PROVIDER", "claude-code")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "opus"
-    # claude-code → anthropic-oauth via the alias map
-    assert provider == "anthropic-oauth"
-
-
-def test_persona_env_lead_with_minimax_model_routes_via_oauth(monkeypatch):
-    """Lead workspace whose persona pins MODEL_PROVIDER=claude-code but
-    whose YAML/canvas selection happens to be a MiniMax model still
-    routes via OAuth — the persona's provider pin wins over the
-    model-prefix matcher. Without the alias map, the fall-through
-    mis-routed leads to MiniMax even when their CLAUDE_CODE_OAUTH_TOKEN
-    was set."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "MiniMax-M2.7")
-    monkeypatch.setenv("MODEL_PROVIDER", "claude-code")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "MiniMax-M2.7"
-    assert provider == "anthropic-oauth"
-
-
-def test_anthropic_alias_resolves_to_anthropic_api(monkeypatch):
-    """``MODEL_PROVIDER=anthropic`` alias → ``anthropic-api`` (direct
-    Anthropic API key path)."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "claude-opus-4-7")
-    monkeypatch.setenv("MODEL_PROVIDER", "anthropic")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "claude-opus-4-7"
-    assert provider == "anthropic-api"
-
-
-def test_persona_env_glm_resolves_correctly(monkeypatch):
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "GLM-4.6")
-    monkeypatch.setenv("MODEL_PROVIDER", "zai")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "GLM-4.6"
-    assert provider == "zai"
-
-
-def test_env_provider_slug_case_insensitive(monkeypatch):
-    """Operator typos like ``MiniMax`` (mixed case) still resolve."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "MiniMax-M2.7-highspeed")
-    monkeypatch.setenv("MODEL_PROVIDER", "MiniMax")  # mixed case
-    _, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert provider == "MiniMax"  # caller compares case-insensitively
-
-
-# ------------------------------------------------------------------
-# Legacy convention: MODEL_PROVIDER=<model-id>, MODEL unset
-# ------------------------------------------------------------------
-
-def test_legacy_model_provider_as_model_id_still_works(monkeypatch):
-    """Pre-2026-05-08 canvas Save+Restart shape: MODEL_PROVIDER carried
-    the model id directly (e.g. ``MODEL_PROVIDER=MiniMax-M2.7``) and
-    no MODEL env. Must keep working so existing canvas users don't
-    break overnight."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL_PROVIDER", "MiniMax-M2.7-highspeed")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    # MiniMax-M2.7-highspeed is not a registered provider name, so
-    # it's treated as a legacy model-id-in-MODEL_PROVIDER value.
-    assert model == "MiniMax-M2.7-highspeed"
-    assert provider is None
-
-
-# ------------------------------------------------------------------
-# Env wins over YAML
-# ------------------------------------------------------------------
-
-def test_env_model_wins_over_yaml_model(monkeypatch):
-    """When both env MODEL and YAML model are set, env wins."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "GLM-4.6")
-    model, _ = _resolve_model_and_provider_from_env(
-        yaml_model="MiniMax-M2.7", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "GLM-4.6"
-
-
-def test_env_provider_wins_over_yaml_provider(monkeypatch):
-    """Env MODEL_PROVIDER (when a registered slug) wins over YAML provider."""
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "GLM-4.6")
-    monkeypatch.setenv("MODEL_PROVIDER", "zai")
-    _, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="minimax", providers=_REGISTRY,
-    )
-    assert provider == "zai"
-
-
-# ------------------------------------------------------------------
-# YAML fallback (no env)
-# ------------------------------------------------------------------
-
-def test_no_env_falls_back_to_yaml(monkeypatch):
-    """Workspace whose env doesn't set MODEL/MODEL_PROVIDER falls back
-    to the YAML config — preserves existing operator workflows."""
-    _clear_env(monkeypatch)
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="claude-sonnet-4-6",
-        yaml_provider="anthropic-api",
-        providers=_REGISTRY,
-    )
-    assert model == "claude-sonnet-4-6"
-    assert provider == "anthropic-api"
-
-
-def test_no_env_no_yaml_returns_empty(monkeypatch):
-    """Pure default path — caller (setup) substitutes ``sonnet``."""
-    _clear_env(monkeypatch)
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == ""
-    assert provider is None
-
-
-# ------------------------------------------------------------------
-# Whitespace / empty-value defensive cases
-# ------------------------------------------------------------------
-
-def test_whitespace_only_env_treated_as_unset(monkeypatch):
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "   ")
-    monkeypatch.setenv("MODEL_PROVIDER", "  ")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="opus", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "opus"
-    assert provider is None
-
-
-def test_empty_env_value_treated_as_unset(monkeypatch):
-    _clear_env(monkeypatch)
-    monkeypatch.setenv("MODEL", "")
-    monkeypatch.setenv("MODEL_PROVIDER", "")
-    model, provider = _resolve_model_and_provider_from_env(
-        yaml_model="sonnet", yaml_provider="", providers=_REGISTRY,
-    )
-    assert model == "sonnet"
-    assert provider is None
--- a/tests/test_provider_resolution.py
+++ b/tests/test_provider_resolution.py
@ -1,146 +0,0 @@
-"""Tests for the provider-resolution path that was silent-failing on #180.
-
-Regression coverage: when an operator picks a provider in the canvas Config
-tab that isn't in the registry, the adapter must raise ValueError with an
-actionable message — NOT silently fall through to providers[0]
-(anthropic-oauth) and then have the Claude SDK hit the user's OAuth quota
-under a different name.
-
-These tests mirror the production failure mode reported by Hongming
-2026-05-07 17:35: workspace config.yaml had `provider: minimax` set, the
-adapter ignored it entirely, the SDK kept calling the Anthropic API with
-CLAUDE_CODE_OAUTH_TOKEN, hit the OAuth quota, and the canvas surfaced
-"Agent error (Exception)" with no clue why.
-
-Import-shim setup (sys.path + molecule_runtime / a2a / claude_sdk_executor
-stubs) lives in tests/conftest.py — shared with test_adapter_prevalidate
-so the two stub installers can't disagree on shape (e.g. BaseAdapter
-having install_plugins_via_registry).
-"""
-
-import pytest
-
-from adapter import (
-    _BUILTIN_PROVIDERS,
-    _resolve_provider,
-)
-
-
-def test_resolve_with_no_explicit_provider_falls_back_to_model_match():
-    """No explicit provider → model-based prefix/alias matching, default to providers[0]."""
-    p = _resolve_provider("claude-opus-4-7", _BUILTIN_PROVIDERS)
-    assert p["name"] == "anthropic-api"  # matches model_prefixes=("claude-",)
-
-
-def test_resolve_with_no_explicit_provider_falls_back_to_default():
-    """Unknown model + no explicit provider → providers[0] (anthropic-oauth)."""
-    p = _resolve_provider("unknown-model", _BUILTIN_PROVIDERS)
-    assert p["name"] == "anthropic-oauth"
-
-
-def test_resolve_with_explicit_provider_in_registry_returns_match():
-    """Explicit name lookup wins over model-based resolution."""
-    # Even though "claude-opus-4-7" would normally resolve to anthropic-api
-    # via prefix matching, the explicit provider name wins.
-    p = _resolve_provider(
-        "claude-opus-4-7", _BUILTIN_PROVIDERS,
-        explicit_provider="anthropic-oauth",
-    )
-    assert p["name"] == "anthropic-oauth"
-
-
-def test_resolve_with_explicit_provider_case_insensitive():
-    """Provider name match is case-insensitive (operators write 'Anthropic-OAuth' etc)."""
-    p = _resolve_provider(
-        "sonnet", _BUILTIN_PROVIDERS,
-        explicit_provider="ANTHROPIC-OAUTH",
-    )
-    assert p["name"] == "anthropic-oauth"
-
-
-def test_resolve_with_explicit_provider_not_in_registry_raises():
-    """The #180 regression test: explicit non-registry provider must raise, not fall through."""
-    with pytest.raises(ValueError) as exc_info:
-        _resolve_provider(
-            "MiniMax-M2.7-highspeed", _BUILTIN_PROVIDERS,
-            explicit_provider="minimax",
-        )
-    msg = str(exc_info.value)
-    # Must name the bad provider so operator knows what they typed
-    assert "minimax" in msg
-    # Must list known providers so operator knows what's available
-    assert "anthropic-oauth" in msg
-    assert "anthropic-api" in msg
-    # Must give actionable next steps — NOT just "not found"
-    assert "providers:" in msg or "Add" in msg
-    assert "Switch" in msg or "runtime" in msg
-
-
-def test_resolve_with_explicit_provider_does_not_silent_fallback():
-    """Specifically: must not return providers[0] when explicit_provider is bogus.
-
-    This is the exact silent-fallback path that caused the user-visible
-    bug: operator picks 'minimax' → adapter returns anthropic-oauth →
-    SDK uses CLAUDE_CODE_OAUTH_TOKEN → hits quota.
-    """
-    with pytest.raises(ValueError):
-        result = _resolve_provider(
-            "anything", _BUILTIN_PROVIDERS,
-            explicit_provider="minimax",
-        )
-        # If the implementation regresses to silent fallback, this would
-        # have returned providers[0] (anthropic-oauth) instead of raising.
-        # Defense-in-depth: guard against accidental "return" inside the
-        # error path.
-        assert result["name"] not in {"anthropic-oauth", "anthropic-api"}, (
-            "REGRESSION: silent fallback to default provider when explicit "
-            "provider name is not in registry — this is the #180 bug."
-        )
-
-
-def test_resolve_with_explicit_provider_in_custom_registry():
-    """When operator adds a third-party provider to the registry, explicit lookup finds it."""
-    custom_registry = _BUILTIN_PROVIDERS + (
-        {
-            "name": "minimax",
-            "auth_mode": "third_party_anthropic_compat",
-            "model_prefixes": ("minimax-",),
-            "model_aliases": (),
-            "base_url": "https://api.minimaxi.com/anthropic-compat",
-            "auth_env": ("MINIMAX_API_KEY",),
-        },
-    )
-    p = _resolve_provider(
-        "MiniMax-M2.7-highspeed", custom_registry,
-        explicit_provider="minimax",
-    )
-    assert p["name"] == "minimax"
-    assert p["base_url"] == "https://api.minimaxi.com/anthropic-compat"
-    assert "MINIMAX_API_KEY" in p["auth_env"]
-
-
-def test_resolve_empty_providers_raises():
-    """Pre-condition: providers must be non-empty (existing behavior preserved)."""
-    with pytest.raises(ValueError, match="empty providers tuple"):
-        _resolve_provider("anything", ())
-
-
-def test_resolve_explicit_empty_string_treated_as_no_explicit():
-    """`provider: ''` (empty string) → fall back to model-based resolution, not raise."""
-    # This shape can happen when the canvas writes an empty provider field.
-    # Treating it as "no explicit pick" is more forgiving than raising,
-    # since the user clearly didn't intend to break their workspace.
-    p = _resolve_provider(
-        "claude-opus-4-7", _BUILTIN_PROVIDERS,
-        explicit_provider="",
-    )
-    assert p["name"] == "anthropic-api"  # fell through to model-based
-
-
-def test_resolve_explicit_none_treated_as_no_explicit():
-    """`explicit_provider=None` (default) → fall back to model-based resolution."""
-    p = _resolve_provider(
-        "claude-opus-4-7", _BUILTIN_PROVIDERS,
-        explicit_provider=None,
-    )
-    assert p["name"] == "anthropic-api"