@goodandready/dsh-cron 0.2.22 → 0.2.23

package/lib/burn-guard.js

@@ -132,7 +132,7 @@ export async function checkAndApplyBurnGuard(scheduler, taskId, outcome) {
   scheduler.pauseTask(taskId, guard.reason);
 
   const alertMessage = formatBurnGuardAlert(task, guard);
-  try {
+  await bestEffort('burn-guard-notify', async () => {
     if (typeof scheduler.deliverNotifications === 'function') {
       const alertRunInfo = {
         output: alertMessage,
@@ -144,9 +144,7 @@ export async function checkAndApplyBurnGuard(scheduler, taskId, outcome) {
       };
       await scheduler.deliverNotifications({ ...task, status: 'paused', pausedReason: guard.reason }, alertRunInfo);
     }
-  } catch (err) {
-    bestEffort('burn-guard-notify', () => {}, scheduler.logger);
-  }
+  }, scheduler.logger);
 
   return guard;
 }

package/lib/client.js

@@ -3380,7 +3380,7 @@ window.__ModuleLoader__.load({
       const [updateState, setUpdateState] = React.useState({
         checking: false,
         updating: false,
-        currentVersion: '0.2.22',
+        currentVersion: '0.2.23',
         latestVersion: undefined,
         updateAvailable: false,
         notice: null,
@@ -3901,7 +3901,19 @@ window.__ModuleLoader__.load({
       const state = { toggle, openTaskSignal, root: undefined, listEl: undefined, headEl: undefined, open: false };
       try { state.open = window.localStorage.getItem(SIDEBAR_JOBS_KEY) === '1'; } catch (err) { /* localStorage read failed */ }
 
-      const observer = new MutationObserver(() => placeSidebarJobs(state, label));
+      let rafPending = false;
+      const schedulePlace = () => {
+        if (state.root !== undefined && state.root.isConnected) return;
+        if (rafPending) return;
+        rafPending = true;
+        const scheduleFn = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : (cb) => setTimeout(cb, 16);
+        scheduleFn(() => {
+          rafPending = false;
+          placeSidebarJobs(state, label);
+        });
+      };
+
+      const observer = new MutationObserver(schedulePlace);
       observer.observe(document.body, { childList: true, subtree: true });
       placeSidebarJobs(state, label);
       loadSidebarJobs(state);

package/lib/scheduler-execution.js

@@ -1,4 +1,4 @@
-import { checkAndApplyBurnGuard } from './burn-guard.js';
+import { checkAndApplyBurnGuard, checkTaskBudgetLimits } from './burn-guard.js';
 import { resolveTaskForExecution } from './prompt-interpolation.js';
 import { bestEffort } from './best-effort.js';
 import { exec } from 'node:child_process';
@@ -66,8 +66,8 @@ export async function executePreflight(task) {
       }
       return { ok: true };
     } catch (err) {
-      bestEffort('statfsSync', () => {}, null);
-      return { ok: true }; // Fail-open
+      // Fail-open if statfsSync is unavailable or throws
+      return { ok: true };
     }
   }
 
@@ -185,6 +185,17 @@ export async function executeTask(scheduler, taskId, options = {}) {
   const task = scheduler.store.get(taskId);
   if (!task) return null;
 
+  // Pre-flight Burn Guard check (#181): prevent executing task if budget already breached
+  const runs = (scheduler.store.history && scheduler.store.history.get(taskId)) || [];
+  const guard = checkTaskBudgetLimits(task, runs);
+  if (guard.exceeded) {
+    console.warn(`[dsh-cron] Burn Guard pre-flight blocked task "${task.title}" (${taskId}): ${guard.reason}`);
+    scheduler.pauseTask(taskId, guard.reason);
+    scheduler.recordSkipped(taskId, `Burn Guard pre-flight pause: ${guard.reason}`);
+    checkAndApplyBurnGuard(scheduler, taskId, { status: 'error', costUsd: 0, durationMs: 0 }).catch(() => {});
+    return { ok: false, status: 'error', error: guard.reason, preflightBlocked: true };
+  }
+
   if (!options.isRetry && task.attempts) {
     task.attempts = 0;
     scheduler.store.set(task);

package/lib/store.js

@@ -34,6 +34,8 @@ export class TaskStore {
     this.tasks = new Map();
     this.history = new Map();
     this.settings = {};
+    this._lastBackupTime = 0;
+    this._saveTimer = null;
     this._savePromise = Promise.resolve();
     this.init();
   }
@@ -102,7 +104,36 @@ export class TaskStore {
     }
   }
 
+  /**
+   * Schedule a debounced save to avoid synchronous event loop blocking on high-frequency run completions.
+   */
+  scheduleSave(delay = 50) {
+    if (this._saveTimer) return;
+    this._saveTimer = setTimeout(() => {
+      this._saveTimer = null;
+      this.save();
+    }, delay);
+    if (typeof this._saveTimer.unref === 'function') {
+      this._saveTimer.unref();
+    }
+  }
+
+  /**
+   * Synchronously flush any pending debounced save to disk.
+   */
+  flushSync() {
+    if (this._saveTimer) {
+      clearTimeout(this._saveTimer);
+      this._saveTimer = null;
+    }
+    this.save();
+  }
+
   save() {
+    if (this._saveTimer) {
+      clearTimeout(this._saveTimer);
+      this._saveTimer = null;
+    }
     try {
       const dir = path.dirname(this.filePath);
       if (!fs.existsSync(dir)) {
@@ -120,7 +151,12 @@ export class TaskStore {
       const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
       fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
       fs.renameSync(tmp, this.filePath);
-      bestEffort('backup-on-save', () => fs.copyFileSync(this.filePath, `${this.filePath}.bak`));
+      // Throttled backup (.bak): avoid expensive copyFileSync on every micro-save
+      const now = Date.now();
+      if (now - this._lastBackupTime > 60000) {
+        this._lastBackupTime = now;
+        bestEffort('backup-on-save', () => fs.copyFileSync(this.filePath, `${this.filePath}.bak`));
+      }
     } catch (err) {
       console.error('[dsh-cron] store save error:', err.message);
     }
@@ -290,8 +326,8 @@ export class TaskStore {
       agentPreset: task.agentPreset !== undefined ? String(task.agentPreset).trim() : (prev.agentPreset || ''),
       targetSessionId: task.targetSessionId !== undefined ? String(task.targetSessionId).trim() : (prev.targetSessionId || ''),
       targetSessionReset: task.targetSessionReset !== undefined ? String(task.targetSessionReset).trim() : (prev.targetSessionReset || 'never'),
-      totalTokens: prev.totalTokens || 0,
-      totalCostUsd: prev.totalCostUsd || 0,
+      totalTokens: task.totalTokens !== undefined ? Number(task.totalTokens) : (prev.totalTokens || 0),
+      totalCostUsd: task.totalCostUsd !== undefined ? Number(task.totalCostUsd) : (prev.totalCostUsd || 0),
       createdAt: prev.createdAt || task.createdAt || now,
       updatedAt: now,
       lastRunAt: task.lastRunAt !== undefined ? task.lastRunAt : (prev.lastRunAt || null),
@@ -379,7 +415,7 @@ export class TaskStore {
       this._archiveHistoryRuns(id, overflow);
     }
     this.history.set(id, runs);
-    this.save();
+    this.scheduleSave();
   }
 
   /**
@@ -399,10 +435,10 @@ export class TaskStore {
       if (archive[id].length > 1000) {
         archive[id] = archive[id].slice(-1000);
       }
-      // Write atomically with tmp file
+      // Write atomically with tmp file using compact JSON (avoiding mega-lines and null, 2 serialization bloat)
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${archivePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
-      fs.writeFileSync(tmp, JSON.stringify(archive, null, 2), 'utf-8');
+      fs.writeFileSync(tmp, JSON.stringify(archive), 'utf-8');
       fs.renameSync(tmp, archivePath);
     } catch (archiveErr) {
       console.error('[dsh-cron] history archive error:', archiveErr.message);

package/package.json

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