@goodandready/dsh-cron 0.2.29 → 0.2.31

package/lib/index.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import { setLogger, logger } from './logger.js';
 import { registerPluginUpdater } from './updater.js';
 import { credentialRefStatus } from './secrets.js';
 import { TaskStore } from './store.js';
@@ -110,10 +112,11 @@ export {
   LEGACY_TOOL_NAMES,
   LEGACY_ACTION_MAP,
 };
-export const createTaskParameters = cronToolParameters;
-export const createTaskOutput = cronToolOutput;
+const pkgUrl = new URL('../package.json', import.meta.url);
+const pkgVersion = JSON.parse(fs.readFileSync(pkgUrl, 'utf8')).version || '0.2.29';
 
 export function apply(ctx, rawConfig) {
+  if (ctx && ctx.logger) setLogger(ctx.logger);
   const config = unwrapConfig(rawConfig);
   const store = new TaskStore();
 
@@ -172,9 +175,9 @@ export function apply(ctx, rawConfig) {
   try {
     const configJobs = Array.isArray(config && config.jobs) ? config.jobs : [];
     const summary = applyConfigSync({ store, scheduler, entries: configJobs });
-    console.log('[dsh-cron] config jobs synced: ' + JSON.stringify(summary));
+    logger.info('[dsh-cron] config jobs synced: ' + JSON.stringify(summary));
   } catch (err) {
-    console.error('[dsh-cron] config job sync failed:', err.message);
+    logger.error('[dsh-cron] config job sync failed:', err.message);
   }
 
   scheduler.start();
@@ -186,7 +189,7 @@ export function apply(ctx, rawConfig) {
     const intervalMs = Number(config.heartbeatIntervalSec) * 1000;
     heartbeatTimer = setInterval(() => {
       fetch(config.heartbeatUrl, { method: 'GET' }).catch((err) => {
-        console.warn('[dsh-cron] heartbeat ping failed:', err.message);
+        logger.warn('[dsh-cron] heartbeat ping failed:', err.message);
       });
     }, intervalMs);
   }
@@ -224,7 +227,7 @@ export function apply(ctx, rawConfig) {
     handler: async (req, res) => {
       try {
         if (req.method === 'GET') {
-          sendJson(res, 200, { ok: true, settings: store.getClientSettings() });
+          sendJson(res, 200, { ok: true, settings: { ...store.getClientSettings(), version: pkgVersion } });
           return;
         }
         if (req.method === 'POST') {
@@ -236,7 +239,7 @@ export function apply(ctx, rawConfig) {
           const scopeErrors = await applySettingsToScope(settingsService, payload);
           sendJson(res, 200, {
             ok: true,
-            settings: store.getClientSettings(),
+            settings: { ...store.getClientSettings(), version: pkgVersion },
             scopeErrors: (scopeErrors && scopeErrors.length > 0) ? scopeErrors : undefined
           });
           return;

package/lib/integrations.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 /**
  * Integration module for dsh-kanban and LLM token cost estimation.
  */
@@ -77,7 +78,7 @@ export async function createKanbanCard({
     const data = await res.json().catch(() => ({}));
     return { success: true, task: data.task };
   } catch (err) {
-    console.error('[dsh-cron] failed to create kanban card:', err.message);
+    logger.error('[dsh-cron] failed to create kanban card:', err.message);
     return { success: false, error: err.message };
   }
 }

package/lib/llm-actions.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import fs from 'node:fs';
 
@@ -103,7 +104,7 @@ export async function executeLlmActionDirectives({ directives, task, runInfo, sc
         results.push({ type, status: giteaRes ? 'created' : 'skipped', details: giteaRes });
       }
     } catch (err) {
-      console.warn(`[dsh-cron] action directive ${type} execution failed:`, err.message);
+      logger.warn(`[dsh-cron] action directive ${type} execution failed:`, err.message);
       results.push({ type, status: 'error', error: err.message });
     }
   }

package/lib/logger.js

@@ -0,0 +1,38 @@
+// Unified logging wrapper for dsh-cron (#204)
+// Routes logs through ctx.logger when running inside DSH/Cordis,
+// and safely falls back to console in tests or standalone runs.
+
+let currentLogger = console;
+
+export function setLogger(logger) {
+  if (logger && typeof logger === 'object') {
+    currentLogger = logger;
+  }
+}
+
+function getLogger() {
+  return currentLogger;
+}
+
+export const logger = {
+  info(...args) {
+    const fn = currentLogger.info || currentLogger.log || console.log;
+    return fn.call(currentLogger, ...args);
+  },
+  warn(...args) {
+    const fn = currentLogger.warn || currentLogger.log || console.warn;
+    return fn.call(currentLogger, ...args);
+  },
+  error(...args) {
+    const fn = currentLogger.error || currentLogger.log || console.error;
+    return fn.call(currentLogger, ...args);
+  },
+  debug(...args) {
+    const fn = currentLogger.debug || currentLogger.log || console.debug;
+    return fn.call(currentLogger, ...args);
+  },
+  log(...args) {
+    const fn = currentLogger.info || currentLogger.log || console.log;
+    return fn.call(currentLogger, ...args);
+  },
+};

package/lib/models-handler.js

@@ -1,4 +1,8 @@
 export async function getModelsHandler(ctx, req, res, sendJson) {
+  if ((req.method || 'GET') !== 'GET') {
+    sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+    return;
+  }
   const current = ctx.get('agentDefaultModel')?.currentSelection?.() ?? null;
   let providers = [];
   try {

package/lib/routes.js

@@ -89,7 +89,7 @@ export function registerRoutes(ctx, { store, scheduler, getCronSettingsScope, re
     path: '/dsh-cron/recipes',
     handler: async (req, res) => {
       try {
-        if (req.method !== 'GET') {
+        if ((req.method || 'GET') !== 'GET') {
           sendJson(res, 405, { ok: false, error: 'Method not allowed' });
           return;
         }
@@ -108,6 +108,10 @@ export function registerRoutes(ctx, { store, scheduler, getCronSettingsScope, re
     path: '/dsh-cron/heartbeat',
     handler: async (req, res) => {
       try {
+        if ((req.method || 'GET') !== 'GET') {
+          sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+          return;
+        }
         const tasks = store.list({ status: 'active' });
         const lastRuns = tasks.map((t) => t.lastRunAt || 0);
         sendJson(res, 200, {

package/lib/runner-external.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import {
   buildInvocation,
@@ -74,7 +75,7 @@ export async function runHttp(task, request, signal) {
       if (!res.ok) {
         const err = new Error(`${summary}\n${String(text).slice(0, 500)}`);
         if (isTransientError(res.status) && attempts < maxAttempts && !signal?.aborted) {
-          console.warn(`[dsh-cron] HTTP request returned ${res.status}, retrying attempt ${attempts + 1}/${maxAttempts}...`);
+          logger.warn(`[dsh-cron] HTTP request returned ${res.status}, retrying attempt ${attempts + 1}/${maxAttempts}...`);
           await new Promise((r) => setTimeout(r, attempts * 1000));
           continue;
         }
@@ -87,7 +88,7 @@ export async function runHttp(task, request, signal) {
       };
     } catch (err) {
       if (isTransientError(err) && attempts < maxAttempts && !signal?.aborted) {
-        console.warn(`[dsh-cron] HTTP request failed (${err.message}), retrying attempt ${attempts + 1}/${maxAttempts}...`);
+        logger.warn(`[dsh-cron] HTTP request failed (${err.message}), retrying attempt ${attempts + 1}/${maxAttempts}...`);
         await new Promise((r) => setTimeout(r, attempts * 1000));
         continue;
       }

package/lib/runner-worktree.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 
 /**
@@ -46,7 +47,7 @@ export async function removeTaskWorktree(cwd, wtPath) {
   await new Promise((resolve) => {
     execFile('git', ['-C', cwd, 'worktree', 'remove', wtPath], { maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
-        console.warn(`[dsh-cron] task worktree kept (not removable without force): ${wtPath} — ${String(stderr || err.message).trim()}`);
+        logger.warn(`[dsh-cron] task worktree kept (not removable without force): ${wtPath} — ${String(stderr || err.message).trim()}`);
       }
       execFile('git', ['-C', cwd, 'worktree', 'prune'], () => resolve());
     });

package/lib/runner.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import { estimateTokenCost } from './integrations.js';
 import {
@@ -141,7 +142,7 @@ export class SessionRunner {
   }
 
   async _run(task, signal, options = {}) {
-    console.log(`[dsh-cron] executing task "${task.title}" (${task.id})`);
+    logger.info(`[dsh-cron] executing task "${task.title}" (${task.id})`);
 
     // 1. Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9)
     const runtime = normalizeTaskType(task.type);
@@ -177,7 +178,7 @@ export class SessionRunner {
         return { output: out, usage, costUsd: estimateTokenCost(task.model, usage) };
       }
     } catch (err) {
-      console.error(`[dsh-cron] session execution failed:`, err.message);
+      logger.error(`[dsh-cron] session execution failed:`, err.message);
       throw err;
     }
     return this._runBare(task);
@@ -207,7 +208,7 @@ export class SessionRunner {
     } 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...`);
+        logger.warn(`[dsh-cron] Persistent session "${prep.targetSessionId}" exceeded context window (${err.message}). Auto-recovering with fresh session...`);
         bestEffort('archive-rotated-session', () => {
           const sessions = this.ctx?.get?.('sessions');
           if (sessions && typeof sessions.archive === 'function') {
@@ -215,7 +216,7 @@ export class SessionRunner {
           }
         });
         const rotatedSessionId = `${prep.targetSessionId}-${Date.now().toString(36)}`;
-        console.log(`[dsh-cron] Rotated persistent session "${prep.targetSessionId}" -> "${rotatedSessionId}"`);
+        logger.info(`[dsh-cron] Rotated persistent session "${prep.targetSessionId}" -> "${rotatedSessionId}"`);
         if (this.store) {
           bestEffort('update-stored-rotated-session', () => {
             const stored = this.store.get(task.id);
@@ -230,7 +231,7 @@ export class SessionRunner {
         const freshPrep = await this._prepareAgentRun(effectiveTask, runtime, signal);
         return await this._executeAgentTurn(task, freshPrep);
       }
-      console.error(`[dsh-cron] agent execution failed:`, err.message);
+      logger.error(`[dsh-cron] agent execution failed:`, err.message);
       throw err;
     }
   }
@@ -306,7 +307,7 @@ export class SessionRunner {
         taskWorktree = await this.createTaskWorktree(baseCwd, task);
         cwd = taskWorktree;
       } catch (wtErr) {
-        console.warn('[dsh-cron] task worktree not created, running in the workspace:', wtErr.message);
+        logger.warn('[dsh-cron] task worktree not created, running in the workspace:', wtErr.message);
       }
     }
     return { baseCwd, cwd, taskWorktree };
@@ -349,7 +350,7 @@ export class SessionRunner {
             await presets.standingKeyFor(preset.id);
           }
         } catch (presetErr) {
-          console.warn('[dsh-cron] agent preset unavailable, running without one:', presetErr && presetErr.message);
+          logger.warn('[dsh-cron] agent preset unavailable, running without one:', presetErr && presetErr.message);
           preset = null;
         }
       }
@@ -375,9 +376,9 @@ export class SessionRunner {
             ...presetSetup,
           });
           isResumed = true;
-          console.log(`[dsh-cron] resumed existing persistent session: ${prep.targetSessionId}`);
+          logger.info(`[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`);
+          logger.info(`[dsh-cron] could not resume session ${prep.targetSessionId} (${resumeErr.message}), creating new persistent session`);
           handle = null;
         }
       }
@@ -431,7 +432,7 @@ export class SessionRunner {
         presets.set(handle.agent.session, task.permissionPreset);
       }
     } catch (ppErr) {
-      console.warn('[dsh-cron] permission preset not applied:', ppErr.message);
+      logger.warn('[dsh-cron] permission preset not applied:', ppErr.message);
     }
   }
 
@@ -462,7 +463,7 @@ export class SessionRunner {
         await handle.agent.destroy();
       }
     } catch (disposeErr) {
-      console.warn('[dsh-cron] session dispose notice:', disposeErr.message);
+      logger.warn('[dsh-cron] session dispose notice:', disposeErr.message);
     }
     // Best-effort: keep ephemeral cron sessions out of the main chat list (#30).
     // Persistent sessions (targetSessionId configured) stay unarchived so users can interact with them (#143).

package/lib/scheduler-execution.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { checkAndApplyBurnGuard, checkTaskBudgetLimits } from './burn-guard.js';
 import { resolveTaskForExecution } from './prompt-interpolation.js';
 import { bestEffort } from './best-effort.js';
@@ -126,7 +127,7 @@ export async function executeWithFallback(scheduler, task, signal, options = {})
     provider: task.fallbackProvider || task.provider,
     model: task.fallbackModel,
   };
-  console.log(`[dsh-cron] task "${task.title}" failed on ${task.model || 'the default model'}, retrying once on ${task.fallbackModel}`);
+  logger.info(`[dsh-cron] task "${task.title}" failed on ${task.model || 'the default model'}, retrying once on ${task.fallbackModel}`);
   const secondary = await scheduler.executeOnce(fallbackTask, signal, options);
   return {
     ...secondary,
@@ -143,12 +144,12 @@ export async function executeWithFallback(scheduler, task, signal, options = {})
 export function beginRun(scheduler, task, taskId) {
   if (!scheduler.running.has(taskId) && scheduler.maxConcurrent > 0 && scheduler.running.size >= scheduler.maxConcurrent) {
     if (task.overlapPolicy === 'queue') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${scheduler.maxConcurrent})`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${scheduler.maxConcurrent})`);
       scheduler.queue.push({ taskId, priority: task.priority !== undefined ? task.priority : 5, queuedAt: Date.now() });
       scheduler.queue.sort((a, b) => (a.priority - b.priority) || (a.queuedAt - b.queuedAt));
       return null;
     }
-    console.log(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency limit (${scheduler.maxConcurrent})`);
+    logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency limit (${scheduler.maxConcurrent})`);
     scheduler.recordSkipped(taskId, `Skipped: concurrency limit reached (${scheduler.maxConcurrent} parallel runs)`);
     return null;
   }
@@ -157,16 +158,16 @@ export function beginRun(scheduler, task, taskId) {
   const active = scheduler.running.get(taskId);
   if (active) {
     if (overlapPolicy === 'skip') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, skipping run (overlapPolicy: skip)`);
       scheduler.recordSkipped(taskId, 'Skipped: the previous run is still in progress (overlapPolicy: skip)');
       return null;
     }
     if (overlapPolicy === 'replace') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, canceling current run (overlapPolicy: replace)`);
       active.controller.abort(new Error('Aborted by overlap policy: replace'));
     }
     if (overlapPolicy === 'queue') {
-      console.log(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
+      logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) is already running, queueing next run (overlapPolicy: queue)`);
       active.queueCount = (active.queueCount || 0) + 1;
       return null;
     }
@@ -189,7 +190,7 @@ export async function executeTask(scheduler, taskId, options = {}) {
   const runs = (scheduler.store.history && scheduler.store.history.get(taskId)) || [];
   const guard = checkTaskBudgetLimits(task, runs);
   if (guard.exceeded) {
-    console.warn(`[dsh-cron] Burn Guard pre-flight blocked task "${task.title}" (${taskId}): ${guard.reason}`);
+    logger.warn(`[dsh-cron] Burn Guard pre-flight blocked task "${task.title}" (${taskId}): ${guard.reason}`);
     scheduler.pauseTask(taskId, guard.reason);
     scheduler.recordSkipped(taskId, `Burn Guard pre-flight pause: ${guard.reason}`);
     checkAndApplyBurnGuard(scheduler, taskId, { status: 'error', costUsd: 0, durationMs: 0 }).catch(() => {});
@@ -222,7 +223,7 @@ export async function executeTask(scheduler, taskId, options = {}) {
 
   const preflight = await executePreflight(task);
   if (!preflight.ok) {
-    console.log(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
+    logger.info(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
     scheduler.running.delete(taskId);
     scheduler.recordSkipped(taskId, `Preflight check skipped: ${preflight.reason}`);
     return null;
@@ -282,18 +283,18 @@ export async function applyModelAssists(task, runInfo, options) {
     runInfo.diagnosis = inspection.diagnosis;
     runInfo.suggestion = inspection.suggestion;
     runInfo.confidence = inspection.confidence;
-    console.log(`[dsh-cron] task "${task.title}" failure diagnosed (${inspection.confidence}): ${inspection.diagnosis}`);
+    logger.info(`[dsh-cron] task "${task.title}" failure diagnosed (${inspection.confidence}): ${inspection.diagnosis}`);
   } else if (inspection.error && task.inspectOnFailure) {
-    console.warn(`[dsh-cron] failure inspection for "${task.title}" not applied: ${inspection.error}`);
+    logger.warn(`[dsh-cron] failure inspection for "${task.title}" not applied: ${inspection.error}`);
   }
 
   const silent = await applySilentRuleToRun(task, runInfo, options);
   if (silent.skipped) {
     runInfo.silentSkip = true;
     runInfo.silentReason = silent.reason;
-    console.log(`[dsh-cron] task "${task.title}" stayed silent by rule: ${silent.reason || 'no reason given'}`);
+    logger.info(`[dsh-cron] task "${task.title}" stayed silent by rule: ${silent.reason || 'no reason given'}`);
   } else if (silent.verdictError) {
-    console.warn(`[dsh-cron] silent rule for "${task.title}" not applied: ${silent.verdictError}`);
+    logger.warn(`[dsh-cron] silent rule for "${task.title}" not applied: ${silent.verdictError}`);
   }
   return silent;
 }
@@ -308,19 +309,19 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
       try {
         settings = { ...settings, ...(await resolveSecrets(settings)) };
       } catch (secErr) {
-        console.warn('[dsh-cron] credential resolution failed:', secErr.message);
+        logger.warn('[dsh-cron] credential resolution failed:', secErr.message);
       }
     }
     if (typeof deliver !== 'function') return;
     const result = await deliver(task, runInfo, settings);
     if (result && Array.isArray(result.delivered) && result.delivered.length) {
-      console.log(`[dsh-cron] delivered "${task.title}" to: ${result.delivered.map((d) => d.channel).join(', ')}`);
+      logger.info(`[dsh-cron] delivered "${task.title}" to: ${result.delivered.map((d) => d.channel).join(', ')}`);
     }
     if (result && Array.isArray(result.failures) && result.failures.length) {
-      console.warn(`[dsh-cron] delivery failures for "${task.title}": ${result.failures.map((f) => `${f.channel}: ${f.error}`).join('; ')}`);
+      logger.warn(`[dsh-cron] delivery failures for "${task.title}": ${result.failures.map((f) => `${f.channel}: ${f.error}`).join('; ')}`);
     }
   } catch (notifyErr) {
-    console.error('[dsh-cron] notification error:', notifyErr.message);
+    logger.error('[dsh-cron] notification error:', notifyErr.message);
   }
 }
 
@@ -343,7 +344,7 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
       }
     }
   } catch (err) {
-    console.error('[dsh-cron] failed to persist the next run of task', taskId + ':', err.message);
+    logger.error('[dsh-cron] failed to persist the next run of task', taskId + ':', err.message);
   }
 
   try {
@@ -359,7 +360,7 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
         scheduler.retryTimers.delete(taskId);
         scheduler.runTask(taskId, { isRetry: true });
       }, backoffMs));
-      console.log(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
+      logger.info(`[dsh-cron] retry ${attempt}/${maxRetries} for task "${task.title}" in ${backoffMs}ms`);
     } else if (!failed && task.attempts) {
       task.attempts = 0;
       scheduler.store.set(task);
@@ -368,7 +369,7 @@ export function finishRun(scheduler, task, taskId, status, queuedCount) {
       scheduler.store.set(task);
     }
   } catch (err) {
-    console.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
+    logger.error('[dsh-cron] retry bookkeeping failed for task', taskId + ':', err.message);
   }
 
   if (queuedCount > 0) {
@@ -398,7 +399,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   };
 
   if (isFailure && task.selfHealingCommand) {
-    console.log(`[dsh-cron] running self-healing command for task "${task.title}": ${task.selfHealingCommand}`);
+    logger.info(`[dsh-cron] running self-healing command for task "${task.title}": ${task.selfHealingCommand}`);
     try {
       await new Promise((resolve) => {
         exec(task.selfHealingCommand, { timeout: 30000 }, (shErr, stdout, stderr) => {
@@ -435,7 +436,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   try {
     scheduler.store.recordRun(taskId, runInfo);
   } catch (recordErr) {
-    console.error(`[dsh-cron] failed to record the run of task ${taskId}:`, recordErr.message);
+    logger.error(`[dsh-cron] failed to record the run of task ${taskId}:`, recordErr.message);
   }
 
   const finishedRun = scheduler.running.get(taskId);
@@ -480,7 +481,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
         }
       }
     } catch (actErr) {
-      console.warn(`[dsh-cron] structured action error for ${taskId}:`, actErr.message);
+      logger.warn(`[dsh-cron] structured action error for ${taskId}:`, actErr.message);
     }
   }
 
@@ -492,7 +493,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
       const targetId = nextTaskId.trim();
       const nextTask = scheduler.store.get(targetId);
       if (nextTask) {
-        console.log(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
+        logger.info(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
         scheduler.runNow(targetId, {
           chainDepth: currentDepth + 1,
           prevOutput: outcome.output || outcome.error || '',
@@ -501,13 +502,13 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
           prevDurationMs: Date.now() - start,
           prevCostUsd: outcome.costUsd || 0,
         }).catch((err) => {
-          console.warn(`[dsh-cron] chained task ${targetId} failed to trigger:`, err.message);
+          logger.warn(`[dsh-cron] chained task ${targetId} failed to trigger:`, err.message);
         });
       } else {
-        console.warn(`[dsh-cron] chained task target not found: ${targetId}`);
+        logger.warn(`[dsh-cron] chained task target not found: ${targetId}`);
       }
     } else {
-      console.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id} -> ${nextTaskId}. Loop prevented.`);
+      logger.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id} -> ${nextTaskId}. Loop prevented.`);
     }
   }
 }

package/lib/scheduler-lifecycle.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 
 /**
@@ -41,7 +42,7 @@ export async function checkHeartbeats(scheduler) {
       task.updatedAt = now;
       scheduler.store.save();
 
-      console.warn(`[dsh-cron] Heartbeat missed for "${task.title}" (${task.id})!`);
+      logger.warn(`[dsh-cron] Heartbeat missed for "${task.title}" (${task.id})!`);
       const runInfo = {
         at: now,
         status: 'missed',
@@ -62,7 +63,7 @@ export async function checkHeartbeats(scheduler) {
           chainDepth: 1,
           prevOutput: runInfo.output,
           prevTaskId: task.id,
-        }).catch((err) => console.warn('[dsh-cron] heartbeat onFailure trigger error:', err.message));
+        }).catch((err) => logger.warn('[dsh-cron] heartbeat onFailure trigger error:', err.message));
       }
     }
   }

package/lib/scheduler.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import { Cron } from 'croner';
 import {
@@ -297,7 +298,7 @@ export class TaskScheduler {
       if (missed) {
         const missedAt = task.nextRunAt;
         const policy = task.misfirePolicy || 'skip';
-        console.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
+        logger.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
         this.countRun('missed');
         this.store.recordRun(task.id, {
           at: missedAt,
@@ -369,7 +370,7 @@ export class TaskScheduler {
     const timer = setTimeout(() => {
       this.timers.delete(task.id);
       this.runTask(task.id).catch((err) => {
-        console.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+        logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
       });
     }, delay);
     this.timers.set(task.id, timer);
@@ -380,7 +381,7 @@ export class TaskScheduler {
     const job = new Cron(parsed.cronPattern, {
       protect: true,
       sloppyRanges: true,
-      catch: (err) => console.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
+      catch: (err) => logger.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
       ...(timezone ? { timezone } : {}),
     }, async () => {
       await this.runTask(task.id);
@@ -407,7 +408,7 @@ export class TaskScheduler {
       }
       this.scheduleCron(task, parsed);
     } catch (err) {
-      console.error(`[dsh-cron] failed to schedule task ${task.id}:`, err.message);
+      logger.error(`[dsh-cron] failed to schedule task ${task.id}:`, err.message);
     }
   }
 

package/lib/settings.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import z from '@deepseek-ai/schemastery';
 import { credentialRefStatus } from './secrets.js';
 import { TaskStore } from './store.js';
@@ -147,14 +148,14 @@ export function sanitizeSettingsPayload(body) {
     if (key in payload && typeof payload[key] === 'string' && payload[key].trim()) {
       const refCheck = credentialRefStatus(payload[key]);
       if (!refCheck.ok) {
-        console.warn(`[dsh-cron] invalid credential reference in "${key}": ${refCheck.error}`);
+        logger.warn(`[dsh-cron] invalid credential reference in "${key}": ${refCheck.error}`);
         delete payload[key];
       }
     }
   }
   for (const key of TaskStore.FORBIDDEN_SETTING_KEYS) {
     if (key in payload) {
-      console.warn(`[dsh-cron] refusing raw secret "${key}" from the client — use a credential reference`);
+      logger.warn(`[dsh-cron] refusing raw secret "${key}" from the client — use a credential reference`);
       delete payload[key];
     }
   }

package/lib/store.js

@@ -1,3 +1,4 @@
+import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -74,21 +75,21 @@ export class TaskStore {
           bestEffort('backup-initial', () => fs.copyFileSync(this.filePath, bakPath));
         }
       } catch (err) {
-        console.error('[dsh-cron] store read error (corrupted file):', err.message);
+        logger.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}`);
+          logger.warn(`[dsh-cron] corrupted store backed up to ${corruptedPath}`);
         } catch (snapErr) {
-          console.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
+          logger.error('[dsh-cron] failed to snapshot corrupted store:', snapErr.message);
         }
         if (fs.existsSync(bakPath)) {
           try {
             const rawBak = fs.readFileSync(bakPath, 'utf-8');
             loadData(rawBak);
-            console.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
+            logger.warn(`[dsh-cron] successfully recovered tasks store from ${bakPath}`);
           } catch (bakErr) {
-            console.error('[dsh-cron] failed to recover tasks store from .bak:', bakErr.message);
+            logger.error('[dsh-cron] failed to recover tasks store from .bak:', bakErr.message);
           }
         }
       }
@@ -97,9 +98,9 @@ export class TaskStore {
         const rawBak = fs.readFileSync(bakPath, 'utf-8');
         loadData(rawBak);
         bestEffort('restore-from-bak', () => fs.copyFileSync(bakPath, this.filePath));
-        console.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
+        logger.warn(`[dsh-cron] restored missing tasks store from ${bakPath}`);
       } catch (bakErr) {
-        console.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
+        logger.error('[dsh-cron] failed to restore tasks store from .bak:', bakErr.message);
       }
     }
   }
@@ -158,7 +159,7 @@ export class TaskStore {
         bestEffort('backup-on-save', () => fs.copyFileSync(this.filePath, `${this.filePath}.bak`));
       }
     } catch (err) {
-      console.error('[dsh-cron] store save error:', err.message);
+      logger.error('[dsh-cron] store save error:', err.message);
     }
   }
 
@@ -222,7 +223,7 @@ export class TaskStore {
 
     for (const key of TaskStore.FORBIDDEN_SETTING_KEYS) {
       if (key in patch) {
-        console.warn(`[dsh-cron] refusing to store raw secret "${key}" in settings — use a credential reference instead`);
+        logger.warn(`[dsh-cron] refusing to store raw secret "${key}" in settings — use a credential reference instead`);
         delete patch[key];
       }
     }
@@ -441,7 +442,7 @@ export class TaskStore {
       fs.writeFileSync(tmp, JSON.stringify(archive), 'utf-8');
       fs.renameSync(tmp, archivePath);
     } catch (archiveErr) {
-      console.error('[dsh-cron] history archive error:', archiveErr.message);
+      logger.error('[dsh-cron] history archive error:', archiveErr.message);
     }
   }
 
@@ -456,7 +457,7 @@ export class TaskStore {
       const archivePath = path.join(dir, 'tasks-history-archive.json');
       if (!fs.existsSync(archivePath)) return { runs: [], total: 0 };
       const archive = JSON.parse(fs.readFileSync(archivePath, 'utf-8')) || {};
-      let runs = Array.isArray(archive[id]) ? archive[id] : [];
+      let runs = Array.isArray(archive[id]) ? [...archive[id]].sort((a, b) => ((b.at || b.timestamp || b.startedAt || 0) - (a.at || a.timestamp || a.startedAt || 0))) : [];
       if (search && search.trim()) {
         const q = search.toLowerCase();
         runs = runs.filter(r => (r.output && r.output.toLowerCase().includes(q)) || (r.error && r.error.toLowerCase().includes(q)));