@grinev/opencode-telegram-bot 0.16.1 → 0.18.0

package/.env.example

@@ -51,6 +51,10 @@ OPENCODE_MODEL_ID=big-pickle
 # Maximum number of scheduled tasks allowed at once (default: 10)
 # TASK_LIMIT=10
 
+# Maximum execution time for a scheduled task in minutes (default: 120)
+# If exceeded, the bot stops waiting for the result and marks the run as failed.
+# SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES=120
+
 # Stream update throttle in milliseconds for assistant/tool message edits (default: 500)
 # Higher value = fewer Telegram edit requests, lower value = more real-time updates
 # RESPONSE_STREAM_THROTTLE_MS=500
@@ -97,6 +101,7 @@ OPENCODE_MODEL_ID=big-pickle
 # STT_API_KEY=
 # STT_MODEL=
 # STT_LANGUAGE=
+# STT_NOTE_PROMPT="The following text is transcribed from voice. It may contain homophone or phonetic errors. Infer the intended meaning from context."
 
 # Text-to-Speech credentials (optional)
 # TTS reply behavior is controlled globally with /tts and persisted in settings.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,17 +27,20 @@ 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
-- **Live status** — pinned message with current project, model, context usage, and changed files list, updated in real time
+- **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
 - **Subagent activity** — watch live subagent progress in chat, including the current task, agent, model, and active tool step
 - **Custom Commands** — run OpenCode custom commands (and built-ins like `init`/`review`) from an inline menu with confirmation
+- **Skills Catalog** — browse OpenCode skills from an inline menu and run them immediately or with arguments in the next message
 - **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, and optionally enable spoken replies with `/tts`
 - **File attachments** — send images, PDF documents, and any text-based files to OpenCode (code, logs, configs etc.)
 - **Scheduled tasks** — schedule prompts to run later or on a recurring interval; see [Scheduled Tasks](#scheduled-tasks)
 - **Context control** — compact context when it gets too large, right from the chat
 - **Input flow control** — when an interactive flow is active, the bot accepts only relevant input to keep context consistent and avoid accidental actions
+- **Git worktree switching** — browse and switch between existing git worktrees for the current repository with `/worktree`
 - **Security** — strict user ID whitelist; no one else can access your bot, even if they find it
 - **Localization** — UI localization is supported for multiple languages (`BOT_LOCALE`)
 
@@ -60,13 +64,15 @@ You'll also need your **Telegram User ID** — send any message to [@userinfobot
 
 ### 2. Start OpenCode Server
 
-Start the OpenCode server:
+Run the OpenCode server on the same machine where the bot runs:
 
 ```bash
 opencode serve
 ```
 
-> The bot connects to the OpenCode API at `http://localhost:4096` by default.
+> The bot connects to the local OpenCode API at `http://localhost:4096` by default.
+
+> After the bot is configured, you can also start and stop the local OpenCode server from Telegram with `/opencode_start` and `/opencode_stop`.
 
 ### 3. Install & Run
 
@@ -76,6 +82,8 @@ The fastest way — run directly with `npx`:
 npx @grinev/opencode-telegram-bot@latest
 ```
 
+> **Note:** This README tracks the `main` branch, which may include unreleased changes. The latest npm release may not include every feature described here yet. See [recent commits on `main`](https://github.com/grinev/opencode-telegram-bot/commits/main).
+
 > Quick start is for npm usage. You do not need to clone this repository. If you run this command from the source directory (repository root), it may fail with `opencode-telegram: not found`. To run from sources, use the [Development](#development) section.
 
 On first launch, an interactive wizard will guide you through the configuration — it asks for interface language first, then your bot token, user ID, OpenCode API URL, and optional OpenCode server credentials (username/password). After that, you're ready to go. Open your bot in Telegram and start sending tasks.
@@ -124,19 +132,21 @@ opencode-telegram config
 | `/abort`          | Abort the current task                                  |
 | `/sessions`       | Browse and switch between recent sessions               |
 | `/projects`       | Switch between OpenCode projects                        |
+| `/worktree`       | Switch between existing git worktrees                   |
 | `/open`           | Add a project by browsing directories                   |
 | `/tts`            | Toggle audio replies                                    |
 | `/rename`         | Rename the current session                              |
 | `/commands`       | Browse and run custom commands                          |
+| `/skills`         | Browse and run OpenCode skills                          |
 | `/task`           | Create a scheduled task                                 |
 | `/tasklist`       | Browse and delete scheduled tasks                       |
-| `/opencode_start` | Start the OpenCode server remotely                      |
-| `/opencode_stop`  | Stop the OpenCode server remotely                       |
+| `/opencode_start` | Start the local OpenCode server on the bot machine      |
+| `/opencode_stop`  | Stop the local OpenCode server on the bot machine       |
 | `/help`           | Show available commands                                 |
 
 Any regular text message is sent as a prompt to the coding agent only when no blocking interaction is active. Voice/audio messages are transcribed and then sent as prompts when STT is configured.
 
-> `/opencode_start` and `/opencode_stop` are intended as emergency commands — for example, if you need to restart a stuck server while away from your computer. Under normal usage, start `opencode serve` yourself before launching the bot.
+When the current project is a git repository, `/worktree` shows the existing worktrees for that repository. Status and pinned updates display the main project path with the active branch, and show a separate `Worktree` line when a linked worktree is selected.
 
 ## Scheduled Tasks
 
@@ -146,8 +156,22 @@ Scheduled tasks let you prepare prompts in advance and run them automatically la
 - Scheduled executions currently always run with the `build` agent
 - Tasks run outside your active chat session, so they do not interrupt or affect the current session flow
 - The minimum recurring interval is 5 minutes
+- If a recurring task is still running when its next interval arrives, the bot does not start a parallel copy of the same task and does not replay missed intervals later
+- 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
@@ -164,40 +188,42 @@ When installed via npm, the configuration wizard handles the initial setup. The
 - **Windows:** `%APPDATA%\opencode-telegram-bot\.env`
 - **Linux:** `~/.config/opencode-telegram-bot/.env`
 
-| Variable                        | Description                                                                                                  | Required | Default                  |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------ | :------: | ------------------------ |
-| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                                                    |   Yes    | —                        |
-| `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_SERVER_USERNAME`      | Server auth username                                                                                         |    No    | `opencode`               |
-| `OPENCODE_SERVER_PASSWORD`      | Server auth password                                                                                         |    No    | —                        |
-| `OPENCODE_MODEL_PROVIDER`       | Default model provider                                                                                       |   Yes    | `opencode`               |
-| `OPENCODE_MODEL_ID`             | Default model ID                                                                                             |   Yes    | `big-pickle`             |
-| `BOT_LOCALE`                    | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                             |    No    | `en`                     |
-| `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                                             |    No    | `10`                     |
-| `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                                             |    No    | `10`                     |
-| `OPEN_BROWSER_ROOTS`            | Comma-separated paths `/open` is allowed to browse (supports `~`)                                            |    No    | `~` (home directory)     |
-| `COMMANDS_LIST_LIMIT`           | Commands per page in `/commands`                                                                             |    No    | `10`                     |
-| `TASK_LIMIT`                    | Maximum number of scheduled tasks that can exist at once                                                     |    No    | `10`                     |
-| `BASH_TOOL_DISPLAY_MAX_LENGTH`  | Maximum displayed length for `bash` tool commands in Telegram summaries; longer commands are truncated       |    No    | `128`                    |
-| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                      |
-| `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                  |
-| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                  |
-| `HIDE_TOOL_FILE_MESSAGES`       | Hide file edit documents sent as `.txt` attachments (`edit_*.txt`, `write_*.txt`)                            |    No    | `false`                  |
-| `RESPONSE_STREAMING`            | Stream assistant replies while they are generated across one or more Telegram messages                       |    No    | `true`                   |
-| `MESSAGE_FORMAT_MODE`           | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                   |    No    | `markdown`               |
-| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                    |
-| `STT_API_URL`                   | Whisper-compatible API base URL (enables voice/audio transcription)                                          |    No    | —                        |
-| `STT_API_KEY`                   | API key for your STT provider                                                                                |    No    | —                        |
-| `STT_MODEL`                     | STT model name passed to `/audio/transcriptions`                                                             |    No    | `whisper-large-v3-turbo` |
-| `STT_LANGUAGE`                  | Optional language hint (empty = provider auto-detect)                                                        |    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`                  |
-| `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`                     |
+| Variable                                   | Description                                                                                                           | Required | Default                  |
+| ------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- | :------: | ------------------------ |
+| `TELEGRAM_BOT_TOKEN`                       | Bot token from @BotFather                                                                                             |   Yes    | —                        |
+| `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_SERVER_USERNAME`                 | Server auth username                                                                                                  |    No    | `opencode`               |
+| `OPENCODE_SERVER_PASSWORD`                 | Server auth password                                                                                                  |    No    | —                        |
+| `OPENCODE_MODEL_PROVIDER`                  | Default model provider                                                                                                |   Yes    | `opencode`               |
+| `OPENCODE_MODEL_ID`                        | Default model ID                                                                                                      |   Yes    | `big-pickle`             |
+| `BOT_LOCALE`                               | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                                      |    No    | `en`                     |
+| `SESSIONS_LIST_LIMIT`                      | Sessions per page in `/sessions`                                                                                      |    No    | `10`                     |
+| `PROJECTS_LIST_LIMIT`                      | Projects per page in `/projects`                                                                                      |    No    | `10`                     |
+| `OPEN_BROWSER_ROOTS`                       | Comma-separated paths `/open` is allowed to browse (supports `~`)                                                     |    No    | `~` (home directory)     |
+| `COMMANDS_LIST_LIMIT`                      | Items per page in `/commands` and `/skills`                                                                           |    No    | `10`                     |
+| `TASK_LIMIT`                               | Maximum number of scheduled tasks that can exist at once                                                              |    No    | `10`                     |
+| `SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES` | Maximum time the bot waits for one scheduled task run before marking it failed                                        |    No    | `120`                    |
+| `BASH_TOOL_DISPLAY_MAX_LENGTH`             | Maximum displayed length for `bash` tool commands in Telegram summaries; longer commands are truncated                |    No    | `128`                    |
+| `SERVICE_MESSAGES_INTERVAL_SEC`            | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate          |    No    | `5`                      |
+| `HIDE_THINKING_MESSAGES`                   | Hide `💭 Thinking...` service messages                                                                                |    No    | `false`                  |
+| `HIDE_TOOL_CALL_MESSAGES`                  | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                                  |    No    | `false`                  |
+| `HIDE_TOOL_FILE_MESSAGES`                  | Hide file edit documents sent as `.txt` attachments (`edit_*.txt`, `write_*.txt`)                                     |    No    | `false`                  |
+| `RESPONSE_STREAMING`                       | Stream assistant replies while they are generated across one or more Telegram messages                                |    No    | `true`                   |
+| `MESSAGE_FORMAT_MODE`                      | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                            |    No    | `markdown`               |
+| `CODE_FILE_MAX_SIZE_KB`                    | Max file size (KB) to send as document                                                                                |    No    | `100`                    |
+| `STT_API_URL`                              | Whisper-compatible API base URL (enables voice/audio transcription)                                                   |    No    | —                        |
+| `STT_API_KEY`                              | API key for your STT provider                                                                                         |    No    | —                        |
+| `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`                  |
+| `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`                     |
 
 > **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
 
@@ -212,6 +238,8 @@ If `STT_API_URL` and `STT_API_KEY` are set, the bot will:
 3. Show recognized text in chat
 4. Send the recognized text to OpenCode as a normal prompt
 
+If `STT_NOTE_PROMPT` is set to a non-empty value other than `false` or `0`, the bot prepends `[Note: ...]` to the transcription before sending it to the LLM. The recognized text shown in Telegram stays unchanged.
+
 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:
@@ -296,8 +324,9 @@ npm run dev
 
 **"OpenCode server is not available"**
 
-- Ensure `opencode serve` is running in your project directory
-- Check that `OPENCODE_API_URL` points to the correct address (default: `http://localhost:4096`)
+- 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
+- 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**
 
@@ -315,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/app/start-bot-app.js

@@ -3,7 +3,6 @@ import { readFile } from "node:fs/promises";
 import { cleanupBotRuntime, createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { loadSettings } from "../settings/manager.js";
-import { processManager } from "../process/manager.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
 import { reconcileStoredModelSelection } from "../model/manager.js";
@@ -39,7 +38,6 @@ export async function startBotApp() {
     logger.info(`Allowed User ID: ${config.telegram.allowedUserId}`);
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
-    await processManager.initialize();
     await reconcileStoredModelSelection();
     await warmupSessionDirectoryCache();
     const bot = createBot();

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/definitions.js

@@ -10,10 +10,12 @@ const COMMAND_DEFINITIONS = [
     { command: "sessions", descriptionKey: "cmd.description.sessions" },
     { command: "tts", descriptionKey: "cmd.description.tts" },
     { command: "projects", descriptionKey: "cmd.description.projects" },
+    { command: "worktree", descriptionKey: "cmd.description.worktree" },
     { command: "task", descriptionKey: "cmd.description.task" },
     { command: "tasklist", descriptionKey: "cmd.description.tasklist" },
     { command: "rename", descriptionKey: "cmd.description.rename" },
     { command: "commands", descriptionKey: "cmd.description.commands" },
+    { command: "skills", descriptionKey: "cmd.description.skills" },
     { command: "opencode_start", descriptionKey: "cmd.description.opencode_start" },
     { command: "opencode_stop", descriptionKey: "cmd.description.opencode_stop" },
     { command: "open", descriptionKey: "cmd.description.open" },