@grinev/opencode-telegram-bot 0.11.4 → 0.12.1

package/dist/bot/commands/tasklist.js

@@ -0,0 +1,220 @@
+import { InlineKeyboard } from "grammy";
+import { getDateLocale, t } from "../../i18n/index.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { formatTaskListBadge } from "../../scheduled-task/display.js";
+import { scheduledTaskRuntime } from "../../scheduled-task/runtime.js";
+import { getScheduledTask, listScheduledTasks, removeScheduledTask, } from "../../scheduled-task/store.js";
+import { logger } from "../../utils/logger.js";
+const TASKLIST_CALLBACK_PREFIX = "tasklist:";
+const TASKLIST_OPEN_PREFIX = `${TASKLIST_CALLBACK_PREFIX}open:`;
+const TASKLIST_DELETE_PREFIX = `${TASKLIST_CALLBACK_PREFIX}delete:`;
+const TASKLIST_CANCEL_CALLBACK = `${TASKLIST_CALLBACK_PREFIX}cancel`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+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 parseTaskListMetadata(state) {
+    if (!state || state.kind !== "custom") {
+        return null;
+    }
+    const flow = state.metadata.flow;
+    const stage = state.metadata.stage;
+    const messageId = state.metadata.messageId;
+    if (flow !== "tasklist" || typeof messageId !== "number") {
+        return null;
+    }
+    if (stage === "list") {
+        return {
+            flow,
+            stage,
+            messageId,
+        };
+    }
+    if (stage === "detail") {
+        const taskId = state.metadata.taskId;
+        if (typeof taskId !== "string" || !taskId) {
+            return null;
+        }
+        return {
+            flow,
+            stage,
+            messageId,
+            taskId,
+        };
+    }
+    return null;
+}
+function clearTaskListInteraction(reason) {
+    const metadata = parseTaskListMetadata(interactionManager.getSnapshot());
+    if (metadata) {
+        interactionManager.clear(reason);
+    }
+}
+function truncateText(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+function formatDateTime(dateIso, timezone) {
+    if (!dateIso) {
+        return "-";
+    }
+    try {
+        return new Intl.DateTimeFormat(getDateLocale(), {
+            dateStyle: "medium",
+            timeStyle: "short",
+            timeZone: timezone,
+        }).format(new Date(dateIso));
+    }
+    catch {
+        return dateIso;
+    }
+}
+function formatTaskButtonPrefix(task) {
+    return formatTaskListBadge(task);
+}
+function formatTaskButtonLabel(task) {
+    const prefix = `[${formatTaskButtonPrefix(task)}]`;
+    const prompt = task.prompt.replace(/\s+/g, " ").trim();
+    return truncateText(`${prefix} ${prompt}`, MAX_INLINE_BUTTON_LABEL_LENGTH);
+}
+function buildTaskListKeyboard(tasks) {
+    const keyboard = new InlineKeyboard();
+    tasks.forEach((task) => {
+        keyboard.text(formatTaskButtonLabel(task), `${TASKLIST_OPEN_PREFIX}${task.id}`).row();
+    });
+    keyboard.text(t("tasklist.button.cancel"), TASKLIST_CANCEL_CALLBACK);
+    return keyboard;
+}
+function buildTaskDetailsKeyboard(taskId) {
+    return new InlineKeyboard()
+        .text(t("tasklist.button.delete"), `${TASKLIST_DELETE_PREFIX}${taskId}`)
+        .text(t("tasklist.button.cancel"), TASKLIST_CANCEL_CALLBACK);
+}
+function sortTasks(tasks) {
+    return [...tasks].sort((left, right) => {
+        const leftNextRun = left.nextRunAt ? Date.parse(left.nextRunAt) : Number.POSITIVE_INFINITY;
+        const rightNextRun = right.nextRunAt ? Date.parse(right.nextRunAt) : Number.POSITIVE_INFINITY;
+        if (leftNextRun !== rightNextRun) {
+            return leftNextRun - rightNextRun;
+        }
+        return left.createdAt.localeCompare(right.createdAt);
+    });
+}
+function formatTaskDetails(task) {
+    const cronLine = task.kind === "cron" ? `${t("tasklist.details.cron", { cron: task.cron })}\n` : "";
+    return t("tasklist.details", {
+        prompt: task.prompt,
+        project: task.projectWorktree,
+        schedule: task.scheduleSummary,
+        cronLine,
+        timezone: task.timezone,
+        nextRunAt: formatDateTime(task.nextRunAt, task.timezone),
+        lastRunAt: formatDateTime(task.lastRunAt, task.timezone),
+        runCount: String(task.runCount),
+    });
+}
+export async function taskListCommand(ctx) {
+    try {
+        const tasks = sortTasks(listScheduledTasks());
+        if (tasks.length === 0) {
+            await ctx.reply(t("tasklist.empty"));
+            return;
+        }
+        const message = await ctx.reply(t("tasklist.select"), {
+            reply_markup: buildTaskListKeyboard(tasks),
+        });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "callback",
+            metadata: {
+                flow: "tasklist",
+                stage: "list",
+                messageId: message.message_id,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[TaskList] Failed to open task list", error);
+        await ctx.reply(t("tasklist.load_error"));
+    }
+}
+export async function handleTaskListCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(TASKLIST_CALLBACK_PREFIX)) {
+        return false;
+    }
+    const metadata = parseTaskListMetadata(interactionManager.getSnapshot());
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!metadata || callbackMessageId === null || metadata.messageId !== callbackMessageId) {
+        await ctx.answerCallbackQuery({ text: t("tasklist.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        if (data === TASKLIST_CANCEL_CALLBACK) {
+            clearTaskListInteraction("tasklist_cancelled");
+            await ctx.answerCallbackQuery({ text: t("tasklist.cancelled_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        if (data.startsWith(TASKLIST_OPEN_PREFIX)) {
+            if (metadata.stage !== "list") {
+                await ctx.answerCallbackQuery({ text: t("tasklist.inactive_callback"), show_alert: true });
+                return true;
+            }
+            const taskId = data.slice(TASKLIST_OPEN_PREFIX.length);
+            const task = getScheduledTask(taskId);
+            if (!task) {
+                clearTaskListInteraction("tasklist_selected_task_missing");
+                await ctx.answerCallbackQuery({ text: t("tasklist.inactive_callback"), show_alert: true });
+                await ctx.deleteMessage().catch(() => { });
+                return true;
+            }
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(formatTaskDetails(task), {
+                reply_markup: buildTaskDetailsKeyboard(task.id),
+            });
+            interactionManager.transition({
+                expectedInput: "callback",
+                metadata: {
+                    flow: "tasklist",
+                    stage: "detail",
+                    messageId: metadata.messageId,
+                    taskId: task.id,
+                },
+            });
+            return true;
+        }
+        if (data.startsWith(TASKLIST_DELETE_PREFIX)) {
+            if (metadata.stage !== "detail") {
+                await ctx.answerCallbackQuery({ text: t("tasklist.inactive_callback"), show_alert: true });
+                return true;
+            }
+            const taskId = data.slice(TASKLIST_DELETE_PREFIX.length);
+            if (taskId !== metadata.taskId) {
+                await ctx.answerCallbackQuery({ text: t("tasklist.inactive_callback"), show_alert: true });
+                return true;
+            }
+            await removeScheduledTask(taskId);
+            scheduledTaskRuntime.removeTask(taskId);
+            clearTaskListInteraction("tasklist_deleted");
+            await ctx.answerCallbackQuery({ text: t("tasklist.deleted_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+        return true;
+    }
+    catch (error) {
+        logger.error("[TaskList] Failed to handle task list callback", error);
+        clearTaskListInteraction("tasklist_callback_error");
+        await ctx.answerCallbackQuery({ text: t("callback.processing_error") }).catch(() => { });
+        return true;
+    }
+}

package/dist/bot/handlers/prompt.js

@@ -16,6 +16,7 @@ import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { formatErrorDetails } from "../../utils/error-format.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 /** Module-level references for async callbacks that don't have ctx. */
 let botInstance = null;
 let chatIdInstance = null;
@@ -47,6 +48,7 @@ async function isSessionBusy(sessionId, directory) {
 async function resetMismatchedSessionContext() {
     stopEventListening();
     summaryAggregator.clear();
+    foregroundSessionState.clearAll("session_mismatch_reset");
     clearAllInteractionState("session_mismatch_reset");
     clearSession();
     keyboardManager.clearContext();
@@ -192,6 +194,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
             fileCount: fileParts.length,
         };
         logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
+        foregroundSessionState.markBusy(currentSession.id);
         // CRITICAL: DO NOT wait for session.prompt to complete.
         // If we wait, the handler will not finish and grammY will not call getUpdates,
         // which blocks receiving button callback_query updates.
@@ -201,6 +204,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
             task: () => opencodeClient.session.prompt(promptOptions),
             onSuccess: ({ error }) => {
                 if (error) {
+                    foregroundSessionState.markIdle(currentSession.id);
                     const details = formatErrorDetails(error, 6000);
                     logger.error("[Bot] OpenCode API returned an error for session.prompt", promptErrorLogContext);
                     logger.error("[Bot] session.prompt error details:", details);
@@ -212,6 +216,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
                 logger.info("[Bot] session.prompt completed");
             },
             onError: (error) => {
+                foregroundSessionState.markIdle(currentSession.id);
                 const details = formatErrorDetails(error, 6000);
                 logger.error("[Bot] session.prompt background task failed", promptErrorLogContext);
                 logger.error("[Bot] session.prompt background failure details:", details);
@@ -222,6 +227,9 @@ export async function processUserPrompt(ctx, text, deps, fileParts = []) {
         return true;
     }
     catch (err) {
+        if (currentSession) {
+            foregroundSessionState.markIdle(currentSession.id);
+        }
         logger.error("Error in prompt handler:", err);
         if (interactionManager.getSnapshot()) {
             clearAllInteractionState("message_handler_error");

package/dist/bot/index.js

@@ -20,6 +20,8 @@ import { abortCommand } from "./commands/abort.js";
 import { opencodeStartCommand } from "./commands/opencode-start.js";
 import { opencodeStopCommand } from "./commands/opencode-stop.js";
 import { renameCommand, handleRenameCancel, handleRenameTextAnswer } from "./commands/rename.js";
+import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands/task.js";
+import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
@@ -49,6 +51,8 @@ import { downloadTelegramFile, toDataUri } from "./utils/file-download.js";
 import { sendBotText } from "./utils/telegram-text.js";
 import { getModelCapabilities, supportsInput } from "../model/capabilities.js";
 import { getStoredModel } from "../model/manager.js";
+import { foregroundSessionState } from "../scheduled-task/foreground-state.js";
+import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 let botInstance = null;
 let chatIdInstance = null;
 let commandsInitialized = false;
@@ -57,6 +61,12 @@ const SESSION_RETRY_PREFIX = "🔁";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMP_DIR = path.join(__dirname, "..", ".tmp");
+function getCurrentReplyKeyboard() {
+    if (!keyboardManager.isInitialized()) {
+        return undefined;
+    }
+    return keyboardManager.getKeyboard();
+}
 function prepareDocumentCaption(caption) {
     const normalizedCaption = caption.trim();
     if (!normalizedCaption) {
@@ -77,8 +87,10 @@ const toolMessageBatcher = new ToolMessageBatcher({
         if (!currentSession || currentSession.id !== sessionId) {
             return;
         }
+        const keyboard = getCurrentReplyKeyboard();
         await botInstance.api.sendMessage(chatIdInstance, text, {
             disable_notification: true,
+            ...(keyboard ? { reply_markup: keyboard } : {}),
         });
     },
     sendFile: async (sessionId, fileData) => {
@@ -94,9 +106,11 @@ const toolMessageBatcher = new ToolMessageBatcher({
             logger.debug(`[Bot] Sending code file: ${fileData.filename} (${fileData.buffer.length} bytes, session=${sessionId})`);
             await fs.mkdir(TEMP_DIR, { recursive: true });
             await fs.writeFile(tempFilePath, fileData.buffer);
+            const keyboard = getCurrentReplyKeyboard();
             await botInstance.api.sendDocument(chatIdInstance, new InputFile(tempFilePath), {
                 caption: fileData.caption,
                 disable_notification: true,
+                ...(keyboard ? { reply_markup: keyboard } : {}),
             });
         }
         finally {
@@ -141,10 +155,13 @@ async function ensureEventSubscription(directory) {
     summaryAggregator.setOnComplete(async (sessionId, messageText) => {
         if (!botInstance || !chatIdInstance) {
             logger.error("Bot or chat ID not available for sending message");
+            foregroundSessionState.markIdle(sessionId);
             return;
         }
         const currentSession = getCurrentSession();
         if (currentSession?.id !== sessionId) {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
             return;
         }
         await toolMessageBatcher.flushSession(sessionId, "assistant_message_completed");
@@ -154,8 +171,7 @@ async function ensureEventSubscription(directory) {
             const assistantMessageFormat = assistantParseMode === "MarkdownV2" ? "markdown_v2" : "raw";
             logger.debug(`[Bot] Sending completed message to Telegram (chatId=${chatIdInstance}, parts=${parts.length})`);
             for (let i = 0; i < parts.length; i++) {
-                const isLastPart = i === parts.length - 1;
-                const keyboard = isLastPart && keyboardManager.isInitialized() ? keyboardManager.getKeyboard() : undefined;
+                const keyboard = getCurrentReplyKeyboard();
                 const options = keyboard ? { reply_markup: keyboard } : undefined;
                 await sendBotText({
                     api: botInstance.api,
@@ -172,6 +188,10 @@ async function ensureEventSubscription(directory) {
             logger.error("[Bot] CRITICAL: Stopping event processing due to error");
             summaryAggregator.clear();
         }
+        finally {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
+        }
     });
     summaryAggregator.setOnTool(async (toolInfo) => {
         if (!botInstance || !chatIdInstance) {
@@ -294,6 +314,18 @@ async function ensureEventSubscription(directory) {
             logger.error("[Bot] Error updating pinned message with tokens:", err);
         }
     });
+    summaryAggregator.setOnCost(async (cost) => {
+        if (!pinnedMessageManager.isInitialized()) {
+            return;
+        }
+        try {
+            logger.debug(`[Bot] Cost update: $${cost.toFixed(2)}`);
+            await pinnedMessageManager.onCostUpdate(cost);
+        }
+        catch (err) {
+            logger.error("[Bot] Error updating cost:", err);
+        }
+    });
     summaryAggregator.setOnSessionCompacted(async (sessionId, directory) => {
         if (!pinnedMessageManager.isInitialized()) {
             return;
@@ -308,10 +340,13 @@ async function ensureEventSubscription(directory) {
     });
     summaryAggregator.setOnSessionError(async (sessionId, message) => {
         if (!botInstance || !chatIdInstance) {
+            foregroundSessionState.markIdle(sessionId);
             return;
         }
         const currentSession = getCurrentSession();
         if (!currentSession || currentSession.id !== sessionId) {
+            foregroundSessionState.markIdle(sessionId);
+            await scheduledTaskRuntime.flushDeferredDeliveries();
             return;
         }
         await toolMessageBatcher.flushSession(sessionId, "session_error");
@@ -324,6 +359,8 @@ async function ensureEventSubscription(directory) {
             .catch((err) => {
             logger.error("[Bot] Failed to send session.error message:", err);
         });
+        foregroundSessionState.markIdle(sessionId);
+        await scheduledTaskRuntime.flushDeferredDeliveries();
     });
     summaryAggregator.setOnSessionRetry(async ({ sessionId, message }) => {
         if (!botInstance || !chatIdInstance) {
@@ -458,6 +495,8 @@ export function createBot() {
     bot.command("sessions", sessionsCommand);
     bot.command("new", newCommand);
     bot.command("abort", abortCommand);
+    bot.command("task", taskCommand);
+    bot.command("tasklist", taskListCommand);
     bot.command("rename", renameCommand);
     bot.command("commands", commandsCommand);
     bot.on("message:text", unknownCommandMiddleware);
@@ -478,9 +517,11 @@ export function createBot() {
             const handledModel = await handleModelSelect(ctx);
             const handledVariant = await handleVariantSelect(ctx);
             const handledCompactConfirm = await handleCompactConfirm(ctx);
+            const handledTask = await handleTaskCallback(ctx);
+            const handledTaskList = await handleTaskListCallback(ctx);
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, rename=${handledRenameCancel}, commands=${handledCommands}`);
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
@@ -490,6 +531,8 @@ export function createBot() {
                 !handledModel &&
                 !handledVariant &&
                 !handledCompactConfirm &&
+                !handledTask &&
+                !handledTaskList &&
                 !handledRenameCancel &&
                 !handledCommands) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
@@ -677,6 +720,10 @@ export function createBot() {
             await handleQuestionTextAnswer(ctx);
             return;
         }
+        const handledTask = await handleTaskTextInput(ctx);
+        if (handledTask) {
+            return;
+        }
         const handledRename = await handleRenameTextAnswer(ctx);
         if (handledRename) {
             return;

package/dist/bot/middleware/interaction-guard.js

@@ -46,6 +46,17 @@ function getInteractionBlockedMessage(reason, interactionKind) {
                 return t("rename.blocked.expected_name");
         }
     }
+    if (interactionKind === "task") {
+        switch (reason) {
+            case "command_not_allowed":
+                return t("task.blocked.command_not_allowed");
+            case "expected_callback":
+            case "expected_command":
+            case "expected_text":
+            default:
+                return t("task.blocked.expected_input");
+        }
+    }
     switch (reason) {
         case "expired":
             return t("interaction.blocked.expired");

package/dist/config.js

@@ -85,6 +85,7 @@ export const config = {
     bot: {
         sessionsListLimit: getOptionalPositiveIntEnvVar("SESSIONS_LIST_LIMIT", 10),
         projectsListLimit: getOptionalPositiveIntEnvVar("PROJECTS_LIST_LIMIT", 10),
+        taskLimit: getOptionalPositiveIntEnvVar("TASK_LIMIT", 10),
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
         serviceMessagesIntervalSec: getOptionalNonNegativeIntEnvVarFromKeys(["SERVICE_MESSAGES_INTERVAL_SEC", "TOOL_MESSAGES_INTERVAL_SEC"], 5),
         hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),

package/dist/i18n/de.js

@@ -4,6 +4,8 @@ export const de = {
     "cmd.description.stop": "Aktuelle Aktion stoppen",
     "cmd.description.sessions": "Sitzungen auflisten",
     "cmd.description.projects": "Projekte auflisten",
+    "cmd.description.task": "Geplante Aufgabe erstellen",
+    "cmd.description.tasklist": "Geplante Aufgaben anzeigen",
     "cmd.description.commands": "Benutzerdefinierte Befehle",
     "cmd.description.opencode_start": "OpenCode-Server starten",
     "cmd.description.opencode_stop": "OpenCode-Server stoppen",
@@ -30,7 +32,7 @@ export const de = {
     "inline.cancelled_callback": "Abgebrochen",
     "common.unknown": "unbekannt",
     "common.unknown_error": "unbekannter Fehler",
-    "start.welcome": "👋 Willkommen beim OpenCode Telegram Bot!\n\nNutze Befehle:\n/projects — Projekt auswählen\n/sessions — Sitzungsliste\n/new — neue Sitzung\n/status — Status\n/help — Hilfe\n\nNutze die unteren Buttons, um Modus, Modell und Variante zu wählen.",
+    "start.welcome": "👋 Willkommen beim OpenCode Telegram Bot!\n\nNutze Befehle:\n/projects — Projekt auswählen\n/sessions — Sitzungsliste\n/new — neue Sitzung\n/task — geplante Aufgabe\n/tasklist — geplante Aufgaben\n/status — Status\n/help — Hilfe\n\nNutze die unteren Buttons, um Modus, Modell und Variante zu wählen.",
     "help.keyboard_hint": "💡 Nutze die unteren Buttons für Modus, Modell, Variante und Kontextaktionen.",
     "help.text": "📖 **Hilfe**\n\n/status - Serverstatus prüfen\n/sessions - Sitzungsliste\n/new - Neue Sitzung erstellen\n/help - Hilfe",
     "bot.thinking": "💭 Denke...",
@@ -214,6 +216,7 @@ export const de = {
     "pinned.line.project": "Projekt: {project}",
     "pinned.line.model": "Modell: {model}",
     "pinned.line.context": "Kontext: {used} / {limit} ({percent}%)",
+    "pinned.line.cost": "Kosten: {cost} ausgegeben",
     "pinned.files.title": "Dateien ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... und {count} mehr",
@@ -247,6 +250,41 @@ export const de = {
     "rename.blocked.expected_name": "⚠️ Sende den neuen Sitzungsnamen als Text oder tippe in der Umbenennen-Nachricht auf Abbrechen.",
     "rename.blocked.command_not_allowed": "⚠️ Dieser Befehl ist nicht verfügbar, solange beim Umbenennen auf einen neuen Namen gewartet wird.",
     "rename.button.cancel": "❌ Abbrechen",
+    "task.prompt.schedule": "⏰ Sende den Zeitplan der Aufgabe in natürlicher Sprache.\n\nBeispiele:\n- alle 5 Minuten\n- jeden Tag um 17:00\n- morgen um 12:00",
+    "task.schedule_empty": "⚠️ Der Zeitplan darf nicht leer sein.",
+    "task.parse.in_progress": "⏳ Zeitplan wird verarbeitet...",
+    "task.parse_error": "🔴 Zeitplan konnte nicht erkannt werden.\n\n{message}\n\nSende den Zeitraum bitte noch einmal klarer formuliert.",
+    "task.schedule_preview": "✅ Zeitplan erkannt\n\nVerstanden als: {summary}\n{cronLine}Zeitzone: {timezone}\nTyp: {kind}\nNächster Lauf: {nextRunAt}",
+    "task.schedule_preview.cron": "Cron: {cron}",
+    "task.prompt.body": "📝 Sende jetzt, was der Bot nach Zeitplan tun soll.",
+    "task.prompt_empty": "⚠️ Der Aufgabentext darf nicht leer sein.",
+    "task.created": "✅ Geplante Aufgabe erstellt\n\nAufgabe: {description}\nProjekt: {project}\nModell: {model}\nZeitplan: {schedule}\n{cronLine}Nächster Lauf: {nextRunAt}",
+    "task.created.cron": "Cron: {cron}",
+    "task.button.retry_schedule": "🔁 Zeitplan neu eingeben",
+    "task.button.cancel": "❌ Abbrechen",
+    "task.retry_schedule_callback": "Zeitplaneingabe wird zurückgesetzt...",
+    "task.cancel_callback": "Abbruch...",
+    "task.cancelled": "❌ Erstellung der geplanten Aufgabe abgebrochen.",
+    "task.inactive_callback": "Dieser Ablauf für geplante Aufgaben ist nicht mehr aktiv",
+    "task.inactive": "⚠️ Die Erstellung geplanter Aufgaben ist nicht aktiv. Starte /task erneut.",
+    "task.blocked.expected_input": "⚠️ Schließe zuerst die aktuelle geplante Aufgabe ab: Sende Text oder nutze die Schaltfläche in der Zeitplan-Nachricht.",
+    "task.blocked.command_not_allowed": "⚠️ Dieser Befehl ist nicht verfügbar, solange die Erstellung einer geplanten Aufgabe aktiv ist.",
+    "task.limit_reached": "⚠️ Aufgabenlimit erreicht ({limit}). Lösche zuerst eine bestehende geplante Aufgabe.",
+    "task.schedule_too_frequent": "Der wiederkehrende Zeitplan ist zu häufig. Das minimale erlaubte Intervall ist einmal alle 5 Minuten.",
+    "task.kind.cron": "wiederkehrend",
+    "task.kind.once": "einmalig",
+    "task.run.success": "⏰ Geplante Aufgabe abgeschlossen: {description}\n\n{result}",
+    "task.run.error": "🔴 Geplante Aufgabe fehlgeschlagen: {description}\n\nFehler: {error}",
+    "tasklist.empty": "📭 Noch keine geplanten Aufgaben.",
+    "tasklist.select": "Wähle eine geplante Aufgabe:",
+    "tasklist.details": "⏰ Geplante Aufgabe\n\nAufgabe: {prompt}\nProjekt: {project}\nZeitplan: {schedule}\n{cronLine}Zeitzone: {timezone}\nNächster Lauf: {nextRunAt}\nLetzter Lauf: {lastRunAt}\nAnzahl Läufe: {runCount}",
+    "tasklist.details.cron": "Cron: {cron}",
+    "tasklist.button.delete": "🗑 Löschen",
+    "tasklist.button.cancel": "❌ Abbrechen",
+    "tasklist.deleted_callback": "Gelöscht",
+    "tasklist.cancelled_callback": "Abgebrochen",
+    "tasklist.inactive_callback": "Dieses Menü für geplante Aufgaben ist inaktiv",
+    "tasklist.load_error": "🔴 Geplante Aufgaben konnten nicht geladen werden.",
     "commands.select": "Wähle einen OpenCode-Befehl:",
     "commands.empty": "📭 Für dieses Projekt sind keine OpenCode-Befehle verfügbar.",
     "commands.fetch_error": "🔴 OpenCode-Befehle konnten nicht geladen werden.",

package/dist/i18n/en.js

@@ -4,6 +4,8 @@ export const en = {
     "cmd.description.stop": "Stop current action",
     "cmd.description.sessions": "List sessions",
     "cmd.description.projects": "List projects",
+    "cmd.description.task": "Create a scheduled task",
+    "cmd.description.tasklist": "List scheduled tasks",
     "cmd.description.commands": "Custom commands",
     "cmd.description.opencode_start": "Start OpenCode server",
     "cmd.description.opencode_stop": "Stop OpenCode server",
@@ -30,7 +32,7 @@ export const en = {
     "inline.cancelled_callback": "Cancelled",
     "common.unknown": "unknown",
     "common.unknown_error": "unknown error",
-    "start.welcome": "👋 Welcome to OpenCode Telegram Bot!\n\nUse commands:\n/projects — select project\n/sessions — session list\n/new — new session\n/status — status\n/help — help\n\nUse the bottom buttons to select agent mode, model, and variant.",
+    "start.welcome": "👋 Welcome to OpenCode Telegram Bot!\n\nUse commands:\n/projects — select project\n/sessions — session list\n/new — new session\n/task — scheduled task\n/tasklist — scheduled tasks\n/status — status\n/help — help\n\nUse the bottom buttons to select agent mode, model, and variant.",
     "help.keyboard_hint": "💡 Use the bottom keyboard buttons for agent mode, model, variant, and context actions.",
     "help.text": "📖 **Help**\n\n/status - Check server status\n/sessions - Session list\n/new - Create new session\n/help - Help",
     "bot.thinking": "💭 Thinking...",
@@ -214,6 +216,7 @@ export const en = {
     "pinned.line.project": "Project: {project}",
     "pinned.line.model": "Model: {model}",
     "pinned.line.context": "Context: {used} / {limit} ({percent}%)",
+    "pinned.line.cost": "Cost: {cost} spent",
     "pinned.files.title": "Files ({count}):",
     "pinned.files.item": "  {path}{diff}",
     "pinned.files.more": "  ... and {count} more",
@@ -247,6 +250,41 @@ export const en = {
     "rename.blocked.expected_name": "⚠️ Enter a new session name as text or tap Cancel in rename message.",
     "rename.blocked.command_not_allowed": "⚠️ This command is not available while rename is waiting for a new name.",
     "rename.button.cancel": "❌ Cancel",
+    "task.prompt.schedule": "⏰ Send the task schedule in natural language.\n\nExamples:\n- every 5 minutes\n- every day at 17:00\n- tomorrow at 12:00",
+    "task.schedule_empty": "⚠️ Schedule cannot be empty.",
+    "task.parse.in_progress": "⏳ Parsing schedule...",
+    "task.parse_error": "🔴 Failed to parse schedule.\n\n{message}\n\nSend the schedule again in a clearer form.",
+    "task.schedule_preview": "✅ Schedule parsed\n\nHow I understood it: {summary}\n{cronLine}Timezone: {timezone}\nType: {kind}\nNext run: {nextRunAt}",
+    "task.schedule_preview.cron": "Cron: {cron}",
+    "task.prompt.body": "📝 Now send what the bot should do on schedule.",
+    "task.prompt_empty": "⚠️ Task text cannot be empty.",
+    "task.created": "✅ Scheduled task created\n\nTask: {description}\nProject: {project}\nModel: {model}\nSchedule: {schedule}\n{cronLine}Next run: {nextRunAt}",
+    "task.created.cron": "Cron: {cron}",
+    "task.button.retry_schedule": "🔁 Re-enter schedule",
+    "task.button.cancel": "❌ Cancel",
+    "task.retry_schedule_callback": "Re-entering schedule...",
+    "task.cancel_callback": "Cancelling...",
+    "task.cancelled": "❌ Scheduled task creation cancelled.",
+    "task.inactive_callback": "This scheduled task flow is inactive",
+    "task.inactive": "⚠️ Scheduled task creation is not active. Run /task again.",
+    "task.blocked.expected_input": "⚠️ Finish the current scheduled task setup first by sending text or using the button in the schedule message.",
+    "task.blocked.command_not_allowed": "⚠️ This command is not available while scheduled task creation is active.",
+    "task.limit_reached": "⚠️ Task limit reached ({limit}). Delete an existing scheduled task first.",
+    "task.schedule_too_frequent": "Recurring schedule is too frequent. The minimum allowed interval is once every 5 minutes.",
+    "task.kind.cron": "recurring",
+    "task.kind.once": "one-time",
+    "task.run.success": "⏰ Scheduled task completed: {description}\n\n{result}",
+    "task.run.error": "🔴 Scheduled task failed: {description}\n\nError: {error}",
+    "tasklist.empty": "📭 No scheduled tasks yet.",
+    "tasklist.select": "Select a scheduled task:",
+    "tasklist.details": "⏰ Scheduled task\n\nTask: {prompt}\nProject: {project}\nSchedule: {schedule}\n{cronLine}Timezone: {timezone}\nNext run: {nextRunAt}\nLast run: {lastRunAt}\nRun count: {runCount}",
+    "tasklist.details.cron": "Cron: {cron}",
+    "tasklist.button.delete": "🗑 Delete",
+    "tasklist.button.cancel": "❌ Cancel",
+    "tasklist.deleted_callback": "Deleted",
+    "tasklist.cancelled_callback": "Cancelled",
+    "tasklist.inactive_callback": "This scheduled task menu is inactive",
+    "tasklist.load_error": "🔴 Failed to load scheduled tasks.",
     "commands.select": "Choose an OpenCode command:",
     "commands.empty": "📭 No OpenCode commands are available for this project.",
     "commands.fetch_error": "🔴 Failed to load OpenCode commands.",