@goodandready/dsh-cron 0.2.36 → 0.2.38

package/README.md

@@ -245,6 +245,7 @@ If the daemon was offline at a scheduled time, the run is recorded as `missed` o
 ### 14. Heartbeat Monitoring (#16-style dead man's switch)
 * Set `heartbeatUrl` and `heartbeatIntervalSec` in the plugin settings and the scheduler pings that URL on schedule — an external monitor alerts when the pings stop.
 * A built-in `GET /dsh-cron/heartbeat` endpoint reports liveness, active task count and the last run time for your own watchdogs.
+* **Missed Heartbeat Alerts in `onlyOnFailure` Mode** — Missed heartbeats (`status === 'missed'`) are recognized as active failure events across all channel delivery predicates (`channels.js`, `telegram.js`, `integrations.js`), guaranteeing that Telegram, Discord, Webhook, and Kanban integrations alert immediately when an external process fails to report.
 
 ### 15. Declarative Jobs From the Profile Config (#50)
 Long-lived operational jobs can be declared in the profile configuration instead of being recreated by hand in the UI. The config file owns the jobs it declares: at every plugin start they are created or updated, and a job that disappears from the file is removed.
@@ -294,6 +295,7 @@ Set the token as the plugin setting `apiToken` (masked like every secret). Auth
 | `POST` | `/dsh-cron/api/tasks/:id/run` | Force an immediate run |
 
 The operations reuse the panel handlers, so the `x-dsh-cron-confirm: script` gate for code-executing types and the `409` refusals for config-owned tasks behave exactly as in the UI.
+* **Bearer-Guarded Remote Access** — Remote clients can create and update tasks, ping heartbeats (`/dsh-cron/api/heartbeat/:id`), and preview schedules (`/dsh-cron/api/schedule/preview`) with valid `Authorization: Bearer <token>` credentials without loopback IP restrictions.
 
 ```bash
 BASE="http://127.0.0.1:3080"
@@ -387,6 +389,8 @@ Developer-facing, no behaviour change. `parseScheduleExpression` was split into
 - **Priority Queues & Concurrency Pools**: When the concurrent run limit is reached, queued tasks are ordered by `priority` (1 = highest, 10 = lowest) to ensure critical system alerts execute ahead of bulk background jobs.
 - **Self-Healing Runbooks & Auto-Diagnosis**: Failed tasks automatically execute an optional compensatory `selfHealingCommand` (e.g. system service restart or temp cleanup). Model failures can trigger `autoDiagnose: true` to append an instant root-cause diagnosis.
 - **Web UI Archive & Pipeline Visualization**: Interactive archive drawer with pagination and full log viewing; visual indicators for `➜ onSuccess` and `↳ onFailure` task connections.
+- **Shell & Disk Pre-flight Gate Hardening**: Supports both `command` and `shell` types with fail-closed semantics for invalid syntax, unknown types, or inspection failures. Disk space checks support exact path and threshold syntax (e.g. `/:10%`, `/data:500MB`).
+- **Complete Reliability Field Persistence**: HTTP POST task creation/editing and `cron_create_task` tool fully preserve and store all 13 reliability and session configuration fields (`agentPreset`, `targetSessionId`, `targetSessionReset`, `onSuccess`, `onFailure`, `heartbeatIntervalSeconds`, `gracePeriodSeconds`, `preflightType`, `preflightTarget`, `priority`, `concurrencyGroup`, `selfHealingCommand`, `autoDiagnose`, `fallbackProvider`, `fallbackModel`, `silentRule`, `inspectOnFailure`).
 
 ---
 
@@ -448,6 +452,7 @@ Developer-facing, no behaviour change. `parseScheduleExpression` was split into
 - **Modular Client Architecture (#150)**: Decomposed monolithic `lib/client.js` (~3950 lines) into 14 focused, single-responsibility fragments under `lib/client-src/` (none exceeding 580 lines). Integrated zero-dependency build script `scripts/build-client.mjs` wired into `package.json` (`build:client`, `pretest`). Development fragments are excluded from npm distribution via `"files": ["lib/*.js", ...]`.
 - **DSH Theme Tokens & Visual Standardization (#149)**: Replaced inline styles on task type badges (`onSuccess`, `onFailure`, `heartbeat`, `targetSession`, `preflight`) with dedicated `.dsh-cron-tag-*` CSS classes powered by semantic `--dsh-cron-*` theme variables. Modal overlay now adapts dynamically using `var(--dsw-alias-bg-mask, rgba(0, 0, 0, 0.75))`, and keyframe pulse animations use theme variables without hardcoded RGBA.
 - **Label Governance & Triage Audit (#95)**: Standardized 100% of repository issues and triage on the canonical repo-level label set.
+- **Style Self-Healing on Dynamic DOM Sweeps (#263 / GH-4)**: Watches `<head>` and `<html>` via `MutationObserver` alongside a 2s backstop interval and `visibilitychange` listener (`startStyleSelfHeal`), automatically re-attaching or repairing the `<style id="dsh-cron-styles">` tag if swept by host head re-renders, theme switches, or neighbor cleanups.
 
 ---
 

package/README.ru.md

@@ -256,6 +256,8 @@ cron({
 - **Очереди с приоритетами**: При достижении лимита параллелизма задачи упорядочиваются по полю `priority` (1 — наивысший, 10 — низший).
 - **Команды самоисцеления и авто-диагностика (Self-Healing)**: Автоматический запуск компенсирующей команды `selfHealingCommand` при падении задачи; опция `autoDiagnose` для генерации AI-диагностики причин сбоя.
 - **Интерактивный архив логов в UI**: Модальное окно просмотра истории с пагинацией и полным выводом логов, визуальные ссылки конвейеров `➜ onSuccess` и `↳ onFailure`.
+- **Безопасные preflight-проверки shell и диска**: Поддержка типов проверок `command` и `shell` с принципом fail-closed при синтаксических ошибках или сбоях проверки. Проверка диска поддерживает явные пути и пороговые значения (например, `/:10%`, `/data:500MB`).
+- **Полное сохранение параметров надёжности**: Создание и редактирование задач через HTTP POST и агентский инструмент `cron_create_task` полностью сохраняют все 13 полей надёжности и управления сессиями (`agentPreset`, `targetSessionId`, `targetSessionReset`, `onSuccess`, `onFailure`, `heartbeatIntervalSeconds`, `gracePeriodSeconds`, `preflightType`, `preflightTarget`, `priority`, `concurrencyGroup`, `selfHealingCommand`, `autoDiagnose`, `fallbackProvider`, `fallbackModel`, `silentRule`, `inspectOnFailure`).
 
 ---
 
@@ -317,6 +319,7 @@ cron({
 - **Модульная архитектура клиентской части (#150)**: Монолитный файл `lib/client.js` (~3950 строк) декомпозирован на 14 независимых специализированных модулей в каталоге `lib/client-src/` (каждый строго <= 580 строк). Сборка `lib/client.js` выполняется легковесным скриптом `scripts/build-client.mjs` перед запуском тестов и сборки. Исходные фрагменты исключены из npm-дистрибутива через `"files": ["lib/*.js", ...]`.
 - **Семантические токены тем DSH (#149)**: Инлайн-стили тегов типа задач (`onSuccess`, `onFailure`, `heartbeat`, `targetSession`, `preflight`) переведены на выделенные CSS-классы `.dsh-cron-tag-*` на базе переменных темы `--dsh-cron-*`. Оверлей модальных окон переведен на адаптивную маску `var(--dsw-alias-bg-mask, rgba(0, 0, 0, 0.75))`, а анимация пульсации избавлена от захардкоженных значений RGBA.
 - **Аудит меток репозитория (#95)**: Подтверждена 100% консистентность использования канонического репозиторного набора меток и фильтрации задач.
+- **Самовосстановление стилей при динамических перерисовках DOM (#263 / GH-4)**: Отслеживает `<head>` и `<html>` через `MutationObserver`, резервный интервал 2с и событие `visibilitychange` (`startStyleSelfHeal`), мгновенно восстанавливая узел `<style id="dsh-cron-styles">` при перерисовке заголовка хостом, смене темы или очистке соседними модулями.
 
 ---
 
@@ -378,6 +381,7 @@ dsh-cron:
 ### 14. Мониторинг heartbeat (dead man's switch)
 * Задайте `heartbeatUrl` и `heartbeatIntervalSec` в настройках плагина — планировщик будет пинговать этот адрес по расписанию, и внешний монитор сообщит, когда пинги прекратятся.
 * Встроенный эндпоинт `GET /dsh-cron/heartbeat` сообщает живость, число активных задач и время последнего запуска для ваших собственных сторожей.
+* **Оповещения о пропущенных heartbeat в режиме `onlyOnFailure`** — Пропущенные heartbeat (`status === 'missed'`) распознаются как полноценное состояние сбоя во всех фильтрах отправки (`channels.js`, `telegram.js`, `integrations.js`), гарантируя своевременную отправку тревог в Telegram, Discord, Webhook и Kanban при отсутствии отчётов от внешних служб.
 
 ### 15. Задачи из конфига профиля (#50)
 Долгоживущие эксплуатационные задачи можно объявлять в конфиге профиля, а не пересоздавать руками в интерфейсе. Владелец объявленных задач — файл конфига: при каждом старте плагина они создаются или обновляются, а задача, исчезнувшая из файла, удаляется.
@@ -427,6 +431,7 @@ dsh-cron:
 | `POST` | `/dsh-cron/api/tasks/:id/run` | Принудительный немедленный запуск |
 
 Операции переиспользуют обработчики панели, поэтому гейт `x-dsh-cron-confirm: script` для код-исполняющих типов и отказ `409` для конфиг-задач действуют здесь так же, как в UI.
+* **Удалённый доступ по Bearer-токену** — Внешние клиенты с любого разрешённого IP могут создавать и обновлять задачи, отправлять heartbeat-сигналы (`/dsh-cron/api/heartbeat/:id`) и запрашивать предпросмотр расписания (`/dsh-cron/api/schedule/preview`) с валидным `Authorization: Bearer <token>`.
 
 ```bash
 BASE="http://127.0.0.1:3080"

package/README.zh.md

@@ -237,6 +237,7 @@ cron({
 ### 14. 心跳监控（Dead man's switch）
 * 在插件设置中配置 `heartbeatUrl` 与 `heartbeatIntervalSec`，调度器会按间隔 GET 该地址 —— 外部监控可在心跳停止时告警。
 * 内置 `GET /dsh-cron/heartbeat` 端点返回存活状态、活跃任务数与最近运行时间，便于自建看门狗。
+* **`onlyOnFailure` 模式支持心跳超时告警** — 遗漏心跳（`status === 'missed'`）在各通知渠道过滤判定（`channels.js`、`telegram.js`、`integrations.js`）中被统一视作失败状态，确保外部守护进程中断时 Telegram、Discord、Webhook 与看板即刻告警。
 
 ### 15. 来自配置的声明式任务（#50）
 长期运行的任务可以直接声明在配置文件里，而无需在界面中手工重建。配置文件拥有这些任务：每次插件启动时会创建或更新它们，从文件中消失的任务会被删除。
@@ -286,6 +287,7 @@ dsh-cron:
 | `POST` | `/dsh-cron/api/tasks/:id/run` | 强制执行一次 |
 
 这些操作复用面板处理器，因此对会执行代码类型的 `x-dsh-cron-confirm: script` 门禁以及对配置任务的 `409` 拒绝与 UI 完全一致。
+* **Bearer Token 远程访问支持** — 远程客户端凭有效 `Authorization: Bearer <token>` 凭据可直接创建/修改任务、打卡心跳（`/dsh-cron/api/heartbeat/:id`）及预览调度（`/dsh-cron/api/schedule/preview`），解除非本机限制。
 
 ```bash
 BASE="http://127.0.0.1:3080"
@@ -379,6 +381,8 @@ bash deploy.sh verify [exact-version]
 - **优先级队列与并发池（Priority Queues）**：并发满载时，等待队列严格依据任务 `priority`（1 最高，10 最低）调度。
 - **自愈脚本与 AI 根因诊断（Self-Healing）**：任务失败后自动执行补偿指令 `selfHealingCommand`（例如重启服务或清理临时空间）；`autoDiagnose` 自动生成 AI 故障根因摘要。
 - **UI 交互式归档与管道全景**：支持分页浏览任务历史运行全量输出，直观展示 `➜ 成功触发` 与 `↳ 失败触发` 关联关系。
+- **Shell 与磁盘前置检查强化**：前置检查统一支持 `command` 与 `shell` 类型，未知类型或异常格式一律安全关闭（fail-closed）；磁盘检查支持完整路径与阈值（如 `/:10%`、`/data:500MB`）。
+- **可靠性与会话字段完整持久化**：HTTP POST 任务创建/修改接口与 `cron_create_task` 智能体工具完整保留并存储全部 13 个可靠性与会话高级字段（`agentPreset`、`targetSessionId`、`targetSessionReset`、`onSuccess`、`onFailure`、`heartbeatIntervalSeconds`、`gracePeriodSeconds`、`preflightType`、`preflightTarget`、`priority`、`concurrencyGroup`、`selfHealingCommand`、`autoDiagnose`、`fallbackProvider`、`fallbackModel`、`silentRule`、`inspectOnFailure`）。
 
 ---
 
@@ -440,6 +444,7 @@ bash deploy.sh verify [exact-version]
 - **客户端模块化架构 (#150)**: 将庞大的单文件 `lib/client.js` (约 3950 行) 拆分为 `lib/client-src/` 下的 14 个高内聚模块文件 (各模块严格 <= 580 行)。集成零依赖构建脚本 `scripts/build-client.mjs` 并接入 `package.json` (`build:client`, `pretest`)，通过 `"files": ["lib/*.js", ...]` 避免开发源码冗余打包进 npm 发布包。
 - **DSH 语义化主题变量对齐 (#149)**: 将任务类型标签 (`onSuccess`, `onFailure`, `heartbeat`, `targetSession`, `preflight`) 的内联样式全部替换为基于主题变量的 `.dsh-cron-tag-*` 类；模态框遮罩层接入自适应主题遮罩变量 `var(--dsw-alias-bg-mask, rgba(0, 0, 0, 0.75))`，移除脉冲动画关键帧中的硬编码 RGBA。
 - **标签治理与工单审计 (#95)**: 审计并确认全仓库 100% 统一规范使用仓库级标签集。
+- **动态 DOM 清理下的样式自动恢复（#263 / GH-4）**: 通过 `MutationObserver`、2 秒兜底定时器与 `visibilitychange` 事件（`startStyleSelfHeal`）监听 `<head>` 与 `<html>`，当宿主重绘 `<head>`、切换主题或邻近插件清理样式时，自动重新注入并修复 `<style id="dsh-cron-styles">` 标签。
 
 ---
 

package/lib/api-helpers.js

@@ -3,12 +3,12 @@ import { sendJson, readBody, rejectCrossOrigin } from './http-utils.js';
 
 const NOT_ALLOWED = { ok: false, error: 'Method not allowed' };
 
-export function handleHeartbeatPing({ store, req, res, taskId }) {
+export function handleHeartbeatPing({ store, req, res, taskId, apiToken: explicitToken }) {
   if (req.method !== 'POST') {
     sendJson(res, 405, NOT_ALLOWED);
     return;
   }
-  const apiToken = store?.getSettings?.()?.apiToken;
+  const apiToken = explicitToken || store?.getSettings?.()?.apiToken;
   if (rejectCrossOrigin(req, res, { apiToken })) return;
 
   const task = store.get(taskId);
@@ -24,8 +24,8 @@ export function handleHeartbeatPing({ store, req, res, taskId }) {
   sendJson(res, 200, result);
 }
 
-export async function handleSchedulePreview({ req, res, url, store }) {
-  const apiToken = store?.getSettings?.()?.apiToken;
+export async function handleSchedulePreview({ req, res, url, store, apiToken: explicitToken }) {
+  const apiToken = explicitToken || store?.getSettings?.()?.apiToken;
   if (rejectCrossOrigin(req, res, { apiToken })) return;
 
   let schedule = '';

package/lib/api.js

@@ -484,6 +484,19 @@ function mergeExecutionFields(current, body, parsed) {
     dailyCostLimitUsd: body.dailyCostLimitUsd !== undefined ? (body.dailyCostLimitUsd === null ? null : (Number(body.dailyCostLimitUsd) > 0 ? Number(body.dailyCostLimitUsd) : null)) : (current ? current.dailyCostLimitUsd : undefined),
     tokenLimit: body.tokenLimit !== undefined ? (body.tokenLimit === null ? null : (Number(body.tokenLimit) > 0 ? Number(body.tokenLimit) : null)) : (current ? current.tokenLimit : undefined),
     pausedReason: body.pausedReason !== undefined ? (body.pausedReason ? String(body.pausedReason) : null) : (current ? current.pausedReason : undefined),
+    agentPreset: body.agentPreset !== undefined ? String(body.agentPreset).trim() : (current ? (current.agentPreset || '') : ''),
+    targetSessionId: body.targetSessionId !== undefined ? String(body.targetSessionId).trim() : (current ? (current.targetSessionId || '') : ''),
+    targetSessionReset: body.targetSessionReset !== undefined ? String(body.targetSessionReset).trim() : (current ? (current.targetSessionReset || 'never') : 'never'),
+    onSuccess: body.onSuccess !== undefined ? String(body.onSuccess).trim() : (current ? (current.onSuccess || '') : ''),
+    onFailure: body.onFailure !== undefined ? String(body.onFailure).trim() : (current ? (current.onFailure || '') : ''),
+    heartbeatIntervalSeconds: body.heartbeatIntervalSeconds !== undefined ? Number(body.heartbeatIntervalSeconds) : (current ? (Number(current.heartbeatIntervalSeconds) || 0) : 0),
+    gracePeriodSeconds: body.gracePeriodSeconds !== undefined ? Number(body.gracePeriodSeconds) : (current ? (Number(current.gracePeriodSeconds) || 300) : 300),
+    preflightType: body.preflightType !== undefined ? String(body.preflightType).trim().toLowerCase() : (current ? (current.preflightType || 'none') : 'none'),
+    preflightTarget: body.preflightTarget !== undefined ? String(body.preflightTarget).trim() : (current ? (current.preflightTarget || '') : ''),
+    priority: body.priority !== undefined ? (Number(body.priority) || 5) : (current ? (Number(current.priority) || 5) : 5),
+    concurrencyGroup: body.concurrencyGroup !== undefined ? String(body.concurrencyGroup).trim() : (current ? (current.concurrencyGroup || 'default') : 'default'),
+    selfHealingCommand: body.selfHealingCommand !== undefined ? String(body.selfHealingCommand).trim() : (current ? (current.selfHealingCommand || '') : ''),
+    autoDiagnose: body.autoDiagnose !== undefined ? Boolean(body.autoDiagnose) : (current ? Boolean(current.autoDiagnose) : false),
   };
 }
 
@@ -495,14 +508,14 @@ function mergeExecutionFields(current, body, parsed) {
  * and reuses the handlers above, so the confirmation gate for code-executing
  * tasks and the config-owned refusals are the same code, not a second copy.
  */
-export async function handleExternalTaskRequest({ store, scheduler, req, res, url }) {
+export async function handleExternalTaskRequest({ store, scheduler, req, res, url, apiToken }) {
   const parts = url.pathname.split('/').filter(Boolean); // dsh-cron, api, [tasks|heartbeat|schedule], :id?, :action?
   if (parts[2] === 'heartbeat' && parts[3]) {
-    handleHeartbeatPing({ store, req, res, taskId: parts[3] });
+    handleHeartbeatPing({ store, req, res, taskId: parts[3], apiToken });
     return;
   }
   if (parts[2] === 'schedule' && parts[3] === 'preview') {
-    await handleSchedulePreview({ req, res, url });
+    await handleSchedulePreview({ req, res, url, store, apiToken });
     return;
   }
   const id = parts[3];
@@ -517,7 +530,7 @@ export async function handleExternalTaskRequest({ store, scheduler, req, res, ur
       return;
     }
     if (req.method === 'POST') {
-      await createOrUpdateTask({ store, scheduler, req, res });
+      await createOrUpdateTask({ store, scheduler, req, res, apiToken });
       return;
     }
     sendJson(res, 405, NOT_ALLOWED);
@@ -525,7 +538,7 @@ export async function handleExternalTaskRequest({ store, scheduler, req, res, ur
   }
 
   if (req.method === 'POST') {
-    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action });
+    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action, apiToken });
     if (handled) return;
   }
   if (req.method === 'GET' && !action) {

package/lib/channels.js

@@ -15,7 +15,8 @@ export const CHANNEL_IDS = ['telegram', 'kanban', 'discord', 'slack', 'ntfy', 'b
 
 // CHANNEL_LABELS removed (#155) — localized via lib/client.js
 
-const isFailed = (status) => status === 'error' || status === 'timeout';
+export const isFailureStatus = (status) => status === 'error' || status === 'timeout' || status === 'missed';
+export const isFailed = (status) => isFailureStatus(status);
 
 /** The message text for a channel: custom template, else built-in defaults. */
 function messageTextFor(channelId, task, runInfo, settings = {}) {

package/lib/client.js

@@ -847,17 +847,63 @@ window.__ModuleLoader__.load({
       }
     `;
 
+    const STYLE_ID = 'dsh-cron-styles';
+
     function ensureStyles() {
-      if (typeof document === 'undefined') return;
-      let el = document.getElementById('dsh-cron-styles');
-      if (!el) {
+      if (typeof document === 'undefined') return null;
+      let el = document.getElementById(STYLE_ID);
+      if (el === null) {
+        const head = document.head || document.documentElement;
+        if (!head) return null;
         el = document.createElement('style');
-        el.id = 'dsh-cron-styles';
+        el.id = STYLE_ID;
         // Mark ownership before insertion so neighbor cleanups leave it alone (#91)
         el.dataset.dshPlugin = 'dsh-cron';
-        document.head.appendChild(el);
+        el.textContent = STYLES;
+        head.appendChild(el);
+        return el;
       }
-      el.textContent = STYLES;
+      if (el.textContent !== STYLES) el.textContent = STYLES;
+      return el;
+    }
+
+    // Registry is shared across hot reloads so the newest instance owns exactly
+    // one watcher instead of stacking one per module evaluation.
+    const STYLE_HEAL_KEY = '__dshCronStyleHeal';
+    const STYLE_HEAL_INTERVAL_MS = 2000;
+
+    /**
+     * Keep the stylesheet attached: watch <head> (and <html>, which catches a
+     * replaced <head>) and re-attach on demand, with a slow interval as the
+     * backstop. heal() is idempotent and writes nothing while healthy.
+     */
+    function startStyleSelfHeal() {
+      if (typeof document === 'undefined') return () => {};
+      if (typeof window !== 'undefined' && typeof window[STYLE_HEAL_KEY] === 'function') {
+        try { window[STYLE_HEAL_KEY](); } catch (_err) { void _err; }
+      }
+      const heal = () => { try { ensureStyles(); } catch (_err) { void _err; } };
+      heal();
+      let observer = null;
+      try {
+        if (typeof MutationObserver === 'function') {
+          observer = new MutationObserver(heal);
+          if (document.head) observer.observe(document.head, { childList: true });
+          if (document.documentElement) observer.observe(document.documentElement, { childList: true });
+        }
+      } catch (_err) { observer = null; }
+      let timer = null;
+      try { timer = setInterval(heal, STYLE_HEAL_INTERVAL_MS); } catch (_err) { timer = null; }
+      const onVisibility = () => { if (document.visibilityState !== 'hidden') heal(); };
+      try { document.addEventListener('visibilitychange', onVisibility); } catch (_err) { void _err; }
+      const stop = () => {
+        try { if (observer) observer.disconnect(); } catch (_err) { void _err; }
+        try { if (timer !== null) clearInterval(timer); } catch (_err) { void _err; }
+        try { document.removeEventListener('visibilitychange', onVisibility); } catch (_err) { void _err; }
+        if (typeof window !== 'undefined' && window[STYLE_HEAL_KEY] === stop) window[STYLE_HEAL_KEY] = undefined;
+      };
+      if (typeof window !== 'undefined') window[STYLE_HEAL_KEY] = stop;
+      return stop;
     }
 
     function createErrorBoundary() {
@@ -4014,6 +4060,9 @@ window.__ModuleLoader__.load({
 
       const applyActive = () => {
         if (toggle.isOpen()) {
+          // Repair a dropped stylesheet before the panel paints, so opening the
+          // screen never shows an unstyled page (see startStyleSelfHeal).
+          ensureStyles();
           document.documentElement.setAttribute(ACTIVE_ATTR, '');
           document.dispatchEvent(new CustomEvent(ACTIVATE_EVENT, { detail: PANEL }));
         } else {
@@ -4070,7 +4119,7 @@ window.__ModuleLoader__.load({
     }
 
     function apply(ctx) {
-      ensureStyles();
+      const stopStyleSelfHeal = startStyleSelfHeal();
 
       // Register the English canonical strings; rebinding the translator lets
       // the translation plugin drive the active language at runtime (#87).
@@ -4158,7 +4207,7 @@ window.__ModuleLoader__.load({
           mountSidebarJobs(toggle, translate('sidebar.jobsTitle'), (taskId) => { pendingTaskHighlight = taskId; }),
           mountCronScreen(ctx, toggle)
         ];
-        return () => { for (const dispose of off) dispose(); };
+        return () => { for (const dispose of off) dispose(); stopStyleSelfHeal(); };
       }, 'dsh-cron: client overlay');
 
       exports.slots = { card: cardSlot, chip: chipSlot };

package/lib/cron-tool.js

@@ -251,6 +251,60 @@ export const cronToolParameters = {
     type: 'number',
     description: 'Maximum allowed token usage before auto-pausing',
   },
+  agentPreset: {
+    type: 'string',
+    description: 'Agent preset name applied to the task session',
+  },
+  targetSessionId: {
+    type: 'string',
+    description: 'Persistent session ID for context continuity',
+  },
+  targetSessionReset: {
+    type: 'string',
+    enum: ['never', 'daily', 'weekly'],
+    description: 'Context rotation policy for target session: never | daily | weekly',
+  },
+  onSuccess: {
+    type: 'string',
+    description: 'Task ID to trigger on successful run',
+  },
+  onFailure: {
+    type: 'string',
+    description: 'Task ID to trigger on failed run',
+  },
+  heartbeatIntervalSeconds: {
+    type: 'number',
+    description: 'Expected heartbeat interval in seconds (0 = disabled)',
+  },
+  gracePeriodSeconds: {
+    type: 'number',
+    description: 'Grace period before alerting on missed heartbeat',
+  },
+  preflightType: {
+    type: 'string',
+    enum: ['none', 'http', 'shell', 'command', 'disk'],
+    description: 'Pre-flight health check type: none | http | shell | disk',
+  },
+  preflightTarget: {
+    type: 'string',
+    description: 'Pre-flight check target: URL, shell command, or path:minPercent / path:minMb',
+  },
+  concurrencyGroup: {
+    type: 'string',
+    description: 'Named concurrency group to serialize related tasks',
+  },
+  priority: {
+    type: 'number',
+    description: 'Task priority (1 = highest, 10 = lowest, default 5)',
+  },
+  selfHealingCommand: {
+    type: 'string',
+    description: 'Shell command executed to recover from run failure',
+  },
+  autoDiagnose: {
+    type: 'boolean',
+    description: 'Automatically run AI failure diagnosis and store in runbook',
+  },
 };
 
 export const cronToolOutput = {

package/lib/external-api.js

@@ -66,7 +66,7 @@ export function createExternalApiHandler({ store, scheduler, getToken }) {
     // for example) surfaces as a thrown error from the shared handlers, and an
     // unhandled rejection here would answer nothing at all.
     try {
-      await handleExternalTaskRequest({ store, scheduler, req, res, url });
+      await handleExternalTaskRequest({ store, scheduler, req, res, url, apiToken: expected });
     } catch (err) {
       sendJson(res, (err && err.statusCode) || 500, { ok: false, error: (err && err.message) || String(err) });
     }

package/lib/integrations.js

@@ -91,7 +91,7 @@ export function shouldCreateKanbanCard(task, runInfo) {
   if (mode === 'none') return false;
   if (mode === 'always') return true;
   if (mode === 'on_failure') {
-    return runInfo.status === 'error' || runInfo.status === 'timeout';
+    return runInfo.status === 'error' || runInfo.status === 'timeout' || runInfo.status === 'missed';
   }
   return false;
 }

package/lib/scheduler-execution.js

@@ -24,12 +24,21 @@ export function addUsage(a, b) {
  * Execute pre-flight check gate before running task body.
  */
 export async function executePreflight(task) {
-  const type = String(task.preflightType || 'none').toLowerCase();
+  const type = String(task.preflightType || 'none').trim().toLowerCase();
   const target = String(task.preflightTarget || '').trim();
-  if (!type || type === 'none' || !target) {
+  if (!type || type === 'none') {
     return { ok: true };
   }
 
+  const KNOWN_PREFLIGHT_TYPES = ['http', 'command', 'shell', 'disk'];
+  if (!KNOWN_PREFLIGHT_TYPES.includes(type)) {
+    return { ok: false, reason: `Unknown preflight type "${type}"` };
+  }
+
+  if (!target) {
+    return { ok: false, reason: `Preflight target is required for type "${type}"` };
+  }
+
   if (type === 'http') {
     try {
       const controller = new AbortController();
@@ -43,7 +52,7 @@ export async function executePreflight(task) {
     }
   }
 
-  if (type === 'command') {
+  if (type === 'command' || type === 'shell') {
     return new Promise((resolve) => {
       exec(target, { timeout: 5000 }, (err, stdout, stderr) => {
         if (err) {
@@ -56,23 +65,49 @@ export async function executePreflight(task) {
   }
 
   if (type === 'disk') {
-    const requiredMb = Number(target) || 100;
+    let diskPath = task.cwd || process.cwd();
+    let requirement = target;
+
+    // Check for "path:requirement", taking care not to split Windows drive letters (e.g. C:\:10%)
+    const lastColon = target.lastIndexOf(':');
+    if (lastColon > 0) {
+      const candidatePath = target.slice(0, lastColon).trim();
+      const candidateReq = target.slice(lastColon + 1).trim();
+      if (candidateReq) {
+        diskPath = candidatePath;
+        requirement = candidateReq;
+      }
+    }
+
+    const isPercent = requirement.endsWith('%');
+    const numericVal = parseFloat(requirement);
+    if (isNaN(numericVal) || numericVal <= 0) {
+      return { ok: false, reason: `Invalid preflight disk target requirement: "${requirement}"` };
+    }
+
     try {
-      if (typeof fs.statfsSync === 'function') {
-        const stats = fs.statfsSync(process.cwd());
+      if (typeof fs.statfsSync !== 'function') {
+        return { ok: false, reason: 'statfsSync is not available on this platform' };
+      }
+      const stats = fs.statfsSync(diskPath);
+      if (isPercent) {
+        const freePercent = stats.blocks > 0 ? (stats.bavail / stats.blocks) * 100 : 0;
+        if (freePercent < numericVal) {
+          return { ok: false, reason: `Free disk space on "${diskPath}" (${freePercent.toFixed(1)}%) is below required ${numericVal}%` };
+        }
+      } else {
         const freeMb = Math.round((stats.bavail * stats.bsize) / (1024 * 1024));
-        if (freeMb < requiredMb) {
-          return { ok: false, reason: `Free disk space (${freeMb} MB) is below required ${requiredMb} MB` };
+        if (freeMb < numericVal) {
+          return { ok: false, reason: `Free disk space on "${diskPath}" (${freeMb} MB) is below required ${numericVal} MB` };
         }
       }
       return { ok: true };
     } catch (err) {
-      // Fail-open if statfsSync is unavailable or throws
-      return { ok: true };
+      return { ok: false, reason: `Preflight disk check failed: filesystem "${diskPath}" not accessible (${err.message})` };
     }
   }
 
-  return { ok: true };
+  return { ok: false, reason: `Unsupported preflight type "${type}"` };
 }
 
 /** Only agent-mediated types use a model, and only a failed run falls back. */

package/lib/task-create.js

@@ -18,6 +18,23 @@ export function executeCreateTask(store, scheduler, args) {
     status: 'active',
     provider: args.provider,
     model: args.model,
+    fallbackProvider: args.fallbackProvider ? String(args.fallbackProvider).trim() : undefined,
+    fallbackModel: args.fallbackModel ? String(args.fallbackModel).trim() : undefined,
+    silentRule: args.silentRule !== undefined ? String(args.silentRule) : '',
+    inspectOnFailure: args.inspectOnFailure !== undefined ? Boolean(args.inspectOnFailure) : false,
+    agentPreset: args.agentPreset ? String(args.agentPreset).trim() : '',
+    targetSessionId: args.targetSessionId ? String(args.targetSessionId).trim() : '',
+    targetSessionReset: args.targetSessionReset ? String(args.targetSessionReset).trim() : 'never',
+    onSuccess: args.onSuccess ? String(args.onSuccess).trim() : '',
+    onFailure: args.onFailure ? String(args.onFailure).trim() : '',
+    heartbeatIntervalSeconds: Number(args.heartbeatIntervalSeconds) || 0,
+    gracePeriodSeconds: Number(args.gracePeriodSeconds) || 300,
+    preflightType: args.preflightType ? String(args.preflightType).trim().toLowerCase() : 'none',
+    preflightTarget: args.preflightTarget ? String(args.preflightTarget).trim() : '',
+    concurrencyGroup: args.concurrencyGroup ? String(args.concurrencyGroup).trim() : 'default',
+    priority: Number(args.priority) || 5,
+    selfHealingCommand: args.selfHealingCommand ? String(args.selfHealingCommand).trim() : '',
+    autoDiagnose: Boolean(args.autoDiagnose),
     notifyTelegram: Boolean(args.notifyTelegram),
     onlyOnFailure: Boolean(args.onlyOnFailure),
     timeoutSeconds: Number(args.timeoutSeconds) || 1800,

package/lib/task-patch.js

@@ -27,8 +27,8 @@ export function isCodeExecutionIntroduced(current, body) {
   if (!current || !body) return false;
   if (body.type !== undefined && isCodeTypeSwitch(current, body.type)) return true;
 
-  const hadPreflight = Boolean(current.preflightCommand && String(current.preflightCommand).trim()) || current.preflightType === 'command';
-  const hasPreflight = Boolean(body.preflightCommand && String(body.preflightCommand).trim()) || body.preflightType === 'command';
+  const hadPreflight = Boolean(current.preflightCommand && String(current.preflightCommand).trim()) || current.preflightType === 'command' || current.preflightType === 'shell';
+  const hasPreflight = Boolean(body.preflightCommand && String(body.preflightCommand).trim()) || body.preflightType === 'command' || body.preflightType === 'shell';
   if (hasPreflight && !hadPreflight) return true;
 
   const hadSelfHealing = Boolean(current.selfHealingCommand && String(current.selfHealingCommand).trim());

package/lib/task-transfer.js

@@ -228,7 +228,7 @@ export function isCodeExecutingTask(task) {
   const CODE_TYPES = ['script', 'node', 'python', 'ssh', 'docker'];
   if (CODE_TYPES.includes(normalizeTaskType(task.type))) return true;
   if (task.command && String(task.command).trim()) return true;
-  if (task.preflightType === 'command' || (task.preflightCommand && String(task.preflightCommand).trim())) return true;
+  if (task.preflightType === 'command' || task.preflightType === 'shell' || (task.preflightCommand && String(task.preflightCommand).trim())) return true;
   if (task.selfHealingCommand && String(task.selfHealingCommand).trim()) return true;
   if (task.preflightScript && String(task.preflightScript).trim()) return true;
   return false;

package/lib/telegram.js

@@ -210,7 +210,7 @@ export function shouldNotifyTask(task, runInfo, globalSettings = {}) {
   const isEnabled = task.notifyTelegram ?? globalSettings.notifyTelegram ?? false;
   if (!isEnabled) return false;
 
-  const failed = runInfo.status === 'error' || runInfo.status === 'timeout';
+  const failed = runInfo.status === 'error' || runInfo.status === 'timeout' || runInfo.status === 'missed';
   const onlyOnFail = task.onlyOnFailure ?? globalSettings.onlyOnFailure ?? false;
   if (onlyOnFail && !failed) {
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.36",
+  "version": "0.2.38",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",