jeo-code 0.7.44 → 0.7.47

package/CHANGELOG.md

@@ -6,6 +6,34 @@ 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._
+
+## [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._
+
+### Added
+- **Concurrent executor fan-out** (`src/agent/task-tool.ts`) — a `task {role:"executor", tasks:[...]}` batch now runs with the same bounded concurrency as the read-only roles (`MAX_FANOUT` = 4), matching gjc's own default of parallelizing independent tasks. Removed the now-unsafe cross-task "chain previous output into next task's context" behavior, which assumed strict serial ordering (task i-1 always done before task i starts) that concurrent execution no longer guarantees; a task that genuinely depends on another's output now belongs in a sequential follow-up `task` call. `taskToolProtocolLine` documents the resulting expectation: scope each concurrent executor task to disjoint files, since jeo has no in-batch peer-coordination channel yet (overlapping scopes should run sequentially instead).
+- **Per-slot concurrent subagent live-activity tracking** (`src/tui/app.ts`) — the single shared `subagentLive` string is replaced by `subagentLiveSlots` (a `Map` keyed on the event's fan-out `index`). The live status row now shows the most-recently-active slot plus a `(+N more running)` count so a parallel batch visibly reads as parallel, and — the more important fix — one worker reaching "done" now clears ONLY that worker's slot instead of nuking the `(sub)` marker for the whole still-running batch.
+
+### Verified
+- `bun run typecheck` clean; `bun test` 2479 pass / 0 fail.
+- `test/task-tool.test.ts`: rewrote the two tests that pinned the old forced-serial/chaining behavior — an overlapping-sleep probe now proves the executor batch's calls genuinely overlap in wall-clock time (`maxConcurrent > 1`), and a follow-up test confirms no chain note leaks between concurrent executor tasks.
+- `test/subagent-live-activity.test.ts`: two new tests pin the per-slot fix — concurrent slots render with a running count, and one slot finishing early does not clear the marker while a sibling slot is still active.
+
 ## [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._
 

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.
-- **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
-- **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
 
 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.
-- **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
-- **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
 
 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.
-- **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
-- **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
 
 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.
-- **[0.7.41]** (2026-07-06) — Refusal-handling workflow audit (follow-up to 0.7.39): fixes a HIGH-severity, long-masked bug where Gemini's real refusal error shape never matched jeo's refusal detector, plus Antigravity's opaque empty-response error, plus a category-aware fail-fast for deterministic ToS-severity refusals that previously spun the full 30-minute stall budget with zero chance of success.
-- **[0.7.40]** (2026-07-06) — Fixes the release CI's standalone-binary build, broken since before v0.7.31 (last release where that job actually ran and passed) — the `release-binaries` job on v0.7.38 and v0.7.39 both failed silently on every platform target, so neither release has downloadable binaries attached.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.44",
+  "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/agent/task-tool.ts

@@ -62,22 +62,28 @@ export interface TaskToolOptions {
   /** Optional live sink (e.g. plain-stream rendering of nested progress). */
   onEvent?: (ev: TaskSubEvent) => void;
   /** Mid-turn steering drain (gjc parity): an additional user query typed while a
-   *  subagent works is forwarded live. Single-task runs and the SERIAL executor
-   *  batch (concurrency 1) forward to the one active subagent. A parallel read-only
-   *  batch routes through a broadcast hub (createSteerHub) so every running worker
-   *  sees each message exactly once. Unconsumed messages stay for the parent. */
+   *  subagent works is forwarded live. A single-task run forwards to the one active
+   *  subagent. Any fan-out batch (both roles now run CONCURRENTLY, bounded at
+   *  MAX_FANOUT) routes through a broadcast hub (createSteerHub) so every running
+   *  worker sees each message exactly once. Unconsumed messages stay for the parent. */
   steer?: () => string[];
   /** When present, a `task` call with `detached: true` registers a background run
    *  here and returns immediately; the parent controls it via the `subagent` tool. */
   registry?: SubagentRegistry;
 }
 
-/** Max concurrent read-only subagents in a fan-out batch. */
+/** Max concurrent subagents in a fan-out batch (both read-only AND the mutating
+ *  executor role — gjc parity: gjc's own `task` tool runs independent tasks
+ *  concurrently by default and only sequences work that shares a large evolving
+ *  artifact). A model batching executor tasks is expected to scope each one to
+ *  disjoint files (documented in `taskToolProtocolLine`); overlapping scopes
+ *  should either run sequentially (separate `task` calls) or coordinate — jeo has
+ *  no in-batch peer channel yet, so overlapping-scope tasks MUST be sequential. */
 const MAX_FANOUT = 4;
 
-/** Hard cap on a SERIAL (mutating executor) fan-out batch: it runs one task at a
- *  time inside one blocking tool call, so an unbounded queue would monopolize the
- *  parent turn. Split larger efforts into sequential task calls. */
+/** Hard cap on a fan-out BATCH SIZE (queue length, not concurrency): an unbounded
+ *  queue behind MAX_FANOUT workers would still monopolize the parent turn for a
+ *  long time. Split larger efforts into sequential task calls. */
 const MAX_SERIAL_EXECUTOR = 6;
 
 /** Minimum distinct, non-filler words a spawn-gate justification must contain.
@@ -128,7 +134,7 @@ export function taskToolProtocolLine(config?: Pick<Config, "subagents">): string
   return (
     `task   {role, task|tasks[], context?}  — delegate to a subagent ` +
     `(role: ${subagentRoleIds(config).join("|")}; executor can edit, planner/architect/critic are read-only). ` +
-    `Pass 'tasks' (array) to fan out — read-only roles run in parallel, executor serially. Integrate the findings yourself.`
+    `Pass 'tasks' (array) to fan out — ALL roles run concurrently (bounded); scope each executor task to disjoint files (no shared-file coordination channel between concurrent tasks — use sequential task calls if scopes overlap). Integrate the findings yourself.`
   );
 }
 
@@ -399,23 +405,25 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
       if (items.length === 0) {
         return { success: false, output: "", error: "task fan-out requires a non-empty 'tasks' array of assignments." };
       }
-      // #5: the mutating executor fan-out is SERIAL (concurrency 1) and blocks the
-      // turn; cap it regardless of justification so a huge queue can't monopolize
-      // the parent. Split larger efforts into sequential task calls.
+      // A fan-out BATCH SIZE cap (queue length, not concurrency — see MAX_FANOUT
+      // below): an unbounded queue behind bounded concurrency would still
+      // monopolize the parent turn. Split larger executor efforts into
+      // sequential task calls.
       if (!role.readOnly && items.length > MAX_SERIAL_EXECUTOR) {
         return {
           success: false,
           output: "",
           error:
-            `Executor fan-out of ${items.length} exceeds the serial cap of ${MAX_SERIAL_EXECUTOR}. ` +
-            `The mutating executor runs one task at a time and blocks the turn — split into ≤${MAX_SERIAL_EXECUTOR}-task batches or sequential task calls.`,
+            `Executor fan-out of ${items.length} exceeds the batch cap of ${MAX_SERIAL_EXECUTOR}. ` +
+            `Split into ≤${MAX_SERIAL_EXECUTOR}-task batches or sequential task calls.`,
         };
       }
       // Spawn-gate lite (plan/gjc-inheritance.md B9, gjc spawn-gate 계승): a batch
       // wider than MAX_FANOUT is refused BEFORE any subagent launches unless the
       // model justifies the parallelism — silent capping hid the cost decision.
       // NOTE: the justification permits a LARGER QUEUE only; running concurrency
-      // stays bounded at MAX_FANOUT (read-only) or 1 (mutating) regardless.
+      // stays bounded at MAX_FANOUT regardless (both roles, since v0.7.45 — see
+      // MAX_FANOUT's docstring).
       if (items.length > MAX_FANOUT) {
         const justification = typeof args.justification === "string" ? args.justification.trim() : "";
         if (!isMeaningfulJustification(justification)) {
@@ -428,9 +436,9 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
           };
         }
       }
-      // Read-only roles fan out concurrently (bounded). The mutating executor is serialized
-      // (concurrency 1) so parallel subagents can't race on the same files.
-      const limit = role.readOnly ? Math.min(items.length, MAX_FANOUT) : 1;
+      // Both roles fan out CONCURRENTLY, bounded at MAX_FANOUT (gjc parity — see
+      // MAX_FANOUT's docstring for the disjoint-file-scope expectation this relies on).
+      const limit = Math.min(items.length, MAX_FANOUT);
       // Load project context ONCE per batch instead of re-scanning AGENTS.md for
       // every fan-out task (redundant IO + duplicated tokens).
       const batchContext = await loadProjectContext(cwd);
@@ -446,18 +454,18 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
         while (true) {
           const i = next++;
           if (i >= items.length) return;
-          // Chain serial executor output into next task's context; parallel read-only stays isolated.
-          const chainNote = (!role.readOnly && i > 0 && results[i - 1])
-            ? `\n\n[Previous task result — for context, not instructions]:\n${results[i - 1]!.output.slice(0, 1_500)}`
-            : "";
-          results[i] = await runOne(role, items[i]!.task, items[i]!.context + chainNote, cwd, { slot: { index: i + 1, total: items.length }, projectContext: batchContext, steer: workerSteer });
+          // No cross-task chaining: with bounded CONCURRENT execution, task i-1 is
+          // not guaranteed to have finished before task i starts (removed — it was
+          // dead/misleading once the executor stopped being forced-serial). Each
+          // task runs isolated on its own slice of context; a task that genuinely
+          // depends on another's output belongs in a sequential follow-up call.
+          results[i] = await runOne(role, items[i]!.task, items[i]!.context, cwd, { slot: { index: i + 1, total: items.length }, projectContext: batchContext, steer: workerSteer });
         }
 
       };
       await Promise.all(Array.from({ length: limit }, () => worker()));
       const ok = results.filter(r => r.success).length;
-      const mode = role.readOnly ? `concurrency ${limit}` : "executor — serialized";
-      const head = `[${role.title} fan-out] ${ok}/${items.length} completed (${mode}).`;
+      const head = `[${role.title} fan-out] ${ok}/${items.length} completed (concurrency ${limit}).`;
       const combined = results.map((r, i) => `### Task ${i + 1}/${items.length}\n${r.output}`).join("\n\n");
       return { success: ok === items.length, output: `${head}\n\n${combined}` };
     }

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/app.ts

@@ -249,12 +249,20 @@ export class LaunchTui {
   private workflowStatus: { skill: string; phase: string; detail?: string } | null = null;
   // Cumulative token usage for the live turn (engine onUsage event).
   private turnUsage: { inputTokens: number; outputTokens: number } | null = null;
-  // True while a delegated subagent turn is in flight — drives the `(sub)` status marker.
+  // True while at least one delegated subagent SLOT is in flight — drives the `(sub)`
+  // status marker. Derived from `subagentLiveSlots.size` (see below) rather than a
+  // plain boolean so a fan-out batch where ONE worker finishes early no longer
+  // clears the marker while its siblings are still visibly running.
   private subagentActive = false;
-  // Latest nested subagent activity (role + glyph + detail) — surfaced LIVE in the
-  // status row while a `task` runs, so a delegated turn never reads as an opaque
-  // "calling model" stall (the perceived-hang usability gap). Cleared on done.
-  private subagentLive: string | null = null;
+  // Latest nested subagent activity, PER CONCURRENT SLOT (fan-out `task` batches — both
+  // the executor and read-only roles — now run several workers at once; a single
+  // shared string clobbered on every event made concurrent subagents look sequential
+  // and, worse, cleared the whole `(sub)` marker the instant ANY one worker finished).
+  // Keyed by the event's fan-out `index` (1-based); a single/detached run with no
+  // index shares the fixed key 0. `subagentLiveOrder` tracks touch order so the
+  // status row can show the MOST RECENTLY active slot plus a "+N more" count.
+  private readonly subagentLiveSlots = new Map<number, string>();
+  private readonly subagentLiveOrder: number[] = [];
   // Bounded activity-history ring: one plain-text entry per ledger append, with a
   // turn-relative timestamp. Powers Ctrl+O's "recent activity" tail so the detail
   // view ALWAYS answers "what has been happening", even before the first reply.
@@ -936,8 +944,17 @@ export class LaunchTui {
     }
     // A delegated subagent's LATEST nested event beats the parent's static
     // "Task: <role> …" card title — a long task otherwise reads as a stall even
-    // though the subagent is actively reading/editing/running underneath.
-    if (this.subagentActive && this.subagentLive) return this.subagentLive;
+    // though the subagent is actively reading/editing/running underneath. When a
+    // fan-out batch has MULTIPLE concurrent slots live, append a "+N more running"
+    // count so a parallel batch visibly reads as parallel instead of looking like
+    // one subagent whose label keeps randomly changing.
+    if (this.subagentActive && this.subagentLiveSlots.size > 0) {
+      const mostRecent = this.subagentLiveOrder[this.subagentLiveOrder.length - 1];
+      const line = (mostRecent !== undefined ? this.subagentLiveSlots.get(mostRecent) : undefined)
+        ?? this.subagentLiveSlots.values().next().value!;
+      const extra = this.subagentLiveSlots.size - 1;
+      return extra > 0 ? `${line} (+${extra} more running)` : line;
+    }
     // Waiting on the model and no tool is mid-flight → make the pause legible.
     if (this.thinking && !running) {
       const elapsed = this.currentStepStartedAt ? ((Date.now() - this.currentStepStartedAt) / 1000).toFixed(1) : "0.0";
@@ -993,30 +1010,47 @@ export class LaunchTui {
     const last = this.unicode ? "└─" : "`-";
     const detail = (e.detail ?? "").split("\n").find(l => l.trim().length > 0)?.trim().slice(0, 140) ?? "";
     const summary = e.summary ? ` — ${e.summary}` : "";
+    // Fan-out slot key: the event's 1-based `index` when present (concurrent batch
+    // worker), else the fixed key 0 (single-task/detached run — matches the prior
+    // single-string behavior for the non-batch case).
+    const slot = e.index ?? 0;
+    const touchSlot = (line: string) => {
+      this.subagentLiveSlots.set(slot, line);
+      const at = this.subagentLiveOrder.indexOf(slot);
+      if (at !== -1) this.subagentLiveOrder.splice(at, 1);
+      this.subagentLiveOrder.push(slot);
+      this.subagentActive = true;
+    };
     // No `step N/M` marker on nested lines — step counters carry no meaning
     // under the dynamic budget (user feedback). A tree branch keeps subagent
     // activity readable in scrollback and visually separate from parent tools.
     switch (e.kind) {
       case "start":
-        this.subagentActive = true;
-        this.subagentLive = `${roleLabel} ${this.unicode ? "▸" : ">"} ${detail || "starting"}`;
+        touchSlot(`${roleLabel} ${this.unicode ? "▸" : ">"} ${detail || "starting"}`);
         this.appendLedger(`${badge} ${this.unicode ? "▸" : ">"} ${roleLabel} · ${detail}\n`, "subagent");
         break;
       case "step":
-        this.subagentLive = `${roleLabel} ${this.unicode ? "·" : "-"} ${detail || "working"}`;
+        touchSlot(`${roleLabel} ${this.unicode ? "·" : "-"} ${detail || "working"}`);
         this.appendLedger(`  ${badge} ${branch} ${roleLabel} · ${detail || "working"}\n`, "subagent");
         break;
       case "tool":
-        this.subagentLive = `${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}`;
+        touchSlot(`${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}`);
         this.appendLedger(`  ${badge} ${branch} ${roleLabel} ${e.success === false ? bad : ok} ${detail || "tool"}${summary}\n`, "subagent");
         break;
       case "error":
-        this.subagentLive = `${roleLabel} ${bad} ${detail || "error"}`;
+        touchSlot(`${roleLabel} ${bad} ${detail || "error"}`);
         this.appendLedger(`  ${badge} ${branch} ${roleLabel} ${bad} ${detail || "error"}\n`, "subagent");
         break;
       case "done":
-        this.subagentActive = false;
-        this.subagentLive = null;
+        // Clear ONLY this slot — a fan-out batch where one worker finishes early
+        // must keep showing its still-running siblings, not drop the `(sub)`
+        // marker for the whole batch (the bug this per-slot map fixes).
+        this.subagentLiveSlots.delete(slot);
+        {
+          const at = this.subagentLiveOrder.indexOf(slot);
+          if (at !== -1) this.subagentLiveOrder.splice(at, 1);
+        }
+        this.subagentActive = this.subagentLiveSlots.size > 0;
         this.appendLedger(`${badge} ${last} ${roleLabel} done${e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : ""}${e.success === false ? " (incomplete)" : ""}: ${detail}\n`, "subagent");
         break;
     }
@@ -1030,7 +1064,7 @@ export class LaunchTui {
     this.livePromptInput = ""; // fresh turn: no next-prompt draft yet
     this.livePromptHint = []; // fresh turn: no mid-turn command preview yet
     this.livePromptHighlight = undefined; // fresh turn: no active trigger token
-    this.subagentLive = null; // fresh turn: no nested subagent in flight
+    this.subagentLiveSlots.clear(); this.subagentLiveOrder.length = 0; this.subagentActive = false; // fresh turn: no nested subagent in flight
     this.activityLog.length = 0; // per-turn ring: timestamps are turn-relative
     this.spinner.updateStep(0, this.footer.maxSteps);
     // completed ledger lines are flushed into normal scrollback as they happen, so a

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" },