@grinev/opencode-telegram-bot 0.11.4 → 0.12.0

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;
@@ -141,10 +145,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");
@@ -172,6 +179,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) {
@@ -308,10 +319,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 +338,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 +474,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 +496,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 +510,8 @@ export function createBot() {
                 !handledModel &&
                 !handledVariant &&
                 !handledCompactConfirm &&
+                !handledTask &&
+                !handledTaskList &&
                 !handledRenameCancel &&
                 !handledCommands) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
@@ -677,6 +699,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...",
@@ -247,6 +249,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...",
@@ -247,6 +249,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.",

package/dist/i18n/es.js

@@ -4,6 +4,8 @@ export const es = {
     "cmd.description.stop": "Detener la acción actual",
     "cmd.description.sessions": "Listar sesiones",
     "cmd.description.projects": "Listar proyectos",
+    "cmd.description.task": "Crear tarea programada",
+    "cmd.description.tasklist": "Ver tareas programadas",
     "cmd.description.commands": "Comandos personalizados",
     "cmd.description.opencode_start": "Iniciar servidor OpenCode",
     "cmd.description.opencode_stop": "Detener servidor OpenCode",
@@ -30,7 +32,7 @@ export const es = {
     "inline.cancelled_callback": "Cancelado",
     "common.unknown": "desconocido",
     "common.unknown_error": "error desconocido",
-    "start.welcome": "👋 ¡Bienvenido a OpenCode Telegram Bot!\n\nUsa los comandos:\n/projects — seleccionar proyecto\n/sessions — lista de sesiones\n/new — sesión nueva\n/status — estado\n/help — ayuda\n\nUsa los botones inferiores para elegir modo, modelo y variante.",
+    "start.welcome": "👋 ¡Bienvenido a OpenCode Telegram Bot!\n\nUsa los comandos:\n/projects — seleccionar proyecto\n/sessions — lista de sesiones\n/new — sesión nueva\n/task — tarea programada\n/tasklist — tareas programadas\n/status — estado\n/help — ayuda\n\nUsa los botones inferiores para elegir modo, modelo y variante.",
     "help.keyboard_hint": "💡 Usa los botones inferiores para modo del agente, modelo, variante y acciones de contexto.",
     "help.text": "📖 **Ayuda**\n\n/status - Ver estado del servidor\n/sessions - Lista de sesiones\n/new - Crear una sesión nueva\n/help - Ayuda",
     "bot.thinking": "💭 Pensando...",
@@ -247,6 +249,41 @@ export const es = {
     "rename.blocked.expected_name": "⚠️ Introduce el nuevo nombre de la sesión como texto o toca Cancelar en el mensaje de cambio de nombre.",
     "rename.blocked.command_not_allowed": "⚠️ Este comando no está disponible mientras el cambio de nombre espera un nuevo nombre.",
     "rename.button.cancel": "❌ Cancelar",
+    "task.prompt.schedule": "⏰ Envía el horario de la tarea en lenguaje natural.\n\nEjemplos:\n- cada 5 minutos\n- cada día a las 17:00\n- mañana a las 12:00",
+    "task.schedule_empty": "⚠️ El horario no puede estar vacío.",
+    "task.parse.in_progress": "⏳ Analizando horario...",
+    "task.parse_error": "🔴 No se pudo interpretar el horario.\n\n{message}\n\nEnvía el periodo otra vez de forma más clara.",
+    "task.schedule_preview": "✅ Horario interpretado\n\nEntendido como: {summary}\n{cronLine}Zona horaria: {timezone}\nTipo: {kind}\nPróxima ejecución: {nextRunAt}",
+    "task.schedule_preview.cron": "Cron: {cron}",
+    "task.prompt.body": "📝 Ahora envía lo que el bot debe hacer según este horario.",
+    "task.prompt_empty": "⚠️ El texto de la tarea no puede estar vacío.",
+    "task.created": "✅ Tarea programada creada\n\nTarea: {description}\nProyecto: {project}\nModelo: {model}\nHorario: {schedule}\n{cronLine}Próxima ejecución: {nextRunAt}",
+    "task.created.cron": "Cron: {cron}",
+    "task.button.retry_schedule": "🔁 Volver a introducir horario",
+    "task.button.cancel": "❌ Cancelar",
+    "task.retry_schedule_callback": "Volviendo a introducir el horario...",
+    "task.cancel_callback": "Cancelando...",
+    "task.cancelled": "❌ Creación de la tarea programada cancelada.",
+    "task.inactive_callback": "Este flujo de tarea programada ya no está activo",
+    "task.inactive": "⚠️ La creación de la tarea programada no está activa. Ejecuta /task otra vez.",
+    "task.blocked.expected_input": "⚠️ Primero termina la configuración actual de la tarea programada: envía texto o usa el botón del mensaje del horario.",
+    "task.blocked.command_not_allowed": "⚠️ Este comando no está disponible mientras la creación de la tarea programada está activa.",
+    "task.limit_reached": "⚠️ Se alcanzó el límite de tareas ({limit}). Primero elimina una tarea programada existente.",
+    "task.schedule_too_frequent": "El horario recurrente es demasiado frecuente. El intervalo mínimo permitido es una vez cada 5 minutos.",
+    "task.kind.cron": "recurrente",
+    "task.kind.once": "única",
+    "task.run.success": "⏰ Tarea programada completada: {description}\n\n{result}",
+    "task.run.error": "🔴 La tarea programada falló: {description}\n\nError: {error}",
+    "tasklist.empty": "📭 Aún no hay tareas programadas.",
+    "tasklist.select": "Elige una tarea programada:",
+    "tasklist.details": "⏰ Tarea programada\n\nTarea: {prompt}\nProyecto: {project}\nHorario: {schedule}\n{cronLine}Zona horaria: {timezone}\nPróxima ejecución: {nextRunAt}\nÚltima ejecución: {lastRunAt}\nNúmero de ejecuciones: {runCount}",
+    "tasklist.details.cron": "Cron: {cron}",
+    "tasklist.button.delete": "🗑 Eliminar",
+    "tasklist.button.cancel": "❌ Cancelar",
+    "tasklist.deleted_callback": "Eliminada",
+    "tasklist.cancelled_callback": "Cancelado",
+    "tasklist.inactive_callback": "Este menú de tareas programadas está inactivo",
+    "tasklist.load_error": "🔴 No se pudieron cargar las tareas programadas.",
     "commands.select": "Elige un comando de OpenCode:",
     "commands.empty": "📭 No hay comandos de OpenCode disponibles para este proyecto.",
     "commands.fetch_error": "🔴 No se pudieron cargar los comandos de OpenCode.",

package/dist/i18n/fr.js

@@ -4,6 +4,8 @@ export const fr = {
     "cmd.description.stop": "Arrêter l'action en cours",
     "cmd.description.sessions": "Lister les sessions",
     "cmd.description.projects": "Lister les projets",
+    "cmd.description.task": "Créer une tâche planifiée",
+    "cmd.description.tasklist": "Afficher les tâches planifiées",
     "cmd.description.commands": "Commandes personnalisées",
     "cmd.description.opencode_start": "Démarrer le serveur OpenCode",
     "cmd.description.opencode_stop": "Arrêter le serveur OpenCode",
@@ -30,7 +32,7 @@ export const fr = {
     "inline.cancelled_callback": "Annulé",
     "common.unknown": "inconnu",
     "common.unknown_error": "erreur inconnue",
-    "start.welcome": "👋 Bienvenue dans OpenCode Telegram Bot !\n\nUtilisez les commandes :\n/projects — sélectionner un projet\n/sessions — liste des sessions\n/new — nouvelle session\n/status — statut\n/help — aide\n\nUtilisez les boutons du bas pour choisir le mode d'agent, le modèle et la variante.",
+    "start.welcome": "👋 Bienvenue dans OpenCode Telegram Bot !\n\nUtilisez les commandes :\n/projects — sélectionner un projet\n/sessions — liste des sessions\n/new — nouvelle session\n/task — tâche planifiée\n/tasklist — tâches planifiées\n/status — statut\n/help — aide\n\nUtilisez les boutons du bas pour choisir le mode d'agent, le modèle et la variante.",
     "help.keyboard_hint": "💡 Utilisez les boutons du bas pour le mode d'agent, le modèle, la variante et les actions de contexte.",
     "help.text": "📖 **Aide**\n\n/status - Vérifier l'état du serveur\n/sessions - Liste des sessions\n/new - Créer une nouvelle session\n/help - Aide",
     "bot.thinking": "💭 Réflexion en cours...",
@@ -247,6 +249,41 @@ export const fr = {
     "rename.blocked.expected_name": "⚠️ Entrez le nouveau nom de la session sous forme de texte ou appuyez sur Annuler dans le message de renommage.",
     "rename.blocked.command_not_allowed": "⚠️ Cette commande n'est pas disponible tant que le renommage attend un nouveau nom.",
     "rename.button.cancel": "❌ Annuler",
+    "task.prompt.schedule": "⏰ Envoyez le planning de la tâche en langage naturel.\n\nExemples :\n- toutes les 5 minutes\n- chaque jour à 17:00\n- demain à 12:00",
+    "task.schedule_empty": "⚠️ Le planning ne peut pas être vide.",
+    "task.parse.in_progress": "⏳ Analyse du planning...",
+    "task.parse_error": "🔴 Impossible d'interpréter le planning.\n\n{message}\n\nEnvoyez le créneau à nouveau de façon plus claire.",
+    "task.schedule_preview": "✅ Planning interprété\n\nCompris comme : {summary}\n{cronLine}Fuseau horaire : {timezone}\nType : {kind}\nProchaine exécution : {nextRunAt}",
+    "task.schedule_preview.cron": "Cron : {cron}",
+    "task.prompt.body": "📝 Envoyez maintenant ce que le bot doit faire selon ce planning.",
+    "task.prompt_empty": "⚠️ Le texte de la tâche ne peut pas être vide.",
+    "task.created": "✅ Tâche planifiée créée\n\nTâche : {description}\nProjet : {project}\nModèle : {model}\nPlanning : {schedule}\n{cronLine}Prochaine exécution : {nextRunAt}",
+    "task.created.cron": "Cron : {cron}",
+    "task.button.retry_schedule": "🔁 Ressaisir le planning",
+    "task.button.cancel": "❌ Annuler",
+    "task.retry_schedule_callback": "Retour à la saisie du planning...",
+    "task.cancel_callback": "Annulation...",
+    "task.cancelled": "❌ Création de la tâche planifiée annulée.",
+    "task.inactive_callback": "Ce flux de tâche planifiée n'est plus actif",
+    "task.inactive": "⚠️ La création de tâche planifiée n'est pas active. Relancez /task.",
+    "task.blocked.expected_input": "⚠️ Terminez d'abord la configuration de la tâche planifiée : envoyez du texte ou utilisez le bouton dans le message du planning.",
+    "task.blocked.command_not_allowed": "⚠️ Cette commande n'est pas disponible pendant la création d'une tâche planifiée.",
+    "task.limit_reached": "⚠️ Limite de tâches atteinte ({limit}). Supprimez d'abord une tâche planifiée existante.",
+    "task.schedule_too_frequent": "Le planning récurrent est trop fréquent. L'intervalle minimum autorisé est d'une fois toutes les 5 minutes.",
+    "task.kind.cron": "récurrente",
+    "task.kind.once": "ponctuelle",
+    "task.run.success": "⏰ Tâche planifiée terminée : {description}\n\n{result}",
+    "task.run.error": "🔴 Échec de la tâche planifiée : {description}\n\nErreur : {error}",
+    "tasklist.empty": "📭 Aucune tâche planifiée pour le moment.",
+    "tasklist.select": "Sélectionnez une tâche planifiée :",
+    "tasklist.details": "⏰ Tâche planifiée\n\nTâche : {prompt}\nProjet : {project}\nPlanning : {schedule}\n{cronLine}Fuseau horaire : {timezone}\nProchaine exécution : {nextRunAt}\nDernière exécution : {lastRunAt}\nNombre d'exécutions : {runCount}",
+    "tasklist.details.cron": "Cron : {cron}",
+    "tasklist.button.delete": "🗑 Supprimer",
+    "tasklist.button.cancel": "❌ Annuler",
+    "tasklist.deleted_callback": "Supprimée",
+    "tasklist.cancelled_callback": "Annulé",
+    "tasklist.inactive_callback": "Ce menu des tâches planifiées est inactif",
+    "tasklist.load_error": "🔴 Impossible de charger les tâches planifiées.",
     "commands.select": "Choisissez une commande OpenCode :",
     "commands.empty": "📭 Aucune commande OpenCode n'est disponible pour ce projet.",
     "commands.fetch_error": "🔴 Impossible de charger les commandes OpenCode.",