@goodandready/dsh-cron 0.2.28 → 0.2.30

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';
@@ -92,66 +94,29 @@ export const name = '@goodandready/dsh-cron';
 export const inject = ['tools', 'webServer', 'llm', 'agents', 'agentDefaultModel', 'credentials'];
 
 import { executeCreateTask } from './task-create.js';
-export { executeCreateTask };
-
-export const createTaskParameters = {
-  title: { type: 'string', description: 'Short task name', required: true },
-  schedule: { type: 'string', description: 'Schedule: cron ("0 9 * * *"), shorthand ("@daily", "@every 30m"), interval ("every 2h") or one-shot ("in 30m", "at: 2026-09-05T15:00:00Z")', required: true },
-  prompt: { type: 'string', description: 'Prompt/instruction for the agent at run time', required: true },
-  type: { type: 'string', enum: TASK_TYPES, description: 'Task type: llm | script | node | python | http | ssh | docker | skill | workflow' },
-  delivery: { type: 'string', enum: ['current', 'isolated'], description: 'Run mode: current (in the current chat) or isolated (separate session)' },
-  provider: { type: 'string', description: 'Model provider (optional)' },
-  inspectOnFailure: { type: 'boolean', description: 'Diagnose failed runs with a model and store the diagnosis with the run (agent tasks)' },
-  silentRule: { type: 'string', description: 'Plain-language condition for staying silent on a successful run (script/node/python/http tasks)' },
-  fallbackModel: { type: 'string', description: 'Model tried once more when the primary model fails (llm/skill/workflow tasks)' },
-  fallbackProvider: { type: 'string', description: 'Provider for the fallback model (defaults to the task provider)' },
-  model: { type: 'string', description: 'Model (optional)' },
-  timezone: { type: 'string', description: 'IANA time zone for the schedule, e.g. "Europe/Berlin" (optional, default = server local)' },
-  notifyTelegram: { type: 'boolean', description: 'Send the run report to Telegram' },
-  onlyOnFailure: { type: 'boolean', description: 'Send reports only for failures' },
-  timeoutSeconds: { type: 'number', description: 'Execution time limit in seconds' },
-  overlapPolicy: { type: 'string', enum: ['skip', 'queue', 'replace'], description: 'Overlap policy' },
-  misfirePolicy: { type: 'string', enum: ['skip', 'runOnce', 'catchUpAll'], description: 'What to do with a run missed during downtime' },
-  maxRetries: { type: 'number', description: 'Automatic retry attempts on failure (0 = off)' },
-  retryBackoffMs: { type: 'number', description: 'Base backoff between retries in ms, doubled per attempt' },
-  permissionPreset: { type: 'string', enum: ['default', 'read-only', 'workspace-write', 'full'], description: 'Permission preset applied to the task session' },
-  kanbanMode: { type: 'string', enum: ['none', 'on_failure', 'always'], description: 'Create a dsh-kanban card for runs' },
-  channels: { type: 'array', items: { type: 'string', enum: CHANNEL_IDS }, description: 'Notification channels for this task; empty = legacy telegram/kanban flags' },
-  template: { type: 'string', description: 'Notification template with {title} {status} {output} {error} {duration} placeholders; empty = built-in text' },
-  env: { type: 'object', additionalProperties: true, description: 'Environment variables for external runtimes (KEY: value); do not store secrets here' },
-  cwd: { type: 'string', description: 'Working directory for the run (external runtimes and agent sessions)' },
-  workspaceId: { type: 'string', description: 'Workspace bound to the task; resolved through the harness' },
-  worktree: { type: 'boolean', description: 'Run code-modifying agent tasks in an isolated git worktree' },
-  keepWorktree: { type: 'boolean', description: 'Keep the created worktree after the run' },
-  nodePath: { type: 'string', description: 'Node.js binary for node tasks (default: the harness runtime)' },
-  pythonPath: { type: 'string', description: 'Python interpreter for python tasks (default: auto-detected venv)' },
-  httpMethod: { type: 'string', description: 'HTTP method for http tasks' },
-  httpUrl: { type: 'string', description: 'URL for http tasks' },
-  httpHeaders: { type: 'object', additionalProperties: true, description: 'Headers for http tasks' },
-  httpBody: { type: 'string', description: 'Request body for http tasks' },
-  sshProfileId: { type: 'string', description: 'dsh-remote-workspace profile id that provides host and credentials' },
-  sshTarget: { type: 'string', description: 'Fallback user@host when no remote-workspace profile is used' },
-  sshPort: { type: 'number', description: 'SSH port (with sshTarget fallback)' },
-  sshKeyPath: { type: 'string', description: 'Private key path (with sshTarget fallback)' },
-  dockerImage: { type: 'string', description: 'Container image for docker tasks' },
-  skillName: { type: 'string', description: 'DSH skill name for skill tasks' },
-  workflowName: { type: 'string', description: 'DSH workflow name for workflow tasks' },
-};
+import {
+  cronToolParameters,
+  cronToolOutput,
+  executeCronTool,
+  rejectLegacyTool,
+  LEGACY_TOOL_NAMES,
+  LEGACY_ACTION_MAP,
+} from './cron-tool.js';
 
-const createTaskOutput = {
-  schema: {
-    type: 'object',
-    additionalProperties: true,
-    properties: {
-      success: { type: 'boolean' },
-      message: { type: 'string' },
-      task: { type: 'object', additionalProperties: true }
-    }
-  },
-  render: (_args, val) => [{ type: 'text', text: val.message || JSON.stringify(val) }]
+export {
+  executeCreateTask,
+  cronToolParameters,
+  cronToolOutput,
+  executeCronTool,
+  rejectLegacyTool,
+  LEGACY_TOOL_NAMES,
+  LEGACY_ACTION_MAP,
 };
+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();
 
@@ -210,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();
@@ -224,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);
   }
@@ -262,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') {
@@ -274,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;
@@ -286,243 +251,12 @@ export function apply(ctx, rawConfig) {
     }
   }), 'dsh-cron: /settings');
 
-  // 2. Tools
-  ctx.tools.register(defineTool({
-    name: 'cron_create_task',
-    description: 'Create a new scheduled cron task (cron schedule, or one-shot via "at: <ISO timestamp>" or "in 20m")',
-    parameters: createTaskParameters,
-    output: createTaskOutput,
-    execute: async (args) => executeCreateTask(store, scheduler, args)
-  }));
-
-  // Alias tool cron_schedule_task for compatibility with agent prompts (#70)
-  ctx.tools.register(defineTool({
-    name: 'cron_schedule_task',
-    description: 'Alias for cron_create_task: create a new scheduled cron task',
-    parameters: createTaskParameters,
-    output: createTaskOutput,
-    execute: async (args) => executeCreateTask(store, scheduler, args)
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_list_tasks',
-    description: 'List all scheduled cron tasks',
-    parameters: {
-      status: { type: 'string', enum: ['all', 'active', 'paused', 'completed'], description: 'Filter by status' }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          count: { type: 'number' },
-          tasks: { type: 'array', items: { type: 'object', additionalProperties: true } }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: `Total tasks: ${val.count}` }]
-    },
-    execute: async (args) => {
-      const tasks = store.list({ status: args.status || 'all' });
-      return {
-        count: tasks.length,
-        tasks: tasks.map(t => ({
-          id: t.id,
-          title: t.title,
-          schedule: t.scheduleText || t.schedule,
-          status: t.status,
-          nextRunAt: t.nextRunAt ? new Date(t.nextRunAt).toISOString() : null,
-          lastStatus: t.lastStatus,
-          totalTokens: t.totalTokens || 0,
-          totalCostUsd: t.totalCostUsd || 0,
-          oneShot: Boolean(t.oneShot),
-        }))
-      };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_pause_task',
-    description: 'Pause a task by its ID',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      // A config-owned task cannot be paused from here either: the next start
-      // would resume it, and the agent would have reported a change that never
-      // happened (#50 review finding).
-      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
-      const task = scheduler.pauseTask(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      return { success: true, message: `Task "${task.title}" paused` };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_resume_task',
-    description: 'Resume a paused task',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
-      const task = scheduler.resumeTask(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      return { success: true, message: `Task "${task.title}" resumed (${task.scheduleText})` };
-    }
-  }));
-
+  // 2. Tools: unified background automation runner (Issue #196: 9 tools -> 1)
   ctx.tools.register(defineTool({
-    name: 'cron_delete_task',
-    description: 'Delete a task by its ID',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      // Deleting a config-owned task would also drop its run history, and the
-      // task would come back at the next start without it.
-      if (isConfigOwned(store.get(args.id))) return { success: false, message: configOwnedMessage(args.id) };
-      scheduler.pauseTask(args.id);
-      const ok = store.delete(args.id);
-      return { success: ok, message: ok ? 'Task deleted' : 'Task not found' };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_get_task',
-    description: 'Read the full configuration of one scheduled task, including fields that are not visible in the task list',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' },
-          task: { type: 'object', additionalProperties: true }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      const task = store.get(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      const summary = [
-        `Task "${task.title}" (${task.id})`,
-        `type: ${task.type || 'llm'}`,
-        `schedule: ${task.scheduleText || task.schedule}`,
-        `status: ${task.status}`,
-        task.type === 'llm' || !task.type ? `model: ${task.model || '(default)'}${task.fallbackModel ? ` (fallback: ${task.fallbackModel})` : ''}` : null,
-        `channels: ${Array.isArray(task.channels) && task.channels.length ? task.channels.join(', ') : '(legacy flags)'}`,
-        `prompt: ${String(task.prompt || '').slice(0, 500)}`,
-      ].filter(Boolean).join(String.fromCharCode(10));
-      return { success: true, message: summary, task };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_update_task',
-    description: 'Change an existing scheduled task. Ask the user what to change first. Switching a task to a code-executing type (script/node/python/ssh/docker) is refused unless confirmCodeSwitch is set, which requires the user to have agreed explicitly. Only the documented task fields can be changed.',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true },
-      confirmCodeSwitch: { type: 'boolean', description: 'Set to true only after the user explicitly agreed to switch this task into a type that executes code' },
-      title: { type: 'string', description: 'New title' },
-      schedule: { type: 'string', description: 'New schedule (cron expression or interval)' },
-      prompt: { type: 'string', description: 'New prompt or command' },
-      type: { type: 'string', enum: TASK_TYPES, description: 'New execution type' },
-      model: { type: 'string', description: 'New model for agent tasks' },
-      fallbackModel: { type: 'string', description: 'New fallback model' },
-      provider: { type: 'string', description: 'New provider' },
-      channels: { type: 'array', items: { type: 'string', enum: CHANNEL_IDS }, description: 'New delivery channels' },
-      template: { type: 'string', description: 'New message template' },
-      onlyOnFailure: { type: 'boolean', description: 'Deliver only on failures' },
-      timeoutSeconds: { type: 'number', description: 'New execution timeout in seconds' },
-      overlapPolicy: { type: 'string', enum: ['skip', 'queue', 'replace'], description: 'New overlap policy' },
-      maxRetries: { type: 'number', description: 'New retry count' },
-      kanbanMode: { type: 'string', enum: ['none', 'on_failure', 'always'], description: 'New Kanban policy' },
-      timezone: { type: 'string', description: 'New IANA time zone' },
-      cwd: { type: 'string', description: 'New working directory' },
-      env: { type: 'object', additionalProperties: true, description: 'New environment variables (KEY: value)' }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      const { id, confirmCodeSwitch, ...patch } = args || {};
-      if (!id) return { success: false, message: 'A task id is required' };
-      const result = applyTaskPatch({ store, scheduler, id, body: patch, allowCodeSwitch: confirmCodeSwitch === true });
-      if (!result.ok) return { success: false, message: result.error };
-      return {
-        success: true,
-        message: `Task "${result.task.title}" updated (${result.task.scheduleText || result.task.schedule}). Changed: ${describeTaskPatch(result.task, result.patch)}`,
-      };
-    }
-  }));
-
-  ctx.tools.register(defineTool({
-    name: 'cron_run_task',
-    description: 'Trigger a task immediately, out of band',
-    parameters: {
-      id: { type: 'string', description: 'Task identifier', required: true }
-    },
-    output: {
-      schema: {
-        type: 'object',
-        additionalProperties: true,
-        properties: {
-          success: { type: 'boolean' },
-          message: { type: 'string' }
-        }
-      },
-      render: (_args, val) => [{ type: 'text', text: val.message }]
-    },
-    execute: async (args) => {
-      const task = store.get(args.id);
-      if (!task) return { success: false, message: 'Task not found' };
-      scheduler.triggerManualRun(args.id);
-      return { success: true, message: `Manual run started for task "${task.title}"` };
-    }
+    name: 'cron',
+    description: 'Background automation runner for DSH: isolated agent runs, script/node/python/http/ssh/docker runtimes, cost guard, notifications, heartbeats. For simple reminders in the current chat, use the built-in schedule_create tool instead. Actions: create, list, get, update, pause, resume, run, delete.',
+    parameters: cronToolParameters,
+    output: cronToolOutput,
+    execute: async (args) => executeCronTool(store, scheduler, args),
   }));
 }

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

@@ -12,9 +12,11 @@ The user's original request:
 "${text}"
 
 CRITICAL RULES FOR THE AGENT:
-1. NEVER RUSH:
-   It is STRICTLY FORBIDDEN to call the \`cron_create_task\` (or \`cron_schedule_task\`) tool in your first reply!
-   You MUST NOT create the task until you have asked clarifying questions and received the user's confirmation.
+1. EVALUATE SIMPLE IN-CHAT REMINDER VS BACKGROUND AUTOMATION:
+   - If the user simply wants a reminder or alert delivered into the current conversation (e.g. "remind me in 2 hours", "say good morning at 9am here"), suggest using the core built-in \`schedule_create\` tool instead.
+   - Use the \`cron\` tool for background automation running in separate isolated sessions, shell/python/node/http/ssh/docker runtimes, multi-channel alerts (Telegram, Discord, Slack, etc.), or monitoring.
+   - NEVER RUSH: It is STRICTLY FORBIDDEN to call the \`cron\` tool in your first reply!
+     You MUST NOT create the task until you have asked clarifying questions and received the user's confirmation.
 
 2. FIRST QUESTION: LLM vs NO-LLM Shell (critical):
    - Evaluate the nature of the task:
@@ -46,7 +48,8 @@ CRITICAL RULES FOR THE AGENT:
    - Ask any remaining questions and ask the user to confirm task creation.
 
 5. CREATING THE TASK:
-   Only AFTER the user replies and confirms the parameters, call the \`cron_create_task\` tool with:
+   Only AFTER the user replies and confirms the parameters, call the \`cron\` tool with:
+   - action: "create"
    - title: a clear task name
    - schedule: the agreed cron expression
    - prompt: the final shell command/script path (for type="script") OR detailed instructions including the Silent Rule (for type="llm")

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).