@grinev/opencode-telegram-bot 0.17.0 → 0.19.0

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);

package/dist/bot/index.js

@@ -26,6 +26,7 @@ import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands
 import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
 import { skillsCommand, handleSkillsCallback, handleSkillTextArguments, } from "./commands/skills.js";
+import { mcpsCommand, handleMcpsCallback } from "./commands/mcps.js";
 import { ttsCommand } from "./commands/tts.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
@@ -66,7 +67,11 @@ import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { assistantRunState } from "./assistant-run-state.js";
 import { ResponseStreamer } from "./streaming/response-streamer.js";
 import { ToolCallStreamer } from "./streaming/tool-call-streamer.js";
+import { attachManager } from "../attach/manager.js";
+import { markAttachedSessionBusy, markAttachedSessionIdle, restoreAttachedCurrentSession, } from "../attach/service.js";
+import { externalUserInputSuppressionManager } from "../external-input/suppression.js";
 import { prepareAssistantFinalStreamingPayload, prepareAssistantStreamingPayload, renderAssistantFinalPartsSafe, } from "./utils/assistant-rendering.js";
+import { deliverExternalUserInputNotification } from "./utils/external-user-input.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
@@ -263,6 +268,27 @@ function getToolStreamKey(tool) {
     }
     return "default";
 }
+function getEventSessionId(event) {
+    const properties = event.properties;
+    return properties.sessionID || properties.info?.sessionID || properties.part?.sessionID || null;
+}
+function shouldMarkAttachedBusyFromEvent(event) {
+    switch (event.type) {
+        case "session.status":
+            return event.properties.status?.type === "busy";
+        case "message.updated": {
+            const info = event.properties.info;
+            return info?.role === "assistant" && !info.time?.completed;
+        }
+        case "message.part.updated":
+        case "message.part.delta":
+        case "question.asked":
+        case "permission.asked":
+            return true;
+        default:
+            return false;
+    }
+}
 async function ensureCommandsInitialized(ctx, next) {
     if (commandsInitialized || !ctx.from || ctx.from.id !== config.telegram.allowedUserId) {
         await next();
@@ -388,6 +414,26 @@ async function ensureEventSubscription(directory) {
             }
         });
     });
+    summaryAggregator.setOnExternalUserInput(async (sessionId, _messageId, messageText) => {
+        void enqueueSessionCompletionTask(sessionId, async () => {
+            if (!botInstance || !chatIdInstance) {
+                return;
+            }
+            try {
+                await deliverExternalUserInputNotification({
+                    api: botInstance.api,
+                    chatId: chatIdInstance,
+                    currentSessionId: getCurrentSession()?.id ?? null,
+                    sessionId,
+                    text: messageText,
+                    consumeSuppressedInput: (incomingSessionId, incomingText) => externalUserInputSuppressionManager.consume(incomingSessionId, incomingText),
+                });
+            }
+            catch (err) {
+                logger.error("[Bot] Failed to deliver external user input to Telegram:", err);
+            }
+        });
+    });
     summaryAggregator.setOnTool(async (toolInfo) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending tool notification");
@@ -461,18 +507,19 @@ async function ensureEventSubscription(directory) {
             logger.error("Failed to send file to Telegram:", err);
         }
     });
-    summaryAggregator.setOnQuestion(async (questions, requestID) => {
+    summaryAggregator.setOnQuestion(async (questions, requestID, sessionId) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for showing questions");
             return;
         }
         const currentSession = getCurrentSession();
-        if (currentSession) {
-            await Promise.all([
-                toolMessageBatcher.flushSession(currentSession.id, "question_asked"),
-                toolCallStreamer.flushSession(currentSession.id, "question_asked"),
-            ]);
+        if (!currentSession || currentSession.id !== sessionId) {
+            return;
         }
+        await Promise.all([
+            toolMessageBatcher.flushSession(currentSession.id, "question_asked"),
+            toolCallStreamer.flushSession(currentSession.id, "question_asked"),
+        ]);
         if (questionManager.isActive()) {
             logger.warn("[Bot] Replacing active poll with a new one");
             const previousMessageIds = questionManager.getMessageIds();
@@ -503,6 +550,10 @@ async function ensureEventSubscription(directory) {
             logger.error("Bot or chat ID not available for showing permission request");
             return;
         }
+        const currentSession = getCurrentSession();
+        if (!currentSession || currentSession.id !== request.sessionID) {
+            return;
+        }
         await Promise.all([
             toolMessageBatcher.flushSession(request.sessionID, "permission_asked"),
             toolCallStreamer.flushSession(request.sessionID, "permission_asked"),
@@ -583,6 +634,7 @@ async function ensureEventSubscription(directory) {
         }
     });
     summaryAggregator.setOnSessionIdle(async (sessionId) => {
+        await markAttachedSessionIdle(sessionId);
         await sessionCompletionTasks.get(sessionId)?.catch(() => undefined);
         const completedRun = assistantRunState.finishRun(sessionId, "session_idle");
         clearPromptResponseMode(sessionId);
@@ -627,6 +679,7 @@ async function ensureEventSubscription(directory) {
         }
     });
     summaryAggregator.setOnSessionError(async (sessionId, message) => {
+        await markAttachedSessionIdle(sessionId);
         if (!botInstance || !chatIdInstance) {
             clearPromptResponseMode(sessionId);
             assistantRunState.clearRun(sessionId, "session_error_no_bot_context");
@@ -706,6 +759,11 @@ async function ensureEventSubscription(directory) {
     });
     logger.info(`[Bot] Subscribing to OpenCode events for project: ${directory}`);
     subscribeToEvents(directory, (event) => {
+        const attached = attachManager.getSnapshot();
+        const eventSessionId = getEventSessionId(event);
+        if (attached && eventSessionId === attached.sessionId && shouldMarkAttachedBusyFromEvent(event)) {
+            void markAttachedSessionBusy(attached.sessionId);
+        }
         if (event.type === "session.created" || event.type === "session.updated") {
             const info = event.properties.info;
             if (info?.directory) {
@@ -723,6 +781,7 @@ async function ensureEventSubscription(directory) {
 export function createBot() {
     clearAllInteractionState("bot_startup");
     sessionCompletionTasks.clear();
+    attachManager.clear("bot_startup");
     assistantRunState.clearAll("bot_startup");
     if (heartbeatTimer) {
         clearInterval(heartbeatTimer);
@@ -748,6 +807,8 @@ export function createBot() {
         };
     }
     const bot = new Bot(config.telegram.token, botOptions);
+    botInstance = bot;
+    chatIdInstance = config.telegram.allowedUserId;
     // Heartbeat for diagnostics: verify the event loop is not blocked
     let heartbeatCounter = 0;
     heartbeatTimer = setInterval(() => {
@@ -806,13 +867,14 @@ export function createBot() {
     bot.command("worktree", worktreeCommand);
     bot.command("open", openCommand);
     bot.command("sessions", sessionsCommand);
-    bot.command("new", newCommand);
+    bot.command("new", (ctx) => newCommand(ctx, { bot, ensureEventSubscription }));
     bot.command("abort", abortCommand);
     bot.command("task", taskCommand);
     bot.command("tasklist", taskListCommand);
     bot.command("rename", renameCommand);
     bot.command("commands", commandsCommand);
     bot.command("skills", skillsCommand);
+    bot.command("mcps", mcpsCommand);
     bot.on("message:text", unknownCommandMiddleware);
     bot.on("callback_query:data", async (ctx) => {
         logger.debug(`[Bot] Received callback_query:data: ${ctx.callbackQuery?.data}`);
@@ -827,7 +889,7 @@ export function createBot() {
                 // Clean up path index when the open-directory menu is cancelled
                 clearOpenPathIndex();
             }
-            const handledSession = await handleSessionSelect(ctx);
+            const handledSession = await handleSessionSelect(ctx, { bot, ensureEventSubscription });
             const handledProject = await handleProjectSelect(ctx);
             const handledWorktree = await handleWorktreeCallback(ctx);
             const handledOpen = await handleOpenCallback(ctx);
@@ -842,7 +904,8 @@ export function createBot() {
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
             const handledSkills = await handleSkillsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}`);
+            const handledMcps = await handleMcpsCallback(ctx);
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}, mcps=${handledMcps}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
@@ -858,7 +921,8 @@ export function createBot() {
                 !handledTaskList &&
                 !handledRenameCancel &&
                 !handledCommands &&
-                !handledSkills) {
+                !handledSkills &&
+                !handledMcps) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
                 await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
             }
@@ -960,6 +1024,14 @@ export function createBot() {
     });
     // Voice and audio message handlers (STT transcription -> prompt)
     const voicePromptDeps = { bot, ensureEventSubscription };
+    safeBackgroundTask({
+        taskName: "bot.restoreFollowedSession",
+        task: () => restoreAttachedCurrentSession({
+            bot,
+            chatId: config.telegram.allowedUserId,
+            ensureEventSubscription,
+        }),
+    });
     bot.on("message:voice", async (ctx) => {
         logger.debug(`[Bot] Received voice message, chatId=${ctx.chat.id}`);
         botInstance = bot;

package/dist/bot/middleware/interaction-guard.js

@@ -80,7 +80,7 @@ export async function interactionGuardMiddleware(ctx, next) {
     const message = decision.busy
         ? decision.state?.kind === "question" || decision.state?.kind === "permission"
             ? getInteractionBlockedMessage(decision.reason, decision.state.kind)
-            : t("interaction.blocked.finish_current")
+            : t("bot.session_busy")
         : getInteractionBlockedMessage(decision.reason, decision.state?.kind);
     logger.debug(`[InteractionGuard] Blocked input: interactionKind=${decision.state?.kind || "none"}, inputType=${decision.inputType}, reason=${decision.reason || "unknown"}, command=${decision.command || "-"}, busy=${decision.busy ? "yes" : "no"}`);
     if (ctx.callbackQuery) {

package/dist/bot/utils/busy-guard.js

@@ -1,10 +1,11 @@
 import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
+import { attachManager } from "../../attach/manager.js";
 import { t } from "../../i18n/index.js";
 export function isForegroundBusy() {
-    return foregroundSessionState.isBusy();
+    return foregroundSessionState.isBusy() || attachManager.isBusy();
 }
 export async function replyBusyBlocked(ctx) {
-    const message = t("interaction.blocked.finish_current");
+    const message = t("bot.session_busy");
     if (ctx.callbackQuery) {
         await ctx.answerCallbackQuery({ text: message }).catch(() => { });
         return;

package/dist/bot/utils/external-user-input.js

@@ -0,0 +1,46 @@
+import { t } from "../../i18n/index.js";
+import { escapePlainTextForTelegramMarkdownV2 } from "../../summary/formatter.js";
+import { sendBotText } from "./telegram-text.js";
+function normalizeExternalUserInputText(text) {
+    return text.replace(/\r\n/g, "\n").trim();
+}
+function buildQuotedPlainText(text) {
+    return text
+        .split("\n")
+        .map((line) => (line.length > 0 ? `> ${line}` : ">"))
+        .join("\n");
+}
+function buildQuotedMarkdownText(text) {
+    return text
+        .split("\n")
+        .map((line) => line.length > 0 ? `> ${escapePlainTextForTelegramMarkdownV2(line)}` : ">")
+        .join("\n");
+}
+export function buildExternalUserInputNotification(text) {
+    const normalizedText = normalizeExternalUserInputText(text);
+    if (!normalizedText) {
+        return null;
+    }
+    const title = `👤 ${t("bot.external_user_input")}`;
+    return {
+        text: `${escapePlainTextForTelegramMarkdownV2(title)}\n\n${buildQuotedMarkdownText(normalizedText)}`,
+        rawFallbackText: `${title}\n\n${buildQuotedPlainText(normalizedText)}`,
+    };
+}
+export async function deliverExternalUserInputNotification({ api, chatId, currentSessionId, sessionId, text, consumeSuppressedInput, }) {
+    const notification = buildExternalUserInputNotification(text);
+    if (!notification || currentSessionId !== sessionId) {
+        return false;
+    }
+    if (consumeSuppressedInput(sessionId, text)) {
+        return false;
+    }
+    await sendBotText({
+        api,
+        chatId,
+        text: notification.text,
+        rawFallbackText: notification.rawFallbackText,
+        format: "markdown_v2",
+    });
+    return true;
+}

package/dist/bot/utils/switch-project.js

@@ -3,6 +3,7 @@ import { clearSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
+import { detachAttachedSession } from "../../attach/service.js";
 import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
@@ -23,6 +24,7 @@ import { logger } from "../../utils/logger.js";
  * @param reason    short tag for `clearAllInteractionState` (e.g. "project_switched")
  */
 export async function switchToProject(ctx, project, reason) {
+    detachAttachedSession(reason);
     setCurrentProject(project);
     clearSession();
     summaryAggregator.clear();

package/dist/config.js

@@ -50,6 +50,18 @@ function getOptionalMessageFormatModeEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
+const VALID_TTS_PROVIDERS = ["openai", "google"];
+function getOptionalTtsProviderEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (VALID_TTS_PROVIDERS.includes(normalized)) {
+        return normalized;
+    }
+    return defaultValue;
+}
 export const config = {
     telegram: {
         token: getEnvVar("TELEGRAM_BOT_TOKEN"),
@@ -60,6 +72,8 @@ export const config = {
         apiUrl: getEnvVar("OPENCODE_API_URL", false) || "http://localhost:4096",
         username: getEnvVar("OPENCODE_SERVER_USERNAME", false) || "opencode",
         password: getEnvVar("OPENCODE_SERVER_PASSWORD", false),
+        autoRestartEnabled: getOptionalBooleanEnvVar("OPENCODE_AUTO_RESTART_ENABLED", false),
+        monitorIntervalSec: getOptionalPositiveIntEnvVar("OPENCODE_MONITOR_INTERVAL_SEC", 300),
         model: {
             provider: getEnvVar("OPENCODE_MODEL_PROVIDER", true), // Required
             modelId: getEnvVar("OPENCODE_MODEL_ID", true), // Required
@@ -95,10 +109,15 @@ export const config = {
         language: getEnvVar("STT_LANGUAGE", false),
         notePrompt: getEnvVar("STT_NOTE_PROMPT", false),
     },
-    tts: {
-        apiUrl: getEnvVar("TTS_API_URL", false),
-        apiKey: getEnvVar("TTS_API_KEY", false),
-        model: getEnvVar("TTS_MODEL", false) || "gpt-4o-mini-tts",
-        voice: getEnvVar("TTS_VOICE", false) || "alloy",
-    },
+    tts: (() => {
+        const provider = getOptionalTtsProviderEnvVar("TTS_PROVIDER", "openai");
+        const defaultVoice = provider === "google" ? "en-US-Studio-O" : "alloy";
+        return {
+            apiUrl: getEnvVar("TTS_API_URL", false),
+            apiKey: getEnvVar("TTS_API_KEY", false),
+            provider,
+            model: getEnvVar("TTS_MODEL", false) || "gpt-4o-mini-tts",
+            voice: getEnvVar("TTS_VOICE", false) || defaultVoice,
+        };
+    })(),
 };

package/dist/external-input/suppression.js

@@ -0,0 +1,54 @@
+const SUPPRESSION_TTL_MS = 60_000;
+function normalizeExternalUserInputText(text) {
+    return text.replace(/\r\n/g, "\n").trim();
+}
+class ExternalUserInputSuppressionManager {
+    entriesBySession = new Map();
+    register(sessionId, text, now = Date.now()) {
+        const normalizedText = normalizeExternalUserInputText(text);
+        if (!sessionId || !normalizedText) {
+            return;
+        }
+        this.prune(now);
+        const sessionEntries = this.entriesBySession.get(sessionId) ?? [];
+        sessionEntries.push({ text: normalizedText, createdAt: now });
+        this.entriesBySession.set(sessionId, sessionEntries);
+    }
+    consume(sessionId, text, now = Date.now()) {
+        const normalizedText = normalizeExternalUserInputText(text);
+        if (!sessionId || !normalizedText) {
+            return false;
+        }
+        this.prune(now);
+        const sessionEntries = this.entriesBySession.get(sessionId);
+        if (!sessionEntries?.length) {
+            return false;
+        }
+        const entryIndex = sessionEntries.findIndex((entry) => entry.text === normalizedText);
+        if (entryIndex < 0) {
+            return false;
+        }
+        sessionEntries.splice(entryIndex, 1);
+        if (sessionEntries.length === 0) {
+            this.entriesBySession.delete(sessionId);
+        }
+        return true;
+    }
+    clearAll() {
+        this.entriesBySession.clear();
+    }
+    __resetForTests() {
+        this.clearAll();
+    }
+    prune(now) {
+        for (const [sessionId, sessionEntries] of this.entriesBySession.entries()) {
+            const activeEntries = sessionEntries.filter((entry) => now - entry.createdAt <= SUPPRESSION_TTL_MS);
+            if (activeEntries.length === 0) {
+                this.entriesBySession.delete(sessionId);
+                continue;
+            }
+            this.entriesBySession.set(sessionId, activeEntries);
+        }
+    }
+}
+export const externalUserInputSuppressionManager = new ExternalUserInputSuppressionManager();

package/dist/i18n/de.js

@@ -10,6 +10,7 @@ export const de = {
     "cmd.description.tasklist": "Geplante Aufgaben anzeigen",
     "cmd.description.commands": "Benutzerdefinierte Befehle",
     "cmd.description.skills": "Skill-Katalog",
+    "cmd.description.mcps": "MCP servers",
     "cmd.description.opencode_start": "OpenCode-Server starten",
     "cmd.description.opencode_stop": "OpenCode-Server stoppen",
     "cmd.description.help": "Hilfe",
@@ -48,6 +49,7 @@ export const de = {
     "bot.prompt_send_error": "Anfrage konnte nicht an OpenCode gesendet werden.",
     "bot.session_error": "🔴 OpenCode meldete einen Fehler: {message}",
     "bot.session_retry": "🔁 {message}\n\nDer Provider liefert bei wiederholten Versuchen immer wieder denselben Fehler. Mit /abort abbrechen.",
+    "bot.external_user_input": "Externe Benutzereingabe",
     "bot.unknown_command": "⚠️ Unbekannter Befehl: {command}. Nutze /help, um verfügbare Befehle zu sehen.",
     "bot.photo_downloading": "⏳ Lade Foto herunter...",
     "bot.photo_too_large": "⚠️ Foto ist zu groß (max. {maxSizeMb}MB)",
@@ -113,6 +115,17 @@ export const de = {
     "sessions.preview.title": "Letzte Nachrichten:",
     "sessions.preview.you": "Du:",
     "sessions.preview.agent": "Agent:",
+    "attach.project_not_selected": "🏗 Projekt ist nicht ausgewählt.\n\nWähle zuerst ein Projekt mit /projects.",
+    "attach.session_not_selected": "💬 Keine Sitzung ausgewählt.\n\nWähle zuerst mit /sessions eine Sitzung aus.",
+    "attach.session_project_mismatch": "⚠️ Die ausgewählte Sitzung passt nicht zum aktuellen Projekt. Wähle sie über /sessions erneut aus.",
+    "attach.connected": "✅ Mit Sitzung verbunden: {title}",
+    "attach.already_connected": "ℹ️ Bereits mit Sitzung verbunden: {title}",
+    "attach.status.idle_message": "Status: idle. Warte auf neue Ereignisse.",
+    "attach.status.busy_message": "Status: busy. Neue Prompts sind vorübergehend blockiert.",
+    "attach.restored_question": "Eine ausstehende Frage für diese Sitzung wurde wiederhergestellt.",
+    "attach.restored_permissions": "Ausstehende Berechtigungsanfragen wiederhergestellt: {count}.",
+    "attach.disconnect_hint": "Zum Trennen einfach zu einer anderen Sitzung oder einem anderen Projekt wechseln.",
+    "attach.error": "🔴 Verbindung mit der aktuellen Sitzung fehlgeschlagen.",
     "new.project_not_selected": "🏗 Projekt ist nicht ausgewählt.\n\nWähle zuerst ein Projekt mit /projects.",
     "new.created": "✅ Neue Sitzung erstellt: {title}",
     "new.create_error": "🔴 OpenCode-Server ist nicht verfügbar oder beim Erstellen der Sitzung ist ein Fehler aufgetreten.",
@@ -232,6 +245,9 @@ export const de = {
     "pinned.line.project": "Projekt: {project}",
     "pinned.line.worktree": "Worktree: {worktree}",
     "pinned.line.model": "Modell: {model}",
+    "pinned.line.attach": "Tracking: {status}",
+    "pinned.attach.status.idle": "aktiv, idle",
+    "pinned.attach.status.busy": "aktiv, busy",
     "pinned.line.context": "Kontext: {used} / {limit} ({percent}%)",
     "pinned.line.cost": "Kosten: {cost} ausgegeben",
     "subagent.header": "Subagent {agent}: {description}",
@@ -349,6 +365,24 @@ export const de = {
     "skills.button.next_page": "Weiter ➡️",
     "skills.page_empty_callback": "Keine Skills auf dieser Seite",
     "skills.page_load_error_callback": "Diese Seite konnte nicht geladen werden. Bitte versuche es erneut.",
+    "mcps.select": "MCP servers:",
+    "mcps.empty": "📭 No MCP servers configured.",
+    "mcps.fetch_error": "🔴 Failed to load MCP servers.",
+    "mcps.toggle_error": "🔴 Failed to toggle MCP server.",
+    "mcps.enabling": "Enabling...",
+    "mcps.disabling": "Disabling...",
+    "mcps.status.connected": "🟢 Connected",
+    "mcps.status.disabled": "🔴 Disabled",
+    "mcps.status.failed": "⚠️ Failed",
+    "mcps.status.needs_auth": "🔒 Needs auth",
+    "mcps.status.needs_client_registration": "🔒 Needs registration",
+    "mcps.detail.title": "Server: {name}",
+    "mcps.detail.status": "Status: {status}",
+    "mcps.detail.error": "Error: {error}",
+    "mcps.button.enable": "🟢 Enable",
+    "mcps.button.disable": "🔴 Disable",
+    "mcps.button.back": "⬅️ Back",
+    "mcps.auth_required": "This server requires authorization and cannot be enabled from the bot.",
     "cmd.description.rename": "Aktuelle Sitzung umbenennen",
     "legacy.models.fetch_error": "🔴 Modellliste konnte nicht geladen werden. Prüfe den Serverstatus mit /status.",
     "legacy.models.empty": "📋 Keine verfügbaren Modelle. Konfiguriere Provider in OpenCode.",