@goodandready/dsh-cron 0.3.22 → 0.3.24

package/lib/chat-start.js

@@ -18,7 +18,12 @@ export async function chatStartHandler(ctx, req, res, parseJsonBody, sendJson, r
       return;
     }
 
-    const agents = ctx.agents;
+    let agents = null;
+    try {
+      agents = (ctx && typeof ctx.get === 'function' ? ctx.get('agents') : null) || (ctx && ctx.agents);
+    } catch {
+      agents = null;
+    }
     if (!agents || typeof agents.create !== 'function') {
       sendJson(res, 500, { ok: false, error: 'The agents service is unavailable in DSH' });
       return;
@@ -45,7 +50,13 @@ export async function chatStartHandler(ctx, req, res, parseJsonBody, sendJson, r
       (ctx.logger || console).debug?.('[dsh-cron] @deepseek-ai/dsh-session SessionId unavailable, using string fallback:', err?.message || err);
     }
 
-    const defaultSel = ctx.get('agentDefaultModel')?.currentSelection?.();
+    let defaultSel = null;
+    try {
+      const adm = (ctx && typeof ctx.get === 'function' ? ctx.get('agentDefaultModel') : null) || (ctx && ctx.agentDefaultModel);
+      defaultSel = adm?.currentSelection?.();
+    } catch {
+      defaultSel = null;
+    }
     const provider = body.provider || defaultSel?.provider;
     const model = body.model || defaultSel?.model;
 

package/lib/index.js

@@ -1,10 +1,24 @@
+import {
+  TaskSchema,
+  validateTaskRecord,
+  safeValidateTaskRecord,
+  validateTaskPatch,
+} from './task-schema.js';
+
+export {
+  TaskSchema,
+  validateTaskRecord,
+  safeValidateTaskRecord,
+  validateTaskPatch,
+};
 import fs from 'node:fs';
 import path from 'node:path';
 import { bestEffort } from './best-effort.js';
 import { setLogger, logger } from './logger.js';
 import { registerPluginUpdater } from './updater.js';
 import { credentialRefStatus } from './secrets.js';
-import { TaskStore } from './store.js';
+import { TaskStore, CURRENT_SCHEMA_VERSION, runStoreMigrations } from './store.js';
+export { TaskStore, CURRENT_SCHEMA_VERSION, runStoreMigrations };
 import { TaskScheduler, parseScheduleExpression } from './scheduler.js';
 import { SessionRunner } from './runner.js';
 import { getModelsHandler } from './models-handler.js';
@@ -95,7 +109,7 @@ export {
 };
 
 export const name = '@goodandready/dsh-cron';
-export const inject = ['tools', 'webServer', 'llm', 'agents', 'agentDefaultModel', 'credentials', 'workspaceRegistry'];
+export const inject = ['tools', 'webServer'];
 
 import { executeCreateTask } from './task-create.js';
 import {

package/lib/models-handler.js

@@ -3,11 +3,18 @@ export async function getModelsHandler(ctx, req, res, sendJson) {
     sendJson(res, 405, { ok: false, error: 'Method not allowed' });
     return;
   }
-  const current = ctx.get('agentDefaultModel')?.currentSelection?.() ?? null;
+  let current = null;
+  try {
+    const adm = (ctx && typeof ctx.get === 'function' ? ctx.get('agentDefaultModel') : null) || (ctx && ctx.agentDefaultModel);
+    current = adm?.currentSelection?.() ?? null;
+  } catch {
+    current = null;
+  }
   let providers = [];
   try {
-    if (ctx.llm && typeof ctx.llm.listProviders === 'function') {
-      providers = (ctx.llm.listProviders() ?? []).map((p) => ({ id: p.id, name: p.name ?? p.id }));
+    const llm = (ctx && typeof ctx.get === 'function' ? ctx.get('llm') : null) || (ctx && ctx.llm);
+    if (llm && typeof llm.listProviders === 'function') {
+      providers = (llm.listProviders() ?? []).map((p) => ({ id: p.id, name: p.name ?? p.id }));
     }
   } catch {
     providers = [];
@@ -22,8 +29,9 @@ export async function getModelsHandler(ctx, req, res, sendJson) {
 
   try {
     let rows = [];
-    if (ctx.llm && typeof ctx.llm.listModels === 'function') {
-      rows = await ctx.llm.listModels(wanted);
+    const llm = (ctx && typeof ctx.get === 'function' ? ctx.get('llm') : null) || (ctx && ctx.llm);
+    if (llm && typeof llm.listModels === 'function') {
+      rows = await llm.listModels(wanted);
     }
     sendJson(res, 200, {
       current,
@@ -33,4 +41,4 @@ export async function getModelsHandler(ctx, req, res, sendJson) {
   } catch {
     sendJson(res, 200, { current, providers, models: [] });
   }
-}
+}

package/lib/routes.js

@@ -22,6 +22,80 @@ const LOCALES_JSON = readFileSync(new URL('./locales.json', import.meta.url), 'u
 
 
 export function registerRoutes(ctx, { store, scheduler, recommendations }) {
+  // Monthly history archives collection route (#391)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/history/archives',
+    handler: (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end('GET only');
+        return;
+      }
+      res.writeHead(200, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+      });
+      const archives = typeof store?.listMonthlyArchives === 'function' ? store.listMonthlyArchives() : [];
+      res.end(JSON.stringify({ ok: true, archives }));
+    }
+  }), 'dsh-cron: /history/archives');
+
+  // Specific monthly history archive route (#391)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/history/archive/',
+    handler: (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end('GET only');
+        return;
+      }
+      const url = new URL(req.url, 'http://127.0.0.1');
+      const month = url.pathname.replace(/^\/dsh-cron\/history\/archive\//, '').replace(/\/$/, '');
+      if (!/^\d{4}-\d{2}$/.test(month)) {
+        res.writeHead(400, { 'content-type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ ok: false, error: 'Invalid month format, expected YYYY-MM' }));
+        return;
+      }
+      const archive = typeof store?.getMonthlyArchive === 'function' ? store.getMonthlyArchive(month) : null;
+      if (!archive) {
+        res.writeHead(404, { 'content-type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ ok: false, error: `Archive for month "${month}" not found` }));
+        return;
+      }
+      res.writeHead(200, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'public, max-age=3600',
+      });
+      res.end(JSON.stringify({ ok: true, month, archive }));
+    }
+  }), 'dsh-cron: /history/archive/:month');
+
+  // Health probe route (#384)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-cron/health',
+    handler: (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end('GET only');
+        return;
+      }
+      res.writeHead(200, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store'
+      });
+      const tasks = typeof store?.list === 'function' ? store.list().length : 0;
+      res.end(JSON.stringify({
+        status: 'ok',
+        plugin: '@goodandready/dsh-cron',
+        tasks,
+        uptimeSec: Math.floor(process.uptime()),
+      }));
+    }
+  }), 'dsh-cron: /health');
+
   // Client locales route (#374)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/runner-external.js

@@ -176,11 +176,22 @@ export async function runExternal(task, runtime, signal, execOptions = {}, { ctx
   return new Promise((resolve, reject) => {
     let child = null;
     let settled = false;
+    let timedOut = false;
     let stdout = '';
     let stderr = '';
-    const maxBuffer = 10 * 1024 * 1024;
+    let truncated = false;
+    // Issue #393: maxLogBytesPerRun cap (default 5MB)
+    const maxLogBytes = Number(task.maxLogBytesPerRun) > 0 ? Number(task.maxLogBytesPerRun) : 5 * 1024 * 1024;
     const isPosix = process.platform !== 'win32';
 
+    // Issue #393: Execution timeout guardrail (default 15 minutes = 900,000ms, or task.executionTimeoutMs / timeoutSeconds)
+    const effectiveTimeoutMs = Number(task.executionTimeoutMs) > 0
+      ? Number(task.executionTimeoutMs)
+      : (Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) * 1000 : 15 * 60 * 1000);
+
+    let timeoutTimer = null;
+    let forceKillTimer = null;
+
     const killProcessTree = (sig = 'SIGTERM') => {
       terminateProcessTree(child, sig, {
         isPosix,
@@ -190,13 +201,37 @@ export async function runExternal(task, runtime, signal, execOptions = {}, { ctx
       });
     };
 
+    const cleanupTimers = () => {
+      if (timeoutTimer) { clearTimeout(timeoutTimer); timeoutTimer = null; }
+      if (forceKillTimer) { clearTimeout(forceKillTimer); forceKillTimer = null; }
+    };
+
+    if (effectiveTimeoutMs > 0) {
+      timeoutTimer = setTimeout(() => {
+        if (settled) return;
+        timedOut = true;
+        logger.warn(`[dsh-cron] task "${task.title || task.id}" timed out after ${effectiveTimeoutMs}ms, sending SIGTERM`);
+        killProcessTree('SIGTERM');
+        forceKillTimer = setTimeout(() => {
+          if (!settled) {
+            logger.warn(`[dsh-cron] task "${task.title || task.id}" force killing with SIGKILL`);
+            killProcessTree('SIGKILL');
+          }
+        }, 3000);
+        if (typeof forceKillTimer.unref === 'function') forceKillTimer.unref();
+      }, effectiveTimeoutMs);
+      if (typeof timeoutTimer.unref === 'function') timeoutTimer.unref();
+    }
+
     const abortHandler = () => {
+      cleanupTimers();
       killProcessTree('SIGTERM');
       setTimeout(() => killProcessTree('SIGKILL'), 300);
     };
 
     if (signal) {
       if (signal.aborted) {
+        cleanupTimers();
         return reject(signal.reason || new Error('Command aborted'));
       }
       signal.addEventListener('abort', abortHandler, { once: true });
@@ -218,23 +253,67 @@ export async function runExternal(task, runtime, signal, execOptions = {}, { ctx
     if (invocation.file) {
       child = spawn(invocation.file, invocation.args || [], options);
     } else {
+      let command = invocation.shellCommand;
+      if (isPosix && Number(task.maxMemoryMb) > 0) {
+        command = `ulimit -v ${Number(task.maxMemoryMb) * 1024} 2>/dev/null || true; ${command}`;
+      }
       const shellPath = isPosix ? (process.env.SHELL || '/bin/bash') : (process.env.ComSpec || 'cmd.exe');
-      const shellArgs = isPosix ? ['-c', invocation.shellCommand] : ['/d', '/s', '/c', invocation.shellCommand];
+      const shellArgs = isPosix ? ['-c', command] : ['/d', '/s', '/c', command];
       child = spawn(shellPath, shellArgs, options);
     }
 
     child.stdout.on('data', (chunk) => {
-      if (stdout.length < maxBuffer) stdout += chunk;
-      logStreamer.appendLog(task.id, chunk.toString('utf-8'), 'stdout');
+      const remaining = maxLogBytes - (stdout.length + stderr.length);
+      const text = chunk.toString('utf-8');
+      if (remaining > 0) {
+        if (text.length <= remaining) {
+          stdout += text;
+          if (!truncated) logStreamer.appendLog(task.id, text, 'stdout');
+        } else {
+          stdout += text.slice(0, remaining);
+          if (!truncated) {
+            truncated = true;
+            const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
+            stdout += note;
+            logStreamer.appendLog(task.id, text.slice(0, remaining) + note, 'stdout');
+          }
+        }
+      } else if (!truncated) {
+        truncated = true;
+        const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
+        stdout += note;
+        logStreamer.appendLog(task.id, note, 'stdout');
+      }
     });
+
     child.stderr.on('data', (chunk) => {
-      if (stderr.length < maxBuffer) stderr += chunk;
-      logStreamer.appendLog(task.id, chunk.toString('utf-8'), 'stderr');
+      const remaining = maxLogBytes - (stdout.length + stderr.length);
+      const text = chunk.toString('utf-8');
+      if (remaining > 0) {
+        if (text.length <= remaining) {
+          stderr += text;
+          if (!truncated) logStreamer.appendLog(task.id, text, 'stderr');
+        } else {
+          stderr += text.slice(0, remaining);
+          if (!truncated) {
+            truncated = true;
+            const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
+            stderr += note;
+            logStreamer.appendLog(task.id, text.slice(0, remaining) + note, 'stderr');
+          }
+        }
+      } else if (!truncated) {
+        truncated = true;
+        const note = `\n[TRUNCATED: log output exceeded maxLogBytesPerRun (${Math.round(maxLogBytes / 1024 / 1024)}MB)]`;
+        stderr += note;
+        logStreamer.appendLog(task.id, note, 'stderr');
+      }
     });
 
     child.on('error', (err) => {
       if (settled) return;
       settled = true;
+      cleanupTimers();
       if (signal) signal.removeEventListener('abort', abortHandler);
       logStreamer.completeStream(task.id, { status: 'error', error: err.message, exitCode: 1 });
       reject(err);
@@ -243,8 +322,14 @@ export async function runExternal(task, runtime, signal, execOptions = {}, { ctx
     child.on('close', (code, sig) => {
       if (settled) return;
       settled = true;
+      cleanupTimers();
       if (signal) signal.removeEventListener('abort', abortHandler);
 
+      if (timedOut) {
+        logStreamer.completeStream(task.id, { status: 'timeout', error: `Execution timed out after ${effectiveTimeoutMs}ms`, exitCode: 124 });
+        return reject(new Error(`Execution timed out after ${effectiveTimeoutMs}ms (SIGTERM/SIGKILL sent)`));
+      }
+
       if (signal && signal.aborted) {
         return reject(signal.reason || new Error('Command aborted'));
       }

package/lib/runner.js

@@ -79,6 +79,40 @@ export class SessionRunner {
     this.store = store;
   }
 
+  _getAgentsService() {
+    if (!this.ctx) return null;
+    try {
+      if (typeof this.ctx.get === 'function') {
+        const svc = this.ctx.get('agents');
+        if (svc) return svc;
+      }
+    } catch (_err) {
+      // service unavailable via ctx.get
+    }
+    try {
+      return this.ctx.agents || null;
+    } catch (_err) {
+      return null;
+    }
+  }
+
+  _getSessionService() {
+    if (!this.ctx) return null;
+    try {
+      if (typeof this.ctx.get === 'function') {
+        const svc = this.ctx.get('session');
+        if (svc) return svc;
+      }
+    } catch (_err) {
+      // service unavailable via ctx.get
+    }
+    try {
+      return this.ctx.session || null;
+    } catch (_err) {
+      return null;
+    }
+  }
+
   async execute(task, options = {}) {
     const timeoutSeconds = Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) : 1800;
     const timeoutMs = timeoutSeconds * 1000;
@@ -234,12 +268,14 @@ export class SessionRunner {
       }
 
       // 2. Agent session, when the harness exposes one
-      if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
+      const agentsSvc = this._getAgentsService();
+      if (agentsSvc && typeof agentsSvc.create === 'function') {
         return this._runAgentSession(effectiveTask, runtime, signal, options);
       }
 
       // 3. Legacy session service
-      if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
+      const sessionSvc = this._getSessionService();
+      if (sessionSvc && typeof sessionSvc.create === 'function') {
         return this._runLegacySession(effectiveTask, options);
       }
 
@@ -270,12 +306,14 @@ export class SessionRunner {
     }
 
     // 2. Agent session, when the harness exposes one
-    if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
+    const agentsSvc2 = this._getAgentsService();
+    if (agentsSvc2 && typeof agentsSvc2.create === 'function') {
       return this._runAgentSession(task, runtime, signal, options);
     }
 
     // 3. Legacy session service
-    if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
+    const sessionSvc2 = this._getSessionService();
+    if (sessionSvc2 && typeof sessionSvc2.create === 'function') {
       return this._runLegacySession(task, options);
     }
 
@@ -484,9 +522,10 @@ export class SessionRunner {
 
       // If targetSessionId is set, attempt to resume the existing session (#143, #346, GH #9)
       let resumeFailure = null;
-      if (prep.targetSessionId && this.ctx.agents && typeof this.ctx.agents.resume === 'function') {
+      const agents = this._getAgentsService();
+      if (prep.targetSessionId && agents && typeof agents.resume === 'function') {
         try {
-          handle = await this.ctx.agents.resume({
+          handle = await agents.resume({
             sessionId: prep.targetSessionId,
             resumeSessionId: prep.targetSessionId,
             meta: {
@@ -508,7 +547,7 @@ export class SessionRunner {
       // Create new session if not resumed
       if (!handle) {
         try {
-          handle = await this.ctx.agents.create({
+          handle = await agents.create({
             sessionId: prep.mintSessionId(),
             meta: {
               cwd: prep.cwd,

package/lib/runtimes.js

@@ -48,12 +48,16 @@ function looksLikeScriptFile(token, extensions) {
 export function buildNodeInvocation(task, cwd) {
   const nodeExecutable = task.nodePath || process.execPath;
   const { path: filePath, args } = splitCommandLine(task.prompt);
+  const flags = [];
+  if (Number(task.maxMemoryMb) > 0) {
+    flags.push(`--max-old-space-size=${Number(task.maxMemoryMb)}`);
+  }
   if (looksLikeScriptFile(filePath, ['.js', '.mjs', '.cjs'])) {
-    return { file: nodeExecutable, args: [filePath, ...args] };
+    return { file: nodeExecutable, args: [...flags, filePath, ...args] };
   }
   const code = String(task.prompt || '');
   const isEsm = /\bimport\s|\bexport\s/.test(code);
-  const nodeArgs = isEsm ? ['--input-type=module', '-e', code] : ['-e', code];
+  const nodeArgs = isEsm ? [...flags, '--input-type=module', '-e', code] : [...flags, '-e', code];
   return { file: nodeExecutable, args: nodeArgs };
 }
 
@@ -147,6 +151,8 @@ export function buildDockerInvocation(task, explicitEnv) {
     if (value === null || value === undefined) continue;
     args.push('-e', `${key}=${value}`);
   }
+  if (Number(task.maxMemoryMb) > 0) args.push(`--memory=${Number(task.maxMemoryMb)}m`);
+  if (Number(task.cpus) > 0) args.push(`--cpus=${Number(task.cpus)}`);
   if (task.cwd) args.push('-v', `${task.cwd}:/workspace`, '-w', '/workspace');
   args.push(image, 'sh', '-lc', String(task.prompt || 'true'));
   return { file: 'docker', args, env: envMap };

package/lib/store.js

@@ -4,6 +4,7 @@ import { ArtifactManager } from './artifacts.js';
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import fs from 'node:fs';
+import { gzipSync, gunzipSync } from 'node:zlib';
 import { pipeline } from 'node:stream/promises';
 import path from 'node:path';
 import { getDshDefaultTelegramCredentials } from './telegram.js';
@@ -17,6 +18,36 @@ import { getDshDefaultTelegramCredentials } from './telegram.js';
  * home's data directory, which is how an isolated test cycle once leaked a
  * task into the wrong profile.
  */
+
+export const CURRENT_SCHEMA_VERSION = 2;
+
+export function runStoreMigrations(data, fromVersion = 1, toVersion = CURRENT_SCHEMA_VERSION) {
+  if (!data || typeof data !== 'object') return data;
+  let current = { ...data };
+
+  // Migration from version 1 to 2 (Issue #390 & #393)
+  if (fromVersion < 2 && toVersion >= 2) {
+    if (Array.isArray(current.tasks)) {
+      current.tasks = current.tasks.map((task) => {
+        if (!task || typeof task !== 'object') return task;
+        return {
+          ...task,
+          maxMemoryMb: task.maxMemoryMb !== undefined ? Number(task.maxMemoryMb) : 0,
+          executionTimeoutMs: task.executionTimeoutMs !== undefined
+            ? Number(task.executionTimeoutMs)
+            : (Number(task.timeoutSeconds) > 0 ? Number(task.timeoutSeconds) * 1000 : 900000),
+          maxLogBytesPerRun: task.maxLogBytesPerRun !== undefined ? Number(task.maxLogBytesPerRun) : (5 * 1024 * 1024),
+          cpus: task.cpus !== undefined ? Number(task.cpus) : 0,
+          maxArchiveMonths: task.maxArchiveMonths !== undefined ? Number(task.maxArchiveMonths) : 6,
+        };
+      });
+    }
+    current.schemaVersion = 2;
+  }
+
+  return current;
+}
+
 export function getDefaultStorePath() {
   const base = process.env.DSH_DATA_DIR
     || (process.env.DSH_HOME
@@ -64,7 +95,21 @@ export class TaskStore {
     const bakPath = `${this.filePath}.bak`;
 
     const loadData = (raw) => {
-      const data = JSON.parse(raw);
+      let data = JSON.parse(raw);
+      const storedVersion = Number(data.schemaVersion) || 1;
+      if (storedVersion < CURRENT_SCHEMA_VERSION) {
+        // Pre-migration backup (#390)
+        try {
+          const preBakPath = `${this.filePath}.bak-v${storedVersion}-${Date.now()}`;
+          fs.writeFileSync(preBakPath, raw, { encoding: 'utf-8', mode: 0o600 });
+          bestEffort('chmod-pre-bak', () => fs.chmodSync(preBakPath, 0o600));
+          logger.info(`[dsh-cron] pre-migration backup saved to ${preBakPath}`);
+        } catch (bakErr) {
+          logger.warn('[dsh-cron] failed to write pre-migration backup:', bakErr.message);
+        }
+        data = runStoreMigrations(data, storedVersion, CURRENT_SCHEMA_VERSION);
+        this._needsMigrationFlush = true;
+      }
       this.tasks.clear();
       this.history.clear();
       if (Array.isArray(data.tasks)) {
@@ -151,6 +196,11 @@ export class TaskStore {
         logger.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
       }
     }
+    if (this._needsMigrationFlush) {
+      this._needsMigrationFlush = false;
+      this.scheduleSave(100);
+    }
+    bestEffort('prune-old-archives', () => this._pruneOldMonthlyArchives(dir, 6));
   }
 
   /**
@@ -201,6 +251,7 @@ export class TaskStore {
     }
     return {
       version: 1,
+      schemaVersion: CURRENT_SCHEMA_VERSION,
       updatedAt: new Date().toISOString(),
       tasks: tasksSnapshot,
       history: historySnapshot,
@@ -358,6 +409,7 @@ export class TaskStore {
       }
 
       yield '{"version":' + JSON.stringify(data.version || 1);
+      yield ',"schemaVersion":' + JSON.stringify(data.schemaVersion || CURRENT_SCHEMA_VERSION);
       yield ',"updatedAt":' + JSON.stringify(data.updatedAt || new Date().toISOString());
       yield ',"settings":' + JSON.stringify(data.settings || {});
 
@@ -651,6 +703,11 @@ export class TaskStore {
         ? (task.onlyOnFailure === null || task.onlyOnFailure === 'inherit' ? undefined : Boolean(task.onlyOnFailure))
         : prev.onlyOnFailure,
       timeoutSeconds: task.timeoutSeconds !== undefined ? Number(task.timeoutSeconds) : (prev.timeoutSeconds || 1800),
+      maxMemoryMb: task.maxMemoryMb !== undefined ? Number(task.maxMemoryMb) : (prev.maxMemoryMb || 0),
+      executionTimeoutMs: task.executionTimeoutMs !== undefined ? Number(task.executionTimeoutMs) : (prev.executionTimeoutMs || 0),
+      maxLogBytesPerRun: task.maxLogBytesPerRun !== undefined ? Number(task.maxLogBytesPerRun) : (prev.maxLogBytesPerRun || (5 * 1024 * 1024)),
+      cpus: task.cpus !== undefined ? Number(task.cpus) : (prev.cpus || 0),
+      maxArchiveMonths: task.maxArchiveMonths !== undefined ? Number(task.maxArchiveMonths) : (prev.maxArchiveMonths || 6),
       overlapPolicy: task.overlapPolicy !== undefined ? String(task.overlapPolicy) : (prev.overlapPolicy || 'skip'),
       kanbanMode: task.kanbanMode !== undefined ? String(task.kanbanMode) : (prev.kanbanMode || 'none'), // 'none' | 'on_failure' | 'always'
       onSuccess: task.onSuccess !== undefined ? String(task.onSuccess).trim() : (prev.onSuccess || ''),
@@ -922,11 +979,124 @@ export class TaskStore {
       bestEffort('chmod-tmp', () => fs.chmodSync(tmp, 0o600));
       fs.renameSync(tmp, archivePath);
       bestEffort('chmod-archive', () => fs.chmodSync(archivePath, 0o600));
+
+      // Partition runs into monthly buckets for compressed archives (#391)
+      const monthlyBuckets = new Map();
+      for (const run of sanitizedOverflow) {
+        const at = run.at || run.timestamp || run.startedAt || Date.now();
+        const date = new Date(at);
+        const monthKey = !isNaN(date.getTime())
+          ? `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}`
+          : new Date().toISOString().slice(0, 7);
+        if (!monthlyBuckets.has(monthKey)) {
+          monthlyBuckets.set(monthKey, []);
+        }
+        monthlyBuckets.get(monthKey).push(run);
+      }
+
+      for (const [monthKey, runsForMonth] of monthlyBuckets.entries()) {
+        const gzPath = path.join(dir, `tasks-history-${monthKey}.json.gz`);
+        let monthArchive = {};
+        if (fs.existsSync(gzPath)) {
+          try {
+            const rawGz = fs.readFileSync(gzPath);
+            const decompressed = gunzipSync(rawGz).toString('utf-8');
+            monthArchive = JSON.parse(decompressed) || {};
+          } catch (gzReadErr) {
+            logger.warn(`[dsh-cron] failed to read existing gzip archive for ${monthKey}:`, gzReadErr.message);
+            monthArchive = {};
+          }
+        }
+        if (!Array.isArray(monthArchive[id])) {
+          monthArchive[id] = [];
+        }
+        monthArchive[id].push(...runsForMonth);
+        const compressed = gzipSync(Buffer.from(JSON.stringify(monthArchive), 'utf-8'), { level: 9 });
+        const randGz = Math.random().toString(36).slice(2, 8);
+        const tmpGz = `${gzPath}.tmp.${process.pid}_${Date.now()}_${randGz}`;
+        fs.writeFileSync(tmpGz, compressed, { mode: 0o600 });
+        bestEffort('chmod-tmp-gz', () => fs.chmodSync(tmpGz, 0o600));
+        fs.renameSync(tmpGz, gzPath);
+        bestEffort('chmod-archive-gz', () => fs.chmodSync(gzPath, 0o600));
+      }
+
+      this._pruneOldMonthlyArchives(dir, 6);
     } catch (archiveErr) {
       logger.error('[dsh-cron] history archive error:', archiveErr.message);
     }
   }
 
+  listMonthlyArchives() {
+    try {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) return [];
+      const files = fs.readdirSync(dir);
+      const archives = [];
+      for (const file of files) {
+        const match = file.match(/^tasks-history-(\d{4}-\d{2})\.json\.gz$/);
+        if (match) {
+          const month = match[1];
+          const fullPath = path.join(dir, file);
+          try {
+            const stat = fs.statSync(fullPath);
+            archives.push({
+              month,
+              filename: file,
+              sizeBytes: stat.size,
+              mtime: stat.mtime.toISOString(),
+              path: fullPath,
+            });
+          } catch (_err) {
+            // ignore unreadable stat
+          }
+        }
+      }
+      return archives.sort((a, b) => b.month.localeCompare(a.month));
+    } catch (err) {
+      logger.error('[dsh-cron] listMonthlyArchives error:', err.message);
+      return [];
+    }
+  }
+
+  getMonthlyArchive(month) {
+    if (!month || !/^\d{4}-\d{2}$/.test(month)) return null;
+    try {
+      const dir = path.dirname(this.filePath);
+      const gzPath = path.join(dir, `tasks-history-${month}.json.gz`);
+      if (!fs.existsSync(gzPath)) return null;
+      const rawGz = fs.readFileSync(gzPath);
+      const decompressed = gunzipSync(rawGz).toString('utf-8');
+      return JSON.parse(decompressed);
+    } catch (err) {
+      logger.error(`[dsh-cron] getMonthlyArchive error for ${month}:`, err.message);
+      return null;
+    }
+  }
+
+  _pruneOldMonthlyArchives(dir, maxMonths = 6) {
+    try {
+      if (!fs.existsSync(dir) || maxMonths < 0) return;
+      const files = fs.readdirSync(dir);
+      const monthlyFiles = [];
+      for (const file of files) {
+        const match = file.match(/^tasks-history-(\d{4}-\d{2})\.json\.gz$/);
+        if (match) {
+          monthlyFiles.push({ month: match[1], file, fullPath: path.join(dir, file) });
+        }
+      }
+      monthlyFiles.sort((a, b) => b.month.localeCompare(a.month));
+      if (monthlyFiles.length > maxMonths) {
+        const toDelete = monthlyFiles.slice(maxMonths);
+        for (const item of toDelete) {
+          bestEffort('delete-old-archive', () => fs.unlinkSync(item.fullPath));
+          logger.info(`[dsh-cron] pruned old monthly history archive: ${item.file}`);
+        }
+      }
+    } catch (err) {
+      bestEffort('log-prune-err', () => logger.debug?.(`[dsh-cron] prune old monthly archives error: ${err.message}`));
+    }
+  }
+
   getHistory(id, limit = 20) {
     const runs = this.history.get(id) || [];
     return runs.slice(0, limit);

package/lib/task-create.js

@@ -1,3 +1,4 @@
+import { validateTaskRecord } from './task-schema.js';
 import { sanitizeSwarmConfig } from './swarm.js';
 import { sanitizeBranchRules } from './branching.js';
 import { sanitizePromptHistory } from './prompt-evolver.js';
@@ -132,7 +133,8 @@ export function executeCreateTask(store, scheduler, args) {
     throw new Error(dagCheck.error);
   }
 
-  const task = store.set(taskData);
+  const validTask = validateTaskRecord(taskData);
+  const task = store.set(validTask);
   scheduler.scheduleTask(task);
   return {
     success: true,

package/lib/task-schema.js

@@ -0,0 +1,180 @@
+import z from '@deepseek-ai/schemastery';
+import { normalizeTaskType } from './runtimes.js';
+import { validateTaskType, PATCHABLE_TASK_FIELDS } from './task-transfer.js';
+import { CHANNEL_IDS } from './channels.js';
+
+export const TaskSchema = z.object({
+  id: z.string(),
+  title: z.string().required(),
+  schedule: z.string().required(),
+  scheduleText: z.string(),
+  type: z.string().default('llm'),
+  prompt: z.string().default(''),
+  delivery: z.string().default('isolated'),
+  status: z.string().default('active'),
+  provider: z.string(),
+  model: z.string(),
+  fallbackProvider: z.string(),
+  fallbackModel: z.string(),
+  silentRule: z.string().default(''),
+  inspectOnFailure: z.boolean().default(false),
+  agentPreset: z.string().default(''),
+  targetSessionId: z.string().default(''),
+  targetSessionReset: z.string().default('never'),
+  sessionTitle: z.string().default(''),
+  timezone: z.string().default(''),
+  misfirePolicy: z.string().default('skip'),
+  maxRetries: z.number().default(0),
+  retryBackoffMs: z.number().default(30000),
+  permissionPreset: z.string().default('default'),
+  captureGitDiff: z.boolean(),
+  kanbanMode: z.string().default('none'),
+  channels: z.array(z.string()).default([]),
+  template: z.string().default(''),
+  env: z.any(),
+  cwd: z.string().default(''),
+  workspaceId: z.string().default(''),
+  worktree: z.boolean().default(false),
+  keepWorktree: z.boolean().default(false),
+  httpMethod: z.string().default('GET'),
+  httpUrl: z.string().default(''),
+  httpHeaders: z.any(),
+  httpBody: z.string().default(''),
+  sshProfileId: z.string().default(''),
+  sshTarget: z.string().default(''),
+  sshPort: z.number().default(0),
+  sshKeyPath: z.string().default(''),
+  dockerImage: z.string().default(''),
+  pythonPath: z.string().default(''),
+  nodePath: z.string().default(''),
+  skillName: z.string().default(''),
+  workflowName: z.string().default(''),
+  webhookEnabled: z.boolean().default(false),
+  webhookToken: z.string(),
+  webhookSecret: z.string(),
+  webhookDebounceMs: z.number(),
+  webhookTrigger: z.any(),
+  onSuccess: z.string().default(''),
+  onFailure: z.string().default(''),
+  heartbeatIntervalSeconds: z.number().default(0),
+  gracePeriodSeconds: z.number().default(300),
+  preflightType: z.string().default('none'),
+  preflightTarget: z.string().default(''),
+  preflightCommand: z.string(),
+  preflightScript: z.string(),
+  concurrencyGroup: z.string().default('default'),
+  priority: z.number().default(5),
+  selfHealingCommand: z.string().default(''),
+  autoDiagnose: z.boolean().default(false),
+  notifyTelegram: z.boolean(),
+  onlyOnFailure: z.boolean(),
+  timeoutSeconds: z.number().default(1800),
+  overlapPolicy: z.string().default('skip'),
+  oneShot: z.boolean().default(false),
+  targetTimestamp: z.number(),
+  nextRunAt: z.number(),
+  costLimitUsd: z.number(),
+  dailyCostLimitUsd: z.number(),
+  tokenLimit: z.number(),
+  pausedReason: z.string(),
+  validators: z.any(),
+  requireApproval: z.boolean().default(false),
+  fileWatch: z.any(),
+  dependsOn: z.array(z.string()).default([]),
+  joinPolicy: z.string().default('all_success'),
+  adaptive: z.any(),
+  adaptiveState: z.any(),
+  promptVersion: z.number(),
+  promptHistory: z.any(),
+  branchRules: z.any(),
+  elseTask: z.string(),
+  autoHeal: z.boolean(),
+  selfHealing: z.any(),
+  revisions: z.any(),
+  previousPrompt: z.string(),
+  previousScript: z.string(),
+  swarm: z.any(),
+  gitDiff: z.any(),
+  maxMemoryMb: z.number().min(0).default(0),
+  executionTimeoutMs: z.number().min(0).default(900000),
+  maxLogBytesPerRun: z.number().min(0).default(5 * 1024 * 1024),
+  cpus: z.number().min(0).default(0),
+  maxArchiveMonths: z.number().min(1).default(6),
+  schemaVersion: z.number().default(2),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export function validateTaskRecord(data) {
+  if (!data || typeof data !== 'object') {
+    throw new TypeError('Task record must be an object');
+  }
+  if (data.title !== undefined && typeof data.title !== 'string') {
+    throw new Error('Task schema validation failed: title must be a string');
+  }
+  const title = String(data.title || '').trim();
+  if (!title) {
+    throw new Error('Task title cannot be empty');
+  }
+  if (data.schedule !== undefined && typeof data.schedule !== 'string') {
+    throw new Error('Task schema validation failed: schedule must be a string');
+  }
+  const schedule = String(data.schedule || '').trim();
+  if (!schedule) {
+    throw new Error('Task schedule cannot be empty');
+  }
+
+  const cleanType = normalizeTaskType(data.type);
+  const typeError = validateTaskType(cleanType, data);
+  if (typeError) {
+    throw new Error(typeError);
+  }
+
+  let validated;
+  try {
+    validated = TaskSchema({
+      ...data,
+      title,
+      schedule,
+      type: cleanType,
+    });
+  } catch (err) {
+    throw new Error(`Task schema validation failed: ${err.message}`);
+  }
+
+  // Filter channels to known channel ids if present
+  if (Array.isArray(validated.channels)) {
+    validated.channels = validated.channels.filter((c) => CHANNEL_IDS.includes(c));
+  }
+
+  // Strip undefined keys
+  for (const k of Object.keys(validated)) {
+    if (validated[k] === undefined) {
+      delete validated[k];
+    }
+  }
+
+  return validated;
+}
+
+export function safeValidateTaskRecord(data) {
+  try {
+    const task = validateTaskRecord(data);
+    return { ok: true, task };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export function validateTaskPatch(patch) {
+  if (!patch || typeof patch !== 'object') {
+    return { ok: false, error: 'Task patch must be an object' };
+  }
+  const clean = {};
+  for (const [key, value] of Object.entries(patch)) {
+    if (PATCHABLE_TASK_FIELDS.includes(key)) {
+      clean[key] = value;
+    }
+  }
+  return { ok: true, patch: clean };
+}

package/lib/task-transfer.js

@@ -98,6 +98,11 @@ export const PATCHABLE_TASK_FIELDS = [
   'previousPrompt',
   'previousScript',
   'swarm',
+  'maxMemoryMb',
+  'executionTimeoutMs',
+  'maxLogBytesPerRun',
+  'cpus',
+  'maxArchiveMonths',
   'gitDiff',
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",
@@ -22,7 +22,8 @@
     "test": "node --test test/*.test.mjs && node scripts/check-pack-size.mjs",
     "build:client": "node scripts/build-client.mjs",
     "pretest": "node scripts/build-client.mjs",
-    "preflight": "node scripts/ci-preflight.mjs"
+    "preflight": "node scripts/ci-preflight.mjs",
+    "test:engine": "node scripts/test-engines.mjs"
   },
   "keywords": [
     "dsh",
@@ -51,6 +52,14 @@
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-slots"
       ]
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.2.1-rc.2": "compatible",
+        "0.2.1-rc.3": "compatible",
+        "0.2.1-rc.4": "compatible"
+      },
+      "dsh": ">=0.2.1-rc.2 <0.2.2-0"
     }
   },
   "dependencies": {