@markusylisiurunen/tau 0.3.68 → 0.3.70

package/dist/core/static/tau_docs/tui.md

@@ -51,7 +51,7 @@ When Tau is idle, Enter and Ctrl+Enter both start a normal turn. While a turn is
 
 Pending input is session state shared by attached clients while the host remains alive. It is not durable across host restart or session recovery. A queued turn captures the persona, reasoning, tools, and model settings when that turn actually starts. Steering remains part of the active logical turn and keeps the settings captured when that turn began.
 
-Escape interrupts foreground client work or the main session’s active work. If a local diff review, recording, or speech playback task owns the foreground, Escape stops that task first; otherwise it requests main-session interruption from the host. It does not stop independently running supervised subagents; select one with Alt+Down and use Ctrl+G. Press Escape twice to clear the current editor text.
+Escape interrupts foreground client work or the main session’s active work. If a local diff review, recording, or speech playback task owns the foreground, Escape stops that task first; otherwise it requests main-session interruption from the host, including cancellation of a running manual compaction. Once compaction has replaced model context, a late interruption does not undo it or turn successful persistence into a failure. It does not stop independently running supervised subagents; select one with Alt+Down and use Ctrl+G. Press Escape twice to clear the current editor text.
 
 Press Enter twice on an empty editor to retry from the current session history. Retry does not rewind or duplicate the last user message. Goal-controlled turns cannot be retried; resume a blocked goal instead.
 
@@ -199,7 +199,7 @@ The TUI also advertises diff review as a client tool unless `--no-client-tools`
 
 `/listen` and Ctrl+Y are currently macOS-only. Recording uses local `ffmpeg` with the AVFoundation audio input and stops when Ctrl+Y is pressed again, when Escape is pressed, or after 20 minutes. Startup fails if the microphone produces no audio within 15 seconds. Stopping manually or reaching the 20-minute limit finishes transcription and inserts the transcript at the cursor for review without submitting it.
 
-If transcription fails, Tau retains the local WAV and reports its path. Run `/listen retry` to transcribe the same audio again with the current provider and conversation context, or `/listen discard` to delete it. Retained recordings longer than 20 minutes are rejected rather than sent to the provider. A replacement recording deletes the retained file only after the new capture starts producing audio. Tau keeps at most one failed recording, and exiting leaves that file at the reported path for manual recovery. For live transcription, both providers extract spelling hints from recent conversation while recording begins, buffer audio until the transcription session is ready, and then stream subsequent audio. Gemini uses Gemini 3.7 Flash for hint extraction and `gemini-3.5-transcribe-live` in smart mode; OpenAI uses GPT-5.6 Luna and `gpt-live-transcribe`. Hint extraction failure does not fail transcription. On retry, Gemini uploads the retained recording for `gemini-3.5-transcribe` smart transcription and attempts to delete the remote file afterward; OpenAI uploads it to `gpt-transcribe` with recent context.
+If transcription fails, Tau retains the local WAV and reports its path. Run `/listen retry` to transcribe the same audio again with the current provider and conversation context, or `/listen discard` to delete it. Retained recordings longer than 20 minutes are rejected rather than sent to the provider. A replacement recording deletes the retained file only after the new capture starts producing audio. Tau keeps at most one failed recording, and exiting leaves that file at the reported path for manual recovery. For live transcription, both providers extract spelling hints from recent conversation while recording begins, buffer audio until the transcription session is ready, and then stream subsequent audio. Gemini uses Gemini 3.8 Flash for hint extraction and `gemini-3.5-transcribe-live` in smart mode; OpenAI uses GPT-5.6 Luna and `gpt-live-transcribe`. Hint extraction failure does not fail transcription. On retry, Gemini uploads the retained recording for `gemini-3.5-transcribe` smart transcription and attempts to delete the remote file afterward; OpenAI uploads it to `gpt-transcribe` with recent context.
 
 Install `ffmpeg` and configure a speech-to-text provider:
 

package/dist/core/telegram/adapter.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, extname, join } from "node:path";
@@ -543,7 +544,7 @@ const TelegramCallbackQuerySchema = telegramPartialObject({
     id: z.string(),
     from: TelegramUserSchema,
     data: z.string(),
-    message: telegramPartialObject({ chat: TelegramChatSchema }),
+    message: telegramPartialObject({ message_id: z.number(), chat: TelegramChatSchema }),
 });
 const TelegramUpdateSchema = telegramPartialObject({
     update_id: z.number(),
@@ -721,6 +722,14 @@ function createTelegramApi(botToken) {
                 ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
             }, z.unknown(), options.signal);
         },
+        async editMessage(chatId, messageId, text, options) {
+            await callTelegramMethod("editMessageText", {
+                chat_id: chatId,
+                message_id: messageId,
+                text,
+                reply_markup: options.replyMarkup ?? { inline_keyboard: [] },
+            }, z.unknown(), options.signal);
+        },
         async sendRichMessage(chatId, markdown, options) {
             await callTelegramMethod("sendRichMessage", {
                 chat_id: chatId,
@@ -806,6 +815,7 @@ class TelegramAdapterImpl {
     commandHandlers;
     callbackActionHandlers;
     abortController = new AbortController();
+    promptPickers = new Map();
     activeSessionsByChat = new Map();
     sessionsByChat = new Map();
     chatsBySession = new Map();
@@ -929,6 +939,11 @@ class TelegramAdapterImpl {
                 callbackAction: "status",
                 handler: async (chatId) => this.handleStatus(chatId),
             },
+            {
+                command: "/prompt",
+                description: "add a saved prompt without starting a turn",
+                handler: async (chatId, args) => this.handlePrompt(chatId, args),
+            },
             {
                 command: "/compact",
                 description: "compact session context",
@@ -1203,7 +1218,7 @@ class TelegramAdapterImpl {
             await this.answerCallbackQuery(callbackQuery.id);
             return;
         }
-        const callbackHandled = await this.handleCallback(chat.id, callbackData);
+        const callbackHandled = await this.handleCallback(chat.id, callbackData, callbackQuery.message?.message_id);
         await this.answerCallbackQuery(callbackQuery.id, callbackHandled ? "done" : undefined);
     }
     parseAudioMessage(message) {
@@ -1583,7 +1598,11 @@ class TelegramAdapterImpl {
         }
         await handler(chatId, args, sourceMessageId);
     }
-    async handleCallback(chatId, callbackData) {
+    async handleCallback(chatId, callbackData, messageId) {
+        if (callbackData.startsWith("prompt:")) {
+            await this.handlePromptCallback(chatId, callbackData, messageId);
+            return true;
+        }
         if (!callbackData.startsWith(CALLBACK_ACTION_PREFIX)) {
             return false;
         }
@@ -1650,6 +1669,101 @@ class TelegramAdapterImpl {
             await this.reply(chatId, `failed to save voice response preference: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async handlePrompt(chatId, args) {
+        if (args.length > 0) {
+            await this.reply(chatId, "use /prompt to choose a saved prompt.");
+            return;
+        }
+        const session = await this.requireActiveSession(chatId);
+        if (!session)
+            return;
+        try {
+            const snapshot = await this.getSessionManagerForChat(chatId).getSessionSnapshot(session.id);
+            if (!snapshot) {
+                await this.reply(chatId, "the session is still preparing.");
+                return;
+            }
+            const prompts = snapshot.catalog.prompts;
+            if (prompts.length === 0) {
+                await this.reply(chatId, "this session has no saved prompts.");
+                return;
+            }
+            this.promptPickers.set(chatId, { token: randomUUID(), sessionId: session.id, prompts });
+            await this.showPromptPage(chatId, 0);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+        }
+    }
+    async showPromptPage(chatId, page, messageId) {
+        const picker = this.promptPickers.get(chatId);
+        if (!picker)
+            return;
+        const start = page * 20;
+        const keyboard = picker.prompts.slice(start, start + 20).map((prompt, index) => [
+            {
+                text: prompt.label ?? prompt.id,
+                callback_data: `prompt:${picker.token}:select:${start + index}`,
+            },
+        ]);
+        const navigation = [];
+        if (page > 0)
+            navigation.push({
+                text: "previous",
+                callback_data: `prompt:${picker.token}:page:${page - 1}`,
+            });
+        if (start + 20 < picker.prompts.length)
+            navigation.push({ text: "next", callback_data: `prompt:${picker.token}:page:${page + 1}` });
+        if (navigation.length > 0)
+            keyboard.push(navigation);
+        const text = "choose a saved prompt to add to the conversation without starting a turn. selection is available only while Tau is idle.";
+        const replyMarkup = { inline_keyboard: keyboard };
+        if (messageId !== undefined) {
+            await this.sendWithRetry((signal) => this.api.editMessage(chatId, messageId, text, { replyMarkup, signal }));
+        }
+        else {
+            await this.reply(chatId, text, { replyMarkup });
+        }
+    }
+    async handlePromptCallback(chatId, data, messageId) {
+        const match = /^prompt:([^:]+):(select|page):(0|[1-9][0-9]*)$/.exec(data);
+        const picker = this.promptPickers.get(chatId);
+        if (!match ||
+            !picker ||
+            picker.token !== match[1] ||
+            this.getActiveSession(chatId)?.id !== picker.sessionId ||
+            messageId === undefined) {
+            await this.reply(chatId, "this prompt picker has expired. use /prompt to open a new one.");
+            return;
+        }
+        const index = Number(match[3]);
+        if (match[2] === "page") {
+            if (index * 20 < picker.prompts.length)
+                await this.showPromptPage(chatId, index, messageId);
+            return;
+        }
+        const prompt = picker.prompts[index];
+        if (!prompt)
+            return;
+        let text;
+        try {
+            text = await this.getSessionManagerForChat(chatId).recordPrompt(picker.sessionId, prompt.id);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+            return;
+        }
+        this.promptPickers.delete(chatId);
+        const chunks = splitTelegramMessage(`added this prompt to the conversation. send a message when you’re ready for Tau to respond.\n\n${text}`);
+        for (const [index, chunk] of chunks.entries()) {
+            if (index === 0) {
+                await this.sendWithRetry((signal) => this.api.editMessage(chatId, messageId, chunk, { signal }));
+            }
+            else {
+                await this.reply(chatId, chunk);
+            }
+        }
+    }
     async handleSetReasoning(chatId, reasoning, args) {
         if (args.length > 0) {
             await this.reply(chatId, `usage: /effort_${reasoning}`);