@grinev/opencode-telegram-bot 0.11.4 → 0.12.0

package/.env.example

@@ -40,6 +40,9 @@ OPENCODE_MODEL_ID=big-pickle
 # Maximum number of projects shown in /projects (default: 10)
 # PROJECTS_LIST_LIMIT=10
 
+# Maximum number of scheduled tasks allowed at once (default: 10)
+# TASK_LIMIT=10
+
 # Bot locale: supported locale code (default: en)
 # Supported locales: en, de, es, fr, ru, zh
 # BOT_LOCALE=en

package/README.md

@@ -11,6 +11,8 @@ Run AI coding tasks, monitor progress, switch models, and manage sessions from y
 
 No open ports, no exposed APIs. The bot communicates with your local OpenCode server and the Telegram Bot API only.
 
+Scheduled tasks support. Turns the bot into a lightweight OpenClaw alternative for OpenCode users.
+
 Platforms: macOS, Windows, Linux
 
 Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Русский (`ru`), 简体中文 (`zh`)
@@ -30,6 +32,7 @@ Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Р
 - **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, then forward recognized text to OpenCode
 - **File attachments** — send images, PDF documents, and any text-based files to OpenCode (code, logs, configs etc.)
+- **Scheduled tasks** — schedule prompts to run later or on a recurring interval; see [Scheduled Tasks](#scheduled-tasks)
 - **Context control** — compact context when it gets too large, right from the chat
 - **Input flow control** — when an interactive flow is active, the bot accepts only relevant input to keep context consistent and avoid accidental actions
 - **Security** — strict user ID whitelist; no one else can access your bot, even if they find it
@@ -107,6 +110,8 @@ opencode-telegram config
 | `/projects`       | Switch between OpenCode projects                        |
 | `/rename`         | Rename the current session                              |
 | `/commands`       | Browse and run custom commands                          |
+| `/task`           | Create a scheduled task                                 |
+| `/tasklist`       | Browse and delete scheduled tasks                       |
 | `/opencode_start` | Start the OpenCode server remotely                      |
 | `/opencode_stop`  | Stop the OpenCode server remotely                       |
 | `/help`           | Show available commands                                 |
@@ -115,6 +120,16 @@ Any regular text message is sent as a prompt to the coding agent only when no bl
 
 > `/opencode_start` and `/opencode_stop` are intended as emergency commands — for example, if you need to restart a stuck server while away from your computer. Under normal usage, start `opencode serve` yourself before launching the bot.
 
+## Scheduled Tasks
+
+Scheduled tasks let you prepare prompts in advance and run them automatically later or on a recurring schedule. This is useful for periodic checks, routine code maintenance, or tasks you want OpenCode to execute while you are away from your computer. Use `/task` to create a scheduled task and `/tasklist` to review or delete existing ones.
+
+- Each task is created from the currently selected OpenCode project and model
+- Scheduled executions currently always run with the `build` agent
+- Tasks run outside your active chat session, so they do not interrupt or affect the current session flow
+- The minimum recurring interval is 5 minutes
+- Up to 10 scheduled tasks can exist at once by default; change this with `TASK_LIMIT` in your `.env`
+
 ## Configuration
 
 ### Localization
@@ -144,6 +159,7 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `BOT_LOCALE`                    | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                             |    No    | `en`                     |
 | `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                                             |    No    | `10`                     |
 | `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                                             |    No    | `10`                     |
+| `TASK_LIMIT`                    | Maximum number of scheduled tasks that can exist at once                                                     |    No    | `10`                     |
 | `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                      |
 | `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                  |
 | `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                  |

package/dist/app/start-bot-app.js

@@ -3,6 +3,7 @@ import { createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { loadSettings } from "../settings/manager.js";
 import { processManager } from "../process/manager.js";
+import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
 import { reconcileStoredModelSelection } from "../model/manager.js";
 import { getRuntimeMode } from "../runtime/mode.js";
@@ -33,6 +34,7 @@ export async function startBotApp() {
     await reconcileStoredModelSelection();
     await warmupSessionDirectoryCache();
     const bot = createBot();
+    await scheduledTaskRuntime.initialize(bot);
     const webhookInfo = await bot.api.getWebhookInfo();
     if (webhookInfo.url) {
         logger.info(`[Bot] Webhook detected: ${webhookInfo.url}, removing...`);

package/dist/bot/commands/abort.js

@@ -5,6 +5,7 @@ import { clearAllInteractionState } from "../../interaction/cleanup.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function abortLocalStreaming() {
     stopEventListening();
@@ -84,6 +85,7 @@ export async function abortCurrentOperation(ctx, options = {}) {
             }
             const finalStatus = await pollSessionStatus(currentSession.id, currentSession.directory, 5000);
             if (finalStatus === "idle" || finalStatus === "not-found") {
+                foregroundSessionState.markIdle(currentSession.id);
                 if (notifyUser && chatId !== null && waitingMessageId !== null) {
                     await ctx.api.editMessageText(chatId, waitingMessageId, t("stop.success"));
                 }

package/dist/bot/commands/commands.js

@@ -10,6 +10,7 @@ import { getStoredModel } from "../../model/manager.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 const COMMANDS_CALLBACK_PREFIX = "commands:";
 const COMMANDS_CALLBACK_SELECT_PREFIX = `${COMMANDS_CALLBACK_PREFIX}select:`;
 const COMMANDS_CALLBACK_CANCEL = `${COMMANDS_CALLBACK_PREFIX}cancel`;
@@ -171,6 +172,7 @@ async function ensureSessionForProject(ctx, projectDirectory) {
         logger.warn(`[Commands] Session/project mismatch detected. sessionDirectory=${currentSession.directory}, projectDirectory=${projectDirectory}. Resetting session context.`);
         clearSession();
         summaryAggregator.clear();
+        foregroundSessionState.clearAll("session_mismatch_reset");
         await ctx.reply(t("bot.session_reset_project_mismatch"));
         currentSession = null;
     }
@@ -218,6 +220,7 @@ async function executeCommand(ctx, deps, params) {
     const model = storedModel.providerID && storedModel.modelID
         ? `${storedModel.providerID}/${storedModel.modelID}`
         : undefined;
+    foregroundSessionState.markBusy(session.id);
     safeBackgroundTask({
         taskName: "session.command",
         task: () => opencodeClient.session.command({
@@ -231,6 +234,7 @@ async function executeCommand(ctx, deps, params) {
         }),
         onSuccess: ({ error }) => {
             if (error) {
+                foregroundSessionState.markIdle(session.id);
                 logger.error("[Commands] OpenCode API returned an error for session.command", {
                     sessionId: session.id,
                     command: params.commandName,
@@ -243,6 +247,7 @@ async function executeCommand(ctx, deps, params) {
             logger.info(`[Commands] session.command completed: session=${session.id}, command=/${params.commandName}`);
         },
         onError: (error) => {
+            foregroundSessionState.markIdle(session.id);
             logger.error("[Commands] session.command background task failed", {
                 sessionId: session.id,
                 command: params.commandName,

package/dist/bot/commands/definitions.js

@@ -9,6 +9,8 @@ const COMMAND_DEFINITIONS = [
     { command: "abort", descriptionKey: "cmd.description.stop" },
     { command: "sessions", descriptionKey: "cmd.description.sessions" },
     { command: "projects", descriptionKey: "cmd.description.projects" },
+    { command: "task", descriptionKey: "cmd.description.task" },
+    { command: "tasklist", descriptionKey: "cmd.description.tasklist" },
     { command: "rename", descriptionKey: "cmd.description.rename" },
     { command: "commands", descriptionKey: "cmd.description.commands" },
     { command: "opencode_start", descriptionKey: "cmd.description.opencode_start" },

package/dist/bot/commands/start.js

@@ -6,6 +6,7 @@ import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { clearSession } from "../../session/manager.js";
 import { clearProject } from "../../settings/manager.js";
+import { foregroundSessionState } from "../../scheduled-task/foreground-state.js";
 import { abortCurrentOperation } from "./abort.js";
 import { t } from "../../i18n/index.js";
 export async function startCommand(ctx) {
@@ -16,6 +17,7 @@ export async function startCommand(ctx) {
         keyboardManager.initialize(ctx.api, ctx.chat.id);
     }
     await abortCurrentOperation(ctx, { notifyUser: false });
+    foregroundSessionState.clearAll("start_command_reset");
     clearSession();
     clearProject();
     keyboardManager.clearContext();

package/dist/bot/commands/task.js

@@ -0,0 +1,399 @@
+import { randomUUID } from "node:crypto";
+import { InlineKeyboard } from "grammy";
+import { config } from "../../config.js";
+import { getDateLocale, t } from "../../i18n/index.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { taskCreationManager } from "../../scheduled-task/creation-manager.js";
+import { parseTaskSchedule } from "../../scheduled-task/schedule-parser.js";
+import { addScheduledTask, listScheduledTasks } from "../../scheduled-task/store.js";
+import { scheduledTaskRuntime } from "../../scheduled-task/runtime.js";
+import { createScheduledTaskModel, } from "../../scheduled-task/types.js";
+import { logger } from "../../utils/logger.js";
+const TASK_RETRY_SCHEDULE_CALLBACK = "task:retry-schedule";
+const TASK_CANCEL_CALLBACK = "task:cancel";
+const TASK_PROMPT_PREVIEW_LENGTH = 100;
+function buildRetryScheduleKeyboard() {
+    return new InlineKeyboard()
+        .text(t("task.button.retry_schedule"), TASK_RETRY_SCHEDULE_CALLBACK)
+        .text(t("task.button.cancel"), TASK_CANCEL_CALLBACK);
+}
+function buildCancelKeyboard() {
+    return new InlineKeyboard().text(t("task.button.cancel"), TASK_CANCEL_CALLBACK);
+}
+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 clearTaskInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "task") {
+        interactionManager.clear(reason);
+    }
+}
+function clearTaskFlow(reason) {
+    taskCreationManager.clear();
+    clearTaskInteraction(reason);
+}
+function isTaskLimitReached() {
+    return listScheduledTasks().length >= config.bot.taskLimit;
+}
+function truncateTaskPrompt(prompt) {
+    const normalized = prompt.replace(/\s+/g, " ").trim();
+    if (normalized.length <= TASK_PROMPT_PREVIEW_LENGTH) {
+        return normalized;
+    }
+    return `${normalized.slice(0, TASK_PROMPT_PREVIEW_LENGTH - 3)}...`;
+}
+function formatScheduledDate(dateIso, timezone) {
+    try {
+        return new Intl.DateTimeFormat(getDateLocale(), {
+            dateStyle: "medium",
+            timeStyle: "short",
+            timeZone: timezone,
+        }).format(new Date(dateIso));
+    }
+    catch {
+        return dateIso;
+    }
+}
+function getTaskKindLabel(schedule) {
+    return schedule.kind === "cron" ? t("task.kind.cron") : t("task.kind.once");
+}
+function formatParsedScheduleMessage(schedule) {
+    const cronLine = schedule.kind === "cron" ? `${t("task.schedule_preview.cron", { cron: schedule.cron })}\n` : "";
+    return t("task.schedule_preview", {
+        summary: schedule.summary,
+        cronLine,
+        timezone: schedule.timezone,
+        kind: getTaskKindLabel(schedule),
+        nextRunAt: formatScheduledDate(schedule.nextRunAt, schedule.timezone),
+    });
+}
+function formatParsedSchedulePromptMessage(schedule) {
+    return `${formatParsedScheduleMessage(schedule)}\n\n${t("task.prompt.body")}`;
+}
+function formatTaskCreatedMessage(task) {
+    const variant = task.model.variant ? ` (${task.model.variant})` : "";
+    const model = `${task.model.providerID}/${task.model.modelID}${variant}`;
+    const cronLine = task.kind === "cron" ? `${t("task.created.cron", { cron: task.cron })}\n` : "";
+    return t("task.created", {
+        description: truncateTaskPrompt(task.prompt),
+        project: task.projectWorktree,
+        model,
+        schedule: task.scheduleSummary,
+        cronLine,
+        nextRunAt: task.nextRunAt ? formatScheduledDate(task.nextRunAt, task.timezone) : "-",
+    });
+}
+function validateCronMinutesFrequency(cron) {
+    const cronParts = cron.trim().split(/\s+/);
+    if (cronParts.length < 5) {
+        throw new Error("Invalid cron expression returned by parser");
+    }
+    const minuteValues = expandCronMinuteField(cronParts[0]);
+    if (minuteValues.length <= 1) {
+        return;
+    }
+    let minGap = 60;
+    for (let index = 0; index < minuteValues.length; index++) {
+        const currentValue = minuteValues[index];
+        const nextValue = index === minuteValues.length - 1 ? minuteValues[0] + 60 : minuteValues[index + 1];
+        minGap = Math.min(minGap, nextValue - currentValue);
+    }
+    if (minGap < 5) {
+        throw new Error(t("task.schedule_too_frequent"));
+    }
+}
+function expandCronMinuteField(field) {
+    const values = new Set();
+    for (const token of field.split(",")) {
+        const trimmedToken = token.trim();
+        if (!trimmedToken) {
+            throw new Error("Invalid cron minute field returned by parser");
+        }
+        for (const value of expandCronMinuteToken(trimmedToken)) {
+            values.add(value);
+        }
+    }
+    return Array.from(values).sort((left, right) => left - right);
+}
+function expandCronMinuteToken(token) {
+    const [rawBase, rawStep] = token.split("/");
+    if (rawStep !== undefined) {
+        const step = Number.parseInt(rawStep, 10);
+        if (!Number.isInteger(step) || step <= 0) {
+            throw new Error("Invalid cron minute step returned by parser");
+        }
+        const baseValues = expandCronMinuteBase(rawBase);
+        return baseValues.filter((value, index) => {
+            if (baseValues.length === 0) {
+                return false;
+            }
+            return index % step === 0;
+        });
+    }
+    return expandCronMinuteBase(rawBase);
+}
+function expandCronMinuteBase(base) {
+    if (base === "*") {
+        return Array.from({ length: 60 }, (_, index) => index);
+    }
+    if (base.includes("-")) {
+        const [rawStart, rawEnd] = base.split("-");
+        const start = parseCronMinuteNumber(rawStart);
+        const end = parseCronMinuteNumber(rawEnd);
+        if (start > end) {
+            throw new Error("Invalid cron minute range returned by parser");
+        }
+        return Array.from({ length: end - start + 1 }, (_, index) => start + index);
+    }
+    return [parseCronMinuteNumber(base)];
+}
+function parseCronMinuteNumber(value) {
+    const parsedValue = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsedValue) || parsedValue < 0 || parsedValue > 59) {
+        throw new Error("Invalid cron minute value returned by parser");
+    }
+    return parsedValue;
+}
+function validateParsedSchedule(parsedSchedule) {
+    if (parsedSchedule.kind === "cron") {
+        validateCronMinutesFrequency(parsedSchedule.cron);
+    }
+}
+function buildTaskInteractionMetadata(stage, projectId, projectWorktree, previewMessageId) {
+    return {
+        flow: "task",
+        stage,
+        projectId,
+        projectWorktree,
+        previewMessageId,
+    };
+}
+function isTaskInteraction(state) {
+    return state?.kind === "task";
+}
+function isTaskCallbackActive(flowState, messageId) {
+    return [
+        flowState.scheduleRequestMessageId,
+        flowState.previewMessageId,
+        flowState.promptRequestMessageId,
+    ].includes(messageId);
+}
+async function deleteMessageIfPresent(ctx, messageId) {
+    if (!ctx.chat || typeof messageId !== "number") {
+        return;
+    }
+    await ctx.api.deleteMessage(ctx.chat.id, messageId).catch(() => { });
+}
+function buildScheduledTask(projectId, projectWorktree, model, scheduleText, parsedSchedule, prompt) {
+    const baseTask = {
+        id: randomUUID(),
+        projectId,
+        projectWorktree,
+        model,
+        scheduleText,
+        scheduleSummary: parsedSchedule.summary,
+        timezone: parsedSchedule.timezone,
+        prompt,
+        createdAt: new Date().toISOString(),
+        nextRunAt: parsedSchedule.nextRunAt,
+        lastRunAt: null,
+        runCount: 0,
+        lastStatus: "idle",
+        lastError: null,
+    };
+    if (parsedSchedule.kind === "cron") {
+        return {
+            ...baseTask,
+            kind: "cron",
+            cron: parsedSchedule.cron,
+        };
+    }
+    return {
+        ...baseTask,
+        kind: "once",
+        runAt: parsedSchedule.runAt,
+    };
+}
+export async function taskCommand(ctx) {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        await ctx.reply(t("bot.project_not_selected"));
+        return;
+    }
+    if (isTaskLimitReached()) {
+        await ctx.reply(t("task.limit_reached", { limit: String(config.bot.taskLimit) }));
+        return;
+    }
+    const currentModel = createScheduledTaskModel(getStoredModel());
+    taskCreationManager.start(currentProject.id, currentProject.worktree, currentModel);
+    interactionManager.start({
+        kind: "task",
+        expectedInput: "text",
+        metadata: buildTaskInteractionMetadata("awaiting_schedule", currentProject.id, currentProject.worktree),
+    });
+    const message = await ctx.reply(t("task.prompt.schedule"), {
+        reply_markup: buildCancelKeyboard(),
+    });
+    taskCreationManager.setScheduleRequestMessageId(message.message_id);
+}
+export async function handleTaskCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (data !== TASK_RETRY_SCHEDULE_CALLBACK && data !== TASK_CANCEL_CALLBACK) {
+        return false;
+    }
+    const flowState = taskCreationManager.getState();
+    const interactionState = interactionManager.getSnapshot();
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!flowState ||
+        !isTaskInteraction(interactionState) ||
+        callbackMessageId === null ||
+        !isTaskCallbackActive(flowState, callbackMessageId)) {
+        if (!flowState && isTaskInteraction(interactionState)) {
+            clearTaskInteraction("task_retry_inactive_state");
+        }
+        await ctx.answerCallbackQuery({ text: t("task.inactive_callback"), show_alert: true });
+        return true;
+    }
+    if (data === TASK_CANCEL_CALLBACK) {
+        await ctx.answerCallbackQuery({ text: t("task.cancel_callback") });
+        await deleteMessageIfPresent(ctx, flowState.scheduleRequestMessageId);
+        await deleteMessageIfPresent(ctx, flowState.previewMessageId);
+        await deleteMessageIfPresent(ctx, flowState.promptRequestMessageId);
+        clearTaskFlow("task_cancelled");
+        await ctx.reply(t("task.cancelled"));
+        return true;
+    }
+    if (!taskCreationManager.isWaitingForPrompt() ||
+        callbackMessageId !== flowState.previewMessageId) {
+        await ctx.answerCallbackQuery({ text: t("task.inactive_callback"), show_alert: true });
+        return true;
+    }
+    taskCreationManager.resetSchedule();
+    interactionManager.transition({
+        kind: "task",
+        expectedInput: "text",
+        metadata: buildTaskInteractionMetadata("awaiting_schedule", flowState.projectId, flowState.projectWorktree),
+    });
+    await ctx.answerCallbackQuery({ text: t("task.retry_schedule_callback") });
+    await deleteMessageIfPresent(ctx, flowState.promptRequestMessageId);
+    await deleteMessageIfPresent(ctx, flowState.previewMessageId);
+    const message = await ctx.reply(t("task.prompt.schedule"), {
+        reply_markup: buildCancelKeyboard(),
+    });
+    taskCreationManager.setScheduleRequestMessageId(message.message_id);
+    return true;
+}
+export async function handleTaskTextInput(ctx) {
+    const text = ctx.message?.text;
+    if (!text || text.startsWith("/")) {
+        return false;
+    }
+    if (!taskCreationManager.isActive()) {
+        return false;
+    }
+    const interactionState = interactionManager.getSnapshot();
+    if (!isTaskInteraction(interactionState)) {
+        taskCreationManager.clear();
+        await ctx.reply(t("task.inactive"));
+        return true;
+    }
+    const flowState = taskCreationManager.getState();
+    if (!flowState) {
+        clearTaskFlow("task_state_missing");
+        await ctx.reply(t("task.inactive"));
+        return true;
+    }
+    if (taskCreationManager.isParsingSchedule()) {
+        await ctx.reply(t("task.parse.in_progress"));
+        return true;
+    }
+    if (taskCreationManager.isWaitingForSchedule()) {
+        const scheduleText = text.trim();
+        if (!scheduleText) {
+            await ctx.reply(t("task.schedule_empty"));
+            return true;
+        }
+        taskCreationManager.markScheduleParsing();
+        interactionManager.transition({
+            kind: "task",
+            expectedInput: "text",
+            metadata: buildTaskInteractionMetadata("parsing_schedule", flowState.projectId, flowState.projectWorktree),
+        });
+        const parsingMessage = await ctx.reply(t("task.parse.in_progress"));
+        try {
+            const parsedSchedule = await parseTaskSchedule(scheduleText, flowState.projectWorktree);
+            validateParsedSchedule(parsedSchedule);
+            await deleteMessageIfPresent(ctx, parsingMessage.message_id);
+            await deleteMessageIfPresent(ctx, flowState.scheduleRequestMessageId);
+            const previewMessage = await ctx.reply(formatParsedSchedulePromptMessage(parsedSchedule), {
+                reply_markup: buildRetryScheduleKeyboard(),
+            });
+            taskCreationManager.setParsedSchedule(scheduleText, parsedSchedule, previewMessage.message_id);
+            interactionManager.transition({
+                kind: "task",
+                expectedInput: "mixed",
+                metadata: buildTaskInteractionMetadata("awaiting_prompt", flowState.projectId, flowState.projectWorktree, previewMessage.message_id),
+            });
+            taskCreationManager.setPromptRequestMessageId(previewMessage.message_id);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : t("common.unknown_error");
+            logger.warn(`[TaskCommand] Failed to parse task schedule: ${errorMessage}`);
+            await deleteMessageIfPresent(ctx, flowState.scheduleRequestMessageId);
+            taskCreationManager.resetSchedule();
+            interactionManager.transition({
+                kind: "task",
+                expectedInput: "text",
+                metadata: buildTaskInteractionMetadata("awaiting_schedule", flowState.projectId, flowState.projectWorktree),
+            });
+            await deleteMessageIfPresent(ctx, parsingMessage.message_id);
+            const errorReply = await ctx.reply(t("task.parse_error", { message: errorMessage }), {
+                reply_markup: buildCancelKeyboard(),
+            });
+            taskCreationManager.setScheduleRequestMessageId(errorReply.message_id);
+        }
+        return true;
+    }
+    if (!taskCreationManager.isWaitingForPrompt()) {
+        return false;
+    }
+    const prompt = text.trim();
+    if (!prompt) {
+        await ctx.reply(t("task.prompt_empty"));
+        return true;
+    }
+    if (!flowState.parsedSchedule || !flowState.scheduleText) {
+        clearTaskFlow("task_missing_schedule_before_save");
+        await ctx.reply(t("task.inactive"));
+        return true;
+    }
+    try {
+        if (isTaskLimitReached()) {
+            await deleteMessageIfPresent(ctx, flowState.previewMessageId);
+            await deleteMessageIfPresent(ctx, flowState.promptRequestMessageId);
+            clearTaskFlow("task_limit_reached_before_save");
+            await ctx.reply(t("task.limit_reached", { limit: String(config.bot.taskLimit) }));
+            return true;
+        }
+        const task = buildScheduledTask(flowState.projectId, flowState.projectWorktree, flowState.model, flowState.scheduleText, flowState.parsedSchedule, prompt);
+        await addScheduledTask(task);
+        scheduledTaskRuntime.registerTask(task);
+        await deleteMessageIfPresent(ctx, flowState.previewMessageId);
+        await deleteMessageIfPresent(ctx, flowState.promptRequestMessageId);
+        clearTaskFlow("task_completed");
+        await ctx.reply(formatTaskCreatedMessage(task));
+    }
+    catch (error) {
+        logger.error("[TaskCommand] Failed to save scheduled task", error);
+        await ctx.reply(t("error.generic"));
+    }
+    return true;
+}