jeo-code 0.8.4 → 0.8.7

package/CHANGELOG.md

@@ -6,6 +6,38 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.8.7] - 2026-07-08
+_Fix-forward for a CI-caught release failure in v0.8.6 (this same session): `test/launch-prompt-routing.test.ts` shipped with a dropped closing brace (a git 3-way merge misaligned on a duplicate `});` line during this session's own working-tree isolation, then a subsequent `git stash push --keep-index` silently reset the working tree to the pre-fix staged content — the fix was applied once, verified once, then invisibly reverted before the commit that actually shipped). The v0.8.6 GitHub Actions release workflow correctly caught the syntax error at `bun test` and failed BEFORE the npm publish step ran; `npm view jeo-code version` confirmed 0.8.5 remained latest throughout — nothing broken ever reached the registry. Per this repo's established pattern for a same-day CI-caught regression (v0.8.0 → v0.8.1), shipping forward rather than retargeting the already-publicly-failed v0.8.6 tag._
+
+### Fixed
+- **Restored the dropped closing brace** in `test/launch-prompt-routing.test.ts`'s "servability veto: does NOT fire for a Codex id..." test — it was missing `});` for both the `withOpenAiEnvCleared` callback and the outer `test()`, which swallowed the next test's `test(...)` opener into the same block and produced a hard parse error (`error: Unexpected end of file`) under `bun test`.
+
+### Verified
+Full suite 2779/2779 pass, typecheck clean — run directly against the working tree immediately after the fix, with no stash operation between fix and verification this time (the actual root cause of v0.8.6 shipping broken).
+
+## [0.8.6] - 2026-07-08
+_Explicit `/model` pin always winning over PromptRouter was correct but opaque: `/route status` showed "routing: on" even while a session pin blocked routing from ever evaluating a prompt, and there was no way back to routed mode short of restarting the session. Also closed a related escalation gap: `routing.enabled` with `roles.smol` unset made ambiguous-prompt LLM escalation silently skip every turn, even when a cheaper credentialed model existed to run the classifier._
+
+### Added
+- **`/route status` pin visibility** (`src/commands/launch/route-slash.ts`) — a new `pinnedModel` field on `RouteSlashCtx` (threaded from `sessionModel` in `launch.ts`) makes an active session pin print `note: model pinned to '<model>' this session — routing will not evaluate any prompt until the pin is cleared (/model auto)` instead of a bare, misleading `routing: on`. Purely additive — the actual routing gate (`!sessionModel` in `runTurn`) is unchanged.
+- **`/model auto` (alias `/model clear`)** (`src/commands/launch/model-slash.ts`, `src/commands/launch.ts`) — releases an explicit `--model`/`/model <id>` pin, resuming per-turn `PromptRouter` evaluation for the rest of the session (subject to `routing.enabled`). `ModelSlashResult.sessionModel` is now 3-state (`undefined`=unchanged, `string`=new pin, `null`=pin explicitly cleared); `launch.ts` converts `null` to `undefined` so `runTurn`'s routing gate reopens. The "explicit pin always wins" contract itself is untouched — this only adds a way to release it.
+- **`routePrompt` escalation fallback when `roles.smol` is unconfigured** (`src/agent/prompt-router.ts`) — instead of unconditionally skipping LLM escalation for ambiguous prompts, `routePrompt` now falls back to `cheapestCredentialed(config)` (the same live `MODEL_CATALOG` lookup trivial-tier auto-select already uses) as the classifier model. Escalation is only skipped (heuristic-only tier, one-time warning) when that fallback also resolves to `defaultModel` or nothing qualifies at all.
+- **`jeo doctor` routing note synced to the same fallback** (`src/commands/doctor.ts`) — the "roles.smol is unset" note now checks `cheapestCredentialed(config)` before firing, so it stops claiming escalation "will never fire" when a real fallback classifier exists.
+
+### Verified
+Full suite 2778/2778 pass, typecheck clean. 10 new tests (`model-slash` ×4, `route-slash` ×2, `prompt-router` ×2, `launch-prompt-routing` ×2). Live tmux smoke test on the real interactive binary: `/route status` → pin note shown → `/model auto` → "Model pin (...) cleared" notice → `/route status` again → note gone, `routing: on (this session)` only.
+
+## [0.8.5] - 2026-07-08
+_"딥리서치 다음과같이 페이블5 모델이 응답하게 되는경우를 피하기 위해" — a claude-fable-5 turn hit `Error: Refusal (reasoning_extraction): This request was blocked as it seems to violate Anthropic's Terms of Service.` jeo already had a full reactive recovery ladder (context reset → thinking-artifact strip → guidance strip → fail-fast on a category-shaped refusal), but every rung still resends to the SAME model — a deterministic classifier trip re-refuses identically no matter how much context gets stripped. Deep-researched Anthropic's current docs and found the actual fix: a documented, dedicated **server-side fallback** beta released alongside Fable 5 that retries a safety-classifier decline against a different model inside the SAME request, before the caller ever sees an error._
+
+### Added
+- **Anthropic server-side fallback for claude-fable-5** (`src/ai/providers/anthropic.ts`) — API-key calls to `claude-fable-5` (direct api.anthropic.com, no custom baseUrl) now carry `fallbacks: [{model: "claude-opus-4-8"}]` plus the `server-side-fallback-2026-06-01` beta header. Any safety-classifier decline (`reasoning_extraction`, `cyber`, `bio`, `frontier_llm` — not just the one that triggered this) is retried by Anthropic against Opus 4.8 inside the same request/stream; most refusals now resolve transparently and never reach jeo's engine at all. Scoped conservatively: OAuth credentials, a custom `baseUrl` (third-party Anthropic-compatible hosts), and `claude-mythos-5` (invite-only; fallback support unconfirmed for it) are unaffected and keep today's reactive-only recovery. `JEO_ANTHROPIC_FALLBACK=0` opts out.
+- **Fail-safe for accounts without the beta**: a 400 naming "fallback" (unsupported param/beta on that account or endpoint) retries once with the fallback request fields stripped, so a non-GA account degrades silently to prior behavior instead of a hard error.
+- **Reasoning artifacts tagged with the model that ACTUALLY served the turn** (not the originally-requested one) — both `call()` (from the response's top-level `model`) and `stream()` (from `message_start.message.model`, updated again from a mid-stream `fallback` content block's `to.model`). A fallback-served turn's thinking blocks are now correctly attributed to Opus 4.8, so a later same-model replay check (`anthropicNativizable`) neither wrongly nativizes nor wrongly skips them.
+
+### Verified
+Full suite 2760/2760 pass, typecheck clean. Live-mocked-fetch smoke tests confirmed all 6 request/response scenarios (fable-5+api_key qualifies; sonnet-5/mythos-5/OAuth/custom-baseUrl/env-opt-out don't; served-model tagging on both call() and stream(); the 400-fallback-unsupported fail-safe; a refusal that survives the fallback path still throws and classifies exactly as before). Tester added 7 regression tests; all 6 mutation-verified (each independently reddens its own test when reverted).
+
 ## [0.8.4] - 2026-07-08
 _Follow-up to the 0.8.3 `jeo --tmux` E2E verification, which surfaced two real bugs: (1) the fake `test-anthropic-key` fixture found sitting in the user's REAL `~/.jeo/config.json` turned out to be reproducible — jeo's own test suite could silently write to the real config with no guard, and a prior session's routing tests had done exactly that; (2) the E2E run's TUI showed `'antigravity/gemini-pro-agent' is not in the live antigravity catalog` for a model that WAS live — traced to the note firing on a FAILED provider discovery (timeout/expired OAuth) rather than a genuinely absent model._
 

package/README.ja.md

@@ -262,11 +262,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.7]** (2026-07-08) — Fix-forward for a CI-caught release failure in v0.8.6 (this same session): `test/launch-prompt-routing.test.ts` shipped with a dropped closing brace (a git 3-way merge misaligned on a duplicate `});` line during this session's own working-tree isolation, then a subsequent `git stash push --keep-index` silently reset the working tree to the pre-fix staged content — the fix was applied once, verified once, then invisibly reverted before the commit that actually shipped). The v0.8.6 GitHub Actions release workflow correctly caught the syntax error at `bun test` and failed BEFORE the npm publish step ran; `npm view jeo-code version` confirmed 0.8.5 remained latest throughout — nothing broken ever reached the registry. Per this repo's established pattern for a same-day CI-caught regression (v0.8.0 → v0.8.1), shipping forward rather than retargeting the already-publicly-failed v0.8.6 tag.
+- **[0.8.6]** (2026-07-08) — Explicit `/model` pin always winning over PromptRouter was correct but opaque: `/route status` showed "routing: on" even while a session pin blocked routing from ever evaluating a prompt, and there was no way back to routed mode short of restarting the session. Also closed a related escalation gap: `routing.enabled` with `roles.smol` unset made ambiguous-prompt LLM escalation silently skip every turn, even when a cheaper credentialed model existed to run the classifier.
+- **[0.8.5]** (2026-07-08) — "딥리서치 다음과같이 페이블5 모델이 응답하게 되는경우를 피하기 위해" — a claude-fable-5 turn hit `Error: Refusal (reasoning_extraction): This request was blocked as it seems to violate Anthropic's Terms of Service.` jeo already had a full reactive recovery ladder (context reset → thinking-artifact strip → guidance strip → fail-fast on a category-shaped refusal), but every rung still resends to the SAME model — a deterministic classifier trip re-refuses identically no matter how much context gets stripped. Deep-researched Anthropic's current docs and found the actual fix: a documented, dedicated **server-side fallback** beta released alongside Fable 5 that retries a safety-classifier decline against a different model inside the SAME request, before the caller ever sees an error.
 - **[0.8.4]** (2026-07-08) — Follow-up to the 0.8.3 `jeo --tmux` E2E verification, which surfaced two real bugs: (1) the fake `test-anthropic-key` fixture found sitting in the user's REAL `~/.jeo/config.json` turned out to be reproducible — jeo's own test suite could silently write to the real config with no guard, and a prior session's routing tests had done exactly that; (2) the E2E run's TUI showed `'antigravity/gemini-pro-agent' is not in the live antigravity catalog` for a model that WAS live — traced to the note firing on a FAILED provider discovery (timeout/expired OAuth) rather than a genuinely absent model.
 - **[0.8.3]** (2026-07-08) — "잘못된 모델 설정하는 경우가 있는데" — the static Antigravity catalog had drifted badly from the LIVE Cloud Code Assist agent backend, and several current wire ids actively LIE about their tier: `gemini-3-flash-agent` is really "Gemini 3.5 Flash (High)" (the flagship agent model, which the name-suffix heuristic filed under the SMALL flash tier), `gemini-pro-agent` is really "Gemini 3.1 Pro (High)" (the code-agent model), and `gemini-3.1-pro-high` is DEPRECATED by the backend in favor of `gemini-pro-agent`. Probed the real `fetchAvailableModels` response (displayNames + agentModelSorts + deprecatedModelIds) and made it the single source of truth.
-- **[0.8.2]** (2026-07-08) — "프롬프트라우팅이 api 입력을 요구하면서 동작안해" — prompt routing kept demanding an API key even when the user was already logged in via OAuth (GPT showed the same symptom). Root cause: every routing gate was PROVIDER-level ("any stored credential exists") while OAuth credentials are MODEL-level (ChatGPT OAuth serves only Codex ids, Kimi OAuth only the Kimi Code catalog, gemini OAuth nothing at all since the Cloud Code Assist masquerade was removed) — so routing happily picked models the stored login could never serve, and the turn then failed at call time asking for `<PROVIDER>_API_KEY`. Also restored a missing export that had broken `bun run typecheck` on HEAD.
-- **[0.8.1]** (2026-07-08) — Fix-forward for a functional regression this same session shipped in v0.8.0. This repo's working tree is shared with a concurrent interactive session; `git add`-ing `src/ai/provider-status.ts` for v0.8.0's routing-veto-gate fix also swept up that session's already-modified, uncommitted copy of the SAME file (containing an unrelated design change: gemini OAuth alone no longer serving `google/gemini-*` models) without its companion piece in `src/auth/flows/index.ts` — so v0.8.0 shipped with a test suite (`provider-status.test.ts`) asserting behavior whose supporting data flag never landed. CI caught this immediately post-release: 2 failing tests on the exact tagged commit. Investigated, confirmed the missing piece was real (and independently observable live via `jeo doctor` before this session had made ANY of its own edits — not a stray/speculative change), and completed it.
-- **[0.8.0]** (2026-07-08) — Root-caused a genuine reliability bug in the routing veto gate ("라우트가 동작후 api 키인증오류가나오는데 근본적인 원인 개선해"), then regenerated the animated README mascot to visualize the smart cross-provider routing this release cycle has been building: prompt routing that finds the cheapest usable path, with a "money saver" visual motif.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -263,11 +263,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.7]** (2026-07-08) — Fix-forward for a CI-caught release failure in v0.8.6 (this same session): `test/launch-prompt-routing.test.ts` shipped with a dropped closing brace (a git 3-way merge misaligned on a duplicate `});` line during this session's own working-tree isolation, then a subsequent `git stash push --keep-index` silently reset the working tree to the pre-fix staged content — the fix was applied once, verified once, then invisibly reverted before the commit that actually shipped). The v0.8.6 GitHub Actions release workflow correctly caught the syntax error at `bun test` and failed BEFORE the npm publish step ran; `npm view jeo-code version` confirmed 0.8.5 remained latest throughout — nothing broken ever reached the registry. Per this repo's established pattern for a same-day CI-caught regression (v0.8.0 → v0.8.1), shipping forward rather than retargeting the already-publicly-failed v0.8.6 tag.
+- **[0.8.6]** (2026-07-08) — Explicit `/model` pin always winning over PromptRouter was correct but opaque: `/route status` showed "routing: on" even while a session pin blocked routing from ever evaluating a prompt, and there was no way back to routed mode short of restarting the session. Also closed a related escalation gap: `routing.enabled` with `roles.smol` unset made ambiguous-prompt LLM escalation silently skip every turn, even when a cheaper credentialed model existed to run the classifier.
+- **[0.8.5]** (2026-07-08) — "딥리서치 다음과같이 페이블5 모델이 응답하게 되는경우를 피하기 위해" — a claude-fable-5 turn hit `Error: Refusal (reasoning_extraction): This request was blocked as it seems to violate Anthropic's Terms of Service.` jeo already had a full reactive recovery ladder (context reset → thinking-artifact strip → guidance strip → fail-fast on a category-shaped refusal), but every rung still resends to the SAME model — a deterministic classifier trip re-refuses identically no matter how much context gets stripped. Deep-researched Anthropic's current docs and found the actual fix: a documented, dedicated **server-side fallback** beta released alongside Fable 5 that retries a safety-classifier decline against a different model inside the SAME request, before the caller ever sees an error.
 - **[0.8.4]** (2026-07-08) — Follow-up to the 0.8.3 `jeo --tmux` E2E verification, which surfaced two real bugs: (1) the fake `test-anthropic-key` fixture found sitting in the user's REAL `~/.jeo/config.json` turned out to be reproducible — jeo's own test suite could silently write to the real config with no guard, and a prior session's routing tests had done exactly that; (2) the E2E run's TUI showed `'antigravity/gemini-pro-agent' is not in the live antigravity catalog` for a model that WAS live — traced to the note firing on a FAILED provider discovery (timeout/expired OAuth) rather than a genuinely absent model.
 - **[0.8.3]** (2026-07-08) — "잘못된 모델 설정하는 경우가 있는데" — the static Antigravity catalog had drifted badly from the LIVE Cloud Code Assist agent backend, and several current wire ids actively LIE about their tier: `gemini-3-flash-agent` is really "Gemini 3.5 Flash (High)" (the flagship agent model, which the name-suffix heuristic filed under the SMALL flash tier), `gemini-pro-agent` is really "Gemini 3.1 Pro (High)" (the code-agent model), and `gemini-3.1-pro-high` is DEPRECATED by the backend in favor of `gemini-pro-agent`. Probed the real `fetchAvailableModels` response (displayNames + agentModelSorts + deprecatedModelIds) and made it the single source of truth.
-- **[0.8.2]** (2026-07-08) — "프롬프트라우팅이 api 입력을 요구하면서 동작안해" — prompt routing kept demanding an API key even when the user was already logged in via OAuth (GPT showed the same symptom). Root cause: every routing gate was PROVIDER-level ("any stored credential exists") while OAuth credentials are MODEL-level (ChatGPT OAuth serves only Codex ids, Kimi OAuth only the Kimi Code catalog, gemini OAuth nothing at all since the Cloud Code Assist masquerade was removed) — so routing happily picked models the stored login could never serve, and the turn then failed at call time asking for `<PROVIDER>_API_KEY`. Also restored a missing export that had broken `bun run typecheck` on HEAD.
-- **[0.8.1]** (2026-07-08) — Fix-forward for a functional regression this same session shipped in v0.8.0. This repo's working tree is shared with a concurrent interactive session; `git add`-ing `src/ai/provider-status.ts` for v0.8.0's routing-veto-gate fix also swept up that session's already-modified, uncommitted copy of the SAME file (containing an unrelated design change: gemini OAuth alone no longer serving `google/gemini-*` models) without its companion piece in `src/auth/flows/index.ts` — so v0.8.0 shipped with a test suite (`provider-status.test.ts`) asserting behavior whose supporting data flag never landed. CI caught this immediately post-release: 2 failing tests on the exact tagged commit. Investigated, confirmed the missing piece was real (and independently observable live via `jeo doctor` before this session had made ANY of its own edits — not a stray/speculative change), and completed it.
-- **[0.8.0]** (2026-07-08) — Root-caused a genuine reliability bug in the routing veto gate ("라우트가 동작후 api 키인증오류가나오는데 근본적인 원인 개선해"), then regenerated the animated README mascot to visualize the smart cross-provider routing this release cycle has been building: prompt routing that finds the cheapest usable path, with a "money saver" visual motif.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -265,11 +265,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.7]** (2026-07-08) — Fix-forward for a CI-caught release failure in v0.8.6 (this same session): `test/launch-prompt-routing.test.ts` shipped with a dropped closing brace (a git 3-way merge misaligned on a duplicate `});` line during this session's own working-tree isolation, then a subsequent `git stash push --keep-index` silently reset the working tree to the pre-fix staged content — the fix was applied once, verified once, then invisibly reverted before the commit that actually shipped). The v0.8.6 GitHub Actions release workflow correctly caught the syntax error at `bun test` and failed BEFORE the npm publish step ran; `npm view jeo-code version` confirmed 0.8.5 remained latest throughout — nothing broken ever reached the registry. Per this repo's established pattern for a same-day CI-caught regression (v0.8.0 → v0.8.1), shipping forward rather than retargeting the already-publicly-failed v0.8.6 tag.
+- **[0.8.6]** (2026-07-08) — Explicit `/model` pin always winning over PromptRouter was correct but opaque: `/route status` showed "routing: on" even while a session pin blocked routing from ever evaluating a prompt, and there was no way back to routed mode short of restarting the session. Also closed a related escalation gap: `routing.enabled` with `roles.smol` unset made ambiguous-prompt LLM escalation silently skip every turn, even when a cheaper credentialed model existed to run the classifier.
+- **[0.8.5]** (2026-07-08) — "딥리서치 다음과같이 페이블5 모델이 응답하게 되는경우를 피하기 위해" — a claude-fable-5 turn hit `Error: Refusal (reasoning_extraction): This request was blocked as it seems to violate Anthropic's Terms of Service.` jeo already had a full reactive recovery ladder (context reset → thinking-artifact strip → guidance strip → fail-fast on a category-shaped refusal), but every rung still resends to the SAME model — a deterministic classifier trip re-refuses identically no matter how much context gets stripped. Deep-researched Anthropic's current docs and found the actual fix: a documented, dedicated **server-side fallback** beta released alongside Fable 5 that retries a safety-classifier decline against a different model inside the SAME request, before the caller ever sees an error.
 - **[0.8.4]** (2026-07-08) — Follow-up to the 0.8.3 `jeo --tmux` E2E verification, which surfaced two real bugs: (1) the fake `test-anthropic-key` fixture found sitting in the user's REAL `~/.jeo/config.json` turned out to be reproducible — jeo's own test suite could silently write to the real config with no guard, and a prior session's routing tests had done exactly that; (2) the E2E run's TUI showed `'antigravity/gemini-pro-agent' is not in the live antigravity catalog` for a model that WAS live — traced to the note firing on a FAILED provider discovery (timeout/expired OAuth) rather than a genuinely absent model.
 - **[0.8.3]** (2026-07-08) — "잘못된 모델 설정하는 경우가 있는데" — the static Antigravity catalog had drifted badly from the LIVE Cloud Code Assist agent backend, and several current wire ids actively LIE about their tier: `gemini-3-flash-agent` is really "Gemini 3.5 Flash (High)" (the flagship agent model, which the name-suffix heuristic filed under the SMALL flash tier), `gemini-pro-agent` is really "Gemini 3.1 Pro (High)" (the code-agent model), and `gemini-3.1-pro-high` is DEPRECATED by the backend in favor of `gemini-pro-agent`. Probed the real `fetchAvailableModels` response (displayNames + agentModelSorts + deprecatedModelIds) and made it the single source of truth.
-- **[0.8.2]** (2026-07-08) — "프롬프트라우팅이 api 입력을 요구하면서 동작안해" — prompt routing kept demanding an API key even when the user was already logged in via OAuth (GPT showed the same symptom). Root cause: every routing gate was PROVIDER-level ("any stored credential exists") while OAuth credentials are MODEL-level (ChatGPT OAuth serves only Codex ids, Kimi OAuth only the Kimi Code catalog, gemini OAuth nothing at all since the Cloud Code Assist masquerade was removed) — so routing happily picked models the stored login could never serve, and the turn then failed at call time asking for `<PROVIDER>_API_KEY`. Also restored a missing export that had broken `bun run typecheck` on HEAD.
-- **[0.8.1]** (2026-07-08) — Fix-forward for a functional regression this same session shipped in v0.8.0. This repo's working tree is shared with a concurrent interactive session; `git add`-ing `src/ai/provider-status.ts` for v0.8.0's routing-veto-gate fix also swept up that session's already-modified, uncommitted copy of the SAME file (containing an unrelated design change: gemini OAuth alone no longer serving `google/gemini-*` models) without its companion piece in `src/auth/flows/index.ts` — so v0.8.0 shipped with a test suite (`provider-status.test.ts`) asserting behavior whose supporting data flag never landed. CI caught this immediately post-release: 2 failing tests on the exact tagged commit. Investigated, confirmed the missing piece was real (and independently observable live via `jeo doctor` before this session had made ANY of its own edits — not a stray/speculative change), and completed it.
-- **[0.8.0]** (2026-07-08) — Root-caused a genuine reliability bug in the routing veto gate ("라우트가 동작후 api 키인증오류가나오는데 근본적인 원인 개선해"), then regenerated the animated README mascot to visualize the smart cross-provider routing this release cycle has been building: prompt routing that finds the cheapest usable path, with a "money saver" visual motif.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -262,11 +262,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.7]** (2026-07-08) — Fix-forward for a CI-caught release failure in v0.8.6 (this same session): `test/launch-prompt-routing.test.ts` shipped with a dropped closing brace (a git 3-way merge misaligned on a duplicate `});` line during this session's own working-tree isolation, then a subsequent `git stash push --keep-index` silently reset the working tree to the pre-fix staged content — the fix was applied once, verified once, then invisibly reverted before the commit that actually shipped). The v0.8.6 GitHub Actions release workflow correctly caught the syntax error at `bun test` and failed BEFORE the npm publish step ran; `npm view jeo-code version` confirmed 0.8.5 remained latest throughout — nothing broken ever reached the registry. Per this repo's established pattern for a same-day CI-caught regression (v0.8.0 → v0.8.1), shipping forward rather than retargeting the already-publicly-failed v0.8.6 tag.
+- **[0.8.6]** (2026-07-08) — Explicit `/model` pin always winning over PromptRouter was correct but opaque: `/route status` showed "routing: on" even while a session pin blocked routing from ever evaluating a prompt, and there was no way back to routed mode short of restarting the session. Also closed a related escalation gap: `routing.enabled` with `roles.smol` unset made ambiguous-prompt LLM escalation silently skip every turn, even when a cheaper credentialed model existed to run the classifier.
+- **[0.8.5]** (2026-07-08) — "딥리서치 다음과같이 페이블5 모델이 응답하게 되는경우를 피하기 위해" — a claude-fable-5 turn hit `Error: Refusal (reasoning_extraction): This request was blocked as it seems to violate Anthropic's Terms of Service.` jeo already had a full reactive recovery ladder (context reset → thinking-artifact strip → guidance strip → fail-fast on a category-shaped refusal), but every rung still resends to the SAME model — a deterministic classifier trip re-refuses identically no matter how much context gets stripped. Deep-researched Anthropic's current docs and found the actual fix: a documented, dedicated **server-side fallback** beta released alongside Fable 5 that retries a safety-classifier decline against a different model inside the SAME request, before the caller ever sees an error.
 - **[0.8.4]** (2026-07-08) — Follow-up to the 0.8.3 `jeo --tmux` E2E verification, which surfaced two real bugs: (1) the fake `test-anthropic-key` fixture found sitting in the user's REAL `~/.jeo/config.json` turned out to be reproducible — jeo's own test suite could silently write to the real config with no guard, and a prior session's routing tests had done exactly that; (2) the E2E run's TUI showed `'antigravity/gemini-pro-agent' is not in the live antigravity catalog` for a model that WAS live — traced to the note firing on a FAILED provider discovery (timeout/expired OAuth) rather than a genuinely absent model.
 - **[0.8.3]** (2026-07-08) — "잘못된 모델 설정하는 경우가 있는데" — the static Antigravity catalog had drifted badly from the LIVE Cloud Code Assist agent backend, and several current wire ids actively LIE about their tier: `gemini-3-flash-agent` is really "Gemini 3.5 Flash (High)" (the flagship agent model, which the name-suffix heuristic filed under the SMALL flash tier), `gemini-pro-agent` is really "Gemini 3.1 Pro (High)" (the code-agent model), and `gemini-3.1-pro-high` is DEPRECATED by the backend in favor of `gemini-pro-agent`. Probed the real `fetchAvailableModels` response (displayNames + agentModelSorts + deprecatedModelIds) and made it the single source of truth.
-- **[0.8.2]** (2026-07-08) — "프롬프트라우팅이 api 입력을 요구하면서 동작안해" — prompt routing kept demanding an API key even when the user was already logged in via OAuth (GPT showed the same symptom). Root cause: every routing gate was PROVIDER-level ("any stored credential exists") while OAuth credentials are MODEL-level (ChatGPT OAuth serves only Codex ids, Kimi OAuth only the Kimi Code catalog, gemini OAuth nothing at all since the Cloud Code Assist masquerade was removed) — so routing happily picked models the stored login could never serve, and the turn then failed at call time asking for `<PROVIDER>_API_KEY`. Also restored a missing export that had broken `bun run typecheck` on HEAD.
-- **[0.8.1]** (2026-07-08) — Fix-forward for a functional regression this same session shipped in v0.8.0. This repo's working tree is shared with a concurrent interactive session; `git add`-ing `src/ai/provider-status.ts` for v0.8.0's routing-veto-gate fix also swept up that session's already-modified, uncommitted copy of the SAME file (containing an unrelated design change: gemini OAuth alone no longer serving `google/gemini-*` models) without its companion piece in `src/auth/flows/index.ts` — so v0.8.0 shipped with a test suite (`provider-status.test.ts`) asserting behavior whose supporting data flag never landed. CI caught this immediately post-release: 2 failing tests on the exact tagged commit. Investigated, confirmed the missing piece was real (and independently observable live via `jeo doctor` before this session had made ANY of its own edits — not a stray/speculative change), and completed it.
-- **[0.8.0]** (2026-07-08) — Root-caused a genuine reliability bug in the routing veto gate ("라우트가 동작후 api 키인증오류가나오는데 근본적인 원인 개선해"), then regenerated the animated README mascot to visualize the smart cross-provider routing this release cycle has been building: prompt routing that finds the cheapest usable path, with a "money saver" visual motif.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.8.4",
+  "version": "0.8.7",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/engine.ts

@@ -789,6 +789,15 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
         // OTHER refusal shape (bare stop_reason=refusal, finish_reason=content_filter,
         // Gemini finishReason=SAFETY/etc.) genuinely can clear as a rolling classifier
         // resets, so those still get the unbounded capped backoff below.
+        // NOTE (this rung reached at all is now the SECOND line of defense): a
+        // claude-fable-5 API-key call already carries server-side `fallbacks` to
+        // claude-opus-4-8 (see anthropicFallbackModels/postAnthropic's
+        // isFallbackUnsupportedError in providers/anthropic.ts) — Anthropic itself
+        // retries the SAME request against a different model before returning any
+        // error, so most reasoning_extraction/cyber/bio/frontier_llm declines never
+        // reach this ladder at all. This rung remains correct for: non-fable models,
+        // OAuth credentials, a custom baseUrl, or an account without the fallback
+        // beta (none of which carry the proactive fallback).
         const category = /Refusal \(\w+\)/i.test((err as Error)?.message ?? String(err));
         if (category) {
           return finish({ done: false, steps: step, doneReason: `Error: ${friendlyProviderError(err)}` });

package/src/agent/prompt-router.ts

@@ -515,16 +515,30 @@ export async function routePrompt(
 
     if (heuristic.confidence < threshold) {
       const smolModel = resolveRoleModel("smol", config);
-      if (smolModel === config.defaultModel) {
-        // roles.smol not configured -> "escalate to a cheap model" would actually call
-        // defaultModel (expensive) — the exact paradox the design doc identifies. Skip
-        // escalation, keep the heuristic result, and surface a one-time warning.
-        warning = warnOnce(
-          SMOL_UNCONFIGURED_WARNING_KEY,
-          "[route] confidence below threshold but roles.smol is not configured — skipping LLM escalation, using heuristic tier (set roles.smol to enable escalation)",
-        );
+      let classifierModel: string | undefined;
+      if (smolModel !== config.defaultModel) {
+        classifierModel = smolModel;
       } else {
-        const escalated = await escalateToLlm(prompt, smolModel, opts.signal);
+        // roles.smol not configured -> "escalate to a cheap model" would otherwise call
+        // defaultModel (expensive) — the exact paradox the design doc identifies. Rather
+        // than giving up outright, fall back to the cheapest CREDENTIALED catalog model
+        // (same live `MODEL_CATALOG` lookup `resolveTierModel`'s trivial-tier auto-select
+        // already uses) so an ambiguous per-turn prompt still gets a real LLM classification
+        // pass whenever a genuinely cheaper option exists. Only skip escalation entirely
+        // (heuristic-only, one-time warning) when even that fallback resolves to
+        // `defaultModel` itself (nothing cheaper is credentialed) or nothing qualifies at all.
+        const fallback = cheapestCredentialed(config);
+        if (fallback && fallback !== config.defaultModel) {
+          classifierModel = fallback;
+        } else {
+          warning = warnOnce(
+            SMOL_UNCONFIGURED_WARNING_KEY,
+            "[route] confidence below threshold but roles.smol is not configured and no cheaper credentialed model was found — skipping LLM escalation, using heuristic tier (set roles.smol to enable escalation)",
+          );
+        }
+      }
+      if (classifierModel) {
+        const escalated = await escalateToLlm(prompt, classifierModel, opts.signal);
         if (escalated) {
           tier = escalated;
           source = "llm";

package/src/ai/providers/anthropic.ts

@@ -5,6 +5,7 @@ import { readSse } from "../sse";
 import { ProviderHttpError, parseRetryAfter, parseRetryFromBody, providerHttpError } from "./errors";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 import { sanitizeJsonStrings } from "../../util/sanitize-json";
+import { jeoEnv } from "../../util/env";
 
 const ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 
@@ -127,6 +128,28 @@ function parseAnthropicVersion(model: string): { kind: "opus" | "sonnet" | "haik
   return { kind: m[1] as "opus" | "sonnet" | "haiku" | "fable" | "mythos", major: Number(m[2]), minor: m[3] !== undefined ? Number(m[3]) : 0 };
 }
 
+/** Server-side fallback (docs.claude.com/en/docs/build-with-claude/refusals-and-fallback):
+ *  name up to 3 fallback models on the request and Anthropic retries a safety-classifier
+ *  DECLINE (any `stop_details.category` — reasoning_extraction, cyber, bio, frontier_llm)
+ *  against the next model in the SAME request/stream, before jeo's engine ever sees an
+ *  error. Field case: fable-5 turns replaying thinking-block history tripped
+ *  `reasoning_extraction` and re-refused through the whole engine ladder (context reset,
+ *  artifact strip, guidance strip) because every rung resent the SAME model. Scoped to
+ *  `claude-fable-5` (the model this beta's docs are written against — Mythos-5's
+ *  invite-only status makes its fallback support unconfirmed) on a DIRECT api.anthropic.com
+ *  API-key call only: the beta's request/response shape is undocumented for the
+ *  Claude-Code OAuth cloak or a custom baseUrl (Anthropic-compatible third-party hosts),
+ *  so those paths keep today's reactive (post-refusal) recovery unchanged.
+ *  `JEO_ANTHROPIC_FALLBACK=0` opts out entirely. */
+const FALLBACK_BETA = "server-side-fallback-2026-06-01";
+function anthropicFallbackModels(model: string, credential: Credential, baseUrl: string | undefined): string[] {
+  if (jeoEnv("ANTHROPIC_FALLBACK") === "0") return [];
+  if (credential.kind !== "api_key" || baseUrl) return [];
+  const v = parseAnthropicVersion(model);
+  if (!v || v.kind !== "fable") return [];
+  return ["claude-opus-4-8"];
+}
+
 /** Adaptive thinking `display` is supported starting with Opus 4.7. Without it, Opus 4.7/4.8
  *  OMIT thinking content entirely (tokens billed, signature present, but zero visible thought —
  *  the "reasoning doesn't show" bug). Older adaptive models (Opus 4.6, Sonnet 4.6+) reject the
@@ -230,6 +253,7 @@ export function anthropicPayload(
   includeTemperature: boolean,
   credential: Credential = { kind: "none", provider: "anthropic" },
   stripArtifacts = false,
+  disableFallback = false,
 ): string {
   const model = stripAnthropicPrefix(options.model);
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
@@ -303,6 +327,10 @@ export function anthropicPayload(
     payload.tool_choice = { type: "auto" };
   }
   if (stream) payload.stream = true;
+  if (!disableFallback) {
+    const fallbacks = anthropicFallbackModels(model, credential, options.baseUrl);
+    if (fallbacks.length) payload.fallbacks = fallbacks.map(m => ({ model: m }));
+  }
   const system = anthropicSystemBlocks(systemPrompt, model, credential, payload, options.baseUrl);
   if (system) payload.system = system;
   return JSON.stringify(sanitizeJsonStrings(payload));
@@ -315,13 +343,14 @@ export function anthropicRequest(
   stream: boolean,
   includeTemperature: boolean,
   stripArtifacts = false,
+  disableFallback = false,
 ): { url: string; headers: Record<string, string>; body: string } {
   return {
     // Anthropic-compatible providers (z.ai, MiniMax, …) accept the Messages wire
     // format at their own host; an explicit baseUrl pins `${base}/v1/messages`.
     url: options.baseUrl ? `${options.baseUrl.replace(/\/$/, "")}/v1/messages` : ANTHROPIC_URL,
-    headers: { ...headersFor(credential, stream, stripAnthropicPrefix(options.model), options.baseUrl), ...options.extraHeaders },
-    body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts),
+    headers: { ...headersFor(credential, stream, stripAnthropicPrefix(options.model), options.baseUrl, disableFallback), ...options.extraHeaders },
+    body: anthropicPayload(messages, options, stream, includeTemperature, credential, stripArtifacts, disableFallback),
   };
 }
 
@@ -336,6 +365,16 @@ function isReasoningArtifactError(status: number, detail: string): boolean {
   return status === 400 && /thinking|signature|redacted_thinking/i.test(detail);
 }
 
+/** A 400 naming "fallback" means the account/endpoint rejected the `fallbacks`
+ *  param or its beta header — not GA yet, a non-Claude-API Anthropic-compatible
+ *  host, OR (per the docs) the named fallback model can't satisfy a feature THIS
+ *  request uses ("rejects the request up front"). Retry once with fallback
+ *  disabled entirely so the turn survives on today's reactive-recovery path
+ *  instead of dying on an unrelated 400. */
+function isFallbackUnsupportedError(status: number, detail: string): boolean {
+  return status === 400 && /fallback/i.test(detail);
+}
+
 /** gjc parity (getSafeAnthropicHeaderEvidence): fold Anthropic's rate-limit response
  *  headers into a 429's error detail so the retry classifier can see them. The decisive
  *  usage-exhaustion signal (`anthropic-ratelimit-unified-overage-disabled-reason:
@@ -358,8 +397,8 @@ async function postAnthropic(
   credential: Credential,
   stream: boolean,
 ): Promise<Response> {
-  const send = (includeTemperature: boolean, stripArtifacts = false) => {
-    const { url, headers, body } = anthropicRequest(messages, options, credential, stream, includeTemperature, stripArtifacts);
+  const send = (includeTemperature: boolean, stripArtifacts = false, disableFallback = false) => {
+    const { url, headers, body } = anthropicRequest(messages, options, credential, stream, includeTemperature, stripArtifacts, disableFallback);
     return fetch(url, { method: "POST", headers, body, signal: options.signal });
   };
 
@@ -378,6 +417,13 @@ async function postAnthropic(
     if (response.ok) return response;
     throw await providerHttpError("Anthropic", response, stream ? "(stream)" : undefined);
   }
+  // Fail-safe: the account/endpoint doesn't support server-side fallback (or the
+  // named fallback model rejected THIS request's shape) → retry once without it.
+  if (isFallbackUnsupportedError(response.status, detail)) {
+    response = await send(true, false, true);
+    if (response.ok) return response;
+    throw await providerHttpError("Anthropic", response, stream ? "(stream)" : undefined);
+  }
 
   // 429s carry their rate-limit headers in the DETAIL so isUsageLimitError /
   // friendlyProviderError can classify on the full evidence (gjc parity).
@@ -425,14 +471,21 @@ export const anthropicAdapter: ProviderAdapter = {
   supportsNativeTools: true,
   async call(messages, options, credential) {
     const response = await postAnthropic(messages, options, credential, false);
-    const result = (await response.json()) as { content: { type: string; text?: string; name?: string; input?: unknown; thinking?: string; signature?: string; data?: string }[]; stop_reason?: string; stop_details?: { category?: string }; usage?: AnthropicUsage };
+    const result = (await response.json()) as { model?: string; content: { type: string; text?: string; name?: string; input?: unknown; thinking?: string; signature?: string; data?: string }[]; stop_reason?: string; stop_details?: { category?: string }; usage?: AnthropicUsage };
     if (result.usage) options.onUsage?.({ inputTokens: totalInputTokens(result.usage), outputTokens: result.usage.output_tokens });
+    // Tag with the model that ACTUALLY produced the content — on a server-side
+    // fallback (see anthropicFallbackModels), `result.model` names the fallback
+    // model, not `options.model` (the originally requested one). Stamping the
+    // wrong model would make a later same-`options.model` turn wrongly nativize
+    // (or wrongly SKIP nativizing) this artifact — `anthropicNativizable` gates
+    // strictly on an exact model match, so an honest tag is required either way.
+    const servedModel = result.model ?? options.model;
     // Capture thinking/redacted blocks as replay artifacts (parity with the stream path).
     for (const c of result.content) {
       if (c.type === "thinking" && (c.thinking || c.signature)) {
-        options.onReasoningArtifact?.({ provider: "anthropic", model: options.model, text: c.thinking || undefined, signature: c.signature });
+        options.onReasoningArtifact?.({ provider: "anthropic", model: servedModel, text: c.thinking || undefined, signature: c.signature });
       } else if (c.type === "redacted_thinking" && c.data) {
-        options.onReasoningArtifact?.({ provider: "anthropic", model: options.model, redacted: c.data });
+        options.onReasoningArtifact?.({ provider: "anthropic", model: servedModel, redacted: c.data });
       }
     }
     // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
@@ -453,6 +506,12 @@ export const anthropicAdapter: ProviderAdapter = {
     let yieldedAny = false;
     let stopReason: string | undefined;
     let stopCategory: string | undefined;
+    // The model that actually served the response — starts at the requested model,
+    // updated from `message_start.message.model` and, on a mid-stream server-side
+    // fallback (see anthropicFallbackModels), from the `fallback` block's `to.model`.
+    // Reasoning artifacts are tagged with THIS, not `options.model` — see call()'s
+    // matching comment for why an honest tag is required either way.
+    let servedModel = options.model;
     // Native tool_use streams as content_block_start (name) + input_json_delta fragments,
     // never as text_delta — accumulate per block index, then re-serialize to canonical
     // JSON and yield it once at the end (concatenation still equals call()).
@@ -465,9 +524,9 @@ export const anthropicAdapter: ProviderAdapter = {
       let evt: {
         type?: string;
         index?: number;
-        content_block?: { type?: string; name?: string; data?: string };
+        content_block?: { type?: string; name?: string; data?: string; to?: { model?: string } };
         delta?: { type?: string; text?: string; partial_json?: string; thinking?: string; signature?: string; stop_reason?: string; stop_details?: { category?: string } };
-        message?: { usage?: AnthropicUsage; stop_reason?: string; stop_details?: { category?: string } };
+        message?: { model?: string; usage?: AnthropicUsage; stop_reason?: string; stop_details?: { category?: string } };
         usage?: { output_tokens?: number };
       };
       try {
@@ -477,6 +536,18 @@ export const anthropicAdapter: ProviderAdapter = {
       }
       if (evt.type === "content_block_start" && evt.content_block?.type === "tool_use" && typeof evt.index === "number") {
         toolBlocks.set(evt.index, { name: evt.content_block.name ?? "", args: "" });
+      } else if (evt.type === "content_block_start" && evt.content_block?.type === "fallback") {
+        // A safety-classifier decline handed off mid-stream (docs.claude.com's "When the
+        // decline happens mid-output"): an ordinary content_block_start/stop pair with no
+        // deltas, marking the boundary. Everything accumulated so far was produced by the
+        // DECLINING model and must be dropped on replay (thinking/redacted_thinking/
+        // client-side tool_use before the boundary) — best-effort here since a
+        // redacted_thinking block streams its artifact immediately (see below) and can't
+        // be un-sent; the common case (decline BEFORE any output — the bug this fixes)
+        // has nothing accumulated yet, so this branch is rarely reached with state to drop.
+        toolBlocks.clear();
+        thinkBlocks.clear();
+        if (evt.content_block.to?.model) servedModel = evt.content_block.to.model;
       } else if (evt.type === "content_block_start" && evt.content_block?.type === "thinking" && typeof evt.index === "number") {
         thinkBlocks.set(evt.index, { text: "" });
         // Signal the thinking phase started so the UI shows a live "thinking" indicator
@@ -485,7 +556,7 @@ export const anthropicAdapter: ProviderAdapter = {
       } else if (evt.type === "content_block_start" && evt.content_block?.type === "redacted_thinking" && evt.content_block.data) {
         // Redacted thinking carries opaque `data` directly (no deltas) — emit immediately.
         options.onReasoningStart?.();
-        options.onReasoningArtifact?.({ provider: "anthropic", model: options.model, redacted: evt.content_block.data });
+        options.onReasoningArtifact?.({ provider: "anthropic", model: servedModel, redacted: evt.content_block.data });
       } else if (evt.type === "content_block_delta" && evt.delta?.type === "input_json_delta" && typeof evt.index === "number") {
         const b = toolBlocks.get(evt.index);
         if (b) b.args += evt.delta.partial_json ?? "";
@@ -504,6 +575,7 @@ export const anthropicAdapter: ProviderAdapter = {
         tb.signature = (tb.signature ?? "") + evt.delta.signature;
         thinkBlocks.set(evt.index, tb);
       } else if (evt.type === "message_start" && evt.message) {
+        if (evt.message.model) servedModel = evt.message.model;
         if (evt.message.stop_reason) stopReason = evt.message.stop_reason;
         if (evt.message.stop_details?.category) stopCategory = evt.message.stop_details.category;
         if (evt.message.usage) {
@@ -522,7 +594,7 @@ export const anthropicAdapter: ProviderAdapter = {
     for (const tb of thinkBlocks.values()) {
       if (tb.text || tb.signature) {
         yieldedAny = true;
-        options.onReasoningArtifact?.({ provider: "anthropic", model: options.model, text: tb.text || undefined, signature: tb.signature });
+        options.onReasoningArtifact?.({ provider: "anthropic", model: servedModel, text: tb.text || undefined, signature: tb.signature });
       }
     }
     const envelope = serializeAccumulatedToolCalls(toolBlocks);
@@ -581,7 +653,7 @@ function claudeCodeOAuthHeaders(stream: boolean, model: string): Record<string,
   };
 }
 
-function headersFor(credential: Credential, stream: boolean, model: string, baseUrl?: string): Record<string, string> {
+function headersFor(credential: Credential, stream: boolean, model: string, baseUrl?: string, disableFallback = false): Record<string, string> {
   if (credential.kind === "oauth") {
     // OAuth against a NON-Anthropic base (Kimi Code, …): plain bearer, no Claude-Code
     // cloaking headers/betas. gjc parity: buildAnthropicHeaders' generic-bearer branch.
@@ -601,12 +673,14 @@ function headersFor(credential: Credential, stream: boolean, model: string, base
     };
   }
   if (credential.kind === "api_key") {
+    const betas = ANTHROPIC_API_KEY_BETA.slice();
+    if (!disableFallback && anthropicFallbackModels(model, credential, baseUrl).length) betas.push(FALLBACK_BETA);
     return {
       accept: stream ? "text/event-stream" : "application/json",
       "content-type": "application/json",
       "x-api-key": credential.token,
       "anthropic-version": "2023-06-01",
-      "anthropic-beta": anthropicBetaHeader(ANTHROPIC_API_KEY_BETA, model),
+      "anthropic-beta": anthropicBetaHeader(betas, model),
     };
   }
   throw new Error("anthropic adapter requires a credential");

package/src/commands/doctor.ts

@@ -8,7 +8,7 @@ import { meter } from "../tui/components/meter";
 import { size } from "../tui/terminal";
 import chalk from "chalk";
 import { extractChatgptAccountId, CODEX_RESPONSES_URL } from "../ai/providers/openai-responses";
-import { resolveTierModel, tierModelPool } from "../agent/prompt-router";
+import { resolveTierModel, tierModelPool, cheapestCredentialed } from "../agent/prompt-router";
 
 interface ProbeResult {
   status: "ok" | "fail" | "skipped";
@@ -173,20 +173,28 @@ export async function runDoctorCommand(args: string[] = []): Promise<void> {
   const ollamaBase = config.ollamaBaseUrl ?? "http://localhost:11434";
 
   // Routing diagnostic (design doc §7 risk #2): routing.enabled without roles.smol
-  // means routePrompt()'s LLM-escalation path silently never fires — resolveRoleModel
-  // falls back to defaultModel, which is exactly the "cheap escalation call is actually
-  // the expensive default model" paradox routePrompt() itself guards against at runtime
-  // (see prompt-router.ts's warnOnce/SMOL_UNCONFIGURED_WARNING_KEY). Surface it here
-  // proactively, at onboarding time, instead of only mid-session on the first qualifying
-  // turn.
+  // used to mean routePrompt()'s LLM-escalation path silently never fired. It no
+  // longer unconditionally gives up — it now falls back to the cheapest CREDENTIALED
+  // catalog model as the ambiguous-prompt classifier (same live MODEL_CATALOG lookup
+  // resolveTierModel's trivial-tier auto-select already uses), and only skips
+  // escalation entirely when that fallback ALSO resolves to defaultModel (nothing
+  // cheaper is credentialed) or nothing qualifies at all. Mirror that exact condition
+  // here so this note stays accurate instead of unconditionally claiming escalation
+  // "will never fire" — see prompt-router.ts's warnOnce/SMOL_UNCONFIGURED_WARNING_KEY
+  // for the matching runtime-side guard. Surface it here proactively, at onboarding
+  // time, instead of only mid-session on the first qualifying turn.
   const routingEnabled = !!config.routing?.enabled;
   const smolConfigured = !!config.roles?.smol;
   const routingNotes: string[] = [];
   if (routingEnabled && !smolConfigured) {
-    routingNotes.push(
-      "routing is enabled but roles.smol is unset — LLM escalation for ambiguous prompts will never fire; heuristic-only tier resolution applies every turn. Set roles.smol to enable escalation.",
-    );
+    const escalationFallback = cheapestCredentialed(config);
+    if (!escalationFallback || escalationFallback === config.defaultModel) {
+      routingNotes.push(
+        "routing is enabled but roles.smol is unset — LLM escalation for ambiguous prompts will never fire; heuristic-only tier resolution applies every turn. Set roles.smol to enable escalation.",
+      );
+    }
   }
+
   // Proactive credential-readiness check for every model routing could actually pick —
   // mirrors launch.ts's runTurn per-turn veto gate (v0.7.51) but surfaced at onboarding/
   // doctor time instead of only reactively on a session's first qualifying turn. Catches

package/src/commands/launch/model-slash.ts

@@ -1,9 +1,10 @@
 /**
  * `/model` slash-command handler extracted from launch.ts.
  *
- * Handles `/model [id|#N|save [id]|thinking <level>|subagent <role> [model|#N]]`
+ * Handles `/model [id|#N|auto|clear|save [id]|thinking <level>|subagent <role> [model|#N]]`
  * (default: interactive live-model picker on a TTY, else prints the current
  * model + a numbered pick list). This block shares mutable REPL state with
+
  * still-inline commands (`/agents`, `/roles`, `/provider` also read/write
  * `lastPickIndex`; `/thinking` reads/writes `sessionThinking`), so the caller
  * passes the current values in via an explicit context object and reads back
@@ -60,14 +61,18 @@ export interface ModelSlashCtx {
 }
 
 export interface ModelSlashResult {
-  /** Present only when changed. */
-  sessionModel?: string;
+  /** Present only when changed. `null` means the pin was explicitly CLEARED
+   *  (`/model auto`/`/model clear`) — distinct from `undefined` ("unchanged"),
+   *  since `sessionModel` itself must become `undefined` in the caller so
+   *  `runTurn`'s `!sessionModel` routing gate re-opens for the rest of the session. */
+  sessionModel?: string | null;
   /** Present only when changed. */
   sessionThinking?: ThinkLevel;
   /** Present only when the block builds/refreshes a pick list. */
   lastPickIndex?: PickEntry[];
 }
 
+
 /**
  * Handle `/model [id|#N|save|thinking <level>|subagent <role> ...]`. Extracted
  * verbatim from launch.ts's inline REPL branch — the caller keeps the
@@ -91,6 +96,26 @@ export async function runModelSlash(input: string, ctx: ModelSlashCtx): Promise<
   });
 
   let arg = input.substring(6).trim();
+  // `/model auto` (or `/model clear`) releases an explicit pin (set by a prior
+  // `--model`/`/model <id>`), resuming per-turn PromptRouter evaluation for the
+  // rest of this session (subject to routing.enabled) — the release valve for
+  // the pin-always-wins contract, which otherwise gives no way back to routed
+  // mode short of restarting `jeo launch` with no `--model`. Distinct from
+  // `/model save`, which PERSISTS a pin; this clears the session-local one only
+  // (never touches ~/.jeo/config.json's defaultModel).
+  if (arg === "auto" || arg === "clear") {
+    if (!sessionModel) {
+      console.log("No model pin is active this session — routing already evaluates every turn (if routing.enabled).");
+      return result();
+    }
+    console.log(`Model pin ('${sessionModel}') cleared — routing resumes evaluating every turn (if routing.enabled); falls back to '${defaultModel}' whenever routing is off or produces no decision.`);
+    return {
+      sessionModel: null,
+      ...(sessionThinkingChanged ? { sessionThinking } : {}),
+      ...(lastPickIndexChanged ? { lastPickIndex } : {}),
+    };
+  }
+
   // `/model save [id]` → persist the (session or given) model as the config default.
   if (arg === "save" || arg.startsWith("save ")) {
     let toSave = arg.slice(4).trim();

package/src/commands/launch/route-slash.ts

@@ -23,8 +23,14 @@ export interface RouteSlashCtx {
   /** `turnConfig.routing?.enabled ?? false`, read fresh by the caller. */
   routingConfigEnabled: boolean;
   lastRouteDecision: RouteDecision | { note: string } | null;
+  /** The session's explicit model pin (`sessionModel`, from `--model`/`/model`),
+   *  if any. Threaded through purely for `/route status`'s visibility note below —
+   *  never changes routing's actual gating logic (`!sessionModel` in launch.ts's
+   *  `runTurn` stays the single source of truth for whether routing engages). */
+  pinnedModel?: string;
 }
 
+
 export interface RouteSlashResult {
   /** Present only when changed by "on"/"off". */
   sessionRouteOverride?: boolean | undefined;
@@ -69,9 +75,17 @@ export function runRouteSlash(input: string, ctx: RouteSlashCtx): RouteSlashResu
     if (isRealDecision(ctx.lastRouteDecision)) {
       lines.push(`last decision: ${ctx.lastRouteDecision.tier} → ${ctx.lastRouteDecision.model} (${ctx.lastRouteDecision.source}: ${ctx.lastRouteDecision.signals.join(", ") || "none"}, confidence ${ctx.lastRouteDecision.confidence.toFixed(2)})`);
     }
+    // A model pin (`--model`/`/model`) unconditionally blocks routing regardless of
+    // this session's on/off toggle — surface that explicitly here, since "routing: on"
+    // read alone is misleading if it will never actually evaluate a prompt. Use
+    // /model auto to release the pin and let routing resume.
+    if (ctx.pinnedModel) {
+      lines.push(`note: model pinned to '${ctx.pinnedModel}' this session — routing will not evaluate any prompt until the pin is cleared (/model auto)`);
+    }
     return { lines };
   }
 
+
   if (sub === "on") {
     return { sessionRouteOverride: true, lines: ["routing: on (this session)"] };
   }

package/src/commands/launch.ts

@@ -4166,7 +4166,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           isTTY: !!(process.stdin.isTTY && process.stdout.isTTY),
           getLiveModels, applyPickedModelWithTarget, persistSessionModel, pickLiveProviderModel,
         });
-        if (modelResult.sessionModel !== undefined) sessionModel = modelResult.sessionModel;
+        // `null` (from `/model auto`/`/model clear`) means "release the pin", NOT
+        // "unchanged" — `sessionModel` must become `undefined` so `runTurn`'s
+        // `!sessionModel` routing gate re-opens for the rest of this session.
+        if (modelResult.sessionModel !== undefined) sessionModel = modelResult.sessionModel === null ? undefined : modelResult.sessionModel;
         if (modelResult.sessionThinking !== undefined) sessionThinking = modelResult.sessionThinking;
         if (modelResult.lastPickIndex !== undefined) lastPickIndex = modelResult.lastPickIndex;
         continue;
@@ -4177,6 +4180,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           sessionRouteOverride,
           routingConfigEnabled: !!cfgNow.routing?.enabled,
           lastRouteDecision,
+          pinnedModel: sessionModel,
         });
         if (routeResult.sessionRouteOverride !== undefined) sessionRouteOverride = routeResult.sessionRouteOverride;
         for (const line of routeResult.lines) console.log(line);