@goodandready/dsh-cron 0.2.2 → 0.2.3

package/README.md

@@ -122,9 +122,21 @@ Powered by `croner`, supporting standard 5-field cron expressions plus user-frie
 * `*/15 * * * *` — every 15 minutes
 * `0 0 * * 0` — every Sunday at midnight
 * `every 10m` / `every 2h` / `every 30s` — natural duration intervals
-* `daily` / `hourly` / `weekdays` shortcuts
+* `daily` / `hourly` / `weekdays` shortcuts, plus standard `@hourly` / `@daily` / `@weekly` / `@monthly` / `@yearly` and `@every 30m`
+* **Per-task time zones** — set an IANA zone (e.g. `Europe/Berlin`) on a task; without it the schedule follows the server's local time
 * **One-shot tasks**: `at: 2026-09-05T15:00:00Z` (exact ISO timestamp) or relative delays `in 20m` / `in 2h` (Russian aliases such as `через 15 минут` are accepted too). One-shot tasks flip to `completed` automatically after their single run and are listed under the **Completed** tab.
 
+### 5. Execution Reliability
+* **Automatic retries** — set `maxRetries` and a base `retryBackoffMs` per task; failed runs (`error`/`timeout`) are retried with exponential backoff, and the attempt counter resets on success.
+* **Misfire policies** — choose per task what happens when the daemon was offline at a scheduled time: `skip` (default — record the gap), `runOnce` (execute once, late), or `catchUpAll` (run late and record the gap). A missed one-shot under `skip` is retired as `completed` instead of firing stale.
+* **Concurrency limit** — `maxConcurrent` (plugin setting) caps parallel runs; extra runs are recorded as `skipped` with a reason.
+* **Live execution indicator** — the task list shows a pulsing status icon and a running timer for the task in flight.
+
+### 6. Session Integration & Permissions
+* **Per-task permission presets** — `default`, `read-only`, `workspace-write`, or `full` are applied to the task's agent session before the prompt runs.
+* **Session auto-archive** — isolated cron sessions are archived after each run (best-effort) so they do not clutter the chat list.
+* **History → session navigation** — every LLM run records its session; open it straight from the run history entry.
+
 ### 5. Telegram Notifications & Delivery Routing
 Direct integration with the Telegram Bot API delivers execution reports and error traces straight to your messenger:
 
@@ -148,6 +160,10 @@ Prevent rogue processes from stacking concurrent duplicate executions:
 
 If the daemon was offline at a scheduled time, the run is recorded as `missed` on startup, so gaps in the history stay visible.
 
+### 8. 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.
+
 ---
 
 ## 📦 Installation
@@ -174,6 +190,10 @@ dsh-cron:
   notifyTelegram: false        # deliver reports for every task globally
   onlyOnFailure: false         # deliver reports only for failed runs
   kanbanBaseUrl: "http://127.0.0.1:3000"  # dsh-kanban HTTP API base URL
+  defaultTimezone: ""          # default IANA time zone for schedules (empty = server local)
+  maxConcurrent: 0             # max parallel task runs (0 = unlimited)
+  heartbeatUrl: ""             # dead man's snitch URL pinged on the heartbeat interval
+  heartbeatIntervalSec: 0      # heartbeat ping interval in seconds (0 = off)
 ```
 
 ### Configuration Parameters
@@ -185,6 +205,10 @@ dsh-cron:
 | `notifyTelegram` | `boolean` | `false` | Global switch: deliver run reports to Telegram |
 | `onlyOnFailure` | `boolean` | `false` | Global switch: deliver reports only for `error`/`timeout` runs |
 | `kanbanBaseUrl` | `string` | `"http://127.0.0.1:3000"` | Base URL of the `dsh-kanban` HTTP API used for automatic card creation |
+| `defaultTimezone` | `string` | `""` | Default IANA time zone for task schedules; empty = server local time |
+| `maxConcurrent` | `number` | `0` | Cap on parallel task runs; extra runs are recorded as `skipped` (0 = unlimited) |
+| `heartbeatUrl` | `string` | `""` | Dead man's snitch URL pinged every `heartbeatIntervalSec` while the scheduler is alive |
+| `heartbeatIntervalSec` | `number` | `0` | Heartbeat ping interval in seconds (0 = disabled) |
 
 Notes:
 
@@ -212,7 +236,8 @@ All endpoints are served by the DSH web server under `/dsh-cron/`. Read endpoint
 | `GET` | `/dsh-cron/models` | List LLM providers; `?provider=<id>` lists models |
 | `POST` | `/dsh-cron/chat/start` | Start a "Create with DSH" agent session with the task-setup instructions |
 | `GET` | `/dsh-cron/settings` | Client-safe settings (token masked) |
-| `POST` | `/dsh-cron/settings` | Update integration settings |
+| `POST` | `/dsh-cron/settings` | Update integration settings (applied through the settings service) |
+| `GET` | `/dsh-cron/heartbeat` | Liveness probe: active task count, last run time, server time |
 | `POST` | `/dsh-cron/telegram/test` | Send a Telegram test message |
 | `POST` | `/dsh-cron/kanban/test` | Create a Kanban connectivity-test card |
 | `*` | `/dsh-cron/action/:id/:action` | Legacy alias for the task action routes (`run`, `toggle`, `delete`, `history`) |

package/docs/README.ru.md

@@ -121,9 +121,21 @@ cron_create_task({
 * `*/15 * * * *` — каждые 15 минут
 * `0 0 * * 0` — каждое воскресенье в полночь
 * `every 10m` / `every 2h` / `every 30s` — естественные интервалы
-* алиасы `daily` / `hourly` / `weekdays` (`weekdays` → `0 9 * * 1-5`)
+* алиасы `daily` / `hourly` / `weekdays`, а также стандартные `@hourly` / `@daily` / `@weekly` / `@monthly` / `@yearly` и `@every 30m`
+* **Часовые пояса** — для задачи можно указать IANA-зону (например, `Europe/Berlin`); без неё расписание живёт в серверном времени
 * **Разовые задачи**: `at: 2026-09-05T15:00:00Z` (точный ISO-таймстемп) или относительные задержки `in 20m` / `in 2h` (принимаются и русские варианты вроде `через 15 минут`). После единственного запуска задача автоматически переходит в `completed` и отображается на табе **Завершённые**.
 
+### 5. Надёжность исполнения
+* **Автоповторы** — `maxRetries` и база `retryBackoffMs` на задачу: упавшие запуски (error/timeout) повторяются с экспоненциальной задержкой, счётчик сбрасывается после успеха.
+* **Misfire-политики** — что делать с пропущенным за время простоя запуском: `skip` (по умолчанию — записать пропуск), `runOnce` (выполнить один раз с опозданием) или `catchUpAll` (выполнить и зафиксировать пропуск). Пропущенный one-shot при `skip` уходит в `completed` без выполнения.
+* **Лимит параллельности** — настройка `maxConcurrent` ограничивает число одновременных запусков; лишние помечаются `skipped` с причиной.
+* **Живой индикатор** — в списке задач пульсирует статус и идёт таймер текущего запуска.
+
+### 6. Интеграция сессий и права
+* **Permission-пресеты на задачу** — `default`, `read-only`, `workspace-write` или `full` применяются к сессии агента перед запуском промпта.
+* **Автоархивация сессий** — изолированные cron-сессии архивируются после запуска (best-effort), не засоряя список чатов.
+* **История → сессия** — каждый LLM-запуск хранит свою сессию; открыть диалог можно прямо из записи истории.
+
 ### 5. Уведомления Telegram
 Прямая интеграция с Telegram Bot API доставляет отчёты о запусках и трейсы ошибок в мессенджер:
 
@@ -170,6 +182,10 @@ dsh-cron:
   notifyTelegram: false        # глобально отправлять отчёты о всех задачах
   onlyOnFailure: false         # отправлять отчёты только при сбоях
   kanbanBaseUrl: "http://127.0.0.1:3000"  # базовый URL HTTP API dsh-kanban
+  defaultTimezone: ""          # IANA-зона по умолчанию (пусто = серверное время)
+  maxConcurrent: 0             # максимум параллельных запусков (0 = без лимита)
+  heartbeatUrl: ""             # URL dead man's snitch, пингуется по интервалу
+  heartbeatIntervalSec: 0      # интервал heartbeat-пинга в секундах (0 = выключено)
 ```
 
 ### Параметры
@@ -181,11 +197,15 @@ dsh-cron:
 | `notifyTelegram` | `boolean` | `false` | Глобальный выключатель доставки отчётов в Telegram |
 | `onlyOnFailure` | `boolean` | `false` | Глобальный режим «только при сбоях» (`error`/`timeout`) |
 | `kanbanBaseUrl` | `string` | `"http://127.0.0.1:3000"` | Базовый URL HTTP API `dsh-kanban` для автоматических карточек |
+| `defaultTimezone` | `string` | `""` | IANA-зона по умолчанию для расписаний; пусто = серверное время |
+| `maxConcurrent` | `number` | `0` | Лимит параллельных запусков; лишние помечаются `skipped` (0 = без лимита) |
+| `heartbeatUrl` | `string` | `""` | URL dead man's snitch, пингуемый каждый `heartbeatIntervalSec`, пока жив планировщик |
+| `heartbeatIntervalSec` | `number` | `0` | Интервал heartbeat-пинга в секундах (0 = выключено) |
 
 Примечания:
 
 * История запусков ограничена **50 записями на задачу** (фиксировано); в записи хранится до 4000 символов вывода.
-* Задачи выполняются в **локальном часовом поясе сервера**; cron-выражения вычисляет `croner` по часам хоста.
+* Задачи выполняются в **локальном часовом поясе сервера**, если для задачи не указана своя IANA-зона; cron-выражения вычисляет `croner` по часам хоста.
 * Задачи сохраняются в каталоге данных DSH (`cron/tasks.json`) и переживают перезапуск; пропущенные one-shot запуски обнаруживаются при старте.
 
 ---
@@ -208,7 +228,8 @@ dsh-cron:
 | `GET` | `/dsh-cron/models` | Список LLM-провайдеров; `?provider=<id>` — модели |
 | `POST` | `/dsh-cron/chat/start` | Старт агентской сессии «Создать с DSH» с инструкциями планировщика |
 | `GET` | `/dsh-cron/settings` | Настройки для клиента (токен замаскирован) |
-| `POST` | `/dsh-cron/settings` | Обновление настроек интеграций |
+| `POST` | `/dsh-cron/settings` | Обновление настроек интеграций (через службу настроек) |
+| `GET` | `/dsh-cron/heartbeat` | Probe живости: число активных задач, время последнего запуска |
 | `POST` | `/dsh-cron/telegram/test` | Тестовое сообщение в Telegram |
 | `POST` | `/dsh-cron/kanban/test` | Тестовая карточка в Kanban |
 | `*` | `/dsh-cron/action/:id/:action` | Legacy-алиас действий над задачей (`run`, `toggle`, `delete`, `history`) |

package/docs/README.zh.md

@@ -121,9 +121,16 @@ cron_create_task({
 * `*/15 * * * *` —— 每 15 分钟
 * `0 0 * * 0` —— 每周日午夜
 * `every 10m` / `every 2h` / `every 30s` —— 自然语言间隔
-* `daily` / `hourly` / `weekdays` 快捷方式
+* `daily` / `hourly` / `weekdays` 快捷方式，以及标准 `@hourly` / `@daily` / `@weekly` / `@monthly` / `@yearly` 与 `@every 30m`
+* **任务级时区** —— 可为任务设置 IANA 时区（如 `Europe/Berlin`）；未设置时按服务器本地时间调度
 * **一次性任务**：`at: 2026-09-05T15:00:00Z`（精确 ISO 时间戳）或相对延时 `in 20m` / `in 2h`（也接受 `через 15 минут` 之类的俄语输入）。一次性任务在单次运行后自动转为 `completed`，显示在 **已完成** 标签下。
 
+### 5. 执行可靠性
+* **自动重试** —— 按任务设置 `maxRetries` 与基础 `retryBackoffMs`：失败（`error`/`timeout`）的运行按指数退避自动重试，成功后计数归零。
+* **Misfire 策略** —— 选择守护进程离线期间错过的运行如何处理：`skip`（默认 —— 记录缺口）、`runOnce`（迟执行一次）或 `catchUpAll`（迟执行并记录缺口）。`skip` 下错过的一次性任务直接转为 `completed`，不再过期触发。
+* **并发上限** —— 插件设置 `maxConcurrent` 限制并行运行数；超出的运行记录为 `skipped` 并附原因。
+* **实时执行指示** —— 任务列表中的脉冲状态图标与运行计时器。
+
 ### 5. Telegram 通知与投递路由
 通过与 Telegram Bot API 的直接集成，将执行报告与错误跟踪推送到你的即时通讯工具：
 
@@ -146,6 +153,10 @@ cron_create_task({
 
 如果守护进程在计划时刻处于离线状态，启动时该次运行会被记录为 `missed`，历史空档始终可见。
 
+### 8. 心跳监控（Dead man's switch）
+* 在插件设置中配置 `heartbeatUrl` 与 `heartbeatIntervalSec`，调度器会按间隔 GET 该地址 —— 外部监控可在心跳停止时告警。
+* 内置 `GET /dsh-cron/heartbeat` 端点返回存活状态、活跃任务数与最近运行时间，便于自建看门狗。
+
 ---
 
 ## 📦 安装
@@ -170,6 +181,10 @@ dsh-cron:
   notifyTelegram: false        # 全局投递所有任务的报告
   onlyOnFailure: false         # 仅失败时投递报告
   kanbanBaseUrl: "http://127.0.0.1:3000"  # dsh-kanban HTTP API 基础地址
+  defaultTimezone: ""          # 默认 IANA 时区（空 = 服务器本地）
+  maxConcurrent: 0             # 最大并行运行数（0 = 不限）
+  heartbeatUrl: ""             # 心跳上报 URL（dead man's snitch）
+  heartbeatIntervalSec: 0      # 心跳间隔秒数（0 = 关闭）
 ```
 
 ### 配置参数
@@ -181,6 +196,10 @@ dsh-cron:
 | `notifyTelegram` | `boolean` | `false` | 全局开关：向 Telegram 投递运行报告 |
 | `onlyOnFailure` | `boolean` | `false` | 全局开关：仅对 `error`/`timeout` 运行投递报告 |
 | `kanbanBaseUrl` | `string` | `"http://127.0.0.1:3000"` | 用于自动卡片的 `dsh-kanban` HTTP API 基础地址 |
+| `defaultTimezone` | `string` | `""` | 任务调度的默认 IANA 时区；空 = 服务器本地时间 |
+| `maxConcurrent` | `number` | `0` | 并行运行上限；超出的运行记录为 `skipped`（0 = 不限） |
+| `heartbeatUrl` | `string` | `""` | 心跳上报 URL，调度器存活期间按 `heartbeatIntervalSec` 间隔 GET |
+| `heartbeatIntervalSec` | `number` | `0` | 心跳间隔秒数（0 = 关闭） |
 
 说明：
 
@@ -208,7 +227,8 @@ dsh-cron:
 | `GET` | `/dsh-cron/models` | 列出 LLM 提供方；`?provider=<id>` 列出模型 |
 | `POST` | `/dsh-cron/chat/start` | 启动带任务配置指令的“由 DSH 创建”智能体会话 |
 | `GET` | `/dsh-cron/settings` | 客户端安全设置（令牌掩码显示） |
-| `POST` | `/dsh-cron/settings` | 更新集成设置 |
+| `POST` | `/dsh-cron/settings` | 更新集成设置（通过设置服务应用） |
+| `GET` | `/dsh-cron/heartbeat` | 存活探针：活跃任务数与最近运行时间 |
 | `POST` | `/dsh-cron/telegram/test` | 发送 Telegram 测试消息 |
 | `POST` | `/dsh-cron/kanban/test` | 创建 Kanban 连通性测试卡片 |
 | `*` | `/dsh-cron/action/:id/:action` | 任务操作路由的兼容别名（`run`、`toggle`、`delete`、`history`） |

package/lib/client.js

@@ -114,6 +114,20 @@ window.__ModuleLoader__.load({
         'form.promptLabelLlm': 'Instruction / Prompt for the agent',
         'form.promptPlaceholderScript': 'curl -fsSL https://... || exit 1',
         'form.promptPlaceholderLlm': 'Describe exactly what the agent should do...',
+        'form.timezoneLabel': 'Time zone (IANA, optional)',
+        'form.timezonePlaceholder': 'e.g. Europe/Berlin (empty = server local)',
+        'form.misfireLabel': 'On missed run (after downtime)',
+        'form.misfireSkip': 'Skip the missed run (skip)',
+        'form.misfireRunOnce': 'Run once late (runOnce)',
+        'form.misfireCatchUp': 'Run late once and record the gap (catchUpAll)',
+        'form.retriesLabel': 'Automatic retries on failure (0 = off)',
+        'form.permissionLabel': 'Session permissions',
+        'form.permissionDefault': 'Default (as configured in DSH)',
+        'form.permissionReadonly': 'Read-only',
+        'form.permissionWrite': 'Workspace write',
+        'form.permissionFull': 'Full',
+        'list.runningNow': 'Running now',
+        'history.openSession': 'Open session',
         'form.notifyTitle': 'Telegram notifications',
         'form.notifyTelegram': 'Send the run report to Telegram',
         'form.notifyOnlyFailure': 'Only on failures (onlyOnFailure / silent on success)',
@@ -363,6 +377,8 @@ window.__ModuleLoader__.load({
       .dsh-cron-status-banner[data-type="success"] { background: var(--dsh-cron-success-bg); border: 1px solid var(--dsh-cron-success); color: var(--dsh-cron-success); }
       .dsh-cron-status-banner[data-type="error"] { background: var(--dsh-cron-danger-bg); border: 1px solid var(--dsh-cron-danger); color: var(--dsh-cron-danger); }
       .dsh-cron-status-banner[data-type="info"] { background: var(--dsh-cron-info-bg); border: 1px solid var(--dsh-cron-info); color: var(--dsh-cron-info); }
+      @keyframes dsh-cron-pulse-ring { 0% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0.5); } 70% { box-shadow: 0 0 0 9px rgba(16, 185, 129, 0); } 100% { box-shadow: 0 0 0 0 rgba(16, 185, 129, 0); } }
+      .dsh-cron-pulse { animation: dsh-cron-pulse-ring 1.6s infinite; border-color: var(--dsh-cron-success); color: var(--dsh-cron-success); }
     `;
 
     function ensureStyles() {
@@ -484,8 +500,26 @@ window.__ModuleLoader__.load({
       const [formTimeoutSeconds, setFormTimeoutSeconds] = React.useState(1800);
       const [formOverlapPolicy, setFormOverlapPolicy] = React.useState('skip');
       const [formKanbanMode, setFormKanbanMode] = React.useState('none');
+      const [formTimezone, setFormTimezone] = React.useState('');
+      const [formMisfirePolicy, setFormMisfirePolicy] = React.useState('skip');
+      const [formMaxRetries, setFormMaxRetries] = React.useState(0);
+      const [formPermissionPreset, setFormPermissionPreset] = React.useState('default');
       const [stats, setStats] = React.useState(null);
 
+      // Live execution indicator (#35): a light 1s tick only while some task
+      // is actually running.
+      const tasksRef = React.useRef([]);
+      const [nowTick, setNowTick] = React.useState(0);
+      React.useEffect(() => {
+        tasksRef.current = tasks;
+      }, [tasks]);
+      React.useEffect(() => {
+        const tick = setInterval(() => {
+          if (tasksRef.current.some((t2) => t2.running)) setNowTick((v) => v + 1);
+        }, 1000);
+        return () => clearInterval(tick);
+      }, []);
+
       // Settings modal state
       const [settingsModalOpen, setSettingsModalOpen] = React.useState(false);
       const [settingsBotToken, setSettingsBotToken] = React.useState('');
@@ -684,6 +718,10 @@ window.__ModuleLoader__.load({
         setFormTimeoutSeconds(1800);
         setFormOverlapPolicy('skip');
         setFormKanbanMode('none');
+        setFormTimezone('');
+        setFormMisfirePolicy('skip');
+        setFormMaxRetries(0);
+        setFormPermissionPreset('default');
         if (preset) {
           setFormTitle(preset.title || '');
           setFormSchedule(preset.schedule || '');
@@ -734,6 +772,10 @@ window.__ModuleLoader__.load({
         setFormTimeoutSeconds(task.timeoutSeconds !== undefined ? task.timeoutSeconds : 1800);
         setFormOverlapPolicy(task.overlapPolicy || 'skip');
         setFormKanbanMode(task.kanbanMode || 'none');
+        setFormTimezone(task.timezone || '');
+        setFormMisfirePolicy(task.misfirePolicy || 'skip');
+        setFormMaxRetries(task.maxRetries !== undefined ? task.maxRetries : 0);
+        setFormPermissionPreset(task.permissionPreset || 'default');
         if (task.provider) loadModels(task.provider);
         else if (defaultModelInfo?.provider) loadModels(defaultModelInfo.provider);
         loadTaskHistory(task.id);
@@ -764,6 +806,10 @@ window.__ModuleLoader__.load({
             onlyOnFailure: formOnlyOnFailure,
             timeoutSeconds: Number(formTimeoutSeconds) || 1800,
             overlapPolicy: formOverlapPolicy,
+            timezone: formTimezone.trim(),
+            misfirePolicy: formMisfirePolicy,
+            maxRetries: Number(formMaxRetries) || 0,
+            permissionPreset: formPermissionPreset,
             kanbanMode: formKanbanMode,
           };
           // Cross-origin hardening: script tasks need the explicit confirm
@@ -940,7 +986,7 @@ window.__ModuleLoader__.load({
                   },
                     React.createElement('button', {
                       type: 'button',
-                      className: 'dsh-cron-task-status-btn',
+                      className: 'dsh-cron-task-status-btn' + (task.running ? ' dsh-cron-pulse' : ''),
                       'data-active': task.status === 'active' ? 'true' : undefined,
                       title: task.status === 'active' ? T_KEY(t, 'actions.pause') : T_KEY(t, 'actions.resume'),
                       'aria-label': task.status === 'active' ? T_KEY(t, 'actions.pause') : T_KEY(t, 'actions.resume'),
@@ -962,7 +1008,10 @@ window.__ModuleLoader__.load({
                       ),
                       React.createElement('div', { className: 'dsh-cron-task-sched' },
                         task.scheduleText || task.schedule,
-                        task.nextRunAt ? T_KEY(t, 'list.next', { time: new Date(task.nextRunAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) }) : ''
+                        task.nextRunAt ? T_KEY(t, 'list.next', { time: new Date(task.nextRunAt).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) }) : '',
+                        task.running && task.runningSince
+                          ? ' · ' + T_KEY(t, 'list.runningNow') + ' ' + Math.max(0, Math.round((Date.now() - task.runningSince) / 1000)) + 's'
+                          : ''
                       ),
                       task.prompt ? React.createElement('div', {
                         className: 'dsh-cron-task-prompt-preview',
@@ -1085,7 +1134,13 @@ window.__ModuleLoader__.load({
                         )
                       ),
                       run.output && React.createElement('div', { className: 'dsh-cron-history-output' }, run.output),
-                      run.error && React.createElement('div', { className: 'dsh-cron-history-output', style: { color: 'var(--dsh-cron-danger)', borderColor: 'var(--dsh-cron-danger-bg)' } }, run.error)
+                      run.error && React.createElement('div', { className: 'dsh-cron-history-output', style: { color: 'var(--dsh-cron-danger)', borderColor: 'var(--dsh-cron-danger-bg)' } }, run.error),
+                      run.sessionId && React.createElement('button', {
+                        type: 'button',
+                        className: 'dsh-cron-btn-secondary',
+                        style: { marginTop: '8px', fontSize: '12px', padding: '4px 10px' },
+                        onClick: () => openSession(ctx, run.sessionId)
+                      }, T_KEY(t, 'history.openSession'))
                     ))
                   ),
               React.createElement('div', { className: 'dsh-cron-modal-foot', style: { marginTop: '18px' } },
@@ -1157,7 +1212,52 @@ window.__ModuleLoader__.load({
                     )
                   )
                 ),
+                React.createElement('div', { className: 'dsh-cron-form-row' },
+                  React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, T_KEY(t, 'form.timezoneLabel')),
+                  React.createElement('input', {
+                    value: formTimezone,
+                    placeholder: T_KEY(t, 'form.timezonePlaceholder'),
+                    onChange: (e) => setFormTimezone(e.target.value)
+                  })
+                ),
                 React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, T_KEY(t, 'form.misfireLabel')),
+                  React.createElement('select', {
+                    value: formMisfirePolicy,
+                    onChange: (e) => setFormMisfirePolicy(e.target.value)
+                  },
+                    React.createElement('option', { value: 'skip' }, T_KEY(t, 'form.misfireSkip')),
+                    React.createElement('option', { value: 'runOnce' }, T_KEY(t, 'form.misfireRunOnce')),
+                    React.createElement('option', { value: 'catchUpAll' }, T_KEY(t, 'form.misfireCatchUp'))
+                  )
+                )
+              ),
+              React.createElement('div', { className: 'dsh-cron-form-row' },
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, T_KEY(t, 'form.retriesLabel')),
+                  React.createElement('input', {
+                    type: 'number',
+                    min: 0,
+                    value: formMaxRetries,
+                    placeholder: '0',
+                    onChange: (e) => setFormMaxRetries(e.target.value)
+                  })
+                ),
+                React.createElement('div', { className: 'dsh-cron-form-group' },
+                  React.createElement('label', null, T_KEY(t, 'form.permissionLabel')),
+                  React.createElement('select', {
+                    value: formPermissionPreset,
+                    onChange: (e) => setFormPermissionPreset(e.target.value)
+                  },
+                    React.createElement('option', { value: 'default' }, T_KEY(t, 'form.permissionDefault')),
+                    React.createElement('option', { value: 'read-only' }, T_KEY(t, 'form.permissionReadonly')),
+                    React.createElement('option', { value: 'workspace-write' }, T_KEY(t, 'form.permissionWrite')),
+                    React.createElement('option', { value: 'full' }, T_KEY(t, 'form.permissionFull'))
+                  )
+                )
+              ),
+              React.createElement('div', { className: 'dsh-cron-form-group' },
                   React.createElement('label', null, T_KEY(t, 'form.kanbanLabel')),
                   React.createElement('select', {
                     value: formKanbanMode,

package/lib/index.js

@@ -24,6 +24,10 @@ export const Config = z.object({
   notifyTelegram: z.boolean().default(false).description('Deliver task reports to Telegram for every task'),
   onlyOnFailure: z.boolean().default(false).description('Deliver reports only for failed runs'),
   kanbanBaseUrl: z.string().default('http://127.0.0.1:3000').description('Base URL of the dsh-kanban HTTP API'),
+  defaultTimezone: z.string().default('').description('Default IANA time zone for schedules (empty = server local)'),
+  maxConcurrent: z.number().default(0).description('Max parallel task runs (0 = unlimited)'),
+  heartbeatUrl: z.string().default('').description('Dead man\'s snitch URL pinged on the heartbeat interval'),
+  heartbeatIntervalSec: z.number().default(0).description('Heartbeat ping interval in seconds (0 = off)'),
 });
 
 const PATCHABLE_TASK_FIELDS = [
@@ -35,6 +39,11 @@ const PATCHABLE_TASK_FIELDS = [
   'delivery',
   'provider',
   'model',
+  'timezone',
+  'misfirePolicy',
+  'maxRetries',
+  'retryBackoffMs',
+  'permissionPreset',
   'notifyTelegram',
   'onlyOnFailure',
   'timeoutSeconds',
@@ -124,7 +133,11 @@ export function createCronApiHandler(store, scheduler, collection) {
         if (req.method === 'GET') {
           const status = url.searchParams.get('status') || 'all';
           const query = url.searchParams.get('query') || '';
-          const list = store.list({ status, query });
+          const list = store.list({ status, query }).map((t) => ({
+            ...t,
+            running: scheduler.isRunning(t.id),
+            runningSince: scheduler.runningSince(t.id),
+          }));
           const stats = store.getAggregatedStats();
           sendJson(res, 200, { ok: true, tasks: list, recommendations: collection.recommendations, stats });
           return;
@@ -162,6 +175,11 @@ export function createCronApiHandler(store, scheduler, collection) {
             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'),
+            timezone: body.timezone !== undefined ? String(body.timezone).trim() : (current ? current.timezone : ''),
+            misfirePolicy: ['skip', 'runOnce', 'catchUpAll'].includes(body.misfirePolicy) ? body.misfirePolicy : (current ? (current.misfirePolicy || 'skip') : 'skip'),
+            maxRetries: body.maxRetries !== undefined ? Math.max(0, Number(body.maxRetries) || 0) : (current ? (Number(current.maxRetries) || 0) : 0),
+            retryBackoffMs: body.retryBackoffMs !== undefined ? Math.max(1000, Number(body.retryBackoffMs) || 30000) : (current ? (Number(current.retryBackoffMs) || 30000) : 30000),
+            permissionPreset: ['default', 'read-only', 'workspace-write', 'full'].includes(body.permissionPreset) ? body.permissionPreset : (current ? (current.permissionPreset || 'default') : 'default'),
             oneShot: Boolean(parsed.isOneShot || body.oneShot),
           });
           if (task.status === 'active') {
@@ -294,6 +312,11 @@ export function executeCreateTask(store, scheduler, args) {
     onlyOnFailure: Boolean(args.onlyOnFailure),
     timeoutSeconds: Number(args.timeoutSeconds) || 1800,
     overlapPolicy: args.overlapPolicy || 'skip',
+    timezone: args.timezone ? String(args.timezone).trim() : '',
+    misfirePolicy: ['skip', 'runOnce', 'catchUpAll'].includes(args.misfirePolicy) ? args.misfirePolicy : 'skip',
+    maxRetries: Number(args.maxRetries) > 0 ? Number(args.maxRetries) : 0,
+    retryBackoffMs: Number(args.retryBackoffMs) > 0 ? Number(args.retryBackoffMs) : 30000,
+    permissionPreset: ['default', 'read-only', 'workspace-write', 'full'].includes(args.permissionPreset) ? args.permissionPreset : 'default',
     kanbanMode: args.kanbanMode || 'none',
     oneShot: Boolean(parsed.isOneShot),
   });
@@ -307,16 +330,21 @@ export function executeCreateTask(store, scheduler, args) {
 
 const createTaskParameters = {
   title: { type: 'string', description: 'Short task name', required: true },
-  schedule: { type: 'string', description: 'Schedule: cron ("0 9 * * *"), interval ("every 2h") or one-shot ("in 30m", "at: 2026-09-05T15:00:00Z")', required: true },
+  schedule: { type: 'string', description: 'Schedule: cron ("0 9 * * *"), shorthand ("@daily", "@every 30m"), interval ("every 2h") or one-shot ("in 30m", "at: 2026-09-05T15:00:00Z")', required: true },
   prompt: { type: 'string', description: 'Prompt/instruction for the agent at run time', required: true },
   type: { type: 'string', enum: ['prompt', 'script'], description: 'Task type' },
   delivery: { type: 'string', enum: ['current', 'isolated'], description: 'Run mode: current (in the current chat) or isolated (separate session)' },
   provider: { type: 'string', description: 'Model provider (optional)' },
   model: { type: 'string', description: 'Model (optional)' },
+  timezone: { type: 'string', description: 'IANA time zone for the schedule, e.g. "Europe/Berlin" (optional, default = server local)' },
   notifyTelegram: { type: 'boolean', description: 'Send the run report to Telegram' },
   onlyOnFailure: { type: 'boolean', description: 'Send reports only for failures' },
   timeoutSeconds: { type: 'number', description: 'Execution time limit in seconds' },
   overlapPolicy: { type: 'string', enum: ['skip', 'queue', 'replace'], description: 'Overlap policy' },
+  misfirePolicy: { type: 'string', enum: ['skip', 'runOnce', 'catchUpAll'], description: 'What to do with a run missed during downtime' },
+  maxRetries: { type: 'number', description: 'Automatic retry attempts on failure (0 = off)' },
+  retryBackoffMs: { type: 'number', description: 'Base backoff between retries in ms, doubled per attempt' },
+  permissionPreset: { type: 'string', enum: ['default', 'read-only', 'workspace-write', 'full'], description: 'Permission preset applied to the task session' },
   kanbanMode: { type: 'string', enum: ['none', 'on_failure', 'always'], description: 'Create a dsh-kanban card for runs' },
 };
 
@@ -336,7 +364,10 @@ const createTaskOutput = {
 export function apply(ctx, config) {
   const store = new TaskStore();
   const runner = new SessionRunner(ctx);
-  const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts));
+  const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts), {
+    maxConcurrent: config && config.maxConcurrent,
+    defaultTimezone: config && config.defaultTimezone,
+  });
 
   // Register settings in the Harness settings service (#71, #102): the scope
   // is the source of truth for the core, scope.watch mirrors values into the
@@ -365,8 +396,21 @@ export function apply(ctx, config) {
 
   scheduler.start();
 
+  // Heartbeat / dead man's snitch (#16): an optional periodic GET ping so an
+  // external monitor can alert when this scheduler stops responding.
+  let heartbeatTimer = null;
+  if (config && config.heartbeatUrl && Number(config.heartbeatIntervalSec) > 0) {
+    const intervalMs = Number(config.heartbeatIntervalSec) * 1000;
+    heartbeatTimer = setInterval(() => {
+      fetch(config.heartbeatUrl, { method: 'GET' }).catch((err) => {
+        console.warn('[dsh-cron] heartbeat ping failed:', err.message);
+      });
+    }, intervalMs);
+  }
+
   ctx.effect(() => {
     return () => {
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
       scheduler.stopAll();
     };
   }, 'dsh-cron: lifecycle');
@@ -466,6 +510,27 @@ export function apply(ctx, config) {
     }
   }), 'dsh-cron: /settings');
 
+  // GET /dsh-cron/heartbeat (#16): liveness probe for external monitors.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/heartbeat',
+    handler: async (req, res) => {
+      try {
+        const tasks = store.list({ status: 'active' });
+        const lastRuns = tasks.map((t) => t.lastRunAt || 0);
+        sendJson(res, 200, {
+          ok: true,
+          activeTasks: tasks.length,
+          running: scheduler.runningCount(),
+          lastRunAt: lastRuns.length ? Math.max(...lastRuns) : null,
+          serverTime: Date.now(),
+        });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /heartbeat');
+
   // POST /dsh-cron/telegram/test
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/runner.js

@@ -130,6 +130,18 @@ export class SessionRunner {
             agentOptions: provider && model ? { provider, model } : undefined,
           });
 
+          // Per-job permission preset (#32): read-only | workspace-write | full.
+          if (task.permissionPreset && task.permissionPreset !== 'default') {
+            try {
+              const presets = this.ctx.get && this.ctx.get('permissionPresets');
+              if (presets && typeof presets.set === 'function') {
+                presets.set(handle.agent.session, task.permissionPreset);
+              }
+            } catch (ppErr) {
+              console.warn('[dsh-cron] permission preset not applied:', ppErr.message);
+            }
+          }
+
           await raceAbort(handle.agent.whenIdle());
           handle.agent.followup(createUserMessage({
             content: [{ type: 'text', text: task.prompt }],
@@ -159,9 +171,14 @@ export class SessionRunner {
           return {
             output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
             usage,
-            costUsd
+            costUsd,
+            sessionId: handle.agent.session?.id || null
           };
         } finally {
+          let archivedSessionId = null;
+          try {
+            archivedSessionId = (handle && handle.agent && handle.agent.session && handle.agent.session.id) || null;
+          } catch {}
           try {
             if (handle && typeof handle.dispose === 'function') {
               await handle.dispose();
@@ -171,6 +188,17 @@ export class SessionRunner {
           } catch (disposeErr) {
             console.warn('[dsh-cron] session dispose notice:', disposeErr.message);
           }
+          // Best-effort: keep ephemeral cron sessions out of the main chat
+          // list (#30). The archive call degrades silently when the core
+          // does not expose it.
+          if (archivedSessionId && this.ctx && this.ctx.get) {
+            try {
+              const sessions = this.ctx.get('sessions');
+              if (sessions && typeof sessions.archive === 'function') {
+                sessions.archive(archivedSessionId);
+              }
+            } catch {}
+          }
         }
       } catch (err) {
         console.error(`[dsh-cron] agent execution failed:`, err.message);

package/lib/scheduler.js

@@ -99,8 +99,19 @@ export function parseScheduleExpression(input) {
     }
   }
 
-  // 4. Friendly recurring aliases (English plus accepted Russian input aliases)
+  // 4. Standard @-shorthands (#15)
   const lower = str.toLowerCase();
+  if (lower === '@hourly') return { cronPattern: '0 * * * *', humanText: 'Every hour' };
+  if (lower === '@daily' || lower === '@midnight') return { cronPattern: '0 0 * * *', humanText: 'Every day at 00:00' };
+  if (lower === '@weekly') return { cronPattern: '0 0 * * 0', humanText: 'Every week on Sunday at 00:00' };
+  if (lower === '@monthly') return { cronPattern: '0 0 1 * *', humanText: 'Every month on the 1st at 00:00' };
+  if (lower === '@yearly' || lower === '@annually') return { cronPattern: '0 0 1 1 *', humanText: 'Every year on Jan 1 at 00:00' };
+  const everyAlias = str.match(/^@every\s+(\d+)\s*(sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?)$/i);
+  if (everyAlias) {
+    return parseScheduleExpression(`every ${everyAlias[1]} ${everyAlias[2]}`);
+  }
+
+  // 5. Friendly recurring aliases (English plus accepted Russian input aliases)
   if (lower === 'daily' || lower === 'каждый день') {
     return { cronPattern: '0 9 * * *', humanText: 'Every day at 09:00' };
   }
@@ -126,35 +137,75 @@ export function parseScheduleExpression(input) {
 }
 
 export class TaskScheduler {
-  constructor(store, executeFn) {
+  constructor(store, executeFn, options = {}) {
     this.store = store;
     this.executeFn = executeFn;
+    this.maxConcurrent = Number(options.maxConcurrent) > 0 ? Number(options.maxConcurrent) : 0; // 0 = unlimited (#52)
+    this.defaultTimezone = options.defaultTimezone || ''; // #13
     this.jobs = new Map(); // taskId -> Cron instance
     this.timers = new Map(); // taskId -> setTimeout handle (for one-shot tasks)
+    this.retryTimers = new Map(); // taskId -> setTimeout handle (for #18 retries)
     this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
   }
 
+  isRunning(taskId) {
+    return this.running.has(taskId);
+  }
+
+  runningCount() {
+    return this.running.size;
+  }
+
+  runningSince(taskId) {
+    const run = this.running.get(taskId);
+    return run ? run.startedAt : null;
+  }
+
+  clearRetryTimer(taskId) {
+    const timer = this.retryTimers.get(taskId);
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      this.retryTimers.delete(taskId);
+    }
+  }
+
   start() {
     const tasks = this.store.list();
     const now = Date.now();
     for (const task of tasks) {
-      if (task.status === 'active') {
-        // Detect missed execution if daemon was offline (threshold: > 5 minutes)
-        if (task.nextRunAt && (now - task.nextRunAt) > 5 * 60 * 1000) {
-          const missedAt = task.nextRunAt;
-          console.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()}`);
-          this.store.recordRun(task.id, {
-            at: missedAt,
-            status: 'missed',
-            durationMs: 0,
-            output: `Skipped: the service was offline or restarting at the scheduled time (${new Date(missedAt).toISOString()})`,
-            error: null,
-            usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-            costUsd: 0,
-          });
+      if (task.status !== 'active') continue;
+      // Detect missed execution if daemon was offline (threshold: > 5 minutes)
+      const missed = task.nextRunAt && (now - task.nextRunAt) > 5 * 60 * 1000;
+      if (missed) {
+        const missedAt = task.nextRunAt;
+        const policy = task.misfirePolicy || 'skip'; // #12: skip | runOnce | catchUpAll
+        console.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
+        this.store.recordRun(task.id, {
+          at: missedAt,
+          status: 'missed',
+          durationMs: 0,
+          output: `Skipped: the service was offline or restarting at the scheduled time (${new Date(missedAt).toISOString()})`,
+          error: null,
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        });
+        if (policy === 'skip') {
+          // A missed one-shot has no future slot left: retire it instead of
+          // arming a timer in the past.
+          if (task.oneShot) {
+            task.status = 'completed';
+            this.store.set(task);
+            continue;
+          }
+          this.scheduleTask(task);
+          continue;
         }
+        // runOnce / catchUpAll: run late exactly once, then resume the schedule.
         this.scheduleTask(task);
+        setImmediate(() => this.runTask(task.id));
+        continue;
       }
+      this.scheduleTask(task);
     }
   }
 
@@ -173,6 +224,13 @@ export class TaskScheduler {
     }
     this.timers.clear();
 
+    for (const [id, timer] of this.retryTimers.entries()) {
+      try {
+        clearTimeout(timer);
+      } catch {}
+    }
+    this.retryTimers.clear();
+
     for (const [, run] of this.running.entries()) {
       try {
         run.controller.abort(new Error('Scheduler stopped'));
@@ -193,9 +251,11 @@ export class TaskScheduler {
     }
 
     if (task.status !== 'active') return;
+    this.clearRetryTimer(task.id);
 
     try {
       const parsed = parseScheduleExpression(task.schedule);
+      const timezone = task.timezone || this.defaultTimezone || undefined;
 
       // Handle One-shot task
       if (parsed.isOneShot) {
@@ -216,7 +276,7 @@ export class TaskScheduler {
       }
 
       // Handle Recurring Cron job
-      const job = new Cron(parsed.cronPattern, { protect: true }, async () => {
+      const job = new Cron(parsed.cronPattern, { protect: true, ...(timezone ? { timezone } : {}) }, async () => {
         await this.runTask(task.id);
       });
 
@@ -235,6 +295,23 @@ export class TaskScheduler {
     const task = this.store.get(taskId);
     if (!task) return;
 
+    // Global concurrency throttle (#52): a run that would exceed the limit is
+    // skipped and recorded; already-running tasks are never throttled against
+    // themselves.
+    if (!this.running.has(taskId) && this.maxConcurrent > 0 && this.running.size >= this.maxConcurrent) {
+      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency limit (${this.maxConcurrent})`);
+      this.store.recordRun(taskId, {
+        at: Date.now(),
+        status: 'skipped',
+        durationMs: 0,
+        output: `Skipped: concurrency limit reached (${this.maxConcurrent} parallel runs)`,
+        error: null,
+        usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+        costUsd: 0,
+      });
+      return;
+    }
+
     const overlapPolicy = task.overlapPolicy || 'skip';
 
     // Check overlap with currently running task
@@ -278,6 +355,7 @@ export class TaskScheduler {
     let error = null;
     let usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
     let costUsd = 0;
+    let sessionId = null;
 
     try {
       if (typeof this.executeFn === 'function') {
@@ -286,6 +364,7 @@ export class TaskScheduler {
           output = res.output || '';
           usage = res.usage || usage;
           costUsd = res.costUsd || 0;
+          sessionId = res.sessionId || null;
         } else {
           output = String(res || '');
         }
@@ -307,6 +386,7 @@ export class TaskScheduler {
         error,
         usage,
         costUsd,
+        sessionId,
       };
       this.store.recordRun(taskId, runInfo);
 
@@ -383,6 +463,25 @@ export class TaskScheduler {
         }
       }
 
+      // 4. Retry with exponential backoff on failure (#18)
+      const failed = status === 'error' || status === 'timeout';
+      const maxRetries = Number(task.maxRetries) > 0 ? Number(task.maxRetries) : 0;
+      if (failed && maxRetries > 0 && (task.attempts || 0) < maxRetries && task.status !== 'paused') {
+        task.attempts = (task.attempts || 0) + 1;
+        const backoffMs = (Number(task.retryBackoffMs) > 0 ? Number(task.retryBackoffMs) : 30000) * Math.pow(2, task.attempts - 1);
+        const attempt = task.attempts;
+        this.store.set(task);
+        this.clearRetryTimer(taskId);
+        this.retryTimers.set(taskId, setTimeout(() => {
+          this.retryTimers.delete(taskId);
+          this.runTask(taskId);
+        }, backoffMs));
+        console.log(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
+      } else if (!failed && task.attempts) {
+        task.attempts = 0;
+        this.store.set(task);
+      }
+
       if (queuedCount > 0) {
         setImmediate(() => {
           this.runTask(taskId);
@@ -396,6 +495,7 @@ export class TaskScheduler {
     if (!task) return null;
     task.status = 'paused';
     task.nextRunAt = null;
+    this.clearRetryTimer(taskId);
     if (this.jobs.has(taskId)) {
       this.jobs.get(taskId).stop();
       this.jobs.delete(taskId);

package/lib/store.js

@@ -212,6 +212,7 @@ export class TaskStore {
       error: runInfo.error ? String(runInfo.error).slice(0, 1000) : null,
       usage,
       costUsd,
+      sessionId: runInfo.sessionId || null,
     });
     if (runs.length > 50) runs.length = 50;
     this.history.set(id, runs);

package/package.json

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