zardbot-telegram 1.0.0

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;
+}

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;
+    }
+}