pi-ui-extend 0.1.65 → 0.1.66

package/external/pi-tools-suite/src/config.ts

@@ -5,19 +5,12 @@ import { parse as parseJsonc } from "jsonc-parser";
 
 import { DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC } from "./default-pi-tools-suite-config.js";
 
-export interface TelegramMirrorConfig {
-	enabled: boolean;
-	botToken: string;
-	chatId: number;
-}
-
 export interface PiToolsSuiteConfig {
 	enabled: boolean;
 	disabledModules: string[];
 	todoThinking: boolean;
 	/** Vision-capable model used by the coding-discipline lookup tool; unset disables lookup. */
 	lookupModel?: string;
-	telegramMirror?: TelegramMirrorConfig;
 }
 
 type MutableConfig = {
@@ -25,7 +18,6 @@ type MutableConfig = {
 	disabledModules: Set<string>;
 	todoThinking: boolean;
 	lookupModel: string | undefined;
-	telegramMirror: TelegramMirrorConfig | undefined;
 };
 
 type Env = Record<string, string | undefined>;
@@ -70,27 +62,6 @@ function normalizeLookupModel(raw: unknown): string | undefined {
 	return trimmed ? trimmed : undefined;
 }
 
-function normalizeTelegramMirror(raw: unknown): TelegramMirrorConfig | undefined {
-	if (!isRecord(raw)) return undefined;
-	const botToken = typeof raw.botToken === "string" ? raw.botToken.trim() : "";
-	if (!botToken) return undefined;
-
-	let chatId: number | undefined;
-	if (typeof raw.chatId === "number" && Number.isFinite(raw.chatId) && Number.isInteger(raw.chatId)) {
-		chatId = raw.chatId;
-	} else if (typeof raw.chatId === "string") {
-		const trimmed = raw.chatId.trim();
-		if (/^-?\d+$/.test(trimmed)) {
-			const parsed = Number(trimmed);
-			if (Number.isFinite(parsed) && Number.isInteger(parsed)) chatId = parsed;
-		}
-	}
-	if (chatId === undefined) return undefined;
-
-	const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
-	return { enabled, botToken, chatId };
-}
-
 function boolFromEnv(value: string | undefined): boolean | undefined {
 	if (value === undefined) return undefined;
 	const normalized = value.trim().toLowerCase();
@@ -165,9 +136,6 @@ function mergeConfigLayer(config: MutableConfig, raw: Record<string, unknown>, k
 		}
 	}
 
-	const telegramMirror = normalizeTelegramMirror(raw.telegramMirror);
-	if (telegramMirror) config.telegramMirror = telegramMirror;
-
 	return config;
 }
 
@@ -210,7 +178,6 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		disabledModules: new Set([...DEFAULT_DISABLED_MODULES].filter((name) => knownModules.has(name))),
 		todoThinking: false,
 		lookupModel: undefined,
-		telegramMirror: undefined,
 	};
 	const userConfigPath = getPiToolsSuiteUserConfigPath(options.homeDir);
 
@@ -230,15 +197,5 @@ export function loadPiToolsSuiteConfig(moduleNames: readonly string[], options:
 		disabledModules: [...config.disabledModules].sort(),
 		todoThinking: config.todoThinking,
 		...(config.lookupModel ? { lookupModel: config.lookupModel } : {}),
-		...(config.telegramMirror ? { telegramMirror: config.telegramMirror } : {}),
 	};
 }
-
-/**
- * Load only the telegram-mirror section from the pi-tools-suite config layers.
- * Returns undefined when the section is missing or invalid (botToken empty /
- * chatId non-integer).
- */
-export function loadTelegramMirrorConfig(options: { cwd?: string; env?: Env; homeDir?: string } = {}): TelegramMirrorConfig | undefined {
-	return loadPiToolsSuiteConfig([], options).telegramMirror;
-}

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -22,11 +22,6 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = String.raw`{
   //   "balanced"     — + restate-code + generic-explanation (default);
   //   "aggressive"   — any non-valuable net-new comment.
   "commentChecker": { "enabled": true, "strictness": "balanced" },
-  // "telegramMirror": {
-  //   "enabled": true,
-  //   "botToken": "123456789:ABCdef...",
-  //   "chatId": 123456789
-  // },
   "dcp": {
     "enabled": true,
     // Write a JSONL debug log of DCP context/prune/compress events to

package/external/pi-tools-suite/src/index.ts

@@ -26,7 +26,6 @@ export const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule>
 	{ name: "dcp", load: () => import("./dcp/index") },
 	{ name: "prompt-commands", load: () => import("./prompt-commands/index") },
 	{ name: "skill-installer", load: () => import("./skill-installer/index") },
-	{ name: "telegram-mirror", load: () => import("./telegram-mirror/index") },
 	// Keep this last: its before_provider_request handler is the final payload
 	// sanitizer after DCP and any other provider-payload modifiers.
 	{ name: "codex-reasoning-fix", load: () => import("./codex-reasoning-fix/index") },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "private": false,
   "type": "module",
   "bin": {

package/external/pi-tools-suite/src/telegram-mirror/README.md

@@ -1,203 +0,0 @@
-# telegram-mirror
-
-A pi-tools-suite module that exposes one or more running pi sessions as a
-single Telegram chat. Pi stays as the source of truth; Telegram is a remote
-second screen.
-
-## Opt-in
-
-The module is a no-op until you add a `telegramMirror` block to
-`~/.config/pi/pi-tools-suite.jsonc`:
-
-```jsonc
-{
-  // …other pi-tools-suite settings…
-  "telegramMirror": {
-    "enabled": true,
-    "botToken": "123456789:ABCdef…",   // from @BotFather
-    "chatId": 123456789                // numeric chat id of your private chat
-  }
-}
-```
-
-- `enabled` (boolean, optional): defaults to `true` when the block is
-  present and `botToken` + `chatId` are valid.
-- `botToken` (string, required): Telegram Bot API token from @BotFather.
-  Empty string disables the mirror.
-- `chatId` (number or string, required): numeric private chat id allowed to
-  control the bot. Non-integer disables the mirror.
-
-When the block is present and valid, the module registers the local
-`/telegram-mirror` and `/tg` slash commands. The bot does not connect until
-you run one of those commands in a pi session.
-
-## Activation
-
-Run this inside each pi session you want to expose to Telegram:
-
-```text
-/telegram-mirror
-```
-
-Short alias:
-
-```text
-/tg
-```
-
-Useful local variants:
-
-- `/telegram-mirror` or `/tg`: connect this pi session to Telegram mirror.
-- `/telegram-mirror status`: show local mirror role and session label.
-- `/telegram-mirror stop`: stop the mirror cluster.
-- `/tg-off`: stop the mirror cluster.
-
-After activation, the leader sends a Telegram message with buttons. Use
-`/menu` or `/list` in Telegram any time to reopen the project/session picker.
-
-## How to get your chat id
-
-Open this URL in a browser (replace `<TOKEN>` with your bot token):
-
-```text
-https://api.telegram.org/bot<TOKEN>/getUpdates
-```
-
-Send any message to your bot in Telegram, then refresh the URL. The JSON
-response contains `"chat": { "id": 123456789, … }` — that number is your
-`chatId`.
-
-Alternative: message [@userinfobot](https://t.me/userinfobot).
-
-The bot silently ignores every message from any other chat.
-
-## Multi-instance setup
-
-Telegram allows exactly one concurrent `getUpdates` call per bot token,
-so this module elects a **leader** when N pi processes share one bot:
-
-1. The first pi to start binds the unix socket at
-   `~/.pi/agent/extensions/pi-tools-suite/.run/telegram-mirror.sock`,
-   connects the bot, and starts polling.
-2. Subsequent pi processes connect to that socket as **followers**. They
-   forward their pix events to the leader over IPC and execute commands
-   received from the leader.
-3. If the leader dies (process exit, socket close, or heartbeat timeout),
-   followers race to bind the socket; the first to win becomes the new
-   leader. `activeId` resets on failover — run `/use N` again.
-
-Run `/telegram-mirror` in every `pi` process you want available in the
-Telegram picker. Only one process polls Telegram; the rest register as
-followers over IPC.
-
-When you start a new pi, it logs `[telegram-mirror] registered with
-leader <label>` on stderr. The leader logs `[telegram-mirror] connected
-as @<botname> (leader)`.
-
-### Selecting the followed project/session
-
-In Telegram, use `/menu`, `/list`, or the inline buttons:
-
-```text
-/list
-→
-1. pi-ui-extend (#12345) (leader) [following] — idle
-2. opencode (#67890) — streaming
-3. other-repo (#99999)
-
-Tap a button below, or use /use N.
-```
-
-```text
-/use 2
-→ ✅ Following: opencode (#67890)
-```
-
-`/use` accepts a 1-based index from `/list` or a substring of the id/label.
-Assistant messages are streamed only from the followed session. Status changes
-from other sessions still produce Telegram signals, so you can see when a
-different session starts or finishes work without switching to it.
-
-### Cleanup
-
-Socket file: `~/.pi/agent/extensions/pi-tools-suite/.run/telegram-mirror.sock`.
-
-If a pi crashes hard and leaves a stale socket, the next pi to start will
-unlink it automatically (bind fails → connect fails → unlink → retry).
-
-## Telegram → pix
-
-- Free text: forwarded to the followed pi session as a user message.
-- `/menu`: show inline project/session picker buttons.
-- `/list`: show all known pi sessions and mark followed.
-- `/use N` or `/use X`: follow by index, id, or label substring.
-- `/abort` or `/stop`: cancel current turn on followed session.
-- `/compact`: trigger context compaction on followed session.
-- `/status`: show idle / streaming state of followed session.
-- `/clear`: best-effort delete known bot messages from the chat.
-- `/say <msg>`: explicit send, for `/`-prefixed text.
-- `/disconnect`: stop the bot cluster-wide.
-- `/new`: not supported via extension API; run `/new` in pi.
-- `/help`: show command list.
-
-## Pix → Telegram
-
-The leader subscribes to pix streaming events (its own + followers' via IPC)
-and renders one Telegram message per agent turn — but only assistant-visible
-text from the followed session is streamed:
-
-- `message_update` (`text_delta`) → appended to the active message, edited
-  in place at ~1.2 s throttle (Telegram rate-limit friendly).
-- `agent_end` → final flush + `— done —` trailer.
-- `agent_start` / `agent_end` from any known session → compact status signal
-  such as `🟡 repo (#pid) is streaming` or `🟢 repo (#pid) is idle`.
-
-Tool calls, tool results, and thinking deltas are intentionally not mirrored
-to Telegram.
-
-Telegram does not expose a full private-chat history wipe API to bots. The
-`/clear` command therefore deletes the messages the bot knows about in this
-process, plus the `/clear` command message when Telegram allows it. Older
-messages from previous bot runs may remain.
-
-Messages are paginated at 4096 chars (Telegram's per-message limit).
-Markdown is converted to Telegram HTML with `**bold**`, `*italic*`,
-`` `code` ``, and fenced blocks.
-
-## Disable
-
-Either set `"enabled": false` in the `telegramMirror` block, remove the
-block entirely, or add `telegram-mirror` to the `disabledModules` array
-in the same config file, then `/reload` pi.
-
-## Known limitations
-
-- `/new` cannot start a fresh session from Telegram. The ExtensionAPI
-  exposes `newSession()` only on slash-command handler contexts, not on
-  event-handler contexts. Workaround: type `/new` in the pi TUI.
-- `pi.sendUserMessage` does not expand pi's own slash commands (calls
-  `prompt(..., { expandPromptTemplates: false })` internally), so text
-  starting with `/` is sent verbatim to the LLM. The module's own
-  `/abort`, `/compact`, `/list`, `/use`, etc. are intercepted before
-  `sendUserMessage` is called, so they work.
-- The leader uses long polling (35 s timeout) and keeps one outbound
-  request open. If your network blocks Telegram, you'll see repeating
-  `[telegram-mirror] polling: …` errors in stderr and the bot will back
-  off up to 60 s between retries.
-- On leader failover, the in-flight streaming output for the followed turn
-  is lost (the new leader's renderer starts empty). The followed session also
-  resets to the new leader; run `/use N` to switch back to a follower.
-- The cluster is single-host only (unix socket). To mirror across
-  machines, use separate bot tokens.
-- IPC events between session_start and leader-registration can be lost
-  for a brief window. Mid-stream output may be cut off.
-
-## Files
-
-- `index.ts`: module factory, activation command, role selection, lifecycle.
-- `bot.ts`: Telegram Bot API fetch client and long-poll loop.
-- `ipc.ts`: unix socket JSON-lines IPC and leader election.
-- `multiplexer.ts`: leader-side registry and active-instance routing.
-- `events.ts`: pix event to sink adapters and context capture.
-- `renderer.ts`: per-turn buffer, throttled edit, pagination.
-- `format.ts`: markdown to Telegram HTML and chunking.

package/external/pi-tools-suite/src/telegram-mirror/bot.ts

@@ -1,299 +0,0 @@
-/**
- * Minimal Telegram Bot API client.
- *
- * Uses native fetch (Node 18+ / Bun) and long polling via getUpdates.
- * No dependencies on grammY or node-telegram-bot-api.
- *
- * Provides:
- *   - sendMessage / editMessageText (HTML parse mode)
- *   - getUpdates long-poll loop with backoff
- *   - Auth gate by chat_id (single whitelist)
- *   - Graceful shutdown via AbortController
- */
-
-export interface TelegramUpdate {
-	update_id: number;
-	message?: TelegramIncomingMessage;
-	callback_query?: {
-		id: string;
-		from?: { id: number; first_name?: string; username?: string };
-		message?: TelegramIncomingMessage;
-		data?: string;
-	};
-}
-
-export interface TelegramIncomingMessage {
-	message_id: number;
-	date: number;
-	chat: { id: number; type: string };
-	from?: { id: number; first_name?: string; username?: string };
-	text?: string;
-}
-
-export interface TelegramMessage {
-	message_id: number;
-	chat: { id: number };
-	date: number;
-	text?: string;
-}
-
-export interface BotConfig {
-	token: string;
-	allowedChatId: number;
-	timeoutMs?: number;
-}
-
-export interface TelegramInlineKeyboardButton {
-	text: string;
-	callback_data?: string;
-	url?: string;
-}
-
-export interface TelegramReplyMarkup {
-	inline_keyboard: TelegramInlineKeyboardButton[][];
-}
-
-export interface TelegramBotCommand {
-	command: string;
-	description: string;
-}
-
-interface SendOptions {
-	parseMode?: "HTML" | "MarkdownV2" | "Markdown";
-	disablePreview?: boolean;
-	silent?: boolean;
-	replyToMessageId?: number;
-	replyMarkup?: TelegramReplyMarkup;
-}
-
-interface EditOptions {
-	parseMode?: "HTML" | "MarkdownV2" | "Markdown";
-	disablePreview?: boolean;
-	replyMarkup?: TelegramReplyMarkup;
-}
-
-export class TelegramBot {
-	private readonly baseUrl: string;
-	private readonly allowedChatId: number;
-	private readonly timeoutMs: number;
-	private readonly controller = new AbortController();
-	private readonly sentMessageIds = new Set<number>();
-	private polling = false;
-	private lastUpdateId = 0;
-	private consecutiveErrors = 0;
-
-	constructor(config: BotConfig) {
-		if (!config.token) throw new Error("TelegramBot: token is required");
-		this.baseUrl = `https://api.telegram.org/bot${config.token}`;
-		this.allowedChatId = config.allowedChatId;
-		this.timeoutMs = config.timeoutMs ?? 35_000;
-	}
-
-	get signal(): AbortSignal {
-		return this.controller.signal;
-	}
-
-	get chatId(): number {
-		return this.allowedChatId;
-	}
-
-	get sentIds(): readonly number[] {
-		return [...this.sentMessageIds];
-	}
-
-	forgetSentId(messageId: number): void {
-		this.sentMessageIds.delete(messageId);
-	}
-
-	isAllowedChat(chatId: number): boolean {
-		return chatId === this.allowedChatId;
-	}
-
-	async getMe(): Promise<{ ok: boolean; result?: { username: string; first_name: string } }> {
-		return this.requestJson("GET", "getMe", undefined);
-	}
-
-	async setMyCommands(commands: TelegramBotCommand[]): Promise<void> {
-		await this.requestJson("POST", "setMyCommands", { commands });
-	}
-
-	async sendMessage(text: string, options: SendOptions = {}): Promise<TelegramMessage | undefined> {
-		const payload = await this.requestJson<{ ok: boolean; result?: TelegramMessage }>("POST", "sendMessage", {
-			chat_id: this.allowedChatId,
-			text,
-			parse_mode: options.parseMode ?? "HTML",
-			disable_web_page_preview: options.disablePreview ?? true,
-			disable_notification: options.silent ?? false,
-			reply_markup: options.replyMarkup,
-			...(options.replyToMessageId ? { reply_to_message_id: options.replyToMessageId } : {}),
-		});
-		if (payload.result?.message_id) this.sentMessageIds.add(payload.result.message_id);
-		return payload.result;
-	}
-
-	async editMessageText(messageId: number, text: string, options: EditOptions = {}): Promise<TelegramMessage | undefined> {
-		try {
-			const payload = await this.requestJson<{ ok: boolean; result?: TelegramMessage }>("POST", "editMessageText", {
-				chat_id: this.allowedChatId,
-				message_id: messageId,
-				text,
-				parse_mode: options.parseMode ?? "HTML",
-				disable_web_page_preview: options.disablePreview ?? true,
-				reply_markup: options.replyMarkup,
-			});
-			return payload.result;
-		} catch (error) {
-			// Telegram returns 400 "message is not modified" if content is identical.
-			// Treat that as success; surface everything else.
-			const message = error instanceof Error ? error.message : String(error);
-			if (/not modified/i.test(message)) return undefined;
-			throw error;
-		}
-	}
-
-	async deleteMessage(messageId: number): Promise<void> {
-		try {
-			await this.requestJson("POST", "deleteMessage", {
-				chat_id: this.allowedChatId,
-				message_id: messageId,
-			});
-			this.sentMessageIds.delete(messageId);
-		} catch {
-			// best-effort
-		}
-	}
-
-	async deleteKnownMessages(extraMessageIds: readonly number[] = []): Promise<{ attempted: number; deleted: number }> {
-		const ids = [...new Set([...this.sentMessageIds, ...extraMessageIds])].sort((a, b) => b - a);
-		let deleted = 0;
-		for (const id of ids) {
-			const before = this.sentMessageIds.has(id);
-			await this.deleteMessage(id);
-			if (before && !this.sentMessageIds.has(id)) deleted += 1;
-		}
-		return { attempted: ids.length, deleted };
-	}
-
-	async answerCallbackQuery(callbackQueryId: string, text?: string): Promise<void> {
-		await this.requestJson("POST", "answerCallbackQuery", {
-			callback_query_id: callbackQueryId,
-			text,
-		});
-	}
-
-	/**
-	 * Start long-polling loop. The callback receives every update from the
-	 * allowed chat; updates from other chats are dropped silently.
-	 *
-	 * The loop exits cleanly when abort() is called.
-	 */
-	startPolling(onUpdate: (update: TelegramUpdate) => void | Promise<void>): void {
-		if (this.polling) return;
-		this.polling = true;
-		void this.pollLoop(onUpdate);
-	}
-
-	abort(): void {
-		if (this.controller.signal.aborted) return;
-		this.controller.abort();
-		this.polling = false;
-	}
-
-	private async pollLoop(onUpdate: (update: TelegramUpdate) => void | Promise<void>): Promise<void> {
-		while (this.polling && !this.controller.signal.aborted) {
-			try {
-				const payload = await this.requestJson<{
-					ok: boolean;
-					result?: TelegramUpdate[];
-				}>("POST", "getUpdates", {
-					offset: this.lastUpdateId > 0 ? this.lastUpdateId + 1 : undefined,
-					timeout: Math.floor(this.timeoutMs / 1000),
-					allowed_updates: ["message", "callback_query"],
-				});
-
-				this.consecutiveErrors = 0;
-
-				if (!payload?.ok || !Array.isArray(payload.result)) {
-					continue;
-				}
-
-				for (const update of payload.result) {
-					if (update.update_id > this.lastUpdateId) this.lastUpdateId = update.update_id;
-					const chatId = getUpdateChatId(update);
-					if (chatId === undefined) continue;
-					if (!this.isAllowedChat(chatId)) continue;
-					try {
-						await onUpdate(update);
-					} catch (handlerError) {
-						this.logError("onUpdate handler", handlerError);
-					}
-				}
-			} catch (error) {
-				if (this.controller.signal.aborted) break;
-				this.consecutiveErrors += 1;
-				this.logError("polling", error);
-				// Backoff: 1s → 60s capped
-				const backoff = Math.min(60_000, 1000 * 2 ** Math.min(5, this.consecutiveErrors - 1));
-				await sleep(backoff).catch(() => undefined);
-			}
-		}
-	}
-
-	private async requestJson<T>(method: "GET" | "POST", endpoint: string, body?: Record<string, unknown>): Promise<T> {
-		const url = `${this.baseUrl}/${endpoint}`;
-		const init: RequestInit = {
-			method,
-			signal: this.controller.signal,
-			headers: body ? { "Content-Type": "application/json" } : undefined,
-			body: body ? JSON.stringify(removeUndefined(body)) : undefined,
-		};
-
-		const response = await fetch(url, init);
-		const text = await response.text();
-		let parsed: unknown;
-		try {
-			parsed = text ? JSON.parse(text) : {};
-		} catch {
-			throw new Error(`Telegram API ${endpoint} returned invalid JSON: ${text.slice(0, 200)}`);
-		}
-
-		if (!response.ok || (isRecord(parsed) && parsed.ok === false)) {
-			const desc = isRecord(parsed) && typeof parsed.description === "string" ? parsed.description : text.slice(0, 200);
-			const errorCode = isRecord(parsed) && typeof parsed.error_code === "number" ? parsed.error_code : response.status;
-			throw new Error(`Telegram API ${endpoint} failed (${errorCode}): ${desc}`);
-		}
-
-		return parsed as T;
-	}
-
-	private logError(label: string, error: unknown): void {
-		const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-		// Use stderr so we don't pollute the TUI. Pi redirects stderr to its log.
-		// eslint-disable-next-line no-console
-		console.error(`[telegram-mirror] ${label}: ${message}`);
-	}
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function getUpdateChatId(update: TelegramUpdate): number | undefined {
-	// For callback_query Telegram may omit `message` or return an
-	// inaccessible message for older inline keyboards. In private chats the
-	// callback sender id is the chat id, so use it as a fallback; otherwise the
-	// auth gate silently drops button presses.
-	return update.message?.chat.id ?? update.callback_query?.message?.chat.id ?? update.callback_query?.from?.id;
-}
-
-function removeUndefined(value: Record<string, unknown>): Record<string, unknown> {
-	const out: Record<string, unknown> = {};
-	for (const [k, v] of Object.entries(value)) {
-		if (v !== undefined) out[k] = v;
-	}
-	return out;
-}
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/external/pi-tools-suite/src/telegram-mirror/events.ts

@@ -1,67 +0,0 @@
-/**
- * Pix event → TurnRenderer adapters.
- *
- * Keeps a per-turn renderer (one TG message chain per agent turn) and exposes
- * ExtensionAPI event handlers that append to it.
- */
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { RendererEvent, RendererInstance } from "./renderer.js";
-
-/**
- * Minimal sink for rendering events. The leader wires this to a Multiplexer
- * (which routes to a TurnRenderer for the active instance); a follower wires
- * it to an IPC socket so events travel to the leader.
- */
-export interface RendererSink {
-	push(event: RendererEvent): void;
-}
-
-export function registerPixEventHandlers(pi: ExtensionAPI, hooks: PixMirrorHooks): void {
-	let turnActive = false;
-
-	pi.on("agent_start", (_event, ctx) => {
-		if (turnActive) return;
-		turnActive = true;
-		hooks.getRenderer()?.push({ kind: "turn_start", instance: hooks.describeInstance(ctx as ExtensionContext | undefined) });
-	});
-
-	pi.on("message_update", (event) => {
-		const type = event?.assistantMessageEvent?.type;
-		if (type === "text_delta") {
-			const delta = (event.assistantMessageEvent as { delta?: string }).delta ?? "";
-			if (delta) hooks.getRenderer()?.push({ kind: "assistant_text", delta });
-			return;
-		}
-		// Ignore thinking and toolcall events. Telegram mirrors only the
-		// user-visible assistant answer, not internal reasoning/tools.
-	});
-
-	pi.on("agent_settled", () => {
-		if (!turnActive) return;
-		turnActive = false;
-		hooks.getRenderer()?.push({ kind: "turn_end", reason: "end" });
-		hooks.notifyAgentSettled();
-	});
-}
-
-export interface PixMirrorHooks {
-	getRenderer(): RendererSink | undefined;
-	describeInstance(ctx: ExtensionContext | undefined): RendererInstance | undefined;
-	notifyAgentSettled(): void;
-}
-
-export function captureAbortableContext(ctx: ExtensionContext | undefined, hooks: ContextCapture): void {
-	if (!ctx) return;
-	hooks.captureAbort(() => ctx.abort());
-	hooks.captureIdle(() => ctx.isIdle());
-	hooks.capturePending(() => ctx.hasPendingMessages());
-	hooks.captureCompact(() => ctx.compact());
-}
-
-export interface ContextCapture {
-	captureAbort(fn: () => void): void;
-	captureIdle(fn: () => boolean): void;
-	capturePending(fn: () => boolean): void;
-	captureCompact(fn: () => void): void;
-}