@gajae-code/coding-agent 0.8.0 → 0.8.2

package/src/notifications/telegram-daemon.ts

@@ -27,6 +27,7 @@ import type {
 } from "./index";
 import {
 	formatLifecycleOutcome,
+	isLifecycleCommandLikeText,
 	isLifecycleCommandText,
 	lifecycleUsage,
 	parseLifecycleCommand,
@@ -48,7 +49,6 @@ import {
 	buildActionMessage,
 	type CallbackRoute,
 	createAliasTable,
-	type PendingAsk,
 	readEndpoint,
 	routeInboundUpdate,
 } from "./telegram-reference";
@@ -56,7 +56,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 +126,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[] {
@@ -142,6 +143,9 @@ function splitTelegramPlainText(text: string, max = TELEGRAM_MESSAGE_LIMIT): str
 	if (out) chunks.push(out);
 	return chunks;
 }
+function endpointGenerationKey(url: string, token: string): string {
+	return `${url}\0${token}`;
+}
 
 /**
  * Whether `err` is a transient network failure worth retrying. Telegram API
@@ -264,7 +268,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, ".gjc", "state");
+	const root = notificationRootForCwd(input.cwd);
 	await withFileLock(
 		paths.roots,
 		async () => {
@@ -283,6 +287,29 @@ export async function registerNotificationRoot(input: {
 	return root;
 }
 
+function notificationRootForCwd(cwd: string): string {
+	return path.join(cwd, ".gjc", "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;
@@ -294,8 +321,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),
 	);
@@ -311,7 +337,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;
@@ -321,6 +353,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,
@@ -346,6 +388,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,
@@ -372,6 +424,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 };
 		}
@@ -549,7 +611,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,
@@ -566,12 +637,17 @@ export async function ensureTelegramDaemonRunning(
 ): Promise<EnsureDaemonResult> {
 	const cfg = getNotificationConfig(input.settings);
 	if (!isGloballyConfigured(cfg) || !cfg.botToken || !cfg.chatId) return "disabled";
-	const root = await registerNotificationRoot({ ...input, fs: deps.fs });
+	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;
 }
 
@@ -772,6 +848,7 @@ export interface TelegramDaemonOptions {
 interface SessionSocket {
 	sessionId: string;
 	token: string;
+	endpointKey: string;
 	ws: WebSocket;
 	pending: Map<string, { sessionId: string; actionId: string }>;
 	/** True once the server advertised the `client_ping_pong` capability. */
@@ -808,12 +885,16 @@ export class TelegramNotificationDaemon {
 	private readonly topicOwnerByIdentity = new Map<string, string>();
 	/** Non-identity frames held until identity creates the correct thread. */
 	private readonly pendingThreadedFrames = new Map<string, PendingThreadedFrame[]>();
+	/** Endpoint generation tombstones for sessions that already sent session_closed. */
+	private readonly closedEndpointKeys = new Map<string, string>();
 	/** True once the daemon has nudged the user to enable Threaded Mode. */
 	private threadedFallbackNoticeSent = false;
 	/** Sessions whose identity header was already sent flat (Threaded Mode off). */
 	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;
@@ -1072,8 +1153,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
@@ -1098,15 +1181,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;
@@ -1139,6 +1222,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);
@@ -1223,7 +1317,9 @@ export class TelegramNotificationDaemon {
 				matches: msg => msg.type === "session_closed",
 				handle: async session => {
 					this.busy.delete(session.sessionId);
+					this.closedEndpointKeys.set(session.sessionId, session.endpointKey);
 					await this.deleteTopic(session.sessionId);
+					this.dropSession(session, "session_closed");
 				},
 			});
 	}
@@ -1239,6 +1335,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);
@@ -1260,6 +1401,9 @@ export class TelegramNotificationDaemon {
 					// would chase a dead, token-bearing record forever.
 					const pidAlive = this.opts.pidAlive ?? defaultPidAlive;
 					if (endpoint.stale || (endpoint.pid !== undefined && !pidAlive(endpoint.pid))) continue;
+					const endpointKey = endpointGenerationKey(endpoint.url, endpoint.token);
+					if (this.closedEndpointKeys.get(sessionId) === endpointKey) continue;
+					this.closedEndpointKeys.delete(sessionId);
 					this.connectSession(sessionId, endpoint.url, endpoint.token);
 				} catch {}
 			}
@@ -1269,9 +1413,12 @@ export class TelegramNotificationDaemon {
 	connectSession(sessionId: string, url: string, token: string): void {
 		const WS = this.opts.WebSocketImpl ?? WebSocket;
 		const ws = new WS(`${url}/?token=${encodeURIComponent(token)}`);
+		const endpointKey = endpointGenerationKey(url, token);
+		this.closedEndpointKeys.delete(sessionId);
 		const session: SessionSocket = {
 			sessionId,
 			token,
+			endpointKey,
 			ws,
 			pending: new Map(),
 			capable: false,
@@ -1352,13 +1499,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) {
@@ -1368,6 +1519,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",
@@ -1420,6 +1579,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,
@@ -1430,6 +1596,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 });
@@ -1451,6 +1622,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 {
@@ -1625,6 +1797,7 @@ export class TelegramNotificationDaemon {
 	private async flushPool(): Promise<void> {
 		for (const item of this.pool.drain()) {
 			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) } : {};
 			try {
@@ -1683,9 +1856,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;
@@ -1694,15 +1868,16 @@ 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", {
@@ -1747,7 +1922,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,
@@ -1761,6 +1936,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,
@@ -1788,12 +1964,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) {
@@ -1876,6 +2052,7 @@ export class TelegramNotificationDaemon {
 			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);
 			}
@@ -1883,19 +2060,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 GJC session or wait for a fresh notification.",
@@ -1910,12 +2090,18 @@ 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 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;
+			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;
+				}
 			}
 		}
 		// Threaded injection: a free-text message in a known topic (not a button
@@ -1940,7 +2126,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
@@ -1965,6 +2150,7 @@ export class TelegramNotificationDaemon {
 								token: session.token,
 							}),
 						);
+						await this.rememberSeenUpdateId(inbound.updateId);
 						if (inbound.messageId !== undefined) await this.setReaction(inbound.messageId, QUEUED_REACTION);
 						return;
 					}
@@ -1983,6 +2169,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.
@@ -1998,7 +2185,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") {
@@ -2007,11 +2193,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);
 		}
@@ -2054,9 +2239,11 @@ 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.runScan();
 			// Owner-only: start the session-lifecycle control server now that
 			// ownership is confirmed (singleton-safe). Best-effort; degrades.
@@ -2117,6 +2304,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,

package/src/notifications/telegram-reference.ts

@@ -197,15 +197,9 @@ export type RouteDecision =
 	| { kind: "stale"; reason: string }
 	| { kind: "ignore" };
 
-export interface PendingAsk {
-	sessionId: string;
-	actionId: string;
-}
-
 export interface RouteInboundContext {
 	aliasTable: Pick<AliasTable, "get">;
 	messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
-	pendingBySession: (sessionId?: string) => PendingAsk[];
 	pairedChatId: string;
 }
 
@@ -250,16 +244,6 @@ export function routeInboundUpdate(update: unknown, ctx: RouteInboundContext): R
 		if (!route) return { kind: "stale", reason: "unknown_reply_message" };
 		return { kind: "reply", ...routeWithAnswer(route, text) };
 	}
-
-	if (text) {
-		const allPending = ctx.pendingBySession(undefined);
-		if (allPending.length === 1) {
-			const [pending] = allPending;
-			return { kind: "reply", sessionId: pending!.sessionId, actionId: pending!.actionId, answer: text };
-		}
-		if (allPending.length > 1) return { kind: "stale", reason: "ambiguous_plain_text" };
-	}
-
 	return { kind: "ignore" };
 }
 

package/src/prompts/system/system-prompt.md

@@ -60,9 +60,11 @@ Use for read-only plan critique. It approves only when execution can proceed wit
 
 <routing>
 - Clear, low-risk implementation request → implement directly with focused verification.
+- Informational questions, bare `?`, and unambiguous explanatory prompts are answer-only/read-only: answer from available context and do not modify files, run commands, or execute workflows unless the user explicitly asks to change, run, implement, or execute something.
 - Do not invoke `deep-interview`, `ralplan`, `ultragoal`, `team`, or role agents for simple clear implementation requests; direct tools and the default launch path are enough.
 - The runtime records a `workflow-intent-diff` CustomEntry for direct-path traceability; it does not participate in LLM context and is not a reason to slow down direct execution.
 - When a task is clear, bounded, and low-risk, the default action is to make the smallest correct change and verify it, not to interview, plan, open a durable ledger, or delegate.
+- Ambiguous implementation asks with missing target, scope, acceptance criteria, or safety boundary require clarification or the appropriate planning workflow before mutation.
 - Small verification needs do not make a task a planning workflow. Escalate only for real ambiguity, non-trivial architecture/sequence risk, durable multi-goal tracking, or useful coordinated workers.
 - Root-cause phase schema is active only for contradiction, regression, or high-risk transition work; otherwise keep ordinary verification and do not add root-cause ceremony.
 - Vague requirements → use `deep-interview` before planning or execution.
@@ -98,6 +100,7 @@ Use for read-only plan critique. It approves only when execution can proceed wit
 - Be concise and information-dense.
 - Do not narrate progress, ceremony, timing, scope inflation, or session limits.
 - If the user's intent is clear, act without asking. Ask only when the next step is destructive or requires a missing choice that materially changes the outcome.
+- Treat an informational question as a request for an answer, not implicit permission to take action; answer read-only unless the user explicitly asks for a concrete change or command execution.
 - When the user proposes something wrong, say what breaks and what to do instead once; then defer to their call.
 - Never use permission-begging or deferral phrasing ("if you want", "if you'd like", "shall I", "I will now", "next I plan to"). For a destructive next step, state the recommended action and stop for approval. For a non-destructive, clearly correct next step, do it directly in the same turn.
 - Do not defer actionable work. Underpromise and overdeliver: report only what is done or in progress, never announce remaining work instead of doing it.