@grinev/opencode-telegram-bot 0.19.0 → 0.19.1

package/dist/bot/commands/projects.js

@@ -153,11 +153,15 @@ export async function handleProjectSelect(ctx) {
     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;
     }
-    const page = parseProjectPageCallback(callbackQuery.data);
     if (page !== null) {
         const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
         if (!isActiveMenu) {
@@ -182,9 +186,6 @@ export async function handleProjectSelect(ctx) {
         }
         return true;
     }
-    if (!callbackQuery.data.startsWith("project:")) {
-        return false;
-    }
     const projectId = callbackQuery.data.replace("project:", "");
     const isActiveMenu = await ensureActiveInlineMenu(ctx, "project");
     if (!isActiveMenu) {

package/dist/bot/commands/tasklist.js

@@ -108,10 +108,12 @@ function sortTasks(tasks) {
     });
 }
 function formatTaskDetails(task) {
+    const variant = task.model.variant ? ` (${task.model.variant})` : "";
+    const model = `${task.model.providerID}/${task.model.modelID}${variant}`;
     const cronLine = task.kind === "cron" ? `${t("tasklist.details.cron", { cron: task.cron })}\n` : "";
     return t("tasklist.details", {
         prompt: task.prompt,
-        project: task.projectWorktree,
+        project: `${task.projectWorktree}\n${t("status.line.model", { model })}`,
         schedule: task.scheduleSummary,
         cronLine,
         timezone: task.timezone,

package/dist/bot/handlers/prompt.js

@@ -197,7 +197,7 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
             promptLength: text.length,
             fileCount: fileParts.length,
         };
-        logger.info(`[Bot] Calling session.prompt (fire-and-forget) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
+        logger.info(`[Bot] Calling session.promptAsync (start-only) with agent=${currentAgent}, fileCount=${fileParts.length}...`);
         foregroundSessionState.markBusy(currentSession.id);
         await markAttachedSessionBusy(currentSession.id);
         assistantRunState.startRun(currentSession.id, {
@@ -210,13 +210,14 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
         if (text.trim().length > 0) {
             externalUserInputSuppressionManager.register(currentSession.id, text);
         }
-        // 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.
-        // The processing result will arrive via SSE events.
+        // CRITICAL: Use the async prompt start endpoint here.
+        // session.prompt streams the full assistant response and can outlive the original
+        // Telegram message handler, which turns late transport failures into misleading
+        // "failed to send" messages even after the run has already started.
+        // The actual assistant result still arrives via the SSE event subscription.
         safeBackgroundTask({
-            taskName: "session.prompt",
-            task: () => opencodeClient.session.prompt(promptOptions),
+            taskName: "session.promptAsync",
+            task: () => opencodeClient.session.promptAsync(promptOptions),
             onSuccess: ({ error }) => {
                 if (error) {
                     foregroundSessionState.markIdle(currentSession.id);
@@ -224,14 +225,14 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
                     assistantRunState.clearRun(currentSession.id, "session_prompt_api_error");
                     clearPromptResponseMode(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);
-                    logger.error("[Bot] session.prompt raw API error object:", error);
+                    logger.error("[Bot] OpenCode API returned an error for session.promptAsync", promptErrorLogContext);
+                    logger.error("[Bot] session.promptAsync error details:", details);
+                    logger.error("[Bot] session.promptAsync raw API error object:", error);
                     // Send user-friendly error via API directly because ctx is no longer available
                     void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
                     return;
                 }
-                logger.info("[Bot] session.prompt completed");
+                logger.info("[Bot] session.promptAsync accepted");
             },
             onError: (error) => {
                 foregroundSessionState.markIdle(currentSession.id);
@@ -239,9 +240,9 @@ export async function processUserPrompt(ctx, text, deps, fileParts = [], options
                 assistantRunState.clearRun(currentSession.id, "session_prompt_background_error");
                 clearPromptResponseMode(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);
-                logger.error("[Bot] session.prompt raw background error object:", error);
+                logger.error("[Bot] session.promptAsync background task failed", promptErrorLogContext);
+                logger.error("[Bot] session.promptAsync background failure details:", details);
+                logger.error("[Bot] session.promptAsync raw background error object:", error);
                 void bot.api.sendMessage(ctx.chat.id, t("bot.prompt_send_error")).catch(() => { });
             },
         });

package/dist/i18n/de.js

@@ -320,6 +320,8 @@ export const de = {
     "task.kind.once": "einmalig",
     "task.run.success": "⏰ Geplante Aufgabe abgeschlossen: {description}",
     "task.run.error": "🔴 Geplante Aufgabe fehlgeschlagen: {description}\n\nFehler: {error}",
+    "task.run.error.interactive_question": "Die geplante Aufgabe hat eine interaktive Frage gestellt und kann unbeaufsichtigt nicht fortfahren.",
+    "task.run.error.interactive_permission": "Die geplante Aufgabe hat eine interaktive Berechtigung angefordert und kann unbeaufsichtigt nicht fortfahren.",
     "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}",

package/dist/i18n/en.js

@@ -320,6 +320,8 @@ export const en = {
     "task.kind.once": "one-time",
     "task.run.success": "⏰ Scheduled task completed: {description}",
     "task.run.error": "🔴 Scheduled task failed: {description}\n\nError: {error}",
+    "task.run.error.interactive_question": "Scheduled task requested an interactive question and cannot continue unattended.",
+    "task.run.error.interactive_permission": "Scheduled task requested interactive permission and cannot continue unattended.",
     "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}",

package/dist/i18n/es.js

@@ -320,6 +320,8 @@ export const es = {
     "task.kind.once": "única",
     "task.run.success": "⏰ Tarea programada completada: {description}",
     "task.run.error": "🔴 La tarea programada falló: {description}\n\nError: {error}",
+    "task.run.error.interactive_question": "La tarea programada solicitó una pregunta interactiva y no puede continuar sin supervisión.",
+    "task.run.error.interactive_permission": "La tarea programada solicitó un permiso interactivo y no puede continuar sin supervisión.",
     "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}",

package/dist/i18n/fr.js

@@ -320,6 +320,8 @@ export const fr = {
     "task.kind.once": "ponctuelle",
     "task.run.success": "⏰ Tâche planifiée terminée : {description}",
     "task.run.error": "🔴 Échec de la tâche planifiée : {description}\n\nErreur : {error}",
+    "task.run.error.interactive_question": "La tâche planifiée a demandé une question interactive et ne peut pas continuer sans intervention.",
+    "task.run.error.interactive_permission": "La tâche planifiée a demandé une autorisation interactive et ne peut pas continuer sans intervention.",
     "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}",

package/dist/i18n/ru.js

@@ -320,6 +320,8 @@ export const ru = {
     "task.kind.once": "однократная",
     "task.run.success": "⏰ Задача по расписанию выполнена: {description}",
     "task.run.error": "🔴 Ошибка выполнения задачи по расписанию: {description}\n\nОшибка: {error}",
+    "task.run.error.interactive_question": "Задача по расписанию задала интерактивный вопрос и не может продолжить выполнение без участия пользователя.",
+    "task.run.error.interactive_permission": "Задача по расписанию запросила интерактивное разрешение и не может продолжить выполнение без участия пользователя.",
     "tasklist.empty": "📭 Задач по расписанию пока нет.",
     "tasklist.select": "Выберите задачу по расписанию:",
     "tasklist.details": "⏰ Задача по расписанию\n\nЗадача: {prompt}\nПроект: {project}\nРасписание: {schedule}\n{cronLine}Часовой пояс: {timezone}\nСледующий запуск: {nextRunAt}\nПоследний запуск: {lastRunAt}\nКоличество запусков: {runCount}",

package/dist/i18n/zh.js

@@ -320,6 +320,8 @@ export const zh = {
     "task.kind.once": "一次性",
     "task.run.success": "⏰ 定时任务已完成: {description}",
     "task.run.error": "🔴 定时任务执行失败: {description}\n\n错误: {error}",
+    "task.run.error.interactive_question": "定时任务请求了交互式问题，无法在无人值守时继续。",
+    "task.run.error.interactive_permission": "定时任务请求了交互式权限，无法在无人值守时继续。",
     "tasklist.empty": "📭 还没有定时任务。",
     "tasklist.select": "请选择一个定时任务：",
     "tasklist.details": "⏰ 定时任务\n\n任务：{prompt}\n项目：{project}\n计划：{schedule}\n{cronLine}时区：{timezone}\n下次运行：{nextRunAt}\n上次运行：{lastRunAt}\n运行次数：{runCount}",

package/dist/scheduled-task/executor.js

@@ -1,12 +1,30 @@
 import { config } from "../config.js";
+import { t } from "../i18n/index.js";
 import { opencodeClient } from "../opencode/client.js";
 import { logger } from "../utils/logger.js";
-const SCHEDULED_TASK_AGENT = "build";
+export const SCHEDULED_TASK_AGENT = "build";
 const SCHEDULED_TASK_SESSION_TITLE = "Scheduled task run";
 const EXECUTION_POLL_INTERVAL_MS = 2000;
 const MAX_IDLE_POLLS_WITHOUT_RESULT = 3;
+const COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS = 500;
+const MAX_COMPLETED_EMPTY_RESULT_RECHECKS = 3;
 const MODELS_DOCS_URL = "https://opencode.ai/docs/config/#models";
 const EXECUTION_TIMEOUT_ERROR_PREFIX = "Scheduled task exceeded bot execution timeout";
+const INTERACTIVE_PERMISSION_REJECT_MESSAGE = "Scheduled task cannot continue because it requires interactive permission.";
+class ScheduledTaskEmptyAssistantResponseError extends Error {
+    constructor() {
+        super("Scheduled task returned an empty assistant response");
+        this.name = "ScheduledTaskEmptyAssistantResponseError";
+    }
+}
+class ScheduledTaskInteractiveRequestError extends Error {
+    constructor(kind) {
+        super(t(kind === "question"
+            ? "task.run.error.interactive_question"
+            : "task.run.error.interactive_permission"));
+        this.name = "ScheduledTaskInteractiveRequestError";
+    }
+}
 function collectResponseText(parts) {
     return parts
         .filter((part) => part.type === "text" && typeof part.text === "string" && !part.ignored)
@@ -69,7 +87,7 @@ function sleep(ms) {
 function findLatestAssistantMessage(messages) {
     for (let index = messages.length - 1; index >= 0; index -= 1) {
         const message = messages[index];
-        if (message?.info.role === "assistant") {
+        if (message?.info.role === "assistant" && !message.info.summary) {
             return message;
         }
     }
@@ -77,7 +95,7 @@ function findLatestAssistantMessage(messages) {
 }
 function extractAssistantResult(message) {
     if (!message) {
-        return { resultText: null, errorMessage: null, completed: false };
+        return { resultText: null, errorMessage: null, completed: false, message: null };
     }
     const errorMessage = extractErrorMessage(message.info.error);
     if (errorMessage) {
@@ -85,6 +103,7 @@ function extractAssistantResult(message) {
             resultText: null,
             errorMessage: normalizeScheduledTaskErrorMessage(errorMessage),
             completed: true,
+            message,
         };
     }
     const resultText = collectResponseText(message.parts);
@@ -92,8 +111,116 @@ function extractAssistantResult(message) {
         resultText,
         errorMessage: null,
         completed: Boolean(message.info.time?.completed),
+        message,
     };
 }
+function summarizeAssistantParts(parts) {
+    return parts.map((part) => ({
+        id: part.id,
+        type: part.type,
+        ignored: part.ignored,
+        ...(typeof part.text === "string" ? { textLength: part.text.length } : {}),
+        ...(part.tool ? { tool: part.tool } : {}),
+        ...(part.state?.status ? { status: part.state.status } : {}),
+    }));
+}
+function logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, message, readCount) {
+    logger.warn("[ScheduledTaskExecutor] Empty completed assistant response diagnostics", {
+        taskId,
+        sessionId,
+        directory,
+        readCount,
+        assistantMessage: message
+            ? {
+                id: message.info.id,
+                completed: Boolean(message.info.time?.completed),
+                summary: Boolean(message.info.summary),
+                errorMessage: extractErrorMessage(message.info.error),
+                parts: summarizeAssistantParts(message.parts),
+            }
+            : null,
+    });
+}
+async function loadPendingInteractiveRequest(sessionId, directory) {
+    const [questionsResult, permissionsResult] = await Promise.all([
+        opencodeClient.question.list({ directory }),
+        opencodeClient.permission.list({ directory }),
+    ]);
+    if (questionsResult.error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to list pending questions: sessionId=${sessionId}`, questionsResult.error);
+    }
+    const question = questionsResult.data?.find((request) => request.sessionID === sessionId);
+    if (question) {
+        return { kind: "question", request: question };
+    }
+    if (permissionsResult.error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to list pending permissions: sessionId=${sessionId}`, permissionsResult.error);
+    }
+    const permission = permissionsResult.data?.find((request) => request.sessionID === sessionId);
+    if (permission) {
+        return { kind: "permission", request: permission };
+    }
+    return null;
+}
+async function rejectInteractiveRequest(request, directory) {
+    try {
+        if (request.kind === "question") {
+            const { error } = await opencodeClient.question.reject({
+                requestID: request.request.id,
+                directory,
+            });
+            if (error) {
+                logger.warn(`[ScheduledTaskExecutor] Failed to reject pending question: requestId=${request.request.id}`, error);
+            }
+            return;
+        }
+        const { error } = await opencodeClient.permission.reply({
+            requestID: request.request.id,
+            directory,
+            reply: "reject",
+            message: INTERACTIVE_PERMISSION_REJECT_MESSAGE,
+        });
+        if (error) {
+            logger.warn(`[ScheduledTaskExecutor] Failed to reject pending permission: requestId=${request.request.id}`, error);
+        }
+    }
+    catch (error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to reject pending interactive request: requestId=${request.request.id}`, error);
+    }
+}
+async function abortScheduledTaskSession(sessionId, directory) {
+    try {
+        const { error } = await opencodeClient.session.abort({ sessionID: sessionId, directory });
+        if (error) {
+            logger.warn(`[ScheduledTaskExecutor] Failed to abort interactive scheduled task session: sessionId=${sessionId}`, error);
+        }
+    }
+    catch (error) {
+        logger.warn(`[ScheduledTaskExecutor] Failed to abort interactive scheduled task session: sessionId=${sessionId}`, error);
+    }
+}
+async function failIfInteractiveRequest(taskId, sessionId, directory) {
+    const interactiveRequest = await loadPendingInteractiveRequest(sessionId, directory);
+    if (!interactiveRequest) {
+        return;
+    }
+    logger.warn("[ScheduledTaskExecutor] Scheduled task requested interactive action", {
+        taskId,
+        sessionId,
+        directory,
+        kind: interactiveRequest.kind,
+        requestId: interactiveRequest.request.id,
+        ...(interactiveRequest.kind === "question"
+            ? { questionCount: interactiveRequest.request.questions?.length ?? 0 }
+            : {
+                permission: interactiveRequest.request.permission,
+                patterns: interactiveRequest.request.patterns,
+            }),
+    });
+    await rejectInteractiveRequest(interactiveRequest, directory);
+    await abortScheduledTaskSession(sessionId, directory);
+    throw new ScheduledTaskInteractiveRequestError(interactiveRequest.kind);
+}
 async function loadAssistantResult(sessionId, directory) {
     const { data: messages, error: messagesError } = await opencodeClient.session.messages({
         sessionID: sessionId,
@@ -104,14 +231,16 @@ async function loadAssistantResult(sessionId, directory) {
     }
     return extractAssistantResult(findLatestAssistantMessage(messages));
 }
-async function waitForScheduledTaskResult(sessionId, directory) {
+async function waitForScheduledTaskResult(taskId, sessionId, directory) {
     const startedAtMs = Date.now();
     const executionTimeoutMs = getExecutionTimeoutMs();
     let idlePollsWithoutResult = 0;
+    let completedEmptyResultReadCount = 0;
     while (true) {
         if (Date.now() - startedAtMs >= executionTimeoutMs) {
             throw new Error(createExecutionTimeoutMessage());
         }
+        await failIfInteractiveRequest(taskId, sessionId, directory);
         const assistantResult = await loadAssistantResult(sessionId, directory);
         if (assistantResult.errorMessage) {
             throw new Error(assistantResult.errorMessage);
@@ -120,8 +249,15 @@ async function waitForScheduledTaskResult(sessionId, directory) {
             if (assistantResult.resultText) {
                 return assistantResult.resultText;
             }
-            throw new Error("Scheduled task returned an empty assistant response");
+            completedEmptyResultReadCount += 1;
+            if (completedEmptyResultReadCount > MAX_COMPLETED_EMPTY_RESULT_RECHECKS) {
+                logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, assistantResult.message, completedEmptyResultReadCount);
+                throw new ScheduledTaskEmptyAssistantResponseError();
+            }
+            await sleep(COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS);
+            continue;
         }
+        completedEmptyResultReadCount = 0;
         const { data: statuses, error: statusError } = await opencodeClient.session.status({
             directory,
         });
@@ -138,7 +274,13 @@ async function waitForScheduledTaskResult(sessionId, directory) {
                 if (confirmedAssistantResult.resultText) {
                     return confirmedAssistantResult.resultText;
                 }
-                throw new Error("Scheduled task returned an empty assistant response");
+                completedEmptyResultReadCount += 1;
+                if (completedEmptyResultReadCount > MAX_COMPLETED_EMPTY_RESULT_RECHECKS) {
+                    logEmptyAssistantResponseDiagnostics(taskId, sessionId, directory, confirmedAssistantResult.message, completedEmptyResultReadCount);
+                    throw new ScheduledTaskEmptyAssistantResponseError();
+                }
+                await sleep(COMPLETED_EMPTY_RESULT_RECHECK_INTERVAL_MS);
+                continue;
             }
             idlePollsWithoutResult += 1;
             if (idlePollsWithoutResult >= MAX_IDLE_POLLS_WITHOUT_RESULT) {
@@ -154,6 +296,7 @@ async function waitForScheduledTaskResult(sessionId, directory) {
 export async function executeScheduledTask(task) {
     const startedAt = new Date().toISOString();
     let sessionId = null;
+    let deleteTemporarySession = true;
     try {
         const { data: session, error: createError } = await opencodeClient.session.create({
             directory: task.projectWorktree,
@@ -182,7 +325,7 @@ export async function executeScheduledTask(task) {
         if (promptError) {
             throw promptError || new Error("Scheduled task prompt execution failed");
         }
-        const resultText = await waitForScheduledTaskResult(session.id, session.directory);
+        const resultText = await waitForScheduledTaskResult(task.id, session.id, session.directory);
         return {
             taskId: task.id,
             status: "success",
@@ -194,6 +337,10 @@ export async function executeScheduledTask(task) {
     }
     catch (error) {
         const errorMessage = toErrorMessage(error);
+        if (error instanceof ScheduledTaskEmptyAssistantResponseError && sessionId) {
+            deleteTemporarySession = false;
+            logger.warn(`[ScheduledTaskExecutor] Keeping temporary session for inspection: id=${task.id}, sessionId=${sessionId}`);
+        }
         logger.warn(`[ScheduledTaskExecutor] Task execution failed: id=${task.id}, message=${errorMessage}`);
         return {
             taskId: task.id,
@@ -205,7 +352,7 @@ export async function executeScheduledTask(task) {
         };
     }
     finally {
-        if (sessionId) {
+        if (sessionId && deleteTemporarySession) {
             try {
                 await opencodeClient.session.delete({ sessionID: sessionId });
             }

package/dist/scheduled-task/runtime.js

@@ -4,7 +4,8 @@ import { t } from "../i18n/index.js";
 import { logger } from "../utils/logger.js";
 import { safeBackgroundTask } from "../utils/safe-background-task.js";
 import { sendBotText } from "../bot/utils/telegram-text.js";
-import { executeScheduledTask } from "./executor.js";
+import { formatAssistantRunFooter } from "../bot/utils/assistant-run-footer.js";
+import { executeScheduledTask, SCHEDULED_TASK_AGENT } from "./executor.js";
 import { foregroundSessionState } from "./foreground-state.js";
 import { computeNextRunAt, isTaskDue } from "./next-run.js";
 import { getScheduledTask, listScheduledTasks, removeScheduledTask, replaceScheduledTasks, updateScheduledTask, } from "./store.js";
@@ -40,7 +41,15 @@ function normalizeTaskPrompt(prompt) {
     }
     return `${normalized.slice(0, TASK_DESCRIPTION_PREVIEW_LENGTH)}...`;
 }
-function buildSuccessDelivery(task, runAt, resultText) {
+function calculateElapsedMs(startedAt, finishedAt) {
+    const startedAtMs = Date.parse(startedAt);
+    const finishedAtMs = Date.parse(finishedAt);
+    if (Number.isNaN(startedAtMs) || Number.isNaN(finishedAtMs)) {
+        return 0;
+    }
+    return finishedAtMs - startedAtMs;
+}
+function buildSuccessDelivery(task, startedAt, runAt, resultText) {
     return {
         taskId: task.id,
         scheduleSummary: task.scheduleSummary,
@@ -51,6 +60,12 @@ function buildSuccessDelivery(task, runAt, resultText) {
             description: normalizeTaskPrompt(task.prompt),
         }),
         resultText,
+        footerText: formatAssistantRunFooter({
+            agent: SCHEDULED_TASK_AGENT,
+            providerID: task.model.providerID,
+            modelID: task.model.modelID,
+            elapsedMs: calculateElapsedMs(startedAt, runAt),
+        }),
     };
 }
 function buildErrorDelivery(task, runAt, errorMessage) {
@@ -280,7 +295,7 @@ export class ScheduledTaskRuntime {
         try {
             const result = await executeScheduledTask(runningTask);
             if (result.status === "success") {
-                await this.handleSuccessfulExecution(runningTask, result.finishedAt, result.resultText || "");
+                await this.handleSuccessfulExecution(runningTask, result.startedAt, result.finishedAt, result.resultText || "");
             }
             else {
                 await this.handleFailedExecution(runningTask, result.finishedAt, result.errorMessage || "Unknown error");
@@ -290,8 +305,8 @@ export class ScheduledTaskRuntime {
             this.runningTaskIds.delete(taskId);
         }
     }
-    async handleSuccessfulExecution(task, finishedAt, resultText) {
-        const delivery = buildSuccessDelivery(task, finishedAt, resultText);
+    async handleSuccessfulExecution(task, startedAt, finishedAt, resultText) {
+        const delivery = buildSuccessDelivery(task, startedAt, finishedAt, resultText);
         if (task.kind === "once") {
             await removeScheduledTask(task.id);
             this.removeTask(task.id);
@@ -357,12 +372,22 @@ export class ScheduledTaskRuntime {
                 ? buildScheduledTaskSuccessMessageParts(delivery)
                 : [delivery.notificationText];
             const format = delivery.status === "success" ? getScheduledTaskDeliveryFormat() : "raw";
+            const suppressResultNotification = delivery.status === "success" && Boolean(delivery.footerText);
             for (const part of messageParts) {
                 await sendBotText({
                     api: this.botApi,
                     chatId: this.chatId,
                     text: part,
                     format,
+                    ...(suppressResultNotification ? { options: { disable_notification: true } } : {}),
+                });
+            }
+            if (delivery.status === "success" && delivery.footerText) {
+                await sendBotText({
+                    api: this.botApi,
+                    chatId: this.chatId,
+                    text: delivery.footerText,
+                    format: "raw",
                 });
             }
             return true;

package/dist/session/cache-manager.js

@@ -136,9 +136,8 @@ function upsertDirectory(worktree, lastUpdated) {
     dedupeAndTrimDirectories(cacheData);
     return true;
 }
-function buildListParams() {
-    const hasWatermark = cacheData.lastSyncedUpdatedAt > 0;
-    if (!hasWatermark) {
+function buildListParams(options) {
+    if (options?.force || cacheData.lastSyncedUpdatedAt === 0) {
         return { limit: INITIAL_WARMUP_LIMIT };
     }
     return {
@@ -194,24 +193,38 @@ function isServerUnavailableError(error) {
     }
     return false;
 }
-async function runSync() {
+async function runSync(options) {
     await ensureCacheLoaded();
-    const params = buildListParams();
+    const shouldPrune = options?.force || cacheData.lastSyncedUpdatedAt === 0;
+    const params = buildListParams(options);
     const { data: sessions, error } = await opencodeClient.session.list(params);
     if (error || !sessions) {
         throw error || new Error("No session list received from server");
     }
     let changed = false;
     let maxUpdated = cacheData.lastSyncedUpdatedAt;
+    const seenDirectories = new Set();
     for (const session of sessions) {
         const updatedAt = session.time?.updated ?? Date.now();
         if (upsertDirectory(session.directory, updatedAt)) {
             changed = true;
         }
+        if (session.directory && isValidWorktree(session.directory)) {
+            seenDirectories.add(worktreeKey(session.directory.trim()));
+        }
         if (updatedAt > maxUpdated) {
             maxUpdated = updatedAt;
         }
     }
+    const responseIsTruncated = sessions.length >= INITIAL_WARMUP_LIMIT;
+    if (shouldPrune && !responseIsTruncated) {
+        const before = cacheData.directories.length;
+        cacheData.directories = cacheData.directories.filter((d) => seenDirectories.has(worktreeKey(d.worktree)));
+        if (cacheData.directories.length !== before) {
+            changed = true;
+            logger.info(`[SessionCache] Pruned ${before - cacheData.directories.length} stale directories from cache`);
+        }
+    }
     if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
         cacheData.lastSyncedUpdatedAt = maxUpdated;
         changed = true;
@@ -397,7 +410,7 @@ export async function syncSessionDirectoryCache(options) {
     if (syncInFlight) {
         return syncInFlight;
     }
-    syncInFlight = runSync()
+    syncInFlight = runSync(options)
         .then(() => {
         lastSyncAttemptAt = Date.now();
     })

package/dist/utils/logger.js

@@ -16,6 +16,7 @@ const LOG_LEVELS = {
 let logStream = null;
 let logFilePath = null;
 let initializePromise = null;
+let cleanupPromise = null;
 let streamErrorReported = false;
 function normalizeLogLevel(value) {
     if (value in LOG_LEVELS) {
@@ -96,6 +97,9 @@ function getInstalledLogFileName() {
 function getLogFileName(mode) {
     return mode === "installed" ? getInstalledLogFileName() : getSourcesLogFileName();
 }
+function getLogFilePathForMode(logsDirPath, mode) {
+    return path.join(logsDirPath, getLogFileName(mode));
+}
 function getLogFilePattern(mode) {
     if (mode === "installed") {
         return /^bot-\d{4}-\d{2}-\d{2}\.log$/;
@@ -160,11 +164,49 @@ async function cleanupOldLogs(logsDirPath, mode) {
         }
     }));
 }
+function cleanupOldLogsInBackground(logsDirPath, mode) {
+    if (cleanupPromise) {
+        return;
+    }
+    cleanupPromise = cleanupOldLogs(logsDirPath, mode)
+        .catch((error) => {
+        reportLoggerInternalError(`Failed to clean up old logs in ${logsDirPath}.`, error);
+    })
+        .finally(() => {
+        cleanupPromise = null;
+    });
+}
+function rotateInstalledLogIfNeeded() {
+    const mode = getRuntimeMode();
+    if (mode !== "installed" || !logFilePath) {
+        return;
+    }
+    const runtimePaths = getRuntimePaths();
+    const nextLogFilePath = getLogFilePathForMode(runtimePaths.logsDirPath, mode);
+    if (logFilePath === nextLogFilePath) {
+        return;
+    }
+    try {
+        fs.mkdirSync(runtimePaths.logsDirPath, { recursive: true });
+        fs.appendFileSync(nextLogFilePath, "");
+        ensureLogStream(nextLogFilePath);
+        cleanupOldLogsInBackground(runtimePaths.logsDirPath, mode);
+    }
+    catch (error) {
+        reportLoggerInternalError(`Failed to rotate file logging to ${nextLogFilePath}.`, error);
+        closeLogStream();
+        logFilePath = null;
+    }
+}
 function writeToFile(line) {
     if (!logStream) {
         return;
     }
     try {
+        rotateInstalledLogIfNeeded();
+        if (!logStream) {
+            return;
+        }
         logStream.write(`${line}\n`);
     }
     catch (error) {
@@ -179,7 +221,7 @@ async function initializeLoggerInternal() {
     const mode = getRuntimeMode();
     try {
         await fsPromises.mkdir(runtimePaths.logsDirPath, { recursive: true });
-        const nextLogFilePath = path.join(runtimePaths.logsDirPath, getLogFileName(mode));
+        const nextLogFilePath = getLogFilePathForMode(runtimePaths.logsDirPath, mode);
         await fsPromises.appendFile(nextLogFilePath, "");
         ensureLogStream(nextLogFilePath);
         await cleanupOldLogs(runtimePaths.logsDirPath, mode);
@@ -207,6 +249,9 @@ export function getLogFilePath() {
     return logFilePath;
 }
 export async function __flushLoggerForTests() {
+    if (cleanupPromise) {
+        await cleanupPromise;
+    }
     if (!logStream) {
         return;
     }
@@ -222,6 +267,7 @@ export async function __flushLoggerForTests() {
 }
 export function __resetLoggerForTests() {
     initializePromise = null;
+    cleanupPromise = null;
     logFilePath = null;
     streamErrorReported = false;
     closeLogStream();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",