@goodandready/dsh-cron 0.1.23 → 0.2.0

package/lib/integrations.js

@@ -57,7 +57,6 @@ export async function createKanbanCard({
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'Sec-Fetch-Site': 'same-origin',
       },
       body: JSON.stringify({
         title,

package/lib/prompt.js

@@ -1,54 +1,56 @@
 /**
  * Builds the initial prompt for starting a session with DSH agent to configure a cron task.
- * @param {string} userText 
+ * English is the canonical source language; the conversation language follows
+ * the user's DSH locale via the translation plugin.
+ * @param {string} userText
  * @returns {string}
  */
 export function buildAgentCronPrompt(userText) {
   const text = (userText || '').trim();
-  return `Пользователь хочет настроить запланированную задачу (cron) через DSH Cron.
-Исходный запрос пользователя:
+  return `The user wants to set up a scheduled (cron) task via DSH Cron.
+The user's original request:
 "${text}"
 
-ВАЖНЕЙШИЕ ПРАВИЛА ДЛЯ АГЕНТА:
-1. СТРОГИЙ ЗАПРЕТ НА СПЕШКУ:
-   КАТЕГОРИЧЕСКИ ЗАПРЕЩЕНО вызывать инструмент \`cron_create_task\` (или \`cron_schedule_task\`) в первом же ответе!
-   Ты НЕ имеешь права создавать задачу, пока не задашь пользователю уточняющие вопросы и не получишь его подтверждение.
+CRITICAL RULES FOR THE AGENT:
+1. NEVER RUSH:
+   It is STRICTLY FORBIDDEN to call the \`cron_create_task\` (or \`cron_schedule_task\`) tool in your first reply!
+   You MUST NOT create the task until you have asked clarifying questions and received the user's confirmation.
 
-2. ПЕРВЫЙ ВОПРОС: LLM vs NO-LLM Shell (КРИТИЧЕСКИ ВАЖНО):
-   - Оцени характер задачи:
-     * Если задача ТРИВИАЛЬНАЯ (проверка RSS/Atom фида, проверка кода ответа HTTP, curl/ping/git check, мониторинг файла или службы) — ТЫ ОБЯЗАН РЕКОМЕНДОВАТЬ NO-LLM Shell (type: "script")!
-       Поясни пользователю: "Для этой задачи языковая модель избыточна — простой bash-скрипт с curl/jq отработает за миллисекунды, надежно и не потратит ни единого токена. Рекомендую оформить как NO-LLM Shell-скрипт."
-     * Если задача требует СЕМАНТИЧЕСКОГО АНАЛИЗА (обобщение писем, генерация отчета из неструктурированного текста, принятие смысловых решений) — предложи LLM (type: "llm").
-   - Спроси пользователя, согласен ли он с предложенным типом задачи.
+2. FIRST QUESTION: LLM vs NO-LLM Shell (critical):
+   - Evaluate the nature of the task:
+     * If the task is TRIVIAL (checking an RSS/Atom feed, checking an HTTP status code, curl/ping/git checks, monitoring a file or a service) — you MUST recommend the NO-LLM Shell variant (type: "script")!
+       Explain to the user: "A language model is overkill for this task — a simple bash script with curl/jq completes in milliseconds, is more reliable, and costs zero tokens. I recommend the NO-LLM Shell script variant."
+     * If the task requires SEMANTIC ANALYSIS (summarizing messages, generating a report from unstructured text, making judgement calls) — propose an LLM task (type: "llm").
+   - Ask the user whether they agree with the proposed task type.
 
-3. ЧТО ТЫ ОБЯЗАН УТОЧНИТЬ:
-   - Если выбран NO-LLM Shell:
-     * Предложи готовый shell-скрипт или команду для выполнения.
-     * Уточни, подходит ли логика скрипта.
-   - Если выбран LLM:
-     * Предложи экономичную модель (например, \`deepseek/deepseek-v4-flash\` или \`Qwen/Qwen3.8-Flash\`).
-     * Спроси, подходит ли эта модель.
-   - Точное расписание (schedule):
-     * Предложи конкретное выражение cron (например, "0 */6 * * *" для 4 раз в день или "0 9 * * 1-5" по будням) и понятное текстовое пояснение.
-   - Silent Rule (Правило тишины / Уведомления):
-     * Для проверок и мониторингов действует жесткое Silent Rule: если новых событий/изменений нет — ПОЛНАЯ ТИШИНА, никаких сообщений в чат/Telegram не отправляется вообще (exit 0 в скрипте или пустой ответ). Оповещение уходит ТОЛЬКО при обнаружении новинок или сбое.
-     * Подтверди пользователю, что правило тишины будет включено.
+3. WHAT YOU MUST CLARIFY:
+   - If NO-LLM Shell was chosen:
+     * Propose a ready-made shell script or command to execute.
+     * Confirm that the script logic suits the user.
+   - If LLM was chosen:
+     * Propose an economical model from those available in the user's DSH installation and explain why it fits this task.
+     * Ask whether this model works for the user.
+   - The exact schedule:
+     * Propose a concrete cron expression (for example, "0 */6 * * *" for 4 times a day, or "0 9 * * 1-5" for weekdays) and a plain-language explanation.
+   - Silent Rule (notifications):
+     * For checks and monitoring, apply the strict Silent Rule: when there are NO new events or changes — FULL SILENCE, no messages to chat/Telegram at all (exit 0 in scripts, or an empty reply). An alert is sent ONLY when something new is found or a failure occurs.
+     * Confirm to the user that the silent rule will be enabled.
 
-4. СТРУКТУРА ПЕРВОГО ОТВЕТА:
-   - Кратко подтверди суть задачи.
-   - Сформулируй проект карточки:
-     • Тип: [NO-LLM Shell (рекомендуется) / LLM]
-     • Расписание: [cron-выражение и понятное описание]
-     • Реализация / Скрипт / Модель: [код скрипта или предлагаемая модель]
-     • Silent Rule: [только при наличии изменений / сбое]
-   - Задай недостающие вопросы и попроси подтвердить создание задачи.
+4. STRUCTURE OF THE FIRST REPLY:
+   - Briefly confirm the essence of the task.
+   - Present the draft task card:
+     • Type: [NO-LLM Shell (recommended) / LLM]
+     • Schedule: [cron expression and a plain-language description]
+     • Implementation / Script / Model: [script code or the proposed model]
+     • Silent Rule: [only on new events / failures]
+   - Ask any remaining questions and ask the user to confirm task creation.
 
-5. СОЗДАНИЕ ЗАДАЧИ:
-   Только ПОСЛЕ ТОГО, как пользователь ответит и подтвердит параметры, вызови инструмент \`cron_create_task\`, передав:
-   - title: понятное название задачи
-   - schedule: согласованное cron-выражение
-   - prompt: финальная shell-команда/путь к скрипту (для type="script") ИЛИ подробная инструкция с Silent Rule (для type="llm")
-   - type: "script" или "llm"
-   - provider и model: согласованный провайдер и модель (только если type="llm")
+5. CREATING THE TASK:
+   Only AFTER the user replies and confirms the parameters, call the \`cron_create_task\` tool with:
+   - title: a clear task name
+   - schedule: the agreed cron expression
+   - prompt: the final shell command/script path (for type="script") OR detailed instructions including the Silent Rule (for type="llm")
+   - type: "script" or "llm"
+   - provider and model: the agreed provider and model (only if type="llm")
    - delivery: "isolated"`;
 }

package/lib/runner.js

@@ -45,14 +45,18 @@ export class SessionRunner {
 
   async _run(task, signal) {
     console.log(`[dsh-cron] executing task "${task.title}" (${task.id})`);
-    
+
     // 1. Direct shell / script task fallback (NO-LLM)
     if (task.type === 'script' || task.mode === 'no-llm') {
       const { exec } = await import('node:child_process');
       return new Promise((resolve, reject) => {
+        const shellPath = process.platform === 'win32' ? undefined : (process.env.SHELL || '/bin/bash');
         const child = exec(task.prompt, {
           cwd: process.cwd(),
           signal,
+          maxBuffer: 10 * 1024 * 1024,
+          shell: shellPath,
+          env: { ...process.env },
         }, (err, stdout, stderr) => {
           if (err) {
             if (signal && signal.aborted) {
@@ -97,50 +101,77 @@ export class SessionRunner {
 
         const defaultSel = this.ctx.get?.('agentDefaultModel')?.currentSelection?.();
         const provider = task.provider || defaultSel?.provider;
-        const model = task.model || defaultSel?.model || 'deepseek-v4-flash';
+        const model = task.model || defaultSel?.model || undefined;
+
+        // The agent session cannot take the AbortSignal natively, so any abort
+        // (timeout, overlap replace, pause, scheduler stop) races against the
+        // session awaits and forces an immediate dispose (#88).
+        const abortError = () => (signal && signal.reason) || new Error('Task aborted');
+        const raceAbort = (promise) => {
+          if (!signal) return promise;
+          return Promise.race([
+            promise,
+            new Promise((_, reject) => {
+              if (signal.aborted) {
+                reject(abortError());
+                return;
+              }
+              signal.addEventListener('abort', () => reject(abortError()), { once: true });
+            }),
+          ]);
+        };
 
         const cwd = process.cwd();
-        const handle = await this.ctx.agents.create({
-          sessionId: mintSessionId(),
-          meta: { cwd },
-          agentOptions: provider && model ? { provider, model } : undefined,
-        });
-
-        if (signal && signal.aborted) {
-          throw (signal.reason || new Error('Aborted'));
-        }
-
-        await handle.agent.whenIdle();
-        handle.agent.followup(createUserMessage({
-          content: [{ type: 'text', text: task.prompt }],
-          source: { kind: 'plugin', plugin: 'dsh-cron', form: 'cron-execute' },
-        }));
+        let handle = null;
+        try {
+          handle = await this.ctx.agents.create({
+            sessionId: mintSessionId(),
+            meta: { cwd, ephemeral: true, internal: true },
+            agentOptions: provider && model ? { provider, model } : undefined,
+          });
 
-        // Await agent turn completion (#67)
-        if (typeof handle.agent.whenIdle === 'function') {
-          await handle.agent.whenIdle();
-        }
+          await raceAbort(handle.agent.whenIdle());
+          handle.agent.followup(createUserMessage({
+            content: [{ type: 'text', text: task.prompt }],
+            source: { kind: 'plugin', plugin: 'dsh-cron', form: 'cron-execute' },
+          }));
 
-        // Try extracting token usage from session history if available
-        let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-        try {
-          const sessionUsage = handle.agent.session?.usage || handle.agent.usage;
-          if (sessionUsage) {
-            usage = {
-              inputTokens: sessionUsage.inputTokens || sessionUsage.promptTokens || 0,
-              outputTokens: sessionUsage.outputTokens || sessionUsage.completionTokens || 0,
-              cacheReadTokens: sessionUsage.cacheReadTokens || sessionUsage.cachedTokens || 0,
-            };
+          // Await agent turn completion (#67), abortable on timeout/overlap (#88)
+          if (typeof handle.agent.whenIdle === 'function') {
+            await raceAbort(handle.agent.whenIdle());
           }
-        } catch {}
 
-        const costUsd = estimateTokenCost(model, usage);
+          // Try extracting token usage from session history if available
+          let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+          try {
+            const sessionUsage = handle.agent.session?.usage || handle.agent.usage;
+            if (sessionUsage) {
+              usage = {
+                inputTokens: sessionUsage.inputTokens || sessionUsage.promptTokens || 0,
+                outputTokens: sessionUsage.outputTokens || sessionUsage.completionTokens || 0,
+                cacheReadTokens: sessionUsage.cacheReadTokens || sessionUsage.cachedTokens || 0,
+              };
+            }
+          } catch {}
 
-        return {
-          output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
-          usage,
-          costUsd
-        };
+          const costUsd = estimateTokenCost(model, usage);
+
+          return {
+            output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
+            usage,
+            costUsd
+          };
+        } finally {
+          try {
+            if (handle && typeof handle.dispose === 'function') {
+              await handle.dispose();
+            } else if (handle && handle.agent && typeof handle.agent.destroy === 'function') {
+              await handle.agent.destroy();
+            }
+          } catch (disposeErr) {
+            console.warn('[dsh-cron] session dispose notice:', disposeErr.message);
+          }
+        }
       } catch (err) {
         console.error(`[dsh-cron] agent execution failed:`, err.message);
         throw err;
@@ -154,7 +185,7 @@ export class SessionRunner {
           title: `[Cron] ${task.title}`,
           ephemeral: task.delivery === 'isolated',
         });
-        
+
         if (session && typeof session.send === 'function') {
           const result = await session.send(task.prompt);
           const out = typeof result === 'string' ? result : JSON.stringify(result);

package/lib/scheduler.js

@@ -10,15 +10,15 @@ export function describeCron(cronPattern) {
   const parts = cronPattern.trim().split(/\s+/);
   if (parts.length === 5) {
     const [m, h, dom, mon, dow] = parts;
-    if (m.startsWith('*/')) return `Каждые ${m.slice(2)} минут`;
+    if (m.startsWith('*/')) return `Every ${m.slice(2)} minutes`;
     if (dow === '1-5' && dom === '*' && mon === '*') {
-      return `В будние дни в ${pad(h)}:${pad(m)}`;
+      return `Weekdays at ${pad(h)}:${pad(m)}`;
     }
     if (dow === '*' && dom === '*' && mon === '*') {
-      return `Каждый день в ${pad(h)}:${pad(m)}`;
+      return `Every day at ${pad(h)}:${pad(m)}`;
     }
     if (dow === '5' && dom === '*' && mon === '*') {
-      return `Пятницы в ${pad(h)}:${pad(m)}`;
+      return `Fridays at ${pad(h)}:${pad(m)}`;
     }
   }
   return cronPattern;
@@ -26,7 +26,7 @@ export function describeCron(cronPattern) {
 
 export function parseScheduleExpression(input) {
   const str = String(input || '').trim();
-  if (!str) throw new Error('Строка расписания не должна быть пустой');
+  if (!str) throw new Error('Schedule expression must not be empty');
 
   // 1. One-shot ISO 8601 timestamp or explicit "at: <ISO/datetime>"
   const atPrefixMatch = str.match(/^(?:at:\s*|at\s+)(.+)$/i);
@@ -38,34 +38,35 @@ export function parseScheduleExpression(input) {
       cronPattern: null,
       isOneShot: true,
       targetTimestamp: targetMs,
-      humanText: `Разово: ${parsedDate.toLocaleString('ru-RU')}`,
+      humanText: `One-shot at ${parsedDate.toISOString()}`,
       nextRun: targetMs
     };
   }
 
   // 2. Relative one-shot: "in 20m", "in 2h", "in 30s", "in 1d", "через 15 минут"
+  //    Russian keywords are accepted input aliases, not display strings.
   const inRelMatch = str.match(/^(?:in\s+|через\s+)(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?|мин|минут|часа?|часов)?$/i);
   if (inRelMatch) {
     const num = parseInt(inRelMatch[1], 10);
     const unit = (inRelMatch[2] || 'm').toLowerCase();
     let delayMs = num * 60 * 1000;
-    let unitText = `${num} мин`;
+    let unitText = `${num} min`;
     if (unit.startsWith('s')) {
       delayMs = num * 1000;
-      unitText = `${num} сек`;
+      unitText = `${num} sec`;
     } else if (unit.startsWith('h') || unit.startsWith('час')) {
       delayMs = num * 3600 * 1000;
-      unitText = `${num} ч`;
+      unitText = `${num} h`;
     } else if (unit.startsWith('d')) {
       delayMs = num * 86400 * 1000;
-      unitText = `${num} дн`;
+      unitText = `${num} d`;
     }
     const targetMs = Date.now() + delayMs;
     return {
       cronPattern: null,
       isOneShot: true,
       targetTimestamp: targetMs,
-      humanText: `Разово через ${unitText} (${new Date(targetMs).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`,
+      humanText: `One-shot in ${unitText} (at ${new Date(targetMs).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`,
       nextRun: targetMs
     };
   }
@@ -78,36 +79,36 @@ export function parseScheduleExpression(input) {
     if (unit.startsWith('m')) {
       return {
         cronPattern: `*/${num} * * * *`,
-        humanText: `Каждые ${num} минут`,
+        humanText: `Every ${num} minutes`,
         isInterval: true,
       };
     }
     if (unit.startsWith('h')) {
       return {
         cronPattern: `0 */${num} * * *`,
-        humanText: `Каждые ${num} часов`,
+        humanText: `Every ${num} hours`,
         isInterval: true,
       };
     }
     if (unit.startsWith('d')) {
       return {
         cronPattern: `0 0 */${num} * *`,
-        humanText: `Каждые ${num} дней`,
+        humanText: `Every ${num} days`,
         isInterval: true,
       };
     }
   }
 
-  // 4. Friendly recurring aliases
+  // 4. Friendly recurring aliases (English plus accepted Russian input aliases)
   const lower = str.toLowerCase();
   if (lower === 'daily' || lower === 'каждый день') {
-    return { cronPattern: '0 9 * * *', humanText: 'Каждый день в 09:00' };
+    return { cronPattern: '0 9 * * *', humanText: 'Every day at 09:00' };
   }
   if (lower === 'weekdays' || lower === 'в будние дни' || lower === 'по будням') {
-    return { cronPattern: '0 9 * * 1-5', humanText: 'В будние дни в 09:00' };
+    return { cronPattern: '0 9 * * 1-5', humanText: 'Weekdays at 09:00' };
   }
   if (lower === 'hourly' || lower === 'каждый час') {
-    return { cronPattern: '0 * * * *', humanText: 'Каждый час' };
+    return { cronPattern: '0 * * * *', humanText: 'Every hour' };
   }
 
   // 5. Standard 5-field cron expression
@@ -120,7 +121,7 @@ export function parseScheduleExpression(input) {
       nextRun: next ? next.getTime() : null,
     };
   } catch (err) {
-    throw new Error('Некорректное расписание cron: ' + err.message);
+    throw new Error('Invalid cron schedule: ' + err.message);
   }
 }
 
@@ -135,8 +136,23 @@ export class TaskScheduler {
 
   start() {
     const tasks = this.store.list();
+    const now = Date.now();
     for (const task of tasks) {
       if (task.status === 'active') {
+        // Detect missed execution if daemon was offline (threshold: > 5 minutes)
+        if (task.nextRunAt && (now - task.nextRunAt) > 5 * 60 * 1000) {
+          const missedAt = task.nextRunAt;
+          console.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()}`);
+          this.store.recordRun(task.id, {
+            at: missedAt,
+            status: 'missed',
+            durationMs: 0,
+            output: `Skipped: the service was offline or restarting at the scheduled time (${new Date(missedAt).toISOString()})`,
+            error: null,
+            usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+            costUsd: 0,
+          });
+        }
         this.scheduleTask(task);
       }
     }
@@ -159,7 +175,7 @@ export class TaskScheduler {
 
     for (const [, run] of this.running.entries()) {
       try {
-        run.controller.abort(new Error('Планировщик остановлен'));
+        run.controller.abort(new Error('Scheduler stopped'));
       } catch {}
     }
     this.running.clear();
@@ -230,7 +246,7 @@ export class TaskScheduler {
           at: Date.now(),
           status: 'skipped',
           durationMs: 0,
-          output: 'Запуск пропущен: предыдущий процесс ещё не завершился (overlapPolicy: skip)',
+          output: 'Skipped: the previous run is still in progress (overlapPolicy: skip)',
           error: null,
           usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
           costUsd: 0,
@@ -239,7 +255,7 @@ export class TaskScheduler {
       }
       if (overlapPolicy === 'replace') {
         console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
-        active.controller.abort(new Error('Прервано из-за политики overlap: replace'));
+        active.controller.abort(new Error('Aborted by overlap policy: replace'));
       }
       if (overlapPolicy === 'queue') {
         console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
@@ -324,14 +340,14 @@ export class TaskScheduler {
         if (shouldCreateKanbanCard(task, runInfo)) {
           const settings = typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
           const isErr = runInfo.status === 'error' || runInfo.status === 'timeout';
-          const cardTitle = isErr ? `[Сбой cron] ${task.title}` : `[Cron завершен] ${task.title}`;
+          const cardTitle = isErr ? `[Cron failure] ${task.title}` : `[Cron completed] ${task.title}`;
           const cardBody = [
-            `**Задача cron:** ${task.title} (\`${task.id}\`)`,
-            `**Расписание:** ${task.scheduleText || task.schedule}`,
-            `**Статус:** ${runInfo.status}`,
-            `**Время запуска:** ${new Date(runInfo.at).toLocaleString('ru-RU')}`,
-            runInfo.error ? `\n**Ошибка:**\n\`\`\`\n${runInfo.error}\n\`\`\`` : '',
-            runInfo.output ? `\n**Лог / Вывод:**\n\`\`\`\n${runInfo.output.slice(0, 1000)}\n\`\`\`` : '',
+            `**Cron task:** ${task.title} (\`${task.id}\`)`,
+            `**Schedule:** ${task.scheduleText || task.schedule}`,
+            `**Status:** ${runInfo.status}`,
+            `**Started at:** ${new Date(runInfo.at).toISOString()}`,
+            runInfo.error ? `\n**Error:**\n\`\`\`\n${runInfo.error}\n\`\`\`` : '',
+            runInfo.output ? `\n**Log / Output:**\n\`\`\`\n${runInfo.output.slice(0, 1000)}\n\`\`\`` : '',
           ].filter(Boolean).join('\n\n');
 
           createKanbanCard({
@@ -391,7 +407,7 @@ export class TaskScheduler {
     const running = this.running.get(taskId);
     if (running) {
       try {
-        running.controller.abort(new Error('Задача приостановлена'));
+        running.controller.abort(new Error('Task paused'));
       } catch {}
       this.running.delete(taskId);
     }
@@ -430,7 +446,7 @@ export class TaskScheduler {
     const running = this.running.get(taskId);
     if (running) {
       try {
-        running.controller.abort(new Error('Задача удалена'));
+        running.controller.abort(new Error('Task deleted'));
       } catch {}
       this.running.delete(taskId);
     }

package/lib/store.js

@@ -13,6 +13,7 @@ export class TaskStore {
     this.tasks = new Map();
     this.history = new Map();
     this.settings = {};
+    this._savePromise = Promise.resolve();
     this.init();
   }
 
@@ -57,7 +58,9 @@ export class TaskStore {
         history: Object.fromEntries(this.history.entries()),
         settings: this.settings || {},
       };
-      const tmp = this.filePath + '.tmp.' + Date.now();
+      // Unique tmp file per save call with process PID and random token to eliminate file collision
+      const rand = Math.random().toString(36).slice(2, 8);
+      const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
       fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
       fs.renameSync(tmp, this.filePath);
     } catch (err) {
@@ -147,7 +150,7 @@ export class TaskStore {
       ...prev,
       ...task,
       id,
-      title: task.title !== undefined ? task.title : (prev.title || 'Новая задача'),
+      title: task.title !== undefined ? task.title : (prev.title || 'New task'),
       schedule: task.schedule !== undefined ? task.schedule : (prev.schedule || '0 9 * * *'),
       scheduleText: task.scheduleText !== undefined ? task.scheduleText : (prev.scheduleText || task.schedule),
       prompt: task.prompt !== undefined ? task.prompt : (prev.prompt || ''),

package/lib/telegram.js

@@ -4,6 +4,8 @@ import os from 'node:os';
 
 /**
  * Extract simple key from YAML text without external dependencies.
+ * Best-effort fallback only: the primary source for cross-plugin defaults is
+ * the Harness settings/credentials service (#51, #93).
  */
 export function extractSettingFromYaml(text, section, key) {
   if (!text) return undefined;
@@ -37,17 +39,26 @@ export function extractFirstAllowedChatId(text) {
 
 /**
  * Read system DSH settings for fallback credentials.
+ * Fails soft with a logged warning so silent misconfiguration is visible (#93).
  */
 export function getDshDefaultTelegramCredentials() {
   try {
     const p = path.join(process.env.HOME || os.homedir(), '.dsh', 'settings.yaml');
     if (fs.existsSync(p)) {
-      const raw = fs.readFileSync(p, 'utf-8');
+      let raw;
+      try {
+        raw = fs.readFileSync(p, 'utf-8');
+      } catch (readErr) {
+        console.warn('[dsh-cron] default Telegram credentials: cannot read DSH settings.yaml:', readErr.message);
+        return { botToken: undefined, chatId: undefined };
+      }
       const botToken = extractSettingFromYaml(raw, 'dsh-messenger-gateway', 'botToken');
       const chatId = extractFirstAllowedChatId(raw);
       return { botToken, chatId };
     }
-  } catch {}
+  } catch (err) {
+    console.warn('[dsh-cron] default Telegram credentials lookup failed:', err.message);
+  }
   return { botToken: undefined, chatId: undefined };
 }
 
@@ -61,29 +72,30 @@ export function escapeMarkdown(str) {
 
 /**
  * Format task execution report for Telegram.
+ * Dynamic values are escaped so titles/schedules cannot break the markup (#93).
  */
 export function formatTaskTelegramMessage(task, runInfo) {
   const isSuccess = runInfo.status === 'success';
   const statusEmoji = isSuccess ? '✅' : '❌';
-  const statusText = isSuccess ? 'Успешно' : 'Ошибка';
+  const statusText = isSuccess ? 'Success' : 'Failed';
   const duration = runInfo.durationMs != null ? `${runInfo.durationMs} ms` : '—';
-  const title = task.title || 'Задача';
-  const schedule = task.scheduleText || task.schedule || '';
+  const title = escapeMarkdown(task.title || 'Task');
+  const schedule = escapeMarkdown(task.scheduleText || task.schedule || '');
 
   const lines = [
     `⏰ *DSH Cron:* ${title}`,
-    `*Статус:* ${statusEmoji} ${statusText}`,
-    schedule ? `*Расписание:* ${schedule}` : null,
-    `*Длительность:* ${duration}`,
+    `*Status:* ${statusEmoji} ${statusText}`,
+    schedule ? `*Schedule:* ${schedule}` : null,
+    `*Duration:* ${duration}`,
   ].filter(Boolean);
 
   if (runInfo.error) {
     const errText = String(runInfo.error).slice(0, 1500);
-    lines.push('', '*Ошибка:*', '```', errText, '```');
+    lines.push('', '*Error:*', '```', errText, '```');
   } else if (runInfo.output && isSuccess) {
     const outText = String(runInfo.output).trim().slice(0, 2000);
     if (outText) {
-      lines.push('', '*Вывод:*', '```', outText, '```');
+      lines.push('', '*Output:*', '```', outText, '```');
     }
   }
 
@@ -94,8 +106,8 @@ export function formatTaskTelegramMessage(task, runInfo) {
  * Send telegram message via Bot API.
  */
 export async function sendTelegramMessage({ botToken, chatId, text, parseMode = 'Markdown' }) {
-  if (!botToken) throw new Error('Telegram botToken не указан');
-  if (!chatId) throw new Error('Telegram chatId не указан');
+  if (!botToken) throw new Error('Telegram botToken is not configured');
+  if (!chatId) throw new Error('Telegram chatId is not configured');
 
   const url = `https://api.telegram.org/bot${botToken}/sendMessage`;
   const body = {
@@ -133,13 +145,15 @@ export async function sendTelegramMessage({ botToken, chatId, text, parseMode =
 
 /**
  * Determine if a notification should be sent for a given task and run result.
+ * "timeout" counts as a failure, matching the Kanban card policy (#89).
  */
 export function shouldNotifyTask(task, runInfo, globalSettings = {}) {
   const isEnabled = task.notifyTelegram ?? globalSettings.notifyTelegram ?? false;
   if (!isEnabled) return false;
 
+  const failed = runInfo.status === 'error' || runInfo.status === 'timeout';
   const onlyOnFail = task.onlyOnFailure ?? globalSettings.onlyOnFailure ?? false;
-  if (onlyOnFail && runInfo.status !== 'error') {
+  if (onlyOnFail && !failed) {
     return false;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.1.23",
+  "version": "0.2.0",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",