@goodandready/dsh-cron 0.2.34 → 0.2.36

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,6 +237,8 @@ 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.
 

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` — пробелы в истории остаются видимыми.
 

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,6 +229,8 @@ cron({
   * **`skip`**（默认）：丢弃重叠的运行，在历史中记录 `skipped`；
   * **`queue`**：将下一次运行排队，当前任务完成后自动开始；
   * **`replace`**：通过 `AbortController` 中止当前运行并启动新的执行。
+* **调度器重叠策略直达** —— Croner 定时触发不再在上游被静默抑制（`Croner protect: false`），确保定时触发的重叠事件能够完整传递至调度器，严格执行 `skip`（记录历史）、`queue`（延迟排队）与 `replace`（优雅终止）。
+* **队列上下文与链路深度延续** —— 全局并发限制队列与任务重叠队列均完整保留不可变执行参数（`chainDepth`、`prevOutput`、`prevTaskId`、`prevStatus`、`prevCostUsd`），防止高负载或排队时任务链路数据丢失。
 
 如果守护进程在计划时刻处于离线状态，启动时该次运行会被记录为 `missed`，历史空档始终可见。
 
@@ -363,7 +368,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 计数器及成本预估指标。
 

package/lib/api.js

@@ -218,7 +218,13 @@ async function createOrUpdateTask({ store, scheduler, req, res, apiToken }) {
       return;
     }
   }
-  const task = store.set(buildTaskRecord(store, body, taskType, parsed));
+  let task;
+  try {
+    task = store.set(buildTaskRecord(store, body, taskType, parsed));
+  } catch (err) {
+    sendJson(res, 500, { ok: false, error: 'Failed to persist task: ' + err.message });
+    return;
+  }
   if (task.status === 'active') {
     scheduler.scheduleTask(task);
   } else {
@@ -345,7 +351,12 @@ async function handleItemPost({ store, scheduler, req, res, url, id, action }) {
       return true;
     }
     const copy = buildDuplicateTask(source, { id: randomUUID() });
-    store.set(copy);
+    try {
+      store.set(copy);
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: 'Failed to persist duplicate task: ' + err.message });
+      return true;
+    }
     // A copy starts paused: it must never fire on its own before the user
     // reviews the schedule (a duplicated one-shot may point at a past time).
     scheduler.pauseTask(copy.id);
@@ -402,7 +413,7 @@ async function patchTask({ store, scheduler, req, res, id }) {
     allowCodeSwitch: req.headers[SCRIPT_CONFIRM_HEADER] === 'script',
   });
   if (!result.ok) {
-    const status = result.notFound ? 404 : (result.needsConfirmation ? 403 : 400);
+    const status = result.status || (result.notFound ? 404 : (result.needsConfirmation ? 403 : 400));
     const error = result.needsConfirmation
       ? `Switching a task to the ${normalizeTaskType(body.type)} type over HTTP requires the ${SCRIPT_CONFIRM_HEADER}: script header`
       : result.error;
@@ -428,7 +439,12 @@ function deleteTask({ store, scheduler, res, id }) {
     } else if (scheduler) {
       scheduler.pauseTask(id);
     }
-    store.delete(id);
+    try {
+      store.delete(id);
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: 'Failed to delete task: ' + err.message });
+      return;
+    }
   }
   sendJson(res, 200, { ok: true });
 }

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/index.js

@@ -198,6 +198,7 @@ export function apply(ctx, rawConfig) {
     return () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
       scheduler.stopAll();
+      bestEffort('lifecycle-store-flush', () => store.flushSync(), logger);
     };
   }, 'dsh-cron: lifecycle');
 

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

@@ -141,11 +141,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;
     }
@@ -168,13 +174,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 currentRun = { controller, startedAt: Date.now(), queueCount: 0 };
+  const runId = 'run_' + Math.random().toString(36).slice(2, 9) + '_' + Date.now();
+  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;
 }
@@ -183,6 +199,7 @@ export function beginRun(scheduler, task, taskId) {
  * Run task by ID.
  */
 export async function executeTask(scheduler, taskId, options = {}) {
+  if (scheduler.isStopped) return null;
   const task = scheduler.store.get(taskId);
   if (!task) return null;
 
@@ -218,7 +235,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);
@@ -328,19 +345,32 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
 /**
  * Post-run bookkeeping: one-shot completion, next-run timestamp, retry backoff, draining.
  */
-export function finishRun(scheduler, task, taskId, status, queuedCount) {
+export function finishRun(scheduler, taskSnapshot, taskId, status, queuedCount, meta = {}) {
   scheduler.countRun(status);
+
+  // If this run was superseded by a newer run or scheduler is stopped, skip updating task
+  if (meta.isCurrentRun === false || scheduler.isStopped) {
+    return;
+  }
+
+  // Refetch live task from store to avoid resurrecting deleted task or overwriting edits (#215)
+  const current = scheduler.store.get(taskId);
+  if (!current) {
+    logger.info(`[dsh-cron] finishRun: task "${taskId}" no longer exists in store; skipping completion write`);
+    return;
+  }
+
   try {
-    if (task.oneShot) {
-      task.status = 'completed';
-      task.nextRunAt = null;
-      scheduler.store.set(task);
+    if (current.oneShot) {
+      current.status = 'completed';
+      current.nextRunAt = null;
+      scheduler.store.set(current);
     } else {
       const job = scheduler.jobs.get(taskId);
       if (job) {
         const next = job.nextRun();
-        task.nextRunAt = next ? next.getTime() : null;
-        scheduler.store.set(task);
+        current.nextRunAt = next ? next.getTime() : null;
+        scheduler.store.set(current);
       }
     }
   } catch (err) {
@@ -349,32 +379,42 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
 
   try {
     const failed = status === 'error' || status === 'timeout';
-    const maxRetries = Number(task.maxRetries) > 0 ? Number(task.maxRetries) : 0;
-    if (failed && maxRetries > 0 && (task.attempts || 0) < maxRetries && task.status !== 'paused') {
-      task.attempts = (task.attempts || 0) + 1;
-      const backoffMs = (Number(task.retryBackoffMs) > 0 ? Number(task.retryBackoffMs) : 30000) * Math.pow(2, task.attempts - 1);
-      const attempt = task.attempts;
-      scheduler.store.set(task);
+    const maxRetries = Number(current.maxRetries) > 0 ? Number(current.maxRetries) : 0;
+    if (failed && maxRetries > 0 && (current.attempts || 0) < maxRetries && current.status !== 'paused' && !scheduler.isStopped) {
+      current.attempts = (current.attempts || 0) + 1;
+      const backoffMs = (Number(current.retryBackoffMs) > 0 ? Number(current.retryBackoffMs) : 30000) * Math.pow(2, current.attempts - 1);
+      const attempt = current.attempts;
+      scheduler.store.set(current);
       scheduler.clearRetryTimer(taskId);
       scheduler.retryTimers.set(taskId, setTimeout(() => {
         scheduler.retryTimers.delete(taskId);
-        scheduler.runTask(taskId, { isRetry: true });
+        if (!scheduler.isStopped) {
+          scheduler.runTask(taskId, { isRetry: true });
+        }
       }, backoffMs));
-      logger.info(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
-    } else if (!failed && task.attempts) {
-      task.attempts = 0;
-      scheduler.store.set(task);
-    } else if (failed && maxRetries > 0 && (task.attempts || 0) >= maxRetries) {
-      task.attempts = 0;
-      scheduler.store.set(task);
+      logger.info(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${current.title}" in ${backoffMs}ms`);
+    } else if (!failed && current.attempts) {
+      current.attempts = 0;
+      scheduler.store.set(current);
+    } else if (failed && maxRetries > 0 && (current.attempts || 0) >= maxRetries) {
+      current.attempts = 0;
+      scheduler.store.set(current);
     }
   } catch (err) {
     logger.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
   }
 
-  if (queuedCount > 0) {
+  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(() => {
-      scheduler.runTask(taskId);
+      if (!scheduler.isStopped) {
+        scheduler.runTask(taskId, nextOptions);
+      }
     });
   }
 }
@@ -440,24 +480,34 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   }
 
   const finishedRun = scheduler.running.get(taskId);
-  if (finishedRun === currentRun) scheduler.running.delete(taskId);
-  const queuedCount = finishedRun?.queueCount || 0;
+  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);
+  scheduler.finishRun(task, taskId, outcome.status, queuedCount, {
+    isCurrentRun,
+    runId: currentRun?.id,
+    queuedRuns,
+  });
+
+  if (scheduler.isStopped) return;
 
   const guard = await checkAndApplyBurnGuard(scheduler, taskId, outcome);
   if (guard && guard.exceeded) return;
 
-  while (scheduler.queue.length > 0 && scheduler.running.size < scheduler.maxConcurrent) {
+  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') {
+    if (queuedTask && queuedTask.status === 'active' && !scheduler.isStopped) {
       setImmediate(() => {
-        scheduler.runTask(nextItem.taskId).catch((runErr) => {
-          bestEffort('drain-queued-task', () => {}, scheduler.logger);
-        });
+        if (!scheduler.isStopped) {
+          scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
+            bestEffort('drain-queued-task', () => {}, scheduler.logger);
+          });
+        }
       });
       break;
     }
@@ -470,14 +520,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

@@ -254,6 +254,8 @@ export class TaskScheduler {
     this.queue = [];
     this.heartbeatTimer = null;
     this.logger = opts.logger || null;
+    this.isStopped = false;
+    this.generation = 0;
   }
 
   isRunning(taskId) {
@@ -290,6 +292,8 @@ export class TaskScheduler {
   }
 
   start() {
+    this.isStopped = false;
+    this.generation = (this.generation || 0) + 1;
     const tasks = this.store.list();
     const now = Date.now();
     for (const task of tasks) {
@@ -328,7 +332,13 @@ export class TaskScheduler {
   }
 
   stopAll() {
+    this.isStopped = true;
+    this.generation = (this.generation || 0) + 1;
     this.stopHeartbeatWatcher();
+
+    // Clear concurrency queue (#217)
+    this.queue = [];
+
     for (const [, job] of this.jobs.entries()) {
       bestEffort('stop-job', () => job.stop(), this.logger);
     }
@@ -348,6 +358,10 @@ export class TaskScheduler {
       bestEffort('abort-running', () => run.controller.abort(new Error('Scheduler stopped')), this.logger);
     }
     this.running.clear();
+
+    if (this.store && typeof this.store.flushSync === 'function') {
+      bestEffort('store-flush-on-stop', () => this.store.flushSync(), this.logger);
+    }
   }
 
   clearScheduled(taskId) {
@@ -379,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 } : {}),
@@ -412,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) {
@@ -451,6 +464,7 @@ export class TaskScheduler {
   }
 
   async runTask(taskId, options = {}) {
+    if (this.isStopped) return null;
     return executeTask(this, taskId, options);
   }
 
@@ -500,8 +514,8 @@ export class TaskScheduler {
     });
   }
 
-  finishRun(task, taskId, status, queuedCount) {
-    return finishRun(this, task, taskId, status, queuedCount);
+  finishRun(task, taskId, status, queuedCount, meta) {
+    return finishRun(this, task, taskId, status, queuedCount, meta);
   }
 
   pauseTask(taskId, reason) {

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);
         }
       }
@@ -112,7 +127,11 @@ export class TaskStore {
     if (this._saveTimer) return;
     this._saveTimer = setTimeout(() => {
       this._saveTimer = null;
-      this.save();
+      try {
+        this.save();
+      } catch (err) {
+        logger.error('[dsh-cron] debounced save failed:', err.message);
+      }
     }, delay);
     if (typeof this._saveTimer.unref === 'function') {
       this._saveTimer.unref();
@@ -160,6 +179,7 @@ export class TaskStore {
       }
     } catch (err) {
       logger.error('[dsh-cron] store save error:', err.message);
+      throw err;
     }
   }
 
@@ -254,6 +274,7 @@ export class TaskStore {
       else if (typeof value === 'string') patch[key] = value.trim();
     }
 
+    const prevSettings = this.settings;
     this.settings = {
       ...this.settings,
       ...patch,
@@ -265,7 +286,12 @@ export class TaskStore {
       onlyOnFailure: patch.onlyOnFailure !== undefined ? Boolean(patch.onlyOnFailure) : Boolean(this.settings.onlyOnFailure),
       llmActionsEnabled: patch.llmActionsEnabled !== undefined ? Boolean(patch.llmActionsEnabled) : Boolean(this.settings.llmActionsEnabled),
     };
-    this.save();
+    try {
+      this.save();
+    } catch (err) {
+      this.settings = prevSettings;
+      throw err;
+    }
     return this.getSettings();
   }
 
@@ -292,7 +318,8 @@ export class TaskStore {
   set(task) {
     const now = Date.now();
     const id = task.id || ('cron_' + Math.random().toString(36).slice(2, 9));
-    const prev = this.tasks.get(id) || {};
+    const existing = this.tasks.get(id);
+    const prev = existing || {};
     const record = {
       ...prev,
       ...task,
@@ -337,7 +364,13 @@ export class TaskStore {
       nextRunAt: task.nextRunAt !== undefined ? task.nextRunAt : (prev.nextRunAt || null),
     };
     this.tasks.set(id, record);
-    this.save();
+    try {
+      this.save();
+    } catch (err) {
+      if (existing) this.tasks.set(id, existing);
+      else this.tasks.delete(id);
+      throw err;
+    }
     return record;
   }
 
@@ -345,13 +378,25 @@ export class TaskStore {
     const task = this.tasks.get(id);
     if (!task) return null;
     const now = Date.now();
+    const prevPing = task.lastPingAt;
+    const prevAlerted = task.heartbeatAlerted;
+    const prevUpdated = task.updatedAt;
+    const prevStatus = task.lastStatus;
     task.lastPingAt = now;
     task.heartbeatAlerted = false;
     task.updatedAt = now;
     if (task.lastStatus === 'missed') {
       task.lastStatus = 'active';
     }
-    this.save();
+    try {
+      this.save();
+    } catch (err) {
+      task.lastPingAt = prevPing;
+      task.heartbeatAlerted = prevAlerted;
+      task.updatedAt = prevUpdated;
+      task.lastStatus = prevStatus;
+      throw err;
+    }
     const interval = (task.heartbeatIntervalSeconds || 0) + (task.gracePeriodSeconds || 300);
     return {
       ok: true,
@@ -363,10 +408,19 @@ export class TaskStore {
   }
 
   delete(id) {
-    const existed = this.tasks.delete(id);
+    const existing = this.tasks.get(id);
+    if (!existing) return false;
+    const existingHistory = this.history.get(id);
+    this.tasks.delete(id);
     this.history.delete(id);
-    if (existed) this.save();
-    return existed;
+    try {
+      this.save();
+    } catch (err) {
+      this.tasks.set(id, existing);
+      if (existingHistory) this.history.set(id, existingHistory);
+      throw err;
+    }
+    return true;
   }
 
   recordRun(id, runInfo) {
@@ -385,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-patch.js

@@ -114,10 +114,14 @@ export function applyTaskPatch({ store, scheduler, id, body, allowCodeSwitch = f
   }
   const built = buildTaskPatch(current, body);
   if (!built.ok) return built;
-  const task = store.set({ ...current, ...built.patch, id });
-  if (task.status === 'active') scheduler.scheduleTask(task);
-  else scheduler.pauseTask(id);
-  return { ok: true, task, patch: built.patch };
+  try {
+    const task = store.set({ ...current, ...built.patch, id });
+    if (task.status === 'active') scheduler.scheduleTask(task);
+    else scheduler.pauseTask(id);
+    return { ok: true, task, patch: built.patch };
+  } catch (err) {
+    return { ok: false, error: 'Failed to persist task patch: ' + err.message, status: 500 };
+  }
 }
 
 /** Human-readable summary of what changed, for tool output and logs. */

package/package.json

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