jeo-code 0.7.46 → 0.7.48

package/CHANGELOG.md

@@ -6,6 +6,32 @@ 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.48] - 2026-07-06
+_gjc Telegram-daemon parity, phase 2 (follow-up to 0.7.37/0.7.38's baseline subagent-visibility daemon, which deliberately scoped OUT forum topics, inline keyboards, and image attachments — see that entry): the daemon now speaks gjc's richer notification surface instead of the plain-text-only baseline._
+
+### Added
+- **Forum-topic routing** (`topicId` in `notifications.telegram` config, `config-schema.ts`/`state.ts`) — every daemon push carries the configured `message_thread_id` so a supergroup with Topics enabled routes jeo's notifications into one dedicated topic instead of the general channel; inbound `/subagents`/`/steer`/`/cancel`/`/help` commands are topic-filtered to match.
+- **Inline-keyboard Cancel buttons + callback taps** (`src/agent/notify/telegram-api.ts`: `answerCallbackQuery`, `replyMarkup` on `sendMessage`/`sendPhoto`; `src/agent/notify/telegram-daemon.ts`) — a subagent's `started` push and `/subagents` listing now attach a per-subagent inline ⏹ Cancel button; tapping it round-trips through the same cancel path as the existing `/cancel <sessionId> <subagentId>` text command, then acknowledges the tap via `answerCallbackQuery` so Telegram clears its loading spinner. `TelegramUpdate` extended with `callback_query`/`message_thread_id`.
+- **Image attachments** (`TelegramApi.sendPhoto`, `TelegramDaemon#notifyPhoto`) — a session `{type:"photo"}` frame is now relayed to Telegram via `sendPhoto` (caption + topic + inline-keyboard `replyMarkup` all supported), closing the last gap from 0.7.37's "no image attachments" scope note.
+
+### Verified
+- `bun run typecheck` clean; `bun test` 2498 pass / 0 fail.
+- `test/notify-telegram-api.test.ts` (+56 lines): `sendPhoto`/`answerCallbackQuery` request shape, `messageThreadId`/`replyMarkup` forwarding.
+- `test/notify-telegram-daemon.test.ts` (+184 lines across two commits): topic-scoped push/inbound-filter round-trip, inline Cancel button attached to a `started` push and to `/subagents` output, a `callback_query` tap correctly cancels the matching subagent and acknowledges, and a session photo frame relayed via `sendPhoto` with caption + topic + `replyMarkup`.
+
+## [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.48]** (2026-07-06) — gjc Telegram-daemon parity, phase 2 (follow-up to 0.7.37/0.7.38's baseline subagent-visibility daemon, which deliberately scoped OUT forum topics, inline keyboards, and image attachments — see that entry): the daemon now speaks gjc's richer notification surface instead of the plain-text-only baseline.
+- **[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

@@ -46,7 +46,8 @@
 - **동적 스텝 버짓** — 최근 도구 호출이 새로운 진전을 보이는 동안 연장되고, 정체되면 정리 요약으로 수렴. 서브에이전트는 정확한 스텝 계약 유지.
 - **인라인 TUI** — 완료된 작업은 실제 스크롤백으로 흘러가고(턴 중에도 tmux 휠 스크롤 가능), 에이전트가 실행 중이어도 기존 쿼리 입력창이 그대로 보이며 편집됩니다. Ctrl+O 상세 토글, 테마, 클립보드 이미지 붙여넣기(Ctrl+V), CJK/이모지 안전 폭 계산.
 - **브라우저 도구** — Playwright 기반 헤드리스 Chromium 자동화가 1급 에이전트 도구로 포함: 이름 붙은 탭을 재사용하며 `open`/`close`/`run`/`act`, 스크린샷보다 `observe`로 태깅된 요소 id를 우선 사용. `npx playwright install chromium`을 한 번 실행해야 함(번들 아님 — jeo 자체는 여전히 네이티브 의존성 0, 브라우저 바이너리는 Playwright의 별도 다운로드).
-- **원격 서브에이전트 가시성(Telegram)** — 봇을 한 번 페어링(`jeo notify setup`)하면, `jeo daemon start`가 서브에이전트 상태 전환(시작 → 완료/실패/취소)마다 메시지를 보내고 `/subagents`, `/steer <id> <subagentId> <msg>`, `/cancel <id> <subagentId>`를 되받습니다 — 명령은 페어링된 채팅에서만 허용됩니다.
+- **원격 서브에이전트 가시성(Telegram)** — 봇을 한 번 페어링(`jeo notify setup`)하면, `jeo daemon start`가 서브에이전트 상태 전환(시작 → 완료/실패/취소)마다 메시지를 보내고 `/subagents`, `/steer <id> <subagentId> <msg>`, `/cancel <id> <subagentId>`를 되받습니다. 이제 Telegram 포럼 토픽, 인라인 키보드, 이미지 첨부 파일 지원 등 `gjc`와의 완전한 패리티를 제공하며, 명령은 페어링된 채팅에서만 허용됩니다.
+
 
 ## 설치
 
@@ -182,7 +183,7 @@ jeo daemon stop         # SIGTERM으로 종료
 └─────────────────────┘        └─────────────────────┘         └─────────────────────┘
 ```
 
-옵트인이며 지연 바인딩됩니다: `notifications.enabled`가 설정되고 detached 서브에이전트(`task {detached:true}`)가 실제로 실행되어야만 동작합니다. 데몬은 살아있는 세션 디스커버리 파일을 스캔해 세션별로 루프백 WebSocket을 연결하고, 서브에이전트 상태 *전환* 시점(시작 → 완료/실패/취소)에만 메시지를 보냅니다 — "여전히 실행 중" 같은 반복 알림은 없습니다. 수신되는 Telegram 명령은 페어링된 채팅에서만 허용되며, 그 외는 조용히 무시됩니다.
+옵트인이며 지연 바인딩됩니다: `notifications.enabled`가 설정되고 detached 서브에이전트(`task {detached:true}`)가 실제로 실행되어야만 동작합니다. 데몬은 살아있는 세션 디스커버리 파일을 스캔해 세션별로 루프백 WebSocket을 연결하고, 서브에이전트 상태 *전환* 시점(시작 → 완료/실패/취소)에만 메시지를 보냅니다 — "여전히 실행 중" 같은 반복 알림은 없습니다. 이제 Telegram 포럼 토픽, 인라인 키보드, 이미지 첨부 파일 지원 등 `gjc`와의 완전한 패리티를 제공합니다. 수신되는 Telegram 명령은 페어링된 채팅에서만 허용되며, 그 외는 조용히 무시됩니다.
 
 | 명령 | 동작 |
 | --- | --- |
@@ -259,11 +260,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.48]** (2026-07-06) — gjc Telegram-daemon parity, phase 2 (follow-up to 0.7.37/0.7.38's baseline subagent-visibility daemon, which deliberately scoped OUT forum topics, inline keyboards, and image attachments — see that entry): the daemon now speaks gjc's richer notification surface instead of the plain-text-only baseline.
+- **[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

@@ -46,7 +46,8 @@ Run `jeo` inside a repository and it reads files, edits them, runs commands, and
 - **Dynamic step budget** — turns extend while the tool window shows novel progress and consolidate gracefully when stalled; subagents keep exact step contracts.
 - **Inline TUI** — completed work flushes into real scrollback (tmux wheel works mid-turn), the normal query input box stays visible and editable while the agent runs, Ctrl+O toggles full detail, themes, clipboard image paste (Ctrl+V), CJK/emoji-safe width math.
 - **Browser tool** — headless Chromium automation (Playwright) as a first-class agent tool: `open`/`close`/`run`/`act` on named, reused tabs, with `observe`-tagged element ids preferred over screenshots for driving pages. Requires `npx playwright install chromium` once (not bundled — jeo stays zero native deps itself, the browser binary is Playwright's separate download).
-- **Remote subagent visibility (Telegram)** — pair a bot once (`jeo notify setup`), then `jeo daemon start` pushes a message on every subagent state edge (started → done/failed/cancelled) and accepts `/subagents`, `/steer <id> <subagentId> <msg>`, `/cancel <id> <subagentId>` back — commands are authorized to the paired chat only.
+- **Remote subagent visibility (Telegram)** — pair a bot once (`jeo notify setup`), then `jeo daemon start` pushes a message on every subagent state edge (started → done/failed/cancelled) and accepts `/subagents`, `/steer <id> <subagentId> <msg>`, `/cancel <id> <subagentId>` back. Telegram Daemon now supports full `gjc` parity, including forum topics, inline keyboards, and image attachments — commands are authorized to the paired chat only.
+
 
 ## Install
 
@@ -183,7 +184,7 @@ jeo daemon stop         # SIGTERM it
 └─────────────────────┘        └─────────────────────┘         └─────────────────────┘
 ```
 
-Opt-in and lazy: nothing binds until `notifications.enabled` is set AND a detached subagent (`task {detached:true}`) actually runs. The daemon scans live session discovery files, connects a loopback WebSocket per session, and pushes a message only on a subagent state *edge* (started → completed/failed/cancelled) — never a repeated "still running" ping. Inbound Telegram commands are authorized to the paired chat only; anything else is dropped silently.
+Opt-in and lazy: nothing binds until `notifications.enabled` is set AND a detached subagent (`task {detached:true}`) actually runs. The daemon scans live session discovery files, connects a loopback WebSocket per session, and pushes a message only on a subagent state *edge* (started → completed/failed/cancelled) — never a repeated "still running" ping. Telegram Daemon now supports full `gjc` parity, including forum topics, inline keyboards, and image attachments. Inbound Telegram commands are authorized to the paired chat only; anything else is dropped silently.
 
 | Command | Effect |
 | --- | --- |
@@ -261,11 +262,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.48]** (2026-07-06) — gjc Telegram-daemon parity, phase 2 (follow-up to 0.7.37/0.7.38's baseline subagent-visibility daemon, which deliberately scoped OUT forum topics, inline keyboards, and image attachments — see that entry): the daemon now speaks gjc's richer notification surface instead of the plain-text-only baseline.
+- **[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.48]** (2026-07-06) — gjc Telegram-daemon parity, phase 2 (follow-up to 0.7.37/0.7.38's baseline subagent-visibility daemon, which deliberately scoped OUT forum topics, inline keyboards, and image attachments — see that entry): the daemon now speaks gjc's richer notification surface instead of the plain-text-only baseline.
+- **[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.48",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/config-schema.ts

@@ -96,6 +96,9 @@ export const ConfigSchema = z
           .object({
             botToken: z.string().optional(),
             chatId: z.string().optional(),
+            /** Forum-topic thread id (message_thread_id) for supergroups with
+             *  topics enabled — daemon pushes go into this topic. */
+            topicId: z.number().optional(),
           })
           .optional(),
       })
@@ -161,6 +164,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/notify/AGENTS.md

@@ -4,16 +4,16 @@
 # notify
 
 ## Purpose
-Remote subagent visibility/control over Telegram (gjc Telegram-daemon parity, deliberately scoped to jeo's subagent surface only — no forum topics, inline keyboards, or image attachments; see root `CHANGELOG.md` 0.7.34 for what jeo intentionally does not replicate from gjc's full notification stack).
+Remote subagent visibility/control over Telegram (gjc Telegram-daemon parity, scoped to jeo's subagent surface). Supports gjc's richer notification surface: forum topics (`message_thread_id`), inline keyboards (per-subagent ⏹ Cancel buttons + `callback_query` handling), and image attachments (`sendPhoto`, relayed from a session `{type:"photo"}` frame).
 
 ## Key Files
 | File | Description |
 |------|-------------|
 | `paths.ts` | Path helpers under `<jeoHome>/notifications` (daemon lock/log, per-session discovery files) |
-| `telegram-api.ts` | Minimal, injectable-`fetch` Telegram Bot API client (`getMe`/`sendMessage`/`getUpdates`) + `maskToken` |
+| `telegram-api.ts` | Minimal, injectable-`fetch` Telegram Bot API client (`getMe`/`sendMessage`/`sendPhoto`/`answerCallbackQuery`/`getUpdates`) + `maskToken`; `sendMessage`/`sendPhoto` accept `messageThreadId` (forum topics) and `replyMarkup` (inline keyboards) |
 | `session-endpoint.ts` | Per-turn, loopback-only WebSocket server exposing ONE `SubagentRegistry` (discovery file + `snapshot`/`steer`/`cancel`/`list` protocol); lazy `ensureSessionNotifyEndpoint`/`stopSessionNotifyEndpoint` wiring, no-op unless `notifications.enabled` |
 | `daemon-control.ts` | Daemon lifecycle: pid+startedAt lock singleton, `daemonInvocation` self-spawn argv (mirrors `memory.ts`'s `distillInvocation`), `startDaemon`/`stopDaemon`/`reloadDaemon`/`daemonStatus` |
-| `telegram-daemon.ts` | The managed daemon (`TelegramDaemon` class + `runNotifyDaemonForeground` CLI entrypoint): scans session discovery files, connects a WS per session, pushes Telegram messages on subagent status EDGES only, and dispatches inbound `/subagents`/`/steer`/`/cancel`/`/help` commands back over the matching session's WebSocket |
+| `telegram-daemon.ts` | The managed daemon (`TelegramDaemon` class + `runNotifyDaemonForeground` CLI entrypoint): scans session discovery files, connects a WS per session, pushes Telegram messages on subagent status EDGES only (with an inline ⏹ Cancel button), and dispatches inbound `/subagents`/`/steer`/`/cancel`/`/help` commands AND inline-button `callback_query` taps back over the matching session's WebSocket. All pushes carry the configured forum `topicId`, and inbound is topic-filtered; a session `{type:"photo"}` frame is relayed via `sendPhoto` |
 
 ## Subdirectories
 *(None)*

package/src/agent/notify/telegram-api.ts

@@ -1,8 +1,9 @@
 /**
  * Minimal Telegram Bot HTTP API client (gjc `telegram-reference.ts`/`telegram-cli.ts`
- * parity, scoped to the three calls the jeo daemon actually needs: identity
- * verification, outbound push, and inbound long-poll). Deliberately thin — no forum
- * topics, no inline keyboards, no rate-limit pool; jeo's daemon sends plain text.
+ * parity). Scoped to the calls the jeo daemon needs — identity verification,
+ * outbound push, inbound long-poll — plus gjc's richer surface: forum topics
+ * (`message_thread_id`), inline keyboards (`reply_markup` + `answerCallbackQuery`),
+ * and image attachments (`sendPhoto`, photo given as a URL or `file_id`).
  */
 
 export interface TelegramChat {
@@ -12,6 +13,31 @@ export interface TelegramChat {
   username?: string;
 }
 
+/** Inline keyboard primitives (gjc parity). `callback_data` is capped by Telegram
+ *  at 64 bytes; the daemon keeps its payloads short (`cancel:<shortId>:<id>`). */
+export interface InlineKeyboardButton {
+  text: string;
+  callback_data?: string;
+  url?: string;
+}
+
+export interface InlineKeyboardMarkup {
+  inline_keyboard: InlineKeyboardButton[][];
+}
+
+/** Button-press callback delivered via `getUpdates` when a user taps an inline
+ *  keyboard button. `message` carries the originating chat/topic. */
+export interface TelegramCallbackQuery {
+  id: string;
+  from: { id: number; username?: string; is_bot: boolean };
+  message?: {
+    message_id: number;
+    chat: TelegramChat;
+    message_thread_id?: number;
+  };
+  data?: string;
+}
+
 export interface TelegramUpdate {
   update_id: number;
   message?: {
@@ -20,7 +46,11 @@ export interface TelegramUpdate {
     chat: TelegramChat;
     text?: string;
     from?: { id: number; username?: string; is_bot: boolean };
+    /** Forum-topic thread this message belongs to (supergroups with topics on). */
+    message_thread_id?: number;
+    is_topic_message?: boolean;
   };
+  callback_query?: TelegramCallbackQuery;
 }
 
 export interface TelegramGetMeResult {
@@ -40,6 +70,24 @@ export interface TelegramGetUpdatesResult {
   description?: string;
 }
 
+/** Shared outbound options: target a forum topic and/or attach an inline keyboard. */
+export interface SendMessageOptions {
+  messageThreadId?: number;
+  replyMarkup?: InlineKeyboardMarkup;
+  disableWebPagePreview?: boolean;
+}
+
+export interface SendPhotoOptions {
+  caption?: string;
+  messageThreadId?: number;
+  replyMarkup?: InlineKeyboardMarkup;
+}
+
+export interface AnswerCallbackQueryOptions {
+  text?: string;
+  showAlert?: boolean;
+}
+
 export type FetchLike = typeof fetch;
 
 export class TelegramApi {
@@ -52,18 +100,59 @@ export class TelegramApi {
     return `https://api.telegram.org/bot${this.token}/${method}`;
   }
 
+  private async postJson<T>(method: string, body: Record<string, unknown>): Promise<T> {
+    const res = await this.fetchImpl(this.url(method), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    return (await res.json()) as T;
+  }
+
   async getMe(): Promise<TelegramGetMeResult> {
     const res = await this.fetchImpl(this.url("getMe"));
     return (await res.json()) as TelegramGetMeResult;
   }
 
-  async sendMessage(chatId: string | number, text: string): Promise<TelegramSendResult> {
-    const res = await this.fetchImpl(this.url("sendMessage"), {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ chat_id: chatId, text, disable_web_page_preview: true }),
-    });
-    return (await res.json()) as TelegramSendResult;
+  async sendMessage(
+    chatId: string | number,
+    text: string,
+    options: SendMessageOptions = {},
+  ): Promise<TelegramSendResult> {
+    const body: Record<string, unknown> = {
+      chat_id: chatId,
+      text,
+      disable_web_page_preview: options.disableWebPagePreview ?? true,
+    };
+    if (options.messageThreadId !== undefined) body.message_thread_id = options.messageThreadId;
+    if (options.replyMarkup) body.reply_markup = options.replyMarkup;
+    return this.postJson<TelegramSendResult>("sendMessage", body);
+  }
+
+  /** Send a photo. `photo` is a public URL or a Telegram `file_id` (no local
+   *  multipart upload — jeo pushes URLs/ids, matching gjc's URL-attachment path). */
+  async sendPhoto(
+    chatId: string | number,
+    photo: string,
+    options: SendPhotoOptions = {},
+  ): Promise<TelegramSendResult> {
+    const body: Record<string, unknown> = { chat_id: chatId, photo };
+    if (options.caption !== undefined) body.caption = options.caption;
+    if (options.messageThreadId !== undefined) body.message_thread_id = options.messageThreadId;
+    if (options.replyMarkup) body.reply_markup = options.replyMarkup;
+    return this.postJson<TelegramSendResult>("sendPhoto", body);
+  }
+
+  /** Acknowledge an inline-button tap (clears the client's loading spinner and
+   *  optionally shows a toast/alert). Telegram requires this within ~15s. */
+  async answerCallbackQuery(
+    callbackQueryId: string,
+    options: AnswerCallbackQueryOptions = {},
+  ): Promise<TelegramSendResult> {
+    const body: Record<string, unknown> = { callback_query_id: callbackQueryId };
+    if (options.text !== undefined) body.text = options.text;
+    if (options.showAlert !== undefined) body.show_alert = options.showAlert;
+    return this.postJson<TelegramSendResult>("answerCallbackQuery", body);
   }
 
   /** Long-poll for new updates. `offset` should be `last_update_id + 1`. */

package/src/agent/notify/telegram-daemon.ts

@@ -1,9 +1,5 @@
 /**
- * The managed Telegram daemon (gjc `notifications/telegram-daemon.ts` parity,
- * scoped down to jeo's subagent-remote-control surface — no forum topics, no
- * inline keyboards, no image attachments; see CHANGELOG 0.7.34 for what jeo
- * intentionally does not replicate from gjc's full notification stack).
- *
+ * The managed Telegram daemon (gjc `notifications/telegram-daemon.ts` parity).
  * Runs as ONE long-lived background process (singleton, enforced by
  * `daemon-control.ts`'s lock file — Telegram allows only one `getUpdates`
  * long-poll owner per bot token). It:
@@ -12,19 +8,28 @@
  *     discovery files and connects a loopback WebSocket to each
  *     (`SessionNotifyEndpoint` on the other end);
  *   - sends a Telegram message on each subagent state EDGE (started → a
- *     terminal state), not on every poll tick;
+ *     terminal state), not on every poll tick, attaching an inline "Cancel"
+ *     keyboard button for the running subagent;
  *   - long-polls Telegram `getUpdates` and dispatches `/subagents`,
  *     `/steer <sessionId> <subagentId> <message>`, `/cancel <sessionId>
- *     <subagentId>`, `/help` back into the matching session's WebSocket.
+ *     <subagentId>`, `/help` — plus inline-keyboard button taps
+ *     (`callback_query`) — back into the matching session's WebSocket.
+ *
+ * gjc-parity surface added on top of the plain-text core: forum topics (all
+ * pushes carry the configured `message_thread_id`, inbound is topic-filtered),
+ * inline keyboards (cancel buttons + `callback_query` handling), and image
+ * attachments (a session may push a `{type:"photo"}` frame relayed via
+ * `sendPhoto`).
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { readGlobalConfig } from "../state";
 import { notifySessionsDir } from "./paths";
 import { acquireDaemonLock, isPidAlive } from "./daemon-control";
-import { TelegramApi, type TelegramUpdate } from "./telegram-api";
+import { TelegramApi, type TelegramUpdate, type TelegramCallbackQuery, type InlineKeyboardMarkup, type InlineKeyboardButton } from "./telegram-api";
 import type { SubagentRecord } from "../subagent-registry";
 
+
 function sleep(ms: number): Promise<void> {
   const { promise, resolve } = Promise.withResolvers<void>();
   setTimeout(resolve, ms);
@@ -109,7 +114,47 @@ export const HELP_TEXT =
   "/subagents — list running/recent subagents across every connected session\n" +
   "/steer <sessionId> <subagentId> <message> — send a live message into a running subagent\n" +
   "/cancel <sessionId> <subagentId> — cancel a running subagent\n" +
-  "/help — show this message";
+  "/cancel <sessionId> <subagentId> — cancel a running subagent\n" +
+  "/help — show this message\n" +
+  "(running subagents also carry an inline ⏹ Cancel button — tap it instead of typing /cancel)";
+
+// ── Inline keyboards / callback data (gjc parity) ───────────────────────────────
+
+/** Encode an inline-button cancel target. Kept short to stay under Telegram's
+ *  64-byte `callback_data` cap. */
+export function cancelCallbackData(shortId: string, subagentId: string): string {
+  return `cancel:${shortId}:${subagentId}`;
+}
+
+/** Parse a `callback_data` payload produced by `cancelCallbackData`. */
+export function parseCallbackData(
+  data: string,
+): { action: "cancel"; shortId: string; subagentId: string } | undefined {
+  const m = /^cancel:([^:]+):([\s\S]+)$/.exec(data);
+  if (!m) return undefined;
+  return { action: "cancel", shortId: m[1]!, subagentId: m[2]! };
+}
+
+/** One ⏹ Cancel button (its own row) targeting a single running subagent. */
+function cancelButton(shortId: string, rec: SubagentRecord): InlineKeyboardButton {
+  return { text: `⏹ Cancel ${rec.role} '${rec.id}'`, callback_data: cancelCallbackData(shortId, rec.id) };
+}
+
+/** Inline keyboard with one ⏹ Cancel button per RUNNING subagent across every
+ *  connected session; returns undefined when nothing is running (no keyboard to
+ *  attach). */
+export function buildSubagentsKeyboard(
+  sessions: Array<{ sessionId: string; records: SubagentRecord[] }>,
+): InlineKeyboardMarkup | undefined {
+  const rows: InlineKeyboardButton[][] = [];
+  for (const s of sessions) {
+    for (const r of s.records) {
+      if (r.status === "running") rows.push([cancelButton(shortSessionId(s.sessionId), r)]);
+    }
+  }
+  return rows.length ? { inline_keyboard: rows } : undefined;
+}
+
 
 // ── Stateful daemon (network/ws — DI'd for tests) ───────────────────────────────
 
@@ -131,6 +176,9 @@ export interface TelegramDaemonOptions {
   isPidAlive?: (pid: number) => boolean;
   scanIntervalMs?: number;
   ackTimeoutMs?: number;
+  /** Forum-topic thread id (message_thread_id). When set, every push is sent
+   *  into this topic and inbound messages/taps from other topics are ignored. */
+  topicId?: number;
 }
 
 export class TelegramDaemon {
@@ -145,14 +193,37 @@ export class TelegramDaemon {
     this.WS = opts.WebSocketImpl ?? WebSocket;
   }
 
-  private async notify(text: string): Promise<void> {
+  private async notify(text: string, replyMarkup?: InlineKeyboardMarkup): Promise<void> {
     try {
-      await this.opts.telegram.sendMessage(this.opts.chatId, text);
+      await this.opts.telegram.sendMessage(this.opts.chatId, text, {
+        messageThreadId: this.opts.topicId,
+        replyMarkup,
+      });
     } catch {
       // best-effort — a failed push must never crash the daemon loop.
     }
   }
 
+  private async notifyPhoto(photo: string, caption?: string, replyMarkup?: InlineKeyboardMarkup): Promise<void> {
+    try {
+      await this.opts.telegram.sendPhoto(this.opts.chatId, photo, {
+        messageThreadId: this.opts.topicId,
+        caption,
+        replyMarkup,
+      });
+    } catch {
+      // best-effort — a failed photo push must never crash the daemon loop.
+    }
+  }
+
+  private async answerCallback(id: string, text?: string): Promise<void> {
+    try {
+      await this.opts.telegram.answerCallbackQuery(id, text !== undefined ? { text } : {});
+    } catch {
+      // best-effort — acknowledging the tap is nice-to-have, not load-bearing.
+    }
+  }
+
   async scanSessions(): Promise<void> {
     const readdir = this.opts.readdir ?? (d => fs.readdir(d));
     let files: string[];
@@ -205,11 +276,28 @@ export class TelegramDaemon {
       const next = msg.subagents as SubagentRecord[];
       const events = diffSubagentTransitions(conn.lastRecords, next);
       conn.lastRecords = next;
+      const shortId = shortSessionId(conn.sessionId);
       for (const ev of events) {
-        await this.notify(formatNotifyEvent(shortSessionId(conn.sessionId), conn.cwd, ev));
+        const keyboard =
+          ev.kind === "started" ? { inline_keyboard: [[cancelButton(shortId, ev.record)]] } : undefined;
+        await this.notify(formatNotifyEvent(shortId, conn.cwd, ev), keyboard);
       }
       return;
     }
+    if (msg.type === "photo" && typeof msg.url === "string") {
+      const replyMarkup =
+        msg.replyMarkup &&
+        typeof msg.replyMarkup === "object" &&
+        "inline_keyboard" in (msg.replyMarkup as object)
+          ? (msg.replyMarkup as InlineKeyboardMarkup)
+          : undefined;
+      await this.notifyPhoto(
+        msg.url,
+        typeof msg.caption === "string" ? msg.caption : undefined,
+        replyMarkup,
+      );
+      return;
+    }
     if (msg.type === "ack" && typeof msg.reqId === "string") {
       const resolve = this.pendingAcks.get(msg.reqId);
       if (resolve) {
@@ -250,7 +338,7 @@ export class TelegramDaemon {
     const trimmed = text.trim();
     if (trimmed === "/subagents") {
       const sessions = [...this.sessions.values()].map(c => ({ sessionId: c.sessionId, cwd: c.cwd, records: c.lastRecords }));
-      await this.notify(formatSubagentsList(sessions));
+      await this.notify(formatSubagentsList(sessions), buildSubagentsKeyboard(sessions));
       return;
     }
     if (trimmed === "/help" || trimmed === "/start") {
@@ -285,14 +373,61 @@ export class TelegramDaemon {
   /** Trust boundary: a bot's username is publicly discoverable, so ANY Telegram
    *  user can message it. Only the paired chat (the one that ran
    *  `jeo notify setup`) may steer/cancel subagents; everything else is dropped
-   *  without a reply (replying would leak that the bot is live). */
+   *  without a reply (replying would leak that the bot is live). When a forum
+   *  topic is configured, messages/taps from other topics are also ignored. */
   async handleUpdate(update: TelegramUpdate): Promise<void> {
+    if (update.callback_query) {
+      await this.handleCallbackQuery(update.callback_query);
+      return;
+    }
     const msg = update.message;
     if (!msg?.text) return;
     if (String(msg.chat.id) !== this.opts.chatId) return;
+    if (
+      this.opts.topicId !== undefined &&
+      msg.message_thread_id !== undefined &&
+      msg.message_thread_id !== this.opts.topicId
+    ) {
+      return;
+    }
     await this.handleInboundText(msg.text);
   }
 
+  /** Handle an inline-button tap. Same chat/topic trust boundary as text, and the
+   *  tap is always acknowledged (Telegram shows a spinner until `answerCallbackQuery`). */
+  async handleCallbackQuery(cb: TelegramCallbackQuery): Promise<void> {
+    const chatId = cb.message?.chat.id;
+    if (chatId !== undefined && String(chatId) !== this.opts.chatId) {
+      await this.answerCallback(cb.id);
+      return;
+    }
+    if (
+      this.opts.topicId !== undefined &&
+      cb.message?.message_thread_id !== undefined &&
+      cb.message.message_thread_id !== this.opts.topicId
+    ) {
+      await this.answerCallback(cb.id);
+      return;
+    }
+    const parsed = cb.data ? parseCallbackData(cb.data) : undefined;
+    if (!parsed) {
+      await this.answerCallback(cb.id);
+      return;
+    }
+    const conn = this.findSession(parsed.shortId);
+    if (!conn) {
+      await this.answerCallback(cb.id, `No connected session matches '${parsed.shortId}'.`);
+      return;
+    }
+    const ok = await this.sendRequest(conn, { type: "cancel", ids: [parsed.subagentId] });
+    await this.answerCallback(cb.id, ok ? `Cancelled '${parsed.subagentId}'.` : "Cancel failed.");
+    await this.notify(
+      ok
+        ? `⏹ Cancelled '${parsed.subagentId}' via button.`
+        : `Cancel failed — '${parsed.subagentId}' is unknown or already finished.`,
+    );
+  }
+
   private async pollTelegramLoop(): Promise<void> {
     while (!this.stopped) {
       let res;
@@ -346,11 +481,12 @@ export async function runNotifyDaemonForeground(): Promise<void> {
     const config = await readGlobalConfig();
     const botToken = config.notifications?.telegram?.botToken;
     const chatId = config.notifications?.telegram?.chatId;
+    const topicId = config.notifications?.telegram?.topicId;
     if (!config.notifications?.enabled || !botToken || !chatId) {
       process.stderr.write("[jeo notify-daemon] notifications not configured — run `jeo notify setup` first.\n");
       return;
     }
-    const daemon = new TelegramDaemon({ chatId, telegram: new TelegramApi(botToken) });
+    const daemon = new TelegramDaemon({ chatId, topicId, telegram: new TelegramApi(botToken) });
     let shuttingDown = false;
     const shutdown = () => {
       if (shuttingDown) return;

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

@@ -64,6 +64,8 @@ export interface Config {
     telegram?: {
       botToken?: string;
       chatId?: string;
+      /** Forum-topic thread id (message_thread_id) for daemon pushes. */
+      topicId?: number;
     };
   };
 
@@ -122,6 +124,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" },