jeo-code 0.8.15 → 0.8.17

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.17] - 2026-07-09
+_"서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns._
+
+### Fixed
+- **README `/route on` semantics corrected** (`README.md`, `README.ko.md`, `README.ja.md`, `README.zh.md`) — the caution block previously said the model pin releases "until `/route on` with no pin active", which has the mechanism backwards: `/route on` (`src/commands/launch/route-slash.ts:93-98`) sets `sessionRouteOverride = true`, which *outranks* an active `sessionModel` pin without clearing it — the pin reasserts itself the instant `/route off` runs (confirmed by the existing `test/launch-prompt-routing.test.ts` "/route on then /route off" regression). Only `/model auto` actually clears the pin (`sessionModel = undefined`).
+- **README tier-fallback claim scoped correctly** — the caution block previously implied any tier missing a `roles.*` entry falls back to `defaultModel` on every turn. `resolveTierModel` (`src/agent/prompt-router.ts:464-472`) only guarantees that for the `standard` tier; `high` and `complex` first run a live credentialed-model scan (`strongestMidTierCredentialed` / `strongestCredentialed`) before falling back, so they can still resolve to a different model each turn even when unconfigured. Reworded in all 4 languages; also fixed a KO/JA translation drift that narrowed "a tier" to "상위 티어"/"上位ティア" (upper tier), which had no counterpart in the EN/ZH text.
+
+### Added
+- **Mid-session `/model <name>` slash-command lock + persistence coverage** (`test/launch-prompt-routing.test.ts`) — 3 new tests proving the pin set by literally typing `/model <name>` (not just the `--model` CLI flag) holds on the very next turn, persists across 3+ consecutive subsequent turns with no further commands, and correctly cycles through pin → `/model auto` release → re-pin to a different model.
+- **Tier-resolution freshness + scoping coverage** (`test/prompt-router-tiers.test.ts`) — 2 new tests proving `resolveTierModel` has no cross-call caching (interleaved trivial/complex/trivial calls never bleed into each other) and asserting the standard/high/complex fallback-boundary contrast in one place (`standard` and `high` fall through to `defaultModel` on an OpenAI-only fixture with no mid-class model, `complex` does not) as a regression guard against this exact scope-of-claim mistake recurring silently.
+
+### Verified
+- `bun test test/launch-prompt-routing.test.ts` — 38 pass / 0 fail (35 pre-existing + 3 new).
+- `bun test test/prompt-router-tiers.test.ts test/prompt-router.test.ts` — 86 pass / 0 fail (84 pre-existing + 2 new).
+- Full `bun test` — 2877 pass / 0 fail across 290 files.
+- `bun run typecheck` — no errors.
+- Live PTY re-verification (`bun src/cli.ts`, isolated `JEO_CONFIG_DIR`, real Anthropic credentials): trivial prompt → routed to `roles.smol`; `/model claude-sonnet-4-6` → next trivial prompt stayed pinned (no `[route]` notice, confirmed via raw byte-stream regex search, not just screen snapshot); `/model auto` → next trivial prompt re-routed to `roles.smol` again. Closes the one claim that was previously only inferred from a code comment.
+
+## [0.8.16] - 2026-07-09
+_"jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind._
+
+### Added
+- **`/computer [status|on|off]` slash command** (`src/commands/launch/computer-slash.ts`, `src/commands/launch.ts`, `src/tui/components/slash.ts`) — mirrors `/route`'s session-local-override pattern. `executeComputerAction` (`src/commands/computer.ts`) now accepts an `opts.enabledOverride` that wins over `config.computer.enabled` when set, and forwards through batched sub-actions. `/computer on|off` sets a REPL-local override for the current session only (never persisted); `/computer status` reports the effective on/off state and reminds the caller that the fail-closed `computerSupervisor` kill-switch/heartbeat gate still applies independently to every non-read-only action.
+- **New mascot artwork** (`assets/character-v2.png`) — a second character illustration (god-tibo-imagen / `gti`, same crimson-shell/cyan-magenta-glasses/purple-DNA-robe identity as `character.png`) depicting the mascot piloting the desktop-automation control panel while juggling provider-routing nodes, tying the two headline features (prompt routing, computer use) into one image.
+
+### Verified
+- `bun run typecheck` — no errors.
+- `bun test test/computer-slash.test.ts test/computer.test.ts test/computer-supervisor.test.ts test/engine-computer-wiring.test.ts` — 25 pass / 0 fail (new `/computer` subcommand coverage + `enabledOverride` true/false end-to-end execution cases).
+- `bun test test/slash.test.ts` — 30 pass / 0 fail (palette prefix-match fixture updated for the new `/computer` entry).
+- Full `bun test` — 2843 pass / 1 pre-existing unrelated flake (`reachability veto: ...unreachable ollama model...`), 0 fail introduced by this change.
+
+
 ## [0.8.15] - 2026-07-09
 _"api 인증 모델도 사용가능하도록 딥리서치하고 개선해줘" — traced the API-authenticated GPT path to a routing catalog gap: `GET /models` with an OpenAI API key or an OpenAI-compatible provider returned real account-scoped model ids, and `/model` could show/pin them, but prompt routing still built its auto-select pools from static `MODEL_CATALOG` rows only. A custom `openaiBaseUrl` made this worse by treating every public OpenAI row as servable, so routing could choose `gpt-*`/`o*` ids that the configured local/Azure/proxy endpoint never listed._
 

package/README.ja.md

@@ -90,6 +90,9 @@ jeo --tmux               # 独立した tmux セッションで実行
 | `/theme` · `/config` · `/help` | テーマ、ランタイム設定、ヘルプ |
 | `jeo autopilot status` | スコア方向、keep/revert 数、次アクションを示す ratchet ステータスフィールド |
 
+> [!CAUTION]
+> **`/model <name>` で特定モデルを手動指定すると、そのセッション中ルーティングが固定されます。** プロンプトルーティング(`/route`)はモデルが手動固定されていない間のみ毎ターン再評価されます。`/model <name>` で特定モデルを選ぶとその選択が固定され、`/model auto`(ピンを完全に解除)を実行するか、`/route on`(ピンを消さずに優先度だけ上げる — `/route off` した瞬間ピンが復活)を実行するまでルーティングは切り替わりません。`roles.*` 未設定時に `defaultModel` へ確定フォールバックするのは `standard` ティアのみで、`high`/`complex` ティアはフォールバック前にライブでクレデンシャル済みの最強モデルを先に探索するため、未設定でも毎ターン別モデルに着地することがあります。
+
 ## Spec-first ワークフロー
 
 要件 → プラン → 承認 → 実行 → 検証が `.jeo/state/` で繋がり、各ハンドオフに**ブロック可能な本物のゲート**があります:
@@ -262,11 +265,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
+- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 - **[0.8.15]** (2026-07-09) — "api 인증 모델도 사용가능하도록 딥리서치하고 개선해줘" — traced the API-authenticated GPT path to a routing catalog gap: `GET /models` with an OpenAI API key or an OpenAI-compatible provider returned real account-scoped model ids, and `/model` could show/pin them, but prompt routing still built its auto-select pools from static `MODEL_CATALOG` rows only. A custom `openaiBaseUrl` made this worse by treating every public OpenAI row as servable, so routing could choose `gpt-*`/`o*` ids that the configured local/Azure/proxy endpoint never listed.
 - **[0.8.14]** (2026-07-09) — "GPT 연결 실패가 여전히 무응답으로 끝나는 케이스를 잡아줘" — traced the remaining GPT/routing failure path to post-call continuity: the route target could be credentialed and servable, but still end a turn with a recoverable terminal result such as plain `OpenAI returned no content`, rate/quota pressure, model unavailable/not found, or an invalid agent-tool response. jeo already knew the prompt tier and equivalent credentialed fallbacks, but it only applied that fallback before the model call. After the call failed, the turn stopped instead of trying another model in the same tier.
 - **[0.8.13]** (2026-07-09) — "테스트검증 jeo --tmux 로 진행해줘" — traced a routing recovery weakness that survived the earlier credential, servability, and local reachability vetoes: once a configured route target was rejected, jeo threw away the whole routing decision and dropped to the session/default model even when the same prompt tier had another credentialed, servable model available. That kept turns working, but it also silently undid routing's cost/latency goal and made `/route why` less useful because the recorded decision was a fallback note instead of the actual model used.
-- **[0.8.12]** (2026-07-08) — "제오코드에서 oauth 지피티 모델 연결이 안되는데 원인파악해서 개선해" — root-caused a structural drift bug: OpenAI's live Codex models endpoint (`chatgpt.com/backend-api/codex/models`, the SAME endpoint the `/model` picker discovers from) had shipped `gpt-5.4-mini` alongside `gpt-5.5`/`gpt-5.4`, but jeo's static OAuth allow-list (`CODEX_MODELS`) hadn't caught up — the picker correctly listed the model (straight from that live endpoint), but selecting or calling it then hit a hard-coded `CODEX_MODELS.includes(...)` gate that rejected it with "OpenAI OAuth credential only supports Codex models", even though the account's own OAuth token genuinely serves it. This is a whole class of bug: it recurs every time OpenAI ships a new Codex model between jeo releases, and previously required a jeo update to fix each time.
-- **[0.8.11]** (2026-07-08) — "프롬프트 라우팅 동작이 Error: Unable to connect. Is the computer able to access the url? Error: Was there a typo in the url or port? 와 같은 메시지 남기고 동작안하는데 원인을 파악하고 근본문제해결하자" — traced the raw, provider-less connection error to two compounding gaps. (1) `describeProvider` reports local providers (ollama/lmstudio) as `ready: true` UNCONDITIONALLY — "keyless" only means no credential is required, never that the server is actually reachable — so the routing veto gate (which exists precisely to keep a misconfigured routing target from making a turn worse than routing being off) had no way to catch a `routing.tiers`/`roles` pin to a downed local server. (2) Bun's fetch/undici throws a bare `Error("Unable to connect. Is the computer able to access the url?")` with `.code === "ConnectionRefused"` for BOTH a refused connection and an unresolvable host — no HTTP status, no provider name, no URL — and this fell through every existing error classifier (`defaultRetryable`, `friendlyProviderError`) to reach the user completely unfiltered.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -91,6 +91,9 @@ jeo --tmux               # 독립 tmux 세션에서 실행
 | `/theme` · `/config` · `/help` | 테마, 런타임 설정, 도움말 |
 | `jeo autopilot status` | 점수 방향, keep/revert 횟수, 다음 액션을 보여주는 ratchet 상태 필드 |
 
+> [!CAUTION]
+> **`/model <name>`으로 특정 모델을 수동 지정하면 그 세션 동안 라우팅이 고정됩니다.** 프롬프트 라우팅(`/route`)은 모델이 수동으로 고정되지 않은 동안만 매 턴 재평가됩니다. `/model <name>`으로 특정 모델을 선택하면 그 선택이 그대로 고정되며, `/model auto`(핀을 완전히 해제)를 실행하거나 `/route on`(핀을 지우지 않고 그보다 우선순위를 높임 — `/route off` 하는 즉시 핀이 다시 살아남)을 실행하기 전까지는 라우팅이 다시 전환되지 않습니다. `roles.*` 항목 미설정 시 `defaultModel`로 확정 폴백되는 건 `standard` 티어뿐이며, `high`/`complex` 티어는 폴백 전에 실시간으로 크레덴셜된 가장 강력한 모델을 먼저 탐색하므로, 설정이 없어도 매 턴 다른 모델로 갈 수 있습니다.
+
 ## Spec-first 워크플로
 
 요구사항 → 플랜 → 승인 → 실행 → 검증이 `.jeo/state/`로 이어지며, 모든 핸드오프에 **차단 가능한 진짜 게이트**가 있습니다:
@@ -263,11 +266,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
+- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 - **[0.8.15]** (2026-07-09) — "api 인증 모델도 사용가능하도록 딥리서치하고 개선해줘" — traced the API-authenticated GPT path to a routing catalog gap: `GET /models` with an OpenAI API key or an OpenAI-compatible provider returned real account-scoped model ids, and `/model` could show/pin them, but prompt routing still built its auto-select pools from static `MODEL_CATALOG` rows only. A custom `openaiBaseUrl` made this worse by treating every public OpenAI row as servable, so routing could choose `gpt-*`/`o*` ids that the configured local/Azure/proxy endpoint never listed.
 - **[0.8.14]** (2026-07-09) — "GPT 연결 실패가 여전히 무응답으로 끝나는 케이스를 잡아줘" — traced the remaining GPT/routing failure path to post-call continuity: the route target could be credentialed and servable, but still end a turn with a recoverable terminal result such as plain `OpenAI returned no content`, rate/quota pressure, model unavailable/not found, or an invalid agent-tool response. jeo already knew the prompt tier and equivalent credentialed fallbacks, but it only applied that fallback before the model call. After the call failed, the turn stopped instead of trying another model in the same tier.
 - **[0.8.13]** (2026-07-09) — "테스트검증 jeo --tmux 로 진행해줘" — traced a routing recovery weakness that survived the earlier credential, servability, and local reachability vetoes: once a configured route target was rejected, jeo threw away the whole routing decision and dropped to the session/default model even when the same prompt tier had another credentialed, servable model available. That kept turns working, but it also silently undid routing's cost/latency goal and made `/route why` less useful because the recorded decision was a fallback note instead of the actual model used.
-- **[0.8.12]** (2026-07-08) — "제오코드에서 oauth 지피티 모델 연결이 안되는데 원인파악해서 개선해" — root-caused a structural drift bug: OpenAI's live Codex models endpoint (`chatgpt.com/backend-api/codex/models`, the SAME endpoint the `/model` picker discovers from) had shipped `gpt-5.4-mini` alongside `gpt-5.5`/`gpt-5.4`, but jeo's static OAuth allow-list (`CODEX_MODELS`) hadn't caught up — the picker correctly listed the model (straight from that live endpoint), but selecting or calling it then hit a hard-coded `CODEX_MODELS.includes(...)` gate that rejected it with "OpenAI OAuth credential only supports Codex models", even though the account's own OAuth token genuinely serves it. This is a whole class of bug: it recurs every time OpenAI ships a new Codex model between jeo releases, and previously required a jeo update to fix each time.
-- **[0.8.11]** (2026-07-08) — "프롬프트 라우팅 동작이 Error: Unable to connect. Is the computer able to access the url? Error: Was there a typo in the url or port? 와 같은 메시지 남기고 동작안하는데 원인을 파악하고 근본문제해결하자" — traced the raw, provider-less connection error to two compounding gaps. (1) `describeProvider` reports local providers (ollama/lmstudio) as `ready: true` UNCONDITIONALLY — "keyless" only means no credential is required, never that the server is actually reachable — so the routing veto gate (which exists precisely to keep a misconfigured routing target from making a turn worse than routing being off) had no way to catch a `routing.tiers`/`roles` pin to a downed local server. (2) Bun's fetch/undici throws a bare `Error("Unable to connect. Is the computer able to access the url?")` with `.code === "ConnectionRefused"` for BOTH a refused connection and an unresolvable host — no HTTP status, no provider name, no URL — and this fell through every existing error classifier (`defaultRetryable`, `friendlyProviderError`) to reach the user completely unfiltered.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -17,8 +17,10 @@
 
 <p align="center">
   <img src="assets/character.gif" alt="animated jeo-code red crayfish mascot smart-routing a prompt to the cheapest provider and saving coins" width="320" />
+  <img src="assets/character-v2.png" alt="jeo-code red crayfish mascot piloting the computer-use desktop-automation control panel while juggling prompt-routing provider nodes" width="320" />
 </p>
 
+
 <p align="center">
   <b>English</b> ·
   <a href="README.ko.md">한국어</a> ·
@@ -38,7 +40,10 @@ Run `jeo` inside a repository and it reads files, edits them, runs commands, and
 
 ## Highlights
 
+- **Prompt routing (cost-aware, credential-aware)** — every turn can auto-route to a tier-appropriate model among only the providers your configured credentials actually serve (`/route [status|on|off|why]`), with a live equivalent-model fallback whenever a routed provider is rate-limited, unauthenticated, unreachable, or silently times out — see `/route why` for the last decision.
+- **Computer use (desktop automation)** — a fail-closed `computer` tool (screenshot/click/type/scroll/drag/batch) gated by both a config flag and an independent kill-switch/heartbeat supervisor; toggle it for the current session with `/computer [status|on|off]` without touching `~/.jeo/config.json`.
 - **Multi-provider, one loop** — Anthropic / OpenAI (+Codex) / Gemini / Antigravity / Ollama / LM Studio, plus 20+ OpenAI- and Anthropic-compatible clouds (Groq, DeepSeek, Mistral, OpenRouter, xAI, Kimi, z.ai, …), all behind one uniform JSON tool loop. OAuth login happens from the input box (`/provider login`), every model pick persists as the new default, and prompt routing only auto-selects usable credentialed paths: Gemini OAuth goes through the provider-qualified `antigravity/*` agent set (Gemini 3.5 Flash tiers, Gemini 3.1 Pro, Claude Sonnet/Opus 4.6), never public `google/gemini-*` rows that require `GEMINI_API_KEY`; if a configured route points at an unready provider, jeo switches to an equivalent credentialed tier model before falling back to the default.
+
 - **Edit integrity** — read output carries content anchors (`42ab|`); anchored edits are verified against the current file, re-mapped when lines shifted, and rejected with fresh content instead of corrupting.
 - **Self-correcting verification loop** — configure a post-edit hook (tsc / eslint / tests) and the agent *sees* the diagnostics and fixes them in-loop; a red hook blocks `done` until resolved.
 - **Real gates, no theater** — `ralplan` consensus is a repo-grounded critic subagent whose `[OKAY]` verdict is persisted and *required* by `jeo approve`; `ultragoal` reports honestly (a suite run is a global signal, never fabricated per-criterion passes).
@@ -91,6 +96,9 @@ Inside the `jeo` REPL (Tab autocompletes; `/` opens the palette).
 | `/theme` · `/config` · `/help` | Theme, runtime config, help |
 | `jeo autopilot status` | Ratchet status field with score direction, keep/revert counts, and next action |
 
+> [!CAUTION]
+> **`/model <name>` locks routing for the rest of the session.** Prompt routing (`/route`) only re-evaluates per turn while no model is manually pinned. Picking a specific model via `/model <name>` freezes that choice — routing will *not* switch away from it again until you run `/model auto` (which clears the pin), or `/route on` (which *outranks* an active pin without clearing it — the pin reasserts itself the moment you run `/route off`). Missing a `roles.*` entry only guarantees a `defaultModel` fallback on the `standard` tier; the `high`/`complex` tiers first scan for the strongest live-credentialed model before falling back, so they can still land on a different model each turn even when unconfigured.
+
 ## Spec-first workflow
 
 Requirements → plan → approval → execution → verification, carried through `.jeo/state/` with **real, blocking gates** at every handoff:
@@ -265,11 +273,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.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
+- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 - **[0.8.15]** (2026-07-09) — "api 인증 모델도 사용가능하도록 딥리서치하고 개선해줘" — traced the API-authenticated GPT path to a routing catalog gap: `GET /models` with an OpenAI API key or an OpenAI-compatible provider returned real account-scoped model ids, and `/model` could show/pin them, but prompt routing still built its auto-select pools from static `MODEL_CATALOG` rows only. A custom `openaiBaseUrl` made this worse by treating every public OpenAI row as servable, so routing could choose `gpt-*`/`o*` ids that the configured local/Azure/proxy endpoint never listed.
 - **[0.8.14]** (2026-07-09) — "GPT 연결 실패가 여전히 무응답으로 끝나는 케이스를 잡아줘" — traced the remaining GPT/routing failure path to post-call continuity: the route target could be credentialed and servable, but still end a turn with a recoverable terminal result such as plain `OpenAI returned no content`, rate/quota pressure, model unavailable/not found, or an invalid agent-tool response. jeo already knew the prompt tier and equivalent credentialed fallbacks, but it only applied that fallback before the model call. After the call failed, the turn stopped instead of trying another model in the same tier.
 - **[0.8.13]** (2026-07-09) — "테스트검증 jeo --tmux 로 진행해줘" — traced a routing recovery weakness that survived the earlier credential, servability, and local reachability vetoes: once a configured route target was rejected, jeo threw away the whole routing decision and dropped to the session/default model even when the same prompt tier had another credentialed, servable model available. That kept turns working, but it also silently undid routing's cost/latency goal and made `/route why` less useful because the recorded decision was a fallback note instead of the actual model used.
-- **[0.8.12]** (2026-07-08) — "제오코드에서 oauth 지피티 모델 연결이 안되는데 원인파악해서 개선해" — root-caused a structural drift bug: OpenAI's live Codex models endpoint (`chatgpt.com/backend-api/codex/models`, the SAME endpoint the `/model` picker discovers from) had shipped `gpt-5.4-mini` alongside `gpt-5.5`/`gpt-5.4`, but jeo's static OAuth allow-list (`CODEX_MODELS`) hadn't caught up — the picker correctly listed the model (straight from that live endpoint), but selecting or calling it then hit a hard-coded `CODEX_MODELS.includes(...)` gate that rejected it with "OpenAI OAuth credential only supports Codex models", even though the account's own OAuth token genuinely serves it. This is a whole class of bug: it recurs every time OpenAI ships a new Codex model between jeo releases, and previously required a jeo update to fix each time.
-- **[0.8.11]** (2026-07-08) — "프롬프트 라우팅 동작이 Error: Unable to connect. Is the computer able to access the url? Error: Was there a typo in the url or port? 와 같은 메시지 남기고 동작안하는데 원인을 파악하고 근본문제해결하자" — traced the raw, provider-less connection error to two compounding gaps. (1) `describeProvider` reports local providers (ollama/lmstudio) as `ready: true` UNCONDITIONALLY — "keyless" only means no credential is required, never that the server is actually reachable — so the routing veto gate (which exists precisely to keep a misconfigured routing target from making a turn worse than routing being off) had no way to catch a `routing.tiers`/`roles` pin to a downed local server. (2) Bun's fetch/undici throws a bare `Error("Unable to connect. Is the computer able to access the url?")` with `.code === "ConnectionRefused"` for BOTH a refused connection and an unresolvable host — no HTTP status, no provider name, no URL — and this fell through every existing error classifier (`defaultRetryable`, `friendlyProviderError`) to reach the user completely unfiltered.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -90,6 +90,9 @@ jeo --tmux               # 在独立 tmux 会话中运行
 | `/theme` · `/config` · `/help` | 主题、运行时配置、帮助 |
 | `jeo autopilot status` | 显示分数方向、keep/revert 次数和下一步动作的 ratchet 状态字段 |
 
+> [!CAUTION]
+> **通过 `/model <name>` 手动指定模型后，路由会在本会话内保持锁定。** Prompt routing(`/route`)只在没有手动锁定模型时才会逐轮重新评估。用 `/model <name>` 选定具体模型后，该选择会被锁定 — 直到你运行 `/model auto`(彻底解除锁定)，或运行 `/route on`(不会清除锁定，只是优先级更高 — 一旦运行 `/route off`，锁定会立刻恢复)之前，路由都不会再切换。未配置 `roles.*` 条目时，只有 `standard` 层级会确定性地退回到 `defaultModel`；`high`/`complex` 层级会先实时扫描已配置凭证中最强的可用模型再决定是否回退，所以即使未配置，也可能每轮落到不同的模型上。
+
 ## Spec-first 工作流
 
 需求 → 计划 → 批准 → 执行 → 验证，经由 `.jeo/state/` 串联，每次交接都有**可阻断的真实门禁**:
@@ -262,11 +265,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.17]** (2026-07-09) — "서브에이전트 이용해. 병렬루 부가 나머지모두 개선하고 검증후 배포까지하자" — a prior 4-way parallel subagent cross-verification pass found the README `[!CAUTION]` routing-lock block (added this session for "프롬프트 라우팅이 한번 정해지면 안바뀌는데?") was directionally correct but had 2 real inaccuracies, plus a concrete test-coverage gap: every existing pin/override regression test drove the lock via the `--model` CLI startup flag, never via typing `/model <name>` as an interactive slash command mid-session, and none proved persistence across 3+ consecutive turns.
+- **[0.8.16]** (2026-07-09) — "jeo code의 computer use 기능은 / 명령어로 설정할수있도록하고, 실동작검증까지진행해줘" — the desktop-automation `computer` tool was only togglable by hand-editing `computer.enabled` in `~/.jeo/config.json`; there was no in-session way to enable it for a single run without leaving a permanent config change behind.
 - **[0.8.15]** (2026-07-09) — "api 인증 모델도 사용가능하도록 딥리서치하고 개선해줘" — traced the API-authenticated GPT path to a routing catalog gap: `GET /models` with an OpenAI API key or an OpenAI-compatible provider returned real account-scoped model ids, and `/model` could show/pin them, but prompt routing still built its auto-select pools from static `MODEL_CATALOG` rows only. A custom `openaiBaseUrl` made this worse by treating every public OpenAI row as servable, so routing could choose `gpt-*`/`o*` ids that the configured local/Azure/proxy endpoint never listed.
 - **[0.8.14]** (2026-07-09) — "GPT 연결 실패가 여전히 무응답으로 끝나는 케이스를 잡아줘" — traced the remaining GPT/routing failure path to post-call continuity: the route target could be credentialed and servable, but still end a turn with a recoverable terminal result such as plain `OpenAI returned no content`, rate/quota pressure, model unavailable/not found, or an invalid agent-tool response. jeo already knew the prompt tier and equivalent credentialed fallbacks, but it only applied that fallback before the model call. After the call failed, the turn stopped instead of trying another model in the same tier.
 - **[0.8.13]** (2026-07-09) — "테스트검증 jeo --tmux 로 진행해줘" — traced a routing recovery weakness that survived the earlier credential, servability, and local reachability vetoes: once a configured route target was rejected, jeo threw away the whole routing decision and dropped to the session/default model even when the same prompt tier had another credentialed, servable model available. That kept turns working, but it also silently undid routing's cost/latency goal and made `/route why` less useful because the recorded decision was a fallback note instead of the actual model used.
-- **[0.8.12]** (2026-07-08) — "제오코드에서 oauth 지피티 모델 연결이 안되는데 원인파악해서 개선해" — root-caused a structural drift bug: OpenAI's live Codex models endpoint (`chatgpt.com/backend-api/codex/models`, the SAME endpoint the `/model` picker discovers from) had shipped `gpt-5.4-mini` alongside `gpt-5.5`/`gpt-5.4`, but jeo's static OAuth allow-list (`CODEX_MODELS`) hadn't caught up — the picker correctly listed the model (straight from that live endpoint), but selecting or calling it then hit a hard-coded `CODEX_MODELS.includes(...)` gate that rejected it with "OpenAI OAuth credential only supports Codex models", even though the account's own OAuth token genuinely serves it. This is a whole class of bug: it recurs every time OpenAI ships a new Codex model between jeo releases, and previously required a jeo update to fix each time.
-- **[0.8.11]** (2026-07-08) — "프롬프트 라우팅 동작이 Error: Unable to connect. Is the computer able to access the url? Error: Was there a typo in the url or port? 와 같은 메시지 남기고 동작안하는데 원인을 파악하고 근본문제해결하자" — traced the raw, provider-less connection error to two compounding gaps. (1) `describeProvider` reports local providers (ollama/lmstudio) as `ready: true` UNCONDITIONALLY — "keyless" only means no credential is required, never that the server is actually reachable — so the routing veto gate (which exists precisely to keep a misconfigured routing target from making a turn worse than routing being off) had no way to catch a `routing.tiers`/`roles` pin to a downed local server. (2) Bun's fetch/undici throws a bare `Error("Unable to connect. Is the computer able to access the url?")` with `.code === "ConnectionRefused"` for BOTH a refused connection and an unresolvable host — no HTTP status, no provider name, no URL — and this fell through every existing error classifier (`defaultRetryable`, `friendlyProviderError`) to reach the user completely unfiltered.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/prompt-router.ts

@@ -58,6 +58,8 @@ import type { AuthProvider } from "../auth";
 
 export type PromptTier = "trivial" | "standard" | "high" | "complex";
 
+export const PROMPT_TIERS = ["trivial", "standard", "high", "complex"] as const satisfies readonly PromptTier[];
+
 export interface HeuristicResult {
   tier: PromptTier;
   confidence: number; // 0..1
@@ -93,7 +95,7 @@ const RE_CAUSAL_KR = /(왜\s|근본\s*원인|이유가|어떻게|이유|어째
 const RE_TRIVIAL_QUESTION_WORD = /\b(what|who|when|where|which)\b/i;
 const RE_TRIVIAL_QUESTION_WORD_KR = /(뭐|뭔가요|무엇|언제|어디|누구|몇\s|인가요|있나요|냐|음\?|인가)/;
 const RE_CODE_FENCE = /```/;
-const RE_CODE_SNIPPET = /(?:const|let|var|import|export|function|class|if\s*\(|try\s*{|=>|\{\s*[\w\d_]+\s*\})/;
+const RE_CODE_SNIPPET = /(?:\b(?:const|let|var)\s+\w+\s*=|\bimport\s+.*?\s+from\s+['"`\.\/]|\bexport\s+(?:const|let|var|function|class|default)\b|\b(?:function|class)\s+\w+|if\s*\(|try\s*{|=>|\{\s*[\w\d_]+\s*\})/;
 const RE_PATH_TOKEN = /(?:^|[\s"'`(])@?(?:\.{0,2}[\w-]*[\/\\])+[\w-]+(?:\.[\w-]+)*(?:\.[A-Za-z]\w{0,7}|[\/\\])\b/g;
 const RE_CLI_COMMAND = /(?:^|\s)(git|npm|bun|docker-compose|pip|cargo)\s+[a-z-_]+/i;
 const RE_DEEP_KEYWORDS_EN = /\b(design|architecture|refactor|debug|deep\s*dive|investigate|diagnose|redesign)\b/i;
@@ -118,12 +120,12 @@ export function classifyPromptHeuristically(prompt: string): HeuristicResult {
     signals.push("short-question");
   }
 
-  // trivial signal 2: no code fence AND no code snippet AND no file path mention AND no CLI command.
+  // trivial signal 2: no code fence AND no code snippet AND no file path mention.
   const hasCodeFence = RE_CODE_FENCE.test(trimmed);
   const hasCodeSnippet = RE_CODE_SNIPPET.test(trimmed);
   const hasCliCommand = RE_CLI_COMMAND.test(trimmed);
   const pathMatches = [...trimmed.matchAll(RE_PATH_TOKEN)];
-  if (!hasCodeFence && !hasCodeSnippet && !hasCliCommand && pathMatches.length === 0) {
+  if (!hasCodeFence && !hasCodeSnippet && pathMatches.length === 0) {
     trivialScore++;
     signals.push("no-code-no-path");
   }
@@ -261,6 +263,24 @@ function sizeClassFor(model: CatalogModel): "small" | "mid" | "large" | null {
   if (segments.includes("sonnet") || segments.includes("pro")) return "mid";
   return null;
 }
+const SIZE_CLASS_TO_TIER: Record<"small" | "mid" | "large", PromptTier> = { small: "trivial", mid: "standard", large: "complex" };
+
+/** Infers the `PromptTier` whose equivalence pool matches `model`'s size class — lets a
+ *  NON-ROUTED turn (routing disabled, or the user pinned a model via `/model`) reuse the
+ *  same cross-provider equivalent-pool fallback (`tierModelPool`/`equivalentRouteFallback`
+ *  in launch.ts) that a routed turn already gets on a usage-limit/rate-limit/credential
+ *  failure — without silently downgrading a pinned flagship (e.g. opus) to a cheap
+ *  trivial-tier substitute, or promoting a pinned cheap model to an expensive one. `null`
+ *  sizeClass (no size-tier suffix — gpt-5.5/o3/grok-4.3/kimi-* / glm-* / …) and an
+ *  uncatalogued model id both default to "standard" (the mid pool) as a reasonable
+ *  middle ground rather than guessing complex/trivial. */
+export function inferTierForModel(model: string): PromptTier {
+  const meta = catalogMetadata(model);
+  if (!meta) return "standard";
+  const cls = sizeClassFor(meta);
+  return cls ? SIZE_CLASS_TO_TIER[cls] : "standard";
+}
+
 
 const TIER_TO_SIZE_CLASS: Record<PromptTier, "small" | "mid" | "large"> = { trivial: "small", standard: "mid", high: "mid", complex: "large" };
 
@@ -455,9 +475,30 @@ function resolveTierThinking(tier: PromptTier, config: RoutingConfig): ThinkLeve
   return config.routing?.tiers?.[tier]?.thinking; // undefined = no override, caller keeps session/global level
 }
 
-const VALID_TIERS: readonly PromptTier[] = ["trivial", "standard", "high", "complex"];
+/** Apply one interactive `/model` pick to a PromptRouter tier without touching the
+ *  global model registry. The write enables routing because a configured tier is
+ *  otherwise invisible until `routing.enabled` is set. */
+export function withRoutingTierSetting(
+  config: Pick<Config, "routing">,
+  tier: PromptTier,
+  patch: { model: string; thinking?: ThinkLevel },
+): NonNullable<Config["routing"]> {
+  return {
+    ...(config.routing ?? {}),
+    enabled: true,
+    tiers: {
+      ...(config.routing?.tiers ?? {}),
+      [tier]: {
+        ...(config.routing?.tiers?.[tier] ?? {}),
+        model: patch.model,
+        thinking: patch.thinking,
+      },
+    },
+  };
+}
+
 function isPromptTier(value: unknown): value is PromptTier {
-  return typeof value === "string" && (VALID_TIERS as readonly string[]).includes(value);
+  return typeof value === "string" && (PROMPT_TIERS as readonly string[]).includes(value);
 }
 
 /** Hard cap on how much of the prompt is embedded in the escalation classifier call —

package/src/agent/route-history.ts

@@ -0,0 +1,107 @@
+/**
+ * Routing decision history tracker — maintains a bounded FIFO queue of recent
+ * routing decisions for `/route history` visibility and performance analysis.
+ *
+ * Session-scoped (one per REPL), not persisted to config.
+ */
+
+import type { RouteDecision } from "./prompt-router";
+
+export interface RouteHistoryEntry extends RouteDecision {
+  timestamp: number; // Date.now()
+  turnNumber: number; // 1-indexed turn in this session
+}
+
+/**
+ * Bounded FIFO queue of routing decisions. Oldest entries are dropped when
+ * the queue exceeds `maxSize`.
+ */
+export class RouteHistory {
+  private entries: RouteHistoryEntry[] = [];
+  private turnNumber = 0;
+  readonly maxSize: number;
+
+  constructor(maxSize: number = 10) {
+    this.maxSize = Math.max(1, maxSize);
+  }
+
+  /**
+   * Record a routing decision. Increments the turn counter and adds the entry
+   * to the queue, dropping the oldest if necessary.
+   */
+  add(decision: RouteDecision): void {
+    this.turnNumber++;
+    const entry: RouteHistoryEntry = {
+      ...decision,
+      timestamp: Date.now(),
+      turnNumber: this.turnNumber,
+    };
+    this.entries.push(entry);
+    if (this.entries.length > this.maxSize) {
+      this.entries.shift();
+    }
+  }
+
+  /**
+   * Get all recorded entries in chronological order (oldest first).
+   */
+  getAll(): RouteHistoryEntry[] {
+    return [...this.entries];
+  }
+
+  /**
+   * Get the most recent entry, if any.
+   */
+  getLast(): RouteHistoryEntry | undefined {
+    return this.entries[this.entries.length - 1];
+  }
+
+  /**
+   * Get entries for a specific model.
+   */
+  getByModel(model: string): RouteHistoryEntry[] {
+    return this.entries.filter((e) => e.model === model);
+  }
+
+  /**
+   * Get entries for a specific tier.
+   */
+  getByTier(tier: string): RouteHistoryEntry[] {
+    return this.entries.filter((e) => e.tier === tier);
+  }
+
+  /**
+   * Compute statistics over the history.
+   */
+  getStats(): {
+    totalDecisions: number;
+    modelFrequency: Record<string, number>;
+    tierFrequency: Record<string, number>;
+    averageConfidence: number;
+  } {
+    const modelFreq: Record<string, number> = {};
+    const tierFreq: Record<string, number> = {};
+    let totalConfidence = 0;
+
+    for (const entry of this.entries) {
+      modelFreq[entry.model] = (modelFreq[entry.model] ?? 0) + 1;
+      tierFreq[entry.tier] = (tierFreq[entry.tier] ?? 0) + 1;
+      totalConfidence += entry.confidence;
+    }
+
+    return {
+      totalDecisions: this.entries.length,
+      modelFrequency: modelFreq,
+      tierFrequency: tierFreq,
+      averageConfidence: this.entries.length > 0 ? totalConfidence / this.entries.length : 0,
+    };
+  }
+
+  /**
+   * Clear all entries.
+   */
+  clear(): void {
+    this.entries = [];
+    this.turnNumber = 0;
+  }
+}

package/src/agent/subagents.ts

@@ -16,6 +16,9 @@ import architectPrompt from "../prompts/agents/architect.md" with { type: "text"
 import criticPrompt from "../prompts/agents/critic.md" with { type: "text" };
 import executorPrompt from "../prompts/agents/executor.md" with { type: "text" };
 import plannerPrompt from "../prompts/agents/planner.md" with { type: "text" };
+import type { PromptTier } from "./prompt-router";
+
+const PROMPT_ROUTE_TIERS = ["trivial", "standard", "high", "complex"] as const satisfies readonly PromptTier[];
 
 export interface SubagentRole {
   /** Stable id used in config + `/agents <id>`. */
@@ -362,9 +365,9 @@ export function clearSubagentSetting(config: Pick<Config, "subagents">, roleId:
   return subs;
 }
 
-/** One pickable apply-target: the global default or a subagent role. */
+/** One pickable apply-target: the global default, a prompt-routing tier, or a subagent role. */
 export interface ApplyTargetChoice {
-  /** "default" or a subagent role id. */
+  /** "default", "routing:<tier>", or a subagent role id. */
   value: string;
   label: string;
   /** Right-aligned hint: the target's CURRENT model (so the picker doubles as a viewer). */
@@ -378,18 +381,32 @@ export interface ApplyTargetChoice {
  * read-and-change panel for existing role assignments. Pure — testable.
  */
 export function applyTargetChoices(
-  config: Pick<Config, "defaultModel" | "subagents" | "thinkingLevel">,
+  config: Pick<Config, "defaultModel" | "subagents" | "thinkingLevel" | "routing" | "roles"> &
+    Partial<Pick<Config, "providers" | "oauth" | "openaiBaseUrl">>,
 ): ApplyTargetChoice[] {
   const roleThink = (id: string): string => {
     const t = resolveSubagentThinking(id, config);
     return t ? ` (${t})` : " (inherit)";
   };
+  const routeThink = (tier: PromptTier): string => {
+    const t = config.routing?.tiers?.[tier]?.thinking;
+    return t ? ` (${t})` : " (auto thinking)";
+  };
+  // Lazy load keeps the existing subagents→prompt-router dependency from
+  // becoming an eager module cycle; resolveSubagentModel uses the same pattern.
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { resolveTierModel } = require("./prompt-router");
   return [
     {
       value: "default",
       label: "default — every session",
       hint: `${config.defaultModel} (${config.thinkingLevel ?? "medium"})`,
     },
+    ...PROMPT_ROUTE_TIERS.map(tier => ({
+      value: `routing:${tier}`,
+      label: `route ${tier} — PromptRouter tier`,
+      hint: `${config.routing?.tiers?.[tier]?.model ?? resolveTierModel(tier, config)}${config.routing?.tiers?.[tier]?.model ? "" : " (auto)"}${routeThink(tier)}`,
+    })),
     ...allSubagentRoles(config).map(role => ({
       value: role.id,
       label: `subagent ${role.id} — ${role.title}`,

package/src/ai/providers/anthropic-compatible.ts

@@ -1,5 +1,7 @@
 import type { ProviderAdapter, CallOptions, ProviderName } from "../types";
 import { anthropicAdapter } from "./anthropic";
+import { relabelProviderError } from "./errors";
+import { companyLabel } from "../model-catalog";
 
 /**
  * Factory for Anthropic-Messages-compatible providers (z.ai, MiniMax, …). They speak
@@ -11,17 +13,32 @@ import { anthropicAdapter } from "./anthropic";
  */
 export function makeAnthropicCompatibleAdapter(opts: { name: ProviderName; baseUrl: string }): ProviderAdapter {
   const prefix = `${opts.name}/`;
+  const label = companyLabel(opts.name);
   const prep = (o: CallOptions): CallOptions => ({
     ...o,
     model: o.model.startsWith(prefix) ? o.model.slice(prefix.length) : o.model,
     baseUrl: o.baseUrl ?? opts.baseUrl,
   });
+  // `anthropicAdapter` hardcodes "Anthropic" as the provider label on every thrown
+  // ProviderHttpError/ProviderStreamError — relabel to the REAL backend (e.g. "Tencent",
+  // "z.ai") so friendlyProviderError/the fallback classifier/the user all see the true
+  // account that needs attention (auth, billing, rate limit) instead of Anthropic's.
   return {
     name: opts.name,
     supportsNativeTools: anthropicAdapter.supportsNativeTools,
-    call: (messages, options, credential) => anthropicAdapter.call(messages, prep(options), credential),
+    call: async (messages, options, credential) => {
+      try {
+        return await anthropicAdapter.call(messages, prep(options), credential);
+      } catch (err) {
+        throw relabelProviderError(err, label);
+      }
+    },
     async *stream(messages, options, credential) {
-      yield* anthropicAdapter.stream!(messages, prep(options), credential);
+      try {
+        yield* anthropicAdapter.stream!(messages, prep(options), credential);
+      } catch (err) {
+        throw relabelProviderError(err, label);
+      }
     },
   };
 }

package/src/ai/providers/errors.ts

@@ -12,12 +12,20 @@ export class ProviderHttpError extends Error {
   readonly provider: string;
   /** Server-directed backoff from a `Retry-After` header, in ms (if present). */
   readonly retryAfterMs?: number;
+  /** Raw response body (or synthesized detail text) — kept separately so a caller can
+   *  reconstruct this error under a DIFFERENT provider label (see `relabelProviderError`)
+   *  without re-parsing it back out of the composed `.message`. */
+  readonly detail: string;
+  /** Optional context suffix (e.g. "(stream)") — see `detail`'s rationale. */
+  readonly context?: string;
   constructor(provider: string, status: number, detail: string, context?: string, retryAfterMs?: number) {
     super(`${provider} request failed (HTTP ${status})${context ? ` ${context}` : ""}: ${detail}`);
     this.name = "ProviderHttpError";
     this.status = status;
     this.provider = provider;
     this.retryAfterMs = retryAfterMs;
+    this.detail = detail;
+    this.context = context;
   }
 }
 
@@ -39,6 +47,10 @@ export class ProviderStreamError extends Error {
   readonly status: number;
   readonly provider: string;
   readonly code?: string;
+  /** Raw stream-error message (pre-composition) — see `ProviderHttpError.detail`'s
+   *  rationale; lets `relabelProviderError` reconstruct this error under a different
+   *  provider label without re-parsing `.message`. */
+  readonly rawMessage: string;
   /** `explicitStatus` lets a caller pass an ALREADY-numeric provider status (e.g. Google's
    *  `error.code` on a `google.rpc.Status` envelope — 429/500/503) instead of relying on the
    *  OpenAI-specific `code === "rate_limit_exceeded"` string heuristic below, which only
@@ -49,9 +61,31 @@ export class ProviderStreamError extends Error {
     this.status = explicitStatus ?? (code === "rate_limit_exceeded" ? 429 : 500);
     this.provider = provider;
     this.code = code;
+    this.rawMessage = message;
   }
 }
 
+/** Rebuild `err` under a DIFFERENT provider label — both `.provider` and the composed
+ *  `.message` are corrected, not just the field (a caller matching on message text, or
+ *  a user reading the raw error, must see the TRUE provider either way). Used by the
+ *  Anthropic/OpenAI-compatible adapter factories (`makeAnthropicCompatibleAdapter`,
+ *  `makeOpenAICompatibleAdapter`): they delegate to `anthropicAdapter`/`openaiAdapter`,
+ *  which hardcode "Anthropic"/"OpenAI" at their `ProviderHttpError`/`ProviderStreamError`
+ *  construction sites — so a groq/tencent/zai/deepseek/… failure previously surfaced as
+ *  "Anthropic rejected the credential" or "OpenAI requires billing", sending the user to
+ *  fix the WRONG account. Non-`ProviderHttpError`/`ProviderStreamError` errors (bare
+ *  `Error`, network failures, etc.) pass through unchanged — those never carried a
+ *  hardcoded label to begin with. */
+export function relabelProviderError(err: unknown, provider: string): unknown {
+  if (err instanceof ProviderHttpError) {
+    return new ProviderHttpError(provider, err.status, err.detail, err.context, err.retryAfterMs);
+  }
+  if (err instanceof ProviderStreamError) {
+    return new ProviderStreamError(provider, err.rawMessage, err.code, err.status);
+  }
+  return err;
+}
+
 /**
  * Parse a `Retry-After` header into ms. Supports the delta-seconds form
  * (`"5"`) and the HTTP-date form (`"Wed, 21 Oct 2025 07:28:00 GMT"`).

package/src/ai/providers/kimi.ts

@@ -3,6 +3,8 @@ import { getKimiCommonHeaders } from "../../auth/flows/kimi";
 import type { CallOptions, ProviderAdapter } from "../types";
 import { anthropicAdapter } from "./anthropic";
 import { makeOpenAICompatibleAdapter } from "./openai-compatible";
+import { relabelProviderError } from "./errors";
+import { companyLabel } from "../model-catalog";
 
 /**
  * Kimi (Moonshot) — two credential-dependent backends (gjc parity):
@@ -18,6 +20,7 @@ export const KIMI_BASE_URL = "https://api.moonshot.ai/v1";
 export const KIMI_ANTHROPIC_BASE_URL = "https://api.kimi.com/coding";
 
 const openaiCompatKimi = makeOpenAICompatibleAdapter({ name: "kimi", baseUrl: KIMI_BASE_URL });
+const KIMI_LABEL = companyLabel("kimi");
 
 /** Route the `kimi/` prefix + OAuth base/headers onto the anthropic adapter. */
 // ponytail: model ids pass through untranslated — the moonshot catalog ids (kimi-latest, …)
@@ -33,19 +36,31 @@ function prepOAuth(o: CallOptions): CallOptions {
 }
 
 /** Dispatch on credential kind: OAuth → Kimi Code Anthropic endpoint; else the
- *  original OpenAI-compatible moonshot adapter (API-key behavior unchanged). */
+ *  original OpenAI-compatible moonshot adapter (API-key behavior unchanged).
+ *  The OAuth path delegates to `anthropicAdapter`, which hardcodes "Anthropic" at
+ *  its `ProviderHttpError`/`ProviderStreamError` construction sites — relabel to
+ *  "Moonshot" (same fix as `makeAnthropicCompatibleAdapter`/`makeOpenAICompatibleAdapter`)
+ *  so a Kimi Code failure never sends the user to fix their Anthropic account. */
 export const kimiAdapter: ProviderAdapter = {
   name: "kimi",
   supportsNativeTools: openaiCompatKimi.supportsNativeTools,
-  call: (messages, options, credential) =>
-    credential.kind === "oauth"
-      ? anthropicAdapter.call(messages, prepOAuth(options), credential)
-      : openaiCompatKimi.call(messages, options, credential),
+  call: async (messages, options, credential) => {
+    if (credential.kind !== "oauth") return openaiCompatKimi.call(messages, options, credential);
+    try {
+      return await anthropicAdapter.call(messages, prepOAuth(options), credential);
+    } catch (err) {
+      throw relabelProviderError(err, KIMI_LABEL);
+    }
+  },
   async *stream(messages, options, credential) {
-    if (credential.kind === "oauth") {
-      yield* anthropicAdapter.stream!(messages, prepOAuth(options), credential);
-    } else {
+    if (credential.kind !== "oauth") {
       yield* openaiCompatKimi.stream!(messages, options, credential);
+      return;
+    }
+    try {
+      yield* anthropicAdapter.stream!(messages, prepOAuth(options), credential);
+    } catch (err) {
+      throw relabelProviderError(err, KIMI_LABEL);
     }
   },
 };