@goodandready/dsh-cron 0.2.12 → 0.2.14

package/README.md

@@ -359,6 +359,30 @@ Developer-facing, no behaviour change. `parseScheduleExpression` was split into
 
 ---
 
+### 25. Persistent Execution Sessions & Context Continuity (`targetSessionId`, Added in v0.2.13, #143)
+- **Continuous Conversation Context**: Tasks can configure a `targetSessionId`. When set, the scheduler resumes the existing session via `agents.resume()` instead of generating an isolated ephemeral session (`cron-exec-${id}-${uuid}`) on every tick. The agent retains conversational memory across runs, allowing periodic auditors or assistants to reference prior findings and outputs directly in context.
+- **Context Window Protection & Session Rotation (`targetSessionReset`)**: To prevent unbounded context growth and token cost explosion over long schedules, tasks can set an automatic rotation policy:
+  - `never`: Continues a single session thread indefinitely.
+  - `daily`: Automatically rotates the session daily (`<id>-YYYY-MM-DD`).
+  - `weekly`: Automatically rotates the session weekly (`<id>-YYYY-Www`).
+  - Custom templating: Any `targetSessionId` containing `{{date}}` automatically interpolates today's date (`YYYY-MM-DD`).
+- **Main Chat Visibility**: Persistent sessions are omitted from `sessions.archive()` and unflagged from `ephemeral`/`internal`, making them visible and interactable directly in the DeepSeek Harness chat interface.
+- **Preset & Tooling Compatibility**: Resumed sessions automatically preserve and remount configured `agentPresets`, ensuring full access to workspace, terminal, and file tools on every turn.
+- *Inspiration credit*: Community idea originally explored by [@RaulLazaro](https://github.com/RaulLazaro).
+
+---
+
+### 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

@@ -235,6 +235,30 @@ cron_create_task({
 
 ---
 
+### 25. Долговременные сессии и непрерывность контекста (`targetSessionId`, добавлено в v0.2.13, #143)
+- **Непрерывный контекст диалога**: Для задач можно задать `targetSessionId`. При наличии этого идентификатора планировщик возобновляет существующую сессию через `agents.resume()` вместо создания одноразовой сессии (`cron-exec-${id}-${uuid}`) на каждом тике. Агент сохраняет память предыдущих ходов и может ссылаться на ранее обнаруженные данные и выводы.
+- **Защита от переполнения контекста и ротация (`targetSessionReset`)**: Чтобы контекстное окно и расход токенов не разрастались бесконечно при частых запусках, предусмотрены политики автоматической ротации:
+  - `never`: единая непрерывная сессия без сброса.
+  - `daily`: ежедневная автоматическая ротация (`<id>-YYYY-MM-DD`).
+  - `weekly`: еженедельная автоматическая ротация (`<id>-YYYY-Www`).
+  - Шаблоны дат: в `targetSessionId` поддерживается плейсхолдер `{{date}}`, который автоматически заменяется на текущую дату `YYYY-MM-DD`.
+- **Видимость в списке чатов DSH**: Долговременные сессии не помечаются как `ephemeral`/`internal` и исключены из автоматической архивации (`sessions.archive()`), поэтому они остаются доступны для чтения и прямого диалога в веб-интерфейсе DSH.
+- **Совместимость с пресетами и инструментами**: При возобновлении сессии автоматически подключаются инструменты пресета `agentPreset`, гарантируя доступ к терминалу, файлам и командам.
+- *Благодарность*: концепция вдохновлена разработкой [@RaulLazaro](https://github.com/RaulLazaro).
+
+---
+
+### 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

@@ -358,6 +358,30 @@ bash deploy.sh verify [exact-version]
 
 ---
 
+### 25. 常驻持久会话与上下文延续 (`targetSessionId`，v0.2.13 新增，#143)
+- **跨周期会话上下文延续**：支持在任务中配置 `targetSessionId`。设置后，调度器将在每次定时触发时通过 `agents.resume()` 唤醒已有会话，而不再每次生成孤立的临时会话（`cron-exec-${id}-${uuid}`）。智能体能够完整继承上一轮对话的历史记忆与分析结论。
+- **上下文窗口保护与轮转机制 (`targetSessionReset`)**：为防止高频执行导致模型上下文窗口超限与 Token 成本暴增，支持智能轮转策略：
+  - `never`：持续累积单一会话，不重置。
+  - `daily`：每日自动开启全新子会话（后缀 `<id>-YYYY-MM-DD`）。
+  - `weekly`：每周自动开启全新子会话（后缀 `<id>-YYYY-Www`）。
+  - 日期变量插值：`targetSessionId` 中支持 `{{date}}` 占位符，自动注入当前日期 `YYYY-MM-DD`。
+- **主界面原生可见交互**：持久会话不会被标记为 `ephemeral`/`internal`，且在执行后跳过自动归档（`sessions.archive()`），用户可在 DSH 聊天列表中直接查看并继续手动对话。
+- **预设工具链无缝适配**：恢复会话时同样完整挂载 `agentPresets`，保障文件读写、代码编辑与终端工具持续可用。
+- *致谢*：功能灵感源自社区开发者 [@RaulLazaro](https://github.com/RaulLazaro)。
+
+---
+
+### 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

@@ -235,6 +235,30 @@ cron_create_task({
 
 ---
 
+### 25. Долговременные сессии и непрерывность контекста (`targetSessionId`, добавлено в v0.2.13, #143)
+- **Непрерывный контекст диалога**: Для задач можно задать `targetSessionId`. При наличии этого идентификатора планировщик возобновляет существующую сессию через `agents.resume()` вместо создания одноразовой сессии (`cron-exec-${id}-${uuid}`) на каждом тике. Агент сохраняет память предыдущих ходов и может ссылаться на ранее обнаруженные данные и выводы.
+- **Защита от переполнения контекста и ротация (`targetSessionReset`)**: Чтобы контекстное окно и расход токенов не разрастались бесконечно при частых запусках, предусмотрены политики автоматической ротации:
+  - `never`: единая непрерывная сессия без сброса.
+  - `daily`: ежедневная автоматическая ротация (`<id>-YYYY-MM-DD`).
+  - `weekly`: еженедельная автоматическая ротация (`<id>-YYYY-Www`).
+  - Шаблоны дат: в `targetSessionId` поддерживается плейсхолдер `{{date}}`, который автоматически заменяется на текущую дату `YYYY-MM-DD`.
+- **Видимость в списке чатов DSH**: Долговременные сессии не помечаются как `ephemeral`/`internal` и исключены из автоматической архивации (`sessions.archive()`), поэтому они остаются доступны для чтения и прямого диалога в веб-интерфейсе DSH.
+- **Совместимость с пресетами и инструментами**: При возобновлении сессии автоматически подключаются инструменты пресета `agentPreset`, гарантируя доступ к терминалу, файлам и командам.
+- *Благодарность*: концепция вдохновлена разработкой [@RaulLazaro](https://github.com/RaulLazaro).
+
+---
+
+### 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

@@ -358,6 +358,30 @@ bash deploy.sh verify [exact-version]
 
 ---
 
+### 25. 常驻持久会话与上下文延续 (`targetSessionId`，v0.2.13 新增，#143)
+- **跨周期会话上下文延续**：支持在任务中配置 `targetSessionId`。设置后，调度器将在每次定时触发时通过 `agents.resume()` 唤醒已有会话，而不再每次生成孤立的临时会话（`cron-exec-${id}-${uuid}`）。智能体能够完整继承上一轮对话的历史记忆与分析结论。
+- **上下文窗口保护与轮转机制 (`targetSessionReset`)**：为防止高频执行导致模型上下文窗口超限与 Token 成本暴增，支持智能轮转策略：
+  - `never`：持续累积单一会话，不重置。
+  - `daily`：每日自动开启全新子会话（后缀 `<id>-YYYY-MM-DD`）。
+  - `weekly`：每周自动开启全新子会话（后缀 `<id>-YYYY-Www`）。
+  - 日期变量插值：`targetSessionId` 中支持 `{{date}}` 占位符，自动注入当前日期 `YYYY-MM-DD`。
+- **主界面原生可见交互**：持久会话不会被标记为 `ephemeral`/`internal`，且在执行后跳过自动归档（`sessions.archive()`），用户可在 DSH 聊天列表中直接查看并继续手动对话。
+- **预设工具链无缝适配**：恢复会话时同样完整挂载 `agentPresets`，保障文件读写、代码编辑与终端工具持续可用。
+- *致谢*：功能灵感源自社区开发者 [@RaulLazaro](https://github.com/RaulLazaro)。
+
+---
+
+### 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/client.js

@@ -326,6 +326,14 @@ window.__ModuleLoader__.load({
         'form.agentPresetLabel': 'Agent preset',
         'form.agentPresetPlaceholder': 'standard (leave empty for configured default)',
         'form.agentPresetHint': 'Agent preset from dsh-agent-presets (e.g. standard, minimal, cordis, ptc). Mounts workspace and coding tools.',
+        'form.targetSessionIdLabel': 'Target persistent session ID',
+        'form.targetSessionIdPlaceholder': 'e.g. audit-chat or dev-summary (empty = isolated run)',
+        'form.targetSessionIdHint': 'When specified, scheduled runs resume this session to maintain conversation context across runs instead of creating a new isolated session.',
+        'form.targetSessionResetLabel': 'Session context rotation',
+        'form.targetSessionResetNever': 'Continuous (never reset)',
+        'form.targetSessionResetDaily': 'Daily rotation (new session each day)',
+        'form.targetSessionResetWeekly': 'Weekly rotation (new session each week)',
+        'form.targetSessionResetHint': 'Automatically rotates the session identifier to prevent context window explosion over long periods.',
         'form.previewSchedule': 'Preview next runs',
         'form.previewScheduleTitle': 'Next 5 scheduled runs:',
       },
@@ -402,6 +410,14 @@ window.__ModuleLoader__.load({
         'form.agentPresetLabel': '智能体预设 (Agent Preset)',
         'form.agentPresetPlaceholder': 'standard (留空使用全局默认预设)',
         'form.agentPresetHint': '来自 dsh-agent-presets 的智能体预设（如 standard, minimal, cordis, ptc），挂载工作区工具与文件读写能力。',
+        'form.targetSessionIdLabel': '目标常驻会话 ID (Target Session ID)',
+        'form.targetSessionIdPlaceholder': '如 audit-chat 或 dev-summary（留空为单次隔离运行）',
+        'form.targetSessionIdHint': '配置后定时任务将在此常驻会话中持续交互，跨周期保留历史上下文对话记忆，不再每次新建孤立会话。',
+        'form.targetSessionResetLabel': '上下文轮转策略 (Session Rotation)',
+        'form.targetSessionResetNever': '永不轮转（单一会话持续累积）',
+        'form.targetSessionResetDaily': '每日轮转（每日自动开启新会话）',
+        'form.targetSessionResetWeekly': '每周轮转（每周自动开启新会话）',
+        'form.targetSessionResetHint': '自动按周期加注日期后缀轮转会话，有效防止长时间运行导致的模型上下文窗口超限与 Token 浪费。',
         'form.previewSchedule': '预测下次运行时间',
         'form.previewScheduleTitle': '未来 5 次计划运行时间:',
         'search.placeholder': '搜索定时任务',
@@ -1162,6 +1178,8 @@ window.__ModuleLoader__.load({
       const [formMaxRetries, setFormMaxRetries] = React.useState(0);
       const [formPermissionPreset, setFormPermissionPreset] = React.useState('default');
       const [formAgentPreset, setFormAgentPreset] = React.useState('');
+      const [formTargetSessionId, setFormTargetSessionId] = React.useState('');
+      const [formTargetSessionReset, setFormTargetSessionReset] = React.useState('never');
       const [formEnv, setFormEnv] = React.useState('');
       const [formCwd, setFormCwd] = React.useState('');
       const [formWorkspaceId, setFormWorkspaceId] = React.useState('');
@@ -1713,6 +1731,8 @@ window.__ModuleLoader__.load({
         setFormMaxRetries(0);
         setFormPermissionPreset('default');
         setFormAgentPreset('');
+          setFormTargetSessionId('');
+          setFormTargetSessionReset('never');
         setFormEnv('');
         setFormCwd('');
         setFormWorkspaceId('');
@@ -1812,6 +1832,8 @@ window.__ModuleLoader__.load({
         setFormMaxRetries(task.maxRetries !== undefined ? task.maxRetries : 0);
         setFormPermissionPreset(task.permissionPreset || 'default');
         setFormAgentPreset(task.agentPreset || '');
+        setFormTargetSessionId(task.targetSessionId || '');
+        setFormTargetSessionReset(task.targetSessionReset || 'never');
         setFormEnv(formatEnvText(task.env));
         setFormCwd(task.cwd || '');
         setFormWorkspaceId(task.workspaceId || '');
@@ -1870,6 +1892,8 @@ window.__ModuleLoader__.load({
             maxRetries: Number(formMaxRetries) || 0,
             permissionPreset: formPermissionPreset,
             agentPreset: formAgentPreset.trim() || undefined,
+            targetSessionId: formTargetSessionId.trim() || undefined,
+            targetSessionReset: formTargetSessionReset || 'never',
             kanbanMode: formKanbanMode,
             onSuccess: formOnSuccess.trim() || undefined,
             onFailure: formOnFailure.trim() || undefined,
@@ -2190,6 +2214,7 @@ window.__ModuleLoader__.load({
                         task.onSuccess ? React.createElement('span', { className: 'dsh-cron-type-tag', title: 'On success: triggers ' + task.onSuccess, style: { background: 'rgba(56, 189, 248, 0.15)', color: '#38bdf8' } }, '➜ ' + task.onSuccess) : null,
                         task.onFailure ? React.createElement('span', { className: 'dsh-cron-type-tag', title: 'On failure: triggers ' + task.onFailure, style: { background: 'rgba(239, 68, 68, 0.15)', color: '#ef4444' } }, '↳ ' + task.onFailure) : null,
                         task.heartbeatIntervalSeconds > 0 ? React.createElement('span', { className: 'dsh-cron-type-tag', title: 'Heartbeat: every ' + task.heartbeatIntervalSeconds + 's', style: { background: 'rgba(168, 85, 247, 0.15)', color: '#a855f7' } }, '💓 ' + task.heartbeatIntervalSeconds + 's') : null,
+                        task.targetSessionId ? React.createElement('span', { className: 'dsh-cron-type-tag', title: 'Target session: ' + task.targetSessionId + (task.targetSessionReset && task.targetSessionReset !== 'never' ? ' (' + task.targetSessionReset + ')' : ''), style: { background: 'rgba(99, 102, 241, 0.15)', color: '#818cf8' } }, '🧵 ' + task.targetSessionId) : null,
                         task.preflightType && task.preflightType !== 'none' ? React.createElement('span', { className: 'dsh-cron-type-tag', title: 'Preflight: ' + task.preflightType, style: { background: 'rgba(234, 179, 8, 0.15)', color: '#eab308' } }, '🛡️ ' + task.preflightType) : null,
                         task.totalCostUsd > 0 ? React.createElement('span', { className: 'dsh-cron-cost-tag' }, '$' + task.totalCostUsd.toFixed(4)) : null,
                         task.totalTokens > 0 ? React.createElement('span', { className: 'dsh-cron-tokens-tag' }, (task.totalTokens > 1000 ? Math.round(task.totalTokens / 1000) + 'k' : task.totalTokens) + ' tok') : null
@@ -2540,6 +2565,30 @@ window.__ModuleLoader__.load({
                   }),
                   React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.agentPresetHint'))
                 ),
+                AGENT_FORM_TYPES.includes(formType) && React.createElement('div', { className: 'dsh-cron-form-row' },
+                  React.createElement('div', { className: 'dsh-cron-form-group' },
+                    React.createElement('label', null, T_KEY(t, 'form.targetSessionIdLabel')),
+                    React.createElement('input', {
+                      type: 'text',
+                      value: formTargetSessionId,
+                      placeholder: T_KEY(t, 'form.targetSessionIdPlaceholder'),
+                      onChange: (e) => setFormTargetSessionId(e.target.value)
+                    }),
+                    React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.targetSessionIdHint'))
+                  ),
+                  React.createElement('div', { className: 'dsh-cron-form-group' },
+                    React.createElement('label', null, T_KEY(t, 'form.targetSessionResetLabel')),
+                    React.createElement('select', {
+                      value: formTargetSessionReset,
+                      onChange: (e) => setFormTargetSessionReset(e.target.value)
+                    },
+                      React.createElement('option', { value: 'never' }, T_KEY(t, 'form.targetSessionResetNever')),
+                      React.createElement('option', { value: 'daily' }, T_KEY(t, 'form.targetSessionResetDaily')),
+                      React.createElement('option', { value: 'weekly' }, T_KEY(t, 'form.targetSessionResetWeekly'))
+                    ),
+                    React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.targetSessionResetHint'))
+                  )
+                ),
                 AGENT_FORM_TYPES.includes(formType) && React.createElement('div', { className: 'dsh-cron-form-row' },
                   React.createElement('div', { className: 'dsh-cron-form-group' },
                     React.createElement('label', null, T_KEY(t, 'form.providerLabel')),

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).
  */
@@ -23,9 +61,46 @@ import {
 /**
  * Runner executing scheduled tasks in DeepSeek Harness sessions.
  */
+
+/**
+ * Resolves the effective target session ID taking into account rotation policies (#143).
+ * Supports {{date}} interpolation, 'daily' rotation (adds -YYYY-MM-DD), and 'weekly' rotation (-YYYY-Www).
+ */
+export function resolveTargetSessionId(targetSessionId, resetPolicy = 'never', date = new Date()) {
+  if (!targetSessionId || typeof targetSessionId !== 'string') return null;
+  let baseId = targetSessionId.trim();
+  if (!baseId) return null;
+
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, '0');
+  const dd = String(date.getDate()).padStart(2, '0');
+  const yyyymmdd = `${yyyy}-${mm}-${dd}`;
+
+  if (baseId.includes('{{date}}')) {
+    return baseId.replaceAll('{{date}}', yyyymmdd);
+  }
+
+  if (resetPolicy === 'daily') {
+    return `${baseId}-${yyyymmdd}`;
+  }
+
+  if (resetPolicy === 'weekly') {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const weekNo = Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
+    const ww = String(weekNo).padStart(2, '0');
+    return `${baseId}-${d.getUTCFullYear()}-W${ww}`;
+  }
+
+  return baseId;
+}
+
 export class SessionRunner {
-  constructor(ctx) {
+  constructor(ctx, store = null) {
     this.ctx = ctx;
+    this.store = store;
   }
 
   async execute(task, options = {}) {
@@ -207,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;
@@ -217,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 = () => {
@@ -349,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;
     }
@@ -381,7 +479,15 @@ export class SessionRunner {
       sessionModule = await import('@deepseek-ai/dsh-session');
     } catch {}
 
+    const targetSessionId = resolveTargetSessionId(task.targetSessionId, task.targetSessionReset);
+
     const mintSessionId = () => {
+      if (targetSessionId) {
+        if (sessionModule && typeof sessionModule.SessionId === 'function') {
+          return sessionModule.SessionId(targetSessionId);
+        }
+        return targetSessionId;
+      }
       const sid = `cron-exec-${task.id}-${randomUUID()}`;
       if (sessionModule && typeof sessionModule.SessionId === 'function') {
         return sessionModule.SessionId(sid);
@@ -393,6 +499,7 @@ export class SessionRunner {
     return {
       createUserMessage,
       mintSessionId,
+      targetSessionId,
       provider: task.provider || defaultSel?.provider,
       model: task.model || defaultSel?.model || undefined,
       ...(await this._resolveRunContext(task)),
@@ -456,6 +563,7 @@ ${prompt}`;
   /** Create the session, drive one turn, and always clean up. */
   async _executeAgentTurn(task, prep) {
     let handle = null;
+    let isResumed = false;
     try {
       // Resolve agent preset (#GH-1): scheduled llm sessions must join an agent preset
       // (default or task-configured), otherwise tools resolve against the empty global layer.
@@ -473,23 +581,49 @@ ${prompt}`;
         }
       }
 
-      handle = await this.ctx.agents.create({
-        sessionId: prep.mintSessionId(),
-        meta: {
-          cwd: prep.cwd,
-          ephemeral: true,
-          internal: true,
-          ...(preset ? { agentPreset: preset.id } : {})
-        },
-        agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
-        ...(preset ? {
-          setup: async (agentCtx) => {
-            if (typeof presets.mount === 'function') {
-              await presets.mount(agentCtx, preset.id);
-            }
+      const presetSetup = preset ? {
+        setup: async (agentCtx) => {
+          if (typeof presets.mount === 'function') {
+            await presets.mount(agentCtx, preset.id);
           }
-        } : {}),
-      });
+        }
+      } : {};
+
+      // If targetSessionId is set, attempt to resume the existing session (#143)
+      if (prep.targetSessionId && this.ctx.agents && typeof this.ctx.agents.resume === 'function') {
+        try {
+          handle = await this.ctx.agents.resume({
+            sessionId: prep.targetSessionId,
+            meta: {
+              cwd: prep.cwd,
+              ...(preset ? { agentPreset: preset.id } : {})
+            },
+            agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
+            ...presetSetup,
+          });
+          isResumed = true;
+          console.log(`[dsh-cron] resumed existing persistent session: ${prep.targetSessionId}`);
+        } catch (resumeErr) {
+          console.log(`[dsh-cron] could not resume session ${prep.targetSessionId} (${resumeErr.message}), creating new persistent session`);
+          handle = null;
+        }
+      }
+
+      // Create new session if not resumed
+      if (!handle) {
+        handle = await this.ctx.agents.create({
+          sessionId: prep.mintSessionId(),
+          meta: {
+            cwd: prep.cwd,
+            ephemeral: !prep.targetSessionId,
+            internal: !prep.targetSessionId,
+            ...(preset ? { agentPreset: preset.id } : {})
+          },
+          agentOptions: prep.provider && prep.model ? { provider: prep.provider, model: prep.model } : undefined,
+          ...presetSetup,
+        });
+      }
+
       this._applyPermissionPreset(task, handle);
       await prep.raceAbort(handle.agent.whenIdle());
       handle.agent.followup(prep.createUserMessage({
@@ -501,8 +635,11 @@ ${prompt}`;
         await prep.raceAbort(handle.agent.whenIdle());
       }
       const usage = this._extractUsage(handle);
+      const sessionNote = isResumed
+        ? `resumed: ${prep.targetSessionId}`
+        : `session: ${handle.agent.session?.id || 'cron'}`;
       return {
-        output: `[dsh-cron] Agent finished turn for task "${task.title}" (session: ${handle.agent.session?.id || 'cron'})`,
+        output: `[dsh-cron] Agent finished turn for task "${task.title}" (${sessionNote})`,
         usage,
         costUsd: estimateTokenCost(prep.model, usage),
         sessionId: handle.agent.session?.id || null,
@@ -555,7 +692,8 @@ ${prompt}`;
       console.warn('[dsh-cron] session dispose notice:', disposeErr.message);
     }
     // Best-effort: keep ephemeral cron sessions out of the main chat list (#30).
-    if (archivedSessionId && this.ctx && this.ctx.get) {
+    // Persistent sessions (targetSessionId configured) stay unarchived so users can interact with them (#143).
+    if (archivedSessionId && this.ctx && this.ctx.get && !prep.targetSessionId) {
       try {
         const sessions = this.ctx.get('sessions');
         if (sessions && typeof sessions.archive === 'function') {

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);
     }
@@ -250,6 +289,8 @@ export class TaskStore {
       selfHealingCommand: task.selfHealingCommand !== undefined ? String(task.selfHealingCommand).trim() : (prev.selfHealingCommand || ''),
       autoDiagnose: task.autoDiagnose !== undefined ? Boolean(task.autoDiagnose) : (prev.autoDiagnose || false),
       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,
       createdAt: prev.createdAt || task.createdAt || now,
@@ -358,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/lib/task-transfer.js

@@ -31,6 +31,8 @@ export const PATCHABLE_TASK_FIELDS = [
   'retryBackoffMs',
   'permissionPreset',
   'agentPreset',
+  'targetSessionId',
+  'targetSessionReset',
   'env',
   'cwd',
   'workspaceId',

package/package.json

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