@sayknow-cli/coding-agent 0.3.7 → 0.3.9

package/src/notifications/telegram-daemon.ts

@@ -8,8 +8,8 @@ import { withFileLock } from "../config/file-lock";
 import type { Settings } from "../config/settings";
 import type { DaemonRuntimeInfo } from "../daemon/control-types";
 import { resolveSkcRuntimeSpawnInfo } from "../daemon/runtime";
-import { getNotificationConfig, isGloballyConfigured, tokenFingerprint } from "./config";
-import { parseInThreadConfigCommand } from "./config-commands";
+import { getNotificationConfig, isTelegramConfigured, tokenFingerprint } from "./config";
+import { parseInThreadConfigCommand, parseRichToggleCommand } from "./config-commands";
 import { daemonPaths } from "./daemon-paths";
 import {
 	buildCompactChoiceGrid,
@@ -27,6 +27,7 @@ import type {
 } from "./index";
 import {
 	formatLifecycleOutcome,
+	isLifecycleCommandLikeText,
 	isLifecycleCommandText,
 	lifecycleUsage,
 	parseLifecycleCommand,
@@ -43,12 +44,15 @@ import {
 import { NotificationOperatorRuntime, OperatorBackoffPolicy, OperatorEventRouter } from "./operator-runtime";
 import { RateLimitPool } from "./rate-limit-pool";
 import { listRecentSessions } from "./recent-activity";
+import { ReplySentStore } from "./reply-sent-store";
+import { DraftStreamState, deliverDraft, shouldStreamDraft } from "./rich-draft";
+import { deliverRichActionWithFallback, deliverRichWithFallback, shouldPromoteRich } from "./rich-render";
 import {
 	type AliasTable,
+	buildActionMarkdown,
 	buildActionMessage,
 	type CallbackRoute,
 	createAliasTable,
-	type PendingAsk,
 	readEndpoint,
 	routeInboundUpdate,
 } from "./telegram-reference";
@@ -56,7 +60,7 @@ import { decideThreadedInbound, type InboundAttachment } from "./threaded-inboun
 import { renderThreadedFrame, type ThreadedSend } from "./threaded-render";
 import { TopicRegistry, type TopicRegistryState } from "./topic-registry";
 
-export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled";
+export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
 
 export interface DaemonState {
 	pid: number;
@@ -126,6 +130,7 @@ const TYPING_REFRESH_INTERVAL_MS = 4_000;
 // messages: queued on receipt, consumed once a turn picks the message up.
 const QUEUED_REACTION = "👀";
 const PENDING_TOPIC_FRAME_LIMIT = 20;
+const SEEN_UPDATE_ID_LIMIT = 1_000;
 const CONSUMED_REACTION = "✅";
 
 function splitTelegramPlainText(text: string, max = TELEGRAM_MESSAGE_LIMIT): string[] {
@@ -267,7 +272,7 @@ export async function registerNotificationRoot(input: {
 	const fsImpl = input.fs ?? nodeFs;
 	const paths = daemonPaths(input.settings.getAgentDir());
 	await ensureDir(fsImpl, paths.dir);
-	const root = path.join(input.cwd, ".skc", "state");
+	const root = notificationRootForCwd(input.cwd);
 	await withFileLock(
 		paths.roots,
 		async () => {
@@ -286,6 +291,29 @@ export async function registerNotificationRoot(input: {
 	return root;
 }
 
+function notificationRootForCwd(cwd: string): string {
+	return path.join(cwd, ".skc", "state");
+}
+
+function ownerIdentityMatches(state: DaemonState, tokenFingerprint: string, chatId: string): boolean {
+	return state.tokenFingerprint === tokenFingerprint && state.chatId === chatId;
+}
+
+function liveOwnerUsesDifferentIdentity(input: {
+	state: DaemonState | undefined;
+	tokenFingerprint: string;
+	chatId: string;
+	pidAlive: (pid: number) => boolean;
+}): boolean {
+	const { state } = input;
+	return Boolean(
+		state &&
+			state.version === DAEMON_VERSION &&
+			!ownerIdentityMatches(state, input.tokenFingerprint, input.chatId) &&
+			input.pidAlive(state.pid),
+	);
+}
+
 export function isFreshLiveOwner(input: {
 	state: DaemonState | undefined;
 	now: number;
@@ -297,8 +325,7 @@ export function isFreshLiveOwner(input: {
 	return Boolean(
 		state &&
 			state.version === DAEMON_VERSION &&
-			state.tokenFingerprint === input.tokenFingerprint &&
-			state.chatId === input.chatId &&
+			ownerIdentityMatches(state, input.tokenFingerprint, input.chatId) &&
 			input.now - state.heartbeatAt <= HEARTBEAT_TTL_MS &&
 			input.pidAlive(state.pid),
 	);
@@ -314,7 +341,13 @@ export async function acquireDaemonOwnership(input: {
 	pid?: number;
 	pidAlive?: (pid: number) => boolean;
 	randomId?: () => string;
-}): Promise<{ acquired: boolean; ownerId?: string; attached?: boolean }> {
+}): Promise<{
+	acquired: boolean;
+	ownerId?: string;
+	attached?: boolean;
+	blocked?: boolean;
+	reason?: "identity_mismatch";
+}> {
 	const fsImpl = input.fs ?? nodeFs;
 	const now = input.now ?? Date.now;
 	const pid = input.pid ?? process.pid;
@@ -324,6 +357,16 @@ export async function acquireDaemonOwnership(input: {
 	const ownerId = input.randomId?.() ?? `${pid}-${now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 	const roots = input.roots ?? (await readJson<{ roots?: string[] }>(fsImpl, paths.roots))?.roots ?? [];
 	const existing = await readJson<DaemonState>(fsImpl, paths.state);
+	if (
+		liveOwnerUsesDifferentIdentity({
+			state: existing,
+			tokenFingerprint: input.tokenFingerprint,
+			chatId: input.chatId,
+			pidAlive,
+		})
+	) {
+		return { acquired: false, blocked: true, reason: "identity_mismatch" };
+	}
 	if (
 		isFreshLiveOwner({
 			state: existing,
@@ -349,6 +392,16 @@ export async function acquireDaemonOwnership(input: {
 		return { acquired: true, ownerId };
 	}
 	const afterLock = await readJson<DaemonState>(fsImpl, paths.state);
+	if (
+		liveOwnerUsesDifferentIdentity({
+			state: afterLock,
+			tokenFingerprint: input.tokenFingerprint,
+			chatId: input.chatId,
+			pidAlive,
+		})
+	) {
+		return { acquired: false, blocked: true, reason: "identity_mismatch" };
+	}
 	if (
 		isFreshLiveOwner({
 			state: afterLock,
@@ -375,6 +428,16 @@ export async function acquireDaemonOwnership(input: {
 		) {
 			return { acquired: false, attached: true };
 		}
+		if (
+			liveOwnerUsesDifferentIdentity({
+				state: rechecked,
+				tokenFingerprint: input.tokenFingerprint,
+				chatId: input.chatId,
+				pidAlive,
+			})
+		) {
+			return { acquired: false, blocked: true, reason: "identity_mismatch" };
+		}
 		if (rechecked && pidAlive(rechecked.pid)) {
 			return { acquired: false, attached: true };
 		}
@@ -552,7 +615,16 @@ export async function spawnTelegramDaemonOwner(
 		ownerId: ownership.ownerId ?? "",
 		agentDir,
 	});
-	if (!ownership.acquired) return { result: "attached", runtime, warnings: [] };
+	if (!ownership.acquired) {
+		if (ownership.blocked) {
+			return {
+				result: "blocked",
+				runtime,
+				warnings: ["live telegram daemon uses a different bot token or chat; refusing to attach"],
+			};
+		}
+		return { result: "attached", runtime, warnings: [] };
+	}
 	const spawnImpl = deps.spawn ?? defaultDaemonSpawn;
 	const child = spawnImpl(command, args, {
 		detached: true,
@@ -568,13 +640,18 @@ export async function ensureTelegramDaemonRunning(
 	deps: TelegramDaemonDeps = {},
 ): Promise<EnsureDaemonResult> {
 	const cfg = getNotificationConfig(input.settings);
-	if (!isGloballyConfigured(cfg) || !cfg.botToken || !cfg.chatId) return "disabled";
-	const root = await registerNotificationRoot({ ...input, fs: deps.fs });
+	if (!isTelegramConfigured(cfg)) return "disabled";
+	const root = notificationRootForCwd(input.cwd);
 	const fp = tokenFingerprint(cfg.botToken);
 	const spawned = await spawnTelegramDaemonOwner(
 		{ settings: input.settings, roots: [root], tokenFingerprint: fp, chatId: cfg.chatId },
 		deps,
 	);
+	if (spawned.result === "blocked") {
+		logger.warn(`notifications: failed to ensure Telegram daemon: ${spawned.warnings.join("; ")}`);
+		return spawned.result;
+	}
+	await registerNotificationRoot({ ...input, fs: deps.fs });
 	return spawned.result;
 }
 
@@ -770,6 +847,10 @@ export interface TelegramDaemonOptions {
 	 * default applies (e.g. lifecycle control disabled), no control server starts.
 	 */
 	createLifecycleControlServer?: LifecycleControlServerFactory | null;
+	/** Rich text promotion (enabled by default; see rich-render.ts). */
+	rich?: { enabled: boolean };
+	/** Opt-in rich-draft streaming of live turn previews (off by default; see rich-draft.ts). */
+	richDraft?: { enabled: boolean };
 }
 
 interface SessionSocket {
@@ -796,6 +877,8 @@ interface PendingThreadedFrame {
 export class TelegramNotificationDaemon {
 	readonly aliasTable: AliasTable;
 	readonly messageRoutes = new Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>();
+	/** Telegram message id backing each streamed `${sessionId}:${coalesceKey}`, for in-place edits. */
+	private readonly liveMessages = new Map<string, number>();
 	readonly sessions = new Map<string, SessionSocket>();
 	private readonly runtime: NotificationOperatorRuntime;
 	private readonly sessionRouter: OperatorEventRouter<SessionSocket>;
@@ -808,6 +891,10 @@ export class TelegramNotificationDaemon {
 	private readonly pool: RateLimitPool<{ send: ThreadedSend; topicId?: string }>;
 	private readonly poller: TelegramUpdatePoller;
 	private readonly dispatchState = new TelegramEventDispatchState();
+	/** Original markdown of rich messages we sent (chat+message_id), for restoring reply context on inbound replies. */
+	private readonly replyStore: ReplySentStore;
+	/** Per-session debounce + monotonic draft-id state for opt-in draft streaming. */
+	private readonly draftStream = new DraftStreamState();
 	/** Identity-bearing sessions by repo/branch surface, used to avoid transient duplicate topics. */
 	private readonly topicOwnerByIdentity = new Map<string, string>();
 	/** Non-identity frames held until identity creates the correct thread. */
@@ -820,6 +907,8 @@ export class TelegramNotificationDaemon {
 	private readonly flatIdentitySent = new Set<string>();
 	/** Cached result of whether the paired chat is a private chat (flat-fallback gate). */
 	private pairedChatPrivate: boolean | undefined;
+	/** Bot username from getMe, cached once at owner startup for group/forum command targeting. */
+	private botUsername: string | undefined;
 	/** Sessions whose agent loop is currently busy (drives the typing indicator). */
 	private get busy(): Set<string> {
 		return this.dispatchState.busy;
@@ -1043,7 +1132,7 @@ export class TelegramNotificationDaemon {
 	/** Build an authenticated lifecycle frame from a parsed command + identity. */
 	private buildLifecycleFrame(
 		parsed:
-			| { kind: "create"; target: SessionCreateTarget }
+			| { kind: "create"; target: SessionCreateTarget; modelPreset?: string }
 			| { kind: "close"; target: SessionCloseTarget }
 			| { kind: "resume"; target: SessionResumeTarget },
 		updateId: number,
@@ -1061,6 +1150,7 @@ export class TelegramNotificationDaemon {
 				chatId,
 				token,
 				target: parsed.target,
+				modelPreset: parsed.modelPreset,
 			};
 		}
 		if (parsed.kind === "close") {
@@ -1078,8 +1168,10 @@ export class TelegramNotificationDaemon {
 		text: string | undefined,
 		updateId: number | undefined,
 		threadId: number | undefined,
+		commandCtx: { chatType?: string; botUsername?: string },
 	): Promise<boolean> {
-		if (!isLifecycleCommandText(text)) return false;
+		if (!isLifecycleCommandText(text, commandCtx)) return false;
+		if (!(await this.pairedChatIsPrivate())) return true;
 		const reply = async (body: string): Promise<void> => {
 			for (const text of splitTelegramPlainText(body)) {
 				await this.botApi
@@ -1104,15 +1196,15 @@ export class TelegramNotificationDaemon {
 			}
 		};
 
+		const parsed = parseLifecycleCommand(text, commandCtx);
+		if (parsed.kind === "none") return false;
 		if (!this.lifecycleControlActive) {
 			await reply("Session lifecycle control is not available right now.");
 			return true;
 		}
 		if (updateId !== undefined && this.dispatchState.seenUpdateIds.has(updateId)) return true;
-		if (updateId !== undefined) this.dispatchState.seenUpdateIds.add(updateId);
+		if (updateId !== undefined) await this.rememberSeenUpdateId(updateId);
 
-		const parsed = parseLifecycleCommand(text);
-		if (parsed.kind === "none") return false;
 		if (parsed.kind === "usage" || parsed.kind === "reject") {
 			await reply(parsed.message);
 			return true;
@@ -1145,6 +1237,17 @@ export class TelegramNotificationDaemon {
 		return true;
 	}
 
+	private async refreshBotIdentity(): Promise<void> {
+		try {
+			const response = (await this.botApi.call("getMe", {})) as { result?: { username?: unknown } };
+			const username = response.result?.username;
+			this.botUsername =
+				typeof username === "string" && username.trim() ? username.trim().replace(/^@/, "") : undefined;
+		} catch {
+			this.botUsername = undefined;
+		}
+	}
+
 	/** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
 	private formatLifecycleResponse(r: SessionLifecycleResponse): string {
 		return formatLifecycleOutcome(r);
@@ -1152,6 +1255,7 @@ export class TelegramNotificationDaemon {
 
 	constructor(private readonly opts: TelegramDaemonOptions) {
 		this.fsImpl = opts.fs ?? nodeFs;
+		this.replyStore = new ReplySentStore({ agentDir: opts.settings.getAgentDir(), fs: opts.fs });
 		this.aliasTable = createAliasTable();
 		this.botApi =
 			opts.botApi ??
@@ -1247,6 +1351,51 @@ export class TelegramNotificationDaemon {
 		await writeJsonAtomic(this.fsImpl, paths.aliases, this.aliasTable.serialize());
 	}
 
+	async loadSeenUpdateIds(): Promise<void> {
+		const raw = await readJson<{ updateIds?: unknown }>(
+			this.fsImpl,
+			daemonPaths(this.opts.settings.getAgentDir()).seenUpdates,
+		);
+		this.dispatchState.seenUpdateIds.clear();
+		const updateIds = Array.isArray(raw?.updateIds) ? raw.updateIds : [];
+		for (const updateId of updateIds) {
+			if (Number.isSafeInteger(updateId) && Number(updateId) >= 0) {
+				this.dispatchState.seenUpdateIds.add(Number(updateId));
+			}
+		}
+		this.pruneSeenUpdateIds();
+	}
+
+	async persistSeenUpdateIds(): Promise<void> {
+		const paths = daemonPaths(this.opts.settings.getAgentDir());
+		await ensureDir(this.fsImpl, paths.dir);
+		await writeJsonAtomic(this.fsImpl, paths.seenUpdates, {
+			version: 1,
+			updateIds: [...this.dispatchState.seenUpdateIds].slice(-SEEN_UPDATE_ID_LIMIT),
+		});
+	}
+
+	private pruneSeenUpdateIds(): void {
+		let extra = this.dispatchState.seenUpdateIds.size - SEEN_UPDATE_ID_LIMIT;
+		if (extra <= 0) return;
+		for (const updateId of this.dispatchState.seenUpdateIds) {
+			this.dispatchState.seenUpdateIds.delete(updateId);
+			extra -= 1;
+			if (extra <= 0) break;
+		}
+	}
+
+	private async rememberSeenUpdateId(updateId: number): Promise<void> {
+		if (!Number.isSafeInteger(updateId) || updateId < 0) return;
+		this.dispatchState.seenUpdateIds.add(updateId);
+		this.pruneSeenUpdateIds();
+		try {
+			await this.persistSeenUpdateIds();
+		} catch (err) {
+			logger.warn(`notifications: failed to persist Telegram update id ${updateId}: ${String(err)}`);
+		}
+	}
+
 	async scanRoots(): Promise<void> {
 		const paths = daemonPaths(this.opts.settings.getAgentDir());
 		const rootState = await readJson<{ roots?: string[] }>(this.fsImpl, paths.roots);
@@ -1366,13 +1515,17 @@ export class TelegramNotificationDaemon {
 	 * (so a delayed old close cannot delete a replacement), and best-effort closes
 	 * the socket. `scanRoots()` then reconnects the session.
 	 */
-	private dropSession(session: SessionSocket, _reason: string): void {
+	private dropSession(session: SessionSocket, reason: string): void {
 		const clearIntervalImpl = this.opts.clearIntervalImpl ?? clearInterval;
 		if (session.pingTimer) {
 			clearIntervalImpl(session.pingTimer);
 			session.pingTimer = undefined;
 		}
-		if (this.sessions.get(session.sessionId) === session) {
+		const isCurrentSession = this.sessions.get(session.sessionId) === session;
+		if (isCurrentSession || reason === "session_closed") {
+			this.deleteMessageRoutes(session.sessionId);
+		}
+		if (isCurrentSession) {
 			this.sessions.delete(session.sessionId);
 		}
 		if (session.ws.readyState !== WebSocket.CLOSED) {
@@ -1382,6 +1535,14 @@ export class TelegramNotificationDaemon {
 		}
 	}
 
+	private deleteMessageRoutes(sessionId: string, actionId?: string): void {
+		for (const [messageId, route] of this.messageRoutes.entries()) {
+			if (route.sessionId === sessionId && (actionId === undefined || route.actionId === actionId)) {
+				this.messageRoutes.delete(messageId);
+			}
+		}
+	}
+
 	private static readonly THREADED_FRAMES = new Set([
 		"identity_header",
 		"context_update",
@@ -1434,6 +1595,13 @@ export class TelegramNotificationDaemon {
 		return undefined;
 	}
 
+	private sessionCanClaimIdentity(session: SessionSocket, msg: { repo?: unknown; branch?: unknown }): boolean {
+		const current = this.sessions.get(session.sessionId);
+		if (current) return current === session;
+		const ownerId = this.topicOwnerForIdentity(msg);
+		return !ownerId || ownerId === session.sessionId;
+	}
+
 	private async submitThreadedFrame(sessionId: string, send: ThreadedSend, topicId: string): Promise<void> {
 		this.pool.submit({
 			sessionId,
@@ -1444,6 +1612,11 @@ export class TelegramNotificationDaemon {
 		await this.flushPool();
 	}
 
+	private async existingTopicForPrivateChat(sessionId: string): Promise<string | undefined> {
+		if (!(await this.pairedChatIsPrivate())) return undefined;
+		return this.topics.get(sessionId)?.topicId;
+	}
+
 	private rememberPendingThreadedFrame(sessionId: string, send: ThreadedSend, msg: Record<string, unknown>): void {
 		const frames = this.pendingThreadedFrames.get(sessionId) ?? [];
 		frames.push({ send, msg });
@@ -1465,6 +1638,7 @@ export class TelegramNotificationDaemon {
 	 * one-time nudge) or drop fail-closed for a non-private chat.
 	 */
 	private async ensureTopic(sessionId: string, name: string): Promise<string | undefined> {
+		if (!(await this.pairedChatIsPrivate())) return undefined;
 		const existing = this.topics.get(sessionId);
 		if (existing) return existing.topicId;
 		try {
@@ -1508,6 +1682,9 @@ export class TelegramNotificationDaemon {
 			})) as { ok?: boolean };
 			if (res?.ok === false) return;
 			this.topics.delete(sessionId);
+			for (const k of [...this.liveMessages.keys()]) {
+				if (k.startsWith(`${sessionId}:`)) this.liveMessages.delete(k);
+			}
 			this.topicOwnerByIdentity.forEach((ownerSessionId, identityKey) => {
 				if (ownerSessionId === sessionId) this.topicOwnerByIdentity.delete(identityKey);
 			});
@@ -1635,13 +1812,81 @@ export class TelegramNotificationDaemon {
 		return { images, fileNotes };
 	}
 
+	/**
+	 * Serialize all pool flushes. Every caller (`submitThreadedFrame`, the flat
+	 * fallback, the drain timer's `void this.flushPool()`, topic teardown) goes
+	 * through one promise chain, so two flushes never interleave — a live send can
+	 * never be in-flight while a finalized flush reads `liveMessages` and decides
+	 * to post a fresh (duplicate) final. Errors are swallowed so one failed flush
+	 * never poisons the queue (each flush is already best-effort internally).
+	 */
+	private flushChain: Promise<void> = Promise.resolve();
+	private flushPool(): Promise<void> {
+		const next = this.flushChain.then(() => this.flushPoolInner());
+		this.flushChain = next.catch(() => {});
+		return next;
+	}
+
 	/** Drain the shared rate-limit pool and deliver each granted send to its topic. */
-	private async flushPool(): Promise<void> {
-		for (const item of this.pool.drain()) {
+	private async flushPoolInner(): Promise<void> {
+		const batch = this.pool.drain();
+		// Within a batch a finalized frame supersedes any still-queued live frame for
+		// the same streamed message (finalized outranks live), so drop the stale live
+		// edit — otherwise the authoritative final text could be overwritten by an
+		// older partial delivered right after it.
+		const finalizedKeys = new Set<string>();
+		for (const item of batch) {
+			if (item.lane === "finalized" && item.coalesceKey !== undefined) {
+				finalizedKeys.add(`${item.sessionId}:${item.coalesceKey}`);
+			}
+		}
+		// Cross-batch protection: also purge any live frame still QUEUED for a
+		// message whose finalized frame is in this batch, so a stale live edit can
+		// never be delivered on a later drain after the authoritative final.
+		if (finalizedKeys.size > 0) {
+			this.pool.removeWhere(
+				it =>
+					it.lane === "live" &&
+					it.coalesceKey !== undefined &&
+					finalizedKeys.has(`${it.sessionId}:${it.coalesceKey}`),
+			);
+		}
+		for (const item of batch) {
 			const { send, topicId } = item.payload;
+			if (topicId && !(await this.pairedChatIsPrivate())) continue;
 			// Threaded topic when available; otherwise deliver flat to the paired chat.
 			const threadField = topicId ? { message_thread_id: Number(topicId) } : {};
+			const ckey = send.editable ? item.coalesceKey : undefined;
+			const editKey = ckey !== undefined ? `${item.sessionId}:${ckey}` : undefined;
+			if (item.lane === "live" && editKey && finalizedKeys.has(editKey)) continue;
 			try {
+				// Draft streaming (opt-in, off by default): stream a live turn frame as a
+				// best-effort rich-draft preview, debounced to >=1.5s per session through
+				// this same rate-limited drain; a finalized frame ends the turn's draft
+				// window. Entirely inert when richDraft is off (the enabled gate /
+				// shouldStreamDraft fail closed), so off-state HTML request bodies stay
+				// byte-identical.
+				if (this.opts.richDraft?.enabled === true && this.opts.rich?.enabled !== false) {
+					if (send.lane === "finalized" && send.method === "sendMessage") {
+						this.draftStream.reset(item.sessionId);
+					} else if (
+						shouldStreamDraft({
+							enabled: this.opts.richDraft.enabled,
+							send,
+						})
+					) {
+						const draftId = this.draftStream.tryClaim(item.sessionId, this.opts.now?.() ?? Date.now());
+						if (draftId !== undefined) {
+							await deliverDraft(
+								this.botApi,
+								{ chat_id: this.opts.chatId, ...threadField },
+								draftId,
+								send.richDraftMarkdown!,
+								logger,
+							);
+						}
+					}
+				}
 				if (send.method === "sendPhoto" && send.photoBase64) {
 					// Real photo upload (the default botApi multiparts base64 -> file).
 					await this.botApi.call("sendPhoto", {
@@ -1663,21 +1908,165 @@ export class TelegramNotificationDaemon {
 						parse_mode: TELEGRAM_PARSE_MODE,
 					});
 				} else if (send.text) {
-					for (const text of splitTelegramHtml(send.text)) {
-						await this.botApi.call("sendMessage", {
-							chat_id: this.opts.chatId,
-							...threadField,
-							text,
-							parse_mode: TELEGRAM_PARSE_MODE,
-						});
+					// Rich pre-branch: promote stable non-editable finalized text to a fresh
+					// sendRichMessage when enabled. Off/miss falls through to the unchanged
+					// upstream edit/send path, so off behavior is byte-identical.
+					if (
+						shouldPromoteRich({
+							enabled: this.opts.rich?.enabled === false ? false : true,
+							send,
+						})
+					) {
+						const sendHtmlFallback = async () => {
+							// Fairness: this frame consumed exactly one token, so send only the
+							// first HTML chunk now and requeue any continuations as their own
+							// non-editable, HTML-only pool items (rich markers stripped) — same
+							// per-token discipline as the non-rich split path.
+							const chunks = splitTelegramHtml(send.text!);
+							await this.botApi.call("sendMessage", {
+								chat_id: this.opts.chatId,
+								...threadField,
+								text: chunks[0]!,
+								parse_mode: TELEGRAM_PARSE_MODE,
+							});
+							for (let i = 1; i < chunks.length; i++) {
+								this.pool.submit({
+									sessionId: item.sessionId,
+									lane: item.lane,
+									payload: {
+										send: {
+											...send,
+											method: "sendMessage",
+											text: chunks[i]!,
+											editable: false,
+											coalesceKey: undefined,
+											photoBase64: undefined,
+											documentBase64: undefined,
+											richMarkdown: undefined,
+											richDraftMarkdown: undefined,
+											richClass: undefined,
+										},
+										topicId,
+									},
+								});
+							}
+						};
+						const richMessageId = await deliverRichWithFallback(
+							this.botApi,
+							{ chat_id: this.opts.chatId, ...threadField },
+							send,
+							sendHtmlFallback,
+							logger,
+						);
+						// Index the sent rich message so an inbound reply to it can restore
+						// the original markdown as context (Telegram does not echo it back).
+						if (richMessageId !== undefined) {
+							await this.replyStore.record({
+								chatId: this.opts.chatId,
+								messageId: richMessageId,
+								text: send.richMarkdown!,
+							});
+						}
+					} else {
+						const chunks = splitTelegramHtml(send.text);
+						const existingId = editKey ? this.liveMessages.get(editKey) : undefined;
+						let firstMessageId: number | undefined;
+						if (editKey && existingId !== undefined) {
+							// Edit the existing streamed message in place with the first chunk
+							// so a finalized turn never leaves a stale live preview. A LOCAL
+							// try/catch keeps a failed edit from aborting the continuation
+							// requeue below; "message is not modified" is a success (the message
+							// already shows this text); a missing/deleted backing message (or a
+							// transport error) resends so the first chunk is never lost.
+							let edited = false;
+							try {
+								const res = (await this.botApi.call("editMessageText", {
+									chat_id: this.opts.chatId,
+									message_id: existingId,
+									text: chunks[0],
+									parse_mode: TELEGRAM_PARSE_MODE,
+								})) as { ok?: boolean; description?: string } | null;
+								edited = res?.ok !== false || /not modified/i.test(String(res?.description ?? ""));
+							} catch {
+								edited = false;
+							}
+							if (edited) {
+								firstMessageId = existingId;
+							} else {
+								const res = (await this.botApi.call("sendMessage", {
+									chat_id: this.opts.chatId,
+									...threadField,
+									text: chunks[0]!,
+									parse_mode: TELEGRAM_PARSE_MODE,
+								})) as { result?: { message_id?: number } };
+								firstMessageId = res?.result?.message_id;
+							}
+						} else {
+							// No streamed message to edit: a single granted slot maps to a
+							// single Telegram send.
+							const res = (await this.botApi.call("sendMessage", {
+								chat_id: this.opts.chatId,
+								...threadField,
+								text: chunks[0]!,
+								parse_mode: TELEGRAM_PARSE_MODE,
+							})) as { result?: { message_id?: number } };
+							firstMessageId = res?.result?.message_id;
+						}
+						// Continuation chunks are FINALIZED-lane only. A live preview is a
+						// single edit-safe chunk (its authoritative full text arrives with the
+						// finalized frame), so a split live frame never fans out into stale,
+						// non-coalesced continuation messages. Finalized continuations are
+						// fresh, non-editable, HTML-only sends (rich markers stripped) so they
+						// can never be re-promoted to a duplicate sendRichMessage.
+						if (item.lane !== "live") {
+							for (let i = 1; i < chunks.length; i++) {
+								this.pool.submit({
+									sessionId: item.sessionId,
+									lane: item.lane,
+									payload: {
+										send: {
+											...send,
+											method: "sendMessage",
+											text: chunks[i]!,
+											editable: false,
+											coalesceKey: undefined,
+											photoBase64: undefined,
+											documentBase64: undefined,
+											richMarkdown: undefined,
+											richDraftMarkdown: undefined,
+											richClass: undefined,
+										},
+										topicId,
+									},
+								});
+							}
+						}
+						if (editKey && ckey !== undefined && firstMessageId !== undefined) {
+							this.recordLiveMessage(item.sessionId, ckey, firstMessageId);
+						}
 					}
 				}
 			} catch {
-				// Best-effort: a failed send must never stop the daemon.
+				// Best-effort: a failed send/edit must never stop the daemon.
 			}
 		}
 	}
 
+	/**
+	 * Track the Telegram message id backing a streamed `(sessionId, coalesceKey)`
+	 * so later live/finalized frames edit it in place. Evicts this session's stale
+	 * same-category entries (e.g. prior turns) so the map stays bounded.
+	 */
+	private recordLiveMessage(sessionId: string, coalesceKey: string, messageId: number): void {
+		const mapKey = `${sessionId}:${coalesceKey}`;
+		const category = coalesceKey.split(":")[0] ?? "";
+		const prefix = `${sessionId}:${category}:`;
+		for (const k of [...this.liveMessages.keys()]) {
+			if (k !== mapKey && k.startsWith(prefix)) this.liveMessages.delete(k);
+		}
+		this.liveMessages.set(mapKey, messageId);
+	}
+
 	/**
 	 * Threaded Mode is unavailable (the bot owner has not enabled forum topics in
 	 * @BotFather, so `createForumTopic` fails). Deliver the rendered frame flat to
@@ -1697,9 +2086,10 @@ export class TelegramNotificationDaemon {
 	}
 
 	/**
-	 * Resolve once (cached) whether the paired `chatId` is a private chat. Flat
-	 * fallback is only safe in a private DM; any non-private chat or an unresolvable
-	 * `getChat` is treated as not-private so delivery fails closed.
+	 * Resolve (and cache successful resolution of) whether the paired `chatId` is a
+	 * private chat. Topic and flat delivery are only safe in a private DM; any
+	 * non-private chat fails closed, while a transient `getChat` failure fails closed
+	 * for the current attempt and is retried later.
 	 */
 	private async pairedChatIsPrivate(): Promise<boolean> {
 		if (this.pairedChatPrivate !== undefined) return this.pairedChatPrivate;
@@ -1708,20 +2098,21 @@ export class TelegramNotificationDaemon {
 				result?: { type?: string };
 			};
 			this.pairedChatPrivate = res.result?.type === "private";
-		} catch {
-			this.pairedChatPrivate = false;
+			return this.pairedChatPrivate;
+		} catch (e) {
+			logger.warn(`notifications: getChat failed while checking Telegram chat privacy: ${String(e)}`);
+			return false;
 		}
-		return this.pairedChatPrivate;
 	}
 
 	/** Tell the user once (per daemon run) how to enable Threaded Mode. */
 	private async notifyThreadedFallback(): Promise<void> {
-		if (this.threadedFallbackNoticeSent) return;
+		if (this.threadedFallbackNoticeSent || !(await this.pairedChatIsPrivate())) return;
 		this.threadedFallbackNoticeSent = true;
 		try {
 			await this.botApi.call("sendMessage", {
 				chat_id: this.opts.chatId,
-				text: "turn on threaded mode from botfather miniapp to receive skc notification!",
+				text: "Flat Telegram private chat supports outbound notifications and inline ask buttons only. Enable Threaded Mode in @BotFather > Bot Settings > Threads Settings for free-text replies and session commands.",
 				parse_mode: TELEGRAM_PARSE_MODE,
 			});
 		} catch {
@@ -1761,7 +2152,7 @@ export class TelegramNotificationDaemon {
 	/** Send a single `typing` chat action into a busy session's topic (best-effort). */
 	private async sendTyping(sessionId: string): Promise<void> {
 		const topicId = this.topics.get(sessionId)?.topicId;
-		if (!topicId) return;
+		if (!topicId || !(await this.pairedChatIsPrivate())) return;
 		try {
 			await this.botApi.call("sendChatAction", {
 				chat_id: this.opts.chatId,
@@ -1775,6 +2166,7 @@ export class TelegramNotificationDaemon {
 
 	/** Set a native reaction on an inbound thread message (best-effort). */
 	private async setReaction(messageId: number, emoji: string): Promise<void> {
+		if (!(await this.pairedChatIsPrivate())) return;
 		try {
 			await this.botApi.call("setMessageReaction", {
 				chat_id: this.opts.chatId,
@@ -1802,12 +2194,12 @@ export class TelegramNotificationDaemon {
 		if (typeof msg?.type === "string" && TelegramNotificationDaemon.THREADED_FRAMES.has(msg.type)) {
 			const send = renderThreadedFrame(msg);
 			if (!send) return;
-			const existingTopic = this.topics.get(session.sessionId)?.topicId;
+			const existingTopic = await this.existingTopicForPrivateChat(session.sessionId);
 			if (!send.identity && !existingTopic && !this.flatIdentitySent.has(session.sessionId)) {
 				this.rememberPendingThreadedFrame(session.sessionId, send, msg as Record<string, unknown>);
 				return;
 			}
-			if (send.identity) {
+			if (send.identity && !this.sessionCanClaimIdentity(session, msg)) {
 				const ownerId = this.topicOwnerForIdentity(msg);
 				const ownerTopic = ownerId ? this.topics.get(ownerId) : undefined;
 				if (ownerId && ownerId !== session.sessionId && ownerTopic) {
@@ -1869,27 +2261,62 @@ export class TelegramNotificationDaemon {
 			});
 			const options = Array.isArray(msg.options) ? msg.options : [];
 			// Daemon keyboards use alias callback data with compact one-based tap targets;
-			// full option text is rendered in the message body by buildActionMessage.
+			// full option text is rendered in the message body by buildActionMessage/buildActionMarkdown.
 			const inline_keyboard = buildCompactChoiceGrid(options, (i: number) =>
 				this.aliasTable.put({ sessionId: session.sessionId, actionId: msg.id, answer: i }),
 			);
-			const chunks = splitTelegramHtml(rendered.text);
-			let result: { result?: { message_id?: number } } = {};
-			for (let i = 0; i < chunks.length; i++) {
-				result = (await this.botApi.call("sendMessage", {
-					chat_id: this.opts.chatId,
-					...threadField,
-					text: chunks[i]!,
-					parse_mode: TELEGRAM_PARSE_MODE,
-					...(i === chunks.length - 1 && inline_keyboard.length ? { reply_markup: { inline_keyboard } } : {}),
-				})) as { result?: { message_id?: number } };
+			// HTML delivery: one sendMessage per chunk, keyboard on the last chunk;
+			// returns the last chunk's message_id (the reply-routable message).
+			const sendHtmlChunks = async (): Promise<number | undefined> => {
+				const chunks = splitTelegramHtml(rendered.text);
+				let result: { result?: { message_id?: number } } = {};
+				for (let i = 0; i < chunks.length; i++) {
+					result = (await this.botApi.call("sendMessage", {
+						chat_id: this.opts.chatId,
+						...threadField,
+						text: chunks[i]!,
+						parse_mode: TELEGRAM_PARSE_MODE,
+						...(i === chunks.length - 1 && inline_keyboard.length ? { reply_markup: { inline_keyboard } } : {}),
+					})) as { result?: { message_id?: number } };
+				}
+				return result.result?.message_id;
+			};
+			const kind = msg.kind === "idle" ? "idle" : "ask";
+			if (this.opts.rich?.enabled !== false) {
+				// Rich (default on): promote to sendRichMessage with a top-level
+				// reply_markup (probe-confirmed). Any miss falls back to the HTML loop.
+
+				const outcome = await deliverRichActionWithFallback(
+					this.botApi,
+					{ chat_id: this.opts.chatId, ...threadField },
+					{
+						markdown: buildActionMarkdown({
+							kind,
+							question: msg.question,
+							options: msg.options,
+							summary: msg.summary,
+						}),
+						replyMarkup: kind === "ask" && inline_keyboard.length ? { inline_keyboard } : undefined,
+						requireMessageId: kind === "ask",
+					},
+					sendHtmlChunks,
+					logger,
+				);
+				// Only asks are reply-routable; idle pings register no route.
+				if (kind === "ask" && outcome.messageId !== undefined)
+					this.messageRoutes.set(String(outcome.messageId), { sessionId: session.sessionId, actionId: msg.id });
+			} else {
+				// Off: byte-identical to the pre-rich HTML path.
+				const messageId = await sendHtmlChunks();
+				// Only asks are reply-routable; idle pings register no route (parity
+				// with the rich branch and correct even in the byte-identical off path).
+				if (kind === "ask" && messageId !== undefined)
+					this.messageRoutes.set(String(messageId), { sessionId: session.sessionId, actionId: msg.id });
 			}
-			const messageId = result.result?.message_id;
-			if (messageId !== undefined)
-				this.messageRoutes.set(String(messageId), { sessionId: session.sessionId, actionId: msg.id });
 			await this.persistAliases();
 		} else if (msg.type === "action_resolved" && msg.id) {
 			session.pending.delete(msg.id);
+			this.deleteMessageRoutes(session.sessionId, msg.id);
 			for (const [alias, route] of this.aliasTable.entries()) {
 				if (route.sessionId === session.sessionId && route.actionId === msg.id) this.aliasTable.delete(alias);
 			}
@@ -1897,19 +2324,22 @@ export class TelegramNotificationDaemon {
 		}
 	}
 
-	pendingBySession = (sessionId?: string): PendingAsk[] => {
-		const result: PendingAsk[] = [];
-		for (const session of this.sessions.values()) {
-			if (sessionId && session.sessionId !== sessionId) continue;
-			result.push(...session.pending.values());
+	private async answerCallbackQueryBestEffort(callbackId: unknown, text?: string): Promise<void> {
+		if (typeof callbackId !== "string") return;
+		try {
+			await this.botApi.call("answerCallbackQuery", {
+				callback_query_id: callbackId,
+				...(text === undefined ? {} : { text }),
+			});
+		} catch {
+			// Telegram callback acknowledgements only dismiss the client-side spinner;
+			// they must never block the already-validated local reply path.
 		}
-		return result;
-	};
+	}
 
 	private async sendStaleGuidance(callbackId: unknown): Promise<void> {
-		if (typeof callbackId === "string") {
-			await this.botApi.call("answerCallbackQuery", { callback_query_id: callbackId, text: "Button is stale" });
-		}
+		await this.answerCallbackQueryBestEffort(callbackId, "Button is stale");
+		if (!(await this.pairedChatIsPrivate())) return;
 		await this.botApi.call("sendMessage", {
 			chat_id: this.opts.chatId,
 			text: "This button is stale after notification daemon restart. Please answer locally in the SKC session or wait for a fresh notification.",
@@ -1924,12 +2354,77 @@ export class TelegramNotificationDaemon {
 		// session input.
 		{
 			const m = (update as { update_id?: number; message?: Record<string, unknown> }).message;
-			const chatId = (m?.chat as { id?: unknown } | undefined)?.id;
+			const chat = m?.chat as { id?: unknown; type?: unknown } | undefined;
+			const chatId = chat?.id;
+			const chatType = typeof chat?.type === "string" ? chat.type : undefined;
 			const cmdText = typeof m?.text === "string" ? m.text : undefined;
-			if (m !== undefined && String(chatId) === String(this.opts.chatId) && isLifecycleCommandText(cmdText)) {
+			const commandCtx = { chatType, botUsername: this.botUsername };
+			if (m !== undefined && String(chatId) === String(this.opts.chatId)) {
+				if (chatType !== undefined && chatType !== "private" && isLifecycleCommandLikeText(cmdText)) return;
+				if (isLifecycleCommandText(cmdText, commandCtx)) {
+					const updateId = (update as { update_id?: number }).update_id;
+					const threadId = typeof m.message_thread_id === "number" ? (m.message_thread_id as number) : undefined;
+					if (await this.handleLifecycleCommand(cmdText, updateId, threadId, commandCtx)) return;
+				}
+			}
+		}
+		// Rich-message toggle (/rich on|off): daemon-local delivery policy, NOT a
+		// session config forward. Handled at paired-chat pre-routing, before threaded
+		// injection and independent of any session WebSocket, so it works even when
+		// no session is connected and never becomes an ask answer.
+		{
+			const m = (update as { update_id?: number; message?: Record<string, unknown> }).message;
+			const chat = m?.chat as { id?: unknown } | undefined;
+			const cmdText = typeof m?.text === "string" ? m.text : undefined;
+			const rawFirst = cmdText?.trim().split(/\s+/)[0]?.toLowerCase();
+			// Fail-closed: intercept ANY "/rich" or "/rich@<anything>" form (Telegram
+			// appends @botname in groups; the bot username may be unknown if getMe
+			// failed) so a rich command is never leaked into threaded injection / an
+			// ask answer. Argument validity is decided by parseRichToggleCommand below.
+			const isRichCommand = rawFirst?.split("@")[0] === "/rich";
+			if (m !== undefined && String(chat?.id) === String(this.opts.chatId) && isRichCommand) {
+				// Fail-closed: /rich mutates global config, so honor it ONLY in a PRIVATE
+				// paired chat — the same contract as session delivery and lifecycle
+				// commands. A group/supergroup chatId (legacy or hand-edited) must never
+				// let an arbitrary chat member toggle the owner's notification config.
+				if (!(await this.pairedChatIsPrivate())) return;
 				const updateId = (update as { update_id?: number }).update_id;
-				const threadId = typeof m.message_thread_id === "number" ? (m.message_thread_id as number) : undefined;
-				if (await this.handleLifecycleCommand(cmdText, updateId, threadId)) return;
+				// Dedupe redelivered updates so a toggle+confirmation runs at most once.
+				if (typeof updateId === "number") {
+					if (this.dispatchState.seenUpdateIds.has(updateId)) return;
+					await this.rememberSeenUpdateId(updateId);
+				}
+				const threadField =
+					typeof m.message_thread_id === "number" ? { message_thread_id: m.message_thread_id as number } : {};
+				const reply = async (body: string): Promise<void> => {
+					try {
+						await this.botApi.call("sendMessage", {
+							chat_id: this.opts.chatId,
+							...threadField,
+							text: body,
+							parse_mode: TELEGRAM_PARSE_MODE,
+						});
+					} catch {
+						// Best-effort confirmation; never block on the notice.
+					}
+				};
+				const desired = parseRichToggleCommand(cmdText ?? "");
+				if (desired === undefined) {
+					await reply("Usage: /rich on|off");
+					return;
+				}
+				try {
+					await this.opts.settings.set("notifications.telegram.rich.enabled", desired);
+				} catch (err) {
+					logger.warn(
+						`notifications: /rich settings write failed (${err instanceof Error ? err.message : String(err)}); runtime unchanged`,
+					);
+					await reply("Rich messages: unchanged (settings write failed)");
+					return;
+				}
+				this.opts.rich = { enabled: desired };
+				await reply(desired ? "Rich messages: on" : "Rich messages: off");
+				return;
 			}
 		}
 		// Threaded injection: a free-text message in a known topic (not a button
@@ -1954,7 +2449,6 @@ export class TelegramNotificationDaemon {
 			});
 			if (inbound.kind === "duplicate") return;
 			if (inbound.kind === "inject") {
-				this.dispatchState.seenUpdateIds.add(inbound.updateId);
 				const session = this.sessions.get(inbound.sessionId);
 				if (session?.ws.readyState === WebSocket.OPEN) {
 					const attachmentResult = inbound.attachment
@@ -1963,7 +2457,17 @@ export class TelegramNotificationDaemon {
 					const images = attachmentResult?.images ?? [];
 					const fileNotes = attachmentResult?.fileNotes ?? [];
 					const hasMedia = images.length > 0 || fileNotes.length > 0;
-					const injectedText = [inbound.text, ...fileNotes].filter(Boolean).join("\n");
+					const baseInjectedText = [inbound.text, ...fileNotes].filter(Boolean).join("\n");
+					// A reply to a rich message we sent (not an ask route) loses its original
+					// text: Telegram does not echo it in reply_to_message. Restore it from the
+					// reply index as a labeled context prefix; a miss leaves the turn unchanged.
+					const repliedOriginal =
+						typeof replyTo === "number"
+							? this.replyStore.lookup({ chatId: this.opts.chatId, messageId: replyTo })
+							: undefined;
+					const injectedText = repliedOriginal
+						? `> replied-to message:\n${repliedOriginal}\n\n${baseInjectedText}`
+						: baseInjectedText;
 					const cfg = hasMedia ? undefined : parseInThreadConfigCommand(inbound.text);
 					// A plain (non-config) message while an ask is pending for this session
 					// answers that ask as free-input — instead of starting a new user turn.
@@ -1979,6 +2483,7 @@ export class TelegramNotificationDaemon {
 								token: session.token,
 							}),
 						);
+						await this.rememberSeenUpdateId(inbound.updateId);
 						if (inbound.messageId !== undefined) await this.setReaction(inbound.messageId, QUEUED_REACTION);
 						return;
 					}
@@ -1997,6 +2502,7 @@ export class TelegramNotificationDaemon {
 									},
 						),
 					);
+					await this.rememberSeenUpdateId(inbound.updateId);
 					// User turns get a native delivery double-check: queued on receipt,
 					// flipped to consumed when the session acks the turn that picks it
 					// up. Config commands are not user turns and get no reaction.
@@ -2012,7 +2518,6 @@ export class TelegramNotificationDaemon {
 		const decision = routeInboundUpdate(update, {
 			aliasTable: this.aliasTable,
 			messageRoutes: this.messageRoutes,
-			pendingBySession: this.pendingBySession,
 			pairedChatId: this.opts.chatId,
 		});
 		if (decision.kind === "reply") {
@@ -2021,11 +2526,10 @@ export class TelegramNotificationDaemon {
 				await this.sendStaleGuidance(callbackId);
 				return;
 			}
-			if (typeof callbackId === "string")
-				await this.botApi.call("answerCallbackQuery", { callback_query_id: callbackId });
 			session.ws.send(
 				JSON.stringify({ type: "reply", id: decision.actionId, answer: decision.answer, token: session.token }),
 			);
+			await this.answerCallbackQueryBestEffort(callbackId);
 		} else if (decision.kind === "stale") {
 			await this.sendStaleGuidance(callbackId);
 		}
@@ -2043,7 +2547,8 @@ export class TelegramNotificationDaemon {
 					{ command: "verbose", description: "Mirror full tool output + reasoning in this thread" },
 					{ command: "lean", description: "Mirror assistant text + tool names only (default)" },
 					{ command: "redact", description: "Toggle redaction of streamed content: /redact <on|off>" },
-					{ command: "session_create", description: "Create a SKC session: path, worktree, or dir" },
+					{ command: "rich", description: "Toggle rich Telegram delivery: /rich <on|off>" },
+					{ command: "session_create", description: "Create a SKC session: path, worktree, or dir [--mpreset]" },
 					{ command: "session_recent", description: "List recent SKC sessions" },
 					{ command: "session_close", description: "Close a SKC-managed session" },
 					{ command: "session_resume", description: "Resume or reattach a session" },
@@ -2068,9 +2573,12 @@ export class TelegramNotificationDaemon {
 		this.startScanTimer();
 		this.startTypingTimer();
 		try {
+			await this.refreshBotIdentity();
 			await this.registerBotCommands();
 			await this.loadAliases();
 			await this.loadTopics();
+			await this.loadSeenUpdateIds();
+			await this.replyStore.load();
 			await this.runScan();
 			// Owner-only: start the session-lifecycle control server now that
 			// ownership is confirmed (singleton-safe). Best-effort; degrades.
@@ -2091,31 +2599,30 @@ export class TelegramNotificationDaemon {
 				await this.runScan();
 				if (await this.controlStopRequested()) break;
 				const idleElapsed = this.runtime.now() - idleSince >= (this.opts.idleTimeoutMs ?? 60_000);
-				if (this.sessions.size === 0 && !this.lifecycleControlActive) {
-					// No sessions and no lifecycle control: idle-exit on timeout.
-					if (idleElapsed) break;
-				} else {
-					// Poll getUpdates when sessions exist OR lifecycle control is active
-					// (so phone /session_* commands are received even with zero sessions).
-					// With zero sessions, still idle-exit after the timeout so the owner
-					// does not run forever; an active session resets the idle window.
-					if (this.sessions.size > 0) idleSince = this.runtime.now();
-					else if (idleElapsed) break;
-					const activePoll = this.runtime.createAbortController();
-					try {
-						await this.pollOnce(activePoll.signal);
-						this.loopBackoff.reset();
-					} catch (e) {
-						// A transient getUpdates/network failure must not kill the
-						// daemon. Back off (bounded, below the heartbeat TTL) and keep
-						// renewing ownership at the loop top.
-						const backoffMs = this.loopBackoff.next();
-						logger.warn(`notifications: getUpdates failed, backing off ${backoffMs}ms: ${String(e)}`);
-						await this.runtime.sleep(backoffMs);
-						continue;
-					} finally {
-						this.runtime.clearAbortController(activePoll);
-					}
+				if (this.sessions.size > 0) {
+					idleSince = this.runtime.now();
+				} else if (idleElapsed) {
+					// Zero sessions past the idle window: exit so the owner does not run
+					// forever. An active session resets the idle window above.
+					break;
+				}
+				// Poll getUpdates whenever the daemon owns the token — even with zero
+				// sessions and no lifecycle control — so daemon-local commands (/rich,
+				// /session_*) are always received until idle-exit.
+				const activePoll = this.runtime.createAbortController();
+				try {
+					await this.pollOnce(activePoll.signal);
+					this.loopBackoff.reset();
+				} catch (e) {
+					// A transient getUpdates/network failure must not kill the daemon.
+					// Back off (bounded, below the heartbeat TTL) and keep renewing
+					// ownership at the loop top.
+					const backoffMs = this.loopBackoff.next();
+					logger.warn(`notifications: getUpdates failed, backing off ${backoffMs}ms: ${String(e)}`);
+					await this.runtime.sleep(backoffMs);
+					continue;
+				} finally {
+					this.runtime.clearAbortController(activePoll);
 				}
 				if (await this.controlStopRequested()) break;
 				await this.runtime.sleep(10);
@@ -2131,6 +2638,7 @@ export class TelegramNotificationDaemon {
 			// (e.g. after reload) reloads aliases/topics seamlessly.
 			await this.persistAliases().catch(() => undefined);
 			await this.persistTopics().catch(() => undefined);
+			await this.persistSeenUpdateIds().catch(() => undefined);
 			await this.opts.control?.clear?.(this.opts.ownerId).catch(() => undefined);
 			await releaseDaemonOwnership({
 				settings: this.opts.settings,