@goodandready/dsh-cron 0.1.20 → 0.1.21

package/lib/client.js

@@ -268,7 +268,9 @@ const React = window.React || require('react');
       const [settingsChatId, setSettingsChatId] = React.useState('');
       const [settingsNotifyGlobal, setSettingsNotifyGlobal] = React.useState(false);
       const [settingsOnlyOnFailureGlobal, setSettingsOnlyOnFailureGlobal] = React.useState(false);
+      const [settingsKanbanUrl, setSettingsKanbanUrl] = React.useState('http://127.0.0.1:3000');
       const [settingsHasDefault, setSettingsHasDefault] = React.useState(false);
+      const [settingsHasCustomBotToken, setSettingsHasCustomBotToken] = React.useState(false);
       const [testStatus, setTestStatus] = React.useState(null);
 
       // DSH dialog state
@@ -283,40 +285,55 @@ const React = window.React || require('react');
 
       React.useEffect(() => {
         const onKey = (e) => {
-          if (e.key !== 'Escape') return;
-          if (settingsModalOpen) { setSettingsModalOpen(false); return; }
-          if (manualModalOpen) { setManualModalOpen(false); return; }
-          if (dshModalOpen) { setDshModalOpen(false); return; }
-          if (dropdownOpen) { setDropdownOpen(false); return; }
-          if (onClose) onClose();
+          if (e.key === 'Escape') {
+            if (dropdownOpen) { setDropdownOpen(false); return; }
+            if (manualModalOpen) { setManualModalOpen(false); return; }
+            if (settingsModalOpen) { setSettingsModalOpen(false); return; }
+            if (dshModalOpen && !dshLoading) { setDshModalOpen(false); return; }
+            if (onClose) onClose();
+            else toggle.set(false);
+          }
         };
-        document.addEventListener('keydown', onKey);
-        return () => document.removeEventListener('keydown', onKey);
+        window.addEventListener('keydown', onKey);
+        return () => window.removeEventListener('keydown', onKey);
       }, [manualModalOpen, settingsModalOpen, dshModalOpen, dropdownOpen, onClose]);
 
       const fetchTasks = async () => {
+        setLoading(true);
         try {
-          const res = await fetch('/dsh-cron/tasks?status=' + tab + '&query=' + encodeURIComponent(query));
+          const res = await fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query));
           const data = await res.json();
           if (data && data.ok) {
             setTasks(data.tasks || []);
-            setRecs(data.recommendations || []);
-            if (data.stats) setStats(data.stats);
+            setRecommendations(data.recommendations || []);
+            setStats(data.stats || null);
           }
-        } catch (err) {}
+        } catch (err) {
+          console.error('[dsh-cron] fetch tasks error:', err);
+        } finally {
+          setLoading(false);
+        }
       };
 
-      const loadModels = async (providerToFetch) => {
+      const loadModels = async (providerName) => {
         try {
-          const url = '/dsh-cron/models' + (providerToFetch ? '?provider=' + encodeURIComponent(providerToFetch) : '');
+          const url = providerName ? '/dsh-cron/models?provider=' + encodeURIComponent(providerName) : '/dsh-cron/models';
           const res = await fetch(url);
           const data = await res.json();
-          if (data) {
-            if (data.providers) setProviders(data.providers);
-            if (data.models) setModels(data.models);
-            if (data.current) setDefaultModelInfo(data.current);
+          if (data && data.ok) {
+            if (!providerName) {
+              setProviders(data.providers || []);
+              setDefaultModelInfo(data.defaultModel || null);
+              if (data.defaultModel?.models) {
+                setModels(data.defaultModel.models);
+              }
+            } else {
+              setModels(data.models || []);
+            }
           }
-        } catch (err) {}
+        } catch (err) {
+          console.error('[dsh-cron] load models error:', err);
+        }
       };
 
       React.useEffect(() => { fetchTasks(); }, [tab, query]);
@@ -324,14 +341,14 @@ const React = window.React || require('react');
 
       const handleToggleTask = async (id) => {
         try {
-          await fetch('/dsh-cron/action/' + id + '/toggle', { method: 'POST' });
+          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/toggle', { method: 'POST' });
           fetchTasks();
         } catch (err) {}
       };
 
       const handleRunNow = async (id) => {
         try {
-          await fetch('/dsh-cron/action/' + id + '/run', { method: 'POST' });
+          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/run', { method: 'POST' });
           alert('Задача запущена');
           fetchTasks();
         } catch (err) {}
@@ -340,7 +357,7 @@ const React = window.React || require('react');
       const handleDelete = async (id) => {
         if (!confirm('Удалить эту задачу?')) return;
         try {
-          await fetch('/dsh-cron/action/' + id + '/delete', { method: 'POST' });
+          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id), { method: 'DELETE' });
           fetchTasks();
         } catch (err) {}
       };
@@ -356,7 +373,9 @@ const React = window.React || require('react');
             setSettingsChatId(data.settings.chatId || '');
             setSettingsNotifyGlobal(Boolean(data.settings.notifyTelegram));
             setSettingsOnlyOnFailureGlobal(Boolean(data.settings.onlyOnFailure));
+            setSettingsKanbanUrl(data.settings.kanbanBaseUrl || 'http://127.0.0.1:3000');
             setSettingsHasDefault(Boolean(data.settings.hasDefaultCredentials));
+            setSettingsHasCustomBotToken(Boolean(data.settings.hasCustomBotToken));
           }
         } catch (e) {}
       };
@@ -371,7 +390,8 @@ const React = window.React || require('react');
               botToken: settingsBotToken,
               chatId: settingsChatId,
               notifyTelegram: settingsNotifyGlobal,
-              onlyOnFailure: settingsOnlyOnFailureGlobal
+              onlyOnFailure: settingsOnlyOnFailureGlobal,
+              kanbanBaseUrl: settingsKanbanUrl,
             })
           });
           const data = await res.json();
@@ -439,7 +459,7 @@ const React = window.React || require('react');
       const loadTaskHistory = async (taskId) => {
         setHistoryLoading(true);
         try {
-          const res = await fetch('/dsh-cron/action/' + encodeURIComponent(taskId) + '/history');
+          const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(taskId) + '/history');
           const data = await res.json();
           if (data.ok) {
             setTaskHistory(data.history || []);
@@ -486,6 +506,7 @@ const React = window.React || require('react');
         try {
           const payload = {
             id: formId || undefined,
+            status: selectedTaskMeta ? selectedTaskMeta.status : 'active',
             title: formTitle,
             schedule: formSchedule,
             prompt: formPrompt,
@@ -1094,6 +1115,93 @@ const React = window.React || require('react');
 
     function CronSettingsCard(props) {
       const { ctx, toggle } = props;
+      const [token, setToken] = React.useState('');
+      const [chatId, setChatId] = React.useState('');
+      const [notify, setNotify] = React.useState(false);
+      const [onlyFailure, setOnlyFailure] = React.useState(false);
+      const [kanbanUrl, setKanbanUrl] = React.useState('http://127.0.0.1:3000');
+      const [hasDefault, setHasDefault] = React.useState(false);
+      const [saved, setSaved] = React.useState(false);
+      const [testInfo, setTestInfo] = React.useState(null);
+
+      React.useEffect(() => {
+        let active = true;
+        fetch('/dsh-cron/settings')
+          .then(r => r.json())
+          .then(data => {
+            if (active && data && data.ok && data.settings) {
+              setToken(data.settings.botToken || '');
+              setChatId(data.settings.chatId || '');
+              setNotify(Boolean(data.settings.notifyTelegram));
+              setOnlyFailure(Boolean(data.settings.onlyOnFailure));
+              setKanbanUrl(data.settings.kanbanBaseUrl || 'http://127.0.0.1:3000');
+              setHasDefault(Boolean(data.settings.hasDefaultCredentials));
+            }
+          })
+          .catch(() => {});
+        return () => { active = false; };
+      }, []);
+
+      const saveSettings = async (e) => {
+        if (e) e.preventDefault();
+        try {
+          const res = await fetch('/dsh-cron/settings', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              botToken: token,
+              chatId,
+              notifyTelegram: notify,
+              onlyOnFailure: onlyFailure,
+              kanbanBaseUrl: kanbanUrl
+            })
+          });
+          const data = await res.json();
+          if (data && data.ok) {
+            setSaved(true);
+            setTimeout(() => setSaved(false), 2500);
+          }
+        } catch (err) {}
+      };
+
+      const testTelegram = async () => {
+        setTestInfo({ loading: true, message: 'Отправка...' });
+        try {
+          const res = await fetch('/dsh-cron/telegram/test', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ botToken: token, chatId })
+          });
+          const data = await res.json();
+          if (data && data.ok) {
+            setTestInfo({ success: true, message: '✅ Успешно доставлено в Telegram' });
+          } else {
+            setTestInfo({ success: false, message: '❌ ' + (data?.error || 'Сбой отправки') });
+          }
+        } catch (err) {
+          setTestInfo({ success: false, message: '❌ ' + err.message });
+        }
+      };
+
+      const testKanban = async () => {
+        setTestInfo({ loading: true, message: 'Проверка Kanban...' });
+        try {
+          const res = await fetch('/dsh-cron/kanban/test', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ kanbanBaseUrl: kanbanUrl })
+          });
+          const data = await res.json();
+          if (data && data.ok) {
+            setTestInfo({ success: true, message: '✅ Карточка в Kanban создана' });
+          } else {
+            setTestInfo({ success: false, message: '❌ ' + (data?.error || 'Ошибка Kanban') });
+          }
+        } catch (err) {
+          setTestInfo({ success: false, message: '❌ ' + err.message });
+        }
+      };
+
       return React.createElement('div', { className: 'dsh-cron-card' },
         React.createElement('div', { className: 'dsh-cron-card-head' },
           React.createElement('span', { className: 'dsh-cron-card-title' }, '⏰ Планировщик задач (Cron)'),
@@ -1101,10 +1209,80 @@ const React = window.React || require('react');
             type: 'button',
             className: 'dsh-cron-btn-primary',
             onClick: () => { if (toggle) toggle.set(true); }
-          }, 'Открыть запланированные задачи')
+          }, 'Открыть панель задач')
+        ),
+        React.createElement('div', { className: 'dsh-cron-card-desc', style: { marginBottom: '16px' } },
+          'Автоматическое выполнение задач по расписанию (cron/интервалы), фоновые сценарии агентов и интеграция с Telegram и Kanban.'
         ),
-        React.createElement('div', { className: 'dsh-cron-card-desc' },
-          'Автоматическое выполнение задач в фоновом режиме по заданному расписанию (cron/интервалы), отслеживание логов и интеграция с чатом через команду /cron.'
+        React.createElement('form', { onSubmit: saveSettings, style: { display: 'flex', flexDirection: 'column', gap: '12px' } },
+          React.createElement('div', { className: 'dsh-cron-form-group', style: { marginBottom: 0 } },
+            React.createElement('label', null, 'Telegram Bot Token'),
+            React.createElement('input', {
+              type: 'password',
+              value: token,
+              placeholder: hasDefault ? 'Используется бот из настроек DSH (или введите свой)' : '123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ',
+              onChange: (e) => setToken(e.target.value)
+            }),
+            hasDefault && React.createElement('div', { className: 'dsh-cron-hint' }, '✓ Найден настроенный бот в профиле DSH')
+          ),
+          React.createElement('div', { className: 'dsh-cron-form-group', style: { marginBottom: 0 } },
+            React.createElement('label', null, 'Telegram Chat ID'),
+            React.createElement('input', {
+              value: chatId,
+              placeholder: 'Например: 345678901',
+              onChange: (e) => setChatId(e.target.value)
+            })
+          ),
+          React.createElement('div', { className: 'dsh-cron-form-group', style: { marginBottom: 0 } },
+            React.createElement('label', null, 'Kanban Base URL'),
+            React.createElement('input', {
+              value: kanbanUrl,
+              placeholder: 'http://127.0.0.1:3000',
+              onChange: (e) => setKanbanUrl(e.target.value)
+            })
+          ),
+          React.createElement('div', { style: { background: 'rgba(255,255,255,0.02)', border: '1px solid #2e2e2e', borderRadius: '6px', padding: '10px 12px', display: 'flex', flexDirection: 'column', gap: '8px' } },
+            React.createElement('label', { className: 'dsh-cron-checkbox-row' },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: notify,
+                onChange: (e) => setNotify(e.target.checked)
+              }),
+              React.createElement('span', null, 'Глобально отправлять отчеты всех задач в Telegram')
+            ),
+            React.createElement('label', { className: 'dsh-cron-checkbox-row' },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: onlyFailure,
+                onChange: (e) => setOnlyFailure(e.target.checked)
+              }),
+              React.createElement('span', null, 'Уведомлять только при ошибках')
+            )
+          ),
+          testInfo && testInfo.message && React.createElement('div', {
+            className: 'dsh-cron-status-banner',
+            'data-type': testInfo.success ? 'success' : 'error',
+            style: { margin: 0, padding: '8px 12px' }
+          }, testInfo.message),
+          React.createElement('div', { style: { display: 'flex', gap: '8px', alignItems: 'center', flexWrap: 'wrap', marginTop: '4px' } },
+            React.createElement('button', {
+              type: 'submit',
+              className: 'dsh-cron-btn-primary',
+              style: { minWidth: '140px' }
+            }, saved ? '✓ Сохранено' : 'Сохранить настройки'),
+            React.createElement('button', {
+              type: 'button',
+              className: 'dsh-cron-btn-secondary',
+              onClick: testTelegram,
+              disabled: testInfo?.loading
+            }, '🔔 Тест Telegram'),
+            React.createElement('button', {
+              type: 'button',
+              className: 'dsh-cron-btn-secondary',
+              onClick: testKanban,
+              disabled: testInfo?.loading
+            }, '📋 Тест Kanban')
+          )
         )
       );
     }

package/lib/index.js

@@ -7,10 +7,19 @@ import { sendTelegramMessage } from './telegram.js';
 import { createKanbanCard } from './integrations.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { randomUUID } from 'node:crypto';
+import z from '@deepseek-ai/schemastery';
 
 export const name = '@goodandready/dsh-cron';
 export const inject = ['tools', 'webServer', 'settings', 'llm', 'agents', 'agentDefaultModel'];
 
+export const Config = z.object({
+  botToken: z.string().role('secret').default('').description('Telegram Bot Token для отправки отчетов'),
+  chatId: z.string().default('').description('Telegram Chat ID получателя'),
+  notifyTelegram: z.boolean().default(false).description('Включить глобальную отправку отчетов в Telegram'),
+  onlyOnFailure: z.boolean().default(false).description('Отправлять отчеты в Telegram только при ошибках'),
+  kanbanBaseUrl: z.string().default('http://127.0.0.1:3000').description('Базовый URL Kanban API'),
+});
+
 function parseJsonBody(req) {
   return new Promise((resolve, reject) => {
     let data = '';
@@ -36,6 +45,24 @@ export function apply(ctx, config) {
   const runner = new SessionRunner(ctx);
   const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts));
 
+  // Register settings in Harness settings service with Config schema and initial state from store (#71)
+  ctx.inject(['settings'], (sctx) => {
+    try {
+      const scope = sctx.settings?.register?.('@goodandready/dsh-cron', Config, {
+        base: store.getSettings()
+      });
+      if (scope && typeof scope.watch === 'function') {
+        scope.watch((updated) => {
+          if (updated && typeof updated === 'object') {
+            store.saveSettings(updated);
+          }
+        });
+      }
+    } catch (e) {
+      console.warn('[dsh-cron] settings registration warning:', e.message);
+    }
+  });
+
   scheduler.start();
 
   ctx.effect(() => {
@@ -98,25 +125,33 @@ export function apply(ctx, config) {
             return;
           }
           const parsed = parseScheduleExpression(body.schedule);
+          const current = body.id ? store.get(body.id) : null;
+          const resolvedStatus = body.status || (current ? current.status : 'active');
+          const taskType = body.type === 'script' ? 'script' : 'llm';
+
           const task = store.set({
             id: body.id,
             title: body.title,
             schedule: parsed.cronPattern || body.schedule,
             scheduleText: body.scheduleText || parsed.humanText,
             prompt: body.prompt,
-            type: body.type || 'prompt',
+            type: taskType,
             delivery: body.delivery || 'current',
-            status: body.status || 'active',
+            status: resolvedStatus,
             provider: body.provider || undefined,
             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',
+            notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : (current ? current.notifyTelegram : false),
+            onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : (current ? current.onlyOnFailure : false),
+            timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : (current ? current.timeoutSeconds : 1800),
+            overlapPolicy: body.overlapPolicy || (current ? current.overlapPolicy : 'skip'),
+            kanbanMode: body.kanbanMode || (current ? current.kanbanMode : 'none'),
             oneShot: Boolean(parsed.isOneShot || body.oneShot),
           });
-          scheduler.scheduleTask(task);
+          if (task.status === 'active') {
+            scheduler.scheduleTask(task);
+          } else {
+            scheduler.pauseTask(task.id);
+          }
           sendJson(res, 200, { ok: true, task });
           return;
         }
@@ -153,13 +188,13 @@ export function apply(ctx, config) {
     handler: async (req, res) => {
       try {
         if (req.method === 'GET') {
-          sendJson(res, 200, { ok: true, settings: store.getSettings() });
+          sendJson(res, 200, { ok: true, settings: store.getClientSettings() });
           return;
         }
         if (req.method === 'POST') {
           const body = await parseJsonBody(req);
-          const updated = store.saveSettings(body);
-          sendJson(res, 200, { ok: true, settings: updated });
+          store.saveSettings(body);
+          sendJson(res, 200, { ok: true, settings: store.getClientSettings() });
           return;
         }
         sendJson(res, 405, { ok: false, error: 'Method not allowed' });
@@ -282,6 +317,17 @@ export function apply(ctx, config) {
           return;
         }
 
+        if (req.method === 'POST' && (action === 'toggle' || (!action && url.searchParams.get('action') === 'toggle'))) {
+          const current = store.get(id);
+          if (!current) {
+            sendJson(res, 404, { ok: false, error: 'Задача не найдена' });
+            return;
+          }
+          const task = scheduler.toggleTask(id);
+          sendJson(res, 200, { ok: true, task });
+          return;
+        }
+
         if (req.method === 'PATCH') {
           const body = await parseJsonBody(req);
           const current = store.get(id);
@@ -289,15 +335,24 @@ export function apply(ctx, config) {
             sendJson(res, 404, { ok: false, error: 'Задача не найдена' });
             return;
           }
-          const task = store.set({ ...current, ...body, id });
+          let patchData = { ...body };
+          if (body.schedule) {
+            const parsed = parseScheduleExpression(body.schedule);
+            patchData.schedule = parsed.cronPattern || body.schedule;
+            patchData.scheduleText = body.scheduleText || parsed.humanText;
+            patchData.oneShot = Boolean(parsed.isOneShot || body.oneShot);
+          }
+          const task = store.set({ ...current, ...patchData, id });
           if (task.status === 'active') {
             scheduler.scheduleTask(task);
+          } else {
+            scheduler.pauseTask(id);
           }
           sendJson(res, 200, { ok: true, task });
           return;
         }
 
-        if (req.method === 'DELETE') {
+        if (req.method === 'DELETE' || (req.method === 'POST' && action === 'delete')) {
           const current = store.get(id);
           if (current) {
             scheduler.pauseTask(id);
@@ -314,6 +369,64 @@ export function apply(ctx, config) {
     }
   }), 'dsh-cron: /tasks/:id');
 
+  // Alias route /dsh-cron/action/:id/:action for backward compatibility (#66)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/action/',
+    handler: async (req, res) => {
+      try {
+        const url = new URL(req.url, 'http://127.0.0.1');
+        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 (action === 'history' || (req.method === 'GET' && !action)) {
+          const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+          const history = store.getHistory(id, limit);
+          sendJson(res, 200, { ok: true, history });
+          return;
+        }
+
+        if (action === 'run') {
+          await scheduler.triggerManualRun(id);
+          const task = store.get(id);
+          sendJson(res, 200, { ok: true, task });
+          return;
+        }
+
+        if (action === 'toggle') {
+          const current = store.get(id);
+          if (!current) {
+            sendJson(res, 404, { ok: false, error: 'Задача не найдена' });
+            return;
+          }
+          const task = scheduler.toggleTask(id);
+          sendJson(res, 200, { ok: true, task });
+          return;
+        }
+
+        if (action === 'delete') {
+          const current = store.get(id);
+          if (current) {
+            scheduler.pauseTask(id);
+            store.delete(id);
+          }
+          sendJson(res, 200, { ok: true });
+          return;
+        }
+
+        sendJson(res, 405, { ok: false, error: 'Action not supported' });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /action/:id/:action');
+
   // 2. Tools
   ctx.tools.register(defineTool({
     name: 'cron_create_task',
@@ -345,13 +458,73 @@ export function apply(ctx, config) {
       render: (_args, val) => [{ type: 'text', text: val.message || JSON.stringify(val) }]
     },
     execute: async (args) => {
+      const taskType = args.type === 'script' ? 'script' : 'llm';
+      const parsed = parseScheduleExpression(args.schedule);
+      const task = store.set({
+        title: args.title,
+        schedule: parsed.cronPattern || args.schedule,
+        scheduleText: parsed.humanText,
+        prompt: args.prompt,
+        type: taskType,
+        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
+      };
+    }
+  }));
+
+  // Alias tool cron_schedule_task for compatibility with agent prompts (#70)
+  ctx.tools.register(defineTool({
+    name: 'cron_schedule_task',
+    description: 'Алиас для cron_create_task: создать новую запланированную задачу cron',
+    parameters: {
+      title: { type: 'string', description: 'Краткое название задачи', required: true },
+      schedule: { type: 'string', description: 'Расписание: cron, интервал или разово', required: true },
+      prompt: { type: 'string', description: 'Промпт/инструкция для агента при запуске', required: true },
+      type: { type: 'string', enum: ['llm', 'prompt', 'script'], description: 'Тип задачи' },
+      delivery: { type: 'string', enum: ['current', 'isolated'], description: 'Режим запуска' },
+      provider: { type: 'string', description: 'Провайдер модели (опционально)' },
+      model: { type: 'string', description: 'Модель (опционально)' },
+      notifyTelegram: { 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: true,
+        properties: {
+          success: { type: 'boolean' },
+          message: { type: 'string' },
+          task: { type: 'object', additionalProperties: true }
+        }
+      },
+      render: (_args, val) => [{ type: 'text', text: val.message || JSON.stringify(val) }]
+    },
+    execute: async (args) => {
+      const taskType = args.type === 'script' ? 'script' : 'llm';
       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',
+        type: taskType,
         delivery: args.delivery || 'isolated',
         status: 'active',
         provider: args.provider,

package/lib/prompt.js

@@ -11,7 +11,7 @@ export function buildAgentCronPrompt(userText) {
 
 ВАЖНЕЙШИЕ ПРАВИЛА ДЛЯ АГЕНТА:
 1. СТРОГИЙ ЗАПРЕТ НА СПЕШКУ:
-   КАТЕГОРИЧЕСКИ ЗАПРЕЩЕНО вызывать инструмент \`cron_schedule_task\` в первом же ответе!
+   КАТЕГОРИЧЕСКИ ЗАПРЕЩЕНО вызывать инструмент \`cron_create_task\` (или \`cron_schedule_task\`) в первом же ответе!
    Ты НЕ имеешь права создавать задачу, пока не задашь пользователю уточняющие вопросы и не получишь его подтверждение.
 
 2. ПЕРВЫЙ ВОПРОС: LLM vs NO-LLM Shell (КРИТИЧЕСКИ ВАЖНО):
@@ -44,7 +44,7 @@ export function buildAgentCronPrompt(userText) {
    - Задай недостающие вопросы и попроси подтвердить создание задачи.
 
 5. СОЗДАНИЕ ЗАДАЧИ:
-   Только ПОСЛЕ ТОГО, как пользователь ответит и подтвердит параметры, вызови инструмент \`cron_schedule_task\`, передав:
+   Только ПОСЛЕ ТОГО, как пользователь ответит и подтвердит параметры, вызови инструмент \`cron_create_task\`, передав:
    - title: понятное название задачи
    - schedule: согласованное cron-выражение
    - prompt: финальная shell-команда/путь к скрипту (для type="script") ИЛИ подробная инструкция с Silent Rule (для type="llm")

package/lib/runner.js

@@ -82,14 +82,18 @@ export class SessionRunner {
           }
         } catch {}
 
-        let mintSessionId = () => `cron-exec-${task.id}-${randomUUID()}`;
+        let sessionModule = null;
         try {
-          const sessionModule = await import('@deepseek-ai/dsh-session');
+          sessionModule = await import('@deepseek-ai/dsh-session');
+        } catch {}
+
+        const mintSessionId = () => {
+          const sid = `cron-exec-${task.id}-${randomUUID()}`;
           if (sessionModule && typeof sessionModule.SessionId === 'function') {
-            const sid = mintSessionId();
-            mintSessionId = () => sessionModule.SessionId(sid);
+            return sessionModule.SessionId(sid);
           }
-        } catch {}
+          return sid;
+        };
 
         const defaultSel = this.ctx.get?.('agentDefaultModel')?.currentSelection?.();
         const provider = task.provider || defaultSel?.provider;
@@ -112,6 +116,11 @@ export class SessionRunner {
           source: { kind: 'plugin', plugin: 'dsh-cron', form: 'cron-execute' },
         }));
 
+        // Await agent turn completion (#67)
+        if (typeof handle.agent.whenIdle === 'function') {
+          await handle.agent.whenIdle();
+        }
+
         // Try extracting token usage from session history if available
         let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
         try {
@@ -128,7 +137,7 @@ export class SessionRunner {
         const costUsd = estimateTokenCost(model, usage);
 
         return {
-          output: `[dsh-cron] Agent started session ${handle.agent.session?.id || 'cron'}`,
+          output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
           usage,
           costUsd
         };

package/lib/scheduler.js

@@ -275,8 +275,12 @@ export class TaskScheduler {
         }
       }
     } catch (err) {
-      status = 'error';
       error = err.message || String(err);
+      if (error.toLowerCase().includes('timed out') || error.toLowerCase().includes('timeout')) {
+        status = 'timeout';
+      } else {
+        status = 'error';
+      }
     } finally {
       const durationMs = Date.now() - start;
       const runInfo = {
@@ -404,6 +408,16 @@ export class TaskScheduler {
     return task;
   }
 
+  toggleTask(taskId) {
+    const task = this.store.get(taskId);
+    if (!task) return null;
+    if (task.status === 'active') {
+      return this.pauseTask(taskId);
+    } else {
+      return this.resumeTask(taskId);
+    }
+  }
+
   removeTask(taskId) {
     if (this.jobs.has(taskId)) {
       this.jobs.get(taskId).stop();

package/lib/store.js

@@ -77,10 +77,39 @@ export class TaskStore {
     };
   }
 
+  getClientSettings() {
+    const raw = this.getSettings();
+    const isCustom = Boolean(this.settings.botToken);
+    const hasToken = Boolean(raw.botToken);
+    const masked = hasToken ? (raw.botToken.length > 8 ? raw.botToken.slice(0, 4) + '••••••••' + raw.botToken.slice(-3) : '••••••••') : '';
+    return {
+      botToken: masked,
+      botTokenMasked: masked,
+      hasBotToken: hasToken,
+      hasCustomBotToken: isCustom,
+      chatId: raw.chatId,
+      notifyTelegram: raw.notifyTelegram,
+      onlyOnFailure: raw.onlyOnFailure,
+      hasDefaultCredentials: raw.hasDefaultCredentials,
+      kanbanBaseUrl: raw.kanbanBaseUrl,
+    };
+  }
+
   saveSettings(newSettings = {}) {
+    let botTokenToSave = this.settings.botToken || '';
+    if (newSettings.botToken !== undefined) {
+      const val = String(newSettings.botToken).trim();
+      // If client sends masked token or empty string while custom token existed, don't overwrite with dots
+      if (val && !val.includes('••') && !val.includes('****')) {
+        botTokenToSave = val;
+      } else if (val === '') {
+        botTokenToSave = '';
+      }
+    }
+
     this.settings = {
       ...this.settings,
-      botToken: newSettings.botToken !== undefined ? String(newSettings.botToken).trim() : (this.settings.botToken || ''),
+      botToken: botTokenToSave,
       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),

package/package.json

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