@grinev/opencode-telegram-bot 0.17.0 → 0.19.0

package/.env.example

@@ -15,6 +15,13 @@ TELEGRAM_ALLOWED_USER_ID=
 # OpenCode API URL (optional, default: http://localhost:4096)
 # OPENCODE_API_URL=http://localhost:4096
 
+# Automatically restart a local OpenCode server when health-checks fail (default: false)
+# Only works when OPENCODE_API_URL points to localhost / 127.0.0.1 / ::1 / 0.0.0.0.
+# OPENCODE_AUTO_RESTART_ENABLED=false
+
+# OpenCode health monitor interval in seconds when auto-restart is enabled (default: 300)
+# OPENCODE_MONITOR_INTERVAL_SEC=300
+
 # OpenCode Server Authentication (optional)
 # OPENCODE_SERVER_USERNAME=opencode
 # OPENCODE_SERVER_PASSWORD=
@@ -105,8 +112,22 @@ OPENCODE_MODEL_ID=big-pickle
 
 # Text-to-Speech credentials (optional)
 # TTS reply behavior is controlled globally with /tts and persisted in settings.json.
-# Set both TTS_API_URL and TTS_API_KEY to enable audio replies.
+# Provider: "openai" (default) or "google".
+#
+# --- OpenAI-compatible (default) ---
+# Set TTS_API_URL and TTS_API_KEY to any OpenAI-compatible TTS endpoint.
 # TTS_API_URL=
 # TTS_API_KEY=
 # TTS_MODEL=gpt-4o-mini-tts
 # TTS_VOICE=alloy
+#
+# --- Google Cloud TTS ---
+# 1. Create a project at https://console.cloud.google.com
+# 2. Enable "Cloud Text-to-Speech API"
+# 3. Create a Service Account (IAM & Admin > Service Accounts)
+#    with role "Cloud Text-to-Speech API User"
+# 4. Download the JSON key file
+# Free tier: 1M characters/month (WaveNet/Neural2), 4M/month (Standard voices)
+# TTS_PROVIDER=google
+# TTS_VOICE=en-US-Studio-O
+# GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json

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
@@ -136,6 +138,7 @@ opencode-telegram config
 | `/rename`         | Rename the current session                              |
 | `/commands`       | Browse and run custom commands                          |
 | `/skills`         | Browse and run OpenCode skills                          |
+| `/mcps`           | Browse and toggle MCP servers                           |
 | `/task`           | Create a scheduled task                                 |
 | `/tasklist`       | Browse and delete scheduled tasks                       |
 | `/opencode_start` | Start the local OpenCode server on the bot machine      |
@@ -158,6 +161,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
@@ -180,6 +195,8 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `TELEGRAM_ALLOWED_USER_ID`                 | Your numeric Telegram user ID                                                                                         |   Yes    | —                        |
 | `TELEGRAM_PROXY_URL`                       | Proxy URL for Telegram API (SOCKS5/HTTP)                                                                              |    No    | —                        |
 | `OPENCODE_API_URL`                         | OpenCode server URL                                                                                                   |    No    | `http://localhost:4096`  |
+| `OPENCODE_AUTO_RESTART_ENABLED`            | Automatically restart a local OpenCode server when health-checks fail                                                 |    No    | `false`                  |
+| `OPENCODE_MONITOR_INTERVAL_SEC`            | Health monitor interval in seconds when OpenCode auto-restart is enabled                                              |    No    | `300`                    |
 | `OPENCODE_SERVER_USERNAME`                 | Server auth username                                                                                                  |    No    | `opencode`               |
 | `OPENCODE_SERVER_PASSWORD`                 | Server auth password                                                                                                  |    No    | —                        |
 | `OPENCODE_MODEL_PROVIDER`                  | Default model provider                                                                                                |   Yes    | `opencode`               |
@@ -204,10 +221,12 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `STT_MODEL`                                | STT model name passed to `/audio/transcriptions`                                                                      |    No    | `whisper-large-v3-turbo` |
 | `STT_LANGUAGE`                             | Optional language hint (empty = provider auto-detect)                                                                 |    No    | —                        |
 | `STT_NOTE_PROMPT`                          | Optional note prepended to the LLM prompt as `[Note: ...]` for voice transcriptions; empty / `false` / `0` disable it |    No    | —                        |
-| `TTS_API_URL`                              | TTS API base URL                                                                                                      |    No    | —                        |
-| `TTS_API_KEY`                              | TTS API key                                                                                                           |    No    | —                        |
-| `TTS_MODEL`                                | TTS model name passed to `/audio/speech`                                                                              |    No    | `gpt-4o-mini-tts`        |
-| `TTS_VOICE`                                | OpenAI-compatible TTS voice name                                                                                      |    No    | `alloy`                  |
+| `TTS_PROVIDER`                             | TTS provider: `openai` for OpenAI-compatible APIs or `google` for Google Cloud TTS                                    |    No    | `openai`                 |
+| `TTS_API_URL`                              | OpenAI-compatible TTS API base URL                                                                                    |    No    | —                        |
+| `TTS_API_KEY`                              | OpenAI-compatible TTS API key                                                                                         |    No    | —                        |
+| `TTS_MODEL`                                | OpenAI-compatible TTS model name passed to `/audio/speech`                                                            |    No    | `gpt-4o-mini-tts`        |
+| `TTS_VOICE`                                | TTS voice name. Defaults to `alloy` for OpenAI-compatible APIs and `en-US-Studio-O` for Google Cloud TTS              |    No    | provider-specific        |
+| `GOOGLE_APPLICATION_CREDENTIALS`           | Path to a Google Cloud service account JSON key file for `TTS_PROVIDER=google`                                        |    No    | —                        |
 | `LOG_LEVEL`                                | Log level (`debug`, `info`, `warn`, `error`)                                                                          |    No    | `info`                   |
 | `LOG_RETENTION`                            | Number of log files to keep: launch files in `sources`, daily files in `installed`                                    |    No    | `10`                     |
 
@@ -228,15 +247,24 @@ If `STT_NOTE_PROMPT` is set to a non-empty value other than `false` or `0`, the
 
 If TTS credentials are configured, you can toggle spoken replies globally with `/tts`. The preference is stored in `settings.json` and persists across restarts.
 
-TTS configuration example:
+OpenAI-compatible TTS configuration example:
 
 ```env
+TTS_PROVIDER=openai
 TTS_API_URL=https://api.openai.com/v1
 TTS_API_KEY=your-tts-api-key
 TTS_MODEL=gpt-4o-mini-tts
 TTS_VOICE=alloy
 ```
 
+Google Cloud TTS configuration example:
+
+```env
+TTS_PROVIDER=google
+TTS_VOICE=en-US-Studio-O
+GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
+```
+
 Supported provider examples (Whisper-compatible):
 
 - **OpenAI**
@@ -312,6 +340,7 @@ npm run dev
 
 - Ensure an OpenCode server is running at the configured `OPENCODE_API_URL` (default: `http://localhost:4096`)
 - For a local setup, you can start it with `opencode serve` or use `/opencode_start` in Telegram
+- For VPS/systemd setups with scheduled tasks, enable `OPENCODE_AUTO_RESTART_ENABLED=true` to let the bot restart a local OpenCode server when health-checks fail
 - If `OPENCODE_API_URL` points to a remote server, verify that the address is reachable from the bot machine and that the remote server is healthy
 
 **No models in model picker**
@@ -330,7 +359,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/app/start-bot-app.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { cleanupBotRuntime, createBot } from "../bot/index.js";
 import { config } from "../config.js";
+import { opencodeAutoRestartService } from "../opencode/auto-restart.js";
 import { loadSettings } from "../settings/manager.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
@@ -39,6 +40,7 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await reconcileStoredModelSelection();
+    await opencodeAutoRestartService.start();
     await warmupSessionDirectoryCache();
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
@@ -73,6 +75,7 @@ export async function startBotApp() {
         shutdownStarted = true;
         logger.info(`[App] Received ${signal}, shutting down...`);
         cleanupBotRuntime(`app_shutdown_${signal.toLowerCase()}`);
+        opencodeAutoRestartService.stop();
         scheduledTaskRuntime.shutdown();
         shutdownTimeout = setTimeout(() => {
             logger.warn(`[App] Shutdown did not finish in ${SHUTDOWN_TIMEOUT_MS}ms, forcing exit.`);
@@ -114,6 +117,7 @@ export async function startBotApp() {
             shutdownTimeout = null;
         }
         cleanupBotRuntime("app_shutdown_complete");
+        opencodeAutoRestartService.stop();
         scheduledTaskRuntime.shutdown();
         await clearManagedServiceState().catch((error) => {
             logger.warn("[App] Failed to clear managed service state", error);

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,171 @@
+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;
+    }
+    if (pinnedState.messageId && pinnedState.sessionId === null) {
+        await pinnedMessageManager.restoreExistingSession(session.id, session.title);
+    }
+    else {
+        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/definitions.js

@@ -16,6 +16,7 @@ const COMMAND_DEFINITIONS = [
     { command: "rename", descriptionKey: "cmd.description.rename" },
     { command: "commands", descriptionKey: "cmd.description.commands" },
     { command: "skills", descriptionKey: "cmd.description.skills" },
+    { command: "mcps", descriptionKey: "cmd.description.mcps" },
     { command: "opencode_start", descriptionKey: "cmd.description.opencode_start" },
     { command: "opencode_stop", descriptionKey: "cmd.description.opencode_stop" },
     { command: "open", descriptionKey: "cmd.description.open" },