@goodandready/dsh-cron 0.2.35 → 0.2.37

package/README.md

@@ -186,8 +186,11 @@ Every task picks its own runtime; non-LLM runtimes need no model and consume no
 ### 7. Cost Control: Fallback Model & Burn Guard
 * **Fallback Model** — A task can run on the cheap model by default and still finish on the strong one: set `fallbackModel` (and optionally `fallbackProvider`) and a failed run — `error` or `timeout` — is retried **once** on that model before the ordinary retry backoff applies. History records which model produced the result and whether the fallback was used, usage and cost of both attempts are summed, and the `{model}` template variable renders the model that finished the run. Only agent-mediated tasks (`llm`, `skill`, `workflow`) can use a fallback.
 * **Token & Cost Burn Guard** — Prevent runaway spending by configuring per-task limits: `costLimitUsd` (lifetime spend limit in USD), `dailyCostLimitUsd` (rolling 24-hour spend limit in USD), and `tokenLimit` (lifetime token limit). If a task exceeds any threshold, execution is halted, the task is automatically paused with `pausedReason` (`cost_limit_exceeded`, `daily_cost_limit_exceeded`, or `token_limit_exceeded`), and an alert notification is dispatched across all active channels.
+* **Event-Driven Token & Cost Extraction** — Reads real token usage from DSH session stream events (`assistant/message`, `assistant/chunk` usage, and `assistant/attempt`), accounting for uncached input, cached reads, output tokens, and paid failed attempts across retries.
+* **Rolling 24-Hour Cost Ledger** — Daily burn guard (`dailyCostLimitUsd`) maintains an independent rolling 24h cost ledger per task, preserved in `store.json`. Expenses remain fully counted across history archive rotations (beyond 100 runs) and survive daemon restarts.
 
 ### 8. Session Integration & Permissions
+* **Real Assistant Output & Terminal Status Extraction** — Isolates current turn session events, extracts the actual assistant message text (excluding previous turn history in persistent sessions), and validates terminal turn status (`turn/end` errors or interruptions) to guarantee accurate reporting, chaining, and structured action execution.
 * **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.
@@ -234,12 +237,15 @@ Prevent rogue processes from stacking concurrent duplicate executions:
   * **`skip`** (default): drops the overlapping run and records a `skipped` entry in the run history.
   * **`queue`**: queues the next execution and starts it as soon as the active job completes.
   * **`replace`**: aborts the active run via `AbortController` and launches a fresh execution.
+* **Croner Overlap Policy Delegation** — Scheduled cron ticks fire without upstream suppression (`Croner protect: false`), allowing `skip` (with history logging), `queue` (delayed execution), and `replace` (clean abort) to govern recurring cron ticks and manual triggers consistently.
+* **Context-Preserving Queues** — Both the global concurrency queue and task overlap queue retain full immutable execution context (`chainDepth`, `prevOutput`, `prevTaskId`, `prevStatus`, `prevCostUsd`), preventing data loss under load.
 
 If the daemon was offline at a scheduled time, the run is recorded as `missed` on startup, so gaps in the history stay visible.
 
 ### 14. Heartbeat Monitoring (#16-style dead man's switch)
 * Set `heartbeatUrl` and `heartbeatIntervalSec` in the plugin settings and the scheduler pings that URL on schedule — an external monitor alerts when the pings stop.
 * A built-in `GET /dsh-cron/heartbeat` endpoint reports liveness, active task count and the last run time for your own watchdogs.
+* **Missed Heartbeat Alerts in `onlyOnFailure` Mode** — Missed heartbeats (`status === 'missed'`) are recognized as active failure events across all channel delivery predicates (`channels.js`, `telegram.js`, `integrations.js`), guaranteeing that Telegram, Discord, Webhook, and Kanban integrations alert immediately when an external process fails to report.
 
 ### 15. Declarative Jobs From the Profile Config (#50)
 Long-lived operational jobs can be declared in the profile configuration instead of being recreated by hand in the UI. The config file owns the jobs it declares: at every plugin start they are created or updated, and a job that disappears from the file is removed.
@@ -289,6 +295,7 @@ Set the token as the plugin setting `apiToken` (masked like every secret). Auth
 | `POST` | `/dsh-cron/api/tasks/:id/run` | Force an immediate run |
 
 The operations reuse the panel handlers, so the `x-dsh-cron-confirm: script` gate for code-executing types and the `409` refusals for config-owned tasks behave exactly as in the UI.
+* **Bearer-Guarded Remote Access** — Remote clients can create and update tasks, ping heartbeats (`/dsh-cron/api/heartbeat/:id`), and preview schedules (`/dsh-cron/api/schedule/preview`) with valid `Authorization: Bearer <token>` credentials without loopback IP restrictions.
 
 ```bash
 BASE="http://127.0.0.1:3080"
@@ -382,6 +389,8 @@ Developer-facing, no behaviour change. `parseScheduleExpression` was split into
 - **Priority Queues & Concurrency Pools**: When the concurrent run limit is reached, queued tasks are ordered by `priority` (1 = highest, 10 = lowest) to ensure critical system alerts execute ahead of bulk background jobs.
 - **Self-Healing Runbooks & Auto-Diagnosis**: Failed tasks automatically execute an optional compensatory `selfHealingCommand` (e.g. system service restart or temp cleanup). Model failures can trigger `autoDiagnose: true` to append an instant root-cause diagnosis.
 - **Web UI Archive & Pipeline Visualization**: Interactive archive drawer with pagination and full log viewing; visual indicators for `➜ onSuccess` and `↳ onFailure` task connections.
+- **Shell & Disk Pre-flight Gate Hardening**: Supports both `command` and `shell` types with fail-closed semantics for invalid syntax, unknown types, or inspection failures. Disk space checks support exact path and threshold syntax (e.g. `/:10%`, `/data:500MB`).
+- **Complete Reliability Field Persistence**: HTTP POST task creation/editing and `cron_create_task` tool fully preserve and store all 13 reliability and session configuration fields (`agentPreset`, `targetSessionId`, `targetSessionReset`, `onSuccess`, `onFailure`, `heartbeatIntervalSeconds`, `gracePeriodSeconds`, `preflightType`, `preflightTarget`, `priority`, `concurrencyGroup`, `selfHealingCommand`, `autoDiagnose`, `fallbackProvider`, `fallbackModel`, `silentRule`, `inspectOnFailure`).
 
 ---
 

package/README.ru.md

@@ -186,8 +186,11 @@ cron({
 ### 7. Экономия: fallback-модель и защита бюджета (Burn Guard)
 * **Fallback-модель** — задача может идти на дешёвой модели по умолчанию и всё же завершиться на сильной: задайте `fallbackModel` (и при необходимости `fallbackProvider`), и сбойный запуск (`error` или `timeout`) один раз повторится на этой модели, прежде чем включится обычный retry с задержкой. В истории видно, какая модель произвела результат и был ли использован fallback; расход и стоимость обеих попыток суммируются; переменная шаблона `{model}` подставляет модель, завершившую запуск. Fallback доступен только агентским типам (`llm`, `skill`, `workflow`).
 * **Защита бюджета токенов и расходов (Burn Guard)** — предотвращение неконтролируемых трат через индивидуальные лимиты задачи: `costLimitUsd` (общий лимит расходов в USD), `dailyCostLimitUsd` (суточный лимит за последние 24 часа в USD) и `tokenLimit` (лимит суммарных токенов). При превышении любого порога выполнение прекращается, задача автоматически переводится в паузу с фиксацией `pausedReason` (`cost_limit_exceeded`, `daily_cost_limit_exceeded`, `token_limit_exceeded`), а во все активные каналы отправляется тревожное оповещение.
+* **Учёт токенов и расходов на событиях сессии** — считывание фактического расхода токенов напрямую из событий потока сессии DSH (`assistant/message`, `assistant/chunk` с типом usage, `assistant/attempt`), с разделением некэшированного ввода, чтений кэша, генерации и оплаченных сбойных попыток провайдера при повторах.
+* **Скользящий суточный реестр (24h Cost Ledger)** — суточный лимит `dailyCostLimitUsd` опирается на независимый реестр расходов задачи за последние 24 часа, сохраняемый в `store.json`. Расходы сохраняются при ротации архива истории (свыше 100 запусков) и восстанавливаются после перезапуска службы.
 
 ### 8. Интеграция сессий и права
+* **Извлечение реального ответа ассистента и статуса хода** — выделение событий только текущего хода (без подмешивания истории прошлых ходов долговременных сессий), сборка итогового текста сообщения ассистента и валидация признака завершения (`turn/end` с ошибкой или прерыванием) для безошибочной классификации сбоев, цепочек задач и выполнения директив.
 * **Permission-пресеты на задачу** — `default`, `read-only`, `workspace-write` или `full` применяются к сессии агента перед запуском промпта.
 * **Автоархивация сессий** — изолированные cron-сессии архивируются после запуска (best-effort), не засоряя список чатов.
 * **История → сессия** — каждый LLM-запуск хранит свою сессию; открыть диалог можно прямо из записи истории.
@@ -226,6 +229,8 @@ cron({
   * **`skip`** (по умолчанию): накладывающийся запуск отбрасывается, в истории появляется запись `skipped`;
   * **`queue`**: следующий запуск ставится в очередь и стартует по завершении активного;
   * **`replace`**: активный запуск прерывается через `AbortController`, запускается свежий.
+* **Прямая передача тиков расписания политикам наложения** — тики Croner поступают без подавления на уровне планировщика (`Croner protect: false`), гарантируя одинаковую работу политик `skip` (с записью в историю), `queue` (отложенный запуск) и `replace` (чистый abort) как для cron-расписания, так и для ручных вызовов.
+* **Сохранение контекста очереди** — глобальная очередь конкурентности и очередь наложения сохраняют полный контекст выполнения (`chainDepth`, `prevOutput`, `prevTaskId`, `prevStatus`, `prevCostUsd`), предотвращая потерю параметров цепочек под нагрузкой.
 
 Если сервис был выключен в момент планового запуска, при старте в истории появится запись `missed` — пробелы в истории остаются видимыми.
 
@@ -251,6 +256,8 @@ cron({
 - **Очереди с приоритетами**: При достижении лимита параллелизма задачи упорядочиваются по полю `priority` (1 — наивысший, 10 — низший).
 - **Команды самоисцеления и авто-диагностика (Self-Healing)**: Автоматический запуск компенсирующей команды `selfHealingCommand` при падении задачи; опция `autoDiagnose` для генерации AI-диагностики причин сбоя.
 - **Интерактивный архив логов в UI**: Модальное окно просмотра истории с пагинацией и полным выводом логов, визуальные ссылки конвейеров `➜ onSuccess` и `↳ onFailure`.
+- **Безопасные preflight-проверки shell и диска**: Поддержка типов проверок `command` и `shell` с принципом fail-closed при синтаксических ошибках или сбоях проверки. Проверка диска поддерживает явные пути и пороговые значения (например, `/:10%`, `/data:500MB`).
+- **Полное сохранение параметров надёжности**: Создание и редактирование задач через HTTP POST и агентский инструмент `cron_create_task` полностью сохраняют все 13 полей надёжности и управления сессиями (`agentPreset`, `targetSessionId`, `targetSessionReset`, `onSuccess`, `onFailure`, `heartbeatIntervalSeconds`, `gracePeriodSeconds`, `preflightType`, `preflightTarget`, `priority`, `concurrencyGroup`, `selfHealingCommand`, `autoDiagnose`, `fallbackProvider`, `fallbackModel`, `silentRule`, `inspectOnFailure`).
 
 ---
 
@@ -373,6 +380,7 @@ dsh-cron:
 ### 14. Мониторинг heartbeat (dead man's switch)
 * Задайте `heartbeatUrl` и `heartbeatIntervalSec` в настройках плагина — планировщик будет пинговать этот адрес по расписанию, и внешний монитор сообщит, когда пинги прекратятся.
 * Встроенный эндпоинт `GET /dsh-cron/heartbeat` сообщает живость, число активных задач и время последнего запуска для ваших собственных сторожей.
+* **Оповещения о пропущенных heartbeat в режиме `onlyOnFailure`** — Пропущенные heartbeat (`status === 'missed'`) распознаются как полноценное состояние сбоя во всех фильтрах отправки (`channels.js`, `telegram.js`, `integrations.js`), гарантируя своевременную отправку тревог в Telegram, Discord, Webhook и Kanban при отсутствии отчётов от внешних служб.
 
 ### 15. Задачи из конфига профиля (#50)
 Долгоживущие эксплуатационные задачи можно объявлять в конфиге профиля, а не пересоздавать руками в интерфейсе. Владелец объявленных задач — файл конфига: при каждом старте плагина они создаются или обновляются, а задача, исчезнувшая из файла, удаляется.
@@ -422,6 +430,7 @@ dsh-cron:
 | `POST` | `/dsh-cron/api/tasks/:id/run` | Принудительный немедленный запуск |
 
 Операции переиспользуют обработчики панели, поэтому гейт `x-dsh-cron-confirm: script` для код-исполняющих типов и отказ `409` для конфиг-задач действуют здесь так же, как в UI.
+* **Удалённый доступ по Bearer-токену** — Внешние клиенты с любого разрешённого IP могут создавать и обновлять задачи, отправлять heartbeat-сигналы (`/dsh-cron/api/heartbeat/:id`) и запрашивать предпросмотр расписания (`/dsh-cron/api/schedule/preview`) с валидным `Authorization: Bearer <token>`.
 
 ```bash
 BASE="http://127.0.0.1:3080"

package/README.zh.md

@@ -186,8 +186,11 @@ cron({
 ### 7. 成本控制：回退模型与支出保护（Burn Guard）
 * **回退模型** —— 任务可以默认使用便宜模型，失败时改用更强模型完成：设置 `fallbackModel`（可选 `fallbackProvider`），失败（`error` 或 `timeout`）的运行会在该模型上重试一次，之后才进入常规重试退避。历史记录会标明最终产出结果的模型以及是否使用了回退，两次尝试的用量与成本都会累计，模板变量 `{model}` 渲染完成运行的模型。回退仅适用于智能体类型（`llm`、`skill`、`workflow`）。
 * **Token 与成本支出保护（Burn Guard）** —— 为任务配置严格预算上限：`costLimitUsd`（总支出美元上限）、`dailyCostLimitUsd`（24小时滚动支出上限）和 `tokenLimit`（Token总数上限）。一旦达到任一阈值，任务将自动暂停并记录 `pausedReason`（`cost_limit_exceeded`、`daily_cost_limit_exceeded` 或 `token_limit_exceeded`），同时向所有配置的通知渠道发送报警通知。
+* **基于会话事件的 Token 与成本统计** —— 直接从 DSH 会话流式事件（`assistant/message`、`assistant/chunk` usage、`assistant/attempt`）中提取实际 Token 消耗，精确计入未命中输入、命中缓存读取、生成输出及重试过程中已计费的失败尝试。
+* **滑动 24 小时成本账本（24h Cost Ledger）** —— 日耗保护（`dailyCostLimitUsd`）在 `store.json` 中为每个任务维护独立的滑动 24 小时成本记录。即使历史记录超过 100 条触发归档，24 小时内的所有花费依然完整保留并能跨服务重启持续生效。
 
 ### 8. 会话集成与权限
+* **真实智能体输出与终端状态捕获** —— 隔离当前轮次的会话事件，提取最终真实的智能体回复文本（持久会话中自动排除以往历史轮次），并严格校验轮次终止状态（带有错误或中断的 `turn/end`），确保任务失败能准确反映到执行历史、链路调用及结构化指令中。
 * **按任务的权限预设** —— `default`、`read-only`、`workspace-write` 或 `full` 在提示词执行前应用于任务会话。
 * **会话自动归档** —— 隔离的 cron 会话在运行后自动归档（尽力而为），不干扰聊天列表。
 * **历史 → 会话** —— 每次 LLM 运行都会记录会话，可直接从历史记录打开对话。
@@ -226,12 +229,15 @@ cron({
   * **`skip`**（默认）：丢弃重叠的运行，在历史中记录 `skipped`；
   * **`queue`**：将下一次运行排队，当前任务完成后自动开始；
   * **`replace`**：通过 `AbortController` 中止当前运行并启动新的执行。
+* **调度器重叠策略直达** —— Croner 定时触发不再在上游被静默抑制（`Croner protect: false`），确保定时触发的重叠事件能够完整传递至调度器，严格执行 `skip`（记录历史）、`queue`（延迟排队）与 `replace`（优雅终止）。
+* **队列上下文与链路深度延续** —— 全局并发限制队列与任务重叠队列均完整保留不可变执行参数（`chainDepth`、`prevOutput`、`prevTaskId`、`prevStatus`、`prevCostUsd`），防止高负载或排队时任务链路数据丢失。
 
 如果守护进程在计划时刻处于离线状态，启动时该次运行会被记录为 `missed`，历史空档始终可见。
 
 ### 14. 心跳监控（Dead man's switch）
 * 在插件设置中配置 `heartbeatUrl` 与 `heartbeatIntervalSec`，调度器会按间隔 GET 该地址 —— 外部监控可在心跳停止时告警。
 * 内置 `GET /dsh-cron/heartbeat` 端点返回存活状态、活跃任务数与最近运行时间，便于自建看门狗。
+* **`onlyOnFailure` 模式支持心跳超时告警** — 遗漏心跳（`status === 'missed'`）在各通知渠道过滤判定（`channels.js`、`telegram.js`、`integrations.js`）中被统一视作失败状态，确保外部守护进程中断时 Telegram、Discord、Webhook 与看板即刻告警。
 
 ### 15. 来自配置的声明式任务（#50）
 长期运行的任务可以直接声明在配置文件里，而无需在界面中手工重建。配置文件拥有这些任务：每次插件启动时会创建或更新它们，从文件中消失的任务会被删除。
@@ -281,6 +287,7 @@ dsh-cron:
 | `POST` | `/dsh-cron/api/tasks/:id/run` | 强制执行一次 |
 
 这些操作复用面板处理器，因此对会执行代码类型的 `x-dsh-cron-confirm: script` 门禁以及对配置任务的 `409` 拒绝与 UI 完全一致。
+* **Bearer Token 远程访问支持** — 远程客户端凭有效 `Authorization: Bearer <token>` 凭据可直接创建/修改任务、打卡心跳（`/dsh-cron/api/heartbeat/:id`）及预览调度（`/dsh-cron/api/schedule/preview`），解除非本机限制。
 
 ```bash
 BASE="http://127.0.0.1:3080"
@@ -363,7 +370,7 @@ bash deploy.sh verify [exact-version]
 ### 22. 自动化、任务链与可观测性包（v0.2.10，#137）
 - **Telegram 双向交互控制**：任务通知附带内嵌操作按钮（`🚀 立即运行`、`⏸️ 暂停/恢复`、`📋 最新日志`）。由 `POST /dsh-cron/telegram/webhook` 处理，严格鉴权 Chat ID 并调用 `answerCallbackQuery` 反馈。
 - **任务链上下文与动态变量插值**：配置 `onSuccess` 与 `onFailure` 下游触发器。父任务的执行结果与元数据自动传递给子任务，在 Shell 任务中提供 `$DSH_PREV_OUTPUT`、`$DSH_PREV_TASK_ID`、`$DSH_PREV_STATUS` 环境变量，在 LLM Prompt 中支持 `{{prev.output}}`（或 `{{prevOutput}}`）、`{{prev.taskId}}`、`{{prev.status}}` 占位符插值。Prompt 额外支持动态运行时时间与元数据变量：`{{date}}`、`{{time}}`、`{{datetime}}`、`{{timestamp}}`、`{{year}}`、`{{month}}`、`{{day}}`、`{{taskId}}`、`{{taskName}}`、`{{runCount}}`。内置最大 5 级深度递归防护，杜绝死循环。
-- **模型结构化动作指令**：自主分析任务可输出 JSON 指令触发级联任务（`trigger_task`）、定向告警（`notify`）或创建 Issue。受 `llmActionsEnabled: false` 严格保护。
+- **模型结构化动作指令**：自主分析任务可输出 JSON 指令触发级联任务（`trigger_task`）、定向告警（`notify`）或创建 Issue。受 `llmActionsEnabled: false` 严格保护。`trigger_task` 指令共享全局链路深度上限（`chainDepth < 4`，最大 5 层调用），彻底阻断自调用死循环与 A → B → A 循环递归，拒绝原因完整记入历史与操作日志中。
 - **历史归档与延迟洞察**：REST 接口 `GET /dsh-cron/tasks/:id/archive`（支持分页）与 `GET /dsh-cron/tasks/:id/stats`；UI 任务卡片展示耗时彩色徽章（<5s 绿，<30s 黄，≥30s 红）。
 - **Prometheus 监控增强**：`/dsh-cron/metrics` 导出当前活动并发量 `dsh_cron_concurrent_running`、各任务 Token 计数器及成本预估指标。
 
@@ -374,6 +381,8 @@ bash deploy.sh verify [exact-version]
 - **优先级队列与并发池（Priority Queues）**：并发满载时，等待队列严格依据任务 `priority`（1 最高，10 最低）调度。
 - **自愈脚本与 AI 根因诊断（Self-Healing）**：任务失败后自动执行补偿指令 `selfHealingCommand`（例如重启服务或清理临时空间）；`autoDiagnose` 自动生成 AI 故障根因摘要。
 - **UI 交互式归档与管道全景**：支持分页浏览任务历史运行全量输出，直观展示 `➜ 成功触发` 与 `↳ 失败触发` 关联关系。
+- **Shell 与磁盘前置检查强化**：前置检查统一支持 `command` 与 `shell` 类型，未知类型或异常格式一律安全关闭（fail-closed）；磁盘检查支持完整路径与阈值（如 `/:10%`、`/data:500MB`）。
+- **可靠性与会话字段完整持久化**：HTTP POST 任务创建/修改接口与 `cron_create_task` 智能体工具完整保留并存储全部 13 个可靠性与会话高级字段（`agentPreset`、`targetSessionId`、`targetSessionReset`、`onSuccess`、`onFailure`、`heartbeatIntervalSeconds`、`gracePeriodSeconds`、`preflightType`、`preflightTarget`、`priority`、`concurrencyGroup`、`selfHealingCommand`、`autoDiagnose`、`fallbackProvider`、`fallbackModel`、`silentRule`、`inspectOnFailure`）。
 
 ---
 

package/lib/api-helpers.js

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

package/lib/api.js

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

package/lib/burn-guard.js

@@ -14,10 +14,20 @@ import { bestEffort } from './best-effort.js';
  * @param {number} now
  * @returns {number}
  */
-export function calculateRollingCost(runs = [], windowMs = 86400000, now = Date.now()) {
+export function calculateRollingCost(runsOrTask = [], windowMs = 86400000, now = Date.now()) {
   const cutoff = now - windowMs;
+  let items = [];
+  if (Array.isArray(runsOrTask)) {
+    items = runsOrTask;
+  } else if (runsOrTask && typeof runsOrTask === 'object') {
+    if (Array.isArray(runsOrTask.costLedger) && runsOrTask.costLedger.length > 0) {
+      items = runsOrTask.costLedger;
+    } else if (Array.isArray(runsOrTask.runs)) {
+      items = runsOrTask.runs;
+    }
+  }
   let total = 0;
-  for (const r of runs) {
+  for (const r of items) {
     if (r && typeof r.at === 'number' && r.at >= cutoff) {
       total += Number(r.costUsd) || 0;
     }
@@ -32,14 +42,28 @@ export function calculateRollingCost(runs = [], windowMs = 86400000, now = Date.
  * @param {number} now
  * @returns {number}
  */
-export function calculateRollingTokens(runs = [], windowMs = 86400000, now = Date.now()) {
+export function calculateRollingTokens(runsOrTask = [], windowMs = 86400000, now = Date.now()) {
   const cutoff = now - windowMs;
+  let items = [];
+  if (Array.isArray(runsOrTask)) {
+    items = runsOrTask;
+  } else if (runsOrTask && typeof runsOrTask === 'object') {
+    if (Array.isArray(runsOrTask.costLedger) && runsOrTask.costLedger.length > 0) {
+      items = runsOrTask.costLedger;
+    } else if (Array.isArray(runsOrTask.runs)) {
+      items = runsOrTask.runs;
+    }
+  }
   let total = 0;
-  for (const r of runs) {
+  for (const r of items) {
     if (r && typeof r.at === 'number' && r.at >= cutoff) {
-      const u = r.usage;
-      const tokens = (u?.inputTokens || 0) + (u?.outputTokens || 0) + (u?.cacheReadTokens || 0);
-      total += tokens;
+      if (typeof r.tokens === 'number') {
+        total += r.tokens;
+      } else {
+        const u = r.usage;
+        const tokens = (u?.inputTokens || 0) + (u?.outputTokens || 0) + (u?.cacheReadTokens || 0);
+        total += tokens;
+      }
     }
   }
   return total;
@@ -70,10 +94,11 @@ export function checkTaskBudgetLimits(task, runs = [], now = Date.now()) {
     }
   }
 
-  // 2. Rolling 24h daily cost limit in USD
+  // 2. Rolling 24h daily cost limit in USD (#221)
   const dailyCostLimit = Number(task.dailyCostLimitUsd);
   if (dailyCostLimit > 0) {
-    const dailyCost = calculateRollingCost(runs, 86400000, now);
+    const source = (Array.isArray(task.costLedger) && task.costLedger.length > 0) ? task.costLedger : runs;
+    const dailyCost = calculateRollingCost(source, 86400000, now);
     if (dailyCost >= dailyCostLimit) {
       return {
         exceeded: true,

package/lib/channels.js

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

package/lib/cron-tool.js

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

package/lib/external-api.js

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

package/lib/integrations.js

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

package/lib/llm-actions.js

@@ -65,7 +65,7 @@ function collectDirectives(obj, list) {
 /**
  * Execute parsed LLM action directives if enabled in plugin settings (#137).
  */
-export async function executeLlmActionDirectives({ directives, task, runInfo, scheduler, store, settings = {}, fetchFn = globalThis.fetch }) {
+export async function executeLlmActionDirectives({ directives, task, runInfo, scheduler, store, settings = {}, fetchFn = globalThis.fetch, options = {} }) {
   if (!Array.isArray(directives) || directives.length === 0) return [];
   if (!settings.llmActionsEnabled) {
     return [];
@@ -78,11 +78,22 @@ export async function executeLlmActionDirectives({ directives, task, runInfo, sc
       if (type === 'trigger_task' || type === 'run_task') {
         const targetId = dir.taskId || dir.payload?.taskId;
         if (targetId && typeof scheduler.runNow === 'function') {
+          const currentDepth = options?.chainDepth || 0;
+          if (currentDepth >= 4) {
+            const limitMsg = `Structured action trigger_task recursion limit reached (depth ${currentDepth}). Target "${targetId}" not triggered.`;
+            logger.warn(`[dsh-cron] ${limitMsg}`);
+            results.push({ type, targetId, status: 'rejected', error: limitMsg, depth: currentDepth });
+            continue;
+          }
           await scheduler.runNow(targetId, {
+            chainDepth: currentDepth + 1,
             prevOutput: runInfo?.output || '',
             prevTaskId: task?.id || '',
+            prevStatus: runInfo?.status || 'success',
+            prevCostUsd: runInfo?.costUsd || 0,
+            prevDurationMs: runInfo?.durationMs || 0,
           });
-          results.push({ type, targetId, status: 'triggered' });
+          results.push({ type, targetId, status: 'triggered', depth: currentDepth + 1 });
         }
       } else if (type === 'notify') {
         const msg = dir.message || dir.text || dir.payload?.message;

package/lib/runner.js

@@ -324,7 +324,7 @@ export class SessionRunner {
 
   /** Create the session, drive one turn, and always clean up. */
   async _executeAgentTurn(task, prep) {
-    let handle = null;
+    let handle = prep?.handle || null;
     let isResumed = false;
     try {
       // Resolve agent preset (#GH-1, #GH-2): scheduled llm sessions must join an agent preset
@@ -397,6 +397,13 @@ export class SessionRunner {
 
       this._applyPermissionPreset(task, handle);
       await prep.raceAbort(handle.agent.whenIdle());
+
+      // 1. Capture starting sequence before sending user message (#227, #228)
+      const session = handle.agent.session;
+      const startSeq = (session && typeof session.seq === 'number')
+        ? session.seq
+        : (Array.isArray(session?.log) ? session.log.length : 0);
+
       handle.agent.followup(prep.createUserMessage({
         content: [{ type: 'text', text: prep.agentPrompt }],
         source: { kind: 'plugin:dsh-cron', form: 'cron-execute' },
@@ -405,12 +412,73 @@ export class SessionRunner {
       if (typeof handle.agent.whenIdle === 'function') {
         await prep.raceAbort(handle.agent.whenIdle());
       }
-      const usage = this._extractUsage(handle);
-      const sessionNote = isResumed
-        ? `resumed: ${prep.targetSessionId}`
-        : `session: ${handle.agent.session?.id || 'cron'}`;
+
+      // 2. Snapshot events from this turn only (#227, #228)
+      let turnEvents = [];
+      if (typeof session?.snapshotEvents === 'function') {
+        turnEvents = session.snapshotEvents(startSeq) || [];
+      } else if (Array.isArray(session?.log)) {
+        turnEvents = session.log.slice(startSeq);
+      } else if (Array.isArray(handle.agent?.log)) {
+        turnEvents = handle.agent.log.slice(startSeq);
+      }
+
+      // 3. Terminal turn failure check (#227)
+      for (const ev of turnEvents) {
+        if (!ev) continue;
+        if (ev.type === 'turn/end' || ev.type === 'turn/error' || ev.type === 'turn/failure') {
+          const reason = ev.data?.reason || ev.reason;
+          const reasonKind = (reason && typeof reason === 'object') ? reason.kind : reason;
+          if (['error', 'interrupted', 'failed', 'aborted'].includes(reasonKind) || ev.data?.error || ev.error) {
+            const errMsg = ev.data?.error?.message || ev.error?.message || reason?.message || (typeof reason === 'string' ? reason : 'Agent turn ended with error');
+            const err = new Error(errMsg);
+            err.reason = reason;
+            err.turnFailed = true;
+            throw err;
+          }
+        }
+      }
+
+      // 4. Extract assistant message text from turn events (#227)
+      const messageTexts = [];
+      const chunkTexts = [];
+      for (const ev of turnEvents) {
+        if (!ev) continue;
+        if (ev.type === 'assistant/message') {
+          const msg = ev.data?.message || ev.data;
+          if (msg) {
+            if (typeof msg.content === 'string' && msg.content.trim()) {
+              messageTexts.push(msg.content.trim());
+            } else if (Array.isArray(msg.content)) {
+              const parts = msg.content
+                .filter((p) => p && p.type === 'text' && typeof p.text === 'string')
+                .map((p) => p.text)
+                .join('');
+              if (parts.trim()) messageTexts.push(parts.trim());
+            }
+          }
+        } else if (ev.type === 'assistant/chunk' && ev.data?.chunk) {
+          const chunk = ev.data.chunk;
+          if (chunk.type === 'text' && typeof chunk.text === 'string') {
+            chunkTexts.push(chunk.text);
+          } else if (chunk.type === 'text-delta' && typeof chunk.delta === 'string') {
+            chunkTexts.push(chunk.delta);
+          }
+        }
+      }
+      let outputText = messageTexts.length > 0 ? messageTexts.join('\n') : chunkTexts.join('');
+
+      // Fallback if no assistant message text was extracted from turn events
+      if (!outputText.trim()) {
+        const sessionNote = isResumed
+          ? `resumed: ${prep.targetSessionId}`
+          : `session: ${handle.agent.session?.id || 'cron'}`;
+        outputText = `[dsh-cron] Agent finished turn for task "${task.title}" (${sessionNote})`;
+      }
+
+      const usage = this._extractUsage(handle, turnEvents);
       return {
-        output: `[dsh-cron] Agent finished turn for task "${task.title}" (${sessionNote})`,
+        output: outputText,
         usage,
         costUsd: estimateTokenCost(prep.model, usage),
         sessionId: handle.agent.session?.id || null,
@@ -433,17 +501,95 @@ export class SessionRunner {
     }
   }
 
-  /** Token usage reported by the session, when the core exposes it. */
-  _extractUsage(handle) {
+  /** Token usage reported by session events or the handle (#228). */
+  _extractUsage(handle, turnEvents = []) {
     const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
-    bestEffort('extract-session-usage', () => {
-      const sessionUsage = handle.agent.session?.usage || handle.agent.usage;
-      if (sessionUsage) {
-        usage.inputTokens = sessionUsage.inputTokens || sessionUsage.promptTokens || 0;
-        usage.outputTokens = sessionUsage.outputTokens || sessionUsage.completionTokens || 0;
-        usage.cacheReadTokens = sessionUsage.cacheReadTokens || sessionUsage.cachedTokens || 0;
+    let hasEventUsage = false;
+
+    bestEffort('extract-session-events-usage', () => {
+      const stepUsage = new Map();
+      const failedAttempts = [];
+
+      for (const ev of turnEvents) {
+        if (!ev || !ev.type) continue;
+
+        // assistant/chunk with usage type
+        if (ev.type === 'assistant/chunk' && ev.data?.chunk?.type === 'usage' && ev.data.chunk.usage) {
+          const u = ev.data.chunk.usage;
+          const key = `${ev.data.turn || 0}:${ev.data.step || 0}`;
+          if (!stepUsage.has(key)) {
+            stepUsage.set(key, {
+              inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
+              outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
+              cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
+            });
+            hasEventUsage = true;
+          }
+        }
+
+        // assistant/message finalized usage overwrites intermediate chunk usage for this step
+        if (ev.type === 'assistant/message') {
+          const u = ev.data?.usage || ev.data?.message?.usage;
+          if (u) {
+            const key = `${ev.data.turn || 0}:${ev.data.step || 0}`;
+            stepUsage.set(key, {
+              inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
+              outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
+              cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
+            });
+            hasEventUsage = true;
+          }
+        }
+
+        // assistant/attempt usage (e.g. paid failed attempts or retry attempts)
+        if (ev.type === 'assistant/attempt' && ev.data?.usage) {
+          const u = ev.data.usage;
+          if (ev.data.failed || ev.data.error || ev.data.status === 'failed') {
+            failedAttempts.push({
+              inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
+              outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
+              cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
+            });
+            hasEventUsage = true;
+          } else {
+            const key = `${ev.data.turn || 0}:${ev.data.step || 0}`;
+            if (!stepUsage.has(key)) {
+              stepUsage.set(key, {
+                inputTokens: Number(u.inputTokens || u.promptTokens || u.uncachedInputTokens) || 0,
+                outputTokens: Number(u.outputTokens || u.completionTokens) || 0,
+                cacheReadTokens: Number(u.cacheReadTokens || u.cachedTokens) || 0,
+              });
+              hasEventUsage = true;
+            }
+          }
+        }
+      }
+
+      if (hasEventUsage) {
+        for (const item of stepUsage.values()) {
+          usage.inputTokens += item.inputTokens;
+          usage.outputTokens += item.outputTokens;
+          usage.cacheReadTokens += item.cacheReadTokens;
+        }
+        for (const item of failedAttempts) {
+          usage.inputTokens += item.inputTokens;
+          usage.outputTokens += item.outputTokens;
+          usage.cacheReadTokens += item.cacheReadTokens;
+        }
       }
     });
+
+    if (!hasEventUsage) {
+      bestEffort('extract-session-usage-fallback', () => {
+        const sessionUsage = handle?.agent?.session?.usage || handle?.agent?.usage;
+        if (sessionUsage) {
+          usage.inputTokens = Number(sessionUsage.inputTokens || sessionUsage.promptTokens) || 0;
+          usage.outputTokens = Number(sessionUsage.outputTokens || sessionUsage.completionTokens) || 0;
+          usage.cacheReadTokens = Number(sessionUsage.cacheReadTokens || sessionUsage.cachedTokens) || 0;
+        }
+      });
+    }
+
     return usage;
   }
 

package/lib/scheduler-execution.js

@@ -24,12 +24,21 @@ export function addUsage(a, b) {
  * Execute pre-flight check gate before running task body.
  */
 export async function executePreflight(task) {
-  const type = String(task.preflightType || 'none').toLowerCase();
+  const type = String(task.preflightType || 'none').trim().toLowerCase();
   const target = String(task.preflightTarget || '').trim();
-  if (!type || type === 'none' || !target) {
+  if (!type || type === 'none') {
     return { ok: true };
   }
 
+  const KNOWN_PREFLIGHT_TYPES = ['http', 'command', 'shell', 'disk'];
+  if (!KNOWN_PREFLIGHT_TYPES.includes(type)) {
+    return { ok: false, reason: `Unknown preflight type "${type}"` };
+  }
+
+  if (!target) {
+    return { ok: false, reason: `Preflight target is required for type "${type}"` };
+  }
+
   if (type === 'http') {
     try {
       const controller = new AbortController();
@@ -43,7 +52,7 @@ export async function executePreflight(task) {
     }
   }
 
-  if (type === 'command') {
+  if (type === 'command' || type === 'shell') {
     return new Promise((resolve) => {
       exec(target, { timeout: 5000 }, (err, stdout, stderr) => {
         if (err) {
@@ -56,23 +65,49 @@ export async function executePreflight(task) {
   }
 
   if (type === 'disk') {
-    const requiredMb = Number(target) || 100;
+    let diskPath = task.cwd || process.cwd();
+    let requirement = target;
+
+    // Check for "path:requirement", taking care not to split Windows drive letters (e.g. C:\:10%)
+    const lastColon = target.lastIndexOf(':');
+    if (lastColon > 0) {
+      const candidatePath = target.slice(0, lastColon).trim();
+      const candidateReq = target.slice(lastColon + 1).trim();
+      if (candidateReq) {
+        diskPath = candidatePath;
+        requirement = candidateReq;
+      }
+    }
+
+    const isPercent = requirement.endsWith('%');
+    const numericVal = parseFloat(requirement);
+    if (isNaN(numericVal) || numericVal <= 0) {
+      return { ok: false, reason: `Invalid preflight disk target requirement: "${requirement}"` };
+    }
+
     try {
-      if (typeof fs.statfsSync === 'function') {
-        const stats = fs.statfsSync(process.cwd());
+      if (typeof fs.statfsSync !== 'function') {
+        return { ok: false, reason: 'statfsSync is not available on this platform' };
+      }
+      const stats = fs.statfsSync(diskPath);
+      if (isPercent) {
+        const freePercent = stats.blocks > 0 ? (stats.bavail / stats.blocks) * 100 : 0;
+        if (freePercent < numericVal) {
+          return { ok: false, reason: `Free disk space on "${diskPath}" (${freePercent.toFixed(1)}%) is below required ${numericVal}%` };
+        }
+      } else {
         const freeMb = Math.round((stats.bavail * stats.bsize) / (1024 * 1024));
-        if (freeMb < requiredMb) {
-          return { ok: false, reason: `Free disk space (${freeMb} MB) is below required ${requiredMb} MB` };
+        if (freeMb < numericVal) {
+          return { ok: false, reason: `Free disk space on "${diskPath}" (${freeMb} MB) is below required ${numericVal} MB` };
         }
       }
       return { ok: true };
     } catch (err) {
-      // Fail-open if statfsSync is unavailable or throws
-      return { ok: true };
+      return { ok: false, reason: `Preflight disk check failed: filesystem "${diskPath}" not accessible (${err.message})` };
     }
   }
 
-  return { ok: true };
+  return { ok: false, reason: `Unsupported preflight type "${type}"` };
 }
 
 /** Only agent-mediated types use a model, and only a failed run falls back. */
@@ -141,12 +176,17 @@ export async function executeWithFallback(scheduler, task, signal, options = {})
 /**
  * Begin a task run with concurrency and overlap policy checks.
  */
-export function beginRun(scheduler, task, taskId) {
+export function beginRun(scheduler, task, taskId, options = {}) {
   if (scheduler.isStopped) return null;
   if (!scheduler.running.has(taskId) && scheduler.maxConcurrent > 0 && scheduler.running.size >= scheduler.maxConcurrent) {
     if (task.overlapPolicy === 'queue') {
       logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${scheduler.maxConcurrent})`);
-      scheduler.queue.push({ taskId, priority: task.priority !== undefined ? task.priority : 5, queuedAt: Date.now() });
+      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;
     }
@@ -169,14 +209,23 @@ export function beginRun(scheduler, task, taskId) {
     }
     if (overlapPolicy === 'queue') {
       logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
-      active.queueCount = (active.queueCount || 0) + 1;
+      active.queuedRuns = active.queuedRuns || [];
+      active.queuedRuns.push({ options: { ...options }, queuedAt: Date.now() });
+      active.queueCount = active.queuedRuns.length;
       return null;
     }
   }
 
   const controller = new AbortController();
   const runId = 'run_' + Math.random().toString(36).slice(2, 9) + '_' + Date.now();
-  const currentRun = { id: runId, controller, startedAt: Date.now(), queueCount: 0 };
+  const pendingOverlap = Array.isArray(options?.pendingOverlapQueue) ? options.pendingOverlapQueue : [];
+  const currentRun = {
+    id: runId,
+    controller,
+    startedAt: Date.now(),
+    queuedRuns: pendingOverlap,
+    queueCount: pendingOverlap.length,
+  };
   scheduler.running.set(taskId, currentRun);
   return currentRun;
 }
@@ -221,7 +270,7 @@ export async function executeTask(scheduler, taskId, options = {}) {
     };
   }
 
-  const currentRun = scheduler.beginRun(task, taskId);
+  const currentRun = scheduler.beginRun(task, taskId, options);
   if (currentRun === null) return null;
 
   const preflight = await executePreflight(task);
@@ -391,9 +440,15 @@ export function finishRun(scheduler, taskSnapshot, taskId, status, queuedCount,
   }
 
   if (queuedCount > 0 && !scheduler.isStopped) {
+    const queuedRuns = Array.isArray(meta?.queuedRuns) ? [...meta.queuedRuns] : [];
+    const nextItem = queuedRuns.shift();
+    const nextOptions = {
+      ...(nextItem?.options || {}),
+      ...(queuedRuns.length > 0 ? { pendingOverlapQueue: queuedRuns } : {}),
+    };
     setImmediate(() => {
       if (!scheduler.isStopped) {
-        scheduler.runTask(taskId);
+        scheduler.runTask(taskId, nextOptions);
       }
     });
   }
@@ -462,10 +517,15 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   const finishedRun = scheduler.running.get(taskId);
   const isCurrentRun = (finishedRun === currentRun);
   if (isCurrentRun) scheduler.running.delete(taskId);
+  const queuedRuns = isCurrentRun ? (finishedRun?.queuedRuns || []) : [];
   const queuedCount = isCurrentRun ? (finishedRun?.queueCount || 0) : 0;
 
   if (!silent.skipped) await scheduler.deliverNotifications(task, runInfo);
-  scheduler.finishRun(task, taskId, outcome.status, queuedCount, { isCurrentRun, runId: currentRun?.id });
+  scheduler.finishRun(task, taskId, outcome.status, queuedCount, {
+    isCurrentRun,
+    runId: currentRun?.id,
+    queuedRuns,
+  });
 
   if (scheduler.isStopped) return;
 
@@ -479,7 +539,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     if (queuedTask && queuedTask.status === 'active' && !scheduler.isStopped) {
       setImmediate(() => {
         if (!scheduler.isStopped) {
-          scheduler.runTask(nextItem.taskId).catch((runErr) => {
+          scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
             bestEffort('drain-queued-task', () => {}, scheduler.logger);
           });
         }
@@ -495,14 +555,18 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
       if (settings.llmActionsEnabled) {
         const directives = parseLlmActionDirectives(outcome.output);
         if (directives.length > 0) {
-          await executeLlmActionDirectives({
+          const actionResults = await executeLlmActionDirectives({
             directives,
             task,
             runInfo,
             scheduler,
             store: scheduler.store,
             settings,
+            options,
           });
+          if (actionResults && actionResults.length > 0) {
+            runInfo.actionResults = actionResults;
+          }
         }
       }
     } catch (actErr) {

package/lib/scheduler.js

@@ -393,7 +393,6 @@ export class TaskScheduler {
   scheduleCron(task, parsed) {
     const timezone = task.timezone || this.defaultTimezone || undefined;
     const job = new Cron(parsed.cronPattern, {
-      protect: true,
       sloppyRanges: true,
       catch: (err) => logger.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
       ...(timezone ? { timezone } : {}),
@@ -426,8 +425,8 @@ export class TaskScheduler {
     }
   }
 
-  beginRun(task, taskId) {
-    return beginRun(this, task, taskId);
+  beginRun(task, taskId, options = {}) {
+    return beginRun(this, task, taskId, options);
   }
 
   countRun(status) {

package/lib/store.js

@@ -53,7 +53,22 @@ export class TaskStore {
       this.tasks.clear();
       this.history.clear();
       if (Array.isArray(data.tasks)) {
+        const now = Date.now();
+        const cutoff24h = now - 86400000;
         for (const t of data.tasks) {
+          if (Array.isArray(t.costLedger) && t.costLedger.length > 0) {
+            t.costLedger = t.costLedger.filter(e => e && typeof e.at === 'number' && e.at >= cutoff24h);
+          } else {
+            // Seed from active history if present (#221)
+            const hist = (data.history && Array.isArray(data.history[t.id])) ? data.history[t.id] : [];
+            t.costLedger = hist
+              .filter(r => r && typeof r.at === 'number' && r.at >= cutoff24h)
+              .map(r => ({
+                at: r.at,
+                costUsd: Number(r.costUsd) || 0,
+                tokens: (r.usage?.inputTokens || 0) + (r.usage?.outputTokens || 0) + (r.usage?.cacheReadTokens || 0),
+              }));
+          }
           this.tasks.set(t.id, t);
         }
       }
@@ -424,6 +439,18 @@ export class TaskStore {
     task.totalCostUsd = Number(((task.totalCostUsd || 0) + costUsd).toFixed(6));
     task.updatedAt = Date.now();
 
+    // Rolling 24h cost ledger preserved across archive rotation and restarts (#221)
+    if (!Array.isArray(task.costLedger)) {
+      task.costLedger = [];
+    }
+    task.costLedger.push({
+      at: task.lastRunAt,
+      costUsd,
+      tokens: runTokens,
+    });
+    const cutoff24h = Date.now() - 86400000;
+    task.costLedger = task.costLedger.filter(e => e && typeof e.at === 'number' && e.at >= cutoff24h);
+
     const runs = this.history.get(id) || [];
     runs.unshift({
       id: 'run_' + Math.random().toString(36).slice(2, 9),

package/lib/task-create.js

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

package/lib/task-patch.js

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

package/lib/task-transfer.js

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

package/lib/telegram.js

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

package/package.json

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