jeo-code 0.8.17 → 0.8.19

package/CHANGELOG.md

@@ -6,6 +6,41 @@ 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.19] - 2026-07-09
+_"프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools._
+
+### Fixed
+- **Antigravity's Claude Sonnet/Opus are now reachable at the `high`/`complex` routing tiers** (`src/agent/prompt-router.ts`) — added `antigravityCompanyPoolPick`: when Antigravity is credentialed and a tier's pool spans 2+ companies, session-stably spreads across ONE candidate per company (the strongest Antigravity row for that company) instead of the plain single-winner comparator always resolving to Google's Gemini rows. Wired into `resolveTierModel`'s `high`/`complex` branches, after the explicit `routing.crossProviderPool` opt-in but before the plain single-winner fallback — purely additive, default-on specifically for Antigravity's multi-vendor case (every other provider represents exactly one vendor and is unaffected).
+
+### Added
+- **Antigravity multi-company routing coverage** (`test/prompt-router.test.ts`) — 3 new tests: reachability across all 3 re-exported companies (Anthropic/Google/OpenAI) over 50 sessions, session-stability (same session always resolves to the same pick), and an explicit `roles.high` override still winning over the new spread. Updated one test whose assertion had locked in the old Gemini-only behavior — its actual invariant (never leak a bare public `gemini-*` id) still holds and is now asserted more precisely.
+
+### Verified
+- Live: `resolveTierModel("high"/"complex", …)` across 5 distinct real sessionIds confirms `antigravity/claude-sonnet-4-6` reachable at `high` and `antigravity/claude-opus-4-6-thinking` reachable at `complex`, spread across all 3 companies.
+- `bun test test/prompt-router.test.ts test/prompt-router-tiers.test.ts test/model-manager.test.ts test/launch-prompt-routing.test.ts test/model-provider-mapping.test.ts` — 159 pass / 0 fail.
+- Full `bun test` — 2893 pass / 0 fail across 291 files.
+- `bun run typecheck` — no errors.
+
+## [0.8.18] - 2026-07-09
+_"라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct._
+
+### Fixed
+- **TUI footer no longer shows a stale model after a mid-turn equivalent-pool fallback** (`src/tui/app.ts`, `src/commands/launch.ts`) — the footer's `model`/`provider` fields were set once at `LaunchTui` construction and never updated when `launch.ts`'s post-call fallback loop (routed model hit a persistent server-side error, rate limit, etc.) switched `activeModel` mid-turn; the status bar kept showing the ORIGINAL pre-fallback model for the remainder of that turn even though the reply actually came from the fallback model. Added an `onModelSwitch(model, provider)` event, fired from the fallback loop right alongside the existing `[route] … switching to equivalent …` notice, that updates the live footer in place.
+
+### Added
+- **`/route history [n]`** (`src/agent/route-history.ts`, `src/commands/launch/route-slash.ts`, registered in `src/tui/components/slash.ts`) — wires the `RouteHistory` class (shipped disconnected in the prior commit) into the live turn loop: a session-scoped bounded FIFO (never persisted) records every real routing decision — both the pre-call routed pick and any mid-turn equivalent-model fallback that actually served the turn — so history reflects reality, not a since-superseded pre-call guess. `/route history [n]` prints the last n (default 10, non-positive/non-numeric args fall back to the default) as `turn N: tier -> model (source, confidence X.XX)`.
+
+### Removed
+- **`IMPROVEMENT_SUMMARY.md`, `REVIEW.md`** — stray AI-session working notes from the prior commit, never referenced by `README.md`, `CHANGELOG.md`, or `package.json`'s `files` allowlist.
+
+### Verified
+- Live PTY re-verification (`bun src/cli.ts`, isolated `JEO_CONFIG_DIR`, real Anthropic credentials): 5 prompts of varying complexity in one session routed to 5 distinct tier/model pairs (trivial→claude-haiku-4-5, complex→claude-fable-5, trivial→claude-haiku-4-5, high→claude-sonnet-5, trivial→claude-haiku-4-5); `/route why` and `/route status` matched the actual serving model on every turn.
+- Live post-call-fallback reproduction: a real `Bun.serve` mock returning HTTP 500 on every call forced `launch.ts`'s equivalent-pool fallback to fire mid-turn; `/route why` immediately after correctly reported the POST-fallback model and a `warning: … switched to equivalent …` field, not the original pre-call pick.
+- `bun test test/route-history.test.ts test/route-slash.test.ts test/launch-prompt-routing.test.ts` — 69 pass / 0 fail.
+- `bun test test/tui-app.test.ts` — 51 pass / 0 fail (50 pre-existing + 1 new, covering the footer live-update fix).
+- Full `bun test` — 2885 pass / 0 fail across 290 files.
+- `bun run typecheck` — no errors.
+
 ## [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._
 

package/README.ja.md

@@ -79,7 +79,7 @@ jeo --tmux               # 独立した tmux セッションで実行
 | `/provider login <name>` · `/logout` | 入力欄から OAuth ログイン/ログアウト |
 | `/agents [role]` · `/subagent` | ロール別(executor/planner/architect/critic)モデル・thinking・ステップ設定 |
 | `/thinking [level]` | デフォルト推論予算(low…xhigh)の表示/設定 |
-| `/route [status\|on\|off\|why]` | セッション単位のプロンプトベース・モデルルーティングの切替 · 直近のルーティング判断の説明(設定済み資格情報 — OAuth または API キー — が実際に提供するモデルの中でのみ自動ルーティング) |
+| `/route [status\|on\|off\|why\|history [n]]` | セッション単位のプロンプトベース・モデルルーティングの切替 · 直近のルーティング判断の説明 · `history [n]` はこのセッションの直近 n 件(デフォルト 10 件)のルーティング判断を表示(設定済み資格情報 — OAuth または API キー — が実際に提供するモデルの中でのみ自動ルーティング) |
 | `/fast [on\|off\|status]` | 現在のモデルが low 推論をサポートする場合に fast thinking モードを切替 |
 | `/skill` · `$<skill> [intent]` | ワークフロースキルの一覧/実行(`$team "task"` 形式) |
 | `/view` · `/diff` · `/find` · `/search` | コード表示、git diff、ファイル/パターン検索 |
@@ -265,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.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
+- **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -80,7 +80,7 @@ jeo --tmux               # 독립 tmux 세션에서 실행
 | `/provider login <name>` · `/logout` | 입력창에서 OAuth 로그인/로그아웃 |
 | `/agents [role]` · `/subagent` | 역할별(executor/planner/architect/critic) 모델·thinking·스텝 구성 |
 | `/thinking [level]` | 기본 추론 예산(low…xhigh) 조회/설정 |
-| `/route [status\|on\|off\|why]` | 세션별 프롬프트 기반 모델 라우팅 켜기/끄기 · 마지막 라우팅 결정 설명(설정된 자격증명 — OAuth 또는 API 키 — 이 실제로 서비스하는 모델 안에서만 자동 라우팅) |
+| `/route [status\|on\|off\|why\|history [n]]` | 세션별 프롬프트 기반 모델 라우팅 켜기/끄기 · 마지막 라우팅 결정 설명 · `history [n]`은 이번 세션의 최근 n개(기본 10개) 라우팅 결정 표시(설정된 자격증명 — OAuth 또는 API 키 — 이 실제로 서비스하는 모델 안에서만 자동 라우팅) |
 | `/fast [on\|off\|status]` | 현재 모델이 low 추론을 지원하면 fast thinking 모드를 켜고 끔 |
 | `/skill` · `$<skill> [intent]` | 워크플로 스킬 목록/실행(`$team "작업"` 스타일) |
 | `/view` · `/diff` · `/find` · `/search` | 코드 보기, git diff, 파일/패턴 검색 |
@@ -266,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.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
+- **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -40,7 +40,7 @@ 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.
+- **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|history]`), 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, `/route history` for the recent ones.
 - **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.
 
@@ -85,7 +85,7 @@ Inside the `jeo` REPL (Tab autocompletes; `/` opens the palette).
 | `/provider login <name>` · `/logout` | OAuth login/logout from the input box |
 | `/agents [role]` · `/subagent` | Per-role (executor/planner/architect/critic) model · thinking · step config |
 | `/thinking [level]` | Show/set default reasoning budget (low…xhigh) |
-| `/route [status\|on\|off\|why]` | Toggle prompt-based model routing for this session · explain the last routing decision (auto-routes each turn to a tier-appropriate model among the models your configured credentials — OAuth or API key — actually serve, and switches to an equivalent tier model when a configured route is unready) |
+| `/route [status\|on\|off\|why\|history [n]]` | Toggle prompt-based model routing for this session · explain the last routing decision · `history [n]` lists the last n (default 10) routing decisions this session (auto-routes each turn to a tier-appropriate model among the models your configured credentials — OAuth or API key — actually serve, and switches to an equivalent tier model when a configured route is unready) |
 | `/fast [on\|off\|status]` | Toggle fast thinking mode when the active model advertises low reasoning |
 | `/skill` · `$<skill> [intent]` | List/run workflow skills (`$team "task"` style) |
 | `/view` · `/diff` · `/find` · `/search` | Code view, git diff, file/pattern search |
@@ -273,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.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
+- **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -79,7 +79,7 @@ jeo --tmux               # 在独立 tmux 会话中运行
 | `/provider login <name>` · `/logout` | 在输入框内 OAuth 登录/登出 |
 | `/agents [role]` · `/subagent` | 按角色(executor/planner/architect/critic)配置模型·thinking·步数 |
 | `/thinking [level]` | 查看/设置默认推理预算(low…xhigh) |
-| `/route [status\|on\|off\|why]` | 切换本会话的基于提示词的模型路由 · 解释最近一次路由决策(仅在已配置凭证 — OAuth 或 API 密钥 — 实际可用的模型内自动路由) |
+| `/route [status\|on\|off\|why\|history [n]]` | 切换本会话的基于提示词的模型路由 · 解释最近一次路由决策 · `history [n]` 列出本会话最近 n 条(默认 10 条)路由决策(仅在已配置凭证 — OAuth 或 API 密钥 — 实际可用的模型内自动路由) |
 | `/fast [on\|off\|status]` | 当前模型支持 low 推理时切换 fast thinking 模式 |
 | `/skill` · `$<skill> [intent]` | 列出/运行工作流技能(`$team "任务"` 风格) |
 | `/view` · `/diff` · `/find` · `/search` | 代码查看、git diff、文件/模式搜索 |
@@ -265,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.19]** (2026-07-09) — "프롬프트 라우팅에 안티그라비티 프로바이더의 경우, 안티그라비티용 소넷과 오퍼스도 3.5급으로 라우팅될수있도록해줘" — Antigravity re-exports 3 distinct model families (Anthropic Claude, Google Gemini, OpenAI GPT-OSS) behind one credential, structurally unlike every other provider. `high`/`complex` tier auto-select always resolved to Google's Gemini 3.5 rows: Anthropic's real 64,000-token output ceiling lost a same-thinking-tier tie to Google's 65,536 by a margin with no practical significance, and Gemini's 1M-token context further outranked Claude's real 200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking` were NEVER reachable through auto-select, even though both were already correctly `sizeClass`-tagged into the `high`/`complex` pools.
+- **[0.8.18]** (2026-07-09) — "라우팅 매 프롬프트마다 변경되는지, route why 의도대로 동작하는지 검증하고 배포할게있는지 확인해줘" — 2 parallel subagents live-verified per-prompt routing + `/route why` (including the previously-only-unit-tested post-call equivalent-model fallback path, now reproduced against a real mock 500-error server) and audited a disconnected `RouteHistory` class shipped as incomplete scaffolding in 0.8.16/0.8.17 (class + 11 tests existed, but nothing ever called it — no `/route history` subcommand, no wiring into the turn loop). Live testing also surfaced one real bug: the TUI footer's model/provider label never updated after a mid-turn fallback, staying on the pre-fallback model for the rest of that turn's render even though the backend decision (`lastRouteDecision`) was already correct.
 - **[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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/prompt-router.ts

@@ -456,6 +456,44 @@ function crossProviderPoolPick(tier: PromptTier, config: RoutingConfig, sessionI
   return pool.length > 0 ? selectFromPool(pool, sessionId) : null;
 }
 
+/** Antigravity re-exports THREE distinct model families (Anthropic's Claude
+ *  Sonnet/Opus, Google's own Gemini, OpenAI's GPT-OSS) behind one credential —
+ *  structurally different from every other provider, which represents exactly
+ *  one vendor. The tier's plain single-winner pick (`strongestMidTierCredentialed`/
+ *  `strongestCredentialed`) always resolves to Google's rows for `high`/`complex`:
+ *  Anthropic's real 64,000-token output ceiling loses a same-thinking-tier tie to
+ *  Google's 65,536 by a margin with no practical significance, and Gemini's
+ *  1M-token context further outranks Claude's real (but comparatively narrower)
+ *  200K window — so `antigravity/claude-sonnet-4-6`/`antigravity/claude-opus-4-6-thinking`
+ *  were NEVER reachable through auto-select even though both are already
+ *  correctly `sizeClass`-tagged into the `high`/`complex` pools (`tierModelPool`).
+ *  This applies the SAME session-stable spread `routing.crossProviderPool` uses
+ *  globally (opt-in, default off), but scoped and DEFAULT-ON specifically for
+ *  Antigravity's multi-company pool: one candidate per COMPANY (the strongest
+ *  Antigravity row for that company, by `compareStrengthAscending`) so Google's
+ *  several same-tier Gemini rows don't crowd out the single Anthropic/OpenAI
+ *  candidate 3-to-1 — each vendor Antigravity re-exports gets an equal, genuinely
+ *  reachable share. `null` when Antigravity isn't credentialed this turn, the
+ *  tier's Antigravity-only pool is empty, or it spans only ONE company (nothing
+ *  to spread — the plain single-winner path already picks correctly and this
+ *  would just add indirection). */
+function antigravityCompanyPoolPick(tier: PromptTier, config: RoutingConfig, sessionId: string | undefined): string | null {
+  if (!hasAntigravityOauth(config)) return null;
+  const pool = tierModelPool(tier, config)
+    .map(id => catalogMetadata(id))
+    .filter((m): m is CatalogModel => !!m && m.provider === "antigravity");
+  if (pool.length === 0) return null;
+  const byCompany = new Map<string, CatalogModel>();
+  for (const m of pool) {
+    const company = m.company ?? "antigravity";
+    const current = byCompany.get(company);
+    if (!current || compareStrengthAscending(current, m) < 0) byCompany.set(company, m);
+  }
+  if (byCompany.size < 2) return null; // one vendor in this tier -> nothing to spread across
+  const representatives = [...byCompany.values()].map(m => m.canonical).sort();
+  return selectFromPool(representatives, sessionId);
+}
+
 // --- Tier -> model/thinking resolution (inline off config.roles/config.routing.tiers; no static map). ---
 
 /** Exported for `jeo doctor`'s routing-preview diagnostic (same resolution the real
@@ -466,8 +504,8 @@ export function resolveTierModel(tier: PromptTier, config: RoutingConfig, sessio
   if (configured) return configured;
   if (tier === "trivial") return config.roles?.smol || crossProviderPoolPick(tier, config, sessionId) || cheapestCredentialed(config) || config.defaultModel;
   if (tier === "standard") return config.roles?.medium || config.roles?.high || crossProviderPoolPick(tier, config, sessionId) || config.defaultModel;
-  if (tier === "high") return config.roles?.high || config.roles?.medium || crossProviderPoolPick(tier, config, sessionId) || strongestMidTierCredentialed(config) || config.defaultModel;
-  if (tier === "complex") return config.roles?.xhigh || config.roles?.slow || crossProviderPoolPick(tier, config, sessionId) || strongestCredentialed(config) || config.defaultModel;
+  if (tier === "high") return config.roles?.high || config.roles?.medium || crossProviderPoolPick(tier, config, sessionId) || antigravityCompanyPoolPick(tier, config, sessionId) || strongestMidTierCredentialed(config) || config.defaultModel;
+  if (tier === "complex") return config.roles?.xhigh || config.roles?.slow || crossProviderPoolPick(tier, config, sessionId) || antigravityCompanyPoolPick(tier, config, sessionId) || strongestCredentialed(config) || config.defaultModel;
   return config.defaultModel;
 }
 

package/src/agent/session.ts

@@ -13,6 +13,11 @@ export interface SessionHeader {
   /** Model id pinned to this session; restored on resume so each session can carry
    *  its own model independent of the global default (per-session model selection). */
   model?: string;
+  /** Unsent input-box draft at last save, restored into the prompt on `/resume`
+   *  (gajae-code parity: an in-progress prompt survives a quit + resume instead
+   *  of being silently lost). Absent/empty when there was nothing to restore. */
+  draft?: string;
+
 }
 
 export interface SessionEntry {
@@ -416,6 +421,25 @@ export async function updateSessionModel(id: string, model: string, cwd = proces
     return true;
   }, cwd);
 }
+/**
+ * Persist (or clear) the unsent input-box draft in a session's JSONL header so a
+ * later `/resume` restores it into the prompt (gajae-code parity). Empty text
+ * clears any stale draft rather than writing an empty string. No-op (no write)
+ * when the header's current draft already matches. Throws a clear Error if the
+ * session file does not exist.
+ */
+export async function updateSessionDraft(id: string, draft: string, cwd = process.cwd()): Promise<void> {
+  const trimmed = draft.trim();
+  const next = trimmed ? trimmed : undefined;
+  await rewriteSessionHeader(id, header => {
+    if ((header.draft ?? undefined) === next) return false;
+    if (next === undefined) delete header.draft;
+    else header.draft = next;
+    return true;
+  }, cwd);
+}
+
+
 
 /**
  * Delete a session file.

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

@@ -1,14 +1,15 @@
 /**
  * `/route` slash-command handler extracted from launch.ts.
  *
- * Handles `/route [status|on|off|why]` (default/`status`: report the effective
- * session routing state + the last decision, if any; `on`/`off`: toggle a
- * SESSION-LOCAL override of `config.routing.enabled`; `why`: explain the last
- * routing decision in detail). This block shares mutable REPL state
- * (`sessionRouteOverride`, `lastRouteDecision`) with `runTurn`'s own routing
- * insertion, so the caller passes the current values in via an explicit
- * context object and reads back a result object instead of this function
- * closing over REPL state directly.
+ * Handles `/route [status|on|off|why|history]` (default/`status`: report the
+ * effective session routing state + the last decision, if any; `on`/`off`:
+ * toggle a SESSION-LOCAL override of `config.routing.enabled`; `why`: explain
+ * the last routing decision in detail; `history [n]`: print the last `n`
+ * (default 10) recorded decisions, one per line). This block shares mutable
+ * REPL state (`sessionRouteOverride`, `lastRouteDecision`, `routeHistory`)
+ * with `runTurn`'s own routing insertion, so the caller passes the current
+ * values in via an explicit context object and reads back a result object
+ * instead of this function closing over REPL state directly.
  *
  * Session-level toggle only — `sessionRouteOverride` is never persisted to
  * `~/.jeo/config.json` (mirrors `/thinking` being session-only vs. `/model
@@ -17,6 +18,7 @@
  */
 
 import type { RouteDecision } from "../../agent/prompt-router";
+import type { RouteHistoryEntry } from "../../agent/route-history";
 
 export interface RouteSlashCtx {
   sessionRouteOverride: boolean | undefined;
@@ -28,9 +30,13 @@ export interface RouteSlashCtx {
    *  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;
+  /** Chronological (oldest-first) snapshot of this session's `RouteHistory`
+   *  (`routeHistory.getAll()`), read fresh by the caller for `/route history`. */
+  routeHistory: RouteHistoryEntry[];
 }
 
 
+
 export interface RouteSlashResult {
   /** Present only when changed by "on"/"off". */
   sessionRouteOverride?: boolean | undefined;
@@ -38,7 +44,7 @@ export interface RouteSlashResult {
   lines: string[];
 }
 
-const USAGE = "Usage: /route [status|on|off|why]";
+const USAGE = "Usage: /route [status|on|off|why|history [n]]";
 
 function isRealDecision(decision: RouteDecision | { note: string } | null): decision is RouteDecision {
   return !!decision && "model" in decision;
@@ -61,13 +67,25 @@ function explainDecision(decision: RouteDecision | { note: string } | null): str
 }
 
 /**
- * Handle `/route [status|on|off|why]`. Extracted for the same reason as
- * `/model`: shares REPL-local routing state with `runTurn` via an explicit
- * ctx/result object rather than closing over it.
+ * Format the last `n` history entries (default 10) as one line each:
+ * `turn N: tier -> model (source, confidence X.XX)`, oldest of the selected
+ * window first — matches `getAll()`'s chronological ordering.
+ */
+function formatHistory(entries: RouteHistoryEntry[], n: number): string[] {
+  if (entries.length === 0) return ["No routing decisions recorded yet this session."];
+  const selected = n > 0 ? entries.slice(Math.max(0, entries.length - n)) : [];
+  if (selected.length === 0) return ["No routing decisions recorded yet this session."];
+  return selected.map((e) => `turn ${e.turnNumber}: ${e.tier} -> ${e.model} (${e.source}, confidence ${e.confidence.toFixed(2)})`);
+}
+
+/**
+ * Handle `/route [status|on|off|why|history]`. Extracted for the same reason
+ * as `/model`: shares REPL-local routing state with `runTurn` via an
+ * explicit ctx/result object rather than closing over it.
  */
 export function runRouteSlash(input: string, ctx: RouteSlashCtx): RouteSlashResult {
   const rest = input.slice("/route".length).trim();
-  const [sub] = rest.split(/\s+/).filter(Boolean);
+  const [sub, arg] = rest.split(/\s+/).filter(Boolean);
   const effective = ctx.sessionRouteOverride ?? ctx.routingConfigEnabled;
 
   if (!sub || sub === "status") {
@@ -102,5 +120,15 @@ export function runRouteSlash(input: string, ctx: RouteSlashCtx): RouteSlashResu
     return { lines: explainDecision(ctx.lastRouteDecision) };
   }
 
+  if (sub === "history") {
+    // Only a finite POSITIVE count selects a window; 0, negatives, and
+    // non-numeric args (`bogus`) all fall back to the default 10 rather than
+    // silently printing the empty-history message when decisions actually
+    // exist (that message must mean "nothing recorded", never "you asked for 0").
+    const parsed = arg !== undefined ? Number.parseInt(arg, 10) : 10;
+    const n = Number.isFinite(parsed) && parsed > 0 ? parsed : 10;
+    return { lines: formatHistory(ctx.routeHistory, n) };
+  }
+
   return { lines: [`Unknown /route subcommand: ${sub}`, USAGE] };
 }

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

@@ -47,6 +47,11 @@ export interface SessionSlashResult {
   lastUserInput?: string;
   /** Present only when changed (by `/session resume` re-seeding retry state). */
   lastReply?: string;
+  /** Present only when changed (by `/session resume` restoring header.draft into
+   *  the prompt box). */
+  draft?: string;
+
+
 }
 
 /**
@@ -62,14 +67,18 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
   let sessionModelChanged = false;
   let lastUserInput: string | undefined;
   let lastReply: string | undefined;
+  let draft: string | undefined;
+
 
   const result = (): SessionSlashResult => ({
     sessionId,
     ...(sessionModelChanged ? { sessionModel } : {}),
     ...(lastUserInput !== undefined ? { lastUserInput } : {}),
     ...(lastReply !== undefined ? { lastReply } : {}),
+    ...(draft !== undefined ? { draft } : {}),
   });
 
+
   const tokens = input.substring(8).trim().split(/\s+/).filter(Boolean);
   const sub = (tokens[0] ?? "").toLowerCase();
 
@@ -125,6 +134,10 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
         sessionId = rid;
         // Restore the model this session was last using (per-session model).
         if (header.model) { sessionModel = header.model; sessionModelChanged = true; }
+        // Restore the unsent input-box draft left over at last save, if any.
+        if (header.draft) draft = header.draft;
+
+
         // Seed /retry + reply marker from the last user/assistant turn.
         lastUserInput = ""; lastReply = "";
         for (let k = history.length - 1; k >= 1; k--) {

package/src/commands/launch.ts

@@ -52,6 +52,7 @@ import { describeModel, describeAllProviders, describeProvider, resolveProvider,
 import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLevel } from "../ai";
 import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../agent/goal-verifier";
 import { routePrompt, deriveCacheSessionKey, warnOnce, tierModelPool, selectFromPool, PROMPT_TIERS, withRoutingTierSetting, inferTierForModel, type PromptTier, type RouteDecision } from "../agent/prompt-router";
+import { RouteHistory } from "../agent/route-history";
 
 import { isRateLimitError, isUsageLimitError, isConnectionError } from "../util/retry";
 
@@ -109,6 +110,8 @@ import {
   latestSessionId,
   exportSession,
   updateSessionModel,
+  updateSessionDraft,
+
   appendCompaction,
   resolveSessionRef,
 } from "../agent/session";
@@ -659,6 +662,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   let sessionRouteOverride: boolean | undefined;
   // Last routing decision (or the reason none applied) — /route why reads this.
   let lastRouteDecision: RouteDecision | { note: string } | null = null;
+  // Bounded FIFO of this session's routing decisions — /route history reads this.
+  // Same lifecycle scope as `lastRouteDecision`: one instance per REPL session,
+  // never persisted to config.
+  const routeHistory = new RouteHistory();
   // Computer-use session override: undefined = follow config.computer.enabled, true/false = /computer on|off wins this session.
   let sessionComputerOverride: boolean | undefined;
 
@@ -747,6 +754,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
   // pi-style session persistence: resume an existing session or create a new one.
   let sessionId: string | undefined;
+  // Unsent input-box draft restored from a resumed session's header (gajae-code
+  // parity) — folded into the very first prompt once `queuedPromptInput` exists.
+  let restoredDraft = "";
+
   let compactionSeq = 0;
   if (!flags.noSession) {
     if (flags.resumeInteractive) {
@@ -765,6 +776,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             for (const m of messages) history.push(m);
             sessionId = id;
             if (!initialSessionModel && header.model) sessionModel = header.model;
+            if (header.draft) restoredDraft = header.draft;
+
             const modelNote = sessionModel ? ` · model ${sessionModel}` : "";
             console.log(`Resumed session ${id} (${messages.length} messages).${modelNote}`);
           } catch (err) {
@@ -803,6 +816,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           // Restore the model this session was last using unless the CLI explicitly
           // pinned one (flags.model/role/provider → initialSessionModel wins).
           if (!initialSessionModel && header.model) sessionModel = header.model;
+          if (header.draft) restoredDraft = header.draft;
+
           const modelNote = sessionModel ? ` · model ${sessionModel}` : "";
           console.log(`Resumed session ${id} (${messages.length} messages).${modelNote}`);
         } catch (err) {
@@ -1025,6 +1040,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
     }
     lastRouteDecision = routed ?? (routeVetoNote ? { note: routeVetoNote } : routingEnabled && (routeOverridesPin || !sessionModel) ? { note: "routing produced no decision (fail-open)" } : { note: "routing not active this turn" });
+    // Only a REAL decision (not a `{note}` placeholder) is worth recording —
+    // `/route history` exists to show what actually routed, not every turn's
+    // gating outcome.
+    if (routed) routeHistory.add(routed);
     // Explicit /model always wins UNLESS an explicit `/route on` this session opted
     // back into per-prompt routing (`routeOverridesPin`); otherwise `routed` is only
     // ever computed when `!sessionModel`.
@@ -1465,9 +1484,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           contextTokens = catalogMetadata(activeModel)?.contextTokens;
           fallbackBaseDecision = { ...fallbackBaseDecision, model: activeModel };
           lastRouteDecision = { ...fallbackBaseDecision, warning: `model '${previousModel}' ${routedFailureReason}; switched to equivalent '${activeModel}'` };
+          // Post-call fallback: the pre-call `routed` pick (already recorded above,
+          // if any) got superseded mid-turn — record the decision that ACTUALLY
+          // served the turn so `/route history`/`why` reflect reality, not a
+          // since-abandoned pre-call guess.
+          routeHistory.add(lastRouteDecision);
           const notice = `[route] model '${previousModel}' ${routedFailureReason}; switching to equivalent '${activeModel}' for this turn.`;
-          if (tui) tui.events().onNotice?.(notice);
-          else console.log(notice);
+          if (tui) {
+            const { provider: fallbackProvider } = await describeModel(activeModel, turnConfig);
+            tui.events().onModelSwitch?.(activeModel, fallbackProvider);
+            tui.events().onNotice?.(notice);
+          } else {
+            console.log(notice);
+          }
           result = await runLoopWithModel(activeModel, activeThinking, turnSessionKey);
         }
 
@@ -2164,6 +2193,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // (the user explicitly invoked them — no second Enter).
   const pendingMidTurnCommands: string[] = [];
   const queuedPromptInput: PromptInputQueue = { pendingLines: pendingStdinLines, partial: "", pastedLines: [], inPaste: false };
+  // Fold a restored `/resume` draft (session header `draft`) into the very first
+  // prompt the same way a queued mid-turn prefill lands — visible in the input box,
+  // Enter to run, Esc/Ctrl+U to discard (gajae-code parity: an in-progress prompt
+  // survives a quit + resume instead of being silently lost).
+  if (restoredDraft) queuedPromptInput.partial = restoredDraft;
+
   queueBusyInput = (chunk: string) => captureLivePromptInputChunk(queuedPromptInput, chunk);
   queueBusyPasteActive = () => queuedPromptInput.inPaste;
   queueBusySnapshot = () => ({
@@ -2175,6 +2210,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // default routes to the immediate-dispatch queue served at the top of the loop.
     (jeoEnv("NO_MIDTURN_DISPATCH") === "1" ? pendingStdinLines : pendingMidTurnCommands).push(line);
   };
+  // Persist (or clear) the unsent input-box draft into the session header so a later
+  // `/resume` restores it (gajae-code parity). Best-effort, mirrors persistSessionModel;
+  // reads readline's own line buffer since that is the single source of truth for
+  // "what's currently typed but not submitted" (same buffer the box-render/prefill
+  // logic above reads from).
+  const persistSessionDraft = async (): Promise<void> => {
+    if (flags.noSession || !sessionId) return;
+    const current = (rl as unknown as { line?: string }).line ?? queuedPromptInput.partial ?? "";
+    try {
+      await updateSessionDraft(sessionId, current, cwd);
+    } catch { /* best-effort */ }
+  };
+
   // Bracketed-paste line routing at the PROMPT: readline strips the 2004 markers
   // and replays pasted lines as synthetic keypresses, emitting paste-start /
   // paste-end around them. Lines submitted INSIDE that window are intentional
@@ -3676,6 +3724,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     if (pickResult.sessionModel !== undefined) sessionModel = pickResult.sessionModel;
     if (pickResult.lastUserInput !== undefined) lastUserInput = pickResult.lastUserInput;
     if (pickResult.lastReply !== undefined) lastReply = pickResult.lastReply;
+    if (pickResult.draft) queuedPromptInput.partial = pickResult.draft;
+
   }
 
   // Remote (Telegram) free-text reply / config command routing — wired here,
@@ -3877,7 +3927,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         });
         sessionId = result.sessionId;
         if (result.sessionModel !== undefined) sessionModel = result.sessionModel;
-        if (result.lastUserInput !== undefined) lastUserInput = result.lastUserInput;
+        if (result.lastReply !== undefined) lastReply = result.lastReply;
+        if (result.draft) queuedPromptInput.partial = result.draft;
+
         if (result.lastReply !== undefined) lastReply = result.lastReply;
         continue;
       }
@@ -4435,6 +4487,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           routingConfigEnabled: !!cfgNow.routing?.enabled,
           lastRouteDecision,
           pinnedModel: sessionModel,
+          routeHistory: routeHistory.getAll(),
         });
         if (routeResult.sessionRouteOverride !== undefined) sessionRouteOverride = routeResult.sessionRouteOverride;
         for (const line of routeResult.lines) console.log(line);
@@ -4578,7 +4631,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
     }
   disarmPreview(); // clear footer + restore full-screen scrolling before leaving the REPL
+  await persistSessionDraft();
   if (hardExitOnLoopEnd) {
+
     try {
       disarmPreview();
       out.write("\x1b[?25h\n");

package/src/tui/app.ts

@@ -92,6 +92,13 @@ export interface AgentEventsLike {
    *  item). The TUI ignores these; launch.ts uses them to persist the final reply's artifacts. */
   onReasoningArtifactStream?(artifact: import("../ai/types").ReasoningArtifact): void;
   onBudget?(limit: number, reason: string): void;
+  /** Fired when the active model changes mid-turn (post-call equivalent-pool fallback,
+   *  launch.ts's `routeFallbackAttempt` loop) — updates the footer's model/provider
+   *  label so the status bar reflects the model that actually serves the REST of the
+   *  turn, instead of staying stuck on the pre-fallback model for the remainder of the
+   *  render (the backend `lastRouteDecision`/`routeHistory` were already correct; only
+   *  this footer label lagged). */
+  onModelSwitch?(model: string, provider?: string): void;
 
 }
 
@@ -696,6 +703,17 @@ export class LaunchTui {
         this.appendLedger(dim(`${mark} ${reason}`) + "\n", "notice");
         this.draw();
       },
+      onModelSwitch: (model: string, provider?: string) => {
+        // Mid-turn equivalent-pool fallback: the footer's model/provider label was
+        // frozen at construction time otherwise, so a post-call reroute (the model
+        // that ACTUALLY produces the rest of the reply) never showed in the status
+        // bar for the remainder of the turn — even though lastRouteDecision/
+        // routeHistory were already correct. Mutate the SAME footer object the
+        // render loop reads every frame; no separate re-render path needed.
+        this.footer.model = model;
+        this.footer.provider = provider;
+        this.draw();
+      },
       onUsage: (u: { inputTokens: number; outputTokens: number }) => {
         // Live cumulative token usage for the turn — shown in the final summary
         // (and available to the footer meter).

package/src/tui/components/slash.ts

@@ -43,7 +43,7 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/logout", usage: "/logout <anthropic|openai|gemini|antigravity>", description: "Remove the stored OAuth token for a provider", group: "models" },
   { command: "/roles", usage: "/roles [tier model]", description: "Show or set model role tiers (smol/slow/plan)", group: "models" },
   { command: "/thinking", usage: "/thinking [level]", description: "Show or set thinking budget (low/medium/high/xhigh)", group: "models" },
-  { command: "/route", usage: "/route [on|off|why]", description: "Show/toggle prompt-based model routing for this session, or explain the last routing decision", group: "models" },
+  { command: "/route", usage: "/route [on|off|why|history [n]]", description: "Show/toggle prompt-based model routing for this session, explain the last routing decision, or list recent routing history", group: "models" },
   { command: "/agents", usage: "/agents [edit|role] [model|#N|thinking L|maxSteps N|reset]", description: "List subagent roles; use /agents edit for the interactive picker or pin role model/settings", group: "subagents" },
   { command: "/subagent", usage: "/subagent [role]", description: "Show the current subagent composition (per-role model · thinking · steps); alias of /agents", group: "subagents" },
   { command: "/view", usage: "/view <file> [a-b]", description: "Render a file with line numbers + light highlight", group: "code" },