@goodandready/dsh-cron 0.2.13 → 0.2.14

package/README.md

@@ -372,6 +372,17 @@ Developer-facing, no behaviour change. `parseScheduleExpression` was split into
 
 ---
 
+### 26. Reliability, Hardening & Self-Healing Maintenance Pack (v0.2.14, #145)
+- **Automatic Retry Budget Reset**: Fixed retry exhaustion amnesia. When a task exhausts its configured retry attempts (`maxRetries`), its attempts counter is automatically cleared, ensuring that subsequent scheduled ticks retain their full retry budget. Any regular or manual execution also guarantees a clean retry budget on launch.
+- **Zombie Queue Elimination**: Tasks paused via UI/API or deleted are immediately purged from the scheduler's concurrency waiting queue (`this.queue`). Additionally, when dequeuing tasks upon concurrency slot release, inactive or deleted tasks are safely skipped.
+- **Bounded History Archive**: Long-running production instances with high-frequency cron tasks safely bound `tasks-history-archive.json` to the latest 1,000 runs per task, eliminating unbounded disk growth and synchronous JSON serialization lag.
+- **Disaster Recovery & Store Auto-Backup**: `TaskStore` maintains an automatic atomic `.bak` copy of `tasks.json` on every successful save. In the event of process crash or file corruption, the store snapshots the corrupted file to `tasks.json.corrupted.<timestamp>` for forensic analysis and self-heals seamlessly from the backup.
+- **Context Window Overflow Auto-Recovery**: For persistent sessions (`targetSessionId`), if an agent turn fails due to context window saturation (`context_length_exceeded`), the runner detects the overflow, archives the exhausted session, automatically rotates to a fresh session thread, and transparently retries execution without task failure.
+- **Windows Process Tree Termination**: External process runners on Windows now execute `taskkill /pid <pid> /T /F` on task cancellation or timeout, preventing zombie background processes and orphan shells from lingering in the operating system.
+
+---
+
+
 ## 📦 Installation
 
 Install into your DeepSeek Harness web profile:

package/README.ru.md

@@ -248,6 +248,17 @@ cron_create_task({
 
 ---
 
+### 26. Пакет надежности, отказоустойчивости и самовосстановления (v0.2.14, #145)
+- **Автоматический сброс бюджета повторов**: Исправлена «амнезия повторов». Когда задача исчерпывает лимит попыток (`maxRetries`), счётчик `attempts` автоматически обнуляется, поэтому следующий плановый запуск по расписанию получает полный бюджет повторов с нуля. Любой регулярный или ручной запуск гарантированно начинает выполнение со сброшенным счётчиком попыток.
+- **Устранение «зомби»-задач в очереди**: Задачи, приостановленные через интерфейс/API или удалённые, мгновенно вычищаются из очереди ожидания параллелизма (`this.queue`). При освобождении слотов очереди неактивные или удалённые задачи безопасно пропускаются.
+- **Ограничение архива истории**: В длительно работающих инсталляциях с высокочастотными cron-задачами файл архива `tasks-history-archive.json` теперь надёжно ограничен последними 1 000 запусками на задачу, предотвращая неконтролируемый рост диска и синхронные задержки сериализации JSON.
+- **Аварийное восстановление и авто-бэкап хранилища**: `TaskStore` автоматически поддерживает атомарную резервную копию `tasks.json.bak` при каждом успешном сохранении. В случае сбоя или повреждения файла хранилище делает снимок `tasks.json.corrupted.<timestamp>` для диагностики и бесшовно восстанавливается из резервной копии.
+- **Самовосстановление при переполнении контекстного окна**: Если в долговременной сессии (`targetSessionId`) очередной ход агента завершается ошибкой переполнения контекста модели (`context_length_exceeded`), раннер распознаёт переполнение, архивирует исчерпанную сессию, автоматически выполняет ротацию на свежую сессию и прозрачно повторяет выполнение без срыва задачи.
+- **Корректное завершение дерева процессов в Windows**: На платформе Windows отмена или таймаут внешних скриптовых задач теперь вызывают `taskkill /pid <pid> /T /F`, гарантируя полное уничтожение всех дочерних процессов и оболочек без зависания зомби-процессов в системе.
+
+---
+
+
 ## 📦 Установка
 
 ```bash

package/README.zh.md

@@ -371,6 +371,17 @@ bash deploy.sh verify [exact-version]
 
 ---
 
+### 26. 系统稳定性、硬化与自愈维护包 (v0.2.14, #145)
+- **重试预算自动重置**：彻底修复重试耗尽后的计数残留问题。当任务耗尽配置的重试次数（`maxRetries`）后，`attempts` 计数器自动清零，确保后续周期的定时调度享有完整的重试预算。常规计划执行或手动触发也均保证以干净的重试预算启动。
+- **清除队列僵尸任务**：通过界面/API 暂停或删除任务时，调度器会立即将其从并发等待队列（`this.queue`）中剔除；并发槽位释放出队时，非激活或已删除的任务也会被自动安全跳过。
+- **历史归档容量上限保护**：针对长期运行和高频调度的生产环境，`tasks-history-archive.json` 针对每个任务安全限制保留最新的 1,000 条运行记录，消除无限制磁盘占用与同步 JSON 序列化卡顿。
+- **灾难恢复与存储自动备份**：`TaskStore` 在每次成功持久化时自动维护原子的 `tasks.json.bak` 备份副本。若发生进程异常导致数据损坏，存储引擎会自动保存现场切片 `tasks.json.corrupted.<timestamp>` 供故障分析，并无缝从备份中自愈恢复。
+- **上下文超限自愈与平滑轮转**：在常驻持久会话（`targetSessionId`）中，若智能体因模型上下文窗口溢出（`context_length_exceeded`）失败，运行器将精准捕获超限错误，归档已满会话，自动轮转至全新子会话并平滑重试，避免任务中断。
+- **Windows 进程树彻底终止**：在 Windows 系统上，外部进程任务被取消或超时终止时，改为执行 `taskkill /pid <pid> /T /F`，杜绝孤儿进程和后台残留外壳。
+
+---
+
+
 ## 📦 安装
 
 ```bash

package/docs/README.ru.md

@@ -248,6 +248,17 @@ cron_create_task({
 
 ---
 
+### 26. Пакет надежности, отказоустойчивости и самовосстановления (v0.2.14, #145)
+- **Автоматический сброс бюджета повторов**: Исправлена «амнезия повторов». Когда задача исчерпывает лимит попыток (`maxRetries`), счётчик `attempts` автоматически обнуляется, поэтому следующий плановый запуск по расписанию получает полный бюджет повторов с нуля. Любой регулярный или ручной запуск гарантированно начинает выполнение со сброшенным счётчиком попыток.
+- **Устранение «зомби»-задач в очереди**: Задачи, приостановленные через интерфейс/API или удалённые, мгновенно вычищаются из очереди ожидания параллелизма (`this.queue`). При освобождении слотов очереди неактивные или удалённые задачи безопасно пропускаются.
+- **Ограничение архива истории**: В длительно работающих инсталляциях с высокочастотными cron-задачами файл архива `tasks-history-archive.json` теперь надёжно ограничен последними 1 000 запусками на задачу, предотвращая неконтролируемый рост диска и синхронные задержки сериализации JSON.
+- **Аварийное восстановление и авто-бэкап хранилища**: `TaskStore` автоматически поддерживает атомарную резервную копию `tasks.json.bak` при каждом успешном сохранении. В случае сбоя или повреждения файла хранилище делает снимок `tasks.json.corrupted.<timestamp>` для диагностики и бесшовно восстанавливается из резервной копии.
+- **Самовосстановление при переполнении контекстного окна**: Если в долговременной сессии (`targetSessionId`) очередной ход агента завершается ошибкой переполнения контекста модели (`context_length_exceeded`), раннер распознаёт переполнение, архивирует исчерпанную сессию, автоматически выполняет ротацию на свежую сессию и прозрачно повторяет выполнение без срыва задачи.
+- **Корректное завершение дерева процессов в Windows**: На платформе Windows отмена или таймаут внешних скриптовых задач теперь вызывают `taskkill /pid <pid> /T /F`, гарантируя полное уничтожение всех дочерних процессов и оболочек без зависания зомби-процессов в системе.
+
+---
+
+
 ## 📦 Установка
 
 ```bash

package/docs/README.zh.md

@@ -371,6 +371,17 @@ bash deploy.sh verify [exact-version]
 
 ---
 
+### 26. 系统稳定性、硬化与自愈维护包 (v0.2.14, #145)
+- **重试预算自动重置**：彻底修复重试耗尽后的计数残留问题。当任务耗尽配置的重试次数（`maxRetries`）后，`attempts` 计数器自动清零，确保后续周期的定时调度享有完整的重试预算。常规计划执行或手动触发也均保证以干净的重试预算启动。
+- **清除队列僵尸任务**：通过界面/API 暂停或删除任务时，调度器会立即将其从并发等待队列（`this.queue`）中剔除；并发槽位释放出队时，非激活或已删除的任务也会被自动安全跳过。
+- **历史归档容量上限保护**：针对长期运行和高频调度的生产环境，`tasks-history-archive.json` 针对每个任务安全限制保留最新的 1,000 条运行记录，消除无限制磁盘占用与同步 JSON 序列化卡顿。
+- **灾难恢复与存储自动备份**：`TaskStore` 在每次成功持久化时自动维护原子的 `tasks.json.bak` 备份副本。若发生进程异常导致数据损坏，存储引擎会自动保存现场切片 `tasks.json.corrupted.<timestamp>` 供故障分析，并无缝从备份中自愈恢复。
+- **上下文超限自愈与平滑轮转**：在常驻持久会话（`targetSessionId`）中，若智能体因模型上下文窗口溢出（`context_length_exceeded`）失败，运行器将精准捕获超限错误，归档已满会话，自动轮转至全新子会话并平滑重试，避免任务中断。
+- **Windows 进程树彻底终止**：在 Windows 系统上，外部进程任务被取消或超时终止时，改为执行 `taskkill /pid <pid> /T /F`，杜绝孤儿进程和后台残留外壳。
+
+---
+
+
 ## 📦 安装
 
 ```bash

package/lib/api.js

@@ -503,7 +503,11 @@ function deleteTask({ store, scheduler, res, id }) {
     return;
   }
   if (current) {
-    scheduler.pauseTask(id);
+    if (scheduler && typeof scheduler.removeTask === 'function') {
+      scheduler.removeTask(id);
+    } else if (scheduler) {
+      scheduler.pauseTask(id);
+    }
     store.delete(id);
   }
   sendJson(res, 200, { ok: true });

package/lib/index.js

@@ -300,7 +300,7 @@ const createTaskOutput = {
 
 export function apply(ctx, config) {
   const store = new TaskStore();
-  const runner = new SessionRunner(ctx);
+  const runner = new SessionRunner(ctx, store);
   const scheduler = new TaskScheduler(store, (task, opts) => runner.execute(task, opts), {
     maxConcurrent: config && config.maxConcurrent,
     defaultTimezone: config && config.defaultTimezone,

package/lib/runner.js

@@ -1,3 +1,41 @@
+/**
+ * Helper to detect context window overflow errors in persistent sessions (#145).
+ */
+export function isContextOverflowError(err) {
+  const msg = String(err?.message || err || '').toLowerCase();
+  return msg.includes('context length') ||
+         msg.includes('context window') ||
+         msg.includes('maximum context') ||
+         msg.includes('too many tokens') ||
+         msg.includes('prompt too long') ||
+         msg.includes('token limit') ||
+         msg.includes('context_length_exceeded') ||
+         msg.includes('string_above_max_length');
+}
+
+/**
+ * Cross-platform process tree killer (#145).
+ * On Windows, calls `taskkill /pid <pid> /T /F` to terminate the entire process hierarchy.
+ */
+export function terminateProcessTree(child, sig = 'SIGTERM', { isPosix = process.platform !== 'win32', execFn } = {}) {
+  if (!child || child.killed) return;
+  try {
+    if (isPosix && child.pid) {
+      try { process.kill(-child.pid, sig); } catch {}
+    } else if (child.pid) {
+      const runner = execFn || ((cmd) => {
+        try {
+          import('node:child_process').then(({ exec }) => {
+            exec(cmd, { windowsHide: true }, () => {});
+          }).catch(() => {});
+        } catch {}
+      });
+      try { runner(`taskkill /pid ${child.pid} /T /F`); } catch {}
+      try { child.kill(sig); } catch {}
+    }
+  } catch {}
+}
+
 /**
  * Helper to test if an error code or status is transient and eligible for retry (#134).
  */
@@ -60,8 +98,9 @@ export function resolveTargetSessionId(targetSessionId, resetPolicy = 'never', d
 }
 
 export class SessionRunner {
-  constructor(ctx) {
+  constructor(ctx, store = null) {
     this.ctx = ctx;
+    this.store = store;
   }
 
   async execute(task, options = {}) {
@@ -243,7 +282,7 @@ export class SessionRunner {
     const invocation = buildInvocation({ ...task, type: runtime }, cwd);
     if (invocation.http) return this._runHttp(task, invocation.http, signal);
 
-    const { spawn } = await import('node:child_process');
+    const { spawn, exec } = await import('node:child_process');
     return new Promise((resolve, reject) => {
       let child = null;
       let settled = false;
@@ -253,14 +292,12 @@ export class SessionRunner {
       const isPosix = process.platform !== 'win32';
 
       const killProcessTree = (sig = 'SIGTERM') => {
-        if (!child || child.killed) return;
-        try {
-          if (isPosix && child.pid) {
-            try { process.kill(-child.pid, sig); } catch {}
-          } else if (child.pid) {
-            child.kill(sig);
+        terminateProcessTree(child, sig, {
+          isPosix,
+          execFn: (cmd) => {
+            try { exec(cmd, { windowsHide: true }, () => {}); } catch {}
           }
-        } catch {}
+        });
       };
 
       const abortHandler = () => {
@@ -385,19 +422,44 @@ export class SessionRunner {
   }
 
   async _runAgentSession(task, runtime, signal, execOptions = {}) {
+    let effectiveTask = task;
+    if (execOptions?.prevOutput) {
+      const prev = String(execOptions.prevOutput);
+      const prompt = task.prompt || '';
+      const newPrompt = prompt.includes('{{prevOutput}}')
+        ? prompt.replaceAll('{{prevOutput}}', prev)
+        : `[Previous Output]:\n${prev}\n\n${prompt}`;
+      effectiveTask = { ...task, prompt: newPrompt };
+    }
+    const prep = await this._prepareAgentRun(effectiveTask, runtime, signal);
     try {
-      let effectiveTask = task;
-      if (execOptions?.prevOutput) {
-        const prev = String(execOptions.prevOutput);
-        const prompt = task.prompt || '';
-        const newPrompt = prompt.includes('{{prevOutput}}')
-          ? prompt.replaceAll('{{prevOutput}}', prev)
-          : `[Previous Output]:\n${prev}\n\n${prompt}`;
-        effectiveTask = { ...task, prompt: newPrompt };
-      }
-      const prep = await this._prepareAgentRun(effectiveTask, runtime, signal);
       return await this._executeAgentTurn(task, prep);
     } catch (err) {
+      // Context window overflow auto-recovery in persistent sessions (#145)
+      if (prep.targetSessionId && isContextOverflowError(err) && !signal?.aborted) {
+        console.warn(`[dsh-cron] Persistent session "${prep.targetSessionId}" exceeded context window (${err.message}). Auto-recovering with fresh session...`);
+        try {
+          const sessions = this.ctx?.get?.('sessions');
+          if (sessions && typeof sessions.archive === 'function') {
+            sessions.archive(prep.targetSessionId);
+          }
+        } catch {}
+        const rotatedSessionId = `${prep.targetSessionId}-${Date.now().toString(36)}`;
+        console.log(`[dsh-cron] Rotated persistent session "${prep.targetSessionId}" -> "${rotatedSessionId}"`);
+        if (this.store) {
+          try {
+            const stored = this.store.get(task.id);
+            if (stored) {
+              stored.targetSessionId = rotatedSessionId;
+              this.store.set(stored);
+            }
+          } catch {}
+        }
+        task.targetSessionId = rotatedSessionId;
+        effectiveTask.targetSessionId = rotatedSessionId;
+        const freshPrep = await this._prepareAgentRun(effectiveTask, runtime, signal);
+        return await this._executeAgentTurn(task, freshPrep);
+      }
       console.error(`[dsh-cron] agent execution failed:`, err.message);
       throw err;
     }

package/lib/scheduler.js

@@ -642,6 +642,11 @@ export class TaskScheduler {
     const task = this.store.get(taskId);
     if (!task) return null;
 
+    if (!options.isRetry && task.attempts) {
+      task.attempts = 0;
+      this.store.set(task);
+    }
+
     if (options.dryRun) {
       const start = Date.now();
       const outcome = await this.executeWithFallback(task, AbortSignal.timeout(Math.min((task.timeoutSeconds || 1800) * 1000, 30000)), options);
@@ -750,12 +755,15 @@ export class TaskScheduler {
     if (!silent.skipped) await this.deliverNotifications(task, runInfo);
     this.finishRun(task, taskId, outcome.status, queuedCount);
 
-    if (this.queue.length > 0 && this.running.size < this.maxConcurrent) {
+    while (this.queue.length > 0 && this.running.size < this.maxConcurrent) {
       const nextItem = this.queue.shift();
-      if (nextItem) {
+      if (!nextItem) break;
+      const queuedTask = this.store.get(nextItem.taskId);
+      if (queuedTask && queuedTask.status === 'active') {
         setImmediate(() => {
           this.runTask(nextItem.taskId).catch(() => {});
         });
+        break;
       }
     }
 
@@ -948,12 +956,16 @@ export class TaskScheduler {
         this.clearRetryTimer(taskId);
         this.retryTimers.set(taskId, setTimeout(() => {
           this.retryTimers.delete(taskId);
-          this.runTask(taskId);
+          this.runTask(taskId, { isRetry: true });
         }, backoffMs));
         console.log(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
       } else if (!failed && task.attempts) {
         task.attempts = 0;
         this.store.set(task);
+      } else if (failed && maxRetries > 0 && (task.attempts || 0) >= maxRetries) {
+        // Retry budget exhausted: reset attempts so the next scheduled run starts fresh (#145)
+        task.attempts = 0;
+        this.store.set(task);
       }
     } catch (err) {
       console.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
@@ -987,10 +999,31 @@ export class TaskScheduler {
       } catch {}
       this.running.delete(taskId);
     }
+    this.queue = this.queue.filter((item) => item.taskId !== taskId);
     this.store.set(task);
     return task;
   }
 
+  removeTask(taskId) {
+    this.clearRetryTimer(taskId);
+    if (this.jobs.has(taskId)) {
+      this.jobs.get(taskId).stop();
+      this.jobs.delete(taskId);
+    }
+    if (this.timers.has(taskId)) {
+      clearTimeout(this.timers.get(taskId));
+      this.timers.delete(taskId);
+    }
+    const running = this.running.get(taskId);
+    if (running) {
+      try {
+        running.controller.abort(new Error('Task deleted'));
+      } catch {}
+      this.running.delete(taskId);
+    }
+    this.queue = this.queue.filter((item) => item.taskId !== taskId);
+  }
+
   resumeTask(taskId) {
     const task = this.store.get(taskId);
     if (!task) return null;

package/lib/store.js

@@ -38,30 +38,66 @@ export class TaskStore {
   }
 
   init() {
-    try {
-      const dir = path.dirname(this.filePath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+    const dir = path.dirname(this.filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const bakPath = `${this.filePath}.bak`;
+
+    const loadData = (raw) => {
+      const data = JSON.parse(raw);
+      this.tasks.clear();
+      this.history.clear();
+      if (Array.isArray(data.tasks)) {
+        for (const t of data.tasks) {
+          this.tasks.set(t.id, t);
+        }
+      }
+      if (data.history && typeof data.history === 'object') {
+        for (const [k, v] of Object.entries(data.history)) {
+          this.history.set(k, Array.isArray(v) ? v : []);
+        }
+      }
+      if (data.settings && typeof data.settings === 'object') {
+        this.settings = data.settings;
       }
-      if (fs.existsSync(this.filePath)) {
+    };
+
+    if (fs.existsSync(this.filePath)) {
+      try {
         const raw = fs.readFileSync(this.filePath, 'utf-8');
-        const data = JSON.parse(raw);
-        if (Array.isArray(data.tasks)) {
-          for (const t of data.tasks) {
-            this.tasks.set(t.id, t);
-          }
+        loadData(raw);
+        if (!fs.existsSync(bakPath)) {
+          try { fs.copyFileSync(this.filePath, bakPath); } catch {}
         }
-        if (data.history && typeof data.history === 'object') {
-          for (const [k, v] of Object.entries(data.history)) {
-            this.history.set(k, Array.isArray(v) ? v : []);
-          }
+      } catch (err) {
+        console.error('[dsh-cron] store read error (corrupted file):', err.message);
+        try {
+          const corruptedPath = `${this.filePath}.corrupted.${Date.now()}`;
+          fs.copyFileSync(this.filePath, corruptedPath);
+          console.warn(`[dsh-cron] corrupted store backed up to ${corruptedPath}`);
+        } catch (snapErr) {
+          console.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
         }
-        if (data.settings && typeof data.settings === 'object') {
-          this.settings = data.settings;
+        if (fs.existsSync(bakPath)) {
+          try {
+            const rawBak = fs.readFileSync(bakPath, 'utf-8');
+            loadData(rawBak);
+            console.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
+          } catch (bakErr) {
+            console.error('[dsh-cron] failed to recover tasks store from .bak:', bakErr.message);
+          }
         }
       }
-    } catch (err) {
-      console.error('[dsh-cron] store read error:', err.message);
+    } else if (fs.existsSync(bakPath)) {
+      try {
+        const rawBak = fs.readFileSync(bakPath, 'utf-8');
+        loadData(rawBak);
+        try { fs.copyFileSync(bakPath, this.filePath); } catch {}
+        console.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
+      } catch (bakErr) {
+        console.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
+      }
     }
   }
 
@@ -83,6 +119,9 @@ 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);
+      try {
+        fs.copyFileSync(this.filePath, `${this.filePath}.bak`);
+      } catch {}
     } catch (err) {
       console.error('[dsh-cron] store save error:', err.message);
     }
@@ -360,6 +399,9 @@ export class TaskStore {
       }
       if (!Array.isArray(archive[id])) archive[id] = [];
       archive[id].push(...overflowRuns);
+      if (archive[id].length > 1000) {
+        archive[id] = archive[id].slice(-1000);
+      }
       // Write atomically with tmp file
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${archivePath}.tmp.${process.pid}_${Date.now()}_${rand}`;

package/package.json

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