@goodandready/dsh-cron 0.3.23 → 0.3.25

package/lib/api-item.js

@@ -21,7 +21,8 @@ export async function handleTaskItem({ store, scheduler, req, res, url, id, acti
   }
 
   if (req.method === 'GET') {
-    if (action === 'stream') {
+    // Both /dsh-cron/tasks/:id/stream and /dsh-cron/tasks/:id/logs/stream (#392)
+    if (action === 'stream' || (action === 'logs' && subAction === 'stream')) {
       logStreamer.handleSseRequest(id, req, res);
       return;
     }

package/lib/client.js

@@ -2736,14 +2736,46 @@ if (window.__dshLiveLogsEvtSource) {
 try { window.__dshLiveLogsEvtSource.close(); } catch (e) { void e; }
 window.__dshLiveLogsEvtSource = null;
 }
+if (window.__dshLiveLogsPollTimer) {
+clearInterval(window.__dshLiveLogsPollTimer);
+window.__dshLiveLogsPollTimer = null;
+}
 setLiveLogsTaskId(task.id);
 setLiveLogsTaskTitle(task.title || task.id);
 setLiveLogsLines([]);
 setLiveLogsStatus(task.running ? 'connecting' : 'idle');
 setLiveLogsCompleted(false);
 setLiveLogsModalOpen(true);
+const startPollingFallback = () => {
+if (window.__dshLiveLogsPollTimer) return;
+const pollFn = () => {
+fetchJsonWithTimeout('/dsh-cron/tasks/' + encodeURIComponent(task.id) + '/history?limit=1')
+.then((data) => {
+if (data && data.history && data.history.length > 0) {
+const lastRun = data.history[0];
+if (lastRun.output || lastRun.error) {
+const text = lastRun.output || lastRun.error;
+setLiveLogsLines([{ chunk: text, stream: lastRun.error ? 'stderr' : 'stdout', ts: lastRun.at }]);
+}
+if (lastRun.status) {
+setLiveLogsStatus(lastRun.status);
+setLiveLogsCompleted(true);
+if (window.__dshLiveLogsPollTimer) {
+clearInterval(window.__dshLiveLogsPollTimer);
+window.__dshLiveLogsPollTimer = null;
+}
+}
+}
+})
+.catch(() => {});
+};
+pollFn();
+window.__dshLiveLogsPollTimer = setInterval(pollFn, 2000);
+};
+if (typeof EventSource !== 'undefined') {
 try {
-const es = new EventSource('/dsh-cron/tasks/' + encodeURIComponent(task.id) + '/stream');
+const streamUrl = '/dsh-cron/tasks/' + encodeURIComponent(task.id) + '/logs/stream';
+const es = new EventSource(streamUrl);
 window.__dshLiveLogsEvtSource = es;
 es.addEventListener('init', (e) => {
 try {
@@ -2767,12 +2799,21 @@ try { es.close(); } catch (e) { void e; }
 window.__dshLiveLogsEvtSource = null;
 });
 es.onerror = () => {
-setLiveLogsStatus((curr) => curr === 'running' ? 'completed' : 'closed');
 try { es.close(); } catch (e) { void e; }
 window.__dshLiveLogsEvtSource = null;
+setLiveLogsStatus((curr) => {
+if (curr === 'running' || curr === 'connecting') {
+startPollingFallback();
+return curr;
+}
+return 'completed';
+});
 };
 } catch (err) {
-setLiveLogsStatus('error');
+startPollingFallback();
+}
+} else {
+startPollingFallback();
 }
 }
 function handleCloseLiveLogs() {
@@ -2780,6 +2821,10 @@ if (window.__dshLiveLogsEvtSource) {
 try { window.__dshLiveLogsEvtSource.close(); } catch (e) { void e; }
 window.__dshLiveLogsEvtSource = null;
 }
+if (window.__dshLiveLogsPollTimer) {
+clearInterval(window.__dshLiveLogsPollTimer);
+window.__dshLiveLogsPollTimer = null;
+}
 setLiveLogsModalOpen(false);
 }
 const openAnalyticsDigest = async (days = 7) => {

package/lib/index.js

@@ -17,7 +17,8 @@ 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';

package/lib/log-streamer.js

@@ -50,12 +50,15 @@ export class LogStreamer extends EventEmitter {
       ts: Date.now(),
     };
 
+    entry.eventSeq = (entry.eventSeq || 0) + 1;
+    item.id = entry.eventSeq;
+
     entry.buffer.push(item);
     if (entry.buffer.length > MAX_BUFFER_LINES) {
       entry.buffer.shift();
     }
 
-    const ssePayload = `event: log\ndata: ${JSON.stringify(item)}\n\n`;
+    const ssePayload = `id: ${item.id}\nevent: log\ndata: ${JSON.stringify(item)}\n\n`;
     for (const res of entry.subscribers) {
       try {
         res.write(ssePayload);
@@ -111,12 +114,17 @@ export class LogStreamer extends EventEmitter {
 
     const entry = this.streams.get(taskId);
 
+    // Support W3C Last-Event-ID for reconnection (#392)
+    const lastEventIdStr = req?.headers ? req.headers['last-event-id'] : undefined;
+    const lastEventId = lastEventIdStr ? parseInt(lastEventIdStr, 10) : 0;
+    const effectiveLogs = (entry?.buffer || []).filter((item) => !lastEventId || (item.id && item.id > lastEventId));
+
     // Initial event with current state and buffered logs
     const initData = {
       taskId,
       runId: entry?.runId || null,
       status: entry ? (entry.completed ? 'completed' : 'running') : 'idle',
-      bufferedLogs: entry?.buffer || [],
+      bufferedLogs: effectiveLogs,
     };
     res.write(`event: init\ndata: ${JSON.stringify(initData)}\n\n`);
 

package/lib/routes.js

@@ -22,6 +22,56 @@ 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',

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

@@ -95,7 +95,12 @@ export const TaskSchema = z.object({
   previousScript: z.string(),
   swarm: z.any(),
   gitDiff: z.any(),
-  schemaVersion: z.number().default(1),
+  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(),
 });

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.23",
+  "version": "0.3.25",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",
@@ -23,7 +23,8 @@
     "build:client": "node scripts/build-client.mjs",
     "pretest": "node scripts/build-client.mjs",
     "preflight": "node scripts/ci-preflight.mjs",
-    "test:engine": "node scripts/test-engines.mjs"
+    "test:engine": "node scripts/test-engines.mjs",
+    "build:client:check": "node scripts/build-client.mjs --check"
   },
   "keywords": [
     "dsh",
@@ -108,6 +109,7 @@
     "@deepseek-ai/dsh-session": ">=0.1.0-rc.6 <0.1.1 || >=0.1.1-rc.1 <0.1.2 || >=0.1.2-alpha.1 <1.0.0",
     "@deepseek-ai/dsh-settings": ">=0.1.0-rc.6 <0.1.1 || >=0.1.1-rc.1 <0.1.2 || >=0.1.2-alpha.1 <1.0.0",
     "@deepseek-ai/dsh-tools": ">=0.1.0-rc.6 <0.1.1 || >=0.1.1-rc.1 <0.1.2 || >=0.1.2-alpha.1 <1.0.0",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "esbuild": "^0.28.2"
   }
 }