jeo-code 0.7.46 → 0.7.47

package/CHANGELOG.md

@@ -6,6 +6,19 @@ 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.7.47] - 2026-07-06
+_PromptRouter (gjc-inspired, jeo-native design — NOT a port of katanemo/plano, whose always-on proxy-orchestrator architecture doesn't fit an interactive CLI's per-turn latency budget): jeo already had static, role-based model mapping (`resolveSubagentModel`/`resolveRoleModel`) but zero logic that varied the model by what THIS turn's prompt actually asks for. Adds an opt-in (default OFF), heuristic-first, fail-open per-turn router: a bilingual regex classifier scores a prompt into trivial/standard/complex, escalating to one cheap LLM call ONLY when the heuristic is genuinely ambiguous (confidence below a configurable threshold — most turns never escalate), and an explicit `/model` pin always wins over routing. No new plumbing: reuses `resolveRoleModel`, `callLlm`, `jsonMode`, `catalogMetadata`, `tryExtractJsonObject`, and the existing `onNotice` transparency pattern._
+
+### Added
+- **`src/agent/prompt-router.ts`** — `classifyPromptHeuristically` (pure, sync, zero-I/O): bilingual (EN/KR) signal detection for short factual questions, causal/debugging questions ("why"/"how"/"왜"/"어떻게" — deliberately NEVER classified as trivial despite being short-and-question-shaped), code fences, file-path mentions (single vs. multi-file), and deep-work keywords (design/architecture/refactor/debug/설계/아키텍처/리팩터/디버그); conflicting or weak signals resolve to `standard` at low confidence so escalation decides. `routePrompt` escalates to a real LLM classification only below `routing.confidenceThreshold` (default 0.6) AND only when `roles.smol` is configured (otherwise "escalate to a cheap model" would paradoxically call the expensive `defaultModel` — skipped with a one-time `warnOnce` notice instead); the escalation response is parsed via `tryExtractJsonObject` (never bare `JSON.parse`, since not every provider has native JSON mode) and the returned tier is strictly validated against the 3 literal values before being trusted. Tier→model resolution reuses `config.roles.smol`/`config.roles.slow` when `routing.tiers.*.model` isn't explicitly set — zero new config required to get working routing if role tiers are already configured. An image-bearing prompt whose resolved tier model lacks image support (`catalogMetadata(...)?.images === false`) fails open, returning `null` so the caller keeps its own multimodal-capable model. The entire function is wrapped in try/catch and returns `null` on any unexpected failure — routing can never break a turn.
+- **`LaunchTui`/`runTurn` wiring** (`src/commands/launch.ts`) — the `activeModel`/`activeThinking` computation now calls `routePrompt` when routing is enabled (session override via `/route on|off`, else `config.routing.enabled`) AND the user has NOT manually pinned a session model via `/model` (explicit choice always wins, verified by a real end-to-end test through `runLaunchCommand` — routing never engages when `sessionModel` is set even with `routing.enabled: true`). A `[route] tier → model (...)` notice surfaces only when something actually changed (an LLM escalation occurred, or the tier isn't `standard`) — a routine unescalated turn stays silent.
+- **`/route [status|on|off|why]`** (`src/commands/launch/route-slash.ts`, registered in `src/tui/components/slash.ts`) — session-local toggle (never persisted to `~/.jeo/config.json`, mirroring `/thinking`) plus a `why` subcommand that explains the last routing decision's tier, resolved model, confidence, source (heuristic/llm), and every fired signal.
+- **`routing` config field** (`ConfigSchema` in `config-schema.ts`, `Config` in `state.ts`) — `{enabled?, confidenceThreshold?, tiers?: {trivial|standard|complex: {model?, thinking?}}}`, all optional, default OFF.
+
+### Verified
+- `bun run typecheck` clean; `bun test` 2479 pass / 0 fail (48 new: `test/prompt-router.test.ts` — 32 tests covering the full bilingual signal corpus incl. the causal-question and numeric-fraction-path false-positive fixes found during design, escalation fail-open on `callLlm` throwing/aborting/returning malformed or invalid-tier JSON, the image-capability gate, and the "no config at all resolves to defaultModel" safe-no-op case; `test/route-slash.test.ts` — 12 tests for every `/route` subcommand; `test/launch-prompt-routing.test.ts` — 4 real end-to-end tests through the actual `runLaunchCommand` entrypoint, mocking only `node:readline` input and `runAgentLoop`'s network boundary, proving the explicit-`/model`-always-wins guarantee and `roles.smol`/`routing.tiers.*.thinking` resolution against the REAL wiring, not a synthetic stub).
+- Two independent subagent passes (config-schema + core router module in parallel, then launch.ts/slash wiring), every line independently re-read and cross-checked against a frozen, pre-verified implementation contract by the orchestrating session before merge — including two real bugs caught in the contract itself before implementation (a TDZ reference to `tui` before its declaration, and invalid `??`/`||` operator mixing) that both subagents correctly fixed as mechanical corrections.
+
 ## [0.7.46] - 2026-07-06
 _Registry-only correction: `npm publish` packs the working-tree filesystem, not the git commit — a concurrent, unrelated, uncommitted feature-in-progress from another session sharing this checkout (`src/agent/prompt-router.ts`, `src/commands/launch/route-slash.ts`, and edits to `config-schema.ts`/`state.ts`/`launch.ts`/`slash.ts`) was physically present on disk during the 0.7.45 `npm publish` and got bundled into that tarball even though it was never committed to git and is absent from the `0.7.45` git tag/branch. Unpublished `jeo-code@0.7.45` from the registry within minutes (npm then permanently blocks republishing that exact version number, hence the bump to 0.7.46) and republished from a verified-clean working tree (`git stash` of the foreign files, `npm pack --dry-run` confirmed their absence, then restored the stash afterward so the other session's in-progress work was never touched or lost). No functional change versus the intended 0.7.45 content — see that entry below._
 

package/README.ja.md

@@ -259,11 +259,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.47]** (2026-07-06) — PromptRouter (gjc-inspired, jeo-native design — NOT a port of katanemo/plano, whose always-on proxy-orchestrator architecture doesn't fit an interactive CLI's per-turn latency budget): jeo already had static, role-based model mapping (`resolveSubagentModel`/`resolveRoleModel`) but zero logic that varied the model by what THIS turn's prompt actually asks for. Adds an opt-in (default OFF), heuristic-first, fail-open per-turn router: a bilingual regex classifier scores a prompt into trivial/standard/complex, escalating to one cheap LLM call ONLY when the heuristic is genuinely ambiguous (confidence below a configurable threshold — most turns never escalate), and an explicit `/model` pin always wins over routing. No new plumbing: reuses `resolveRoleModel`, `callLlm`, `jsonMode`, `catalogMetadata`, `tryExtractJsonObject`, and the existing `onNotice` transparency pattern.
 - **[0.7.46]** (2026-07-06) — Registry-only correction: `npm publish` packs the working-tree filesystem, not the git commit — a concurrent, unrelated, uncommitted feature-in-progress from another session sharing this checkout (`src/agent/prompt-router.ts`, `src/commands/launch/route-slash.ts`, and edits to `config-schema.ts`/`state.ts`/`launch.ts`/`slash.ts`) was physically present on disk during the 0.7.45 `npm publish` and got bundled into that tarball even though it was never committed to git and is absent from the `0.7.45` git tag/branch. Unpublished `jeo-code@0.7.45` from the registry within minutes (npm then permanently blocks republishing that exact version number, hence the bump to 0.7.46) and republished from a verified-clean working tree (`git stash` of the foreign files, `npm pack --dry-run` confirmed their absence, then restored the stash afterward so the other session's in-progress work was never touched or lost). No functional change versus the intended 0.7.45 content — see that entry below.
 - **[0.7.45]** (2026-07-06) — gjc parity: jeo's subagent `task {tasks:[...]}` fan-out batches now visibly run as PARALLEL processes the way gjc's own task tool does, instead of quietly forcing the mutating executor role to serialize. Two compounding bugs made a batch of independent subagent tasks look and behave sequential even though the read-only roles were already technically concurrent: (1) the executor role's fan-out was hard-coded to concurrency 1 regardless of batch size, and (2) the TUI's live status line tracked ONE shared string clobbered by whichever worker's event landed last — worse, ANY single worker reaching "done" cleared the whole `(sub)` marker even while its siblings were still actively running.
 - **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
 - **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
-- **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -259,11 +259,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.47]** (2026-07-06) — PromptRouter (gjc-inspired, jeo-native design — NOT a port of katanemo/plano, whose always-on proxy-orchestrator architecture doesn't fit an interactive CLI's per-turn latency budget): jeo already had static, role-based model mapping (`resolveSubagentModel`/`resolveRoleModel`) but zero logic that varied the model by what THIS turn's prompt actually asks for. Adds an opt-in (default OFF), heuristic-first, fail-open per-turn router: a bilingual regex classifier scores a prompt into trivial/standard/complex, escalating to one cheap LLM call ONLY when the heuristic is genuinely ambiguous (confidence below a configurable threshold — most turns never escalate), and an explicit `/model` pin always wins over routing. No new plumbing: reuses `resolveRoleModel`, `callLlm`, `jsonMode`, `catalogMetadata`, `tryExtractJsonObject`, and the existing `onNotice` transparency pattern.
 - **[0.7.46]** (2026-07-06) — Registry-only correction: `npm publish` packs the working-tree filesystem, not the git commit — a concurrent, unrelated, uncommitted feature-in-progress from another session sharing this checkout (`src/agent/prompt-router.ts`, `src/commands/launch/route-slash.ts`, and edits to `config-schema.ts`/`state.ts`/`launch.ts`/`slash.ts`) was physically present on disk during the 0.7.45 `npm publish` and got bundled into that tarball even though it was never committed to git and is absent from the `0.7.45` git tag/branch. Unpublished `jeo-code@0.7.45` from the registry within minutes (npm then permanently blocks republishing that exact version number, hence the bump to 0.7.46) and republished from a verified-clean working tree (`git stash` of the foreign files, `npm pack --dry-run` confirmed their absence, then restored the stash afterward so the other session's in-progress work was never touched or lost). No functional change versus the intended 0.7.45 content — see that entry below.
 - **[0.7.45]** (2026-07-06) — gjc parity: jeo's subagent `task {tasks:[...]}` fan-out batches now visibly run as PARALLEL processes the way gjc's own task tool does, instead of quietly forcing the mutating executor role to serialize. Two compounding bugs made a batch of independent subagent tasks look and behave sequential even though the read-only roles were already technically concurrent: (1) the executor role's fan-out was hard-coded to concurrency 1 regardless of batch size, and (2) the TUI's live status line tracked ONE shared string clobbered by whichever worker's event landed last — worse, ANY single worker reaching "done" cleared the whole `(sub)` marker even while its siblings were still actively running.
 - **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
 - **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
-- **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -261,11 +261,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.7.47]** (2026-07-06) — PromptRouter (gjc-inspired, jeo-native design — NOT a port of katanemo/plano, whose always-on proxy-orchestrator architecture doesn't fit an interactive CLI's per-turn latency budget): jeo already had static, role-based model mapping (`resolveSubagentModel`/`resolveRoleModel`) but zero logic that varied the model by what THIS turn's prompt actually asks for. Adds an opt-in (default OFF), heuristic-first, fail-open per-turn router: a bilingual regex classifier scores a prompt into trivial/standard/complex, escalating to one cheap LLM call ONLY when the heuristic is genuinely ambiguous (confidence below a configurable threshold — most turns never escalate), and an explicit `/model` pin always wins over routing. No new plumbing: reuses `resolveRoleModel`, `callLlm`, `jsonMode`, `catalogMetadata`, `tryExtractJsonObject`, and the existing `onNotice` transparency pattern.
 - **[0.7.46]** (2026-07-06) — Registry-only correction: `npm publish` packs the working-tree filesystem, not the git commit — a concurrent, unrelated, uncommitted feature-in-progress from another session sharing this checkout (`src/agent/prompt-router.ts`, `src/commands/launch/route-slash.ts`, and edits to `config-schema.ts`/`state.ts`/`launch.ts`/`slash.ts`) was physically present on disk during the 0.7.45 `npm publish` and got bundled into that tarball even though it was never committed to git and is absent from the `0.7.45` git tag/branch. Unpublished `jeo-code@0.7.45` from the registry within minutes (npm then permanently blocks republishing that exact version number, hence the bump to 0.7.46) and republished from a verified-clean working tree (`git stash` of the foreign files, `npm pack --dry-run` confirmed their absence, then restored the stash afterward so the other session's in-progress work was never touched or lost). No functional change versus the intended 0.7.45 content — see that entry below.
 - **[0.7.45]** (2026-07-06) — gjc parity: jeo's subagent `task {tasks:[...]}` fan-out batches now visibly run as PARALLEL processes the way gjc's own task tool does, instead of quietly forcing the mutating executor role to serialize. Two compounding bugs made a batch of independent subagent tasks look and behave sequential even though the read-only roles were already technically concurrent: (1) the executor role's fan-out was hard-coded to concurrency 1 regardless of batch size, and (2) the TUI's live status line tracked ONE shared string clobbered by whichever worker's event landed last — worse, ANY single worker reaching "done" cleared the whole `(sub)` marker even while its siblings were still actively running.
 - **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
 - **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
-- **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -259,11 +259,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.47]** (2026-07-06) — PromptRouter (gjc-inspired, jeo-native design — NOT a port of katanemo/plano, whose always-on proxy-orchestrator architecture doesn't fit an interactive CLI's per-turn latency budget): jeo already had static, role-based model mapping (`resolveSubagentModel`/`resolveRoleModel`) but zero logic that varied the model by what THIS turn's prompt actually asks for. Adds an opt-in (default OFF), heuristic-first, fail-open per-turn router: a bilingual regex classifier scores a prompt into trivial/standard/complex, escalating to one cheap LLM call ONLY when the heuristic is genuinely ambiguous (confidence below a configurable threshold — most turns never escalate), and an explicit `/model` pin always wins over routing. No new plumbing: reuses `resolveRoleModel`, `callLlm`, `jsonMode`, `catalogMetadata`, `tryExtractJsonObject`, and the existing `onNotice` transparency pattern.
 - **[0.7.46]** (2026-07-06) — Registry-only correction: `npm publish` packs the working-tree filesystem, not the git commit — a concurrent, unrelated, uncommitted feature-in-progress from another session sharing this checkout (`src/agent/prompt-router.ts`, `src/commands/launch/route-slash.ts`, and edits to `config-schema.ts`/`state.ts`/`launch.ts`/`slash.ts`) was physically present on disk during the 0.7.45 `npm publish` and got bundled into that tarball even though it was never committed to git and is absent from the `0.7.45` git tag/branch. Unpublished `jeo-code@0.7.45` from the registry within minutes (npm then permanently blocks republishing that exact version number, hence the bump to 0.7.46) and republished from a verified-clean working tree (`git stash` of the foreign files, `npm pack --dry-run` confirmed their absence, then restored the stash afterward so the other session's in-progress work was never touched or lost). No functional change versus the intended 0.7.45 content — see that entry below.
 - **[0.7.45]** (2026-07-06) — gjc parity: jeo's subagent `task {tasks:[...]}` fan-out batches now visibly run as PARALLEL processes the way gjc's own task tool does, instead of quietly forcing the mutating executor role to serialize. Two compounding bugs made a batch of independent subagent tasks look and behave sequential even though the read-only roles were already technically concurrent: (1) the executor role's fan-out was hard-coded to concurrency 1 regardless of batch size, and (2) the TUI's live status line tracked ONE shared string clobbered by whichever worker's event landed last — worse, ANY single worker reaching "done" cleared the whole `(sub)` marker even while its siblings were still actively running.
 - **[0.7.44]** (2026-07-06) — Root-caused a real production hang reported from `jeo`'s OpenAI Codex OAuth subagent path: after roughly 20-30 minutes of active streamed traffic, `chatgpt.com`'s backend severs the live SSE connection mid-response (an infra connection-duration cap, not a broken network) and Bun's fetch/undici surfaces it as `Error: The socket connection was closed unexpectedly …`. `retryableStream` (model-manager.ts) only auto-retries losing the FIRST streamed chunk — once any chunk had reached the caller it deliberately stopped retrying (a full re-call would replay already-emitted content) — so this class of drop propagated straight out of the engine as a raw, unretried turn-ending error every time, even though nothing had been committed to history yet and a plain resend is exactly as safe as a fresh call.
 - **[0.7.43]** (2026-07-06) — TUI inline image DISPLAY (gjc TUI-image parity): jeo could already ATTACH an image to a turn (clipboard paste, drag-drop, `@path`) but never rendered it back — the transcript only ever showed a `⧉ N image(s) attached` count. On a terminal that speaks the kitty graphics protocol (kitty/ghostty/wezterm) or iTerm2's OSC 1337 inline-image protocol, a submitted image now renders as an actual picture directly under the `user` card; every other terminal (Terminal.app, plain xterm, CI/non-TTY) keeps today's text-only behavior unchanged. No native/binary dependency added — Sixel was deliberately left out because producing a sixel stream from arbitrary PNG/JPEG bytes needs a pixel quantizer jeo doesn't have; both implemented protocols decode compressed image bytes themselves.
-- **[0.7.42]** (2026-07-06) — Fixes a genuine infinite hang on "thinking"/"executing" (reported under `jeo --tmux`, but the two root causes are tmux-agnostic): the interactive streaming model call had no absolute wall-clock, and the ~30-minute turn stall budget was a passive check that could never interrupt a blocked await in the first place. A third, lower-confidence but plausible tmux-specific trigger (synchronous TUI frame writes blocking on a backpressured tmux pane) gets a defensive, generic fix too.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

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

package/src/agent/config-schema.ts

@@ -161,6 +161,24 @@ export const ConfigSchema = z
         plan: z.string().optional(),
       })
       .optional(),
+    /** Prompt-content-based per-turn model routing (PromptRouter). Opt-in — off unless
+     *  `enabled: true`. Applies ONLY to the main interactive turn loop (never to
+     *  subagents/`task`, which keep their own `subagents.*`/role-tier resolution
+     *  untouched), and ONLY when the user has not manually pinned a session model
+     *  via `/model` (explicit user choice always wins). */
+    routing: z
+      .object({
+        enabled: z.boolean().optional(),
+        confidenceThreshold: z.number().min(0).max(1).optional(),
+        tiers: z
+          .object({
+            trivial: z.object({ model: z.string().optional(), thinking: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional() }).optional(),
+            standard: z.object({ model: z.string().optional(), thinking: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional() }).optional(),
+            complex: z.object({ model: z.string().optional(), thinking: z.enum(["minimal", "low", "medium", "high", "xhigh"]).optional() }).optional(),
+          })
+          .optional(),
+      })
+      .optional(),
     gitAutoCommit: z.boolean().optional(),
     hooks: HookConfigSchema.optional(),
     computer: z

package/src/agent/prompt-router.ts

@@ -0,0 +1,273 @@
+/**
+ * PromptRouter: per-turn, prompt-content-based model routing (heuristic-first,
+ * LLM-escalation-only-when-ambiguous, always fail-open).
+ *
+ * Why heuristic-first instead of always asking a model to classify: a classifier
+ * call on every turn would burn latency+cost on the common case (most turns are
+ * unambiguously trivial or unambiguously routine). The regex heuristic below
+ * resolves the vast majority of turns with zero I/O; only genuinely ambiguous
+ * prompts (conflicting or absent signals) pay for a cheap escalation call.
+ *
+ * Why fail-open everywhere: this module runs on EVERY qualifying turn (see
+ * launch.ts's `runTurn`). A routing bug or a flaky classifier call must never
+ * be able to break a real user turn — every internal step swallows its own
+ * failures and falls back to a safe default, and the top-level export wraps
+ * everything again as a final backstop.
+ *
+ * Why no static tier→model map: `resolveTierModel` computes inline off
+ * `config.roles`/`config.routing.tiers` so a user who already configured
+ * `roles.smol`/`roles.slow` (for `--smol`/`--slow` role-tier resolution
+ * elsewhere) gets working routing with zero additional config, and an
+ * unconfigured role falls through to `defaultModel` exactly like every other
+ * role-tier consumer in this codebase (see `resolveRoleModel`).
+ */
+import { callLlm } from "./loop";
+import { resolveRoleModel } from "../ai/model-manager";
+import { catalogMetadata } from "../ai/model-catalog";
+import { tryExtractJsonObject } from "./json";
+import type { Config } from "./state";
+import type { ThinkLevel } from "../ai/model-catalog";
+
+export type PromptTier = "trivial" | "standard" | "complex";
+
+export interface HeuristicResult {
+  tier: PromptTier;
+  confidence: number; // 0..1
+  signals: string[]; // fired signal names, e.g. ["short-question","no-code-no-path"]
+}
+
+export interface RouteDecision {
+  model: string;
+  thinking?: ThinkLevel; // undefined = do not override the session/global thinking level
+  tier: PromptTier;
+  confidence: number;
+  source: "heuristic" | "llm";
+  signals: string[];
+  /** Present only on the "smol role not configured" first-occurrence case — see warnOnce below. */
+  warning?: string;
+}
+
+export interface RoutePromptOptions {
+  hasImages?: boolean;
+  signal?: AbortSignal;
+}
+
+// --- Frozen, bilingual-validated classification signals (do not re-derive). ---
+
+const RE_CAUSAL = /\b(why|how|root cause|how come)\b/i;
+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_PATH_TOKEN = /(?:^|[\s"'`(])@?(?:\.{0,2}[\w-]*\/)+[\w-]+(?:\.[\w-]+)*\.[A-Za-z]\w{0,7}\b/g;
+const RE_DEEP_KEYWORDS_EN = /\b(design|architecture|refactor|debug|deep\s*dive|investigate|diagnose|redesign)\b/i;
+const RE_DEEP_KEYWORDS_KR = /(설계|아키텍처|리팩터|디버그|딥\s*다이브|딥다이브|진단)/;
+const RE_SENTENCE_BOUNDARY = /[.!?][ \n]|[.!?]$/g;
+
+/**
+ * Pure, synchronous, zero-I/O prompt classification. Every branch and threshold
+ * here is frozen per the PromptRouter contract (validated against a 17+-case
+ * bilingual corpus) — in particular: a causal ("why"/"how"/"왜"/"어떻게") question
+ * is NEVER treated as trivial just because it's short and question-shaped (a
+ * debugging question is the opposite of trivial), and the path-token regex is
+ * anchored so numeric fractions like "3/4.5" or "10/10" never false-positive as
+ * a file path (the trailing segment must end in a letter-led extension).
+ */
+export function classifyPromptHeuristically(prompt: string): HeuristicResult {
+  const trimmed = prompt.trim();
+  const signals: string[] = [];
+  let trivialScore = 0;
+  let complexScore = 0;
+
+  const isCausal = RE_CAUSAL.test(trimmed) || RE_CAUSAL_KR.test(trimmed);
+
+  // trivial signal 1: short AND a factual-lookup-shaped question (never for a causal question).
+  const isShort = trimmed.length < 40;
+  const looksLikeFactualQuestion =
+    !isCausal &&
+    (trimmed.includes("?") || RE_TRIVIAL_QUESTION_WORD.test(trimmed) || RE_TRIVIAL_QUESTION_WORD_KR.test(trimmed));
+  if (isShort && looksLikeFactualQuestion) {
+    trivialScore++;
+    signals.push("short-question");
+  }
+
+  // trivial signal 2: no code fence AND no file path mention.
+  const hasCodeFence = RE_CODE_FENCE.test(trimmed);
+  const pathMatches = [...trimmed.matchAll(RE_PATH_TOKEN)];
+  if (!hasCodeFence && pathMatches.length === 0) {
+    trivialScore++;
+    signals.push("no-code-no-path");
+  }
+
+  // complex signal 1: deep-work keyword.
+  if (RE_DEEP_KEYWORDS_EN.test(trimmed) || RE_DEEP_KEYWORDS_KR.test(trimmed)) {
+    complexScore++;
+    signals.push("deep-work-keyword");
+  }
+
+  // complex signal 1b: causal/debugging question.
+  if (isCausal) {
+    complexScore++;
+    signals.push("causal-question");
+  }
+
+  // complex signal 2: long or multi-sentence.
+  const questionMarkCount = (trimmed.match(/\?/g) ?? []).length;
+  const sentenceCount = (trimmed.match(RE_SENTENCE_BOUNDARY) ?? []).length;
+  if (trimmed.length >= 200 || questionMarkCount >= 2 || sentenceCount >= 3) {
+    complexScore++;
+    signals.push("long-or-multi-sentence");
+  }
+
+  // complex signal 3: multiple distinct file mentions.
+  const distinctPaths = new Set(pathMatches.map(m => m[0].trim()));
+  if (distinctPaths.size >= 2) {
+    complexScore++;
+    signals.push("multi-file");
+  }
+
+  // Tier + confidence resolution (frozen thresholds).
+  if (trivialScore > 0 && complexScore > 0) {
+    return { tier: "standard", confidence: 0.35, signals }; // conflicting signals -> let escalation decide
+  }
+  if (complexScore >= 2) return { tier: "complex", confidence: 0.85, signals };
+  if (complexScore === 1) return { tier: "complex", confidence: 0.65, signals };
+  if (trivialScore >= 2) return { tier: "trivial", confidence: 0.85, signals };
+  if (trivialScore === 1) return { tier: "trivial", confidence: 0.65, signals };
+  return { tier: "standard", confidence: 0.9, signals }; // no signals at all -> common case, high confidence
+}
+
+// --- warnOnce: module-level one-time warning surface (no existing helper for this). ---
+
+const warnedKeys = new Set<string>();
+
+/** Returns `message` the first time `key` is seen in this process, `undefined` every
+ *  time after — lets a fail-open path surface a diagnostic exactly once instead of
+ *  spamming it on every qualifying turn. */
+export function warnOnce(key: string, message: string): string | undefined {
+  if (warnedKeys.has(key)) return undefined;
+  warnedKeys.add(key);
+  return message;
+}
+
+/** Test-only: clear warned-once state between test cases (mirrors
+ *  src/tui/components/color.ts's resetAppearanceCache pattern). */
+export function resetPromptRouterWarnings(): void {
+  warnedKeys.clear();
+}
+
+// --- Tier -> model/thinking resolution (inline off config.roles/config.routing.tiers; no static map). ---
+
+function resolveTierModel(tier: PromptTier, config: Pick<Config, "defaultModel" | "roles" | "routing">): string {
+  const configured = config.routing?.tiers?.[tier]?.model;
+  if (configured) return configured;
+  if (tier === "trivial") return config.roles?.smol || config.defaultModel;
+  if (tier === "complex") return config.roles?.slow || config.defaultModel;
+  return config.defaultModel; // "standard" always falls through to defaultModel unless explicitly configured
+}
+
+function resolveTierThinking(tier: PromptTier, config: Pick<Config, "defaultModel" | "roles" | "routing">): ThinkLevel | undefined {
+  return config.routing?.tiers?.[tier]?.thinking; // undefined = no override, caller keeps session/global level
+}
+
+const VALID_TIERS: readonly PromptTier[] = ["trivial", "standard", "complex"];
+function isPromptTier(value: unknown): value is PromptTier {
+  return typeof value === "string" && (VALID_TIERS as readonly string[]).includes(value);
+}
+
+/** Hard cap on how much of the prompt is embedded in the escalation classifier call —
+ *  never send megabytes of user text to a cheap classifier model. */
+const ESCALATION_PROMPT_CHAR_CAP = 2000;
+
+function buildClassifierPrompt(prompt: string): string {
+  const capped = prompt.length > ESCALATION_PROMPT_CHAR_CAP ? prompt.slice(0, ESCALATION_PROMPT_CHAR_CAP) : prompt;
+  return (
+    `Classify the complexity of the following user request for a coding assistant into exactly one ` +
+    `tier: "trivial" (a quick factual lookup, no repo work), "standard" (routine coding/editing work), ` +
+    `or "complex" (multi-file, architectural, or root-cause debugging work). ` +
+    `Respond with ONLY a JSON object of the shape {"tier":"trivial"|"standard"|"complex"}.\n\n` +
+    `Request:\n${capped}`
+  );
+}
+
+/** Attempt LLM-based re-classification for an ambiguous heuristic result. Fail-open:
+ *  ANY failure (throw, abort/timeout, malformed JSON, invalid tier value) resolves to
+ *  `undefined` so the caller falls back to the heuristic tier silently. */
+async function escalateToLlm(prompt: string, smolModel: string, signal: AbortSignal | undefined): Promise<PromptTier | undefined> {
+  try {
+    const raw = await callLlm([{ role: "user", content: buildClassifierPrompt(prompt) }], {
+      model: smolModel,
+      jsonMode: true,
+      maxTokens: 200,
+      signal,
+    });
+    const parsed = tryExtractJsonObject<{ tier?: unknown }>(raw);
+    if (parsed && isPromptTier(parsed.tier)) return parsed.tier;
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Stable key for the one-time "escalation skipped, roles.smol unconfigured" notice. */
+const SMOL_UNCONFIGURED_WARNING_KEY = "prompt-router:smol-unconfigured";
+
+/**
+ * Route a single turn's prompt to a tier-appropriate model. Heuristic-first: only
+ * escalates to a real LLM call when the heuristic's confidence is below
+ * `config.routing?.confidenceThreshold` (default 0.6). Returns `null` (never
+ * throws) when routing should not override the caller's own already-computed
+ * model — either because of an unexpected internal failure (defensive backstop;
+ * every internal step already fails open on its own) or because the resolved
+ * tier's model lacks image support for an image-bearing turn (the caller must
+ * keep whatever multimodal-capable model it already had).
+ */
+export async function routePrompt(
+  prompt: string,
+  config: Pick<Config, "defaultModel" | "roles" | "routing">,
+  opts: RoutePromptOptions = {},
+): Promise<RouteDecision | null> {
+  try {
+    const heuristic = classifyPromptHeuristically(prompt);
+    const threshold = config.routing?.confidenceThreshold ?? 0.6;
+
+    let tier = heuristic.tier;
+    let source: "heuristic" | "llm" = "heuristic";
+    let warning: string | undefined;
+
+    if (heuristic.confidence < threshold) {
+      const smolModel = resolveRoleModel("smol", config);
+      if (smolModel === config.defaultModel) {
+        // roles.smol not configured -> "escalate to a cheap model" would actually call
+        // defaultModel (expensive) — the exact paradox the design doc identifies. Skip
+        // escalation, keep the heuristic result, and surface a one-time warning.
+        warning = warnOnce(
+          SMOL_UNCONFIGURED_WARNING_KEY,
+          "[route] confidence below threshold but roles.smol is not configured — skipping LLM escalation, using heuristic tier (set roles.smol to enable escalation)",
+        );
+      } else {
+        const escalated = await escalateToLlm(prompt, smolModel, opts.signal);
+        if (escalated) {
+          tier = escalated;
+          source = "llm";
+        }
+      }
+    }
+
+    const model = resolveTierModel(tier, config);
+    if (opts.hasImages && catalogMetadata(model)?.images === false) return null;
+
+    const decision: RouteDecision = {
+      model,
+      thinking: resolveTierThinking(tier, config),
+      tier,
+      confidence: heuristic.confidence,
+      source,
+      signals: heuristic.signals,
+    };
+    if (warning) decision.warning = warning;
+    return decision;
+  } catch {
+    return null;
+  }
+}

package/src/agent/state.ts

@@ -122,6 +122,17 @@ export interface Config {
    * `defaultModel`. Env `JEO_SMOL_MODEL`/`JEO_SLOW_MODEL`/`JEO_PLAN_MODEL` fill gaps.
    */
   roles?: { smol?: string; slow?: string; plan?: string };
+  /** Prompt-content-based per-turn model routing (PromptRouter) — see prompt-router.ts.
+   *  Opt-in (undefined/false = off). Never affects subagent/role-tier model resolution. */
+  routing?: {
+    enabled?: boolean;
+    confidenceThreshold?: number;
+    tiers?: {
+      trivial?: { model?: string; thinking?: "minimal" | "low" | "medium" | "high" | "xhigh" };
+      standard?: { model?: string; thinking?: "minimal" | "low" | "medium" | "high" | "xhigh" };
+      complex?: { model?: string; thinking?: "minimal" | "low" | "medium" | "high" | "xhigh" };
+    };
+  };
   gitAutoCommit?: boolean;
   hooks?: HookConfig;
   computer?: {

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

@@ -0,0 +1,88 @@
+/**
+ * `/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.
+ *
+ * Session-level toggle only — `sessionRouteOverride` is never persisted to
+ * `~/.jeo/config.json` (mirrors `/thinking` being session-only vs. `/model
+ * save` being the explicit opt-in for persistence). `/route` has no `save`
+ * subcommand in v1.
+ */
+
+import type { RouteDecision } from "../../agent/prompt-router";
+
+export interface RouteSlashCtx {
+  sessionRouteOverride: boolean | undefined;
+  /** `turnConfig.routing?.enabled ?? false`, read fresh by the caller. */
+  routingConfigEnabled: boolean;
+  lastRouteDecision: RouteDecision | { note: string } | null;
+}
+
+export interface RouteSlashResult {
+  /** Present only when changed by "on"/"off". */
+  sessionRouteOverride?: boolean | undefined;
+  /** Lines to print. */
+  lines: string[];
+}
+
+const USAGE = "Usage: /route [status|on|off|why]";
+
+function isRealDecision(decision: RouteDecision | { note: string } | null): decision is RouteDecision {
+  return !!decision && "model" in decision;
+}
+
+function explainDecision(decision: RouteDecision | { note: string } | null): string[] {
+  if (!isRealDecision(decision)) {
+    return [decision?.note ?? "No routing decision has been made yet this session."];
+  }
+  const lines = [
+    `tier: ${decision.tier}`,
+    `model: ${decision.model}`,
+    `source: ${decision.source}`,
+    `confidence: ${decision.confidence.toFixed(2)}`,
+    `signals: ${decision.signals.join(", ") || "none"}`,
+  ];
+  if (decision.thinking) lines.push(`thinking: ${decision.thinking}`);
+  if (decision.warning) lines.push(`warning: ${decision.warning}`);
+  return lines;
+}
+
+/**
+ * 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.
+ */
+export function runRouteSlash(input: string, ctx: RouteSlashCtx): RouteSlashResult {
+  const rest = input.slice("/route".length).trim();
+  const [sub] = rest.split(/\s+/).filter(Boolean);
+  const effective = ctx.sessionRouteOverride ?? ctx.routingConfigEnabled;
+
+  if (!sub || sub === "status") {
+    const lines = [`routing: ${effective ? "on" : "off"} (this session)`];
+    if (isRealDecision(ctx.lastRouteDecision)) {
+      lines.push(`last decision: ${ctx.lastRouteDecision.tier} → ${ctx.lastRouteDecision.model} (${ctx.lastRouteDecision.source}: ${ctx.lastRouteDecision.signals.join(", ") || "none"}, confidence ${ctx.lastRouteDecision.confidence.toFixed(2)})`);
+    }
+    return { lines };
+  }
+
+  if (sub === "on") {
+    return { sessionRouteOverride: true, lines: ["routing: on (this session)"] };
+  }
+
+  if (sub === "off") {
+    return { sessionRouteOverride: false, lines: ["routing: off (this session)"] };
+  }
+
+  if (sub === "why") {
+    return { lines: explainDecision(ctx.lastRouteDecision) };
+  }
+
+  return { lines: [`Unknown /route subcommand: ${sub}`, USAGE] };
+}

package/src/commands/launch.ts

@@ -47,6 +47,7 @@ import { rememberModelPatch, recentModelsForDisplay } from "../agent/model-recen
 import { describeModel, describeAllProviders, thinkingMaxTokens, resolveMaxOutputTokens, thinkingToReasoningEffort, discoverModels, flattenModels, resolveSelection, catalogMetadata, catalogByProvider, resolveRoleModel, CODEX_MODELS, qualifyModelId } from "../ai";
 import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLevel } from "../ai";
 import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../agent/goal-verifier";
+import { routePrompt, type RouteDecision } from "../agent/prompt-router";
 
 import { listAliases } from "../ai/model-registry";
 import { openaiCompatDef, SUBSCRIPTION_PROVIDER_NAMES } from "../ai/providers/openai-compatible-catalog";
@@ -204,6 +205,7 @@ import {
 import { handleUndoSlash } from "./launch/git-slash";
 import { runSessionSlash } from "./launch/session-slash";
 import { runModelSlash } from "./launch/model-slash";
+import { runRouteSlash } from "./launch/route-slash";
 import { runAgentsSlash, runRolesSlash, runFastSlash, runThinkingSlash } from "./launch/agents-slash";
 import { wikiRootPromptLine, decideWikiSlash } from "./launch/wiki-slash";
 import { decideThemeSlash, buildConfigPanelLines, runEvolveSimulation } from "./launch/system-slash";
@@ -642,6 +644,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   let sessionModel: string | undefined = initialSessionModel;
   // Session thinking-level override (`/thinking`); falls back to the config level.
   let sessionThinking: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined = flags.thinking ?? cfg.thinkingLevel;
+  // PromptRouter session override: undefined = follow config.routing.enabled, true/false = /route on|off wins this session.
+  let sessionRouteOverride: boolean | undefined;
+  // Last routing decision (or the reason none applied) — /route why reads this.
+  let lastRouteDecision: RouteDecision | { note: string } | null = null;
   // Cache of live, credential-validated models per provider (refreshed by live pickers).
   let liveModelsCache: ProviderModelsResult[] | null = null;
   const getLiveModels = async (force = false): Promise<ProviderModelsResult[]> => {
@@ -844,7 +850,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // global default (rememberModelPatch), so re-reading turnConfig.defaultModel here let
     // that write silently switch THIS running session's model mid-run. Per-session model
     // selection must stay session-local: running sessions never influence each other.
-    const activeModel = sessionModel || defaultModel;
+    const routingEnabled = sessionRouteOverride ?? !!turnConfig.routing?.enabled;
+    const routed = routingEnabled && !sessionModel
+      ? await routePrompt(userInput, turnConfig, { hasImages: !!images?.length }).catch(() => null)
+      : null;
+    lastRouteDecision = routed ?? (routingEnabled && !sessionModel ? { note: "routing produced no decision (fail-open)" } : { note: "routing not active this turn" });
+    // Explicit /model always wins: `routed` is only ever computed when `!sessionModel`.
+    const activeModel = routed?.model ?? (sessionModel || defaultModel);
+    const activeThinking = routed?.thinking ?? sessionThinking;
     const contextTokens = catalogMetadata(activeModel)?.contextTokens;
 
     // Resolve provider + dirty count up front — both are cheap and feed the live
@@ -852,7 +865,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // config file. (gjc parity P1.B5: dirty count per-turn, not per-render.)
     const { provider: activeProvider } = await describeModel(activeModel, turnConfig);
     const turnDirtyCount = branch ? gitDirtyCount(cwd) : undefined;
-    const tui = useTui ? new LaunchTui({ model: activeModel, provider: activeProvider, sessionId, maxSteps: initialStepLimit, cwd, branch, dirtyCount: turnDirtyCount, thinking: sessionThinking }) : null;
+    const tui = useTui ? new LaunchTui({ model: activeModel, provider: activeProvider, sessionId, maxSteps: initialStepLimit, cwd, branch, dirtyCount: turnDirtyCount, thinking: activeThinking }) : null;
+    if (routed?.warning) {
+      if (tui) tui.events().onNotice?.(routed.warning);
+      else console.log(routed.warning);
+    }
+    if (routed && (routed.source === "llm" || routed.tier !== "standard")) {
+      const routeNotice = `[route] ${routed.tier} → ${routed.model} (${routed.source}: ${routed.signals.join(", ") || "none"}, confidence ${routed.confidence.toFixed(2)})`;
+      if (tui) tui.events().onNotice?.(routeNotice);
+      else console.log(routeNotice);
+    }
     tui?.setTurnTitle(userInput); // gjc-parity turn title → HUD + tmux pane title (no LLM call)
     // `beforeLen` marks where this turn's appended messages start; it is re-read
     // AFTER compaction (which mutates history) and consumed by the post-turn
@@ -1134,8 +1156,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           tools,
           maxSteps: flags.maxSteps,
           model: activeModel,
-          maxTokens: resolveMaxOutputTokens(activeModel, sessionThinking),
-          reasoningEffort: sessionThinking ? thinkingToReasoningEffort(sessionThinking) : undefined,
+          maxTokens: resolveMaxOutputTokens(activeModel, activeThinking),
+          reasoningEffort: activeThinking ? thinkingToReasoningEffort(activeThinking) : undefined,
           signal: ac.signal,
           sessionKey: sessionId,
           steer: drainSteer,
@@ -1154,8 +1176,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             maxSteps: Math.min(6, flags.maxSteps > 0 ? flags.maxSteps : 6),
             budget: { maxExtensions: 0 },
             model: activeModel,
-            maxTokens: resolveMaxOutputTokens(activeModel, sessionThinking),
-            reasoningEffort: sessionThinking ? thinkingToReasoningEffort(sessionThinking) : undefined,
+            maxTokens: resolveMaxOutputTokens(activeModel, activeThinking),
+            reasoningEffort: activeThinking ? thinkingToReasoningEffort(activeThinking) : undefined,
             signal: ac.signal,
             sessionKey: sessionId,
             steer: drainSteer,
@@ -3964,6 +3986,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         if (modelResult.lastPickIndex !== undefined) lastPickIndex = modelResult.lastPickIndex;
         continue;
       }
+      if (input.startsWith("/route") && (input === "/route" || input[6] === " ")) {
+        const cfgNow = await readGlobalConfig();
+        const routeResult = runRouteSlash(input, {
+          sessionRouteOverride,
+          routingConfigEnabled: !!cfgNow.routing?.enabled,
+          lastRouteDecision,
+        });
+        if (routeResult.sessionRouteOverride !== undefined) sessionRouteOverride = routeResult.sessionRouteOverride;
+        for (const line of routeResult.lines) console.log(line);
+        continue;
+      }
       if (input.startsWith("/view") && (input === "/view" || input[5] === " ")) {
         for (const line of await handleViewSlash(input, cwd)) console.log(line);
         continue;

package/src/tui/components/slash.ts

@@ -43,6 +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 (minimal/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: "/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" },