@agentconnect.md/daemon 1.0.0-rc.229 → 1.0.0-rc.230

package/dist/{run-foreground-D_XxYTap.js → run-foreground-Cg2ewYjn.js}

@@ -5728,6 +5728,17 @@ var LocalStore = class {
 	threadTranscript(channel, thread) {
 		return this.db.prepare("SELECT * FROM transcript WHERE channel = ? AND thread = ? ORDER BY seq ASC").all(channel, thread);
 	}
+	/**
+	* The session thread a Telegram message belongs to, recovered from the transcript
+	* (every conversational `text` row carries its platform message id in `ts`, and
+	* Telegram message ids are unique per chat). Backs reply-based session continuity:
+	* a human reply to a bot message (`reply_to_message.message_id`) resolves to the
+	* session that bot message was posted in. Undefined when the id was never recorded
+	* as text (e.g. a reply to transient chrome, or an unknown message).
+	*/
+	telegramThreadForMessage(channel, messageId) {
+		return this.db.prepare("SELECT thread FROM transcript WHERE channel = ? AND ts = ? AND kind = 'text' ORDER BY seq DESC LIMIT 1").get(channel, messageId)?.thread;
+	}
 	openSessionAgents(channel, thread) {
 		return this.db.prepare("SELECT agentId FROM sessions WHERE channel = ? AND thread = ? AND state != 'closed'").all(channel, thread).map((r) => r.agentId);
 	}
@@ -10151,23 +10162,26 @@ function routeRules(msg, rules, threadOwner, explicitAgentId) {
 }
 //#endregion
 //#region src/commands/commands.ts
-/** Accepted command prefixes (Slack uses `!`; `/` is for future platforms). */
+/** Accepted command prefixes (Slack uses `!`; `/` is the Telegram/Discord surface). */
 const COMMAND_PREFIXES = ["!", "/"];
 const STOP_WORDS = /* @__PURE__ */ new Set(["stop"]);
 const CANCEL_WORDS = /* @__PURE__ */ new Set(["cancel"]);
 const QUEUE_WORDS = /* @__PURE__ */ new Set(["queue"]);
+const STATUS_WORDS = /* @__PURE__ */ new Set(["status"]);
+const FAST_WORDS = /* @__PURE__ */ new Set(["fast"]);
 /**
 * Parse a leading control command from a message's text. Returns `null` when the
 * text is not a recognized command (so it flows to the agent unchanged). The
 * prefix must be the first non-whitespace character and be followed immediately by
 * a known command word, so ordinary text like `hello!` or `! note` is never a
-* command.
+* command. An optional `@botname` right after the word (Telegram group addressing)
+* is stripped before the argument is read.
 */
 function parseCommand(raw) {
 	const text = raw.trimStart();
 	const prefix = COMMAND_PREFIXES.find((p) => text.startsWith(p));
 	if (!prefix) return null;
-	const m = /^([a-zA-Z]+)([\s\S]*)$/.exec(text.slice(prefix.length));
+	const m = /^([a-zA-Z]+)(?:@[A-Za-z0-9_]+)?([\s\S]*)$/.exec(text.slice(prefix.length));
 	if (!m) return null;
 	const word = m[1].toLowerCase();
 	const arg = (m[2] ?? "").trim();
@@ -10177,6 +10191,14 @@ function parseCommand(raw) {
 		kind: "queue",
 		text: arg
 	};
+	if (STATUS_WORDS.has(word)) return { kind: "status" };
+	if (FAST_WORDS.has(word)) {
+		const a = arg.toLowerCase();
+		return {
+			kind: "fast",
+			enable: a === "on" ? true : a === "off" ? false : null
+		};
+	}
 	return null;
 }
 //#endregion
@@ -117339,15 +117361,16 @@ function photoToAttachment(sizes) {
 	};
 }
 /**
-* Which Telegram concept maps to a Slack "thread" (drives session keying):
-*   forum-topic message_thread_id → reply_to_message chain → channel-root (none).
-* Channel-root deliberately returns undefined so the whole chat is ONE session
-* (unlike Slack, whose own-ts fallback makes every top-level message its own
-* thread) — the intended Telegram continuity model.
+* The raw Telegram `message_thread_id` of a message, or undefined. This id means one of
+* two DIFFERENT things depending on `is_topic_message`:
+*   - in a forum supergroup (is_topic_message) it's the forum TOPIC id, and
+*   - in a plain supergroup it's the REPLY-THREAD ROOT (Telegram auto-threads replies).
+* Normalize splits these into `telegramTopicId` vs `telegramThreadRoot` because only the
+* forum-topic id may be sent back as `message_thread_id` when posting — a plain reply
+* thread is continued with `reply_parameters`, not `message_thread_id`.
 */
 function telegramThread(msg) {
-	if (msg.message_thread_id != null) return String(msg.message_thread_id);
-	if (msg.reply_to_message?.message_id != null) return String(msg.reply_to_message.message_id);
+	return msg.message_thread_id != null ? String(msg.message_thread_id) : void 0;
 }
 /** Distinct bot/user handles mentioned in a message — @usernames (without the '@')
 *  from `mention` entities, plus numeric ids from `text_mention` entities. The
@@ -117369,14 +117392,18 @@ function normalizeTelegramMessage(msg, ctx) {
 	if (photo) attachments.push(photo);
 	const doc = documentToAttachment(msg.document);
 	if (doc) attachments.push(doc);
-	const thread = telegramThread(msg);
+	const threadId = telegramThread(msg);
+	const isForumTopic = msg.is_topic_message === true;
+	const replyTo = msg.reply_to_message?.message_id != null ? String(msg.reply_to_message.message_id) : void 0;
 	return {
 		msgId: `telegram:${msg.chat.id}:${msg.message_id}`,
 		traceId: ctx.traceId,
 		source: "user",
 		platform: "telegram",
 		channel: String(msg.chat.id),
-		...thread !== void 0 ? { thread } : {},
+		...isForumTopic && threadId !== void 0 ? { telegramTopicId: threadId } : {},
+		...!isForumTopic && threadId !== void 0 ? { telegramThreadRoot: threadId } : {},
+		...replyTo !== void 0 ? { replyTo } : {},
 		sender: {
 			id: msg.from ? String(msg.from.id) : "unknown",
 			isBot: Boolean(msg.from?.is_bot)
@@ -117388,254 +117415,42 @@ function normalizeTelegramMessage(msg, ctx) {
 	};
 }
 //#endregion
-//#region src/telegram/render.ts
-/** Telegram single-message hard cap (4096 chars) — vs Slack's 12000-char block. */
-const TELEGRAM_MESSAGE_LIMIT = 4096;
-const MAX_LABEL = 100;
-const MAX_REASONING = 2800;
-const MAX_TOOL_OUTPUT = 2800;
-function clampTo(s, max) {
-	const t = s.trim();
-	return t.length > max ? `${t.slice(0, max - 1)}…` : t;
-}
-/** Escape the three characters Telegram's HTML parse_mode is sensitive to. */
-function escapeHtml(s) {
-	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-/** An HTML inline code span (monospace, verbatim). */
-function htmlCode(s) {
-	return `<code>${escapeHtml(s)}</code>`;
-}
-/** An HTML preformatted block (monospace, multi-line). */
-function htmlPre(s) {
-	return `<pre>${escapeHtml(s)}</pre>`;
-}
-/** Head-clamp a finished tool's output (kept under the message cap so the whole
-*  block posts as one message); head-kept since the start is usually most useful. */
-function capOutput(s) {
-	const t = s.trim();
-	return t.length > MAX_TOOL_OUTPUT ? `${t.slice(0, MAX_TOOL_OUTPUT - 1)}…` : t;
-}
-/** Pull human-readable output text out of an ACP tool_call/_update (content[] text
-*  blocks preferred; string rawOutput fallback). Mirrors slack/render's extractor. */
-function extractToolOutput(update) {
-	const content = update.content;
-	if (Array.isArray(content)) {
-		const parts = [];
-		for (const item of content) {
-			if (!item || typeof item !== "object") continue;
-			if (item.type !== "content") continue;
-			const block = item.content;
-			if (block?.type === "text" && block.text) parts.push(block.text);
-		}
-		if (parts.length) return parts.join("\n").trim();
-	}
-	return typeof update.rawOutput === "string" ? update.rawOutput.trim() : "";
-}
-function planIcon(status) {
-	if (status === "completed") return "✅";
-	if (status === "in_progress") return "⏳";
-	return "⬜";
-}
-/** Render an ACP plan (full entry list, resent each update) as a compact HTML summary. */
-function renderPlan(entries) {
-	return ["📋 <b>Plan</b>", ...entries.map((e) => `${planIcon(e.status)} ${escapeHtml(clampTo(e.content ?? "", MAX_LABEL))}`)].join("\n");
-}
-/** Render the accumulated reasoning trace (high mode) tail-clamped, as HTML. */
-function renderReasoning(buf) {
-	const trimmed = buf.trim();
-	return `💭 <b>Thinking</b>\n${escapeHtml(trimmed.length > MAX_REASONING ? `…${trimmed.slice(-2800)}` : trimmed)}`;
-}
-function compactCount(n) {
-	if (n < 1e3) return String(n);
-	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
-	return `${(n / 1e6).toFixed(1)}M`;
-}
-/** The compact status line (HTML), e.g. `📊 <b>opus-4.8</b> · fast · ctx 120k/200k (60%) · 45.2k tok`. */
-function renderStatusText(info) {
-	const parts = [];
-	if (info.model) parts.push(`<b>${escapeHtml(info.model)}</b>`);
-	if (info.fastMode) parts.push("fast");
-	if (info.contextUsed !== void 0 && info.contextSize !== void 0 && info.contextSize > 0) {
-		const pct = Math.round(info.contextUsed / info.contextSize * 100);
-		parts.push(`ctx ${compactCount(info.contextUsed)}/${compactCount(info.contextSize)} (${pct}%)`);
-	} else if (info.contextUsed !== void 0) parts.push(`ctx ${compactCount(info.contextUsed)}`);
-	if (info.totalTokens !== void 0) parts.push(`${compactCount(info.totalTokens)} tok`);
-	return `📊 ${parts.length ? parts.join(" · ") : "—"}`;
-}
-/** callback_data verbs for the status keyboard. Telegram caps callback_data at 64
-*  bytes and cannot fit a full session key, so the verb is stateless — the
-*  connection maps the message (chat+message_id) back to its session key. */
-const TG_CALLBACK = {
-	cancel: "ac_cancel",
-	fastOn: "ac_fast_on",
-	fastOff: "ac_fast_off"
-};
-/** Parse a status-keyboard callback_data verb into a status action (null if unknown). */
-function parseTelegramCallback(data) {
-	if (data === TG_CALLBACK.cancel) return { kind: "cancel" };
-	if (data === TG_CALLBACK.fastOn) return {
-		kind: "set-fast",
-		fastMode: true
-	};
-	if (data === TG_CALLBACK.fastOff) return {
-		kind: "set-fast",
-		fastMode: false
-	};
-	return null;
-}
+//#region src/telegram/connection.ts
 /**
-* Build the per-turn status inline keyboard: a Cancel button, an optional Fast
-* on/off toggle (when the model advertises one), and a View-session URL button
-* when a deep link is known. Model/effort selection isn't offered here — inline
-* keyboards can't do dropdowns; that's a future Mini-App. Pure — unit-testable.
+* §Telegram edge unit. Mirrors slack/connection.ts but over grammY long-polling
+* (getUpdates) — an OUTBOUND long-lived connection, so it works behind NAT just
+* like Slack Socket Mode. One connection per bot token.
+*
+* Control surface: unlike Slack (interactive status bar + modal), Telegram exposes
+* session state and controls via slash commands — `/status`, `/stop`, `/cancel`,
+* `/fast`, `/queue`, parsed by the daemon like any inbound text. start() registers
+* them with BotFather (setMyCommands) so they autocomplete in the Telegram UI.
 */
-function buildStatusKeyboard(info, link) {
-	const row = [{
-		text: "🛑 Cancel",
-		callback_data: TG_CALLBACK.cancel
-	}];
-	if (info.fastModeAvailable) row.push(info.fastMode ? {
-		text: "⚡ Fast: on",
-		callback_data: TG_CALLBACK.fastOff
-	} : {
-		text: "⚡ Fast: off",
-		callback_data: TG_CALLBACK.fastOn
-	});
-	if (link) row.push({
-		text: "🔗 View session",
-		url: link
-	});
-	return { inline_keyboard: [row] };
-}
-var TelegramConverger = class {
-	mode;
-	buf = "";
-	reasoningBuf = "";
-	reasoningDirty = false;
-	toolTitles = /* @__PURE__ */ new Map();
-	toolOutputs = /* @__PURE__ */ new Map();
-	emittedOutput = /* @__PURE__ */ new Set();
-	constructor(mode) {
-		this.mode = mode;
-	}
-	/** True while body text OR reasoning is pending — the daemon (re)arms the idle-flush timer on it. */
-	hasBuffered() {
-		return this.buf.trim().length > 0 || this.reasoningDirty;
-	}
-	/** Idle-timer flush: one in-place reasoning update (high) placed ABOVE the body, then the body. */
-	flushBuffered() {
-		return [...this.drainReasoning(), ...this.flush()];
-	}
-	drainReasoning() {
-		if (!this.reasoningDirty) return [];
-		this.reasoningDirty = false;
-		return [{
-			kind: "reasoning",
-			text: renderReasoning(this.reasoningBuf),
-			parseMode: "HTML"
-		}];
-	}
-	flush() {
-		const text = this.buf;
-		this.buf = "";
-		if (!text.trim()) return [];
-		return splitIntoSections(text, TELEGRAM_MESSAGE_LIMIT).map((t) => ({
-			kind: "post",
-			text: t
-		}));
-	}
-	toolLabel(update) {
-		const id = update.toolCallId;
-		if (update.title) {
-			if (id) this.toolTitles.set(id, update.title);
-			return update.title;
-		}
-		return (id && this.toolTitles.get(id)) ?? id ?? "tool";
-	}
-	drainToolOutput(update) {
-		const id = update.toolCallId;
-		if (!id) return [];
-		if (update.content !== void 0 || update.rawOutput !== void 0) {
-			const out = extractToolOutput(update);
-			if (out) this.toolOutputs.set(id, out);
-			else this.toolOutputs.delete(id);
-		}
-		if (!(update.status === "completed" || update.status === "failed") || this.emittedOutput.has(id)) return [];
-		const text = this.toolOutputs.get(id);
-		if (!text) return [];
-		this.emittedOutput.add(id);
-		this.toolOutputs.delete(id);
-		return [{
-			kind: "tool-output",
-			text: `${update.status === "failed" ? "❌" : "📄"}\n${htmlPre(capOutput(text))}`,
-			parseMode: "HTML"
-		}];
-	}
-	onUpdate(update) {
-		switch (update.sessionUpdate) {
-			case "agent_message_chunk": {
-				const content = update.content;
-				if (content?.type === "text") this.buf += content.text ?? "";
-				return [];
-			}
-			case "agent_thought_chunk":
-				if (this.mode === "high") {
-					const text = update.content?.text ?? "";
-					if (text) {
-						this.reasoningBuf += text;
-						if (this.reasoningBuf.length > MAX_REASONING * 2) this.reasoningBuf = this.reasoningBuf.slice(-2800 * 2);
-						this.reasoningDirty = true;
-					}
-				}
-				return [...this.flush(), { kind: "typing" }];
-			case "tool_call":
-			case "tool_call_update": {
-				const u = update;
-				const label = this.toolLabel(u);
-				if (this.mode === "low") return [...this.flush(), { kind: "typing" }];
-				const actions = [
-					...this.flush(),
-					{ kind: "typing" },
-					{
-						kind: "progress",
-						text: `🔨 ${htmlCode(label)}`,
-						parseMode: "HTML"
-					}
-				];
-				if (this.mode === "high") actions.push(...this.drainToolOutput(u));
-				return actions;
-			}
-			case "plan": {
-				const entries = update.entries ?? [];
-				if (this.mode === "low") return [...this.flush(), { kind: "typing" }];
-				return [...this.flush(), {
-					kind: "plan",
-					text: renderPlan(entries),
-					parseMode: "HTML"
-				}];
-			}
-			default: return [];
-		}
-	}
-	/** Turn end: flush remaining body; in medium/high append a done footer with the deep link. */
-	onFinal(link) {
-		if (this.mode === "low") return [...this.flush()];
-		const reasoning = this.drainReasoning();
-		const footer = link ? [{
-			kind: "notice",
-			text: `✅ done — <a href="${escapeHtml(link)}">details</a>`,
-			parseMode: "HTML"
-		}] : [];
-		return [
-			...reasoning,
-			...this.flush(),
-			...footer
-		];
+/** The bot commands advertised to Telegram (setMyCommands) so they autocomplete.
+*  The daemon parses the actual invocations (commands/commands.ts); this list is
+*  purely the client-side menu. */
+const BOT_COMMANDS = [
+	{
+		command: "status",
+		description: "Show session model, context, and token usage"
+	},
+	{
+		command: "stop",
+		description: "Stop the current turn and mute until you @mention me"
+	},
+	{
+		command: "cancel",
+		description: "Cancel the current turn (keep the session live)"
+	},
+	{
+		command: "fast",
+		description: "Toggle fast mode — /fast on | off"
+	},
+	{
+		command: "queue",
+		description: "Queue a message to run when idle — /queue <text>"
 	}
-};
-//#endregion
-//#region src/telegram/connection.ts
+];
 /** §6.1 analog: group integrations by bot token (one grammY Bot per token). */
 function consolidateTelegram(agents) {
 	const groups = /* @__PURE__ */ new Map();
@@ -117670,9 +117485,6 @@ function defaultFactory(token) {
 		onMessage(handler) {
 			bot.on("message", (ctx) => handler(ctx.message));
 		},
-		onCallbackQuery(handler) {
-			bot.on("callback_query:data", (ctx) => handler(ctx.callbackQuery));
-		},
 		start(onStart) {
 			bot.start(onStart ? { onStart: () => onStart() } : void 0);
 		},
@@ -117686,7 +117498,6 @@ var TelegramConnection = class {
 	deps;
 	bot;
 	queue;
-	statusKeys = /* @__PURE__ */ new Map();
 	/** The bot token this connection authenticated with (used to detect a swap). */
 	botToken;
 	/** The bot's numeric user id (as string), resolved at start() via getMe. */
@@ -117712,48 +117523,44 @@ var TelegramConnection = class {
 		log?.debug(`telegram: getMe ok → bot @${this.botUsername || "?"} (id ${this.botUserId || "n/a"})`);
 		this.bot.onMessage((message) => {
 			const msg = normalizeTelegramMessage(message, { traceId: this.deps.newTraceId() });
-			log?.debug(`telegram: inbound ch=${msg.channel} user=${msg.sender.id} isBot=${msg.sender.isBot} isDm=${msg.isDm} thread=${msg.thread ?? "-"} mentions=[${msg.mentionedBots.join(",")}] text=${JSON.stringify(msg.text.slice(0, 80))}`);
+			log?.debug(`telegram: inbound ch=${msg.channel} user=${msg.sender.id} isBot=${msg.sender.isBot} isDm=${msg.isDm} topic=${msg.telegramTopicId ?? "-"} root=${msg.telegramThreadRoot ?? "-"} replyTo=${msg.replyTo ?? "-"} mentions=[${msg.mentionedBots.join(",")}] text=${JSON.stringify(msg.text.slice(0, 80))}`);
 			this.deps.onMessage(msg);
 		});
-		this.bot.onCallbackQuery((q) => {
-			this.answerCallbackQuery(q.id);
-			const action = q.data ? parseTelegramCallback(q.data) : null;
-			if (!action || !q.message) return;
-			const sessionKey = this.statusKeys.get(`${q.message.chat.id}:${q.message.message_id}`);
-			if (!sessionKey) return;
-			if (action.kind === "cancel") this.deps.onStatusAction?.({
-				kind: "cancel",
-				sessionKey
-			});
-			else this.deps.onStatusAction?.({
-				kind: "set-fast",
-				sessionKey,
-				fastMode: action.fastMode
-			});
-		});
+		try {
+			await this.bot.api.setMyCommands(BOT_COMMANDS);
+			log?.debug("telegram: setMyCommands ok");
+		} catch (err) {
+			log?.debug(`telegram: setMyCommands failed: ${err.message}`);
+		}
 		log?.debug("telegram: bot.start → opening long-poll (getUpdates)…");
 		this.bot.start(() => log?.debug("telegram: long-poll established"));
 	}
 	/**
 	* Post a message. `threadTs` (when numeric) is treated as a forum-topic
-	* message_thread_id. Returns the resulting message id as a string.
-	*
-	* Stage 3: sent as plain text (no parse_mode). MarkdownV2 conversion + the
-	* serialized send-queue arrive with telegram/render.ts.
+	* message_thread_id — the daemon's reply-based session threads are non-numeric
+	* (`tg:<id>` / `dm`), so they correctly post to the chat root here. `replyTo`
+	* (a message id) threads the post as a reply, which is how the bot anchors its
+	* turn to the triggering message and keeps the reply chain intact. Returns the
+	* resulting message id as a string.
 	*/
-	async postMessage(channel, text, threadTs) {
+	async postMessage(channel, text, threadTs, replyTo) {
 		const thread = threadTs != null && /^\d+$/.test(threadTs) ? Number(threadTs) : void 0;
 		return this.queue.enqueue(async () => {
-			const res = await this.bot.api.sendMessage(channel, text, thread !== void 0 ? { message_thread_id: thread } : {});
+			const res = await this.bot.api.sendMessage(channel, text, {
+				...thread !== void 0 ? { message_thread_id: thread } : {},
+				...replyTo !== void 0 ? { reply_parameters: {
+					message_id: replyTo,
+					allow_sending_without_reply: true
+				} } : {}
+			});
 			return res?.message_id != null ? String(res.message_id) : void 0;
 		});
 	}
 	/**
-	* Post a "chrome" message (progress / plan / reasoning / tool-output / status bar)
-	* with an optional parse_mode + inline keyboard + forum topic. Returns the new
-	* message id for later in-place edits. When `sessionKey` is given (the status
-	* bar), the message is registered so its keyboard callbacks resolve back to the
-	* session. Best-effort: swallows send errors (chrome must never break a turn).
+	* Post a "chrome" message (progress / plan / reasoning / tool-output / a `/status`
+	* reply) with an optional parse_mode + forum topic + reply target. Returns the new
+	* message id for later in-place edits. Best-effort: swallows send errors (chrome
+	* must never break a turn).
 	*/
 	async postChrome(channel, text, opts = {}) {
 		const thread = opts.threadTs != null && /^\d+$/.test(opts.threadTs) ? Number(opts.threadTs) : void 0;
@@ -117762,11 +117569,12 @@ var TelegramConnection = class {
 				const res = await this.bot.api.sendMessage(channel, text, {
 					...thread !== void 0 ? { message_thread_id: thread } : {},
 					...opts.parseMode ? { parse_mode: opts.parseMode } : {},
-					...opts.keyboard ? { reply_markup: opts.keyboard } : {}
+					...opts.replyTo !== void 0 ? { reply_parameters: {
+						message_id: opts.replyTo,
+						allow_sending_without_reply: true
+					} } : {}
 				});
-				const id = res?.message_id != null ? String(res.message_id) : void 0;
-				if (id && opts.sessionKey) this.statusKeys.set(`${channel}:${id}`, opts.sessionKey);
-				return id;
+				return res?.message_id != null ? String(res.message_id) : void 0;
 			} catch (err) {
 				this.deps.log?.debug(`telegram: sendMessage (chrome) failed (ch=${channel}): ${err.message}`);
 				return;
@@ -117777,10 +117585,7 @@ var TelegramConnection = class {
 	async updateMessage(channel, messageId, text, opts = {}) {
 		await this.queue.enqueue(async () => {
 			try {
-				await this.bot.api.editMessageText(channel, Number(messageId), text, {
-					...opts.parseMode ? { parse_mode: opts.parseMode } : {},
-					...opts.keyboard ? { reply_markup: opts.keyboard } : {}
-				});
+				await this.bot.api.editMessageText(channel, Number(messageId), text, { ...opts.parseMode ? { parse_mode: opts.parseMode } : {} });
 			} catch (err) {
 				this.deps.log?.debug(`telegram: editMessageText failed (ch=${channel} id=${messageId}): ${err.message}`);
 			}
@@ -117795,14 +117600,6 @@ var TelegramConnection = class {
 			this.deps.log?.debug(`telegram: sendChatAction failed (ch=${channel}): ${err.message}`);
 		}
 	}
-	/** Ack a callback_query so Telegram stops showing the button spinner. Best-effort. */
-	async answerCallbackQuery(id, text) {
-		try {
-			await this.bot.api.answerCallbackQuery(id, text ? { text } : {});
-		} catch (err) {
-			this.deps.log?.debug(`telegram: answerCallbackQuery failed: ${err.message}`);
-		}
-	}
 	/**
 	* Download a Telegram file by its `file_id` (carried in Attachment.sourceUrl):
 	* getFile → file_path → GET https://api.telegram.org/file/bot<token>/<path>, up
@@ -117988,6 +117785,217 @@ var SlackNameResolver = class {
 	}
 };
 //#endregion
+//#region src/telegram/render.ts
+/** Telegram single-message hard cap (4096 chars) — vs Slack's 12000-char block. */
+const TELEGRAM_MESSAGE_LIMIT = 4096;
+const MAX_LABEL = 100;
+const MAX_REASONING = 2800;
+const MAX_TOOL_OUTPUT = 2800;
+function clampTo(s, max) {
+	const t = s.trim();
+	return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+/** Escape the three characters Telegram's HTML parse_mode is sensitive to. */
+function escapeHtml(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** An HTML inline code span (monospace, verbatim). */
+function htmlCode(s) {
+	return `<code>${escapeHtml(s)}</code>`;
+}
+/** An HTML preformatted block (monospace, multi-line). */
+function htmlPre(s) {
+	return `<pre>${escapeHtml(s)}</pre>`;
+}
+/** Head-clamp a finished tool's output (kept under the message cap so the whole
+*  block posts as one message); head-kept since the start is usually most useful. */
+function capOutput(s) {
+	const t = s.trim();
+	return t.length > MAX_TOOL_OUTPUT ? `${t.slice(0, MAX_TOOL_OUTPUT - 1)}…` : t;
+}
+/** Pull human-readable output text out of an ACP tool_call/_update (content[] text
+*  blocks preferred; string rawOutput fallback). Mirrors slack/render's extractor. */
+function extractToolOutput(update) {
+	const content = update.content;
+	if (Array.isArray(content)) {
+		const parts = [];
+		for (const item of content) {
+			if (!item || typeof item !== "object") continue;
+			if (item.type !== "content") continue;
+			const block = item.content;
+			if (block?.type === "text" && block.text) parts.push(block.text);
+		}
+		if (parts.length) return parts.join("\n").trim();
+	}
+	return typeof update.rawOutput === "string" ? update.rawOutput.trim() : "";
+}
+function planIcon(status) {
+	if (status === "completed") return "✅";
+	if (status === "in_progress") return "⏳";
+	return "⬜";
+}
+/** Render an ACP plan (full entry list, resent each update) as a compact HTML summary. */
+function renderPlan(entries) {
+	return ["📋 <b>Plan</b>", ...entries.map((e) => `${planIcon(e.status)} ${escapeHtml(clampTo(e.content ?? "", MAX_LABEL))}`)].join("\n");
+}
+/** Render the accumulated reasoning trace (high mode) tail-clamped, as HTML. */
+function renderReasoning(buf) {
+	const trimmed = buf.trim();
+	return `💭 <b>Thinking</b>\n${escapeHtml(trimmed.length > MAX_REASONING ? `…${trimmed.slice(-2800)}` : trimmed)}`;
+}
+function compactCount(n) {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+}
+/** The compact status line (HTML), e.g. `📊 <b>opus-4.8</b> · fast · ctx 120k/200k (60%) · 45.2k tok`. */
+function renderStatusText(info) {
+	const parts = [];
+	if (info.model) parts.push(`<b>${escapeHtml(info.model)}</b>`);
+	if (info.fastMode) parts.push("fast");
+	if (info.contextUsed !== void 0 && info.contextSize !== void 0 && info.contextSize > 0) {
+		const pct = Math.round(info.contextUsed / info.contextSize * 100);
+		parts.push(`ctx ${compactCount(info.contextUsed)}/${compactCount(info.contextSize)} (${pct}%)`);
+	} else if (info.contextUsed !== void 0) parts.push(`ctx ${compactCount(info.contextUsed)}`);
+	if (info.totalTokens !== void 0) parts.push(`${compactCount(info.totalTokens)} tok`);
+	return `📊 ${parts.length ? parts.join(" · ") : "—"}`;
+}
+/**
+* The `/status` command reply (HTML): the compact status line, plus a View-session
+* link line when a deep link is known. Sent as Telegram chrome (parse_mode HTML),
+* so the link renders as a tappable anchor. Pure — unit-testable.
+*/
+function renderStatusReply(info, link) {
+	const line = renderStatusText(info);
+	return link ? `${line}\n🔗 <a href="${escapeHtml(link)}">View session</a>` : line;
+}
+var TelegramConverger = class {
+	mode;
+	buf = "";
+	reasoningBuf = "";
+	reasoningDirty = false;
+	toolTitles = /* @__PURE__ */ new Map();
+	toolOutputs = /* @__PURE__ */ new Map();
+	emittedOutput = /* @__PURE__ */ new Set();
+	constructor(mode) {
+		this.mode = mode;
+	}
+	/** True while body text OR reasoning is pending — the daemon (re)arms the idle-flush timer on it. */
+	hasBuffered() {
+		return this.buf.trim().length > 0 || this.reasoningDirty;
+	}
+	/** Idle-timer flush: one in-place reasoning update (high) placed ABOVE the body, then the body. */
+	flushBuffered() {
+		return [...this.drainReasoning(), ...this.flush()];
+	}
+	drainReasoning() {
+		if (!this.reasoningDirty) return [];
+		this.reasoningDirty = false;
+		return [{
+			kind: "reasoning",
+			text: renderReasoning(this.reasoningBuf),
+			parseMode: "HTML"
+		}];
+	}
+	flush() {
+		const text = this.buf;
+		this.buf = "";
+		if (!text.trim()) return [];
+		return splitIntoSections(text, TELEGRAM_MESSAGE_LIMIT).map((t) => ({
+			kind: "post",
+			text: t
+		}));
+	}
+	toolLabel(update) {
+		const id = update.toolCallId;
+		if (update.title) {
+			if (id) this.toolTitles.set(id, update.title);
+			return update.title;
+		}
+		return (id && this.toolTitles.get(id)) ?? id ?? "tool";
+	}
+	drainToolOutput(update) {
+		const id = update.toolCallId;
+		if (!id) return [];
+		if (update.content !== void 0 || update.rawOutput !== void 0) {
+			const out = extractToolOutput(update);
+			if (out) this.toolOutputs.set(id, out);
+			else this.toolOutputs.delete(id);
+		}
+		if (!(update.status === "completed" || update.status === "failed") || this.emittedOutput.has(id)) return [];
+		const text = this.toolOutputs.get(id);
+		if (!text) return [];
+		this.emittedOutput.add(id);
+		this.toolOutputs.delete(id);
+		return [{
+			kind: "tool-output",
+			text: `${update.status === "failed" ? "❌" : "📄"}\n${htmlPre(capOutput(text))}`,
+			parseMode: "HTML"
+		}];
+	}
+	onUpdate(update) {
+		switch (update.sessionUpdate) {
+			case "agent_message_chunk": {
+				const content = update.content;
+				if (content?.type === "text") this.buf += content.text ?? "";
+				return [];
+			}
+			case "agent_thought_chunk":
+				if (this.mode === "high") {
+					const text = update.content?.text ?? "";
+					if (text) {
+						this.reasoningBuf += text;
+						if (this.reasoningBuf.length > MAX_REASONING * 2) this.reasoningBuf = this.reasoningBuf.slice(-2800 * 2);
+						this.reasoningDirty = true;
+					}
+				}
+				return [...this.flush(), { kind: "typing" }];
+			case "tool_call":
+			case "tool_call_update": {
+				const u = update;
+				const label = this.toolLabel(u);
+				if (this.mode === "low") return [...this.flush(), { kind: "typing" }];
+				const actions = [
+					...this.flush(),
+					{ kind: "typing" },
+					{
+						kind: "progress",
+						text: `🔨 ${htmlCode(label)}`,
+						parseMode: "HTML"
+					}
+				];
+				if (this.mode === "high") actions.push(...this.drainToolOutput(u));
+				return actions;
+			}
+			case "plan": {
+				const entries = update.entries ?? [];
+				if (this.mode === "low") return [...this.flush(), { kind: "typing" }];
+				return [...this.flush(), {
+					kind: "plan",
+					text: renderPlan(entries),
+					parseMode: "HTML"
+				}];
+			}
+			default: return [];
+		}
+	}
+	/** Turn end: flush remaining body; in medium/high append a done footer with the deep link. */
+	onFinal(link) {
+		if (this.mode === "low") return [...this.flush()];
+		const reasoning = this.drainReasoning();
+		const footer = link ? [{
+			kind: "notice",
+			text: `✅ done — <a href="${escapeHtml(link)}">details</a>`,
+			parseMode: "HTML"
+		}] : [];
+		return [
+			...reasoning,
+			...this.flush(),
+			...footer
+		];
+	}
+};
+//#endregion
 //#region ../../node_modules/.pnpm/croner@10.0.1/node_modules/croner/dist/croner.js
 function T(s) {
 	return Date.UTC(s.y, s.m - 1, s.d, s.h, s.i, s.s);
@@ -136793,7 +136801,6 @@ var Daemon = class Daemon {
 				group,
 				newTraceId: () => randomUUID(),
 				onMessage: (msg) => this.onInbound(msg),
-				onStatusAction: (a) => this.handleStatusAction(a),
 				log: this.log
 			});
 			try {
@@ -136918,6 +136925,59 @@ var Daemon = class Daemon {
 		this.hosts.set(agentId, host);
 		return host;
 	}
+	/** The bare Telegram message id from a normalized `telegram:<chatId>:<messageId>`
+	*  msgId (the last segment; chat ids may be negative, so split, don't parse). */
+	telegramMessageId(msg) {
+		const parts = msg.msgId.split(":");
+		return parts[parts.length - 1] ?? "";
+	}
+	/**
+	* Resolve the session thread for a Telegram message and set it on `msg.thread` in
+	* place (normalize leaves it unset for Telegram). Ladder:
+	*   - forum topic       → the topic id (a real native thread; numeric, so it also
+	*                          drives the post's `message_thread_id`)
+	*   - native reply-root → `tg:<root>` from Telegram's own `message_thread_id` in a
+	*                          plain supergroup (Telegram auto-threads replies to the root)
+	*   - DM                → one continuous session per chat (`dm`)
+	*   - reply that maps   → the session the replied-to message belongs to, resolved from
+	*                          the transcript (basic groups carry no `message_thread_id`)
+	*   - otherwise         → a fresh session rooted at this message (`tg:<msgId>`) — a new
+	*                          @mention, or a reply we can't place
+	* A fresh @mention (message N, no thread root) keys `tg:N`; every later reply in that
+	* thread carries `message_thread_id = N`, so it keys `tg:N` too — the two meet with no
+	* lookup. The non-topic keys are deliberately NON-numeric so posting never mistakes
+	* them for a forum `message_thread_id` (see TelegramConnection.postMessage). No-op for
+	* other platforms or when the thread is already set.
+	*/
+	canonicalizeTelegramThread(msg) {
+		if (msg.platform !== "telegram" || msg.thread !== void 0) return;
+		if (msg.telegramTopicId !== void 0) {
+			msg.thread = msg.telegramTopicId;
+			return;
+		}
+		if (msg.telegramThreadRoot !== void 0) {
+			msg.thread = `tg:${msg.telegramThreadRoot}`;
+			return;
+		}
+		if (msg.isDm) {
+			msg.thread = "dm";
+			return;
+		}
+		if (msg.replyTo) {
+			msg.thread = this.store.telegramThreadForMessage(msg.channel, msg.replyTo) ?? `tg:${msg.replyTo}`;
+			return;
+		}
+		msg.thread = `tg:${this.telegramMessageId(msg)}`;
+	}
+	/** Telegram reply target for a turn/command triggered by `msg`: the triggering
+	*  message's own id, so the bot's posts reply to it (req: reply to the last message
+	*  in the session, and keep the reply chain resolvable). Undefined off Telegram or
+	*  when the id can't be recovered as a positive integer. */
+	telegramReplyTarget(msg) {
+		if (msg.platform !== "telegram") return void 0;
+		const n = Number(this.telegramMessageId(msg));
+		return Number.isInteger(n) && n > 0 ? n : void 0;
+	}
 	seenMsgIds = /* @__PURE__ */ new Set();
 	onInbound(msg) {
 		if (this.draining) {
@@ -136934,6 +136994,7 @@ var Daemon = class Daemon {
 			this.log.debug(`routing: dropping own bot echo ${msg.msgId}`);
 			return;
 		}
+		this.canonicalizeTelegramThread(msg);
 		const command = parseCommand(msg.text);
 		if (command) {
 			this.handleCommand(command, msg);
@@ -137236,28 +137297,62 @@ var Daemon = class Daemon {
 		const rec = this.store.getSession(key);
 		const acpSessionId = rec?.acpSessionId;
 		const inflight = !!(acpSessionId && this.pending.has(acpSessionId));
+		const tgReplyTo = this.telegramReplyTarget(msg);
+		const reply = (text) => {
+			if (!conn) return;
+			if (msg.platform === "telegram") conn.postMessage(msg.channel, text, thread, tgReplyTo);
+			else conn.postMessage(msg.channel, text, thread);
+		};
 		if (command.kind === "stop") {
 			if (rec) this.store.setSessionMuted(key, true);
 			const muteNote = "Muted in this thread — @mention me to resume.";
 			if (!inflight) {
-				conn?.postMessage(msg.channel, rec ? `🔇 Nothing is running. ${muteNote}` : "Nothing is running to stop.", thread);
+				reply(rec ? `🔇 Nothing is running. ${muteNote}` : "Nothing is running to stop.");
 				return;
 			}
 			this.interruptTurn(target.agentId, acpSessionId, key, "stop");
-			conn?.postMessage(msg.channel, `🛑 Stopped. ${muteNote}`, thread);
+			reply(`🛑 Stopped. ${muteNote}`);
 			return;
 		}
 		if (command.kind === "cancel") {
 			if (!inflight) {
-				conn?.postMessage(msg.channel, "Nothing is running to cancel.", thread);
+				reply("Nothing is running to cancel.");
 				return;
 			}
 			this.interruptTurn(target.agentId, acpSessionId, key, "cancel");
-			conn?.postMessage(msg.channel, "🛑 Cancelled.", thread);
+			reply("🛑 Cancelled.");
+			return;
+		}
+		if (command.kind === "status") {
+			if (!rec) {
+				reply("No active session here yet — send me a message to start one.");
+				return;
+			}
+			const info = this.statusInfoFrom(target.agentId, key, acpSessionId ?? void 0);
+			const link = acpSessionId ? this.sessionLink(acpSessionId) : void 0;
+			if (msg.platform === "telegram") conn?.postChrome(msg.channel, renderStatusReply(info, link), {
+				parseMode: "HTML",
+				threadTs: thread,
+				replyTo: tgReplyTo
+			});
+			else reply(link ? `${renderStatusBar(info)}  ·  <${link}|View session>` : renderStatusBar(info));
+			return;
+		}
+		if (command.kind === "fast") {
+			if (!rec) {
+				reply("No active session here to configure.");
+				return;
+			}
+			if (command.enable === null) {
+				reply("Usage: `/fast on` or `/fast off`.");
+				return;
+			}
+			this.setFastByKey(key, command.enable);
+			reply(command.enable ? "⚡ Fast mode on." : "🐢 Fast mode off.");
 			return;
 		}
 		if (!command.text) {
-			conn?.postMessage(msg.channel, "Usage: `!queue <message>` — runs when the current turn finishes.", thread);
+			reply("Usage: `!queue <message>` — runs when the current turn finishes.");
 			return;
 		}
 		const payload = {
@@ -137272,13 +137367,13 @@ var Daemon = class Daemon {
 		const q = this.queued.get(acpSessionId) ?? [];
 		if (q.length >= MAX_QUEUED_PER_SESSION) {
 			this.log.warn(`command: queue → agent "${target.agentId}" session ${acpSessionId} full (${q.length}), rejected`);
-			conn?.postMessage(msg.channel, `Queue is full (${MAX_QUEUED_PER_SESSION} pending) — wait for the current turn to finish.`, thread);
+			reply(`Queue is full (${MAX_QUEUED_PER_SESSION} pending) — wait for the current turn to finish.`);
 			return;
 		}
 		q.push(payload);
 		this.queued.set(acpSessionId, q);
 		this.log.info(`command: queue → agent "${target.agentId}" session ${acpSessionId} (depth ${q.length})`);
-		conn?.postMessage(msg.channel, `📥 Queued (#${q.length}) — will run when the current turn finishes.`, thread);
+		reply(`📥 Queued (#${q.length}) — will run when the current turn finishes.`);
 	}
 	/** Drain one buffered message for a session whose turn just finished (FIFO). */
 	flushQueued(agentId, sessionId, integrationId) {
@@ -137387,6 +137482,7 @@ var Daemon = class Daemon {
 			acpSessionId: sessionId,
 			channel: msg.channel,
 			thread: msg.thread,
+			...this.telegramReplyTarget(msg) !== void 0 ? { tgReplyTo: this.telegramReplyTarget(msg) } : {},
 			statusThread,
 			conn: replyConn,
 			applyChain: Promise.resolve(),
@@ -137595,7 +137691,6 @@ var Daemon = class Daemon {
 	*  - notice / tool-output → posted (HTML) but NOT recorded (chrome).
 	*  - typing      → a transient chat-action ("typing…").
 	*  - progress / plan / reasoning → the single in-place message of that kind.
-	*  - status-bar  → the per-turn status line + inline keyboard (Cancel / Fast / View).
 	*/
 	async applyTelegramAction(p, action) {
 		const conn = p.conn;
@@ -137605,7 +137700,7 @@ var Daemon = class Daemon {
 				await conn.sendChatAction(p.channel);
 				return;
 			case "post": {
-				const id = await conn.postMessage(p.channel, action.text, p.thread);
+				const id = await conn.postMessage(p.channel, action.text, p.thread, p.tgReplyTo);
 				this.store.appendTranscript({
 					channel: p.channel,
 					thread: p.statusThread,
@@ -137620,7 +137715,8 @@ var Daemon = class Daemon {
 			case "tool-output":
 				await conn.postChrome(p.channel, action.text, {
 					parseMode: action.parseMode,
-					threadTs: p.thread
+					threadTs: p.thread,
+					replyTo: p.tgReplyTo
 				});
 				return;
 			case "progress":
@@ -137629,7 +137725,8 @@ var Daemon = class Daemon {
 					p.progressAttempted = true;
 					p.progressTs = await conn.postChrome(p.channel, action.text, {
 						parseMode: action.parseMode,
-						threadTs: p.thread
+						threadTs: p.thread,
+						replyTo: p.tgReplyTo
 					});
 				}
 				return;
@@ -137639,7 +137736,8 @@ var Daemon = class Daemon {
 					p.planAttempted = true;
 					p.planTs = await conn.postChrome(p.channel, action.text, {
 						parseMode: action.parseMode,
-						threadTs: p.thread
+						threadTs: p.thread,
+						replyTo: p.tgReplyTo
 					});
 				}
 				return;
@@ -137648,23 +137746,9 @@ var Daemon = class Daemon {
 				else if (!p.reasoningAttempted) {
 					p.reasoningAttempted = true;
 					p.reasoningTs = await conn.postChrome(p.channel, action.text, {
-						parseMode: action.parseMode,
-						threadTs: p.thread
-					});
-				}
-				return;
-			case "status-bar":
-				if (p.statusBarTs) await conn.updateMessage(p.channel, p.statusBarTs, action.text, {
-					parseMode: action.parseMode,
-					keyboard: action.keyboard
-				});
-				else if (!p.statusBarAttempted) {
-					p.statusBarAttempted = true;
-					p.statusBarTs = await conn.postChrome(p.channel, action.text, {
 						parseMode: action.parseMode,
 						threadTs: p.thread,
-						keyboard: action.keyboard,
-						sessionKey: p.sessionKey
+						replyTo: p.tgReplyTo
 					});
 				}
 				return;
@@ -137803,8 +137887,9 @@ var Daemon = class Daemon {
 	/** Emit/refresh the session's status bar (model / context / tokens / cost). Called at
 	*  turn start (model + carried-over usage), on each `usage_update` (live context/cost),
 	*  and at turn end (token totals). Deduped against the last snapshot so an unchanged
-	*  update is a no-op. Webchat rides a status-only `webchat/output` frame; every other
-	*  (Slack / headless) target gets the in-place `status-bar` action — headless no-ops in
+	*  update is a no-op. Webchat rides a status-only `webchat/output` frame; Slack gets
+	*  the in-place `status-bar` action. Telegram has NO status bar — state is queried on
+	*  demand via `/status` (see handleCommand) — so it's skipped here. Headless no-ops in
 	*  applyAction (no connection), which is fine. */
 	emitStatusBar(p) {
 		const info = this.buildStatusInfo(p);
@@ -137820,16 +137905,11 @@ var Daemon = class Daemon {
 				index: wc.index++,
 				status: info
 			});
-		} else {
+		} else if (p.platform === "telegram") p.lastStatusBar = key;
+		else {
 			p.lastStatusBar = key;
 			const link = this.sessionLink(p.acpSessionId);
-			if (p.platform === "telegram") this.enqueueApply(p, {
-				kind: "status-bar",
-				text: renderStatusText(info),
-				parseMode: "HTML",
-				keyboard: buildStatusKeyboard(info, link)
-			});
-			else this.enqueueApply(p, {
+			this.enqueueApply(p, {
 				kind: "status-bar",
 				text: renderStatusBar(info),
 				blocks: buildStatusBlocks(info, p.sessionKey, link)
@@ -138557,4 +138637,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as n, runForeground as t };
 
-//# sourceMappingURL=run-foreground-D_XxYTap.js.map
+//# sourceMappingURL=run-foreground-Cg2ewYjn.js.map