@grinev/opencode-telegram-bot 0.16.1 → 0.17.0

package/dist/bot/commands/skills.js

@@ -0,0 +1,376 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { config } from "../../config.js";
+import { processUserPrompt } from "../handlers/prompt.js";
+const SKILLS_CALLBACK_PREFIX = "skills:";
+const SKILLS_CALLBACK_SELECT_PREFIX = `${SKILLS_CALLBACK_PREFIX}select:`;
+const SKILLS_CALLBACK_PAGE_PREFIX = `${SKILLS_CALLBACK_PREFIX}page:`;
+const SKILLS_CALLBACK_CANCEL = `${SKILLS_CALLBACK_PREFIX}cancel`;
+const SKILLS_CALLBACK_EXECUTE = `${SKILLS_CALLBACK_PREFIX}execute`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+function formatExecutingSkillMessage(skillName, args) {
+    const prefix = t("skills.executing_prefix");
+    const skillText = `/${skillName}`;
+    const argsSuffix = args ? ` ${args}` : "";
+    return {
+        text: `${prefix}\n${skillText}${argsSuffix}`,
+        entities: [
+            {
+                type: "code",
+                offset: prefix.length + 1,
+                length: skillText.length,
+            },
+        ],
+    };
+}
+export function buildSkillPageCallback(page) {
+    return `${SKILLS_CALLBACK_PAGE_PREFIX}${page}`;
+}
+export function parseSkillPageCallback(data) {
+    if (!data.startsWith(SKILLS_CALLBACK_PAGE_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(SKILLS_CALLBACK_PAGE_PREFIX.length);
+    const page = Number(rawPage);
+    if (!Number.isInteger(page) || page < 0) {
+        return null;
+    }
+    return page;
+}
+export function formatSkillsSelectText(page) {
+    if (page === 0) {
+        return t("skills.select");
+    }
+    return t("skills.select_page", { page: page + 1 });
+}
+function normalizeDirectoryForCommandApi(directory) {
+    return directory.replace(/\\/g, "/");
+}
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    const messageId = message.message_id;
+    return typeof messageId === "number" ? messageId : null;
+}
+function formatSkillButtonLabel(skill) {
+    const description = skill.description?.trim() || t("skills.no_description");
+    const rawLabel = `/${skill.name} - ${description}`;
+    if (rawLabel.length <= MAX_INLINE_BUTTON_LABEL_LENGTH) {
+        return rawLabel;
+    }
+    return `${rawLabel.slice(0, MAX_INLINE_BUTTON_LABEL_LENGTH - 3)}...`;
+}
+export function calculateSkillsPaginationRange(totalSkills, page, pageSize) {
+    const safePageSize = Math.max(1, pageSize);
+    const totalPages = Math.max(1, Math.ceil(totalSkills / safePageSize));
+    const normalizedPage = Math.min(Math.max(0, page), totalPages - 1);
+    const startIndex = normalizedPage * safePageSize;
+    const endIndex = Math.min(startIndex + safePageSize, totalSkills);
+    return {
+        page: normalizedPage,
+        totalPages,
+        startIndex,
+        endIndex,
+    };
+}
+function buildSkillsListKeyboard(skills, page, pageSize) {
+    const keyboard = new InlineKeyboard();
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateSkillsPaginationRange(skills.length, page, pageSize);
+    skills.slice(startIndex, endIndex).forEach((skill, index) => {
+        const globalIndex = startIndex + index;
+        keyboard
+            .text(formatSkillButtonLabel(skill), `${SKILLS_CALLBACK_SELECT_PREFIX}${globalIndex}`)
+            .row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("skills.button.prev_page"), buildSkillPageCallback(normalizedPage - 1));
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("skills.button.next_page"), buildSkillPageCallback(normalizedPage + 1));
+        }
+        keyboard.row();
+    }
+    keyboard.text(t("skills.button.cancel"), SKILLS_CALLBACK_CANCEL);
+    return keyboard;
+}
+function buildSkillsConfirmKeyboard() {
+    return new InlineKeyboard()
+        .text(t("skills.button.execute"), SKILLS_CALLBACK_EXECUTE)
+        .text(t("skills.button.cancel"), SKILLS_CALLBACK_CANCEL);
+}
+function parseSkillItems(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const skills = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object") {
+            return null;
+        }
+        const skillName = item.name;
+        if (typeof skillName !== "string" || !skillName.trim()) {
+            return null;
+        }
+        const description = item.description;
+        skills.push({
+            name: skillName,
+            description: typeof description === "string" ? description : undefined,
+        });
+    }
+    return skills;
+}
+function parseSkillsMetadata(state) {
+    if (!state || state.kind !== "custom") {
+        return null;
+    }
+    const flow = state.metadata.flow;
+    const stage = state.metadata.stage;
+    const messageId = state.metadata.messageId;
+    const projectDirectory = state.metadata.projectDirectory;
+    if (flow !== "skills" || typeof messageId !== "number" || typeof projectDirectory !== "string") {
+        return null;
+    }
+    if (stage === "list") {
+        const skills = parseSkillItems(state.metadata.skills);
+        if (!skills) {
+            return null;
+        }
+        const page = typeof state.metadata.page === "number" && Number.isInteger(state.metadata.page)
+            ? Math.max(0, state.metadata.page)
+            : 0;
+        return {
+            flow,
+            stage,
+            messageId,
+            projectDirectory,
+            skills,
+            page,
+        };
+    }
+    if (stage === "confirm") {
+        const skillName = state.metadata.skillName;
+        if (typeof skillName !== "string" || !skillName.trim()) {
+            return null;
+        }
+        return {
+            flow,
+            stage,
+            messageId,
+            projectDirectory,
+            skillName,
+        };
+    }
+    return null;
+}
+function clearSkillsInteraction(reason) {
+    const metadata = parseSkillsMetadata(interactionManager.getSnapshot());
+    if (metadata) {
+        interactionManager.clear(reason);
+    }
+}
+async function getSkillList(projectDirectory) {
+    const { data, error } = await opencodeClient.command.list({
+        directory: normalizeDirectoryForCommandApi(projectDirectory),
+    });
+    if (error || !data) {
+        throw error || new Error("No skill data received");
+    }
+    return data
+        .filter((skill) => {
+        const source = skill.source;
+        return typeof skill.name === "string" && skill.name.trim().length > 0 && source === "skill";
+    })
+        .map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+    }));
+}
+function parseSelectIndex(data) {
+    if (!data.startsWith(SKILLS_CALLBACK_SELECT_PREFIX)) {
+        return null;
+    }
+    const rawIndex = data.slice(SKILLS_CALLBACK_SELECT_PREFIX.length);
+    const index = Number(rawIndex);
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+async function executeSkill(ctx, deps, params) {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        await ctx.reply(t("bot.project_not_selected"));
+        return;
+    }
+    if (currentProject.worktree !== params.projectDirectory) {
+        logger.warn(`[Skills] Project changed between selection and execution. listedProject=${params.projectDirectory}, currentProject=${currentProject.worktree}. Using current project.`);
+    }
+    const args = params.argumentsText.trim();
+    const executingMessage = formatExecutingSkillMessage(params.skillName, args);
+    await ctx.reply(executingMessage.text, { entities: executingMessage.entities });
+    const promptText = args ? `/${params.skillName} ${args}` : `/${params.skillName}`;
+    await processUserPrompt(ctx, promptText, deps);
+}
+export async function skillsCommand(ctx) {
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("bot.project_not_selected"));
+            return;
+        }
+        const skills = await getSkillList(currentProject.worktree);
+        if (skills.length === 0) {
+            await ctx.reply(t("skills.empty"));
+            return;
+        }
+        const pageSize = config.bot.commandsListLimit;
+        const keyboard = buildSkillsListKeyboard(skills, 0, pageSize);
+        const message = await ctx.reply(formatSkillsSelectText(0), {
+            reply_markup: keyboard,
+        });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "callback",
+            metadata: {
+                flow: "skills",
+                stage: "list",
+                messageId: message.message_id,
+                projectDirectory: currentProject.worktree,
+                skills,
+                page: 0,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Skills] Error fetching skills list:", error);
+        await ctx.reply(t("skills.fetch_error"));
+    }
+}
+export async function handleSkillsCallback(ctx, deps) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(SKILLS_CALLBACK_PREFIX)) {
+        return false;
+    }
+    const metadata = parseSkillsMetadata(interactionManager.getSnapshot());
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!metadata || callbackMessageId === null || metadata.messageId !== callbackMessageId) {
+        await ctx.answerCallbackQuery({ text: t("skills.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        if (data === SKILLS_CALLBACK_CANCEL) {
+            clearSkillsInteraction("skills_cancelled");
+            await ctx.answerCallbackQuery({ text: t("skills.cancelled_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        if (data === SKILLS_CALLBACK_EXECUTE) {
+            if (metadata.stage !== "confirm") {
+                await ctx.answerCallbackQuery({ text: t("skills.inactive_callback"), show_alert: true });
+                return true;
+            }
+            clearSkillsInteraction("skills_execute_clicked");
+            await ctx.answerCallbackQuery({ text: t("skills.execute_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            await executeSkill(ctx, deps, {
+                projectDirectory: metadata.projectDirectory,
+                skillName: metadata.skillName,
+                argumentsText: "",
+            });
+            return true;
+        }
+        const page = parseSkillPageCallback(data);
+        if (page !== null) {
+            if (metadata.stage !== "list") {
+                await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+                return true;
+            }
+            const pageSize = config.bot.commandsListLimit;
+            const { page: normalizedPage, totalPages } = calculateSkillsPaginationRange(metadata.skills.length, page, pageSize);
+            if (page >= totalPages || page < 0) {
+                await ctx.answerCallbackQuery({ text: t("skills.page_empty_callback") });
+                return true;
+            }
+            const keyboard = buildSkillsListKeyboard(metadata.skills, normalizedPage, pageSize);
+            await ctx.editMessageText(formatSkillsSelectText(normalizedPage), {
+                reply_markup: keyboard,
+            });
+            await ctx.answerCallbackQuery();
+            interactionManager.transition({
+                expectedInput: "callback",
+                metadata: {
+                    flow: "skills",
+                    stage: "list",
+                    messageId: metadata.messageId,
+                    projectDirectory: metadata.projectDirectory,
+                    skills: metadata.skills,
+                    page: normalizedPage,
+                },
+            });
+            return true;
+        }
+        const skillIndex = parseSelectIndex(data);
+        if (skillIndex === null || metadata.stage !== "list") {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+            return true;
+        }
+        const selectedSkill = metadata.skills[skillIndex];
+        if (!selectedSkill) {
+            await ctx.answerCallbackQuery({ text: t("skills.inactive_callback"), show_alert: true });
+            return true;
+        }
+        await ctx.answerCallbackQuery();
+        await ctx.editMessageText(t("skills.confirm", { skill: `/${selectedSkill.name}` }), {
+            reply_markup: buildSkillsConfirmKeyboard(),
+        });
+        interactionManager.transition({
+            expectedInput: "mixed",
+            metadata: {
+                flow: "skills",
+                stage: "confirm",
+                messageId: metadata.messageId,
+                projectDirectory: metadata.projectDirectory,
+                skillName: selectedSkill.name,
+            },
+        });
+        return true;
+    }
+    catch (error) {
+        logger.error("[Skills] Error handling skill callback:", error);
+        clearSkillsInteraction("skills_callback_error");
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        return true;
+    }
+}
+export async function handleSkillTextArguments(ctx, deps) {
+    const text = ctx.message?.text;
+    if (!text || text.startsWith("/")) {
+        return false;
+    }
+    const metadata = parseSkillsMetadata(interactionManager.getSnapshot());
+    if (!metadata || metadata.stage !== "confirm") {
+        return false;
+    }
+    const argumentsText = text.trim();
+    if (!argumentsText) {
+        await ctx.reply(t("skills.arguments_empty"));
+        return true;
+    }
+    clearSkillsInteraction("skills_arguments_submitted");
+    if (ctx.chat) {
+        await ctx.api.deleteMessage(ctx.chat.id, metadata.messageId).catch(() => { });
+    }
+    await executeSkill(ctx, deps, {
+        projectDirectory: metadata.projectDirectory,
+        skillName: metadata.skillName,
+        argumentsText,
+    });
+    return true;
+}

package/dist/bot/commands/status.js

@@ -1,10 +1,10 @@
 import { opencodeClient } from "../../opencode/client.js";
+import { getGitWorktreeContext } from "../../git/worktree.js";
 import { getCurrentSession } from "../../session/manager.js";
 import { getCurrentProject, isTtsEnabled } from "../../settings/manager.js";
 import { fetchCurrentAgent } from "../../agent/manager.js";
 import { getAgentDisplayName } from "../../agent/types.js";
 import { fetchCurrentModel } from "../../model/manager.js";
-import { processManager } from "../../process/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { logger } from "../../utils/logger.js";
@@ -25,17 +25,6 @@ export async function statusCommand(ctx) {
         message += `${t("status.line.tts", {
             tts: isTtsEnabled() ? t("status.tts.on") : t("status.tts.off"),
         })}\n`;
-        // Add process management information
-        if (processManager.isRunning()) {
-            const uptime = processManager.getUptime();
-            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
-            message += `${t("status.line.managed_yes")}\n`;
-            message += `${t("status.line.pid", { pid: processManager.getPID() ?? "-" })}\n`;
-            message += `${t("status.line.uptime_sec", { seconds: uptimeStr })}\n`;
-        }
-        else {
-            message += `${t("status.line.managed_no")}\n`;
-        }
         // Add agent information
         const currentAgent = await fetchCurrentAgent();
         const agentDisplay = currentAgent
@@ -48,8 +37,26 @@ export async function statusCommand(ctx) {
         message += `${t("status.line.model", { model: modelDisplay })}\n`;
         const currentProject = getCurrentProject();
         if (currentProject) {
-            const projectName = currentProject.name || currentProject.worktree;
-            message += `\n${t("status.project_selected", { project: projectName })}\n`;
+            let projectDisplay = currentProject.worktree;
+            let linkedWorktreePath = null;
+            try {
+                const worktreeContext = await getGitWorktreeContext(currentProject.worktree);
+                if (worktreeContext) {
+                    projectDisplay = worktreeContext.branch
+                        ? `${worktreeContext.mainProjectPath}: ${worktreeContext.branch}`
+                        : worktreeContext.mainProjectPath;
+                    linkedWorktreePath = worktreeContext.isLinkedWorktree
+                        ? worktreeContext.activeWorktreePath
+                        : null;
+                }
+            }
+            catch (error) {
+                logger.debug("[Status] Could not resolve git worktree metadata", error);
+            }
+            message += `\n${t("status.project_selected", { project: projectDisplay })}\n`;
+            if (linkedWorktreePath) {
+                message += `${t("status.worktree_selected", { worktree: linkedWorktreePath })}\n`;
+            }
         }
         else {
             message += `\n${t("status.project_not_selected")}\n`;

package/dist/bot/commands/worktree.js

@@ -0,0 +1,196 @@
+import { InlineKeyboard } from "grammy";
+import { config } from "../../config.js";
+import { getGitWorktreeContext } from "../../git/worktree.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { getProjectByWorktree } from "../../project/manager.js";
+import { upsertSessionDirectory } from "../../session/cache-manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
+import { switchToProject } from "../utils/switch-project.js";
+import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
+import { buildProjectButtonLabel, calculateProjectsPaginationRange } from "./projects.js";
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const WORKTREE_CALLBACK_PREFIX = "worktree:";
+const WORKTREE_PAGE_CALLBACK_PREFIX = "worktree:page:";
+function formatWorktreeButtonLabel(label, isActive) {
+    const prefix = isActive ? "✅ " : "";
+    const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
+    if (label.length <= availableLength) {
+        return `${prefix}${label}`;
+    }
+    return `${prefix}${label.slice(0, Math.max(0, availableLength - 3))}...`;
+}
+function buildWorktreeButtonLabel(index, entry) {
+    return buildProjectButtonLabel(index, entry.path);
+}
+function parseWorktreePageCallback(data) {
+    if (!data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawPage = data.slice(WORKTREE_PAGE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawPage)) {
+        return null;
+    }
+    return Number.parseInt(rawPage, 10);
+}
+function parseWorktreeIndexCallback(data) {
+    if (!data.startsWith(WORKTREE_CALLBACK_PREFIX) ||
+        data.startsWith(WORKTREE_PAGE_CALLBACK_PREFIX)) {
+        return null;
+    }
+    const rawIndex = data.slice(WORKTREE_CALLBACK_PREFIX.length);
+    if (!/^\d+$/.test(rawIndex)) {
+        return null;
+    }
+    return Number.parseInt(rawIndex, 10);
+}
+function buildWorktreeMenuText(page, totalPages) {
+    const baseText = t("worktree.select_with_current");
+    if (totalPages <= 1) {
+        return baseText;
+    }
+    return `${baseText}\n\n${t("projects.page_indicator", {
+        current: String(page + 1),
+        total: String(totalPages),
+    })}`;
+}
+function buildWorktreeKeyboard(worktrees, page) {
+    const keyboard = new InlineKeyboard();
+    const pageSize = config.bot.projectsListLimit;
+    const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(worktrees.length, page, pageSize);
+    worktrees.slice(startIndex, endIndex).forEach((entry, index) => {
+        const label = buildWorktreeButtonLabel(startIndex + index, entry);
+        keyboard
+            .text(formatWorktreeButtonLabel(label, entry.isCurrent), `${WORKTREE_CALLBACK_PREFIX}${startIndex + index}`)
+            .row();
+    });
+    if (totalPages > 1) {
+        if (normalizedPage > 0) {
+            keyboard.text(t("projects.prev_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage - 1}`);
+        }
+        if (normalizedPage < totalPages - 1) {
+            keyboard.text(t("projects.next_page"), `${WORKTREE_PAGE_CALLBACK_PREFIX}${normalizedPage + 1}`);
+        }
+    }
+    return keyboard;
+}
+function buildWorktreeMenuView(worktrees, page) {
+    const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(worktrees.length, page, config.bot.projectsListLimit);
+    return {
+        text: buildWorktreeMenuText(normalizedPage, totalPages),
+        keyboard: buildWorktreeKeyboard(worktrees, normalizedPage),
+    };
+}
+async function loadCurrentWorktreeContext() {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        return { currentProject: null, context: null };
+    }
+    const context = await getGitWorktreeContext(currentProject.worktree);
+    return { currentProject, context };
+}
+export async function worktreeCommand(ctx) {
+    try {
+        if (isForegroundBusy()) {
+            await replyBusyBlocked(ctx);
+            return;
+        }
+        const { currentProject, context } = await loadCurrentWorktreeContext();
+        if (!currentProject) {
+            await ctx.reply(t("worktree.project_not_selected"));
+            return;
+        }
+        if (!context) {
+            await ctx.reply(t("worktree.not_git_repo"));
+            return;
+        }
+        if (context.worktrees.length === 0) {
+            await ctx.reply(t("worktree.empty"));
+            return;
+        }
+        const { text, keyboard } = buildWorktreeMenuView(context.worktrees, 0);
+        await replyWithInlineMenu(ctx, {
+            menuKind: "worktree",
+            text,
+            keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Bot] Error loading worktrees:", error);
+        await ctx.reply(t("worktree.fetch_error"));
+    }
+}
+export async function handleWorktreeCallback(ctx) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data || !callbackQuery.data.startsWith(WORKTREE_CALLBACK_PREFIX)) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    const page = parseWorktreePageCallback(callbackQuery.data);
+    const index = parseWorktreeIndexCallback(callbackQuery.data);
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "worktree");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        const { currentProject, context } = await loadCurrentWorktreeContext();
+        if (!currentProject) {
+            clearAllInteractionState("worktree_project_missing");
+            await ctx.answerCallbackQuery();
+            await ctx.reply(t("worktree.project_not_selected"));
+            return true;
+        }
+        if (!context) {
+            clearAllInteractionState("worktree_git_context_missing");
+            await ctx.answerCallbackQuery({ text: t("worktree.not_git_repo_callback") });
+            return true;
+        }
+        if (page !== null) {
+            if (context.worktrees.length === 0) {
+                await ctx.answerCallbackQuery({ text: t("worktree.page_empty_callback") });
+                return true;
+            }
+            const { text, keyboard } = buildWorktreeMenuView(context.worktrees, page);
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "worktree"),
+            });
+            return true;
+        }
+        if (index === null) {
+            await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+            return true;
+        }
+        const selectedWorktree = context.worktrees[index];
+        if (!selectedWorktree) {
+            await ctx.answerCallbackQuery({ text: t("worktree.selection_missing_callback") });
+            return true;
+        }
+        if (selectedWorktree.isCurrent) {
+            await ctx.answerCallbackQuery({ text: t("worktree.already_selected_callback") });
+            return true;
+        }
+        logger.info(`[Bot] Worktree selected: ${selectedWorktree.path}`);
+        await upsertSessionDirectory(selectedWorktree.path, Date.now());
+        const projectInfo = await getProjectByWorktree(selectedWorktree.path);
+        const replyKeyboard = await switchToProject(ctx, { ...projectInfo, name: selectedWorktree.path }, "worktree_switched");
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("worktree.selected", { worktree: selectedWorktree.path }), {
+            reply_markup: replyKeyboard,
+        });
+        await ctx.deleteMessage();
+        return true;
+    }
+    catch (error) {
+        logger.error("[Bot] Error handling worktree callback:", error);
+        clearAllInteractionState("worktree_select_error");
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") });
+        await ctx.reply(t("worktree.select_error"));
+        return true;
+    }
+}

package/dist/bot/handlers/inline-menu.js

@@ -11,6 +11,7 @@ const INLINE_MENU_KINDS = [
     "variant",
     "context",
     "open",
+    "worktree",
 ];
 function isInlineMenuKind(value) {
     return INLINE_MENU_KINDS.includes(value);

package/dist/bot/handlers/voice.js

@@ -156,8 +156,15 @@ export async function handleVoiceMessage(ctx, deps) {
             logger.warn("[Voice] Failed to edit status message with recognized text:", editError);
         }
         logger.info(`[Voice] Transcribed audio: ${recognizedText.length} chars`);
+        let textForLLM = recognizedText;
+        const notePrompt = config.stt.notePrompt.trim();
+        if (notePrompt && notePrompt.toLowerCase() !== "false" && notePrompt !== "0") {
+            const llmNote = `[Note: ${notePrompt}]`;
+            logger.debug(`[Voice] Added STT note to LLM prompt: ${llmNote}`);
+            textForLLM = `${llmNote}\n${recognizedText}`;
+        }
         // Process the recognized text as a prompt
-        await processPrompt(ctx, recognizedText, deps);
+        await processPrompt(ctx, textForLLM, deps);
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : "unknown error";