@llblab/pi-kit 0.11.2 → 0.11.4

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.11.4 - 2026-09-14
+
+- `State Flow Inspection Hierarchy`: Advances the exact State Flow pin to `0.11.1`, placing Show state below Start/Stop, presenting Back and the four scope choices as one vertical composition axis, and rendering a fixed scope heading above four top-level disclosures.
+- `Companion Ownership`: Advances the exact Telegram pin to `0.45.11`, retaining generic Rich Message headings while removing State Flow-specific scope semantics from the transport-owned UI registry. The package set, resource inventory, and explicit load order remain unchanged.
+
+## 0.11.3 - 2026-09-14
+
+- `Telegram Rich Sections And Queue Continuation`: Advances the exact Telegram pin to `0.45.9`, adding callback-targeted Native Rich Messages for companion sections and binding `/next` notices to the exact dispatchable queue item across concurrent readiness, admission, mutation, reordering, clearing, and transport changes.
+- `State Flow Inspection`: Advances the exact State Flow pin to `0.11.0`, adding read-only Global, CWD, Session, and Effective state inspection through the Telegram submenu with bounded collapsible Native Rich Message rendering. The package set, resource inventory, and explicit load order remain unchanged.
+
 ## 0.11.2 - 2026-09-13
 
 - `State Flow Compaction And Resilience`: Advances the exact State Flow pin to `0.10.2`, replacing byte-based early-compaction readiness with public context-token usage, retaining the complete latest accepted iteration after shortening, accepting unambiguous non-terminal `final:false`, and strengthening bounded memory stewardship. The package set, resource inventory, and explicit load order remain unchanged.

package/README.md

@@ -14,8 +14,8 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-clean-room`](https://github.com/llblab/pi-clean-room) | `0.1.1` | Isolated nested Pi TUI with explicitly selected extensions |
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.9.4` | Compact Codex/Spark subscription-limit status |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.8.1` | Visible continuation scheduling and bounded worker Skills |
-| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.10.2` | Durable scoped state with native session compaction and exact publication |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.45.8` | Telegram companion, queues, files, voice, controls, and Generative Apps guidance |
+| [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.11.1` | Durable scoped state with native session compaction, exact publication, and read-only Telegram inspection |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.45.11` | Telegram companion with exact queues, generic Rich section messages, files, voice, controls, and Generative Apps guidance |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.

package/node_modules/@llblab/pi-state-flow/BACKLOG.md

@@ -2,49 +2,6 @@
 
 Completed release work belongs in [CHANGELOG.md](CHANGELOG.md).
 
-## 0.10.2 hotfix: Native boundaries and patch robustness
-
-- **Outcome:** Correct runtime friction without weakening State Flow's semantic or durability guarantees: early post-acceptance compaction uses public context-token readiness and retains one complete accepted iteration, while non-terminal `patch_state.final` input degrades to an ordinary scoped update instead of failing. Model-facing guidance remains canonical and teaches only omission or `final:true`; tolerant Boolean normalization is a runtime resilience layer, not another advertised protocol form.
-- **Scope gate:** The hotfix stays extension-owned: retain State Flow-initiated early compaction through public Pi APIs, replace byte-based readiness with public context usage, and keep one complete latest iteration after successful shortening. Do not require or modify Pi itself.
-- **Compaction failure class:** State Flow previously admitted compaction from `JSON.stringify(activeEntries) >= 80_000`, although serialized bytes do not prove that Pi's configured recent-token suffix leaves a removable prefix. It also retained only the latest accepted assistant response. The hotfix uses public context-token usage with a 24,000-token floor and retains the complete latest accepted user iteration; custom Pi retention settings may still decline safely and permit a later retry.
-- **Patch failure class:** The public `patch_state` schema declares `final` as an optional Boolean, but execution rejects every supplied value except literal `true`. A model therefore produced a schema-valid `{ cwd: {...}, final: false }` non-terminal patch during a DEOS Grow Loop run and received `patch_state final must be exactly true when supplied`. The semantic patch was unambiguous and otherwise valid; rejecting it spent another tool turn and diagnostic record solely to enforce omission syntax.
-- **Ownership contract:** Pi owns native preparation, configured compaction settings, one prepared branch snapshot, cut-point validity, persistence, lifecycle events, and transcript projection. State Flow owns post-acceptance compaction admission, durable revision/step details, foreign-context protection, generation/leaf fencing, and `patch_state` normalization. The advertised TypeBox schema and model context remain the smallest canonical language; runtime may accept a bounded unambiguous compatibility superset without teaching it to the model.
-
-### Checkpoint A: Token-guided early compaction
-
-- **Acceptance checkpoint:** After an eligible accepted run settles, State Flow initiates its own early native compaction only when public `getContextUsage()` reports enough context. A successful request retains the complete latest accepted user iteration and durable handoff; unknown or short usage remains untouched without invoking Pi.
-- [x] **Replace byte readiness:** Removed `STATE_FLOW_COMPACTION_MIN_ACTIVE_BYTES` and the serialized-entry byte gate. The extension now requires at least 24,000 estimated context tokens—a modest margin above Pi's default 20,000-token retained suffix—while preserving enabled, accepted, non-bootstrap, idle, empty-queue, durable-base, generation, and resolution guards.
-- [x] **Retain one complete iteration:** The custom compaction boundary now starts at the latest accepted user request, preserving its assistant/tool trajectory and final response instead of retaining only the answer.
-- [x] **Keep foreign context safe:** Foreign context-bearing custom entries block shortening only when they precede the retained iteration; entries within the retained iteration remain visible.
-- [x] **Keep benign refusal recoverable:** Unknown or sub-threshold usage skips compaction. A native refusal under custom Pi retention settings releases the attempt so later accepted work can retry without affecting state.
-- [x] **Documentation and protocol:** Project protocol, architecture, usage guidance, changelog, and tests now describe token readiness and complete-iteration retention. User manual and native threshold/overflow compaction remain Pi-owned.
-
-### Checkpoint B: Quiet non-terminal patch degradation
-
-- **Acceptance checkpoint:** Model-facing contracts expose one canonical rule: omit `final` during ongoing work and set `final:true` only when the iteration may finish. Runtime treats explicit false as benign non-terminal intent and may normalize only unambiguous Boolean-like primitives before schema validation. No non-terminal value suppresses or reverses an existing eligibility latch, creates semantic work, changes transition identity or persistence behavior, or produces an invalid-patch diagnostic merely because no scope accompanied it.
-- [x] **Normalize explicit false:** `final:false` now accompanies useful global/CWD/session patches without latching or clearing terminal eligibility; pre-latch and post-latch tests preserve atomic state semantics.
-- [x] **Bound tolerant coercion:** `prepareArguments` normalizes only `true`, `false`, `1`, `0`, and case-insensitive trimmed `"true"`/`"false"`. Arrays, objects, null, unknown strings, empty strings, and other numbers remain invalid; raw JavaScript truthiness is not used.
-- [x] **Keep false-only inert:** `{final:false}` and normalized false-like-only calls return an acknowledged non-terminal no-op without semantic transition, eligibility, response, publication, or diagnostic. Bare `{}`, empty supplied scopes, unknown fields, null semantic values, and material scope no-ops remain invalid.
-- [x] **Keep model guidance canonical:** Tool descriptions, prompt snippets/guidelines, injected context, fallback prompts, `AGENTS.md`, the bundled memory Skill, and user-facing documentation teach only omission during ongoing work and `final:true` for terminal eligibility. Compatibility aliases remain implementation/test knowledge.
-- [x] **Reconcile diagnostics:** Invalid-input tests now use genuinely malformed values. Unit and real-Pi regressions prove scoped false/false-like updates are accepted without an invalid-patch record and remain terminal-ineligible until a later `final:true`.
-
-### Checkpoint C: Continuous state stewardship
-
-- **Acceptance checkpoint:** State Flow makes memory care part of ordinary model responsibility without creating an automatic background agent, arbitrary maintenance counter, full-state rewrite ritual, or second mutation path. Every handoff curates newly affected state, while explicit project/feature/release phase changes trigger one bounded ownership and obsolescence pass before terminal completion.
-- [x] **Strengthen the baseline contract:** The compact runtime protocol, `patch_state` prompt metadata, `AGENTS.md`, and bundled memory Skill now make narrowest-scope placement, touched-branch reconciliation, supersession, and obsolete-progress deletion ordinary responsibilities while keeping detailed migration procedure in the Skill.
-- [x] **Define phase-boundary care:** Feature/release/campaign completion, project switches, and active-version changes now require one bounded reconciliation that removes transient prior-work state while retaining still-operative consequences.
-- [x] **Make scope movement ordinary:** The runtime contract and Skill define global/CWD/session applicability, targeted scoped reads when effective ownership is unclear, and destination-write/readback/source-delete/readback migration ordering.
-- [x] **Bound routine cost:** Ordinary turns curate only touched and obviously stale or mis-scoped visible branches. Full reconciliation is event-driven, with no background loop, arbitrary counter, size trigger, maintenance ledger, timestamp, or score.
-- [x] **Align Skill activation:** `state-flow-memory` now covers explicit requests and runtime-required phase boundaries while remaining one bounded, materialized-first, evidence-aware cohort that cannot launch itself or authorize external promotion.
-- [x] **Live behavior witness:** A clean temporary Pi 0.85.1 session with the release extension created scoped fixture memory, then a real model moved project-specific campaign state from global to CWD through destination-write/readback/source-delete/readback, removed completed session progress, retained the cross-project rule plus active commitment/uncertainty, and left unrelated state untouched. Durable scope tails verify the claimed movement and deletion.
-
-### Checkpoint D: Integrated hotfix candidate
-
-- **Acceptance checkpoint:** Token-guided early compaction, quiet non-terminal patch degradation, and continuous state stewardship form one coherent release candidate, and validation proves all three without reopening completed 0.10.1 work.
-- [x] **Compatibility and versions:** The release preserves the existing public Pi API floor; `getContextUsage()` is present in the 0.84.4 public extension types, the complete suite passes on 0.85.1, and package/lockfile metadata agree on 0.10.2 without a new host capability dependency.
-- [x] **Regression validation:** Focused compaction and real-Pi witnesses pass; `npm run validate` passes 446/446 on Pi 0.85.1, context validation reports zero errors, and the 46-file dry-run package includes the renamed protocol and compaction domains. Real-Pi lifecycle coverage proves retained complete-iteration history and skipped short usage; patch/logging tests prove useful `final:false`; the clean real-model witness proves bounded phase-boundary cleanup.
-- [ ] **Release follow-through:** After the combined candidate is validated, release the State Flow hotfix through its guarded direct-main/tag automation and update the exact Pi Kit pin and synchronized lock/inventory surfaces.
-
 ## Candidate evolution
 
 - [ ] **Read-only global bootstrap layer:** Project the existing global materialization into enabled and non-enabled sessions by default, so even one-shot work starts carrying established cross-project facts, preferences, routing, and conventions. The global scope is the highest-value, lowest-cost half of the memory, while writing carries the protocol and curation tax; making the read side unconditional gives continuity without enabling mutation.

package/node_modules/@llblab/pi-state-flow/CHANGELOG.md

@@ -4,6 +4,14 @@
 
 ## Unreleased
 
+## 0.11.1: Telegram inspection hierarchy
+
+- `Telegram inspection`: `👁 Show state` now follows Start/Stop, and its Back, 🌐 Global, 📂 CWD, 💬 Session, and 🧬 Effective controls form one vertical composition axis. A selected scope opens with a fixed emoji-bearing heading followed directly by the four top-level collapsible semantic fields, removing the redundant outer disclosure.
+
+## 0.11.0: Telegram state inspection
+
+- `Telegram inspection`: The State Flow submenu now offers `👁 Show state` with Global, CWD, Session, and Effective choices. Selecting one scope sends exactly that projected materialized slice as a standalone Telegram Native Rich Message whose semantic fields use collapsible `details` and JSON `pre` blocks; inspection is read-only and the optional adapter remains fail-open without a compatible pi-telegram membrane.
+
 ## 0.10.2: Token-guided compaction and patch resilience
 
 - `Compaction readiness`: Early State Flow compaction now uses Pi's public context-token estimate with a 24,000-token floor instead of serialized-entry bytes, skipping unknown or short contexts without invoking native compaction. Successful shortening retains the complete latest accepted user iteration rather than only its final answer, while durable state and append-only session history remain intact.

package/node_modules/@llblab/pi-state-flow/README.md

@@ -53,7 +53,7 @@ Continue working normally. The agent receives the state protocol and uses `patch
 
 State Flow is **opt-in**. Starting in an existing conversation keeps its active context for one migration run. To enable genuinely new sessions automatically, set `"autoStart": true` in the optional [configuration](docs/usage.md#configuration).
 
-With `pi-telegram` installed, its main menu also exposes the same Start/Stop controls.
+With a compatible `pi-telegram` installed, its main menu exposes the same Start/Stop controls followed by `👁 Show state`. The chooser presents Back, 🌐 Global, 📂 CWD, 💬 Session, and 🧬 Effective as one vertical composition axis. Selecting a scope sends exactly that materialized slice as a standalone native Rich Message with a fixed scope heading and four top-level collapsible semantic fields; inspection is read-only and does not create a State Flow transition.
 
 ## What carries forward
 

package/node_modules/@llblab/pi-state-flow/lib/extension.ts

@@ -1001,6 +1001,11 @@ export default function stateFlowExtension(pi: ExtensionAPI, options: StateFlowE
 				bootstrap: snapshot.meta.bootstrap === true,
 				startPending: telegramStartPending,
 			}),
+			state: (scope) => projectStateForModel(
+				scope === "effective"
+					? overlayStates(scopeStates.global, scopeStates.cwd, scopeStates.session)
+					: scopeStates[scope],
+			),
 			canStartNow: () => activeContext === undefined || activeContext.isIdle(),
 			start: () => {
 				if (!activeContext) throw new Error("State Flow is not attached to an active session yet");

package/node_modules/@llblab/pi-state-flow/lib/telegram.ts

@@ -16,6 +16,25 @@ export interface StateFlowTelegramSnapshot {
 	startPending: boolean;
 }
 
+export type StateFlowTelegramScope = "global" | "cwd" | "session" | "effective";
+
+export interface StateFlowTelegramState {
+	artifacts: Record<string, unknown>;
+	contract: Record<string, unknown>;
+	working: Record<string, unknown>;
+	response: string;
+}
+
+export type StateFlowTelegramRichBlock =
+	| { type: "heading"; text: string; size: 2 }
+	| { type: "pre"; text: string; language?: string }
+	| { type: "details"; summary: string | { type: "bold" | "code"; text: string }; blocks: StateFlowTelegramRichBlock[]; is_open?: true };
+
+export interface StateFlowTelegramRichMessage {
+	blocks: StateFlowTelegramRichBlock[];
+	skip_entity_detection?: boolean;
+}
+
 export interface StateFlowTelegramButton {
 	text: string;
 	callback_data: string;
@@ -30,6 +49,7 @@ export interface StateFlowTelegramView {
 export interface StateFlowTelegramSectionContext {
 	callbackData(action: string, payload?: string): string;
 	edit(view: StateFlowTelegramView): Promise<void>;
+	openRich(message: StateFlowTelegramRichMessage): Promise<void>;
 	answerCallback(text?: string): Promise<void>;
 }
 
@@ -61,6 +81,7 @@ export interface StateFlowTelegramControlResult {
 
 export interface StateFlowTelegramPort {
 	snapshot(): StateFlowTelegramSnapshot;
+	state(scope: StateFlowTelegramScope): StateFlowTelegramState;
 	canStartNow(): boolean;
 	start(): StateFlowTelegramControlResult;
 	stop(): StateFlowTelegramControlResult;
@@ -103,10 +124,79 @@ export function buildStateFlowSectionView(
 	return {
 		text: [formatStateFlowSectionHeader(snapshot), "", STATE_FLOW_SECTION_HELP].join("\n"),
 		parseMode: "html",
-		replyMarkup: { inline_keyboard: [[action]] },
+		replyMarkup: { inline_keyboard: [
+			[action],
+			[{ text: "👁 Show state", callback_data: callbackData("show-state") }],
+		] },
 	};
 }
 
+const STATE_FLOW_SCOPE_LABELS: Record<StateFlowTelegramScope, string> = {
+	global: "🌐 Global",
+	cwd: "📂 CWD",
+	session: "💬 Session",
+	effective: "🧬 Effective",
+};
+
+export function buildStateFlowScopeChooser(callbackData: (action: string, payload?: string) => string): StateFlowTelegramView {
+	return {
+		text: "<b>👁 Show state:</b>",
+		parseMode: "html",
+		replyMarkup: { inline_keyboard: [
+			[{ text: "⬅️ Back", callback_data: callbackData("back") }],
+			...(["global", "cwd", "session", "effective"] as const).map((scope) => [
+				{ text: STATE_FLOW_SCOPE_LABELS[scope], callback_data: callbackData("inspect", scope) },
+			]),
+		] },
+	};
+}
+
+// The complete message serializes each preformatted field one additional time;
+// 3,000 leaves safe headroom for worst-case JSON escaping across all four fields.
+const STATE_FLOW_TELEGRAM_FIELD_MAX_CHARS = 3_000;
+
+function renderStateFlowTelegramField(value: unknown): string {
+	const json = JSON.stringify(value, null, 2);
+	if (json.length <= STATE_FLOW_TELEGRAM_FIELD_MAX_CHARS) return json;
+	let low = 0;
+	let high = json.length;
+	let rendered = "";
+	while (low <= high) {
+		const length = Math.floor((low + high) / 2);
+		const candidate = JSON.stringify({
+			truncated: true,
+			preview: json.slice(0, length),
+			omittedChars: json.length - length,
+		}, null, 2);
+		if (candidate.length <= STATE_FLOW_TELEGRAM_FIELD_MAX_CHARS) {
+			rendered = candidate;
+			low = length + 1;
+		} else {
+			high = length - 1;
+		}
+	}
+	return rendered;
+}
+
+export function renderStateFlowRichState(scope: StateFlowTelegramScope, state: StateFlowTelegramState): StateFlowTelegramRichMessage {
+	const fields = ["artifacts", "contract", "working", "response"] as const;
+	return {
+		blocks: [
+			{ type: "heading", text: STATE_FLOW_SCOPE_LABELS[scope], size: 2 },
+			...fields.map((field) => ({
+				type: "details" as const,
+				summary: { type: "code" as const, text: field },
+				blocks: [{ type: "pre" as const, language: "json", text: renderStateFlowTelegramField(state[field]) }],
+			})),
+		],
+		skip_entity_detection: true,
+	};
+}
+
+function isStateFlowTelegramScope(value: string): value is StateFlowTelegramScope {
+	return value === "global" || value === "cwd" || value === "session" || value === "effective";
+}
+
 function buildStateFlowTelegramSection(port: StateFlowTelegramPort) {
 	return {
 		id: STATE_FLOW_TELEGRAM_ID,
@@ -115,10 +205,21 @@ function buildStateFlowTelegramSection(port: StateFlowTelegramPort) {
 		render: (ctx: StateFlowTelegramSectionContext) =>
 			buildStateFlowSectionView(port.snapshot(), (action) => ctx.callbackData(action)),
 		handleCallback: async (ctx: StateFlowTelegramCallbackContext) => {
-			// cancel/refresh remain routable for keyboards sent by earlier versions; 0.9.4 presents only the state action.
-			if (ctx.action !== "start" && ctx.action !== "stop" && ctx.action !== "cancel" && ctx.action !== "refresh") return "pass" as const;
+			// cancel/refresh remain routable for keyboards sent by earlier versions.
+			if (ctx.action !== "start" && ctx.action !== "stop" && ctx.action !== "cancel" && ctx.action !== "refresh" && ctx.action !== "show-state" && ctx.action !== "inspect" && ctx.action !== "back") return "pass" as const;
 			let notice: string | undefined;
 			try {
+				if (ctx.action === "show-state") {
+					await ctx.answerCallback();
+					await ctx.edit(buildStateFlowScopeChooser((action, payload) => ctx.callbackData(action, payload)));
+					return "handled" as const;
+				}
+				if (ctx.action === "inspect") {
+					if (!isStateFlowTelegramScope(ctx.payload)) throw new Error("Unknown State Flow scope");
+					await ctx.openRich(renderStateFlowRichState(ctx.payload, port.state(ctx.payload)));
+					await ctx.answerCallback();
+					return "handled" as const;
+				}
 				if (ctx.action === "start") {
 					if (port.canStartNow()) notice = port.start().message;
 					else {

package/node_modules/@llblab/pi-state-flow/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-state-flow",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "private": false,
   "description": "Incremental scoped state/context compiler for Pi, inspired by SKILL.state",
   "keywords": [

package/node_modules/@llblab/pi-telegram/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 ## Unreleased
 
+## 0.45.11: Consumer-owned companion semantics
+
+- `Extension boundaries`: Removes consumer-specific state-scope emoji from the Telegram UI registry. The bridge continues to own generic Rich Message headings and inspection semantics, while companion extensions independently own their domain labels, composition rules, and presentation through the public section API.
+
+## 0.45.10: Rich headings and state-scope markers
+
+- `Rich section headings`: Public Rich Message block types now include native headings, allowing companion sections to place a fixed title above sibling disclosures instead of wrapping the entire view in another collapsible block.
+- `State-scope markers`: Registers 🌐 Global, 📂 CWD, 💬 Session, and 🧬 Effective as canonical state-scope semantics for chooser buttons and selected-scope headings, with composition flowing Global → CWD → Session → Effective.
+
+## 0.45.9: Rich sections and exact queue continuation
+
+- `Extension Sections`: Public section contexts now expose `openRich(message)` for one standalone Telegram Native Rich Message routed to the exact callback chat/thread with normal message-ownership recording and scoped callback diagnostics. Companion extensions can reuse native `details`/`pre` disclosure without raw bot access; `👁` is the canonical read-only inspection marker.
+- `/next` ordering: Active interruption settles before continuation is announced. The notice is bound to the exact selected queued item and revalidates queue identity, readiness, admission, pending mutations, and transport authority before dispatch; removal, clear, reordering, concurrent append, or transport loss cannot transfer stale intent to unrelated work.
+
 ## 0.45.8: Follower Forwarding Hotfix
 
 - `Follower Forwarding`: Message-ownership lookups now project the matching live registration's protocol identity before forwarding. Voice/message and edit retries, message-only callbacks, and reactions no longer stall on an incomplete cached owner after a rejection or re-registration. Exact generation, binding, protocol, and durable-receipt checks remain enforced.

package/node_modules/@llblab/pi-telegram/api/sections.ts

@@ -4,6 +4,8 @@
  * Exposes the stable managed Telegram menu-section surface while keeping registry internals package-private
  */
 
+export type { TelegramInputRichBlock, TelegramInputRichMessage, TelegramRichText } from "../lib/telegram-api.ts";
+
 export {
   getTelegramSectionDiagnostics,
   registerTelegramSection,

package/node_modules/@llblab/pi-telegram/docs/architecture.md

@@ -507,7 +507,7 @@ Immediate controls:
 - `/start` opens the main inline application menu.
 - `/model`, `/thinking`, `/queue`, and `/settings` are hidden shortcuts to menu sections.
 - `/compact` opens an inline confirmation dialog and then runs compaction when the bridge is idle.
-- `/next` dispatches the next queued turn, aborting Pi first when needed. When an active Telegram turn is aborted, its single Pi-aligned informational notice replies to a pre-abort snapshot of that turn; otherwise the command message is the fallback target. Aborted pending assistant text is not projected as a second reply, while already completed intermediate output remains visible.
+- `/next` dispatches the next queued turn, aborting Pi first when needed. Active-turn settlement delivers its abort notice to the interrupted prompt before queue dispatch continues. The queue owner then emits `Dispatching next queued turn.` against the exact selected prompt's chat/thread/reply id before its one model dispatch; skipped, inactive, pending-mutation, and admission-blocked candidates never receive it. The `/next` command itself is never a lifecycle-notice reply target. Aborted pending assistant text is not projected as a second reply, while already completed intermediate output remains visible.
 - `/abort` aborts active work while preserving queued items. Abort-history preservation is enabled only for Telegram-owned active turns; later local/non-Telegram agent starts clear stale abort-history mode so the next Telegram prompt appends instead of absorbing old queued turns as history.
 - `/stop` aborts and clears waiting Telegram queue items.
 

package/node_modules/@llblab/pi-telegram/docs/public-api.md

@@ -52,7 +52,7 @@ Stable commands inside the paired Telegram DM:
 
 - `/start` — pair when needed and open the main application menu.
 - `/compact` — open confirmation and compact when idle.
-- `/next` — dispatch the next queued turn, aborting active work first when needed; one Pi-aligned informational reply anchors to a pre-abort snapshot of the Telegram turn or falls back to the command, and aborted pending assistant text is suppressed.
+- `/next` — abort active work first when needed, let the interrupted prompt receive its abort notice, then reply `Dispatching next queued turn.` to the exact queued prompt selected for the next model turn. The command itself is never the lifecycle-notice reply target, and aborted pending assistant text is suppressed.
 - `/continue` — enqueue a priority `continue` prompt.
 - `/abort` — abort active work and keep the queue; abort-history is scoped to Telegram-owned active turns.
 - `/stop` — abort active Telegram-owned work and clear waiting Telegram queue items.

package/node_modules/@llblab/pi-telegram/docs/sections.md

@@ -262,6 +262,8 @@ interface TelegramSectionContext {
   edit(view: TelegramSectionView): Promise<void>;
   /** Send a standalone chat message without auto-navigation */
   open(view: TelegramSectionView): Promise<void>;
+  /** Send one standalone Telegram Native Rich Message without exposing transport */
+  openRich(message: TelegramInputRichMessage): Promise<void>;
   /** Enqueue a plain-text prompt turn */
   enqueuePrompt(prompt: string): Promise<void>;
   /** Build a section-namespaced callback_data string */
@@ -285,6 +287,7 @@ interface TelegramSectionCallbackContext {
   answerCallback(text?: string): Promise<void>;
   edit(view: TelegramSectionView): Promise<void>;
   open(view: TelegramSectionView): Promise<void>;
+  openRich(message: TelegramInputRichMessage): Promise<void>;
   enqueuePrompt(prompt: string): Promise<void>;
   callbackData(action: string, payload?: string): string;
   /** Delete the message that triggered this callback */
@@ -292,6 +295,12 @@ interface TelegramSectionCallbackContext {
 }
 ```
 
+### `openRich` semantics
+
+`ctx.openRich(message)` sends exactly one standalone Telegram Native Rich Message to the callback's exact chat/thread target. It accepts the public `TelegramInputRichMessage` tree (`details` and `pre` blocks) used by native tool evidence, records message ownership, and routes through the active direct/follower transport. It adds no menu navigation and exposes no raw bot client or arbitrary API method.
+
+Use it when disclosure behavior is part of the document, such as one selected read-only state or evidence tree. Do not imitate nested disclosure with HTML or Markdown when the native tree is required.
+
 ### `enqueuePrompt` semantics
 
 Queues a `[telegram] <prompt>` turn in the default lane with the paired user's `chatId`. Uses `queueMutationRuntime.append()` and triggers `dispatchNextQueuedTelegramTurn()`. The prompt arrives as a normal Telegram-owned turn — the agent sees it as if the user typed it.

package/node_modules/@llblab/pi-telegram/docs/ui-style.md

@@ -36,6 +36,7 @@ Use emoji as stable semantic markers, not decoration. Emoji carry transportable
 | `🔬` | Activity / technical detail | Activity settings row and detail card | Chooses quiet, thinking, tools, or verbose bridge activity; not a generic diagnostics marker. |
 | `🧠` | Model thinking controls | Thinking menus and status rows | Thinking activity quotes omit this icon and their header entirely to minimize chat height. |
 | `📎` | Attachment | Attachment summaries, queue rows for attachment-only turns | Not for thread binding. |
+| `👁` | Read-only inspection | State/detail viewers and inspection entrypoints | Opens evidence without mutating the inspected object; do not use for edit or refresh actions. |
 
 ### Command And Control Actions
 

package/node_modules/@llblab/pi-telegram/lib/bindings.ts

@@ -50,6 +50,7 @@ type TelegramAgentMessageRouter = NonNullable<
 export interface TelegramQueueBindingRuntime<TContext> {
   mutation: Queue.TelegramQueueMutationController<TContext>;
   dispatchNext: (ctx: TContext) => void;
+  requestNextDispatchAnnouncement: () => void;
   watchdog: Queue.TelegramQueueDispatchWatchdogRuntime<TContext>;
 }
 
@@ -122,7 +123,7 @@ export function createTelegramQueueBindingRuntime<TContext>(deps: {
     updateStatus: deps.updateStatus,
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
-  const dispatchNext = Queue.createTelegramQueueDispatchRuntime({
+  const dispatch = Queue.createTelegramQueueDispatchRuntime({
     ...deps.store,
     isCompactionInProgress: deps.lifecycle.isCompactionInProgress,
     hasActiveTurn: deps.activeTurn.has,
@@ -162,13 +163,14 @@ export function createTelegramQueueBindingRuntime<TContext>(deps: {
     recordRuntimeEvent: deps.recordRuntimeEvent,
     ...deps.promptDispatch,
     sendUserMessage: deps.sendUserMessage,
-  }).dispatchNext;
+  });
   return {
     mutation,
-    dispatchNext,
+    dispatchNext: dispatch.dispatchNext,
+    requestNextDispatchAnnouncement: dispatch.requestNextDispatchAnnouncement,
     watchdog: Queue.createTelegramQueueDispatchWatchdogRuntime({
       hasQueuedItems: deps.store.hasQueuedItems,
-      dispatchNextQueuedTelegramTurn: dispatchNext,
+      dispatchNextQueuedTelegramTurn: dispatch.dispatchNext,
       recordRuntimeEvent: deps.recordRuntimeEvent,
     }),
   };

package/node_modules/@llblab/pi-telegram/lib/commands.ts

@@ -1147,6 +1147,7 @@ export interface TelegramCommandRuntimeDeps<
   updateStatus: (ctx: TContext) => void;
   isContextActive?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  requestNextDispatchAnnouncement?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
@@ -1416,6 +1417,7 @@ export async function handleTelegramNextCommand(deps: {
   clearPendingModelSwitch: () => void;
   abortCurrentTurn: () => void;
   dispatchNextQueuedTurn: () => void;
+  requestNextDispatchAnnouncement?: () => void;
   clearFoldForDispatch: () => void;
   updateStatus: () => void;
   sendTextReply: (
@@ -1435,19 +1437,10 @@ export async function handleTelegramNextCommand(deps: {
     return;
   }
   if (!deps.isIdle() && deps.hasAbortHandler()) {
-    const activeTurnReply = deps.getActiveTurnReply?.();
     deps.clearFoldForDispatch();
+    deps.requestNextDispatchAnnouncement?.();
     deps.abortCurrentTurn();
     deps.updateStatus();
-    const notice = formatTelegramInformationHeading(
-      "⏩",
-      "Dispatching next queued turn.",
-    );
-    if (activeTurnReply) {
-      await activeTurnReply(notice, { parseMode: "HTML" });
-    } else {
-      await deps.sendTextReply(notice, { parseMode: "HTML" });
-    }
     return;
   }
   if (!deps.isIdle()) {
@@ -1460,12 +1453,9 @@ export async function handleTelegramNextCommand(deps: {
     );
     return;
   }
+  deps.requestNextDispatchAnnouncement?.();
   deps.dispatchNextQueuedTurn();
   deps.updateStatus();
-  await deps.sendTextReply(
-    formatTelegramInformationHeading("▶️", "Dispatching next queued turn."),
-    { parseMode: "HTML" },
-  );
 }
 
 export async function handleTelegramContinueCommand<TMessage, TContext>(
@@ -2029,6 +2019,7 @@ async function handleTelegramCommandRuntime<
           abortCurrentTurn: deps.abortCurrentTurn,
           dispatchNextQueuedTurn: () =>
             deps.dispatchNextQueuedTelegramTurn(commandCtx),
+          requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
           clearFoldForDispatch: () =>
             deps.setFoldQueuedPromptsIntoHistory(false),
           updateStatus: updateStatusFor(commandCtx),

package/node_modules/@llblab/pi-telegram/lib/extension.ts

@@ -629,8 +629,12 @@ export default function (pi: Pi.ExtensionAPI) {
     getAssistantRenderingMode: configControls.getAssistantRenderingMode,
     editMessage: editTelegramMessageText,
   });
-  const { replyTransport, editInteractiveMessage, sendInteractiveMessage } =
-    replyRuntime;
+  const {
+    replyTransport,
+    editInteractiveMessage,
+    sendInteractiveMessage,
+    sendSectionRichMessage,
+  } = replyRuntime;
   const deliveryTargetPolicyRuntime =
     Delivery.createTelegramDeliveryTargetPolicyRuntime({
       ownsDirect: lockRuntime.owns,
@@ -744,6 +748,7 @@ export default function (pi: Pi.ExtensionAPI) {
   const {
     mutation: queueMutationRuntime,
     dispatchNext: dispatchNextQueuedTelegramTurn,
+    requestNextDispatchAnnouncement,
     watchdog: queueDispatchWatchdogRuntime,
   } = Bindings.createTelegramQueueBindingRuntime({
     store: telegramQueueStore,
@@ -964,6 +969,7 @@ export default function (pi: Pi.ExtensionAPI) {
     openSettingsMenu: settingsMenuRuntime.openSettingsMenu,
     settingsMenuCallbackHandler: settingsMenuRuntime.handleCallbackQuery,
     sectionRegistry,
+    sendSectionRichMessage,
     buttonActionStore,
     invokeBoundButtonAction: invokeGenerativeAppBoundButtonAction,
     inboundHandlerRuntime,
@@ -972,6 +978,7 @@ export default function (pi: Pi.ExtensionAPI) {
     updateStatus,
     isContextActive: telegramSessionContextStore.isCurrent,
     dispatchNextQueuedTelegramTurn,
+    requestNextDispatchAnnouncement,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deferredQueueDispatchRuntime.request,
     hasDeferredDispatchContext: deferredQueueDispatchRuntime.isBound,

package/node_modules/@llblab/pi-telegram/lib/menu.ts

@@ -32,6 +32,7 @@ import {
   type ScopedTelegramModel,
   type ThinkingLevel,
 } from "./model.ts";
+import type { TelegramInputRichMessage } from "./telegram-api.ts";
 import {
   handleTelegramSectionCallback,
   handleTelegramSectionOpen,
@@ -225,6 +226,11 @@ export interface TelegramMenuCallbackRuntimeDeps<
     replyMarkup: TelegramReplyMarkup,
     options?: { target?: { chatId: number; threadId?: number } },
   ) => Promise<number | undefined>;
+  sendSectionRichMessage?: (
+    chatId: number,
+    message: TelegramInputRichMessage,
+    options?: { target?: { chatId: number; threadId?: number } },
+  ) => Promise<number | undefined>;
   enqueueSectionPrompt?: (
     prompt: string,
     ctx: TContext,
@@ -478,6 +484,11 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
     replyMarkup: TelegramReplyMarkup,
     options?: { target?: { chatId: number; threadId?: number } },
   ) => Promise<number | undefined>;
+  sendSectionRichMessage?: (
+    chatId: number,
+    message: TelegramInputRichMessage,
+    options?: { target?: { chatId: number; threadId?: number } },
+  ) => Promise<number | undefined>;
   enqueueSectionPrompt?: (
     prompt: string,
     ctx: TContext,
@@ -527,6 +538,7 @@ export function createTelegramMenuCallbackHandlerForContext<
     sectionRegistry: deps.sectionRegistry,
     editInteractiveMessage: deps.editInteractiveMessage,
     sendInteractiveMessage: deps.sendInteractiveMessage,
+    sendSectionRichMessage: deps.sendSectionRichMessage,
     enqueueSectionPrompt: deps.enqueueSectionPrompt,
     deleteMessage: deps.deleteMessage,
   });
@@ -591,6 +603,9 @@ export async function handleTelegramMenuCallbackRuntime<
                 deps.editInteractiveMessage ?? (async () => {}),
               sendInteractiveMessage:
                 deps.sendInteractiveMessage ?? (async () => undefined),
+              sendRichMessage: deps.sendSectionRichMessage ?? (async () => {
+                throw new Error("Rich Message delivery is unavailable");
+              }),
               enqueuePrompt: deps.enqueueSectionPrompt
                 ? (prompt: string) =>
                     deps.enqueueSectionPrompt!(prompt, ctx, target, query)
@@ -614,6 +629,9 @@ export async function handleTelegramMenuCallbackRuntime<
                   deps.editInteractiveMessage ?? (async () => {}),
                 sendInteractiveMessage:
                   deps.sendInteractiveMessage ?? (async () => undefined),
+                sendRichMessage: deps.sendSectionRichMessage ?? (async () => {
+                  throw new Error("Rich Message delivery is unavailable");
+                }),
                 enqueuePrompt: deps.enqueueSectionPrompt
                   ? (prompt: string) =>
                       deps.enqueueSectionPrompt!(prompt, ctx, target, query)
@@ -639,6 +657,9 @@ export async function handleTelegramMenuCallbackRuntime<
                 deps.editInteractiveMessage ?? (async () => {}),
               sendInteractiveMessage:
                 deps.sendInteractiveMessage ?? (async () => undefined),
+              sendRichMessage: deps.sendSectionRichMessage ?? (async () => {
+                throw new Error("Rich Message delivery is unavailable");
+              }),
               enqueuePrompt: deps.enqueueSectionPrompt
                 ? (prompt: string) =>
                     deps.enqueueSectionPrompt!(prompt, ctx, target, query)

package/node_modules/@llblab/pi-telegram/lib/queue.ts

@@ -3055,6 +3055,7 @@ export interface TelegramQueueDispatchControllerDeps<
 
 export interface TelegramQueueDispatchController<TContext = unknown> {
   dispatchNext: (ctx: TContext) => void;
+  requestNextDispatchAnnouncement: () => void;
 }
 
 export function executeTelegramQueueDispatchPlan<TContext = unknown>(
@@ -3123,7 +3124,13 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
   deps: TelegramQueueDispatchControllerDeps<TContext>,
 ): TelegramQueueDispatchController<TContext> {
   let controlDispatchPending = false;
+  let nextDispatchAnnouncementRequested = false;
+  let nextDispatchAnnouncementAnchor: TelegramQueueItem<TContext> | undefined;
   const controller: TelegramQueueDispatchController<TContext> = {
+    requestNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementRequested = true;
+      nextDispatchAnnouncementAnchor = undefined;
+    },
     dispatchNext: (ctx) => {
       if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
       if (controlDispatchPending) {
@@ -3151,6 +3158,10 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
       }
       if (droppedInactiveItemCount > 0) {
         deps.setQueuedItems(retainedItems);
+        if (retainedItems.length === 0) {
+          nextDispatchAnnouncementRequested = false;
+          nextDispatchAnnouncementAnchor = undefined;
+        }
         deps.recordRuntimeEvent?.(
           "dispatch",
           new Error(
@@ -3209,6 +3220,21 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
       }
       const dispatchableItems = activeItems.slice(nextActiveIndex);
       const nextItem = dispatchableItems[0];
+      if (nextDispatchAnnouncementRequested) {
+        if (nextDispatchAnnouncementAnchor) {
+          const anchorRetained = retainedItems.includes(nextDispatchAnnouncementAnchor);
+          const anchorTransportActive =
+            deps.isQueueItemTransportActive?.(nextDispatchAnnouncementAnchor) !== false;
+          if (!anchorRetained || !anchorTransportActive) {
+            nextDispatchAnnouncementRequested = false;
+            nextDispatchAnnouncementAnchor = undefined;
+          }
+        } else if (nextItem) {
+          nextDispatchAnnouncementAnchor = nextItem;
+        } else if (retainedItems.length === 0) {
+          nextDispatchAnnouncementRequested = false;
+        }
+      }
       if (
         nextItem &&
         deps.hasPendingInboundQueueMutationForItem?.(nextItem)
@@ -3224,17 +3250,49 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
         deps.updateStatus(ctx);
         return;
       }
+      const dispatchBasisItems = deps.getQueuedItems();
       const dispatchPlan = planNextTelegramQueueAction(
         dispatchableItems,
         canDispatch,
       );
-      if (dispatchPlan.kind !== "none") {
+      const commitDispatchPlan = (): boolean => {
+        if (dispatchPlan.kind === "none") return true;
+        const currentItems = deps.getQueuedItems();
+        if (dispatchPlan.kind === "prompt") {
+          const queueDrifted =
+            currentItems.length !== dispatchBasisItems.length ||
+            currentItems.some((item, index) => item !== dispatchBasisItems[index]);
+          const dispatchEligibilityDrifted =
+            !deps.canDispatch(ctx) ||
+            deps.hasPendingInboundQueueMutationForItem?.(dispatchPlan.item) === true ||
+            (deps.isQueueItemAdmissionReady?.(dispatchPlan.item) === false) ||
+            (deps.isQueueItemTransportActive?.(dispatchPlan.item) === false);
+          if (queueDrifted || dispatchEligibilityDrifted) {
+            const selectedItemRetained = currentItems.includes(dispatchPlan.item);
+            const selectedTransportActive =
+              deps.isQueueItemTransportActive?.(dispatchPlan.item) !== false;
+            nextDispatchAnnouncementRequested =
+              selectedItemRetained && selectedTransportActive;
+            nextDispatchAnnouncementAnchor = nextDispatchAnnouncementRequested
+              ? dispatchPlan.item
+              : undefined;
+            deps.updateStatus(ctx);
+            if (nextDispatchAnnouncementRequested && queueDrifted && !dispatchEligibilityDrifted) {
+              controller.dispatchNext(ctx);
+            }
+            return false;
+          }
+        }
         deps.setQueuedItems([
           ...dispatchPlan.remainingItems,
           ...protectedInactiveItems,
         ]);
-      }
-      executeTelegramQueueDispatchPlan(dispatchPlan, {
+        nextDispatchAnnouncementAnchor = undefined;
+        return true;
+      };
+      const executePlan = (): void => {
+        if (!commitDispatchPlan()) return;
+        executeTelegramQueueDispatchPlan(dispatchPlan, {
         executeControlItem: (item) => {
           controlDispatchPending = true;
           const dispatchGeneration = deps.getDispatchGeneration?.();
@@ -3280,6 +3338,32 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
           deps.updateStatus(ctx);
         },
       });
+      };
+      if (dispatchPlan.kind === "prompt" && nextDispatchAnnouncementRequested) {
+        nextDispatchAnnouncementRequested = false;
+        controlDispatchPending = true;
+        const dispatchGeneration = deps.getDispatchGeneration?.();
+        deps.updateStatus(ctx);
+        void deps.sendTextReply(
+          dispatchPlan.item.chatId,
+          dispatchPlan.item.replyToMessageId,
+          "<b>⏩ Dispatching next queued turn.</b>",
+          { target: dispatchPlan.item.target },
+        ).catch((error) => {
+          deps.recordRuntimeEvent?.("dispatch", error, { phase: "next-announcement" });
+        }).finally(() => {
+          controlDispatchPending = false;
+          if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
+          if (
+            dispatchGeneration !== undefined &&
+            deps.isDispatchGenerationActive &&
+            !deps.isDispatchGenerationActive(dispatchGeneration)
+          ) return;
+          executePlan();
+        });
+        return;
+      }
+      executePlan();
     },
   };
   return controller;

package/node_modules/@llblab/pi-telegram/lib/replies.ts

@@ -730,6 +730,24 @@ export async function sendTelegramNativeMarkdownReply<TReplyMarkup = unknown>(
   return lastMessageId;
 }
 
+export async function sendTelegramNativeRichMessage(
+  chatId: number,
+  richMessage: TelegramInputRichMessage,
+  deps: {
+    recordOwnership?: TelegramReplyOwnershipRecorder["record"];
+    sendRichMessage: (body: TelegramSendRichMessageBody) => Promise<TelegramSentMessage>;
+  },
+  options?: TelegramReplyTargetOptions,
+): Promise<number> {
+  const sent = await deps.sendRichMessage({
+    chat_id: chatId,
+    rich_message: richMessage,
+    ...(options?.target ? getTelegramTargetThreadParams(options.target) : {}),
+  });
+  deps.recordOwnership?.({ chatId, messageId: sent.message_id, target: options?.target });
+  return sent.message_id;
+}
+
 // UI/compat regular-message runtime for bridge-owned text and interactive
 // surfaces. Assistant and guest Markdown delivery bypass this path and use
 // native Rich Message helpers above.
@@ -775,6 +793,11 @@ export interface TelegramRenderedMessageRuntime<TReplyMarkup> {
     replyMarkup: TReplyMarkup,
     options?: TelegramReplyTargetOptions,
   ) => Promise<number | undefined>;
+  sendSectionRichMessage: (
+    chatId: number,
+    message: TelegramInputRichMessage,
+    options?: TelegramReplyTargetOptions,
+  ) => Promise<number>;
 }
 
 export interface TelegramRenderedMessageDeliveryRuntime<
@@ -891,6 +914,11 @@ export function createTelegramRenderedMessageRuntime<TReplyMarkup>(
         },
       );
     },
+    sendSectionRichMessage: (chatId, message, options) =>
+      sendTelegramNativeRichMessage(chatId, message, {
+        recordOwnership: deps.recordOwnership,
+        sendRichMessage: deps.sendRichMessage,
+      }, options),
   };
 }
 

package/node_modules/@llblab/pi-telegram/lib/routing.ts

@@ -19,6 +19,7 @@ import * as Queue from "./queue.ts";
 import * as Replies from "./replies.ts";
 import type { TelegramBridgeRuntime } from "./runtime.ts";
 import type { TelegramSectionRegistry } from "./sections.ts";
+import type { TelegramInputRichMessage } from "./telegram-api.ts";
 import * as TextGroups from "./text-groups.ts";
 import * as ThreadNaming from "./thread-naming.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
@@ -625,6 +626,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   updateStatus: (ctx: TContext, error?: string) => void;
   isContextActive?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
+  requestNextDispatchAnnouncement?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
@@ -706,6 +708,11 @@ export interface TelegramInboundRouteRuntimeDeps<
     details?: Record<string, unknown>,
   ) => void;
   sectionRegistry?: TelegramSectionRegistry;
+  sendSectionRichMessage?: (
+    chatId: number,
+    message: TelegramInputRichMessage,
+    options?: { target?: { chatId: number; threadId?: number } },
+  ) => Promise<number | undefined>;
 }
 
 const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
@@ -1013,6 +1020,7 @@ export function createTelegramInboundRouteRuntime<
     sectionRegistry: deps.sectionRegistry,
     editInteractiveMessage: deps.editInteractiveMessage,
     sendInteractiveMessage: deps.sendInteractiveMessage,
+    sendSectionRichMessage: deps.sendSectionRichMessage,
     deleteMessage: deps.deleteMessage,
     enqueueSectionPrompt: async (
       prompt: string,
@@ -2171,6 +2179,7 @@ export function createTelegramInboundRouteRuntime<
     updateStatus: deps.updateStatus,
     isContextActive: deps.isContextActive,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deps.requestDeferredDispatchNextQueuedTelegramTurn,
     startTypingLoop: deps.startTypingLoop,

package/node_modules/@llblab/pi-telegram/lib/sections.ts

@@ -8,6 +8,7 @@ import {
   assertTelegramCallbackData,
   type TelegramInlineKeyboardMarkup,
 } from "./keyboard.ts";
+import type { TelegramInputRichMessage } from "./telegram-api.ts";
 
 const SECTION_REGISTRY_KEY = "__piTelegramSectionRegistry__";
 
@@ -66,6 +67,7 @@ export interface TelegramSectionContext {
   answerCallback(text?: string): Promise<void>;
   edit(view: TelegramSectionView): Promise<void>;
   open(view: TelegramSectionView): Promise<void>;
+  openRich(message: TelegramInputRichMessage): Promise<void>;
   enqueuePrompt(prompt: string): Promise<void>;
   callbackData(action: string, payload?: string): string;
   /** Delete the message that triggered this callback (dialog cleanup) */
@@ -81,6 +83,7 @@ export interface TelegramSectionCallbackContext {
   answerCallback(text?: string): Promise<void>;
   edit(view: TelegramSectionView): Promise<void>;
   open(view: TelegramSectionView): Promise<void>;
+  openRich(message: TelegramInputRichMessage): Promise<void>;
   enqueuePrompt(prompt: string): Promise<void>;
   callbackData(action: string, payload?: string): string;
   /** Delete the message that triggered this callback (dialog cleanup) */
@@ -160,6 +163,11 @@ export interface TelegramSectionRuntimeDeps {
     replyMarkup: TelegramInlineKeyboardMarkup,
     options?: { target?: TelegramSectionTarget },
   ) => Promise<number | undefined>;
+  sendRichMessage: (
+    chatId: number,
+    message: TelegramInputRichMessage,
+    options?: { target?: TelegramSectionTarget },
+  ) => Promise<number | undefined>;
   enqueuePrompt: (prompt: string) => Promise<void>;
   deleteMessage: (chatId: number, messageId: number) => Promise<void>;
 }
@@ -202,6 +210,12 @@ function buildTelegramSectionContext(
           deps.target ? { target: deps.target } : undefined,
         )
         .then(() => {}),
+    openRich: (message) =>
+      deps.sendRichMessage(
+        chatId,
+        message,
+        deps.target ? { target: deps.target } : undefined,
+      ).then(() => {}),
     enqueuePrompt: deps.enqueuePrompt,
     callbackData: (action, payload) =>
       buildTelegramSectionCallbackData(token, action, payload),
@@ -251,6 +265,12 @@ function buildTelegramSectionCallbackContext(
           deps.target ? { target: deps.target } : undefined,
         )
         .then(() => {}),
+    openRich: (message) =>
+      deps.sendRichMessage(
+        chatId,
+        message,
+        deps.target ? { target: deps.target } : undefined,
+      ).then(() => {}),
     enqueuePrompt: deps.enqueuePrompt,
     callbackData: (action, payload) =>
       buildTelegramSectionCallbackData(token, action, payload),
@@ -526,6 +546,11 @@ export interface TelegramSectionCallbackHandlerDeps {
     replyMarkup: TelegramInlineKeyboardMarkup,
     options?: { target?: TelegramSectionTarget },
   ) => Promise<number | undefined>;
+  sendRichMessage: (
+    chatId: number,
+    message: TelegramInputRichMessage,
+    options?: { target?: TelegramSectionTarget },
+  ) => Promise<number | undefined>;
   enqueuePrompt: (prompt: string) => Promise<void>;
   deleteMessage: (chatId: number, messageId: number) => Promise<void>;
 }

package/node_modules/@llblab/pi-telegram/lib/telegram-api.ts

@@ -292,6 +292,7 @@ export type TelegramRichText =
   | { type: "bold" | "code"; text: TelegramRichText };
 
 export type TelegramInputRichBlock =
+  | { type: "heading"; text: TelegramRichText; size?: 1 | 2 | 3 }
   | { type: "pre"; text: TelegramRichText; language?: string }
   | {
       type: "details";

package/node_modules/@llblab/pi-telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.45.8",
+  "version": "0.45.11",
   "private": false,
   "publishConfig": {
     "access": "public"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -44,8 +44,8 @@
     "@llblab/pi-clean-room": "0.1.1",
     "@llblab/pi-codex-usage": "0.9.4",
     "@llblab/pi-grow-loop": "0.8.1",
-    "@llblab/pi-state-flow": "0.10.2",
-    "@llblab/pi-telegram": "0.45.8",
+    "@llblab/pi-state-flow": "0.11.1",
+    "@llblab/pi-telegram": "0.45.11",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [