@goodandready/dsh-cron 0.2.38 → 0.2.40

package/README.md

@@ -488,7 +488,7 @@ dsh-cron:
   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)
+  maxConcurrent: 2             # max parallel task runs (default 2, 0 = unlimited)
   heartbeatUrl: ""             # dead man's snitch URL pinged on the heartbeat interval
   heartbeatIntervalSec: 0      # heartbeat ping interval in seconds (0 = off)
   # --- delivery channels ---
@@ -513,7 +513,15 @@ dsh-cron:
   apiToken: ""                 # bearer token for the external /dsh-cron/api/* surface (masked; empty = 503)
 ```
 
-### Configuration Parameters
+#### Timers, Intervals & Concurrency Groups Hardening (0.2.39)
+
+- **32-Bit Timer Overflow Protection**: One-shot tasks scheduled >24.85 days in the future (exceeding Node's 32-bit signed integer `setTimeout` limit of 2,147,483,647 ms) are safely executed via bounded timer chunking, preventing immediate misfires.
+- **Persistent Relative One-Shot Deadlines**: Relative one-shot tasks (`in 30m`, `in 2h`) maintain their absolute target timestamp across daemon restarts, store reloads, pause/resume, and metadata edits. Deadlines are only recalculated upon explicit schedule modifications.
+- **Strict Interval Validation & Normalization**: Unsupported irregular intervals exceeding 59 minutes (e.g. `every 90m`) are validated and rejected upfront with HTTP 400 before persisting. Clean hourly multiples (e.g. `every 120m` -> `every 2h`, `every 24h` -> `every 1d`) are automatically converted to valid cron patterns.
+- **Unified Safe Concurrency Defaults**: The Config schema and TaskScheduler now uniformly default `maxConcurrent` to safe cap `2` (0 explicitly denotes unlimited).
+- **Concurrency Group Pool Isolation**: Tasks configured with `concurrencyGroup` have per-group execution limits enforced during admission and queue draining (default 1 concurrent run per named group). Tasks in separate groups run concurrently up to `maxConcurrent`, while queued tasks drain as soon as group capacity becomes available.
+
+## Configuration Parameters
 
 | Parameter | Type | Default | Description |
 |:---|:---|:---|:---|
@@ -523,7 +531,7 @@ dsh-cron:
 | `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) |
+| `maxConcurrent` | `number` | `2` | Cap on parallel task runs; extra runs are recorded as `skipped` (default 2, 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) |
 | `botTokenRef` | `string` | `""` | Name of the DSH credential holding the Telegram bot token; resolved at send time (falls back to `botToken`, then the messenger-gateway settings, then the `CRON_TELEGRAM_BOT_TOKEN` environment variable) |

package/README.ru.md

@@ -353,7 +353,7 @@ dsh-cron:
   onlyOnFailure: false         # отправлять отчёты только при сбоях
   kanbanBaseUrl: "http://127.0.0.1:3000"  # базовый URL HTTP API dsh-kanban
   defaultTimezone: ""          # IANA-зона по умолчанию (пусто = серверное время)
-  maxConcurrent: 0             # максимум параллельных запусков (0 = без лимита)
+  maxConcurrent: 2             # максимум параллельных запусков (по умолчанию 2, 0 = без лимита)
   heartbeatUrl: ""             # URL dead man's snitch, пингуется по интервалу
   heartbeatIntervalSec: 0      # интервал heartbeat-пинга в секундах (0 = выключено)
   # --- каналы доставки ---
@@ -513,7 +513,7 @@ bash deploy.sh verify [exact-version]
 | `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 = без лимита) |
+| `maxConcurrent` | `number` | `2` | Лимит параллельных запусков; лишние помечаются `skipped` (по умолчанию 2, 0 = без лимита) |
 | `heartbeatUrl` | `string` | `""` | URL dead man's snitch, пингуемый каждый `heartbeatIntervalSec`, пока жив планировщик |
 | `heartbeatIntervalSec` | `number` | `0` | Интервал heartbeat-пинга в секундах (0 = выключено) |
 | `botTokenRef` | `string` | `""` | Имя credential DSH с токеном Telegram-бота; резолвится при отправке (фолбэк: `botToken` → настройки messenger-gateway → переменная окружения `CRON_TELEGRAM_BOT_TOKEN`) |
@@ -591,3 +591,12 @@ node scripts/ci-preflight.mjs
 ## 📄 Лицензия
 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+
+### Надёжность таймеров, интервалов и групп параллелизма (0.2.39)
+
+- **Защита от 32-битного переполнения таймера**: Одноразовые задачи, запланированные более чем на 24.85 дня вперёд (превышающие лимит 32-битного целого `setTimeout` в 2 147 483 647 мс в Node.js), выполняются через порционный таймер и не запускаются раньше времени.
+- **Сохранение первоначального дедлайна относительных задач**: Задачи вида `in 30m` или `через 2 часа` сохраняют первоначальный целевой таймстемп при перезапусках сервера, перезагрузке хранилища, паузе/возобновлении и изменении полей задачи (title, tags, channels). Новый дедлайн вычисляется только при явном изменении поля расписания.
+- **Строгая валидация и нормализация интервалов**: Недопустимые минутные интервалы свыше 59 минут (например, `every 90m`) отклоняются на входе с кодом HTTP 400 без создания неработающей активной задачи. Кратные интервалы (например, `every 120m` -> `every 2h`, `every 24h` -> `every 1d`) корректно приводятся к валидным cron-паттернам.
+- **Единый безопасный лимит maxConcurrent**: Схема Config и планировщик TaskScheduler теперь согласованно используют лимит по умолчанию `2` (0 остаётся явным выбором безлимитного режима).
+- **Изоляция пулов через concurrencyGroup**: Поле `concurrencyGroup` теперь строго контролируется при допуске задач и опустошении очереди (по умолчанию 1 параллельный запуск на именованную группу). Задачи из разных групп исполняются параллельно в пределах общего `maxConcurrent`, а задачи с политикой `queue` стартуют сразу при освобождении слота своей группы.
+

package/README.zh.md

@@ -478,7 +478,7 @@ dsh-cron:
   onlyOnFailure: false         # 仅失败时投递报告
   kanbanBaseUrl: "http://127.0.0.1:3000"  # dsh-kanban HTTP API 基础地址
   defaultTimezone: ""          # 默认 IANA 时区（空 = 服务器本地）
-  maxConcurrent: 0             # 最大并行运行数（0 = 不限）
+  maxConcurrent: 2             # 最大并行运行数（默认 2，0 = 不限）
   heartbeatUrl: ""             # 心跳上报 URL（dead man's snitch）
   heartbeatIntervalSec: 0      # 心跳间隔秒数（0 = 关闭）
   # --- 投递渠道 ---
@@ -513,7 +513,7 @@ dsh-cron:
 | `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 = 不限） |
+| `maxConcurrent` | `number` | `2` | 并行运行上限；超出的运行记录为 `skipped`（默认 2，0 = 不限） |
 | `heartbeatUrl` | `string` | `""` | 心跳上报 URL，调度器存活期间按 `heartbeatIntervalSec` 间隔 GET |
 | `heartbeatIntervalSec` | `number` | `0` | 心跳间隔秒数（0 = 关闭） |
 | `botTokenRef` | `string` | `""` | 保存 Telegram bot token 的 DSH 凭据名称；发送时解析（回退顺序：`botToken` → messenger-gateway 设置 → 环境变量 `CRON_TELEGRAM_BOT_TOKEN`） |
@@ -591,3 +591,12 @@ node scripts/ci-preflight.mjs
 ## 📄 许可证
 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+
+### 定时器、间隔与并发分组精度强化 (0.2.39)
+
+- **32位定时器溢出防护**：计划在 24.85 天以后的单次任务（超出 Node.js `setTimeout` 32位有符号整数上限 2,147,483,647 毫秒）通过分段定时器安全挂起，杜绝立即误触发。
+- **相对单次任务持久截止时间**：相对单次任务（如 `in 30m`、`in 2h`）在服务重启、存储重载、暂停/恢复以及修改元数据时完整保留初始目标绝对时间戳，仅在显式修改调度表达式时重新计算。
+- **严格的时间间隔校验与转换**：对于无法用标准 Cron 分钟步进表示的超限分钟间隔（如 `every 90m`），在持久化前返回 HTTP 400 拦截；规整整倍数（如 `every 120m` -> `every 2h`、`every 24h` -> `every 1d`）自动转为合法 Cron 表达式。
+- **统一安全并发默认值**：配置规范（Config）与调度器（TaskScheduler）全面对齐默认并发上限 `maxConcurrent = 2`（0 仅作为显式无限制选项）。
+- **并发分组隔离调度**：任务的 `concurrencyGroup` 属性全面接入调度仲裁与队列排队（同名分组默认限流 1 个并发执行），不同分组可并发运行直至 `maxConcurrent`，队列任务随所属分组资源释放立即触发。
+

package/lib/api-import-export.js

@@ -15,9 +15,18 @@ import {
 } from './http-utils.js';
 import { MANAGED_BY_CONFIG } from './config-jobs.js';
 
-export function handleTaskExport({ store, res }) {
-  const doc = buildTaskExport(store.list({ status: 'all' }));
-  sendJson(res, 200, { ok: true, document: doc, count: doc.tasks.length });
+export function handleTaskExport({ store, req, res }) {
+  let sanitize = false;
+  if (req && req.url) {
+    try {
+      const parsed = new URL(req.url, 'http://127.0.0.1');
+      sanitize = parsed.searchParams.get('sanitize') === 'true' || parsed.searchParams.get('redact') === 'true';
+    } catch (urlErr) {
+      logger.debug('[dsh-cron] export url parse fallback:', urlErr.message);
+    }
+  }
+  const doc = buildTaskExport(store.list({ status: 'all' }), { sanitize });
+  sendJson(res, 200, { ok: true, document: doc, count: doc.tasks.length, sanitized: sanitize });
 }
 
 export async function handleTaskImport({ store, scheduler, req, res }) {

package/lib/api.js

@@ -101,7 +101,7 @@ export function createCronApiHandler(store, scheduler, collection) {
           sendJson(res, 405, NOT_ALLOWED);
           return;
         }
-        handleTaskExport({ store, res });
+        handleTaskExport({ store, req, res });
         return;
       }
       if (id === 'import') {
@@ -200,7 +200,13 @@ async function createOrUpdateTask({ store, scheduler, req, res, apiToken }) {
     sendJson(res, 400, { ok: false, error: typeError });
     return;
   }
-  const parsed = parseScheduleExpression(body.schedule);
+  let parsed;
+  try {
+    parsed = parseScheduleExpression(body.schedule);
+  } catch (err) {
+    sendJson(res, 400, { ok: false, error: err.message });
+    return;
+  }
   // A client-supplied id must not shadow the collection routes under
   // /dsh-cron/tasks, otherwise that task could never be fetched or deleted
   // again (#42 review finding).
@@ -480,6 +486,9 @@ function mergeExecutionFields(current, body, parsed) {
     skillName: body.skillName !== undefined ? String(body.skillName).trim() : (current ? current.skillName : ''),
     workflowName: body.workflowName !== undefined ? String(body.workflowName).trim() : (current ? current.workflowName : ''),
     oneShot: Boolean((parsed && parsed.isOneShot) || (body && body.oneShot)),
+    targetTimestamp: parsed && parsed.isOneShot
+      ? (current && current.schedule === (parsed.cronPattern || body.schedule) ? (current.targetTimestamp || parsed.targetTimestamp) : parsed.targetTimestamp)
+      : (current ? current.targetTimestamp : undefined),
     costLimitUsd: body.costLimitUsd !== undefined ? (body.costLimitUsd === null ? null : (Number(body.costLimitUsd) > 0 ? Number(body.costLimitUsd) : null)) : (current ? current.costLimitUsd : undefined),
     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),

package/lib/client.js

@@ -88,7 +88,8 @@ window.__ModuleLoader__.load({
         'transfer.exported': 'Exported {count} task(s).',
         'transfer.exportFailed': 'Export failed: {error}',
         'transfer.importTitleModal': 'Import tasks',
-        'transfer.importHint': 'Exported task configuration only: no run history, no counters. Secrets are not included — channels reference credentials by name, so make sure those credential names exist on the target harness.',
+        'transfer.importHint': 'Exported task configuration only: no run history, no counters. Channel configurations reference credentials by name; note that raw exports retain custom env variables and HTTP request headers.',
+        'transfer.exportPrompt': 'Choose export mode:\nOK = Sanitized (removes custom env vars & headers)\nCancel = Full raw export',
         'transfer.strategyAdd': 'Add as new tasks (new ids, existing ones stay untouched)',
         'transfer.strategyReplace': 'Replace tasks with the same id',
         'transfer.strategySkip': 'Skip tasks whose id already exists',
@@ -390,7 +391,8 @@ window.__ModuleLoader__.load({
         'transfer.exported': '已成功导出 {count} 个任务。',
         'transfer.exportFailed': '导出失败: {error}',
         'transfer.importTitleModal': '导入任务',
-        'transfer.importHint': '仅导出任务静态配置：不包含历史记录与计数器。不包含密钥——渠道通过凭据名称引用。',
+        'transfer.importHint': '仅导出任务静态配置：不包含历史记录与计数器。渠道通过凭据名称引用；注意完整导出保留自定义环境变量和 HTTP 请求头。',
+        'transfer.exportPrompt': '请选择导出模式：\n确定 = 净化导出（移除自定义环境变量与请求头）\n取消 = 完整原始导出',
         'transfer.strategyAdd': '作为新任务导入（分配新 ID）',
         'transfer.strategyReplace': '覆盖同 ID 任务',
         'transfer.strategySkip': '跳过已存在的同 ID 任务',
@@ -1383,12 +1385,16 @@ window.__ModuleLoader__.load({
         setTimeout(() => { try { node.classList.remove('dsh-cron-task-highlight'); } catch (err) { /* node unmounted */ } }, 2500);
       }, [tasks]);
 
+      const fetchGenRef = React.useRef(0);
+
       const fetchTasks = async () => {
+        const gen = ++fetchGenRef.current;
         setLoading(true);
         setFetchError(null);
         try {
           const res = await fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query));
           const data = await res.json();
+          if (gen !== fetchGenRef.current) return;
           if (data && data.ok) {
             setTasks(data.tasks || []);
             setRecs(data.recommendations || []);
@@ -1397,10 +1403,13 @@ window.__ModuleLoader__.load({
             setFetchError(data && data.error ? data.error : T_KEY(t, 'list.loadErrorPrefix'));
           }
         } catch (err) {
+          if (gen !== fetchGenRef.current) return;
           console.error('[dsh-cron] fetch tasks error:', err);
           setFetchError(err.message || T_KEY(t, 'list.loadErrorPrefix'));
         } finally {
-          setLoading(false);
+          if (gen === fetchGenRef.current) {
+            setLoading(false);
+          }
         }
       };
 
@@ -1488,22 +1497,50 @@ window.__ModuleLoader__.load({
       }, [tab, query]);
       React.useEffect(() => { loadModels(); }, []);
 
+      const actionInProgressRef = React.useRef(new Set());
+
       const handleToggleTask = async (id) => {
+        if (actionInProgressRef.current.has(id)) return;
+        actionInProgressRef.current.add(id);
         try {
-          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/toggle', { method: 'POST' });
-          fetchTasks();
+          const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/toggle', { method: 'POST' });
+          const data = await res.json().catch(() => ({}));
+          if (!res.ok || (data && data.ok === false)) {
+            const msg = (data && data.error) || `Toggle failed (HTTP ${res.status})`;
+            alert(msg);
+            return;
+          }
+          await fetchTasks();
         } catch (err) {
-          console.debug('[dsh-cron] toggle failed', err);
+          console.error('[dsh-cron] toggle failed', err);
+          alert('Toggle request failed: ' + err.message);
+        } finally {
+          actionInProgressRef.current.delete(id);
         }
       };
 
       const handleRunNow = async (id) => {
+        if (actionInProgressRef.current.has(id)) return;
+        actionInProgressRef.current.add(id);
+        const prevTask = tasks.find(t => t.id === id);
+        const prevStatus = prevTask ? prevTask.lastStatus : null;
+        setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: 'running' } : t2));
         try {
-          setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: 'running' } : t2));
-          await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/run', { method: 'POST' });
+          const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(id) + '/run', { method: 'POST' });
+          const data = await res.json().catch(() => ({}));
+          if (!res.ok || (data && data.ok === false)) {
+            setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: prevStatus } : t2));
+            const msg = (data && data.error) || `Run failed (HTTP ${res.status})`;
+            alert(msg);
+            return;
+          }
           setTimeout(() => fetchTasks(), 1500);
         } catch (err) {
           console.error('[dsh-cron] run now error:', err);
+          setTasks(prev => prev.map(t2 => t2.id === id ? { ...t2, lastStatus: prevStatus } : t2));
+          alert('Run request failed: ' + err.message);
+        } finally {
+          actionInProgressRef.current.delete(id);
         }
       };
 
@@ -1527,7 +1564,7 @@ window.__ModuleLoader__.load({
           const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(task.id) + '/archive?limit=15&offset=' + offset);
           const data = await res.json();
           if (data.ok) {
-            setArchiveRuns(data.runs || []);
+            setArchiveRuns(prev => offset === 0 ? (data.runs || []) : [...prev, ...(data.runs || [])]);
             setArchiveTotal(data.total || 0);
           }
         } catch (err) {
@@ -1592,11 +1629,14 @@ window.__ModuleLoader__.load({
         return headers;
       };
 
-      /** #42: download the task configuration as a JSON file. */
+      /** #42, #240: download the task configuration with honest disclosure and sanitized export choice. */
       const handleExport = async () => {
         setTransferBusy(true);
         try {
-          const res = await fetch('/dsh-cron/tasks/export');
+          const promptMsg = T_KEY(t, 'transfer.exportPrompt') || 'Choose export mode:\nOK = Sanitized (removes custom env vars & headers)\nCancel = Full raw export';
+          const wantSanitized = confirm(promptMsg);
+          const exportUrl = '/dsh-cron/tasks/export' + (wantSanitized ? '?sanitize=true' : '');
+          const res = await fetch(exportUrl);
           const data = await res.json();
           if (!data.ok) {
             alert(T_KEY(t, 'transfer.exportFailed', { error: (data && data.error) || '' }));
@@ -1607,7 +1647,7 @@ window.__ModuleLoader__.load({
           const stamp = new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-');
           const anchor = document.createElement('a');
           anchor.href = url;
-          anchor.download = `dsh-cron-tasks-${stamp}.json`;
+          anchor.download = `dsh-cron-tasks-${stamp}${data.sanitized ? '-sanitized' : ''}.json`;
           document.body.appendChild(anchor);
           anchor.click();
           document.body.removeChild(anchor);
@@ -3145,9 +3185,9 @@ window.__ModuleLoader__.load({
               }, '✕')
             ),
             React.createElement('div', { style: { marginTop: '12px', display: 'flex', flexDirection: 'column', gap: '8px', fontSize: '13px' } },
-              React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.status') + ': '), React.createElement('span', { style: { color: dryRunResult.ok ? 'var(--dsh-cron-success)' : 'var(--dsh-cron-danger)' } }, dryRunResult.ok ? (dryRunResult.result && dryRunResult.result.status || 'success') : 'failed')),
-              dryRunResult.result && dryRunResult.result.preflight && React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.preflight') + ': '), React.createElement('span', null, dryRunResult.result.preflight.passed ? '✓ Passed' : '✗ Failed (' + (dryRunResult.result.preflight.reason || '') + ')')),
-              dryRunResult.result && React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.duration') + ': '), React.createElement('span', null, (dryRunResult.result.durationMs || 0) + 'ms')),
+              React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.status') + ': '), React.createElement('span', { style: { color: dryRunResult.ok ? 'var(--dsh-cron-success)' : 'var(--dsh-cron-danger)' } }, dryRunResult.ok ? ((dryRunResult.result && dryRunResult.result.status) || dryRunResult.status || 'success') : 'failed')),
+              ((dryRunResult.result && dryRunResult.result.preflight) || dryRunResult.preflight) && React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.preflight') + ': '), React.createElement('span', null, (((dryRunResult.result && dryRunResult.result.preflight) || dryRunResult.preflight).passed) ? '✓ Passed' : '✗ Failed (' + ((((dryRunResult.result && dryRunResult.result.preflight) || dryRunResult.preflight).reason) || '') + ')')),
+              React.createElement('div', null, React.createElement('strong', null, T_KEY(t, 'dryRun.duration') + ': '), React.createElement('span', null, (((dryRunResult.result && dryRunResult.result.durationMs) !== undefined ? dryRunResult.result.durationMs : dryRunResult.durationMs) || 0) + 'ms')),
               React.createElement('div', { style: { marginTop: '6px' } }, React.createElement('strong', null, T_KEY(t, 'dryRun.output') + ':')),
               React.createElement('pre', {
                 style: {
@@ -3162,7 +3202,7 @@ window.__ModuleLoader__.load({
                   wordBreak: 'break-word',
                   color: 'var(--dsw-alias-label-primary)'
                 }
-              }, (dryRunResult.result && dryRunResult.result.output) || (dryRunResult.error) || '(no output)')
+              }, ((dryRunResult.result && dryRunResult.result.output) !== undefined ? dryRunResult.result.output : (dryRunResult.output !== undefined ? dryRunResult.output : ((dryRunResult.result && dryRunResult.result.error) || dryRunResult.error || '(no output)'))))
             ),
             React.createElement('div', { className: 'dsh-cron-modal-foot', style: { marginTop: '16px' } },
               React.createElement('button', {
@@ -3229,7 +3269,7 @@ window.__ModuleLoader__.load({
                 type: 'button',
                 className: 'dsh-cron-btn-secondary',
                 onClick: () => {
-                  const nextOffset = archiveOffset + 15;
+                  const nextOffset = archiveRuns.length;
                   if (archiveTask) openArchiveModal(archiveTask, nextOffset);
                 }
               }, T_KEY(t, 'archive.loadMore', { shown: archiveRuns.length, total: archiveTotal })) : React.createElement('div', null),

package/lib/scheduler-execution.js

@@ -195,6 +195,28 @@ export function beginRun(scheduler, task, taskId, options = {}) {
     return null;
   }
 
+  const group = task.concurrencyGroup && task.concurrencyGroup !== 'default' ? String(task.concurrencyGroup).trim() : null;
+  const groupLimit = scheduler.getGroupLimit ? scheduler.getGroupLimit(group) : (group ? 1 : 0);
+  if (group && groupLimit > 0 && !scheduler.running.has(taskId)) {
+    const runningInGroup = scheduler.getRunningGroupCount ? scheduler.getRunningGroupCount(group) : 0;
+    if (runningInGroup >= groupLimit) {
+      if (task.overlapPolicy === 'queue') {
+        logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) queued by group "${group}" limit (${groupLimit})`);
+        scheduler.queue.push({
+          taskId,
+          options: { ...options },
+          priority: task.priority !== undefined ? task.priority : 5,
+          queuedAt: Date.now(),
+        });
+        scheduler.queue.sort((a, b) => (a.priority - b.priority) || (a.queuedAt - b.queuedAt));
+        return null;
+      }
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency group "${group}" limit reached (${groupLimit})`);
+      scheduler.recordSkipped(taskId, `Skipped: concurrency group "${group}" limit reached (${groupLimit} parallel runs)`);
+      return null;
+    }
+  }
+
   const overlapPolicy = task.overlapPolicy || 'skip';
   const active = scheduler.running.get(taskId);
   if (active) {
@@ -225,6 +247,7 @@ export function beginRun(scheduler, task, taskId, options = {}) {
     startedAt: Date.now(),
     queuedRuns: pendingOverlap,
     queueCount: pendingOverlap.length,
+    concurrencyGroup: group || 'default',
   };
   scheduler.running.set(taskId, currentRun);
   return currentRun;
@@ -532,20 +555,41 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   const guard = await checkAndApplyBurnGuard(scheduler, taskId, outcome);
   if (guard && guard.exceeded) return;
 
-  while (!scheduler.isStopped && scheduler.queue.length > 0 && scheduler.running.size < scheduler.maxConcurrent) {
-    const nextItem = scheduler.queue.shift();
-    if (!nextItem) break;
-    const queuedTask = scheduler.store.get(nextItem.taskId);
-    if (queuedTask && queuedTask.status === 'active' && !scheduler.isStopped) {
-      setImmediate(() => {
-        if (!scheduler.isStopped) {
-          scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
-            bestEffort('drain-queued-task', () => {}, scheduler.logger);
-          });
+  while (!scheduler.isStopped && scheduler.queue.length > 0 && (scheduler.maxConcurrent === 0 || scheduler.running.size < scheduler.maxConcurrent)) {
+    let admittedIndex = -1;
+    for (let i = 0; i < scheduler.queue.length; i++) {
+      const candidate = scheduler.queue[i];
+      const queuedTask = scheduler.store.get(candidate.taskId);
+      if (!queuedTask || queuedTask.status !== 'active') {
+        scheduler.queue.splice(i, 1);
+        i--;
+        continue;
+      }
+      const qGroup = queuedTask.concurrencyGroup && queuedTask.concurrencyGroup !== 'default'
+        ? String(queuedTask.concurrencyGroup).trim()
+        : null;
+      const qLimit = scheduler.getGroupLimit ? scheduler.getGroupLimit(qGroup) : (qGroup ? 1 : 0);
+      if (qGroup && qLimit > 0) {
+        const inGroup = scheduler.getRunningGroupCount ? scheduler.getRunningGroupCount(qGroup) : 0;
+        if (inGroup >= qLimit) {
+          continue;
         }
-      });
+      }
+      admittedIndex = i;
       break;
     }
+
+    if (admittedIndex === -1) break;
+
+    const nextItem = scheduler.queue.splice(admittedIndex, 1)[0];
+    setImmediate(() => {
+      if (!scheduler.isStopped) {
+        scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
+          bestEffort('drain-queued-task', () => {}, scheduler.logger);
+        });
+      }
+    });
+    break;
   }
 
   // 1. Structured LLM Actions (#137)

package/lib/scheduler-lifecycle.js

@@ -76,6 +76,9 @@ export function pauseTask(scheduler, taskId, reason = null) {
   const task = scheduler.store.get(taskId);
   if (!task) return null;
   task.status = 'paused';
+  if (task.oneShot) {
+    task.targetTimestamp = task.targetTimestamp || task.nextRunAt;
+  }
   task.nextRunAt = null;
   if (reason) {
     task.pausedReason = reason;

package/lib/scheduler.js

@@ -1,6 +1,8 @@
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import { Cron } from 'croner';
+
+const MAX_TIMEOUT_MS = 2147483647; // 2^31 - 1 ms (~24.85 days)
 import {
   AGENT_TASK_TYPES,
   addUsage,
@@ -128,14 +130,76 @@ function parseIntervalExpression(str) {
   if (!match) return null;
   const num = parseInt(match[1], 10);
   const unit = (match[2] || 'm').toLowerCase();
+  let pattern = null;
+  let humanText = null;
+
   if (unit.startsWith('m')) {
-    return { cronPattern: `*/${num} * * * *`, humanText: `Every ${num} minutes`, isInterval: true };
-  }
-  if (unit.startsWith('h')) {
-    return { cronPattern: `0 */${num} * * *`, humanText: `Every ${num} hours`, isInterval: true };
+    if (num < 1) {
+      throw new Error('Invalid interval: minute interval must be at least 1 minute');
+    }
+    if (num >= 60) {
+      if (num % 60 === 0) {
+        const hours = num / 60;
+        if (hours >= 24 && hours % 24 === 0) {
+          const days = hours / 24;
+          if (days > 31) {
+            throw new Error(`Invalid interval: minute interval "${num}m" (${days} days) exceeds 31 days`);
+          }
+          pattern = `0 0 */${days} * *`;
+          humanText = `Every ${days} days`;
+        } else if (hours > 23) {
+          throw new Error(`Invalid interval: minute interval "${num}m" (${hours} hours) cannot be expressed as a cron step`);
+        } else {
+          pattern = `0 */${hours} * * *`;
+          humanText = `Every ${hours} hours`;
+        }
+      } else {
+        throw new Error(`Invalid interval: minute interval "${num}m" exceeds 59 minutes and is not a multiple of 60. Use hours (e.g. every 2h) or a multiple of 60m`);
+      }
+    } else {
+      pattern = `*/${num} * * * *`;
+      humanText = `Every ${num} minutes`;
+    }
+  } else if (unit.startsWith('h')) {
+    if (num < 1) {
+      throw new Error('Invalid interval: hour interval must be at least 1 hour');
+    }
+    if (num >= 24) {
+      if (num % 24 === 0) {
+        const days = num / 24;
+        if (days > 31) {
+          throw new Error(`Invalid interval: hour interval "${num}h" (${days} days) exceeds 31 days`);
+        }
+        pattern = `0 0 */${days} * *`;
+        humanText = `Every ${days} days`;
+      } else {
+        throw new Error(`Invalid interval: hour interval "${num}h" exceeds 23 hours and is not a multiple of 24. Use days (e.g. every 2d) or a multiple of 24h`);
+      }
+    } else {
+      pattern = `0 */${num} * * *`;
+      humanText = `Every ${num} hours`;
+    }
+  } else if (unit.startsWith('d')) {
+    if (num < 1 || num > 31) {
+      throw new Error(`Invalid interval: day interval "${num}d" must be between 1 and 31 days`);
+    }
+    pattern = `0 0 */${num} * *`;
+    humanText = `Every ${num} days`;
   }
-  if (unit.startsWith('d')) {
-    return { cronPattern: `0 0 */${num} * *`, humanText: `Every ${num} days`, isInterval: true };
+
+  if (pattern) {
+    try {
+      const testJob = new Cron(pattern, { sloppyRanges: true });
+      const next = testJob.nextRun();
+      return {
+        cronPattern: pattern,
+        humanText,
+        isInterval: true,
+        nextRun: next ? next.getTime() : null,
+      };
+    } catch (err) {
+      throw new Error(`Invalid interval pattern "${pattern}": ${err.message}`);
+    }
   }
   return null;
 }
@@ -252,6 +316,7 @@ export class TaskScheduler {
     this.running = new Map();
     this.runCounters = {};
     this.queue = [];
+    this.groupLimits = opts.groupLimits instanceof Map ? opts.groupLimits : new Map(Object.entries(opts.groupLimits || {}));
     this.heartbeatTimer = null;
     this.logger = opts.logger || null;
     this.isStopped = false;
@@ -377,17 +442,34 @@ export class TaskScheduler {
 
   scheduleOneShot(task, parsed) {
     task.oneShot = true;
+    task.targetTimestamp = parsed.targetTimestamp;
     task.nextRunAt = parsed.targetTimestamp;
     this.store.set(task);
 
-    const delay = Math.max(0, parsed.targetTimestamp - Date.now());
-    const timer = setTimeout(() => {
-      this.timers.delete(task.id);
-      this.runTask(task.id).catch((err) => {
-        logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
-      });
-    }, delay);
-    this.timers.set(task.id, timer);
+    const armTimer = () => {
+      const remaining = parsed.targetTimestamp - Date.now();
+      if (remaining <= 0) {
+        this.timers.delete(task.id);
+        this.runTask(task.id).catch((err) => {
+          logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+        });
+        return;
+      }
+      const delay = Math.min(remaining, MAX_TIMEOUT_MS);
+      const timer = setTimeout(() => {
+        if (Date.now() >= parsed.targetTimestamp) {
+          this.timers.delete(task.id);
+          this.runTask(task.id).catch((err) => {
+            logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+          });
+        } else {
+          armTimer();
+        }
+      }, delay);
+      this.timers.set(task.id, timer);
+    };
+
+    armTimer();
   }
 
   scheduleCron(task, parsed) {
@@ -416,6 +498,11 @@ export class TaskScheduler {
     try {
       const parsed = parseScheduleExpression(task.schedule);
       if (parsed.isOneShot) {
+        const existingTarget = task.targetTimestamp || task.nextRunAt;
+        if (existingTarget && typeof existingTarget === 'number' && !isNaN(existingTarget)) {
+          parsed.targetTimestamp = existingTarget;
+          parsed.nextRun = existingTarget;
+        }
         this.scheduleOneShot(task, parsed);
         return;
       }
@@ -425,6 +512,25 @@ export class TaskScheduler {
     }
   }
 
+  getGroupLimit(group) {
+    if (!group || group === 'default') return 0;
+    if (this.groupLimits && this.groupLimits.has(group)) {
+      return Number(this.groupLimits.get(group)) || 0;
+    }
+    return 1;
+  }
+
+  getRunningGroupCount(group) {
+    if (!group || group === 'default') return 0;
+    let count = 0;
+    for (const [, run] of this.running.entries()) {
+      if (run.concurrencyGroup === group) {
+        count++;
+      }
+    }
+    return count;
+  }
+
   beginRun(task, taskId, options = {}) {
     return beginRun(this, task, taskId, options);
   }

package/lib/settings.js

@@ -21,7 +21,7 @@ export const Config = z.object({
   onlyOnFailure: z.boolean().default(false).description('Deliver reports only for failed runs').volatile(),
   kanbanBaseUrl: z.string().default('http://127.0.0.1:3000').description('Base URL of the dsh-kanban HTTP API').volatile(),
   defaultTimezone: z.string().default('').description('Default IANA time zone for schedules (empty = server local)').volatile(),
-  maxConcurrent: z.number().default(0).description('Max parallel task runs (0 = unlimited)').volatile(),
+  maxConcurrent: z.number().default(2).description('Max parallel task runs (0 = unlimited, default 2)').volatile(),
   heartbeatUrl: z.string().default('').description('Dead man\'s snitch URL pinged on the heartbeat interval').volatile(),
   heartbeatIntervalSec: z.number().default(0).description('Heartbeat ping interval in seconds (0 = off)').volatile(),
   // --- Delivery channels (#20-#23, #26, #28, #47) ---

package/lib/store.js

@@ -38,14 +38,17 @@ export class TaskStore {
     this._lastBackupTime = 0;
     this._saveTimer = null;
     this._savePromise = Promise.resolve();
+    this._saveVersion = 0;
+    this._lastWrittenVersion = 0;
     this.init();
   }
 
   init() {
     const dir = path.dirname(this.filePath);
     if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
+    bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
     const bakPath = `${this.filePath}.bak`;
 
     const loadData = (raw) => {
@@ -84,22 +87,30 @@ export class TaskStore {
 
     if (fs.existsSync(this.filePath)) {
       try {
+        bestEffort('chmod-store', () => fs.chmodSync(this.filePath, 0o600));
         const raw = fs.readFileSync(this.filePath, 'utf-8');
         loadData(raw);
         if (!fs.existsSync(bakPath)) {
-          bestEffort('backup-initial', () => fs.copyFileSync(this.filePath, bakPath));
+          bestEffort('backup-initial', () => {
+            fs.copyFileSync(this.filePath, bakPath);
+            fs.chmodSync(bakPath, 0o600);
+          });
+        } else {
+          bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
         }
       } catch (err) {
         logger.error('[dsh-cron] store read error (corrupted file):', err.message);
         try {
           const corruptedPath = `${this.filePath}.corrupted.${Date.now()}`;
           fs.copyFileSync(this.filePath, corruptedPath);
+          bestEffort('chmod-corrupted', () => fs.chmodSync(corruptedPath, 0o600));
           logger.warn(`[dsh-cron] corrupted store backed up to ${corruptedPath}`);
         } catch (snapErr) {
           logger.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
         }
         if (fs.existsSync(bakPath)) {
           try {
+            bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
             const rawBak = fs.readFileSync(bakPath, 'utf-8');
             loadData(rawBak);
             logger.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
@@ -110,9 +121,13 @@ export class TaskStore {
       }
     } else if (fs.existsSync(bakPath)) {
       try {
+        bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
         const rawBak = fs.readFileSync(bakPath, 'utf-8');
         loadData(rawBak);
-        bestEffort('restore-from-bak', () => fs.copyFileSync(bakPath, this.filePath));
+        bestEffort('restore-from-bak', () => {
+          fs.copyFileSync(bakPath, this.filePath);
+          fs.chmodSync(this.filePath, 0o600);
+        });
         logger.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
       } catch (bakErr) {
         logger.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
@@ -121,17 +136,16 @@ export class TaskStore {
   }
 
   /**
-   * Schedule a debounced save to avoid synchronous event loop blocking on high-frequency run completions.
+   * Schedule a debounced save using the asynchronous write queue to avoid
+   * blocking the event loop on large task stores (#244).
    */
   scheduleSave(delay = 50) {
     if (this._saveTimer) return;
     this._saveTimer = setTimeout(() => {
       this._saveTimer = null;
-      try {
-        this.save();
-      } catch (err) {
+      this.saveAsync().catch((err) => {
         logger.error('[dsh-cron] debounced save failed:', err.message);
-      }
+      });
     }, delay);
     if (typeof this._saveTimer.unref === 'function') {
       this._saveTimer.unref();
@@ -149,16 +163,72 @@ export class TaskStore {
     this.save();
   }
 
+  /**
+   * Asynchronously serialize and write tasks store to disk using fs.promises queue (#244).
+   * Safe mode 0600 on files and 0700 on dir (#222).
+   */
+  async saveAsync() {
+    const version = ++this._saveVersion;
+    const data = {
+      version: 1,
+      updatedAt: new Date().toISOString(),
+      tasks: Array.from(this.tasks.values()),
+      history: Object.fromEntries(this.history.entries()),
+      settings: this.settings || {},
+    };
+
+    const writeOp = async () => {
+      if (this._lastWrittenVersion >= version) {
+        return;
+      }
+      const dir = path.dirname(this.filePath);
+      await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
+      bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
+
+      const rand = Math.random().toString(36).slice(2, 8);
+      const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
+      const payload = JSON.stringify(data, null, 2);
+      await fs.promises.writeFile(tmp, payload, { encoding: 'utf-8', mode: 0o600 });
+      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
+
+      if (this._lastWrittenVersion >= version) {
+        await fs.promises.unlink(tmp).catch(() => {});
+        return;
+      }
+
+      await fs.promises.rename(tmp, this.filePath);
+      bestEffort('chmod-store', () => fs.chmodSync(this.filePath, 0o600));
+      this._lastWrittenVersion = version;
+
+      const now = Date.now();
+      if (now - this._lastBackupTime > 60000) {
+        this._lastBackupTime = now;
+        try {
+          const bakPath = `${this.filePath}.bak`;
+          await fs.promises.copyFile(this.filePath, bakPath);
+          bestEffort('chmod-bak', () => fs.chmodSync(bakPath, 0o600));
+        } catch (bakErr) {
+          logger.warn('[dsh-cron] async backup copy failed:', bakErr.message);
+        }
+      }
+    };
+
+    this._savePromise = this._savePromise.then(writeOp, writeOp);
+    return this._savePromise;
+  }
+
   save() {
     if (this._saveTimer) {
       clearTimeout(this._saveTimer);
       this._saveTimer = null;
     }
+    const version = ++this._saveVersion;
     try {
       const dir = path.dirname(this.filePath);
       if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
       }
+      bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
       const data = {
         version: 1,
         updatedAt: new Date().toISOString(),
@@ -169,13 +239,21 @@ export class TaskStore {
       // Unique tmp file per save call with process PID and random token to eliminate file collision
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
-      fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+      fs.writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: 'utf-8', mode: 0o600 });
+      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
       fs.renameSync(tmp, this.filePath);
+      bestEffort('chmod-store', () => fs.chmodSync(this.filePath, 0o600));
+      this._lastWrittenVersion = version;
+
       // Throttled backup (.bak): avoid expensive copyFileSync on every micro-save
       const now = Date.now();
       if (now - this._lastBackupTime > 60000) {
         this._lastBackupTime = now;
-        bestEffort('backup-on-save', () => fs.copyFileSync(this.filePath, `${this.filePath}.bak`));
+        bestEffort('backup-on-save', () => {
+          const bakPath = `${this.filePath}.bak`;
+          fs.copyFileSync(this.filePath, bakPath);
+          fs.chmodSync(bakPath, 0o600);
+        });
       }
     } catch (err) {
       logger.error('[dsh-cron] store save error:', err.message);
@@ -505,8 +583,10 @@ export class TaskStore {
       // Write atomically with tmp file using compact JSON (avoiding mega-lines and null, 2 serialization bloat)
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${archivePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
-      fs.writeFileSync(tmp, JSON.stringify(archive), 'utf-8');
+      fs.writeFileSync(tmp, JSON.stringify(archive), { encoding: 'utf-8', mode: 0o600 });
+      bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
       fs.renameSync(tmp, archivePath);
+      bestEffort('chmod-archive', () => fs.chmodSync(archivePath, 0o600));
     } catch (archiveErr) {
       logger.error('[dsh-cron] history archive error:', archiveErr.message);
     }

package/lib/task-create.js

@@ -66,6 +66,8 @@ export function executeCreateTask(store, scheduler, args) {
     skillName: args.skillName ? String(args.skillName).trim() : '',
     workflowName: args.workflowName ? String(args.workflowName).trim() : '',
     oneShot: Boolean(parsed.isOneShot),
+    targetTimestamp: parsed.isOneShot ? parsed.targetTimestamp : undefined,
+    nextRunAt: parsed.isOneShot ? parsed.targetTimestamp : (parsed.nextRun || undefined),
     costLimitUsd: Number(args.costLimitUsd) > 0 ? Number(args.costLimitUsd) : undefined,
     dailyCostLimitUsd: Number(args.dailyCostLimitUsd) > 0 ? Number(args.dailyCostLimitUsd) : undefined,
     tokenLimit: Number(args.tokenLimit) > 0 ? Number(args.tokenLimit) : undefined,

package/lib/task-patch.js

@@ -67,10 +67,20 @@ export function buildTaskPatch(current, body) {
   if (patch.schedule !== undefined) {
     // An empty schedule would leave an armed task that can never fire.
     if (!String(patch.schedule).trim()) return { ok: false, error: 'Schedule cannot be empty' };
-    const parsed = parseScheduleExpression(patch.schedule);
-    patch.schedule = parsed.cronPattern || patch.schedule;
-    patch.scheduleText = (body && body.scheduleText) || parsed.humanText;
-    patch.oneShot = Boolean(parsed.isOneShot || (body && body.oneShot));
+    try {
+      const parsed = parseScheduleExpression(patch.schedule);
+      const newSchedule = parsed.cronPattern || patch.schedule;
+      const scheduleChanged = newSchedule !== current.schedule;
+      patch.schedule = newSchedule;
+      patch.scheduleText = (body && body.scheduleText) || parsed.humanText;
+      patch.oneShot = Boolean(parsed.isOneShot || (body && body.oneShot));
+      if (scheduleChanged) {
+        patch.nextRunAt = parsed.isOneShot ? parsed.targetTimestamp : (parsed.nextRun || null);
+        patch.targetTimestamp = parsed.isOneShot ? parsed.targetTimestamp : undefined;
+      }
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
   }
   if (patch.costLimitUsd !== undefined) {
     patch.costLimitUsd = patch.costLimitUsd === null ? null : (Number(patch.costLimitUsd) > 0 ? Number(patch.costLimitUsd) : null);

package/lib/task-transfer.js

@@ -162,16 +162,18 @@ export const IMPORT_STRATEGIES = ['add', 'replace', 'skip'];
  * `env` and headers can contain hand-typed secrets, so the caller must not
  * claim the file is secret-free.
  */
-export function buildTaskExport(tasks, { now = Date.now() } = {}) {
+export function buildTaskExport(tasks, { now = Date.now(), sanitize = false } = {}) {
   const list = Array.isArray(tasks) ? tasks : [];
   return {
     kind: TASK_EXPORT_KIND,
     version: TASK_EXPORT_VERSION,
     exportedAt: new Date(now).toISOString(),
+    sanitized: Boolean(sanitize),
     tasks: list.map((task) => {
       const out = {};
       for (const key of EXPORT_TASK_FIELDS) {
         if (task[key] === undefined || key === 'status') continue;
+        if (sanitize && EXPORT_SECRET_BEARING_FIELDS.includes(key)) continue;
         out[key] = Array.isArray(task[key]) ? [...task[key]] : task[key];
       }
       return out;
@@ -215,6 +217,26 @@ export function validateImportDocument(doc) {
     for (const key of DUPLICATE_TASK_FIELDS) {
       if (raw[key] !== undefined) clean[key] = Array.isArray(raw[key]) ? [...raw[key]] : raw[key];
     }
+    if (clean.env && typeof clean.env === 'object') {
+      const filteredEnv = {};
+      for (const [k, v] of Object.entries(clean.env)) {
+        if (typeof v === 'string' && (v.includes('••••') || v.trim() === '********')) {
+          continue; // Masked secret placeholder from UI/doc must never become literal secret (#240)
+        }
+        filteredEnv[k] = v;
+      }
+      clean.env = filteredEnv;
+    }
+    if (clean.httpHeaders && typeof clean.httpHeaders === 'object') {
+      const filteredHeaders = {};
+      for (const [k, v] of Object.entries(clean.httpHeaders)) {
+        if (typeof v === 'string' && (v.includes('••••') || v.trim() === '********')) {
+          continue;
+        }
+        filteredHeaders[k] = v;
+      }
+      clean.httpHeaders = filteredHeaders;
+    }
     if (id) clean.id = id;
     if (channels) clean.channels = channels;
     tasks.push(clean);

package/package.json

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