@goodandready/dsh-cron 0.1.16 → 0.1.18

package/README.md

@@ -187,3 +187,13 @@ 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.
+
+### One-Shot Delayed Tasks (v0.1.18)
+- **Precise Timing & Relative Delays**: Supports one-time tasks triggered at exact ISO 8601 timestamps (`at: 2026-09-05T12:00:00Z`) or human-friendly relative delays (`in 20m`, `in 2h`, `через 15 минут`).
+- **Auto-Completion Lifecycle**: One-shot jobs transition automatically to `completed` status after their single run, preventing unexpected repeats.
+- **Dedicated Filter**: View historical and pending one-shot executions under the «Completed» (`completed`) tab.

package/docs/README.ru.md

@@ -170,3 +170,13 @@ npm test
 ## 📄 Лицензия
 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+
+### Интеграция с Kanban и счетчик стоимости токенов (v0.1.17)
+- **Автосоздание карточек в Kanban**: Автоматическое заведение задач в бэклог `dsh-kanban` при обнаружении сбоев/ошибок (`on_failure`) или при каждом завершении (`always`).
+- **Трекинг токенов и расчет расходов (USD)**: Подсчет потребления токенов (input, output, cacheRead) для каждой задачи и запуск с расчетом примерной стоимости в долларах США.
+- **Сводная панель статистики**: Отображение общего числа запусков, активных задач, суммарного расхода токенов и совокупных затрат прямо в заголовке планировщика.
+
+### Разовые отложенные задачи (v0.1.18)
+- **Точное время и относительные задержки**: Поддержка однократных задач, запускаемых в конкретный момент времени по стандарту ISO 8601 (`at: 2026-09-05T12:00:00Z`) или через заданный интервал (`in 20m`, `in 2h`, `через 15 минут`).
+- **Автоматический перевод в «Завершенные»**: После единичного выполнения задача автоматически переходит в статус `completed`, исключая повторные старты.
+- **Индикация в интерфейсе**: Разовые задачи помечаются специальным бейджем «Разовая» и фильтруются по вкладке «Завершенные».

package/lib/client.js

@@ -140,6 +140,14 @@ const React = window.React || require('react');
       .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-oneshot-tag { font-size: 11px; padding: 2px 6px; border-radius: 4px; background: rgba(168, 85, 247, 0.15); color: #c084fc; font-weight: 500; }
+      .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; }
@@ -251,6 +259,8 @@ const React = window.React || require('react');
       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);
@@ -291,6 +301,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) {}
       };
@@ -406,6 +417,7 @@ const React = window.React || require('react');
         setFormOnlyOnFailure(false);
         setFormTimeoutSeconds(1800);
         setFormOverlapPolicy('skip');
+        setFormKanbanMode('none');
         if (preset) {
           setFormTitle(preset.title || '');
           setFormSchedule(preset.schedule || '');
@@ -455,6 +467,7 @@ const React = window.React || require('react');
         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);
@@ -480,6 +493,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',
@@ -582,6 +600,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', {
@@ -618,7 +654,10 @@ 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.oneShot ? React.createElement('span', { className: 'dsh-cron-oneshot-tag' }, 'Разовая') : 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,
@@ -728,7 +767,11 @@ const React = window.React || require('react');
                       }, 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)
@@ -774,7 +817,7 @@ const React = window.React || require('react');
                   React.createElement('input', {
                     required: true,
                     value: formSchedule,
-                    placeholder: '0 */6 * * * или every 2h',
+                    placeholder: '0 */6 * * * или every 2h или in 30m или at: 2026-09-05T15:00:00Z',
                     onChange: (e) => setFormSchedule(e.target.value)
                   })
                 )
@@ -802,6 +845,17 @@ const React = window.React || require('react');
                   )
                 )
               ),
+              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';
 
@@ -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;
         }
 
@@ -99,7 +101,7 @@ export function apply(ctx, config) {
           const task = store.set({
             id: body.id,
             title: body.title,
-            schedule: parsed.cronPattern,
+            schedule: parsed.cronPattern || body.schedule,
             scheduleText: body.scheduleText || parsed.humanText,
             prompt: body.prompt,
             type: body.type || 'prompt',
@@ -111,6 +113,8 @@ export function apply(ctx, config) {
             onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : false,
             timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : 1800,
             overlapPolicy: body.overlapPolicy || 'skip',
+            kanbanMode: body.kanbanMode || 'none',
+            oneShot: Boolean(parsed.isOneShot || body.oneShot),
           });
           scheduler.scheduleTask(task);
           sendJson(res, 200, { ok: true, task });
@@ -176,280 +180,284 @@ 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];
+
+        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;
+        }
 
-        const toggleMatch = pathname.match(/^\/dsh-cron\/action\/([^/]+)\/toggle$/);
-        if (req.method === 'POST' && toggleMatch) {
-          const taskId = toggleMatch[1];
-          const task = store.get(taskId);
+        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 (запуск по расписанию или разово через "at: ISO" или "in 20m")',
+    parameters: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Краткое название задачи' },
+        schedule: { type: 'string', description: 'Расписание: cron ("0 9 * * *"), интервал ("every 2h") или разово ("in 30m", "at: 2026-09-05T15:00:00Z")' },
+        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 только при ошибках' },
-        timeoutSeconds: { type: 'integer', description: 'Таймаут выполнения задачи в секундах (по умолчанию 1800 = 30 мин)' },
-        overlapPolicy: { type: 'string', description: 'Политика наложения: "skip" (по умолчанию), "queue", "replace"' }
-      },
-      output: {
-        schema: {
-          type: 'object',
-          additionalProperties: false,
-          properties: {
-            success: { type: 'boolean' },
-            message: { type: 'string' }
-          }
-        },
-        render(_args, value) {
-          return [{ type: 'text', text: value.message }];
-        }
+        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' },
       },
-      execute: async ({ title, schedule, prompt, delivery, provider, model, type, notifyTelegram, onlyOnFailure, timeoutSeconds, overlapPolicy }) => {
-        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),
-            timeoutSeconds: timeoutSeconds !== undefined ? Number(timeoutSeconds) : 1800,
-            overlapPolicy: overlapPolicy || 'skip',
-            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 || args.schedule,
+        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',
+        oneShot: Boolean(parsed.isOneShot),
+      });
+      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', 'completed'], 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,
+          oneShot: Boolean(t.oneShot),
+        }))
+      };
+    }
+  }));
+
+  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.
  */
@@ -59,7 +61,11 @@ export class SessionRunner {
             return reject(err);
           }
           const out = (stdout || stderr || '').trim();
-          resolve(out || 'Script completed with code 0');
+          resolve({
+            output: out || 'Script completed with code 0',
+            usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+            costUsd: 0
+          });
         });
       });
     }
@@ -87,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({
@@ -106,7 +112,26 @@ export class SessionRunner {
           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;
@@ -123,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);
@@ -131,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');
@@ -27,6 +28,49 @@ export function parseScheduleExpression(input) {
   const str = String(input || '').trim();
   if (!str) throw new Error('Строка расписания не должна быть пустой');
 
+  // 1. One-shot ISO 8601 timestamp or explicit "at: <ISO/datetime>"
+  const atPrefixMatch = str.match(/^(?:at:\s*|at\s+)(.+)$/i);
+  const candidateIso = atPrefixMatch ? atPrefixMatch[1].trim() : str;
+  const parsedDate = new Date(candidateIso);
+  if (!isNaN(parsedDate.getTime()) && (candidateIso.includes('-') || candidateIso.includes('T') || atPrefixMatch)) {
+    const targetMs = parsedDate.getTime();
+    return {
+      cronPattern: null,
+      isOneShot: true,
+      targetTimestamp: targetMs,
+      humanText: `Разово: ${parsedDate.toLocaleString('ru-RU')}`,
+      nextRun: targetMs
+    };
+  }
+
+  // 2. Relative one-shot: "in 20m", "in 2h", "in 30s", "in 1d", "через 15 минут"
+  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} мин`;
+    if (unit.startsWith('s')) {
+      delayMs = num * 1000;
+      unitText = `${num} сек`;
+    } else if (unit.startsWith('h') || unit.startsWith('час')) {
+      delayMs = num * 3600 * 1000;
+      unitText = `${num} ч`;
+    } else if (unit.startsWith('d')) {
+      delayMs = num * 86400 * 1000;
+      unitText = `${num} дн`;
+    }
+    const targetMs = Date.now() + delayMs;
+    return {
+      cronPattern: null,
+      isOneShot: true,
+      targetTimestamp: targetMs,
+      humanText: `Разово через ${unitText} (${new Date(targetMs).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`,
+      nextRun: targetMs
+    };
+  }
+
+  // 3. Repeating Interval: "every 5m", "every 2h", "every 1d"
   const intervalMatch = str.match(/^every\s+(\d+)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days)?$/i);
   if (intervalMatch) {
     const num = parseInt(intervalMatch[1], 10);
@@ -54,6 +98,7 @@ export function parseScheduleExpression(input) {
     }
   }
 
+  // 4. Friendly recurring aliases
   const lower = str.toLowerCase();
   if (lower === 'daily' || lower === 'каждый день') {
     return { cronPattern: '0 9 * * *', humanText: 'Каждый день в 09:00' };
@@ -65,6 +110,7 @@ export function parseScheduleExpression(input) {
     return { cronPattern: '0 * * * *', humanText: 'Каждый час' };
   }
 
+  // 5. Standard 5-field cron expression
   try {
     const testJob = new Cron(str);
     const next = testJob.nextRun();
@@ -82,7 +128,8 @@ export class TaskScheduler {
   constructor(store, executeFn) {
     this.store = store;
     this.executeFn = executeFn;
-    this.jobs = new Map();
+    this.jobs = new Map(); // taskId -> Cron instance
+    this.timers = new Map(); // taskId -> setTimeout handle (for one-shot tasks)
     this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
   }
 
@@ -103,6 +150,13 @@ export class TaskScheduler {
     }
     this.jobs.clear();
 
+    for (const [id, timer] of this.timers.entries()) {
+      try {
+        clearTimeout(timer);
+      } catch {}
+    }
+    this.timers.clear();
+
     for (const [, run] of this.running.entries()) {
       try {
         run.controller.abort(new Error('Планировщик остановлен'));
@@ -112,15 +166,40 @@ export class TaskScheduler {
   }
 
   scheduleTask(task) {
+    // Clear any existing job or timer for this task
     if (this.jobs.has(task.id)) {
       this.jobs.get(task.id).stop();
       this.jobs.delete(task.id);
     }
+    if (this.timers.has(task.id)) {
+      clearTimeout(this.timers.get(task.id));
+      this.timers.delete(task.id);
+    }
 
     if (task.status !== 'active') return;
 
     try {
       const parsed = parseScheduleExpression(task.schedule);
+
+      // Handle One-shot task
+      if (parsed.isOneShot) {
+        task.oneShot = true;
+        const now = Date.now();
+        const delay = Math.max(0, parsed.targetTimestamp - now);
+        task.nextRunAt = parsed.targetTimestamp;
+        this.store.set(task);
+
+        // If target is in the past, or when delay triggers:
+        const timer = setTimeout(async () => {
+          this.timers.delete(task.id);
+          await this.runTask(task.id);
+        }, delay);
+
+        this.timers.set(task.id, timer);
+        return;
+      }
+
+      // Handle Recurring Cron job
       const job = new Cron(parsed.cronPattern, { protect: true }, async () => {
         await this.runTask(task.id);
       });
@@ -153,6 +232,8 @@ export class TaskScheduler {
           durationMs: 0,
           output: 'Запуск пропущен: предыдущий процесс ещё не завершился (overlapPolicy: skip)',
           error: null,
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
         });
         return;
       }
@@ -179,10 +260,19 @@ export class TaskScheduler {
     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, { signal: controller.signal });
+        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';
@@ -195,6 +285,8 @@ export class TaskScheduler {
         durationMs,
         output,
         error,
+        usage,
+        costUsd,
       };
       this.store.recordRun(taskId, runInfo);
 
@@ -206,7 +298,7 @@ export class TaskScheduler {
 
       const queuedCount = finishedRun?.queueCount || 0;
 
-      // Telegram notification delivery
+      // 1. Telegram notification delivery
       try {
         const settings = typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
         if (shouldNotifyTask(task, runInfo, settings)) {
@@ -223,11 +315,52 @@ export class TaskScheduler {
         console.error('[dsh-cron] notification error:', notifyErr.message);
       }
 
-      const job = this.jobs.get(taskId);
-      if (job) {
-        const next = job.nextRun();
-        task.nextRunAt = next ? next.getTime() : null;
+      // 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);
+      }
+
+      // 3. Reschedule or mark completed for one-shot
+      if (task.oneShot) {
+        task.status = 'completed';
+        task.nextRunAt = null;
         this.store.set(task);
+      } else {
+        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) {
@@ -247,9 +380,15 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    if (this.timers.has(taskId)) {
+      clearTimeout(this.timers.get(taskId));
+      this.timers.delete(taskId);
+    }
     const running = this.running.get(taskId);
     if (running) {
-      running.controller.abort(new Error('Задача приостановлена'));
+      try {
+        running.controller.abort(new Error('Задача приостановлена'));
+      } catch {}
       this.running.delete(taskId);
     }
     this.store.set(task);
@@ -270,17 +409,30 @@ export class TaskScheduler {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);
     }
+    if (this.timers.has(taskId)) {
+      clearTimeout(this.timers.get(taskId));
+      this.timers.delete(taskId);
+    }
     const running = this.running.get(taskId);
     if (running) {
-      running.controller.abort(new Error('Задача удалена'));
+      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);
+      if (parsed.isOneShot) {
+        return parsed.targetTimestamp;
+      }
       const tempJob = new Cron(parsed.cronPattern);
       const next = tempJob.nextRun();
       return next ? next.getTime() : null;

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();
@@ -129,6 +131,10 @@ export class TaskStore {
       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'
+      oneShot: task.oneShot !== undefined ? Boolean(task.oneShot) : Boolean(prev.oneShot),
+      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),
@@ -154,6 +160,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) || [];
@@ -164,6 +178,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);
@@ -174,4 +190,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.16",
+  "version": "0.1.18",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",