@goodandready/dsh-cron 0.2.46 → 0.2.48

package/lib/api.js

@@ -547,7 +547,7 @@ export async function handleExternalTaskRequest({ store, scheduler, req, res, ur
   }
 
   if (req.method === 'POST') {
-    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action, apiToken });
+    const handled = await handleItemPost({ store, scheduler, req, res, url, id, action });
     if (handled) return;
   }
   if (req.method === 'GET' && !action) {

package/lib/channels.js

@@ -153,14 +153,27 @@ export function buildGiteaIssuePayload({ task, runInfo, settings = {} }) {
   const failed = isFailed(runInfo.status);
   const defaultNames = failed ? ['cron', 'bug', 'alert'] : ['cron', 'auto'];
 
-  // Resolve labels to integer IDs per Gitea Swagger (array<int64>) (#224)
-  const mapping = settings.giteaLabelIds || {};
+  // Resolve labels to integer IDs per Gitea Swagger (array<int64>) (#224, #297)
+  let mapping = settings.giteaLabelIds || {};
+  if (typeof mapping === 'string' && mapping.trim().startsWith('{')) {
+    try {
+      mapping = JSON.parse(mapping);
+    } catch (_) {
+      mapping = {};
+    }
+  }
   let candidateIds = [];
 
   if (Array.isArray(task && task.giteaLabelIds)) {
     candidateIds = task.giteaLabelIds;
   } else if (Array.isArray(settings.giteaLabels)) {
     candidateIds = settings.giteaLabels;
+  } else if (typeof settings.giteaLabels === 'string' && settings.giteaLabels.trim()) {
+    candidateIds = settings.giteaLabels.split(',').map((s) => s.trim()).filter(Boolean).map((name) => {
+      const num = Number(name);
+      if (Number.isInteger(num) && num > 0) return num;
+      return typeof mapping === 'object' && mapping !== null ? mapping[name] : undefined;
+    });
   } else if (Array.isArray(settings.giteaLabelIds)) {
     candidateIds = settings.giteaLabelIds;
   } else if (Array.isArray(task && task.labels)) {

package/lib/config-jobs.js

@@ -17,6 +17,7 @@ import { parseScheduleExpression } from './scheduler.js';
 import { unknownChannelIds } from './channels.js';
 import { PATCHABLE_TASK_FIELDS, validateTaskType } from './task-transfer.js';
 import { pickPatchableFields } from './http-utils.js';
+import { logger } from './logger.js';
 
 /** Marker that makes a task owned by the config (#50). */
 export const MANAGED_BY_CONFIG = 'config';
@@ -171,7 +172,7 @@ export function planConfigSync(entries, existingTasks) {
  * Apply the plan: create, update and remove tasks, then arm or pause them.
  * Never throws for a single bad entry — that entry is reported and skipped.
  */
-export function applyConfigSync({ store, scheduler, entries, log = console }) {
+export function applyConfigSync({ store, scheduler, entries, log = logger }) {
   const plan = planConfigSync(entries, store.list({ status: 'all' }));
   for (const warning of plan.warnings) log.warn('[dsh-cron] config jobs: ' + warning);
   for (const entry of plan.skipped) log.error('[dsh-cron] config jobs: skipped: ' + entry.error);

package/lib/cron-tool.js

@@ -3,6 +3,7 @@ import { applyTaskPatch, describeTaskPatch } from './task-patch.js';
 import { isConfigOwned, configOwnedMessage } from './config-jobs.js';
 import { TASK_TYPES } from './runtimes.js';
 import { CHANNEL_IDS } from './channels.js';
+import { redactTaskSecrets } from './http-utils.js';
 
 export const LEGACY_TOOL_NAMES = [
   'cron_create_task',
@@ -394,7 +395,7 @@ export async function executeCronTool(store, scheduler, args = {}) {
         `channels: ${Array.isArray(task.channels) && task.channels.length ? task.channels.join(', ') : '(legacy flags)'}`,
         `prompt: ${String(task.prompt || '').slice(0, 500)}`,
       ].filter(Boolean).join('\n');
-      return { success: true, message: summary, task };
+      return { success: true, message: summary, task: redactTaskSecrets(task) };
     }
 
     case 'update': {
@@ -411,7 +412,7 @@ export async function executeCronTool(store, scheduler, args = {}) {
       return {
         success: true,
         message: `Task "${result.task.title}" updated (${result.task.scheduleText || result.task.schedule}). Changed: ${describeTaskPatch(result.task, result.patch)}`,
-        task: result.task,
+        task: redactTaskSecrets(result.task),
       };
     }
 

package/lib/http-utils.js

@@ -94,15 +94,17 @@ export function isTrustedRequest(req, options = {}) {
 
   const remote = req.socket?.remoteAddress || req.connection?.remoteAddress;
   const hasRemote = Boolean(remote && typeof remote === 'string');
-  const isLoopback = !hasRemote || isLoopbackAddress(remote);
+  const isLoopback = Boolean(hasRemote && isLoopbackAddress(remote));
 
   const token = extractBearerToken(req);
   const expectedToken = options.apiToken || process.env.DSH_AUTH_TOKEN || process.env.DSH_TOKEN;
   const isTokenAuthenticated = Boolean(expectedToken && token && token === expectedToken);
 
-  // 1. Non-loopback remote addresses require explicit token authentication (#86)
-  if (hasRemote && !isLoopback && !isTokenAuthenticated) {
-    return false;
+  // 1. Non-loopback socket callers (or callers with missing remoteAddress) require explicit token authentication (#86, #295)
+  if (req.socket || req.connection || hasRemote) {
+    if (!isLoopback && !isTokenAuthenticated) {
+      return false;
+    }
   }
 
   // 2. Validate Origin header if present: cannot be null, must match Host

package/lib/index.js

@@ -117,22 +117,20 @@ export {
   LEGACY_ACTION_MAP,
 };
 const pkgUrl = new URL('../package.json', import.meta.url);
-// Helper to access configuration safely in native Cordis Context without throwing missing-inject error (#235)
-function getContextConfig(ctx, rawConfig) {
+// Helper to access configuration safely in native Cordis Context without throwing missing-inject error (#235, #288)
+export function getContextConfig(ctx, rawConfig) {
   try {
     if (ctx && ctx.fiber && ctx.fiber.config) return ctx.fiber.config;
     if (ctx && ctx.scope && ctx.scope.config) return ctx.scope.config;
     if (ctx && ctx.runtime && ctx.runtime.config) return ctx.runtime.config;
-    if (ctx && typeof ctx === 'object' && 'config' in ctx) {
-      try {
-        const c = ctx.config;
-        if (c) return c;
-      } catch (err) {
-        // Ignore missing inject error on native Cordis Context (#235)
-      }
+    // In plain/mock contexts without fiber/scope, safely attempt reading config
+    try {
+      if (ctx && ctx.config) return ctx.config;
+    } catch (_) {
+      // Ignored if ctx is a Cordis proxy throwing without inject (#235, #288)
     }
   } catch (err) {
-    // Ignore context access error and fall back to rawConfig (#235)
+    // Ignore context access error and fall back to rawConfig (#235, #288)
   }
   return rawConfig || {};
 }
@@ -199,7 +197,7 @@ export function apply(ctx, rawConfig) {
   // A broken entry is reported and skipped, never fatal.
   try {
     const configJobs = Array.isArray(config && config.jobs) ? config.jobs : [];
-    const summary = applyConfigSync({ store, scheduler, entries: configJobs });
+    const summary = applyConfigSync({ store, scheduler, entries: configJobs, log: logger });
     logger.info('[dsh-cron] config jobs synced: ' + JSON.stringify(summary));
   } catch (err) {
     logger.error('[dsh-cron] config job sync failed:', err.message);
@@ -253,7 +251,7 @@ export function apply(ctx, rawConfig) {
       }
       const current = store.getSettings();
       const patch = {};
-      for (const k of ['maxConcurrent', 'defaultTimezone', 'heartbeatUrl', 'heartbeatIntervalSec', 'llmActionsEnabled']) {
+      for (const k of SETTINGS_SYNC_KEYS) {
         if (unwrapped[k] !== undefined && unwrapped[k] !== current[k]) {
           patch[k] = unwrapped[k];
         }
@@ -295,7 +293,6 @@ export function apply(ctx, rawConfig) {
   registerRoutes(ctx, {
     store,
     scheduler,
-    getCronSettingsScope: () => settingsService,
     recommendations,
   });
 
@@ -311,7 +308,7 @@ export function apply(ctx, rawConfig) {
             ...activeVolatileConfig,
           };
           const clientSettings = store.getClientSettings();
-          for (const k of ['maxConcurrent', 'defaultTimezone', 'heartbeatUrl', 'heartbeatIntervalSec', 'llmActionsEnabled']) {
+          for (const k of SETTINGS_SYNC_KEYS) {
             if (unwrapped[k] !== undefined) {
               clientSettings[k] = unwrapped[k];
             }

package/lib/routes.js

@@ -10,7 +10,7 @@ import { sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard } from './integrations.js';
 import { sanitizeSettingsPayload, applySettingsToScope } from './settings.js';
 
-export function registerRoutes(ctx, { store, scheduler, getCronSettingsScope, recommendations }) {
+export function registerRoutes(ctx, { store, scheduler, recommendations }) {
   // handler per route family; registered WITHOUT the trailing slash (#96)
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix',

package/lib/scheduler-execution.js

@@ -40,15 +40,17 @@ export async function executePreflight(task) {
   }
 
   if (type === 'http') {
+    let timeout;
     try {
       const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 5000);
+      timeout = setTimeout(() => controller.abort(), 5000);
       const res = await fetch(target, { signal: controller.signal });
-      clearTimeout(timeout);
       if (res.ok) return { ok: true };
       return { ok: false, reason: `HTTP check returned status ${res.status}` };
     } catch (err) {
       return { ok: false, reason: `HTTP check failed: ${err.message}` };
+    } finally {
+      if (timeout) clearTimeout(timeout);
     }
   }
 
@@ -595,7 +597,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   const guard = await checkAndApplyBurnGuard(scheduler, taskId, outcome);
   if (guard && guard.exceeded) return;
 
-  while (!scheduler.isStopped && scheduler.queue.length > 0 && (scheduler.maxConcurrent === 0 || scheduler.running.size < scheduler.maxConcurrent)) {
+  if (!scheduler.isStopped && scheduler.queue.length > 0 && (scheduler.maxConcurrent === 0 || scheduler.running.size < scheduler.maxConcurrent)) {
     let admittedIndex = -1;
     for (let i = 0; i < scheduler.queue.length; i++) {
       const candidate = scheduler.queue[i];
@@ -619,17 +621,16 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
       break;
     }
 
-    if (admittedIndex === -1) break;
-
-    const nextItem = scheduler.queue.splice(admittedIndex, 1)[0];
-    setImmediate(() => {
-      if (!scheduler.isStopped) {
-        scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
-          bestEffort('drain-queued-task', () => {}, scheduler.logger);
-        });
-      }
-    });
-    break;
+    if (admittedIndex !== -1) {
+      const nextItem = scheduler.queue.splice(admittedIndex, 1)[0];
+      setImmediate(() => {
+        if (!scheduler.isStopped) {
+          scheduler.runTask(nextItem.taskId, nextItem.options || {}).catch((runErr) => {
+            bestEffort('drain-queued-task', () => {}, scheduler.logger);
+          });
+        }
+      });
+    }
   }
 
   // 1. Structured LLM Actions (#137)

package/lib/scheduler.js

@@ -140,15 +140,17 @@ function parseIntervalExpression(str) {
     if (num >= 60) {
       if (num % 60 === 0) {
         const hours = num / 60;
-        if (hours >= 24 && hours % 24 === 0) {
-          const days = hours / 24;
-          if (days > 31) {
-            throw new Error(`Invalid interval: minute interval "${num}m" (${days} days) exceeds 31 days`);
+        if (hours >= 24) {
+          if (hours % 24 === 0) {
+            const days = hours / 24;
+            if (days > 31) {
+              throw new Error(`Invalid interval: minute interval "${num}m" (${days} days) exceeds 31 days`);
+            }
+            pattern = `0 0 */${days} * *`;
+            humanText = `Every ${days} days`;
+          } else {
+            throw new Error(`Invalid interval: minute interval "${num}m" (${hours} hours) cannot be expressed as a cron step`);
           }
-          pattern = `0 0 */${days} * *`;
-          humanText = `Every ${days} days`;
-        } else if (hours > 23) {
-          throw new Error(`Invalid interval: minute interval "${num}m" (${hours} hours) cannot be expressed as a cron step`);
         } else {
           pattern = `0 */${hours} * * *`;
           humanText = `Every ${hours} hours`;

package/lib/settings.js

@@ -44,6 +44,8 @@ export const Config = z.object({
   giteaBaseUrl: z.string().default('').description('Gitea base URL for alert issues').volatile(),
   giteaRepo: z.string().default('').description('Gitea repository (owner/name) for alert issues').volatile(),
   giteaTokenRef: z.string().default('').description('Credential name for the Gitea API token').volatile(),
+  giteaLabels: z.any().default([]).description('Gitea label names or IDs for alert issues').volatile(),
+  giteaLabelIds: z.any().default({}).description('Mapping of label name to integer ID for Gitea issues').volatile(),
   prReviewerEnabled: z.boolean().default(false).description('Enable automated PR Reviewer scheduled agent (#33)').volatile(),
   // --- Declarative jobs (#50, ADR-0001) ---
   jobs: z.array(z.any()).default([]).description('Static jobs owned by the config; each entry needs id, title, schedule and (for agent types) prompt'),
@@ -79,7 +81,7 @@ export const SETTINGS_SYNC_KEYS = [
   'pushplusTokenRef',
   'pushplusUrl',
   'ttsBaseUrl',
-  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'prReviewerEnabled',
+  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'giteaLabels', 'giteaLabelIds', 'prReviewerEnabled',
   'apiToken',
 ];
 

package/lib/store.js

@@ -1,6 +1,7 @@
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import fs from 'node:fs';
+import { pipeline } from 'node:stream/promises';
 import path from 'node:path';
 import { getDshDefaultTelegramCredentials } from './telegram.js';
 
@@ -168,15 +169,36 @@ export class TaskStore {
    * Asynchronously serialize and write tasks store to disk using fs.promises queue (#244).
    * Safe mode 0600 on files and 0700 on dir (#222).
    */
-  async saveAsync() {
-    const version = ++this._saveVersion;
-    const data = {
+  /**
+   * Create an isolated deep snapshot of tasks, history, and settings (#301).
+   * Prevents concurrent in-memory mutations (e.g. recordRun during streamed save)
+   * from corrupting serialized JSON state or causing duplicate / skipped run records.
+   */
+  _createSnapshot() {
+    const tasksSnapshot = Array.from(this.tasks.values()).map((t) => ({
+      ...t,
+      costLedger: Array.isArray(t.costLedger) ? t.costLedger.slice() : t.costLedger,
+    }));
+    const historySnapshot = {};
+    for (const [id, runs] of this.history.entries()) {
+      historySnapshot[id] = Array.isArray(runs) ? runs.slice() : runs;
+    }
+    return {
       version: 1,
       updatedAt: new Date().toISOString(),
-      tasks: Array.from(this.tasks.values()),
-      history: Object.fromEntries(this.history.entries()),
-      settings: this.settings || {},
+      tasks: tasksSnapshot,
+      history: historySnapshot,
+      settings: this.settings ? { ...this.settings } : {},
     };
+  }
+
+  /**
+   * Asynchronously serialize and write tasks store to disk using fs.promises queue (#244, #301, #303).
+   * Safe mode 0600 on files and 0700 on dir (#222).
+   */
+  async saveAsync() {
+    const version = ++this._saveVersion;
+    const data = this._createSnapshot();
 
     const writeOp = async () => {
       if ((this._diskVersion || 0) >= version || (this._lastSyncVersion || 0) >= version) {
@@ -244,116 +266,98 @@ export class TaskStore {
    * Stream data incrementally to disk with fine-grained setImmediate yields (#244).
    * Prevents blocking the V8 single thread on heavy serialization (e.g. 21MB / 10k runs).
    */
-  _writeStoreStream(filePath, data, version) {
-    return new Promise((resolve, reject) => {
-      let aborted = false;
-      const ws = fs.createWriteStream(filePath, { encoding: 'utf-8', mode: 0o600 });
-
-      const cleanupListeners = () => {
-        ws.removeAllListeners('error');
-        ws.removeAllListeners('drain');
-      };
-
-      ws.on('error', (err) => {
-        aborted = true;
-        cleanupListeners();
-        reject(err);
-      });
+  /**
+   * Stream data incrementally to disk with fine-grained setImmediate yields (#244, #303).
+   * Prevents blocking the V8 single thread on heavy serialization (e.g. 21MB / 10k runs).
+   * Uses canonical Node stream/promises pipeline for error-handling and backpressure hygiene (#303).
+   */
+  async _writeStoreStream(filePath, data, version) {
+    const isCanceled = () => {
+      return (
+        (this._diskVersion || 0) >= version ||
+        (this._lastSyncVersion || 0) >= version ||
+        this._saveVersion > version
+      );
+    };
+
+    if (isCanceled()) {
+      return;
+    }
+
+    const ac = new AbortController();
+    let ws;
+    try {
+      ws = fs.createWriteStream(filePath, { encoding: 'utf-8', mode: 0o600 });
+    } catch (createErr) {
+      if (isCanceled()) return;
+      throw createErr;
+    }
+
+    async function* generateChunks() {
+      await new Promise((r) => setImmediate(r));
+      if (isCanceled()) {
+        ac.abort();
+        return;
+      }
+
+      yield '{"version":' + JSON.stringify(data.version || 1);
+      yield ',"updatedAt":' + JSON.stringify(data.updatedAt || new Date().toISOString());
+      yield ',"settings":' + JSON.stringify(data.settings || {});
 
-      const isCanceled = () => {
-        if ((this._diskVersion || 0) >= version || (this._lastSyncVersion || 0) >= version || this._saveVersion > version) {
-          aborted = true;
-          cleanupListeners();
-          ws.destroy();
-          return true;
+      yield ',"tasks":[';
+      const tasks = data.tasks || [];
+      for (let i = 0; i < tasks.length; i++) {
+        if (isCanceled()) {
+          ac.abort();
+          return;
         }
-        return false;
-      };
-
-      const writeChunk = (chunk) => {
-        if (aborted) return Promise.reject(new Error('Store write aborted'));
-        if (!ws.write(chunk)) {
-          return new Promise((res, rej) => {
-            const onDrain = () => {
-              ws.removeListener('drain', onDrain);
-              ws.removeListener('error', onError);
-              res();
-            };
-            const onError = (e) => {
-              ws.removeListener('drain', onDrain);
-              ws.removeListener('error', onError);
-              rej(e);
-            };
-            ws.once('drain', onDrain);
-            ws.once('error', onError);
-          });
+        if (i > 0) yield ',';
+        yield JSON.stringify(tasks[i]);
+        if ((i + 1) % 10 === 0) {
+          await new Promise((r) => setImmediate(r));
         }
-        return Promise.resolve();
-      };
+      }
+      yield ']';
 
-      const run = async () => {
-        try {
-          await new Promise((r) => setImmediate(r));
-          if (isCanceled()) return resolve();
-
-          await writeChunk('{"version":' + JSON.stringify(data.version || 1));
-          await writeChunk(',"updatedAt":' + JSON.stringify(data.updatedAt || new Date().toISOString()));
-          await writeChunk(',"settings":' + JSON.stringify(data.settings || {}));
-
-          await writeChunk(',"tasks":[');
-          const tasks = data.tasks || [];
-          for (let i = 0; i < tasks.length; i++) {
-            if (isCanceled()) return resolve();
-            if (i > 0) await writeChunk(',');
-            await writeChunk(JSON.stringify(tasks[i]));
-            if ((i + 1) % 10 === 0) {
-              await new Promise((r) => setImmediate(r));
+      yield ',"history":{';
+      const historyEntries = Object.entries(data.history || {});
+      for (let i = 0; i < historyEntries.length; i++) {
+        if (isCanceled()) {
+          ac.abort();
+          return;
+        }
+        if (i > 0) yield ',';
+        const [taskId, runs] = historyEntries[i];
+        yield JSON.stringify(taskId) + ':[';
+        if (Array.isArray(runs)) {
+          for (let j = 0; j < runs.length; j++) {
+            if (isCanceled()) {
+              ac.abort();
+              return;
             }
-          }
-          await writeChunk(']');
-
-          await writeChunk(',"history":{');
-          const historyEntries = Object.entries(data.history || {});
-          for (let i = 0; i < historyEntries.length; i++) {
-            if (isCanceled()) return resolve();
-            if (i > 0) await writeChunk(',');
-            const [taskId, runs] = historyEntries[i];
-            await writeChunk(JSON.stringify(taskId) + ':[');
-            if (Array.isArray(runs)) {
-              for (let j = 0; j < runs.length; j++) {
-                if (isCanceled()) return resolve();
-                if (j > 0) await writeChunk(',');
-                await writeChunk(JSON.stringify(runs[j]));
-                if ((j + 1) % 15 === 0) {
-                  await new Promise((r) => setImmediate(r));
-                }
-              }
-            } else {
-              await writeChunk(JSON.stringify(runs));
+            if (j > 0) yield ',';
+            yield JSON.stringify(runs[j]);
+            if ((j + 1) % 15 === 0) {
+              await new Promise((r) => setImmediate(r));
             }
-            await writeChunk(']');
-            await new Promise((r) => setImmediate(r));
-          }
-          await writeChunk('}}');
-
-          if (isCanceled()) return resolve();
-
-          ws.end(() => {
-            cleanupListeners();
-            resolve();
-          });
-        } catch (err) {
-          if (!aborted) {
-            aborted = true;
-            cleanupListeners();
-            ws.destroy();
-            reject(err);
           }
+        } else {
+          yield JSON.stringify(runs);
         }
-      };
+        yield ']';
+        await new Promise((r) => setImmediate(r));
+      }
+      yield '}}';
+    }
 
-      run();
-    });
+    try {
+      await pipeline(generateChunks(), ws, { signal: ac.signal });
+    } catch (err) {
+      if (ac.signal.aborted || isCanceled()) {
+        return;
+      }
+      throw err;
+    }
   }
 
   save() {
@@ -376,13 +380,7 @@ export class TaskStore {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
       }
       bestEffort('chmod-dir', () => fs.chmodSync(dir, 0o700));
-      const data = {
-        version: 1,
-        updatedAt: new Date().toISOString(),
-        tasks: Array.from(this.tasks.values()),
-        history: Object.fromEntries(this.history.entries()),
-        settings: this.settings || {},
-      };
+      const data = this._createSnapshot();
       // Unique tmp file per save call with process PID and random token to eliminate file collision
       const rand = Math.random().toString(36).slice(2, 8);
       const tmp = `${this.filePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
@@ -670,42 +668,46 @@ export class TaskStore {
     task.updatedAt = Date.now();
 
     // Rolling 24h cost ledger preserved across archive rotation and restarts (#221)
-    if (!Array.isArray(task.costLedger)) {
-      task.costLedger = [];
-    }
-    task.costLedger.push({
-      at: task.lastRunAt,
-      costUsd,
-      tokens: runTokens,
-    });
+    const existingLedger = Array.isArray(task.costLedger) ? task.costLedger : [];
     const cutoff24h = Date.now() - 86400000;
-    task.costLedger = task.costLedger.filter(e => e && typeof e.at === 'number' && e.at >= cutoff24h);
-
-    const runs = this.history.get(id) || [];
-    runs.unshift({
-      id: 'run_' + Math.random().toString(36).slice(2, 9),
-      at: task.lastRunAt,
-      status: task.lastStatus,
-      durationMs: task.lastDurationMs,
-      output: (runInfo.output || '').slice(0, 4000),
-      error: runInfo.error ? String(runInfo.error).slice(0, 1000) : null,
-      usage,
-      costUsd,
-      sessionId: runInfo.sessionId || null,
-      // #45: which model produced the run, and whether it only finished thanks
-      // to the configured fallback.
-      model: runInfo.model || '',
-      fallback: Boolean(runInfo.fallback),
-      // #44: this run was suppressed by its silent rule, with the reason.
-      silentSkip: Boolean(runInfo.silentSkip),
-      silentReason: runInfo.silentSkip ? String(runInfo.silentReason || '').slice(0, 500) : '',
-      // #43: the failure diagnosis and the prompt change it proposes.
-      diagnosis: runInfo.diagnosis ? String(runInfo.diagnosis).slice(0, 1000) : '',
-      suggestion: runInfo.suggestion ? String(runInfo.suggestion).slice(0, 2000) : '',
-      selfHealing: runInfo.selfHealing || null,
-      autoDiagnosis: runInfo.autoDiagnosis ? String(runInfo.autoDiagnosis).slice(0, 1000) : '',
-      confidence: runInfo.confidence || '',
-    });
+    task.costLedger = [
+      ...existingLedger.filter(e => e && typeof e.at === 'number' && e.at >= cutoff24h),
+      {
+        at: task.lastRunAt,
+        costUsd,
+        tokens: runTokens,
+      },
+    ];
+
+    // Immutable copy-on-write history update (#301)
+    const prevRuns = this.history.get(id) || [];
+    const runs = [
+      {
+        id: 'run_' + Math.random().toString(36).slice(2, 9),
+        at: task.lastRunAt,
+        status: task.lastStatus,
+        durationMs: task.lastDurationMs,
+        output: (runInfo.output || '').slice(0, 4000),
+        error: runInfo.error ? String(runInfo.error).slice(0, 1000) : null,
+        usage,
+        costUsd,
+        sessionId: runInfo.sessionId || null,
+        // #45: which model produced the run, and whether it only finished thanks
+        // to the configured fallback.
+        model: runInfo.model || '',
+        fallback: Boolean(runInfo.fallback),
+        // #44: this run was suppressed by its silent rule, with the reason.
+        silentSkip: Boolean(runInfo.silentSkip),
+        silentReason: runInfo.silentSkip ? String(runInfo.silentReason || '').slice(0, 500) : '',
+        // #43: the failure diagnosis and the prompt change it proposes.
+        diagnosis: runInfo.diagnosis ? String(runInfo.diagnosis).slice(0, 1000) : '',
+        suggestion: runInfo.suggestion ? String(runInfo.suggestion).slice(0, 2000) : '',
+        selfHealing: runInfo.selfHealing || null,
+        autoDiagnosis: runInfo.autoDiagnosis ? String(runInfo.autoDiagnosis).slice(0, 1000) : '',
+        confidence: runInfo.confidence || '',
+      },
+      ...prevRuns,
+    ];
     // Keep up to 100 runs in active store; archive older runs to tasks-history-archive.json (#134)
     if (runs.length > 100) {
       const overflow = runs.splice(100);

package/lib/task-create.js

@@ -2,6 +2,7 @@ import { normalizeTaskType } from './runtimes.js';
 import { validateTaskType } from './task-transfer.js';
 import { parseScheduleExpression } from './scheduler.js';
 import { CHANNEL_IDS } from './channels.js';
+import { redactTaskSecrets } from './http-utils.js';
 
 export function executeCreateTask(store, scheduler, args) {
   const taskType = normalizeTaskType(args.type);
@@ -76,7 +77,7 @@ export function executeCreateTask(store, scheduler, args) {
   return {
     success: true,
     message: `Task "${task.title}" scheduled successfully (${task.scheduleText})`,
-    task
+    task: redactTaskSecrets(task),
   };
 }
 

package/lib/task-patch.js

@@ -22,23 +22,27 @@ export function isCodeTypeSwitch(current, nextType) {
   return CODE_EXECUTING_TYPES.includes(target) && !CODE_EXECUTING_TYPES.includes(current.type);
 }
 
-/** True when a patch introduces code-executing type or shell hooks (#212). */
+/** True when a patch introduces code-executing type or shell hooks (#212, #296). */
 export function isCodeExecutionIntroduced(current, body) {
   if (!current || !body) return false;
   if (body.type !== undefined && isCodeTypeSwitch(current, body.type)) return true;
 
-  const hadPreflight = Boolean(current.preflightCommand && String(current.preflightCommand).trim()) || current.preflightType === 'command' || current.preflightType === 'shell';
-  const hasPreflight = Boolean(body.preflightCommand && String(body.preflightCommand).trim()) || body.preflightType === 'command' || body.preflightType === 'shell';
+  const isShellPreflight = (t) => t === 'command' || t === 'shell';
+  const currentPreflightType = current.preflightType || 'none';
+  const nextPreflightType = body.preflightType !== undefined ? body.preflightType : currentPreflightType;
+
+  const currentPreflightTarget = current.preflightTarget || current.preflightCommand || '';
+  const bodyPreflightTarget = body.preflightTarget !== undefined ? body.preflightTarget : (body.preflightCommand !== undefined ? body.preflightCommand : '');
+  const nextPreflightTarget = (body.preflightTarget !== undefined || body.preflightCommand !== undefined) ? bodyPreflightTarget : currentPreflightTarget;
+
+  const hadPreflight = isShellPreflight(currentPreflightType) && Boolean(String(currentPreflightTarget).trim());
+  const hasPreflight = isShellPreflight(nextPreflightType) && Boolean(String(nextPreflightTarget).trim());
   if (hasPreflight && !hadPreflight) return true;
 
   const hadSelfHealing = Boolean(current.selfHealingCommand && String(current.selfHealingCommand).trim());
   const hasSelfHealing = Boolean(body.selfHealingCommand && String(body.selfHealingCommand).trim());
   if (hasSelfHealing && !hadSelfHealing) return true;
 
-  const hadCommand = Boolean(current.command && String(current.command).trim());
-  const hasCommand = Boolean(body.command && String(body.command).trim());
-  if (hasCommand && !hadCommand && !CODE_EXECUTING_TYPES.includes(current.type)) return true;
-
   return false;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.46",
+  "version": "0.2.48",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",