@grinev/opencode-telegram-bot 0.17.0 → 0.18.0

package/README.md

@@ -5,6 +5,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
 [![Follow updates](https://img.shields.io/badge/-Follow%20updates-333333?logo=x)](https://x.com/grin_rus)
+[![Community](https://img.shields.io/badge/Community-Telegram-26A5E4?logo=telegram&logoColor=white)](https://t.me/+Fj_IyKRi6-41MGUy)
 
 OpenCode Telegram Bot is a secure Telegram client for [OpenCode](https://opencode.ai) CLI that runs on your local machine.
 
@@ -26,6 +27,7 @@ Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Р
 
 - **Remote coding** — send prompts to OpenCode from anywhere, receive complete results with code sent as files
 - **Session management** — create new sessions or continue existing ones, just like in the TUI
+- **Track live session** — follow a live OpenCode CLI session; see [Track Existing Session](#track-existing-session)
 - **Live status** — pinned message with current project/worktree, model, context usage, and changed files list, updated in real time
 - **Model switching** — pick models from OpenCode favorites and recent history directly in the chat (favorites are shown first)
 - **Agent modes** — switch between Plan and Build modes on the fly
@@ -158,6 +160,18 @@ Scheduled tasks let you prepare prompts in advance and run them automatically la
 - By default, the bot waits up to 120 minutes for one scheduled task run; change this with `SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES` if needed
 - Up to 10 scheduled tasks can exist at once by default; change this with `TASK_LIMIT` in your `.env`
 
+## Track Existing Session
+
+After you create a new session, select an existing one, or let the bot auto-create one from your first prompt, the bot automatically starts tracking that session. It follows live events from the same OpenCode CLI session, shows external text input sent from another TUI client, and lets you continue the same session from Telegram.
+
+For this to work, the console OpenCode instance must be started on the same port the bot connects to. By default, OpenCode starts on a random port, so use one of the setups below.
+
+- **Single TUI, simplest setup** — start OpenCode on a fixed port: `opencode --port 4096`
+- Point the bot to `http://127.0.0.1:4096`, then select or create the same session in Telegram
+- **Multiple TUI clients, shared backend** — start one backend: `opencode serve --port 4096`
+- In each terminal client, connect with: `opencode attach http://127.0.0.1:4096`
+- In the bot, select or create the same session to start tracking it automatically
+
 ## Configuration
 
 ### Localization
@@ -330,7 +344,7 @@ Please follow commit and release note conventions in [CONTRIBUTING.md](CONTRIBUT
 
 ## Community
 
-Have questions, want to share your experience using the bot, or have an idea for a feature? Join the conversation in [GitHub Discussions](https://github.com/grinev/opencode-telegram-bot/discussions).
+Have questions, want to share your experience using the bot, or have an idea for a feature? Join the [Telegram group](https://t.me/+Fj_IyKRi6-41MGUy) for announcements and discussions, or start a thread in [GitHub Discussions](https://github.com/grinev/opencode-telegram-bot/discussions).
 
 ## License
 

package/dist/attach/manager.js

@@ -0,0 +1,66 @@
+import { logger } from "../utils/logger.js";
+class AttachManager {
+    state = null;
+    attach(sessionId, directory) {
+        this.state = {
+            sessionId,
+            directory,
+            busy: false,
+        };
+        logger.info(`[Attach] Attached to session: session=${sessionId}, directory=${directory}`);
+    }
+    clear(reason) {
+        if (!this.state) {
+            return;
+        }
+        logger.info(`[Attach] Cleared attached session: reason=${reason}, session=${this.state.sessionId}, directory=${this.state.directory}`);
+        this.state = null;
+    }
+    getSnapshot() {
+        return this.state ? { ...this.state } : null;
+    }
+    isAttached() {
+        return this.state !== null;
+    }
+    isAttachedSession(sessionId, directory) {
+        if (!this.state || !sessionId) {
+            return false;
+        }
+        if (this.state.sessionId !== sessionId) {
+            return false;
+        }
+        if (directory && this.state.directory !== directory) {
+            return false;
+        }
+        return true;
+    }
+    isBusy() {
+        return this.state?.busy === true;
+    }
+    markBusy(sessionId) {
+        if (!this.state || this.state.sessionId !== sessionId) {
+            return false;
+        }
+        if (this.state.busy) {
+            return false;
+        }
+        this.state.busy = true;
+        logger.info(`[Attach] Marked attached session busy: session=${sessionId}`);
+        return true;
+    }
+    markIdle(sessionId) {
+        if (!this.state || this.state.sessionId !== sessionId) {
+            return false;
+        }
+        if (!this.state.busy) {
+            return false;
+        }
+        this.state.busy = false;
+        logger.info(`[Attach] Marked attached session idle: session=${sessionId}`);
+        return true;
+    }
+    __resetForTests() {
+        this.state = null;
+    }
+}
+export const attachManager = new AttachManager();

package/dist/attach/service.js

@@ -0,0 +1,166 @@
+import { opencodeClient } from "../opencode/client.js";
+import { stopEventListening } from "../opencode/events.js";
+import { summaryAggregator } from "../summary/aggregator.js";
+import { pinnedMessageManager } from "../pinned/manager.js";
+import { keyboardManager } from "../keyboard/manager.js";
+import { questionManager } from "../question/manager.js";
+import { permissionManager } from "../permission/manager.js";
+import { showCurrentQuestion } from "../bot/handlers/question.js";
+import { showPermissionRequest } from "../bot/handlers/permission.js";
+import { getCurrentSession } from "../session/manager.js";
+import { getCurrentProject } from "../settings/manager.js";
+import { attachManager } from "./manager.js";
+import { logger } from "../utils/logger.js";
+function getAttachBusyStatus(sessionId, statuses) {
+    if (!statuses || typeof statuses !== "object") {
+        return false;
+    }
+    const sessionStatus = statuses[sessionId];
+    return sessionStatus?.type === "busy";
+}
+async function ensureAttachPinnedSession({ api, chatId, session, }) {
+    if (!pinnedMessageManager.isInitialized()) {
+        pinnedMessageManager.initialize(api, chatId);
+    }
+    keyboardManager.initialize(api, chatId);
+    const pinnedState = pinnedMessageManager.getState();
+    if (pinnedState.sessionId === session.id && pinnedState.messageId) {
+        return;
+    }
+    await pinnedMessageManager.onSessionChange(session.id, session.title);
+    await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
+    const contextInfo = pinnedMessageManager.getContextInfo();
+    if (contextInfo) {
+        keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
+    }
+}
+async function syncPinnedAttachState() {
+    if (!pinnedMessageManager.isInitialized()) {
+        return;
+    }
+    const attached = attachManager.getSnapshot();
+    await pinnedMessageManager.setAttachState(attached !== null, attached?.busy ?? false);
+}
+async function restorePendingQuestion(bot, chatId, sessionId, directory) {
+    const { data, error } = await opencodeClient.question.list({
+        directory,
+    });
+    if (error || !data) {
+        logger.warn("[Attach] Failed to load pending questions during attach:", error);
+        return false;
+    }
+    const pendingQuestion = data.find((request) => request.sessionID === sessionId);
+    if (!pendingQuestion) {
+        return false;
+    }
+    questionManager.startQuestions(pendingQuestion.questions, pendingQuestion.id);
+    await showCurrentQuestion(bot.api, chatId);
+    return true;
+}
+async function restorePendingPermissions(bot, chatId, sessionId, directory) {
+    const { data, error } = await opencodeClient.permission.list({
+        directory,
+    });
+    if (error || !data) {
+        logger.warn("[Attach] Failed to load pending permissions during attach:", error);
+        return 0;
+    }
+    const pendingPermissions = data.filter((request) => request.sessionID === sessionId);
+    for (const request of pendingPermissions) {
+        await showPermissionRequest(bot.api, chatId, request);
+    }
+    return pendingPermissions.length;
+}
+export async function attachToSession(deps) {
+    const { bot, chatId, session, ensureEventSubscription } = deps;
+    const alreadyAttached = attachManager.isAttachedSession(session.id, session.directory);
+    await ensureAttachPinnedSession({
+        api: bot.api,
+        chatId,
+        session,
+    });
+    if (!alreadyAttached) {
+        await ensureEventSubscription(session.directory);
+        summaryAggregator.setSession(session.id);
+        summaryAggregator.setBotAndChatId(bot, chatId);
+        attachManager.attach(session.id, session.directory);
+    }
+    else {
+        summaryAggregator.setSession(session.id);
+        summaryAggregator.setBotAndChatId(bot, chatId);
+    }
+    const { data: statuses, error: statusesError } = await opencodeClient.session.status({
+        directory: session.directory,
+    });
+    if (statusesError) {
+        logger.warn("[Attach] Failed to load session status during attach:", statusesError);
+    }
+    const busy = getAttachBusyStatus(session.id, statuses);
+    if (busy) {
+        attachManager.markBusy(session.id);
+    }
+    else {
+        attachManager.markIdle(session.id);
+    }
+    await syncPinnedAttachState();
+    let restoredQuestion = false;
+    let restoredPermissions = 0;
+    if (!alreadyAttached && !questionManager.isActive() && !permissionManager.isActive()) {
+        restoredQuestion = await restorePendingQuestion(bot, chatId, session.id, session.directory);
+        if (!restoredQuestion) {
+            restoredPermissions = await restorePendingPermissions(bot, chatId, session.id, session.directory);
+        }
+    }
+    return {
+        busy,
+        alreadyAttached,
+        restoredQuestion,
+        restoredPermissions,
+    };
+}
+export async function restoreAttachedCurrentSession(deps) {
+    const currentProject = getCurrentProject();
+    const currentSession = getCurrentSession();
+    if (!currentProject || !currentSession) {
+        return false;
+    }
+    if (currentSession.directory !== currentProject.worktree) {
+        logger.warn(`[Attach] Skipping auto-restore because project/session mismatch: sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}`);
+        return false;
+    }
+    try {
+        await attachToSession({
+            bot: deps.bot,
+            chatId: deps.chatId,
+            session: currentSession,
+            ensureEventSubscription: deps.ensureEventSubscription,
+        });
+        logger.info(`[Attach] Restored followed session on startup: session=${currentSession.id}, directory=${currentSession.directory}`);
+        return true;
+    }
+    catch (error) {
+        logger.error("[Attach] Failed to restore followed session on startup:", error);
+        return false;
+    }
+}
+export function detachAttachedSession(reason) {
+    if (!attachManager.isAttached()) {
+        return;
+    }
+    stopEventListening();
+    summaryAggregator.clear();
+    attachManager.clear(reason);
+    void syncPinnedAttachState();
+}
+export async function markAttachedSessionBusy(sessionId) {
+    if (!attachManager.markBusy(sessionId)) {
+        return;
+    }
+    await syncPinnedAttachState();
+}
+export async function markAttachedSessionIdle(sessionId) {
+    if (!attachManager.markIdle(sessionId)) {
+        return;
+    }
+    await syncPinnedAttachState();
+}

package/dist/bot/commands/abort.js

@@ -1,16 +1,12 @@
 import { opencodeClient } from "../../opencode/client.js";
-import { stopEventListening } from "../../opencode/events.js";
 import { getCurrentSession } from "../../session/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { assistantRunState } from "../assistant-run-state.js";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function abortLocalStreaming() {
-    stopEventListening();
-    summaryAggregator.clear();
     clearAllInteractionState("abort_command");
 }
 async function pollSessionStatus(sessionId, directory, maxWaitMs = 5000) {

package/dist/bot/commands/commands.js

@@ -13,6 +13,8 @@ import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { config } from "../../config.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { attachToSession, detachAttachedSession, markAttachedSessionBusy, markAttachedSessionIdle, } from "../../attach/service.js";
+import { externalUserInputSuppressionManager } from "../../external-input/suppression.js";
 const COMMANDS_CALLBACK_PREFIX = "commands:";
 const COMMANDS_CALLBACK_SELECT_PREFIX = `${COMMANDS_CALLBACK_PREFIX}select:`;
 const COMMANDS_CALLBACK_PAGE_PREFIX = `${COMMANDS_CALLBACK_PREFIX}page:`;
@@ -234,6 +236,7 @@ async function ensureSessionForProject(ctx, projectDirectory) {
     let currentSession = getCurrentSession();
     if (currentSession && currentSession.directory !== projectDirectory) {
         logger.warn(`[Commands] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${projectDirectory}. Resetting session context.`);
+        detachAttachedSession("session_mismatch_reset");
         clearSession();
         summaryAggregator.clear();
         foregroundSessionState.clearAll("session_mismatch_reset");
@@ -273,9 +276,12 @@ async function executeCommand(ctx, deps, params) {
     if (!session) {
         return;
     }
-    await deps.ensureEventSubscription(session.directory);
-    summaryAggregator.setSession(session.id);
-    summaryAggregator.setBotAndChatId(deps.bot, ctx.chat.id);
+    await attachToSession({
+        bot: deps.bot,
+        chatId: ctx.chat.id,
+        session,
+        ensureEventSubscription: deps.ensureEventSubscription,
+    });
     const sessionIsBusy = await isSessionBusy(session.id, session.directory);
     if (sessionIsBusy) {
         await ctx.reply(t("bot.session_busy"));
@@ -287,12 +293,14 @@ async function executeCommand(ctx, deps, params) {
         ? `${storedModel.providerID}/${storedModel.modelID}`
         : undefined;
     foregroundSessionState.markBusy(session.id);
+    await markAttachedSessionBusy(session.id);
     assistantRunState.startRun(session.id, {
         startedAt: Date.now(),
         configuredAgent: currentAgent,
         configuredProviderID: storedModel.providerID,
         configuredModelID: storedModel.modelID,
     });
+    externalUserInputSuppressionManager.register(session.id, args ? `/${params.commandName} ${args}` : `/${params.commandName}`);
     safeBackgroundTask({
         taskName: "session.command",
         task: () => opencodeClient.session.command({
@@ -307,6 +315,7 @@ async function executeCommand(ctx, deps, params) {
         onSuccess: ({ error }) => {
             if (error) {
                 foregroundSessionState.markIdle(session.id);
+                void markAttachedSessionIdle(session.id);
                 assistantRunState.clearRun(session.id, "session_command_api_error");
                 logger.error("[Commands] OpenCode API returned an error for session.command", {
                     sessionId: session.id,
@@ -321,6 +330,7 @@ async function executeCommand(ctx, deps, params) {
         },
         onError: (error) => {
             foregroundSessionState.markIdle(session.id);
+            void markAttachedSessionIdle(session.id);
             assistantRunState.clearRun(session.id, "session_command_background_error");
             logger.error("[Commands] session.command background task failed", {
                 sessionId: session.id,

package/dist/bot/commands/new.js

@@ -3,8 +3,6 @@ import { setCurrentSession } from "../../session/manager.js";
 import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { getStoredModel } from "../../model/manager.js";
@@ -13,7 +11,8 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-export async function newCommand(ctx) {
+import { attachToSession } from "../../attach/service.js";
+export async function newCommand(ctx, deps) {
     try {
         if (isForegroundBusy()) {
             await replyBusyBlocked(ctx);
@@ -38,27 +37,20 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
-        summaryAggregator.clear();
         clearAllInteractionState("session_created");
         await ingestSessionInfoForCache(session);
-        // Initialize pinned message manager and create pinned message
-        if (!pinnedMessageManager.isInitialized()) {
-            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
-        }
-        // Initialize keyboard manager if not already
-        keyboardManager.initialize(ctx.api, ctx.chat.id);
-        try {
-            await pinnedMessageManager.onSessionChange(session.id, session.title);
-        }
-        catch (err) {
-            logger.error("[Bot] Error creating pinned message:", err);
-        }
+        await attachToSession({
+            bot: deps.bot,
+            chatId: ctx.chat.id,
+            session: sessionInfo,
+            ensureEventSubscription: deps.ensureEventSubscription,
+        });
         // Get current state for keyboard
         const currentAgent = await resolveProjectAgent(getStoredAgent());
         const currentModel = getStoredModel();
-        const contextInfo = pinnedMessageManager.getContextInfo();
-        const variantName = formatVariantForButton(currentModel.variant || "default");
         keyboardManager.updateAgent(currentAgent);
+        const contextInfo = keyboardManager.getContextInfo();
+        const variantName = formatVariantForButton(currentModel.variant || "default");
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
         await ctx.reply(t("new.created", { title: session.title }), {
             reply_markup: keyboard,

package/dist/bot/commands/sessions.js

@@ -4,8 +4,6 @@ import { resolveProjectAgent } from "../../agent/manager.js";
 import { setCurrentSession } from "../../session/manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
 import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
@@ -13,6 +11,7 @@ import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { config } from "../../config.js";
 import { getDateLocale, t } from "../../i18n/index.js";
+import { attachToSession } from "../../attach/service.js";
 const SESSION_CALLBACK_PREFIX = "session:";
 const SESSION_PAGE_CALLBACK_PREFIX = "session:page:";
 const SESSION_FETCH_EXTRA_COUNT = 1;
@@ -120,7 +119,7 @@ export async function sessionsCommand(ctx) {
         await ctx.reply(t("sessions.fetch_error"));
     }
 }
-export async function handleSessionSelect(ctx) {
+export async function handleSessionSelect(ctx, deps) {
     const callbackQuery = ctx.callbackQuery;
     if (!callbackQuery?.data || !callbackQuery.data.startsWith(SESSION_CALLBACK_PREFIX)) {
         return false;
@@ -182,7 +181,6 @@ export async function handleSessionSelect(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
-        summaryAggregator.clear();
         clearAllInteractionState("session_switched");
         await ctx.answerCallbackQuery();
         let loadingMessageId = null;
@@ -195,30 +193,31 @@ export async function handleSessionSelect(ctx) {
                 logger.error("[Sessions] Failed to send loading message:", err);
             }
         }
-        // Initialize pinned message manager if not already
-        if (!pinnedMessageManager.isInitialized() && ctx.chat) {
-            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
-        }
-        // Initialize keyboard manager if not already
-        if (ctx.chat) {
-            keyboardManager.initialize(ctx.api, ctx.chat.id);
-        }
         try {
-            // Create new pinned message for this session
-            await pinnedMessageManager.onSessionChange(session.id, session.title);
-            // Load context from session history (for existing sessions)
-            // Wait for it to complete so keyboard has correct context
-            await pinnedMessageManager.loadContextFromHistory(session.id, currentProject.worktree);
+            await attachToSession({
+                bot: deps.bot,
+                chatId: ctx.chat.id,
+                session: sessionInfo,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
         }
         catch (err) {
-            logger.error("[Bot] Error initializing pinned message:", err);
+            if (loadingMessageId) {
+                try {
+                    await ctx.api.deleteMessage(ctx.chat.id, loadingMessageId);
+                }
+                catch (deleteError) {
+                    logger.debug("[Sessions] Failed to delete loading message after follow error:", deleteError);
+                }
+            }
+            logger.error("[Sessions] Error following selected session:", err);
+            throw err;
         }
         if (ctx.chat) {
             const chatId = ctx.chat.id;
             const currentAgent = await resolveProjectAgent();
             keyboardManager.updateAgent(currentAgent);
-            // Update keyboard with loaded context (callback executes async via setImmediate, so update manually)
-            const contextInfo = pinnedMessageManager.getContextInfo();
+            const contextInfo = keyboardManager.getContextInfo();
             if (contextInfo) {
                 keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
             }

package/dist/bot/commands/start.js

@@ -10,6 +10,7 @@ import { foregroundSessionState } from "../../scheduled-task/foreground-state.js
 import { abortCurrentOperation } from "./abort.js";
 import { t } from "../../i18n/index.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { detachAttachedSession } from "../../attach/service.js";
 export async function startCommand(ctx) {
     if (ctx.chat) {
         if (!pinnedMessageManager.isInitialized()) {
@@ -18,6 +19,7 @@ export async function startCommand(ctx) {
         keyboardManager.initialize(ctx.api, ctx.chat.id);
     }
     await abortCurrentOperation(ctx, { notifyUser: false });
+    detachAttachedSession("start_command_reset");
     foregroundSessionState.clearAll("start_command_reset");
     assistantRunState.clearAll("start_command_reset");
     clearSession();

package/dist/bot/handlers/prompt.js

@@ -18,6 +18,8 @@ import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { attachToSession, detachAttachedSession, markAttachedSessionBusy, markAttachedSessionIdle, } from "../../attach/service.js";
+import { externalUserInputSuppressionManager } from "../../external-input/suppression.js";
 /** Module-level references for async callbacks that don't have ctx. */
 let botInstance = null;
 let chatIdInstance = null;
@@ -59,6 +61,7 @@ async function isSessionBusy(sessionId, directory) {
     }
 }
 async function resetMismatchedSessionContext() {
+    detachAttachedSession("session_mismatch_reset");
     stopEventListening();
     summaryAggregator.clear();
     foregroundSessionState.clearAll("session_mismatch_reset");
@@ -96,13 +99,8 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
     }
     botInstance = bot;
     chatIdInstance = ctx.chat.id;
-    // Initialize pinned message manager if not already
-    if (!pinnedMessageManager.isInitialized()) {
-        pinnedMessageManager.initialize(bot.api, ctx.chat.id);
-    }
-    // Initialize keyboard manager if not already
-    keyboardManager.initialize(bot.api, ctx.chat.id);
     let currentSession = getCurrentSession();
+    let createdNewSession = false;
     if (currentSession && currentSession.directory !== currentProject.worktree) {
         logger.warn(`[Bot] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${currentProject.worktree}. Resetting session context.`);
         await resetMismatchedSessionContext();
@@ -126,38 +124,28 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         };
         setCurrentSession(currentSession);
         await ingestSessionInfoForCache(session);
-        // Create pinned message for new session
-        try {
-            await pinnedMessageManager.onSessionChange(session.id, session.title);
-        }
-        catch (err) {
-            logger.error("[Bot] Error creating pinned message for new session:", err);
-        }
+        createdNewSession = true;
+    }
+    else {
+        logger.info(`[Bot] Using existing session: id=${currentSession.id}, title="${currentSession.title}"`);
+    }
+    await attachToSession({
+        bot,
+        chatId: ctx.chat.id,
+        session: currentSession,
+        ensureEventSubscription,
+    });
+    if (createdNewSession) {
         const currentAgent = await resolveProjectAgent(getStoredAgent());
         const currentModel = getStoredModel();
-        const contextInfo = pinnedMessageManager.getContextInfo();
-        const variantName = formatVariantForButton(currentModel.variant || "default");
         keyboardManager.updateAgent(currentAgent);
+        const contextInfo = keyboardManager.getContextInfo();
+        const variantName = formatVariantForButton(currentModel.variant || "default");
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
-        await ctx.reply(t("bot.session_created", { title: session.title }), {
+        await ctx.reply(t("bot.session_created", { title: currentSession.title }), {
             reply_markup: keyboard,
         });
     }
-    else {
-        logger.info(`[Bot] Using existing session: id=${currentSession.id}, title="${currentSession.title}"`);
-        // Ensure pinned message exists for existing session
-        if (!pinnedMessageManager.getState().messageId) {
-            try {
-                await pinnedMessageManager.onSessionChange(currentSession.id, currentSession.title);
-            }
-            catch (err) {
-                logger.error("[Bot] Error creating pinned message for existing session:", err);
-            }
-        }
-    }
-    await ensureEventSubscription(currentSession.directory);
-    summaryAggregator.setSession(currentSession.id);
-    summaryAggregator.setBotAndChatId(bot, ctx.chat.id);
     const sessionIsBusy = await isSessionBusy(currentSession.id, currentSession.directory);
     if (sessionIsBusy) {
         logger.info(`[Bot] Ignoring new prompt: session ${currentSession.id} is busy`);
@@ -211,6 +199,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         };
         logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
         foregroundSessionState.markBusy(currentSession.id);
+        await markAttachedSessionBusy(currentSession.id);
         assistantRunState.startRun(currentSession.id, {
             startedAt: Date.now(),
             configuredAgent: currentAgent,
@@ -218,6 +207,9 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             configuredModelID: storedModel.modelID,
         });
         setPromptResponseMode(currentSession.id, responseMode);
+        if (text.trim().length > 0) {
+            externalUserInputSuppressionManager.register(currentSession.id, text);
+        }
         // CRITICAL: DO NOT wait for session.prompt to complete.
         // If we wait, the handler will not finish and grammY will not call getUpdates,
         // which blocks receiving button callback_query updates.
@@ -228,6 +220,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             onSuccess: ({ error }) => {
                 if (error) {
                     foregroundSessionState.markIdle(currentSession.id);
+                    void markAttachedSessionIdle(currentSession.id);
                     assistantRunState.clearRun(currentSession.id, "session_prompt_api_error");
                     clearPromptResponseMode(currentSession.id);
                     const details = formatErrorDetails(error, 6000);
@@ -242,6 +235,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             },
             onError: (error) => {
                 foregroundSessionState.markIdle(currentSession.id);
+                void markAttachedSessionIdle(currentSession.id);
                 assistantRunState.clearRun(currentSession.id, "session_prompt_background_error");
                 clearPromptResponseMode(currentSession.id);
                 const details = formatErrorDetails(error, 6000);
@@ -256,6 +250,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
     catch (err) {
         if (currentSession) {
             foregroundSessionState.markIdle(currentSession.id);
+            await markAttachedSessionIdle(currentSession.id);
             assistantRunState.clearRun(currentSession.id, "session_prompt_handler_error");
         }
         logger.error("Error in prompt handler:", err);