@goodandready/dsh-cron 0.1.15 → 0.1.17

package/README.md

@@ -116,6 +116,15 @@ Direct integration with the Telegram Bot API delivers execution reports and erro
 * **Markdown Formatting**: Messages are formatted with status badges (✅ / ❌), execution duration in milliseconds, schedule descriptions, and monospace code blocks.
 * **Test Dispatch Button**: Verify Telegram connectivity on the spot before scheduling critical production jobs.
 
+### 7. Overlap Policies & Execution Timeout Control (Issues #11, #17)
+Prevent rogue processes from consuming server resources or stacking concurrent duplicate executions:
+
+* **Execution Timeout (`timeoutSeconds`)**: Automatically cancels agent sessions or kills shell subprocesses when the configured run time limit is reached (default: 1800s / 30m). Prevents hung tasks and records a descriptive timeout failure in run logs.
+* **Overlap Policy (`overlapPolicy`)**: Controls scheduler behavior when a scheduled tick fires while the previous execution is still running:
+  * **`skip`** (default): Drops the overlapping run and records a `skipped` status entry in the run history without spamming.
+  * **`queue`**: Queues the next execution and starts it automatically as soon as the active job completes.
+  * **`replace`**: Aborts the stuck/active run immediately via `AbortController` and launches the fresh execution.
+
 ### 5. Schedule Expression Syntax
 Powered by `croner`, supporting both standard 5-part/6-part cron expressions and user-friendly interval aliases:
 
@@ -178,3 +187,8 @@ npm test
 ## 📄 License
 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+
+### Kanban & Token Cost Integration (v0.1.17)
+- **Automatic Kanban Card Creation**: Automatically creates task/bug cards in `dsh-kanban` on task failure (`on_failure`) or every run (`always`).
+- **Token & Execution Cost Meter**: Tracks token consumption (input, output, cache tokens) for LLM executions and estimates USD expenses using current model pricing.
+- **Aggregated Analytics Bar**: Live dashboard displaying active jobs count, total executions, total token consumption, and aggregate estimated dollar spend.

package/docs/README.ru.md

@@ -170,3 +170,8 @@ npm test
 ## 📄 Лицензия
 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+
+### Интеграция с Kanban и счетчик стоимости токенов (v0.1.17)
+- **Автосоздание карточек в Kanban**: Автоматическое заведение задач в бэклог `dsh-kanban` при обнаружении сбоев/ошибок (`on_failure`) или при каждом завершении (`always`).
+- **Трекинг токенов и расчет расходов (USD)**: Подсчет потребления токенов (input, output, cacheRead) для каждой задачи и запуск с расчетом примерной стоимости в долларах США.
+- **Сводная панель статистики**: Отображение общего числа запусков, активных задач, суммарного расхода токенов и совокупных затрат прямо в заголовке планировщика.

package/lib/client.js

@@ -136,9 +136,17 @@ const React = window.React || require('react');
       .dsh-cron-history-status { font-weight: 600; font-size: 11.5px; text-transform: uppercase; padding: 2px 6px; border-radius: 4px; }
       .dsh-cron-history-status[data-status="success"] { background: rgba(16, 185, 129, 0.15); color: #10b981; }
       .dsh-cron-history-status[data-status="error"] { background: rgba(239, 68, 68, 0.15); color: #ef4444; }
+      .dsh-cron-history-status[data-status="skipped"] { background: rgba(234, 179, 8, 0.15); color: #eab308; }
       .dsh-cron-history-time { color: #777; font-size: 12px; }
       .dsh-cron-history-output { background: #0c0c0c; border: 1px solid #222; border-radius: 6px; padding: 8px 10px; font-family: monospace; font-size: 12px; color: #bbb; max-height: 140px; overflow-y: auto; white-space: pre-wrap; word-break: break-all; margin-top: 6px; }
       .dsh-cron-history-empty { text-align: center; padding: 36px 0; color: #666; font-size: 13.5px; }
+
+      .dsh-cron-stats-bar { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; margin-bottom: 18px; }
+      .dsh-cron-stat-card { background: rgba(255, 255, 255, 0.02); border: 1px solid #222; border-radius: 8px; padding: 10px 14px; }
+      .dsh-cron-stat-val { font-size: 16px; font-weight: 600; color: #fff; }
+      .dsh-cron-stat-lbl { font-size: 11.5px; color: #777; margin-top: 2px; }
+      .dsh-cron-cost-tag { font-size: 11px; padding: 2px 6px; border-radius: 4px; background: rgba(16, 185, 129, 0.12); color: #10b981; font-weight: 500; }
+      .dsh-cron-tokens-tag { font-size: 11px; padding: 2px 6px; border-radius: 4px; background: rgba(59, 130, 246, 0.12); color: #60a5fa; }
       .dsh-cron-checkbox-row { display: flex; align-items: center; gap: 8px; font-size: 13px; color: #ccc; cursor: pointer; user-select: none; }
       .dsh-cron-checkbox-row input { width: 15px; height: 15px; margin: 0; cursor: pointer; accent-color: #ededed; }
       .dsh-cron-hint { font-size: 12px; color: #888; margin-top: 4px; }
@@ -248,6 +256,10 @@ const React = window.React || require('react');
       const [historyLoading, setHistoryLoading] = React.useState(false);
       const [formNotifyTelegram, setFormNotifyTelegram] = React.useState(false);
       const [formOnlyOnFailure, setFormOnlyOnFailure] = React.useState(false);
+      const [formTimeoutSeconds, setFormTimeoutSeconds] = React.useState(1800);
+      const [formOverlapPolicy, setFormOverlapPolicy] = React.useState('skip');
+      const [formKanbanMode, setFormKanbanMode] = React.useState('none');
+      const [stats, setStats] = React.useState(null);
 
       // Settings modal state
       const [settingsModalOpen, setSettingsModalOpen] = React.useState(false);
@@ -288,6 +300,7 @@ const React = window.React || require('react');
           if (data && data.ok) {
             setTasks(data.tasks || []);
             setRecs(data.recommendations || []);
+            if (data.stats) setStats(data.stats);
           }
         } catch (err) {}
       };
@@ -401,6 +414,9 @@ const React = window.React || require('react');
         setFormDelivery('isolated');
         setFormNotifyTelegram(false);
         setFormOnlyOnFailure(false);
+        setFormTimeoutSeconds(1800);
+        setFormOverlapPolicy('skip');
+        setFormKanbanMode('none');
         if (preset) {
           setFormTitle(preset.title || '');
           setFormSchedule(preset.schedule || '');
@@ -448,6 +464,9 @@ const React = window.React || require('react');
         setFormDelivery(task.delivery || 'isolated');
         setFormNotifyTelegram(Boolean(task.notifyTelegram));
         setFormOnlyOnFailure(Boolean(task.onlyOnFailure));
+        setFormTimeoutSeconds(task.timeoutSeconds !== undefined ? task.timeoutSeconds : 1800);
+        setFormOverlapPolicy(task.overlapPolicy || 'skip');
+        setFormKanbanMode(task.kanbanMode || 'none');
         if (task.provider) loadModels(task.provider);
         else if (defaultModelInfo?.provider) loadModels(defaultModelInfo.provider);
         loadTaskHistory(task.id);
@@ -473,6 +492,11 @@ const React = window.React || require('react');
             delivery: formDelivery || 'isolated',
             provider: formType === 'script' ? undefined : (formProvider || undefined),
             model: formType === 'script' ? undefined : (formModel || undefined),
+            notifyTelegram: formNotifyTelegram,
+            onlyOnFailure: formOnlyOnFailure,
+            timeoutSeconds: Number(formTimeoutSeconds) || 1800,
+            overlapPolicy: formOverlapPolicy,
+            kanbanMode: formKanbanMode,
           };
           const res = await fetch('/dsh-cron/tasks', {
             method: 'POST',
@@ -575,6 +599,24 @@ const React = window.React || require('react');
               onChange: (e) => setQuery(e.target.value)
             })
           ),
+          stats && React.createElement('div', { className: 'dsh-cron-stats-bar' },
+            React.createElement('div', { className: 'dsh-cron-stat-card' },
+              React.createElement('div', { className: 'dsh-cron-stat-val' }, stats.activeTasks || 0),
+              React.createElement('div', { className: 'dsh-cron-stat-lbl' }, 'Активных задач')
+            ),
+            React.createElement('div', { className: 'dsh-cron-stat-card' },
+              React.createElement('div', { className: 'dsh-cron-stat-val' }, stats.totalRuns || 0),
+              React.createElement('div', { className: 'dsh-cron-stat-lbl' }, 'Всего запусков')
+            ),
+            React.createElement('div', { className: 'dsh-cron-stat-card' },
+              React.createElement('div', { className: 'dsh-cron-stat-val' }, (stats.totalTokens || 0).toLocaleString()),
+              React.createElement('div', { className: 'dsh-cron-stat-lbl' }, 'Токенов израсходовано')
+            ),
+            React.createElement('div', { className: 'dsh-cron-stat-card' },
+              React.createElement('div', { className: 'dsh-cron-stat-val', style: { color: '#10b981' } }, '$' + (stats.totalCostUsd || 0).toFixed(4)),
+              React.createElement('div', { className: 'dsh-cron-stat-lbl' }, 'Оценочная стоимость')
+            )
+          ),
           React.createElement('div', { className: 'dsh-cron-tabs' },
             ['all', 'active', 'paused', 'completed'].map((t) =>
               React.createElement('button', {
@@ -611,7 +653,9 @@ const React = window.React || require('react');
                             color: task.type === 'script' ? '#60a5fa' : '#34d399'
                           }
                         }, task.type === 'script' ? 'Shell' : 'LLM'),
-                        task.model ? React.createElement('span', { className: 'dsh-cron-task-model-tag' }, task.model.split('/').pop()) : null
+                        task.model ? React.createElement('span', { className: 'dsh-cron-task-model-tag' }, task.model.split('/').pop()) : null,
+                        task.totalCostUsd > 0 ? React.createElement('span', { className: 'dsh-cron-cost-tag' }, '$' + task.totalCostUsd.toFixed(4)) : null,
+                        task.totalTokens > 0 ? React.createElement('span', { className: 'dsh-cron-tokens-tag' }, (task.totalTokens > 1000 ? Math.round(task.totalTokens / 1000) + 'k' : task.totalTokens) + ' tok') : null
                       ),
                       React.createElement('div', { className: 'dsh-cron-task-sched' },
                         task.scheduleText || task.schedule,
@@ -718,10 +762,14 @@ const React = window.React || require('react');
                       React.createElement('span', {
                         className: 'dsh-cron-history-status',
                         'data-status': run.status
-                      }, run.status === 'success' ? 'Успешно' : 'Ошибка'),
+                      }, run.status === 'success' ? 'Успешно' : run.status === 'skipped' ? 'Пропущен' : 'Ошибка'),
                       React.createElement('span', { className: 'dsh-cron-history-time' }, run.at ? new Date(run.at).toLocaleString() : '')
                     ),
-                    React.createElement('span', { style: { color: '#888', fontSize: '11.5px' } }, (run.durationMs || 0) + ' ms')
+                    React.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '8px' } },
+                      run.costUsd > 0 && React.createElement('span', { className: 'dsh-cron-cost-tag' }, '$' + run.costUsd.toFixed(5)),
+                      run.usage && (run.usage.inputTokens > 0 || run.usage.outputTokens > 0) && React.createElement('span', { className: 'dsh-cron-tokens-tag' }, (run.usage.inputTokens + run.usage.outputTokens) + ' tok'),
+                      React.createElement('span', { style: { color: '#888', fontSize: '11.5px' } }, (run.durationMs || 0) + ' ms')
+                    )
                   ),
                   run.output && React.createElement('div', { className: 'dsh-cron-history-output' }, run.output),
                   run.error && React.createElement('div', { className: 'dsh-cron-history-output', style: { color: '#ef4444', borderColor: '#552222' } }, run.error)
@@ -772,6 +820,40 @@ const React = window.React || require('react');
                   })
                 )
               ),
+              React.createElement('div', { className: 'dsh-cron-form-row', style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' } },
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, 'Таймаут выполнения (секунды)'),
+                  React.createElement('input', {
+                    type: 'number',
+                    min: 1,
+                    value: formTimeoutSeconds,
+                    placeholder: '1800',
+                    onChange: (e) => setFormTimeoutSeconds(e.target.value)
+                  })
+                ),
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, 'Политика наложения (Overlap)'),
+                  React.createElement('select', {
+                    value: formOverlapPolicy,
+                    onChange: (e) => setFormOverlapPolicy(e.target.value)
+                  },
+                    React.createElement('option', { value: 'skip' }, 'Пропустить новый запуск (skip)'),
+                    React.createElement('option', { value: 'queue' }, 'Встать в очередь (queue)'),
+                    React.createElement('option', { value: 'replace' }, 'Отменить текущий и перезапустить (replace)')
+                  )
+                )
+              ),
+              React.createElement('div', { className: 'dsh-cron-form-group' },
+                React.createElement('label', null, 'Создание карточки в Kanban (dsh-kanban)'),
+                React.createElement('select', {
+                  value: formKanbanMode,
+                  onChange: (e) => setFormKanbanMode(e.target.value)
+                },
+                  React.createElement('option', { value: 'none' }, 'Не создавать карточки (отключено)'),
+                  React.createElement('option', { value: 'on_failure' }, 'Создавать тикет при ошибке/сбое (в Backlog)'),
+                  React.createElement('option', { value: 'always' }, 'Создавать карточку при каждом завершении (Done / Backlog)')
+                )
+              ),
               formType !== 'script' && React.createElement('div', { className: 'dsh-cron-form-row', style: { display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' } },
                 React.createElement('div', { className: 'dsh-cron-form-group' },
                   React.createElement('label', null, 'Провайдер LLM'),

package/lib/index.js

@@ -4,6 +4,7 @@ import { SessionRunner } from './runner.js';
 import { getModelsHandler } from './models-handler.js';
 import { chatStartHandler } from './chat-start.js';
 import { sendTelegramMessage } from './telegram.js';
+import { createKanbanCard } from './integrations.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { randomUUID } from 'node:crypto';
 
@@ -33,7 +34,7 @@ function sendJson(res, statusCode, data) {
 export function apply(ctx, config) {
   const store = new TaskStore();
   const runner = new SessionRunner(ctx);
-  const scheduler = new TaskScheduler(store, (task) => runner.execute(task));
+  const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts));
 
   scheduler.start();
 
@@ -85,7 +86,8 @@ export function apply(ctx, config) {
           const status = url.searchParams.get('status') || 'all';
           const query = url.searchParams.get('query') || '';
           const list = store.list({ status, query });
-          sendJson(res, 200, { ok: true, tasks: list, recommendations });
+          const stats = store.getAggregatedStats();
+          sendJson(res, 200, { ok: true, tasks: list, recommendations, stats });
           return;
         }
 
@@ -109,6 +111,9 @@ export function apply(ctx, config) {
             model: body.model || undefined,
             notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : false,
             onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : false,
+            timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : 1800,
+            overlapPolicy: body.overlapPolicy || 'skip',
+            kanbanMode: body.kanbanMode || 'none',
           });
           scheduler.scheduleTask(task);
           sendJson(res, 200, { ok: true, task });
@@ -174,276 +179,282 @@ export function apply(ctx, config) {
           return;
         }
         const body = await parseJsonBody(req);
-        const currentSettings = store.getSettings();
-        const botToken = (body.botToken || currentSettings.botToken || '').trim();
-        const chatId = (body.chatId || currentSettings.chatId || '').trim();
+        const settings = store.getSettings();
+        const botToken = body.botToken || settings.botToken;
+        const chatId = body.chatId || settings.chatId;
 
-        if (!botToken) {
-          sendJson(res, 400, { ok: false, error: 'Укажите Telegram Bot Token' });
+        if (!botToken || !chatId) {
+          sendJson(res, 400, { ok: false, error: 'Не указан botToken или chatId' });
           return;
         }
-        if (!chatId) {
-          sendJson(res, 400, { ok: false, error: 'Укажите Telegram Chat ID' });
+
+        const text = `🔔 *Тестовое оповещение dsh-cron*\n\nСвязь между DSH Cron и Telegram успешно настроена! Проверка времени: \`${new Date().toISOString()}\``;
+        await sendTelegramMessage({ botToken, chatId, text });
+        sendJson(res, 200, { ok: true, message: 'Тестовое сообщение успешно отправлено' });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /telegram/test');
+
+  // POST /dsh-cron/kanban/test
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/kanban/test',
+    handler: async (req, res) => {
+      try {
+        if (req.method !== 'POST') {
+          sendJson(res, 405, { ok: false, error: 'Method not allowed' });
           return;
         }
+        const body = await parseJsonBody(req);
+        const settings = store.getSettings();
+        const kanbanBaseUrl = body.kanbanBaseUrl || settings.kanbanBaseUrl || 'http://127.0.0.1:3000';
 
-        await sendTelegramMessage({
-          botToken,
-          chatId,
-          text: '⏰ *DSH Cron — Проверка связи*\nТестовое уведомление успешно доставлено! Планировщик готов к отправке отчётов.',
-          parseMode: 'Markdown'
+        const result = await createKanbanCard({
+          title: `[Тест] Проверка связи DSH Cron -> Kanban`,
+          body: `Тестовая карточка создана автоматически из модуля \`dsh-cron\` в ${new Date().toLocaleString('ru-RU')}.`,
+          board: 'main',
+          column: 'backlog',
+          labels: ['cron', 'test'],
+          kanbanBaseUrl
         });
 
-        sendJson(res, 200, { ok: true, message: 'Сообщение успешно отправлено в Telegram' });
+        if (result.success) {
+          sendJson(res, 200, { ok: true, task: result.task });
+        } else {
+          sendJson(res, 500, { ok: false, error: result.error });
+        }
       } catch (err) {
         sendJson(res, 500, { ok: false, error: err.message });
       }
     }
-  }), 'dsh-cron: /telegram/test');
+  }), 'dsh-cron: /kanban/test');
 
-  // Prefix routes for actions (/dsh-cron/action/*)
+  // PATCH & DELETE /dsh-cron/tasks/:id
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix',
-    path: '/dsh-cron/action',
+    path: '/dsh-cron/tasks/',
     handler: async (req, res) => {
       try {
         const url = new URL(req.url, 'http://127.0.0.1');
-        const pathname = url.pathname;
+        const parts = url.pathname.split('/').filter(Boolean);
+        const id = parts[2];
+        const action = parts[3];
 
-        const toggleMatch = pathname.match(/^\/dsh-cron\/action\/([^/]+)\/toggle$/);
-        if (req.method === 'POST' && toggleMatch) {
-          const taskId = toggleMatch[1];
-          const task = store.get(taskId);
+        if (!id) {
+          sendJson(res, 400, { ok: false, error: 'ID задачи не указан' });
+          return;
+        }
+
+        if (req.method === 'GET' && action === 'history') {
+          const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+          const history = store.getHistory(id, limit);
+          sendJson(res, 200, { ok: true, history });
+          return;
+        }
+
+        if (req.method === 'POST' && action === 'run') {
+          await scheduler.triggerManualRun(id);
+          const task = store.get(id);
+          sendJson(res, 200, { ok: true, task });
+          return;
+        }
+
+        if (req.method === 'POST' && action === 'pause') {
+          const task = scheduler.pauseTask(id);
           if (!task) {
-            sendJson(res, 404, { ok: false, error: 'Task not found' });
+            sendJson(res, 404, { ok: false, error: 'Задача не найдена' });
             return;
           }
-          const updated = task.status === 'active'
-            ? scheduler.pauseTask(taskId)
-            : scheduler.resumeTask(taskId);
-          sendJson(res, 200, { ok: true, task: updated });
+          sendJson(res, 200, { ok: true, task });
           return;
         }
 
-        const runMatch = pathname.match(/^\/dsh-cron\/action\/([^/]+)\/run$/);
-        if (req.method === 'POST' && runMatch) {
-          const taskId = runMatch[1];
-          scheduler.runTask(taskId);
-          sendJson(res, 200, { ok: true });
+        if (req.method === 'POST' && action === 'resume') {
+          const task = scheduler.resumeTask(id);
+          if (!task) {
+            sendJson(res, 404, { ok: false, error: 'Задача не найдена' });
+            return;
+          }
+          sendJson(res, 200, { ok: true, task });
           return;
         }
 
-        const deleteMatch = pathname.match(/^\/dsh-cron\/action\/([^/]+)\/delete$/);
-        if (req.method === 'POST' && deleteMatch) {
-          const taskId = deleteMatch[1];
-          const ok = scheduler.removeTask(taskId);
-          sendJson(res, 200, { ok });
+        if (req.method === 'PATCH') {
+          const body = await parseJsonBody(req);
+          const current = store.get(id);
+          if (!current) {
+            sendJson(res, 404, { ok: false, error: 'Задача не найдена' });
+            return;
+          }
+          const task = store.set({ ...current, ...body, id });
+          if (task.status === 'active') {
+            scheduler.scheduleTask(task);
+          }
+          sendJson(res, 200, { ok: true, task });
           return;
         }
 
-        const historyMatch = pathname.match(/^\/dsh-cron\/action\/([^/]+)\/history$/);
-        if (req.method === 'GET' && historyMatch) {
-          const taskId = historyMatch[1];
-          const history = store.getHistory(taskId, 30);
-          sendJson(res, 200, { ok: true, history });
+        if (req.method === 'DELETE') {
+          const current = store.get(id);
+          if (current) {
+            scheduler.pauseTask(id);
+            store.delete(id);
+          }
+          sendJson(res, 200, { ok: true });
           return;
         }
 
-        sendJson(res, 404, { ok: false, error: 'Action not found' });
+        sendJson(res, 405, { ok: false, error: 'Method not allowed' });
       } catch (err) {
         sendJson(res, 500, { ok: false, error: err.message });
       }
     }
-  }), 'dsh-cron: /action');
-
-  // 2. AI Tools for Model Interaction
-  if (ctx.tools && typeof ctx.tools.register === 'function') {
-    ctx.tools.register(defineTool({
-      name: 'cron_schedule_task',
-      description: 'Запланировать автоматическую задачу по расписанию (cron).',
-      parameters: {
-        title: { type: 'string', required: true, description: 'Краткое название задачи' },
-        schedule: { type: 'string', required: true, description: 'Выражение cron или интервал (every 30m, 0 9 * * 1-5, daily)' },
-        prompt: { type: 'string', required: true, description: 'Инструкция для агента при запуске' },
-        delivery: { type: 'string', description: 'Режим запуска: current или isolated' },
-        type: { type: 'string', description: 'Тип задачи: "llm" (агент с LLM) или "script" (прямой запуск shell без LLM)' },
-        provider: { type: 'string', description: 'ID провайдера LLM для выполнения задачи' },
-        model: { type: 'string', description: 'ID модели LLM для выполнения задачи' },
+  }), 'dsh-cron: /tasks/:id');
+
+  // 2. Tools
+  ctx.tools.register(defineTool({
+    name: 'cron_create_task',
+    description: 'Создать новую запланированную задачу cron (запуск по расписанию)',
+    parameters: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Краткое название задачи' },
+        schedule: { type: 'string', description: 'Расписание: cron-выражение (например, "0 9 * * *") или интервал ("every 2h", "каждый день в 15:00")' },
+        prompt: { type: 'string', description: 'Промпт/инструкция для агента при запуске' },
+        type: { type: 'string', enum: ['prompt', 'script'], description: 'Тип задачи' },
+        delivery: { type: 'string', enum: ['current', 'isolated'], description: 'Режим запуска: current (в текущем чате) или isolated (изолированная сессия)' },
+        provider: { type: 'string', description: 'Провайдер модели (опционально)' },
+        model: { type: 'string', description: 'Модель (опционально)' },
         notifyTelegram: { type: 'boolean', description: 'Отправлять отчет в Telegram' },
-        onlyOnFailure: { type: 'boolean', description: 'Отправлять в Telegram только при ошибках' }
+        onlyOnFailure: { type: 'boolean', description: 'Отправлять отчет только при сбоях' },
+        timeoutSeconds: { type: 'number', description: 'Лимит времени выполнения в секундах' },
+        overlapPolicy: { type: 'string', enum: ['skip', 'queue', 'replace'], description: 'Политика перекрытия' },
+        kanbanMode: { type: 'string', enum: ['none', 'on_failure', 'always'], description: 'Создавать карточку в Kanban' },
       },
-      output: {
-        schema: {
-          type: 'object',
-          additionalProperties: false,
-          properties: {
-            success: { type: 'boolean' },
-            message: { type: 'string' }
-          }
-        },
-        render(_args, value) {
-          return [{ type: 'text', text: value.message }];
-        }
-      },
-      execute: async ({ title, schedule, prompt, delivery, provider, model, type, notifyTelegram, onlyOnFailure }) => {
-        try {
-          const parsed = parseScheduleExpression(schedule);
-          const task = store.set({
-            title,
-            schedule: parsed.cronPattern,
-            scheduleText: parsed.humanText,
-            prompt,
-            type: type || (provider || model ? 'llm' : 'llm'),
-            delivery: delivery || 'isolated',
-            provider: provider || undefined,
-            model: model || undefined,
-            notifyTelegram: Boolean(notifyTelegram),
-            onlyOnFailure: Boolean(onlyOnFailure),
-            status: 'active'
-          });
-          scheduler.scheduleTask(task);
-          return {
-            success: true,
-            message: `Задача "${task.title}" запланирована (${parsed.humanText}). Следующий запуск: ${task.nextRunAt ? new Date(task.nextRunAt).toLocaleString() : 'скоро'}.`
-          };
-        } catch (err) {
-          return { success: false, message: 'Ошибка планирования: ' + err.message };
-        }
-      }
-    }));
+      required: ['title', 'schedule', 'prompt']
+    },
+    execute: async (args) => {
+      const parsed = parseScheduleExpression(args.schedule);
+      const task = store.set({
+        title: args.title,
+        schedule: parsed.cronPattern,
+        scheduleText: parsed.humanText,
+        prompt: args.prompt,
+        type: args.type || 'prompt',
+        delivery: args.delivery || 'isolated',
+        status: 'active',
+        provider: args.provider,
+        model: args.model,
+        notifyTelegram: Boolean(args.notifyTelegram),
+        onlyOnFailure: Boolean(args.onlyOnFailure),
+        timeoutSeconds: Number(args.timeoutSeconds) || 1800,
+        overlapPolicy: args.overlapPolicy || 'skip',
+        kanbanMode: args.kanbanMode || 'none',
+      });
+      scheduler.scheduleTask(task);
+      return {
+        success: true,
+        message: `Задача "${task.title}" успешно запланирована (${task.scheduleText})`,
+        task
+      };
+    }
+  }));
 
-    ctx.tools.register(defineTool({
-      name: 'cron_list_tasks',
-      description: 'Получить список текущих запланированных cron-задач.',
-      parameters: {
-        status: { type: 'string', description: 'Фильтр статуса: all, active, paused, completed' }
-      },
-      output: {
-        schema: {
-          type: 'object',
-          additionalProperties: false,
-          properties: {
-            total: { type: 'integer' },
-            text: { type: 'string' }
-          }
-        },
-        render(_args, value) {
-          return [{ type: 'text', text: value.text }];
-        }
-      },
-      execute: async ({ status }) => {
-        const tasks = store.list({ status: status || 'all' });
-        const text = tasks.length === 0
-          ? 'Нет запланированных задач.'
-          : tasks.map(t => `• ${t.title} [${t.status}] — ${t.scheduleText}`).join('\n');
-        return {
-          total: tasks.length,
-          text
-        };
+  ctx.tools.register(defineTool({
+    name: 'cron_list_tasks',
+    description: 'Получить список всех запланированных задач cron',
+    parameters: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', enum: ['all', 'active', 'paused'], description: 'Фильтр по статусу' }
       }
-    }));
-
-    ctx.tools.register(defineTool({
-      name: 'cron_toggle_task',
-      description: 'Приостановить, возобновить или запустить cron-задачу.',
-      parameters: {
-        taskId: { type: 'string', required: true, description: 'Идентификатор задачи' },
-        action: { type: 'string', required: true, description: 'pause, resume, run_now или delete' }
+    },
+    execute: async (args) => {
+      const tasks = store.list({ status: args.status || 'all' });
+      return {
+        count: tasks.length,
+        tasks: tasks.map(t => ({
+          id: t.id,
+          title: t.title,
+          schedule: t.scheduleText || t.schedule,
+          status: t.status,
+          nextRunAt: t.nextRunAt ? new Date(t.nextRunAt).toISOString() : null,
+          lastStatus: t.lastStatus,
+          totalTokens: t.totalTokens || 0,
+          totalCostUsd: t.totalCostUsd || 0,
+        }))
+      };
+    }
+  }));
+
+  ctx.tools.register(defineTool({
+    name: 'cron_pause_task',
+    description: 'Приостановить выполнение задачи по её ID',
+    parameters: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Идентификатор задачи' }
       },
-      output: {
-        schema: {
-          type: 'object',
-          additionalProperties: false,
-          properties: {
-            success: { type: 'boolean' },
-            message: { type: 'string' }
-          }
-        },
-        render(_args, value) {
-          return [{ type: 'text', text: value.message }];
-        }
+      required: ['id']
+    },
+    execute: async (args) => {
+      const task = scheduler.pauseTask(args.id);
+      if (!task) return { success: false, message: 'Задача не найдена' };
+      return { success: true, message: `Задача "${task.title}" приостановлена` };
+    }
+  }));
+
+  ctx.tools.register(defineTool({
+    name: 'cron_resume_task',
+    description: 'Возобновить выполнение приостановленной задачи',
+    parameters: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Идентификатор задачи' }
       },
-      execute: async ({ taskId, action }) => {
-        if (action === 'pause') {
-          const t = scheduler.pauseTask(taskId);
-          return { success: !!t, message: t ? `Задача "${t.title}" приостановлена` : 'Задача не найдена' };
-        }
-        if (action === 'resume') {
-          const t = scheduler.resumeTask(taskId);
-          return { success: !!t, message: t ? `Задача "${t.title}" возобновлена` : 'Задача не найдена' };
-        }
-        if (action === 'run_now') {
-          scheduler.runTask(taskId);
-          return { success: true, message: `Задача ${taskId} запущена` };
-        }
-        if (action === 'delete') {
-          const ok = scheduler.removeTask(taskId);
-          return { success: ok, message: ok ? 'Задача удалена' : 'Задача не найдена' };
-        }
-        return { success: false, message: 'Неизвестное действие' };
-      }
-    }));
-  }
-
-  // 3. /cron Slash Command Handler
-  ctx.on('user/message', async (event) => {
-    const text = (event && event.text || event && event.message && event.message.content || '').trim();
-    if (!text.startsWith('/cron')) return;
-
-    const parts = text.slice(5).trim().split(/\s+/);
-    const subCmd = parts[0] ? parts[0].toLowerCase() : '';
-
-    if (!subCmd || subCmd === 'help') {
-      const helpMsg = `**⏰ DSH Cron — Управление запланированными задачами**\n\n` +
-        `• \`/cron list\` — показать активные задачи\n` +
-        `• \`/cron add <расписание> <промпт>\` — создать новую задачу\n` +
-        `• \`/cron pause <id>\` — приостановить задачу\n` +
-        `• \`/cron resume <id>\` — возобновить задачу\n` +
-        `• \`/cron run <id>\` — запустить сейчас\n\n` +
-        `_Открыть графический экран управления можно в боковой панели._`;
-      
-      if (typeof event.reply === 'function') {
-        event.reply(helpMsg);
-      }
-      return;
+      required: ['id']
+    },
+    execute: async (args) => {
+      const task = scheduler.resumeTask(args.id);
+      if (!task) return { success: false, message: 'Задача не найдена' };
+      return { success: true, message: `Задача "${task.title}" возобновлена (${task.scheduleText})` };
     }
+  }));
 
-    if (subCmd === 'list') {
-      const list = store.list();
-      if (!list.length) {
-        if (typeof event.reply === 'function') event.reply('Нет запланированных задач. Создайте через `/cron add` или в UI.');
-        return;
-      }
-      const lines = list.map(t => `• **${t.title}** (${t.id}) — ${t.scheduleText} [${t.status}]`);
-      if (typeof event.reply === 'function') event.reply(`**Запланированные задачи (${list.length}):**\n\n` + lines.join('\n'));
-      return;
+  ctx.tools.register(defineTool({
+    name: 'cron_delete_task',
+    description: 'Удалить задачу по её ID',
+    parameters: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Идентификатор задачи' }
+      },
+      required: ['id']
+    },
+    execute: async (args) => {
+      scheduler.pauseTask(args.id);
+      const ok = store.delete(args.id);
+      return { success: ok, message: ok ? 'Задача удалена' : 'Задача не найдена' };
     }
+  }));
 
-    if (subCmd === 'add') {
-      const rest = text.slice(text.indexOf('add') + 3).trim();
-      const match = rest.match(/^"([^"]+)"\s+(.+)$/) || rest.match(/^(\S+)\s+(.+)$/);
-      if (!match) {
-        if (typeof event.reply === 'function') event.reply('Формат: `/cron add "<расписание>" <промпт>`');
-        return;
-      }
-      const [, scheduleStr, promptStr] = match;
-      try {
-        const parsed = parseScheduleExpression(scheduleStr);
-        const task = store.set({
-          title: promptStr.slice(0, 40),
-          schedule: parsed.cronPattern,
-          scheduleText: parsed.humanText,
-          prompt: promptStr,
-          status: 'active'
-        });
-        scheduler.scheduleTask(task);
-        if (typeof event.reply === 'function') {
-          event.reply(`✅ Создана задача: **${task.title}** (${parsed.humanText})`);
-        }
-      } catch (err) {
-        if (typeof event.reply === 'function') event.reply(`❌ Ошибка: ${err.message}`);
-      }
-      return;
+  ctx.tools.register(defineTool({
+    name: 'cron_run_task',
+    description: 'Запустить задачу немедленно вне очереди',
+    parameters: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Идентификатор задачи' }
+      },
+      required: ['id']
+    },
+    execute: async (args) => {
+      const task = store.get(args.id);
+      if (!task) return { success: false, message: 'Задача не найдена' };
+      scheduler.triggerManualRun(args.id);
+      return { success: true, message: `Запущен внеплановый старт задачи "${task.title}"` };
     }
-  });
+  }));
 }

package/lib/integrations.js

@@ -0,0 +1,95 @@
+/**
+ * Integration module for dsh-kanban and LLM token cost estimation.
+ */
+
+/**
+ * Model pricing per 1M tokens in USD: [promptPrice, completionPrice, cachePrice]
+ */
+export const MODEL_PRICING = {
+  'deepseek-chat': { prompt: 0.14, completion: 0.28, cacheRead: 0.014 },
+  'deepseek-reasoner': { prompt: 0.55, completion: 2.19, cacheRead: 0.14 },
+  'deepseek-v4-flash': { prompt: 0.10, completion: 0.20, cacheRead: 0.01 },
+  'deepseek-v4-pro': { prompt: 0.50, completion: 2.00, cacheRead: 0.10 },
+  'gpt-4o': { prompt: 2.50, completion: 10.00, cacheRead: 1.25 },
+  'gpt-4o-mini': { prompt: 0.15, completion: 0.60, cacheRead: 0.075 },
+  'claude-3-5-sonnet': { prompt: 3.00, completion: 15.00, cacheRead: 0.30 },
+  'claude-3-5-haiku': { prompt: 0.80, completion: 4.00, cacheRead: 0.08 },
+  'gemini-1.5-flash': { prompt: 0.075, completion: 0.30, cacheRead: 0.01875 },
+  'gemini-1.5-pro': { prompt: 1.25, completion: 5.00, cacheRead: 0.3125 },
+};
+
+/**
+ * Calculate token cost in USD based on model and token counts.
+ */
+export function estimateTokenCost(model, usage = {}) {
+  if (!usage) return 0;
+  const inputTokens = Number(usage.inputTokens) || 0;
+  const outputTokens = Number(usage.outputTokens) || 0;
+  const cacheReadTokens = Number(usage.cacheReadTokens) || 0;
+
+  const modelKey = Object.keys(MODEL_PRICING).find(k => model && model.toLowerCase().includes(k.toLowerCase())) || 'deepseek-v4-flash';
+  const pricing = MODEL_PRICING[modelKey] || { prompt: 0.14, completion: 0.28, cacheRead: 0.014 };
+
+  const inputCost = (inputTokens / 1_000_000) * pricing.prompt;
+  const outputCost = (outputTokens / 1_000_000) * pricing.completion;
+  const cacheCost = (cacheReadTokens / 1_000_000) * pricing.cacheRead;
+
+  const total = inputCost + outputCost + cacheCost;
+  return Number(total.toFixed(6));
+}
+
+/**
+ * Create an issue card in dsh-kanban.
+ * Can use ctx.webServer or direct HTTP to http://127.0.0.1:3000/dsh-kanban/task
+ */
+export async function createKanbanCard({
+  title,
+  body,
+  board = 'main',
+  column = 'backlog',
+  labels = ['cron', 'alert'],
+  fetchFn = globalThis.fetch,
+  kanbanBaseUrl = 'http://127.0.0.1:3000'
+}) {
+  try {
+    const url = `${kanbanBaseUrl.replace(/\/$/, '')}/dsh-kanban/task`;
+    const res = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Sec-Fetch-Site': 'same-origin',
+      },
+      body: JSON.stringify({
+        title,
+        body,
+        board,
+        column,
+        labels,
+      })
+    });
+
+    if (!res.ok) {
+      const errText = await res.text().catch(() => '');
+      throw new Error(`HTTP ${res.status}: ${errText}`);
+    }
+
+    const data = await res.json().catch(() => ({}));
+    return { success: true, task: data.task };
+  } catch (err) {
+    console.error('[dsh-cron] failed to create kanban card:', err.message);
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Check if kanban card should be created for this run.
+ */
+export function shouldCreateKanbanCard(task, runInfo) {
+  const mode = task.kanbanMode || 'none'; // 'none' | 'on_failure' | 'always'
+  if (mode === 'none') return false;
+  if (mode === 'always') return true;
+  if (mode === 'on_failure') {
+    return runInfo.status === 'error' || runInfo.status === 'timeout';
+  }
+  return false;
+}

package/lib/runner.js

@@ -1,3 +1,5 @@
+import { estimateTokenCost } from './integrations.js';
+
 /**
  * Runner executing scheduled tasks in DeepSeek Harness sessions.
  */
@@ -6,25 +8,66 @@ export class SessionRunner {
     this.ctx = ctx;
   }
 
-    async execute(task) {
+  async execute(task, options = {}) {
+    const timeoutSeconds = Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) : 1800;
+    const timeoutMs = timeoutSeconds * 1000;
+    const externalSignal = options.signal;
+
+    // Internal abort controller combining external signal + timeout
+    const controller = new AbortController();
+    let timeoutId = null;
+
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        throw new Error(externalSignal.reason?.message || 'Task aborted before execution');
+      }
+      externalSignal.addEventListener('abort', () => {
+        controller.abort(externalSignal.reason || new Error('Task aborted by overlap policy'));
+      }, { once: true });
+    }
+
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        const timeoutErr = new Error(`Task execution timed out after ${timeoutSeconds} seconds`);
+        controller.abort(timeoutErr);
+        reject(timeoutErr);
+      }, timeoutMs);
+    });
+
+    const executionPromise = this._run(task, controller.signal);
+
+    try {
+      return await Promise.race([executionPromise, timeoutPromise]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+
+  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');
-      const { promisify } = await import('node:util');
-      const execAsync = promisify(exec);
-      try {
-        const { stdout, stderr } = await execAsync(task.prompt, {
-          timeout: 60000,
-          cwd: process.cwd()
+      return new Promise((resolve, reject) => {
+        const child = exec(task.prompt, {
+          cwd: process.cwd(),
+          signal,
+        }, (err, stdout, stderr) => {
+          if (err) {
+            if (signal && signal.aborted) {
+              return reject(signal.reason || new Error('Command aborted'));
+            }
+            return reject(err);
+          }
+          const out = (stdout || stderr || '').trim();
+          resolve({
+            output: out || 'Script completed with code 0',
+            usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+            costUsd: 0
+          });
         });
-        const out = (stdout || stderr || '').trim();
-        return out || 'Script completed with code 0';
-      } catch (err) {
-        console.error(`[dsh-cron] script task failed:`, err.message);
-        throw err;
-      }
+      });
     }
 
     // 2. If ctx.agents is available, run through agent session (LLM)
@@ -50,7 +93,7 @@ export class SessionRunner {
 
         const defaultSel = this.ctx.get?.('agentDefaultModel')?.currentSelection?.();
         const provider = task.provider || defaultSel?.provider;
-        const model = task.model || defaultSel?.model;
+        const model = task.model || defaultSel?.model || 'deepseek-v4-flash';
 
         const cwd = process.cwd();
         const handle = await this.ctx.agents.create({
@@ -59,13 +102,36 @@ export class SessionRunner {
           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' },
         }));
 
-        return `[dsh-cron] Agent started session ${handle.agent.session?.id || 'cron'}`;
+        // 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 {}
+
+        const costUsd = estimateTokenCost(model, usage);
+
+        return {
+          output: `[dsh-cron] Agent started session ${handle.agent.session?.id || 'cron'}`,
+          usage,
+          costUsd
+        };
       } catch (err) {
         console.error(`[dsh-cron] agent execution failed:`, err.message);
         throw err;
@@ -82,7 +148,14 @@ export class SessionRunner {
         
         if (session && typeof session.send === 'function') {
           const result = await session.send(task.prompt);
-          return typeof result === 'string' ? result : JSON.stringify(result);
+          const out = typeof result === 'string' ? result : JSON.stringify(result);
+          const usage = session.usage || { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+          const costUsd = estimateTokenCost(task.model, usage);
+          return {
+            output: out,
+            usage,
+            costUsd
+          };
         }
       } catch (err) {
         console.error(`[dsh-cron] session execution failed:`, err.message);
@@ -90,6 +163,10 @@ export class SessionRunner {
       }
     }
 
-    return `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`;
+    return {
+      output: `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`,
+      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+      costUsd: 0
+    };
   }
-}
+}

package/lib/scheduler.js

@@ -1,5 +1,6 @@
 import { Cron } from 'croner';
 import { shouldNotifyTask, formatTaskTelegramMessage, sendTelegramMessage } from './telegram.js';
+import { createKanbanCard, shouldCreateKanbanCard } from './integrations.js';
 
 function pad(v) {
   return String(v).padStart(2, '0');
@@ -83,6 +84,7 @@ export class TaskScheduler {
     this.store = store;
     this.executeFn = executeFn;
     this.jobs = new Map();
+    this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
   }
 
   start() {
@@ -101,6 +103,13 @@ export class TaskScheduler {
       } catch {}
     }
     this.jobs.clear();
+
+    for (const [, run] of this.running.entries()) {
+      try {
+        run.controller.abort(new Error('Планировщик остановлен'));
+      } catch {}
+    }
+    this.running.clear();
   }
 
   scheduleTask(task) {
@@ -132,14 +141,60 @@ export class TaskScheduler {
     const task = this.store.get(taskId);
     if (!task) return;
 
+    const overlapPolicy = task.overlapPolicy || 'skip';
+
+    // Check overlap with currently running task
+    const active = this.running.get(taskId);
+    if (active) {
+      if (overlapPolicy === 'skip') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
+        this.store.recordRun(taskId, {
+          at: Date.now(),
+          status: 'skipped',
+          durationMs: 0,
+          output: 'Запуск пропущен: предыдущий процесс ещё не завершился (overlapPolicy: skip)',
+          error: null,
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        });
+        return;
+      }
+      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'));
+      }
+      if (overlapPolicy === 'queue') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
+        active.queueCount = (active.queueCount || 0) + 1;
+        return;
+      }
+    }
+
+    const controller = new AbortController();
+    const currentRun = {
+      controller,
+      startedAt: Date.now(),
+      queueCount: 0,
+    };
+    this.running.set(taskId, currentRun);
+
     const start = Date.now();
     let status = 'success';
     let output = '';
     let error = null;
+    let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+    let costUsd = 0;
 
     try {
       if (typeof this.executeFn === 'function') {
-        output = await this.executeFn(task);
+        const res = await this.executeFn(task, { signal: controller.signal });
+        if (typeof res === 'object' && res !== null) {
+          output = res.output || '';
+          usage = res.usage || usage;
+          costUsd = res.costUsd || 0;
+        } else {
+          output = String(res || '');
+        }
       }
     } catch (err) {
       status = 'error';
@@ -152,10 +207,20 @@ export class TaskScheduler {
         durationMs,
         output,
         error,
+        usage,
+        costUsd,
       };
       this.store.recordRun(taskId, runInfo);
 
-      // Telegram notification delivery
+      // Clean up running map
+      const finishedRun = this.running.get(taskId);
+      if (finishedRun === currentRun) {
+        this.running.delete(taskId);
+      }
+
+      const queuedCount = finishedRun?.queueCount || 0;
+
+      // 1. Telegram notification delivery
       try {
         const settings = typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
         if (shouldNotifyTask(task, runInfo, settings)) {
@@ -172,12 +237,52 @@ export class TaskScheduler {
         console.error('[dsh-cron] notification error:', notifyErr.message);
       }
 
+      // 2. Kanban card creation
+      try {
+        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 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\`\`\`` : '',
+          ].filter(Boolean).join('\n\n');
+
+          createKanbanCard({
+            title: cardTitle,
+            body: cardBody,
+            board: 'main',
+            column: isErr ? 'backlog' : 'done',
+            labels: isErr ? ['cron', 'bug', 'alert'] : ['cron', 'auto'],
+            kanbanBaseUrl: settings.kanbanBaseUrl || 'http://127.0.0.1:3000'
+          }).then((res) => {
+            if (res.success) {
+              console.log(`[dsh-cron] created kanban card for task "${task.title}"`);
+            }
+          }).catch((kErr) => {
+            console.error('[dsh-cron] kanban card error:', kErr.message);
+          });
+        }
+      } catch (kanbanErr) {
+        console.error('[dsh-cron] kanban error:', kanbanErr.message);
+      }
+
       const job = this.jobs.get(taskId);
       if (job) {
         const next = job.nextRun();
         task.nextRunAt = next ? next.getTime() : null;
         this.store.set(task);
       }
+
+      if (queuedCount > 0) {
+        setImmediate(() => {
+          this.runTask(taskId);
+        });
+      }
     }
   }
 
@@ -190,6 +295,13 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    const running = this.running.get(taskId);
+    if (running) {
+      try {
+        running.controller.abort(new Error('Задача приостановлена'));
+      } catch {}
+      this.running.delete(taskId);
+    }
     this.store.set(task);
     return task;
   }
@@ -208,9 +320,20 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    const running = this.running.get(taskId);
+    if (running) {
+      try {
+        running.controller.abort(new Error('Задача удалена'));
+      } catch {}
+      this.running.delete(taskId);
+    }
     return this.store.delete(taskId);
   }
 
+  triggerManualRun(taskId) {
+    return this.runTask(taskId);
+  }
+
   getNextRun(schedule) {
     try {
       const parsed = parseScheduleExpression(schedule);

package/lib/store.js

@@ -73,6 +73,7 @@ export class TaskStore {
       notifyTelegram: Boolean(this.settings.notifyTelegram),
       onlyOnFailure: Boolean(this.settings.onlyOnFailure),
       hasDefaultCredentials: Boolean(defaults.botToken && defaults.chatId),
+      kanbanBaseUrl: this.settings.kanbanBaseUrl || 'http://127.0.0.1:3000',
     };
   }
 
@@ -83,6 +84,7 @@ export class TaskStore {
       chatId: newSettings.chatId !== undefined ? String(newSettings.chatId).trim() : (this.settings.chatId || ''),
       notifyTelegram: newSettings.notifyTelegram !== undefined ? Boolean(newSettings.notifyTelegram) : Boolean(this.settings.notifyTelegram),
       onlyOnFailure: newSettings.onlyOnFailure !== undefined ? Boolean(newSettings.onlyOnFailure) : Boolean(this.settings.onlyOnFailure),
+      kanbanBaseUrl: newSettings.kanbanBaseUrl !== undefined ? String(newSettings.kanbanBaseUrl).trim() : (this.settings.kanbanBaseUrl || 'http://127.0.0.1:3000'),
     };
     this.save();
     return this.getSettings();
@@ -127,6 +129,11 @@ export class TaskStore {
       model: task.model !== undefined ? task.model : prev.model,
       notifyTelegram: task.notifyTelegram !== undefined ? Boolean(task.notifyTelegram) : (prev.notifyTelegram || false),
       onlyOnFailure: task.onlyOnFailure !== undefined ? Boolean(task.onlyOnFailure) : (prev.onlyOnFailure || false),
+      timeoutSeconds: task.timeoutSeconds !== undefined ? Number(task.timeoutSeconds) : (prev.timeoutSeconds || 1800),
+      overlapPolicy: task.overlapPolicy !== undefined ? String(task.overlapPolicy) : (prev.overlapPolicy || 'skip'),
+      kanbanMode: task.kanbanMode !== undefined ? String(task.kanbanMode) : (prev.kanbanMode || 'none'), // 'none' | 'on_failure' | 'always'
+      totalTokens: prev.totalTokens || 0,
+      totalCostUsd: prev.totalCostUsd || 0,
       createdAt: prev.createdAt || task.createdAt || now,
       updatedAt: now,
       lastRunAt: task.lastRunAt !== undefined ? task.lastRunAt : (prev.lastRunAt || null),
@@ -152,6 +159,14 @@ export class TaskStore {
     task.lastRunAt = runInfo.at || Date.now();
     task.lastStatus = runInfo.status || 'success';
     task.lastDurationMs = runInfo.durationMs || 0;
+    
+    // Track usage and cost
+    const usage = runInfo.usage || { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+    const costUsd = Number(runInfo.costUsd) || 0;
+    const runTokens = (usage.inputTokens || 0) + (usage.outputTokens || 0) + (usage.cacheReadTokens || 0);
+
+    task.totalTokens = (task.totalTokens || 0) + runTokens;
+    task.totalCostUsd = Number(((task.totalCostUsd || 0) + costUsd).toFixed(6));
     task.updatedAt = Date.now();
 
     const runs = this.history.get(id) || [];
@@ -162,6 +177,8 @@ export class TaskStore {
       durationMs: task.lastDurationMs,
       output: (runInfo.output || '').slice(0, 4000),
       error: runInfo.error ? String(runInfo.error).slice(0, 1000) : null,
+      usage,
+      costUsd,
     });
     if (runs.length > 50) runs.length = 50;
     this.history.set(id, runs);
@@ -172,4 +189,26 @@ export class TaskStore {
     const runs = this.history.get(id) || [];
     return runs.slice(0, limit);
   }
+
+  getAggregatedStats() {
+    let totalRuns = 0;
+    let totalTokens = 0;
+    let totalCostUsd = 0;
+    let activeTasks = 0;
+
+    for (const t of this.tasks.values()) {
+      if (t.status === 'active') activeTasks++;
+      totalTokens += (t.totalTokens || 0);
+      totalCostUsd += (t.totalCostUsd || 0);
+      const h = this.history.get(t.id) || [];
+      totalRuns += h.length;
+    }
+
+    return {
+      activeTasks,
+      totalRuns,
+      totalTokens,
+      totalCostUsd: Number(totalCostUsd.toFixed(4)),
+    };
+  }
 }

package/package.json

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