@grinev/opencode-telegram-bot 0.21.2 → 0.22.1

package/.env.example

@@ -83,12 +83,6 @@ OPENCODE_MODEL_ID=big-pickle
 # Send scheduled task result/error messages without Telegram push notifications (default: false)
 # SCHEDULED_TASK_DISABLE_NOTIFICATION=false
 
-# Response streaming mode: "edit" (default) or "draft" (default: edit)
-# edit = uses editMessageText to update messages incrementally (may flicker)
-# draft = uses sendMessageDraft (Bot API 9.5+) for smooth animated draft previews,
-#         then finalizes with sendMessage. Only works in private chats.
-# RESPONSE_STREAMING_MODE=edit
-
 # Stream update throttle in milliseconds for assistant/tool message edits (default: 1000)
 # Higher value = fewer Telegram edit requests, lower value = more real-time updates
 # RESPONSE_STREAM_THROTTLE_MS=1000
@@ -101,15 +95,6 @@ OPENCODE_MODEL_ID=big-pickle
 # Supported locales: en, ar, de, es, fr, ru, zh
 # BOT_LOCALE=en
 
-# Hide thinking indicator messages (default: false)
-# HIDE_THINKING_MESSAGES=false
-
-# Hide tool call service messages (default: false)
-# HIDE_TOOL_CALL_MESSAGES=false
-
-# Hide tool file edit documents sent as .txt attachments (default: false)
-# HIDE_TOOL_FILE_MESSAGES=false
-
 # Track background sessions in the currently selected project/worktree (default: true)
 # Sends short notifications when detached or non-current sessions in the current directory reply,
 # ask questions, or request permissions. Other projects/worktrees are not tracked.

package/README.md

@@ -38,7 +38,8 @@ Languages: English (`en`), العربية (`ar`), Deutsch (`de`), Español (`es`
 - **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`
+- **Runtime settings** — use `/settings` to change runtime preferences; see [Runtime Settings](#runtime-settings)
+- **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, and optionally enable spoken replies in `/settings`
 - **File attachments** — send images, PDF documents, and text-based files to OpenCode, including multiple files in one Telegram album
 - **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
@@ -141,7 +142,7 @@ opencode-telegram config
 | `/worktree`       | Switch between existing git worktrees                   |
 | `/open`           | Add a project by browsing directories                   |
 | `/ls`             | List directory contents, then tap to open or download   |
-| `/tts`            | Toggle audio replies                                    |
+| `/settings`       | Change bot settings                                     |
 | `/rename`         | Rename the current session                              |
 | `/commands`       | Browse and run custom commands                          |
 | `/skills`         | Browse and run OpenCode skills                          |
@@ -229,12 +230,8 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES` | Maximum time the bot waits for one scheduled task run before marking it failed                                        |    No    | `120`                    |
 | `SCHEDULED_TASK_DISABLE_NOTIFICATION`      | Send scheduled task result/error messages without Telegram push notifications                                         |    No    | `false`                  |
 | `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`                  |
 | `TRACK_BACKGROUND_SESSIONS`                | Track detached/non-current sessions in the current selected project/worktree and send short notifications             |    No    | `true`                   |
-| `RESPONSE_STREAMING`                       | Stream assistant replies while they are generated across one or more Telegram messages                                |    No    | `true`                   |
+| `RESPONSE_STREAM_THROTTLE_MS`              | Stream update throttle in milliseconds for assistant, thinking, and tool message edits                                |    No    | `1000`                   |
 | `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    | —                        |
@@ -255,6 +252,16 @@ When installed via npm, the configuration wizard handles the initial setup. The
 
 Logs are written to `./logs` when running from sources and to the runtime config directory `logs/` folder in `installed` mode. Log rotation depends on runtime mode: `sources` creates one file per bot launch, while `installed` appends to one file per day. Old log files are removed according to `LOG_RETENTION`.
 
+### Runtime Settings
+
+Runtime preferences are changed from `/settings` and stored in `settings.json`:
+
+- Compact output mode
+- Thinking content display
+- Diff file attachments
+- Response streaming mode: `edit` or `draft (experimental)`; applies only to final assistant replies, not thinking messages
+- Audio replies: `off`, `all`, or `auto` when TTS is configured
+
 ### Reverse Proxy (Optional)
 
 For environments that block `api.telegram.org` but allow your own HTTPS endpoint (corporate networks, restricted regions), you can route Bot API traffic through a reverse proxy you control. This is an alternative to the SOCKS/HTTP forward proxy configured with `TELEGRAM_PROXY_URL`.
@@ -314,7 +321,7 @@ If `STT_API_URL` and `STT_API_KEY` are set, the bot will:
 
 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.
+If TTS credentials are configured, you can choose spoken reply behavior in `/settings`: `off` disables audio replies, `all` sends audio for every assistant reply, and `auto` sends audio only after voice/audio prompts. The preference is stored in `settings.json` and persists across restarts.
 
 OpenAI-compatible TTS configuration example:
 

package/dist/app/formatters/summary-formatter.js

@@ -227,6 +227,22 @@ export function formatCompactToolInfo(toolInfo, maxLength = 64, fallback = "-")
     }
     return `${normalized.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
 }
+export function formatCompactToolActivity(toolInfo, maxLength = 64) {
+    if (!hasCompactToolDetails(toolInfo)) {
+        return null;
+    }
+    const formatted = formatCompactToolInfo(toolInfo, maxLength, "").trim();
+    return formatted || null;
+}
+function hasCompactToolDetails(toolInfo) {
+    if (typeof toolInfo.title === "string" && toolInfo.title.trim().length > 0) {
+        return true;
+    }
+    if (toolInfo.tool === "todowrite" && Array.isArray(toolInfo.metadata?.todos)) {
+        return true;
+    }
+    return getToolDetails(toolInfo.tool, toolInfo.input).trim().length > 0;
+}
 function countLines(text) {
     return text.split("\n").length;
 }

package/dist/app/managers/summary-aggregation-manager.js

@@ -38,6 +38,7 @@ function normalizeSnapshotValue(value) {
 class SummaryAggregator {
     currentSessionId = null;
     textMessageStates = new Map();
+    thinkingMessageStates = new Map();
     messages = new Map();
     messageCount = 0;
     lastUpdated = 0;
@@ -45,10 +46,12 @@ class SummaryAggregator {
     onPartialCallback = null;
     onExternalUserInputCallback = null;
     onToolCallback = null;
+    onRootToolUpdateCallback = null;
     onToolFileCallback = null;
     onQuestionCallback = null;
     onQuestionErrorCallback = null;
     onThinkingCallback = null;
+    onThinkingFinishedCallback = null;
     onTokensCallback = null;
     onCostCallback = null;
     onSubagentCallback = null;
@@ -62,6 +65,7 @@ class SummaryAggregator {
     onClearedCallback = null;
     processedToolStates = new Set();
     thinkingFiredForMessages = new Set();
+    thinkingFinishedForMessages = new Set();
     deliveredExternalUserMessageIds = new Set();
     knownTextPartIds = new Map();
     bot = null;
@@ -93,6 +97,9 @@ class SummaryAggregator {
     setOnTool(callback) {
         this.onToolCallback = callback;
     }
+    setOnRootToolUpdate(callback) {
+        this.onRootToolUpdateCallback = callback;
+    }
     setOnToolFile(callback) {
         this.onToolFileCallback = callback;
     }
@@ -105,6 +112,9 @@ class SummaryAggregator {
     setOnThinking(callback) {
         this.onThinkingCallback = callback;
     }
+    setOnThinkingFinished(callback) {
+        this.onThinkingFinishedCallback = callback;
+    }
     setOnTokens(callback) {
         this.onTokensCallback = callback;
     }
@@ -242,11 +252,13 @@ class SummaryAggregator {
         this.stopTypingIndicator();
         this.currentSessionId = null;
         this.textMessageStates.clear();
+        this.thinkingMessageStates.clear();
         this.messages.clear();
         this.partHashes.clear();
         this.knownTextPartIds.clear();
         this.processedToolStates.clear();
         this.thinkingFiredForMessages.clear();
+        this.thinkingFinishedForMessages.clear();
         this.deliveredExternalUserMessageIds.clear();
         this.trackedSessionParents.clear();
         this.subagentStates.clear();
@@ -755,26 +767,38 @@ class SummaryAggregator {
             this.registerKnownTextPart(messageID, part.id);
             this.registerTextPart(messageID, part.id);
         }
+        if (part.type === "reasoning") {
+            this.registerThinkingPart(messageID, part.id, this.extractReasoningTitle(part));
+        }
         const deltaFromUpdated = event.properties.delta;
         if (part.type === "text" &&
             typeof deltaFromUpdated === "string" &&
             deltaFromUpdated.length > 0) {
+            this.emitThinkingFinishedOnce(part.sessionID, messageID);
             this.applyTextDelta(part.sessionID, messageID, part.id, deltaFromUpdated, part.text);
             this.lastUpdated = Date.now();
             return;
         }
+        if (part.type === "reasoning" &&
+            typeof deltaFromUpdated === "string" &&
+            deltaFromUpdated.length > 0) {
+            const partText = "text" in part && typeof part.text === "string" ? part.text : undefined;
+            this.applyThinkingDelta(part.sessionID, messageID, part.id, deltaFromUpdated, partText, this.extractReasoningTitle(part));
+            this.lastUpdated = Date.now();
+            return;
+        }
         if (part.type === "reasoning") {
-            // Fire the thinking callback once per message on the first reasoning part.
-            // This is the signal that the model is actually doing extended thinking.
-            if (!this.thinkingFiredForMessages.has(messageID) && this.onThinkingCallback) {
+            // Fire the thinking callback on every reasoning update. The first update
+            // preserves the old lightweight indicator behavior for callers that do
+            // not display full reasoning content.
+            const isFirstUpdate = !this.thinkingFiredForMessages.has(messageID);
+            if (isFirstUpdate) {
                 this.thinkingFiredForMessages.add(messageID);
-                const callback = this.onThinkingCallback;
-                const sessionID = part.sessionID;
-                setImmediate(() => {
-                    if (typeof callback === "function") {
-                        callback(sessionID);
-                    }
-                });
+            }
+            const partText = "text" in part && typeof part.text === "string" ? part.text : "";
+            const wasUpdated = this.setThinkingPartSnapshot(messageID, part.id, partText, this.extractReasoningTitle(part));
+            if (isFirstUpdate || wasUpdated) {
+                this.emitThinkingUpdate(part.sessionID, messageID, isFirstUpdate);
             }
         }
         else if (part.type === "text" && "text" in part && part.text) {
@@ -784,6 +808,7 @@ class SummaryAggregator {
             if (!wasUpdated) {
                 return;
             }
+            this.emitThinkingFinishedOnce(part.sessionID, messageID);
             const fullText = this.getCombinedMessageText(messageID);
             if (messageInfo && messageInfo.role === "assistant") {
                 this.startTypingIndicator();
@@ -808,6 +833,19 @@ class SummaryAggregator {
                 this.updateSubagentFromTaskTool(part.sessionID, input);
             }
             logger.debug(`[Aggregator] Tool event: callID=${part.callID}, tool=${part.tool}, status=${"status" in state ? state.status : "unknown"}`);
+            if (this.onRootToolUpdateCallback) {
+                this.onRootToolUpdateCallback({
+                    sessionId: part.sessionID,
+                    messageId: messageID,
+                    callId: part.callID,
+                    tool: part.tool,
+                    state: part.state,
+                    input,
+                    title,
+                    metadata: "metadata" in state ? state.metadata : undefined,
+                    hasFileAttachment: false,
+                });
+            }
             if (part.tool === "question") {
                 logger.debug(`[Aggregator] Question tool part update:`, JSON.stringify(part, null, 2));
                 // If the question tool fails, clear the active poll
@@ -871,6 +909,13 @@ class SummaryAggregator {
         if (!sessionID || !messageID || typeof delta !== "string" || delta.length === 0) {
             return;
         }
+        if (partType === "reasoning" || (!partType && this.isKnownThinkingPart(messageID, partID))) {
+            const title = part
+                ? this.extractReasoningTitle(part)
+                : undefined;
+            this.applyThinkingDelta(sessionID, messageID, partID, delta, part?.text, title);
+            return;
+        }
         if (partType && partType !== "text") {
             return;
         }
@@ -890,6 +935,7 @@ class SummaryAggregator {
                 this.registerTextPart(messageID, partID);
             }
         }
+        this.emitThinkingFinishedOnce(sessionID, messageID);
         this.applyTextDelta(sessionID, messageID, partID, delta, part?.text);
     }
     applyTextDelta(sessionID, messageID, partID, delta, fullTextHint) {
@@ -916,6 +962,121 @@ class SummaryAggregator {
         this.startTypingIndicator();
         this.emitPartialText(sessionID, messageID, combined);
     }
+    extractReasoningTitle(part) {
+        for (const key of ["title", "heading", "summary", "name"]) {
+            const value = part[key];
+            if (typeof value === "string" && value.trim()) {
+                return value;
+            }
+        }
+        const metadata = part.metadata;
+        if (metadata && typeof metadata === "object") {
+            for (const key of ["title", "heading", "summary", "name"]) {
+                const value = metadata[key];
+                if (typeof value === "string" && value.trim()) {
+                    return value;
+                }
+            }
+        }
+        return undefined;
+    }
+    getOrCreateThinkingMessageState(messageID) {
+        let state = this.thinkingMessageStates.get(messageID);
+        if (!state) {
+            state = {
+                orderedPartIds: [],
+                sections: new Map(),
+            };
+            this.thinkingMessageStates.set(messageID, state);
+        }
+        return state;
+    }
+    isKnownThinkingPart(messageID, partID) {
+        return this.thinkingMessageStates.get(messageID)?.sections.has(partID) ?? false;
+    }
+    registerThinkingPart(messageID, partID, title) {
+        const state = this.getOrCreateThinkingMessageState(messageID);
+        if (!state.orderedPartIds.includes(partID)) {
+            state.orderedPartIds.push(partID);
+        }
+        const existing = state.sections.get(partID);
+        if (!existing) {
+            const section = { id: partID, text: "" };
+            if (title) {
+                section.title = title;
+            }
+            state.sections.set(partID, section);
+            return;
+        }
+        if (title && existing.title !== title) {
+            existing.title = title;
+        }
+    }
+    setThinkingPartSnapshot(messageID, partID, text, title) {
+        this.registerThinkingPart(messageID, partID, title);
+        const state = this.getOrCreateThinkingMessageState(messageID);
+        const existing = state.sections.get(partID);
+        const nextTitle = title ?? existing?.title;
+        if (existing && existing.text === text && existing.title === nextTitle) {
+            return false;
+        }
+        const next = { id: partID, text };
+        if (nextTitle) {
+            next.title = nextTitle;
+        }
+        state.sections.set(partID, next);
+        return true;
+    }
+    applyThinkingDelta(sessionID, messageID, partID, delta, fullTextHint, title) {
+        if (sessionID !== this.currentSessionId) {
+            return;
+        }
+        this.registerThinkingPart(messageID, partID, title);
+        const state = this.getOrCreateThinkingMessageState(messageID);
+        const existing = state.sections.get(partID);
+        const previous = existing?.text ?? "";
+        let accumulated = `${previous}${delta}`;
+        if (typeof fullTextHint === "string" && fullTextHint.length > accumulated.length) {
+            accumulated = fullTextHint;
+        }
+        this.setThinkingPartSnapshot(messageID, partID, accumulated, title ?? existing?.title);
+        this.emitThinkingUpdate(sessionID, messageID, false);
+    }
+    getThinkingSections(messageID) {
+        const state = this.thinkingMessageStates.get(messageID);
+        if (!state) {
+            return [];
+        }
+        return state.orderedPartIds
+            .map((partID) => state.sections.get(partID))
+            .filter((section) => Boolean(section))
+            .map((section) => ({ ...section }));
+    }
+    emitThinkingUpdate(sessionId, messageId, isFirstUpdate) {
+        if (!this.onThinkingCallback) {
+            return;
+        }
+        const sections = this.getThinkingSections(messageId);
+        if (sections.length === 0) {
+            return;
+        }
+        const callback = this.onThinkingCallback;
+        setImmediate(() => {
+            callback({ sessionId, messageId, sections, isFirstUpdate });
+        });
+    }
+    emitThinkingFinishedOnce(sessionId, messageId) {
+        if (!this.onThinkingFinishedCallback ||
+            !this.thinkingFiredForMessages.has(messageId) ||
+            this.thinkingFinishedForMessages.has(messageId)) {
+            return;
+        }
+        this.thinkingFinishedForMessages.add(messageId);
+        const callback = this.onThinkingFinishedCallback;
+        setImmediate(() => {
+            callback(sessionId, messageId);
+        });
+    }
     emitExternalUserInputIfReady(sessionId, messageId) {
         if (sessionId !== this.currentSessionId || this.deliveredExternalUserMessageIds.has(messageId)) {
             return;
@@ -942,9 +1103,12 @@ class SummaryAggregator {
     }
     cleanupCompletedMessage(messageId) {
         this.textMessageStates.delete(messageId);
+        this.thinkingMessageStates.delete(messageId);
         this.messages.delete(messageId);
         this.partHashes.delete(messageId);
         this.knownTextPartIds.delete(messageId);
+        this.thinkingFiredForMessages.delete(messageId);
+        this.thinkingFinishedForMessages.delete(messageId);
         if (this.textMessageStates.size === 0) {
             logger.debug("[Aggregator] No more active messages, stopping typing indicator");
             this.stopTypingIndicator();

package/dist/app/services/file-download-service.js

@@ -79,12 +79,61 @@ const APPLICATION_TEXT_MIME_TYPES = new Set([
     "application/x-yaml",
     "application/sql",
 ]);
-export function isTextMimeType(mimeType) {
+const TEXT_FILE_EXTENSIONS = new Set([
+    "svelte",
+    "vue",
+    "ts",
+    "tsx",
+    "jsx",
+    "mjs",
+    "cjs",
+    "go",
+    "rs",
+    "rb",
+    "py",
+    "java",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "cs",
+    "swift",
+    "kt",
+    "kts",
+    "sh",
+    "bash",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "md",
+    "mdx",
+    "css",
+    "scss",
+    "less",
+    "html",
+    "htm",
+    "graphql",
+    "gql",
+    "proto",
+    "gradle",
+]);
+export function isTextMimeType(mimeType, filename) {
     if (!mimeType) {
         return false;
     }
     if (mimeType.startsWith("text/")) {
         return true;
     }
-    return APPLICATION_TEXT_MIME_TYPES.has(mimeType);
+    if (APPLICATION_TEXT_MIME_TYPES.has(mimeType)) {
+        return true;
+    }
+    if (filename) {
+        const ext = filename.split(".").pop()?.toLowerCase();
+        if (ext && TEXT_FILE_EXTENSIONS.has(ext)) {
+            return true;
+        }
+    }
+    return false;
 }

package/dist/app/services/scheduled-task-executor-service.js

@@ -7,6 +7,8 @@ export const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
 const EXECUTION_POLL_INTERVAL_MS = 2000;
 const MAX_IDLE_POLLS_WITHOUT_RESULT = 3;
+// Grace period for the server to start the session before any activity is seen.
+const MAX_STARTUP_POLLS_WITHOUT_ACTIVITY = 45;
 const COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS = 500;
 const MAX_COMPLETED_EMPTY_RESULT_RECHECKS = 3;
 const MODELS_DOCS_URL = "https://opencode.ai/docs/config/#models";
@@ -258,6 +260,8 @@ async function waitForScheduledTaskResult(taskId, sessionId, directory) {
     const startedAtMs = Date.now();
     const executionTimeoutMs = getExecutionTimeoutMs();
     let idlePollsWithoutResult = 0;
+    let startupPollsWithoutActivity = 0;
+    let hasObservedActivity = false;
     let completedEmptyResultReadCount = 0;
     while (true) {
         if (Date.now() - startedAtMs >= executionTimeoutMs) {
@@ -288,7 +292,13 @@ async function waitForScheduledTaskResult(taskId, sessionId, directory) {
             throw statusError || new Error("Failed to load scheduled task status");
         }
         const sessionStatus = statuses[sessionId];
-        if (!sessionStatus || sessionStatus.type === "idle") {
+        const sessionIsActive = sessionStatus !== undefined && sessionStatus.type !== "idle";
+        if (sessionIsActive) {
+            hasObservedActivity = true;
+            idlePollsWithoutResult = 0;
+            startupPollsWithoutActivity = 0;
+        }
+        else {
             const confirmedAssistantResult = await loadAssistantResult(sessionId, directory);
             if (confirmedAssistantResult.errorMessage) {
                 throw new Error(confirmedAssistantResult.errorMessage);
@@ -305,13 +315,18 @@ async function waitForScheduledTaskResult(taskId, sessionId, directory) {
                 await sleep(COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS);
                 continue;
             }
-            idlePollsWithoutResult += 1;
-            if (idlePollsWithoutResult >= MAX_IDLE_POLLS_WITHOUT_RESULT) {
-                throw new Error("Scheduled task finished without a completed assistant response");
+            if (hasObservedActivity) {
+                idlePollsWithoutResult += 1;
+                if (idlePollsWithoutResult >= MAX_IDLE_POLLS_WITHOUT_RESULT) {
+                    throw new Error("Scheduled task finished without a completed assistant response");
+                }
+            }
+            else {
+                startupPollsWithoutActivity += 1;
+                if (startupPollsWithoutActivity >= MAX_STARTUP_POLLS_WITHOUT_ACTIVITY) {
+                    throw new Error("Scheduled task did not start producing a response in time");
+                }
             }
-        }
-        else {
-            idlePollsWithoutResult = 0;
         }
         await sleep(EXECUTION_POLL_INTERVAL_MS);
     }

package/dist/app/stores/settings-store.js

@@ -66,11 +66,46 @@ export function clearSession() {
     currentSettings.currentSession = undefined;
     void writeSettingsFile(currentSettings);
 }
-export function isTtsEnabled() {
-    return currentSettings.ttsEnabled === true;
+export function getTtsMode() {
+    return currentSettings.ttsMode ?? "off";
 }
-export function setTtsEnabled(enabled) {
-    currentSettings.ttsEnabled = enabled;
+export function setTtsMode(mode) {
+    currentSettings.ttsMode = mode;
+    void writeSettingsFile(currentSettings);
+}
+export function getCompactOutputMode() {
+    return currentSettings.compactOutputMode ?? false;
+}
+export function setCompactOutputMode(enabled) {
+    currentSettings.compactOutputMode = enabled;
+    void writeSettingsFile(currentSettings);
+}
+export function getShowThinkingContent() {
+    return currentSettings.showThinkingContent ?? true;
+}
+export function setShowThinkingContent(enabled) {
+    currentSettings.showThinkingContent = enabled;
+    void writeSettingsFile(currentSettings);
+}
+export function getShowAssistantRunFooter() {
+    return currentSettings.showAssistantRunFooter ?? true;
+}
+export function setShowAssistantRunFooter(enabled) {
+    currentSettings.showAssistantRunFooter = enabled;
+    void writeSettingsFile(currentSettings);
+}
+export function getResponseStreamingMode() {
+    return currentSettings.responseStreamingMode === "draft" ? "draft" : "edit";
+}
+export function setResponseStreamingMode(mode) {
+    currentSettings.responseStreamingMode = mode;
+    void writeSettingsFile(currentSettings);
+}
+export function getSendDiffFileAttachments() {
+    return currentSettings.sendDiffFileAttachments ?? true;
+}
+export function setSendDiffFileAttachments(enabled) {
+    currentSettings.sendDiffFileAttachments = enabled;
     void writeSettingsFile(currentSettings);
 }
 export function getCurrentAgent() {
@@ -146,6 +181,13 @@ export async function loadSettings() {
         delete loadedSettings.serverProcess;
         requiresRewrite = true;
     }
+    // Migrate old ttsEnabled boolean to new ttsMode
+    if ("ttsEnabled" in loadedSettings) {
+        const oldEnabled = loadedSettings.ttsEnabled;
+        loadedSettings.ttsMode = oldEnabled === true ? "all" : "off";
+        delete loadedSettings.ttsEnabled;
+        requiresRewrite = true;
+    }
     currentSettings = loadedSettings;
     currentSettings.scheduledTasks = cloneScheduledTasks(loadedSettings.scheduledTasks) ?? [];
     currentSettings.scheduledTaskSessionIgnores =

package/dist/bot/callbacks/callback-router.js

@@ -13,6 +13,7 @@ import { handlePermissionCallback } from "./permission-callback-handler.js";
 import { handleProjectSelect } from "./project-callback-handler.js";
 import { handleQuestionCallback } from "./question-callback-handler.js";
 import { handleRenameCancel } from "./rename-callback-handler.js";
+import { handleSettingsCallback } from "./settings-callback-handler.js";
 import { handleBackgroundSessionOpen, handleSessionSelect, } from "./session-callback-handler.js";
 import { handleSkillsCallback } from "./skills-catalog-callback-handler.js";
 import { handleTaskCallback, handleTaskListCallback, } from "./scheduled-task-callback-handler.js";
@@ -57,6 +58,7 @@ export function registerCallbackRouter(bot, deps) {
             const handledModelSearchResults = await handleModelSearchResults(ctx);
             const handledModel = await handleModelSelect(ctx);
             const handledVariant = await handleVariantSelect(ctx);
+            const handledSettings = await handleSettingsCallback(ctx);
             const handledCompactConfirm = await handleCompactConfirm(ctx);
             const handledTask = await handleTaskCallback(ctx);
             const handledTaskList = await handleTaskListCallback(ctx);
@@ -74,7 +76,7 @@ export function registerCallbackRouter(bot, deps) {
                 ensureEventSubscription: deps.ensureEventSubscription,
             });
             const handledMcps = await handleMcpsCallback(ctx);
-            logger.debug(`[Bot] Callback handled: backgroundSession=${handledBackgroundSession}, inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, ls=${handledLs}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, modelSearch=${handledModelSearch}, modelSearchResults=${handledModelSearchResults}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, messages=${handledMessages}, skills=${handledSkills}, mcps=${handledMcps}`);
+            logger.debug(`[Bot] Callback handled: backgroundSession=${handledBackgroundSession}, inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, ls=${handledLs}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, modelSearch=${handledModelSearch}, modelSearchResults=${handledModelSearchResults}, model=${handledModel}, variant=${handledVariant}, settings=${handledSettings}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, messages=${handledMessages}, skills=${handledSkills}, mcps=${handledMcps}`);
             if (!handledBackgroundSession &&
                 !handledInlineCancel &&
                 !handledSession &&
@@ -89,6 +91,7 @@ export function registerCallbackRouter(bot, deps) {
                 !handledModelSearchResults &&
                 !handledModel &&
                 !handledVariant &&
+                !handledSettings &&
                 !handledCompactConfirm &&
                 !handledTask &&
                 !handledTaskList &&

package/dist/bot/callbacks/scheduled-task-callback-handler.js

@@ -100,12 +100,31 @@ function formatDateTime(dateIso, timezone) {
         return dateIso;
     }
 }
+const TASK_DETAIL_PROMPT_BYTE_BUDGET = 3400;
+function truncatePromptForDetails(prompt) {
+    if (Buffer.byteLength(prompt, "utf-8") <= TASK_DETAIL_PROMPT_BYTE_BUDGET) {
+        return prompt;
+    }
+    const budget = TASK_DETAIL_PROMPT_BYTE_BUDGET - 3;
+    let lo = 0;
+    let hi = prompt.length;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (Buffer.byteLength(prompt.slice(0, mid), "utf-8") <= budget) {
+            lo = mid;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return `${prompt.slice(0, lo)}...`;
+}
 function formatTaskDetails(task) {
     const variant = task.model.variant ? ` (${task.model.variant})` : "";
     const model = `${task.model.providerID}/${task.model.modelID}${variant}`;
     const cronLine = task.kind === "cron" ? `${t("tasklist.details.cron", { cron: task.cron })}\n` : "";
     return t("tasklist.details", {
-        prompt: task.prompt,
+        prompt: truncatePromptForDetails(task.prompt),
         project: `${task.projectWorktree}\n${t("status.line.model", { model })}`,
         schedule: task.scheduleSummary,
         cronLine,