@grinev/opencode-telegram-bot 0.21.1 → 0.21.2

package/dist/bot/callbacks/permission-callback-handler.js

@@ -0,0 +1,114 @@
+import { permissionManager } from "../../app/managers/permission-manager.js";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../app/stores/settings-store.js";
+import { getCurrentSession } from "../../app/services/session-service.js";
+import { summaryAggregator } from "../../app/managers/summary-aggregation-manager.js";
+import { clearPermissionInteraction, syncPermissionInteractionState } from "../menus/permission-menu.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { safeBackgroundTask } from "../../utils/safe-background-task.js";
+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 isPermissionReply(value) {
+    return value === "once" || value === "always" || value === "reject";
+}
+export async function handlePermissionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    if (!data.startsWith("permission:")) {
+        return false;
+    }
+    logger.debug(`[PermissionHandler] Received callback: ${data}`);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_inactive_callback");
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!permissionManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const requestID = permissionManager.getRequestID(callbackMessageId);
+    if (!requestID) {
+        await ctx.answerCallbackQuery({ text: t("permission.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    if (!isPermissionReply(action)) {
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+        return true;
+    }
+    try {
+        await handlePermissionReply(ctx, action, requestID, callbackMessageId);
+    }
+    catch (err) {
+        logger.error("[PermissionHandler] Error handling callback:", err);
+        await ctx.answerCallbackQuery({
+            text: t("permission.processing_error_callback"),
+            show_alert: true,
+        });
+    }
+    return true;
+}
+async function handlePermissionReply(ctx, reply, requestID, callbackMessageId) {
+    const currentProject = getCurrentProject();
+    const currentSession = getCurrentSession();
+    const chatId = ctx.chat?.id;
+    const directory = currentSession?.directory ?? currentProject?.worktree;
+    if (!directory || !chatId) {
+        permissionManager.clear();
+        clearPermissionInteraction("permission_invalid_runtime_context");
+        await ctx.answerCallbackQuery({
+            text: t("permission.no_active_request_callback"),
+            show_alert: true,
+        });
+        return;
+    }
+    const replyLabels = {
+        once: t("permission.reply.once"),
+        always: t("permission.reply.always"),
+        reject: t("permission.reply.reject"),
+    };
+    await ctx.answerCallbackQuery({ text: replyLabels[reply] });
+    await ctx.deleteMessage().catch(() => { });
+    summaryAggregator.stopTypingIndicator();
+    logger.info(`[PermissionHandler] Sending permission reply: ${reply}, requestID=${requestID}`);
+    safeBackgroundTask({
+        taskName: "permission.reply",
+        task: () => opencodeClient.permission.reply({
+            requestID,
+            directory,
+            reply,
+        }),
+        onSuccess: ({ error }) => {
+            if (error) {
+                logger.error("[PermissionHandler] Failed to send permission reply:", error);
+                if (ctx.api && chatId) {
+                    void ctx.api.sendMessage(chatId, t("permission.send_reply_error")).catch(() => { });
+                }
+                return;
+            }
+            logger.info("[PermissionHandler] Permission reply sent successfully");
+        },
+    });
+    permissionManager.removeByMessageId(callbackMessageId);
+    if (!permissionManager.isActive()) {
+        clearPermissionInteraction("permission_replied");
+        return;
+    }
+    syncPermissionInteractionState({
+        lastRepliedRequestID: requestID,
+    });
+}

package/dist/bot/callbacks/project-callback-handler.js

@@ -0,0 +1,79 @@
+import { clearAllInteractionState } from "../../app/managers/interaction-manager.js";
+import { getProjects } from "../../app/services/project-service.js";
+import { isForegroundBusy } from "../../app/services/run-control-service.js";
+import { switchToProject } from "../../app/services/project-switch-service.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+import { appendInlineMenuCancelButton, ensureActiveInlineMenu } from "../menus/inline-menu.js";
+import { buildProjectsMenuView, parseProjectPageCallback } from "../menus/project-selection-menu.js";
+import { replyBusyBlocked } from "../messages/busy-blocked-renderer.js";
+import { createProjectSwitchPresentation } from "../services/project-switch-presentation.js";
+export async function handleProjectSelect(ctx, deps = {}) {
+    const callbackQuery = ctx.callbackQuery;
+    if (!callbackQuery?.data) {
+        return false;
+    }
+    const page = parseProjectPageCallback(callbackQuery.data);
+    const isProjectSelection = callbackQuery.data.startsWith("project:");
+    if (page === null && !isProjectSelection) {
+        return false;
+    }
+    if (isForegroundBusy()) {
+        await replyBusyBlocked(ctx);
+        return true;
+    }
+    if (page !== null) {
+        const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
+        if (!isActiveMenu) {
+            return true;
+        }
+        try {
+            const projects = await getProjects();
+            if (projects.length === 0) {
+                await ctx.answerCallbackQuery();
+                await ctx.reply(t("projects.empty"));
+                return true;
+            }
+            const { text, keyboard } = await buildProjectsMenuView(projects, page);
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(text, {
+                reply_markup: appendInlineMenuCancelButton(keyboard, "project"),
+            });
+        }
+        catch (error) {
+            logger.error("[Bot] Error switching projects page:", error);
+            await ctx.answerCallbackQuery({ text: t("projects.page_load_error") });
+        }
+        return true;
+    }
+    const projectId = callbackQuery.data.replace("project:", "");
+    const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
+    if (!isActiveMenu) {
+        return true;
+    }
+    try {
+        const projects = await getProjects();
+        const selectedProject = projects.find((p) => p.id === projectId);
+        if (!selectedProject) {
+            throw new Error(`Project with id ${projectId} not found`);
+        }
+        const projectName = selectedProject.name || selectedProject.worktree;
+        logger.info(`[Bot] Project selected: ${projectName} (id: ${projectId})`);
+        const keyboard = await switchToProject(ctx, selectedProject, "project_switched", {
+            ensureEventSubscription: deps.ensureEventSubscription,
+            presentation: createProjectSwitchPresentation(),
+        });
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("projects.selected", { project: projectName }), {
+            reply_markup: keyboard,
+        });
+        await ctx.deleteMessage();
+    }
+    catch (error) {
+        clearAllInteractionState("project_select_error");
+        logger.error("[Bot] Error selecting project:", error);
+        await ctx.answerCallbackQuery();
+        await ctx.reply(t("projects.select_error"));
+    }
+    return true;
+}

package/dist/bot/callbacks/question-callback-handler.js

@@ -0,0 +1,159 @@
+import { questionManager } from "../../app/managers/question-manager.js";
+import { clearQuestionInteraction, showNextQuestion, syncQuestionInteractionState, updateQuestionMessage, } from "../menus/question-menu.js";
+import { t } from "../../i18n/index.js";
+import { logger } from "../../utils/logger.js";
+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;
+}
+export async function handleQuestionCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data)
+        return false;
+    if (!data.startsWith("question:")) {
+        return false;
+    }
+    logger.debug(`[QuestionHandler] Received callback: ${data}`);
+    if (!questionManager.isActive()) {
+        clearQuestionInteraction("question_inactive_callback");
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!questionManager.isActiveMessage(callbackMessageId)) {
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    const parts = data.split(":");
+    const action = parts[1];
+    const questionIndex = parseInt(parts[2], 10);
+    if (Number.isNaN(questionIndex) || questionIndex !== questionManager.getCurrentIndex()) {
+        await ctx.answerCallbackQuery({ text: t("question.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        switch (action) {
+            case "select":
+                {
+                    const optionIndex = parseInt(parts[3], 10);
+                    if (Number.isNaN(optionIndex)) {
+                        await ctx.answerCallbackQuery({
+                            text: t("question.processing_error_callback"),
+                            show_alert: true,
+                        });
+                        break;
+                    }
+                    await handleSelectOption(ctx, questionIndex, optionIndex);
+                }
+                break;
+            case "submit":
+                await handleSubmitAnswer(ctx, questionIndex);
+                break;
+            case "custom":
+                await handleCustomAnswer(ctx, questionIndex);
+                break;
+            case "cancel":
+                await handleCancelPoll(ctx);
+                break;
+            default:
+                await ctx.answerCallbackQuery({
+                    text: t("question.processing_error_callback"),
+                    show_alert: true,
+                });
+                break;
+        }
+    }
+    catch (err) {
+        logger.error("[QuestionHandler] Error handling callback:", err);
+        await ctx.answerCallbackQuery({
+            text: t("question.processing_error_callback"),
+            show_alert: true,
+        });
+    }
+    return true;
+}
+async function handleSelectOption(ctx, questionIndex, optionIndex) {
+    logger.debug(`[QuestionHandler] handleSelectOption: qIndex=${questionIndex}, oIndex=${optionIndex}`);
+    const question = questionManager.getCurrentQuestion();
+    if (!question) {
+        logger.debug("[QuestionHandler] No current question");
+        return;
+    }
+    if (questionManager.isWaitingForCustomInput(questionIndex)) {
+        questionManager.clearCustomInput();
+        syncQuestionInteractionState("callback", questionIndex, questionManager.getActiveMessageId());
+    }
+    questionManager.selectOption(questionIndex, optionIndex);
+    if (question.multiple) {
+        logger.debug("[QuestionHandler] Multiple choice mode, updating message");
+        await updateQuestionMessage(ctx);
+        await ctx.answerCallbackQuery();
+    }
+    else {
+        logger.debug("[QuestionHandler] Single choice mode, moving to next question");
+        await ctx.answerCallbackQuery();
+        const answer = questionManager.getSelectedAnswer(questionIndex);
+        logger.debug(`[QuestionHandler] Selected answer for question ${questionIndex}: ${answer}`);
+        await ctx.deleteMessage().catch(() => { });
+        await showNextQuestion(ctx);
+    }
+}
+async function handleSubmitAnswer(ctx, questionIndex) {
+    if (questionManager.isWaitingForCustomInput(questionIndex)) {
+        questionManager.clearCustomInput();
+        syncQuestionInteractionState("callback", questionIndex, questionManager.getActiveMessageId());
+    }
+    const answer = questionManager.getSelectedAnswer(questionIndex);
+    if (!answer) {
+        await ctx.answerCallbackQuery({
+            text: t("question.select_one_required_callback"),
+            show_alert: true,
+        });
+        return;
+    }
+    logger.debug(`[QuestionHandler] Submit answer for question ${questionIndex}: ${answer}`);
+    await ctx.answerCallbackQuery();
+    await ctx.deleteMessage().catch(() => { });
+    await showNextQuestion(ctx);
+}
+async function handleCustomAnswer(ctx, questionIndex) {
+    questionManager.startCustomInput(questionIndex);
+    syncQuestionInteractionState("mixed", questionIndex, questionManager.getActiveMessageId());
+    await ctx.answerCallbackQuery({
+        text: t("question.enter_custom_callback"),
+        show_alert: true,
+    });
+}
+async function handleCancelPoll(ctx) {
+    questionManager.cancel();
+    clearQuestionInteraction("question_cancelled");
+    await ctx.editMessageText(t("question.cancelled")).catch(() => { });
+    await ctx.answerCallbackQuery();
+    questionManager.clear();
+}
+export async function handleQuestionTextAnswer(ctx) {
+    const text = ctx.message?.text;
+    if (!text)
+        return;
+    const currentIndex = questionManager.getCurrentIndex();
+    if (!questionManager.isWaitingForCustomInput(currentIndex)) {
+        await ctx.reply(t("question.use_custom_button_first"));
+        return;
+    }
+    if (questionManager.hasCustomAnswer(currentIndex)) {
+        await ctx.reply(t("question.answer_already_received"));
+        return;
+    }
+    logger.debug(`[QuestionHandler] Custom text answer for question ${currentIndex}: ${text}`);
+    questionManager.setCustomAnswer(currentIndex, text);
+    questionManager.clearCustomInput();
+    const activeMessageId = questionManager.getActiveMessageId();
+    if (activeMessageId !== null && ctx.chat) {
+        await ctx.api.deleteMessage(ctx.chat.id, activeMessageId).catch(() => { });
+    }
+    await showNextQuestion(ctx);
+}

package/dist/bot/{commands/rename.js → callbacks/rename-callback-handler.js}

@@ -1,11 +1,11 @@
-import { InlineKeyboard } from "grammy";
 import { opencodeClient } from "../../opencode/client.js";
-import { getCurrentSession, setCurrentSession } from "../../session/manager.js";
-import { renameManager } from "../../rename/manager.js";
-import { interactionManager } from "../../interaction/manager.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
+import { setCurrentSession } from "../../app/services/session-service.js";
+import { renameManager } from "../../app/managers/rename-manager.js";
+import { interactionManager } from "../../app/managers/interaction-manager.js";
+import { pinnedMessageManager } from "../pinned/pinned-message-manager.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { RENAME_CANCEL_CALLBACK } from "../menus/rename-menu.js";
 function getCallbackMessageId(ctx) {
     const message = ctx.callbackQuery?.message;
     if (!message || !("message_id" in message)) {
@@ -20,37 +20,9 @@ function clearRenameInteraction(reason) {
         interactionManager.clear(reason);
     }
 }
-export async function renameCommand(ctx) {
-    try {
-        const currentSession = getCurrentSession();
-        if (!currentSession) {
-            await ctx.reply(t("rename.no_session"));
-            return;
-        }
-        const keyboard = new InlineKeyboard().text(t("rename.button.cancel"), "rename:cancel");
-        const message = await ctx.reply(t("rename.prompt", { title: currentSession.title }), {
-            reply_markup: keyboard,
-        });
-        renameManager.startWaiting(currentSession.id, currentSession.directory, currentSession.title);
-        renameManager.setMessageId(message.message_id);
-        interactionManager.start({
-            kind: "rename",
-            expectedInput: "text",
-            metadata: {
-                sessionId: currentSession.id,
-                messageId: message.message_id,
-            },
-        });
-        logger.info(`[RenameCommand] Waiting for new title for session: ${currentSession.id}`);
-    }
-    catch (error) {
-        logger.error("[RenameCommand] Error starting rename flow:", error);
-        await ctx.reply(t("rename.error"));
-    }
-}
 export async function handleRenameCancel(ctx) {
     const data = ctx.callbackQuery?.data;
-    if (!data || data !== "rename:cancel") {
+    if (!data || data !== RENAME_CANCEL_CALLBACK) {
         return false;
     }
     logger.debug("[RenameHandler] Cancel callback received");

package/dist/bot/{commands/tasklist.js → callbacks/scheduled-task-callback-handler.js}

@@ -1,15 +1,10 @@
-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 { interactionManager } from "../../app/managers/interaction-manager.js";
+import { taskCreationManager } from "../../app/managers/scheduled-task-creation-manager.js";
+import { getScheduledTask, removeScheduledTask } from "../../app/stores/scheduled-task-store.js";
+import { scheduledTaskRuntime } from "../../app/services/scheduled-task-runtime-service.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;
+import { buildCancelKeyboard, buildTaskDetailsKeyboard, TASK_CANCEL_CALLBACK, TASK_RETRY_SCHEDULE_CALLBACK, TASKLIST_CALLBACK_PREFIX, TASKLIST_CANCEL_CALLBACK, TASKLIST_DELETE_PREFIX, TASKLIST_OPEN_PREFIX, } from "../menus/scheduled-task-menu.js";
 function getCallbackMessageId(ctx) {
     const message = ctx.callbackQuery?.message;
     if (!message || !("message_id" in message)) {
@@ -18,6 +13,41 @@ function getCallbackMessageId(ctx) {
     const messageId = message.message_id;
     return typeof messageId === "number" ? messageId : null;
 }
+async function deleteMessageIfPresent(ctx, messageId) {
+    if (!ctx.chat || typeof messageId !== "number") {
+        return;
+    }
+    await ctx.api.deleteMessage(ctx.chat.id, messageId).catch(() => { });
+}
+function buildTaskInteractionMetadata(stage, projectId, projectWorktree, previewMessageId) {
+    return {
+        flow: "task",
+        stage,
+        projectId,
+        projectWorktree,
+        previewMessageId,
+    };
+}
+function isTaskInteraction(state) {
+    return state?.kind === "task";
+}
+function clearTaskInteraction(reason) {
+    const state = interactionManager.getSnapshot();
+    if (state?.kind === "task") {
+        interactionManager.clear(reason);
+    }
+}
+function clearTaskFlow(reason) {
+    taskCreationManager.clear();
+    clearTaskInteraction(reason);
+}
+function isTaskCallbackActive(flowState, messageId) {
+    return [
+        flowState.scheduleRequestMessageId,
+        flowState.previewMessageId,
+        flowState.promptRequestMessageId,
+    ].includes(messageId);
+}
 function parseTaskListMetadata(state) {
     if (!state || state.kind !== "custom") {
         return null;
@@ -55,12 +85,6 @@ function clearTaskListInteraction(reason) {
         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 "-";
@@ -76,37 +100,6 @@ function formatDateTime(dateIso, timezone) {
         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 variant = task.model.variant ? ` (${task.model.variant})` : "";
     const model = `${task.model.providerID}/${task.model.modelID}${variant}`;
@@ -122,30 +115,52 @@ function formatTaskDetails(task) {
         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;
+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");
         }
-        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,
-            },
-        });
+        await ctx.answerCallbackQuery({ text: t("task.inactive_callback"), show_alert: true });
+        return true;
     }
-    catch (error) {
-        logger.error("[TaskList] Failed to open task list", error);
-        await ctx.reply(t("tasklist.load_error"));
+    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 handleTaskListCallback(ctx) {
     const data = ctx.callbackQuery?.data;