jeo-code 0.7.47 → 0.7.48

package/CHANGELOG.md

@@ -6,6 +6,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.7.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._
 

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.
 
 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.
 
 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.
 
 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.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.47",
+  "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(),
       })

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/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;
     };
   };