@goodandready/dsh-cron 0.3.4 → 0.3.5

package/lib/api.js

@@ -1,3 +1,4 @@
+import { calculate24hTimeline } from './timeline.js';
 import { rollbackPromptVersion, sanitizePromptHistory } from './prompt-evolver.js';
 import { sanitizeAdaptiveConfig } from './adaptive.js';
 import { logStreamer } from './log-streamer.js';
@@ -91,6 +92,10 @@ export function createCronApiHandler(store, scheduler, collection) {
         await handleSchedulePreview({ req, res, url, store });
         return;
       }
+      if (scope === 'schedule' && id === 'timeline-24h') {
+        await handleScheduleTimeline({ req, res, url, store, scheduler });
+        return;
+      }
 
       if (!id) {
         await handleTaskCollection({ store, scheduler, collection, req, res, url, scope, apiToken });

package/lib/client.js

@@ -285,6 +285,12 @@ en: {
 'form.adaptiveEnabled': 'Adaptive Polling', 'form.adaptiveHint': 'Exponential backoff when no changes are detected',
 'liveLog.modalTitle': 'Real-Time Streaming Execution Logs', 'liveLog.viewLog': 'Live Stream',
 'liveLog.autoScroll': 'Auto-scroll', 'liveLog.connecting': 'Connecting to log stream...', 'liveLog.waiting': 'Waiting for runner output...', 'liveLog.completed': 'Execution stream completed', 'liveLog.close': 'Close Stream',
+'timeline.modalTitle': '24-Hour Schedule Timeline', 'timeline.buttonLabel': 'Timeline',
+'timeline.buttonTitle': 'View 24-hour projected schedule and concurrency timeline',
+'timeline.tabTimeline': 'Schedule Timeline', 'timeline.legendDesc': 'Projected run distribution across 24 hourly buckets:',
+'timeline.peakWarning': 'Peak concurrency warning',
+'heatmap.modalTitle': 'Cost & Token Burn Heatmap', 'heatmap.buttonLabel': 'Heatmap',
+'heatmap.tabHeatmap': 'Cost Heatmap', 'heatmap.matrixDesc': 'Weekly hour-of-day cost concentration (7 days × 24 hours):',
 'digest.modalTitle': 'Automation & Cost Digest', 'digest.buttonLabel': 'Digest',
 'digest.buttonTitle': 'View 7-day or 30-day automation analytics and cost digest',
 'digest.period7': 'Last 7 Days', 'digest.period30': 'Last 30 Days',
@@ -461,6 +467,12 @@ zh: {
 'form.adaptiveEnabled': '自适应轮询 (Adaptive Polling)', 'form.adaptiveHint': '数据无变化时指数级延长执行间隔',
 'liveLog.modalTitle': '实时任务执行日志流', 'liveLog.viewLog': '实时日志',
 'liveLog.autoScroll': '自动滚动', 'liveLog.connecting': '正在连接日志流...', 'liveLog.waiting': '等待运行器输出...', 'liveLog.completed': '日志流已结束', 'liveLog.close': '关闭日志流',
+'timeline.modalTitle': '24小时调度时间线', 'timeline.buttonLabel': '时间线',
+'timeline.buttonTitle': '查看24小时预测任务调度与并发时间线',
+'timeline.tabTimeline': '调度时间线', 'timeline.legendDesc': '未来24小时各时段任务预计执行分布：',
+'timeline.peakWarning': '并发峰值预警',
+'heatmap.modalTitle': '成本与Token消耗热力图', 'heatmap.buttonLabel': '热力图',
+'heatmap.tabHeatmap': '成本热力图', 'heatmap.matrixDesc': '每周各时段成本分布矩阵（7天 × 24小时）：',
 'digest.modalTitle': '自动化与成本分析摘要', 'digest.buttonLabel': '分析摘要',
 'digest.buttonTitle': '查看 7 天或 30 天运行统计与花费摘要',
 'digest.period7': '最近 7 天', 'digest.period30': '最近 30 天',
@@ -1481,6 +1493,191 @@ style: { padding: '6px 14px', fontSize: '12px' }
 )
 );
 }
+function renderTimelineHeatmapModal({
+isOpen,
+onClose,
+activeTab,
+onSelectTab,
+timelineData,
+heatmapData,
+isLoading,
+t
+}) {
+if (!isOpen) return null;
+const tab = activeTab || 'timeline';
+const timeline = timelineData || { buckets: [], totalRuns: 0, peakHoursCount: 0, maxConcurrent: 3 };
+const heatmap = heatmapData || { matrix: [], dayLabels: [], hourLabels: [], totalCostUsd: 0, totalTokens: 0, maxCostHour: 0 };
+return React.createElement('div', {
+className: 'dsh-cron-modal-overlay',
+onClick: onClose
+},
+React.createElement('div', {
+className: 'dsh-cron-modal',
+style: { maxWidth: '960px', width: '94vw', maxHeight: '88vh', display: 'flex', flexDirection: 'column', background: 'var(--dsw-alias-bg-base, #111)', color: 'var(--dsw-alias-label-primary, #ddd)', border: '1px solid var(--dsw-alias-border-l2, #333)', borderRadius: '8px' },
+role: 'dialog',
+'aria-modal': 'true',
+onClick: (e) => e.stopPropagation()
+},
+React.createElement('div', {
+style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '14px 18px', borderBottom: '1px solid var(--dsw-alias-border-l2, #333)', background: 'var(--dsw-alias-bg-layer-2, #111)' }
+},
+React.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '10px' } },
+React.createElement('span', { style: { fontSize: '20px' } }, tab === 'timeline' ? '⏱' : '🔥'),
+React.createElement('div', null,
+React.createElement('div', { style: { fontWeight: '600', fontSize: '15px', color: 'var(--dsw-alias-label-primary, #fff)' } },
+tab === 'timeline' ? (T_KEY(t, 'timeline.modalTitle') || '24-Hour Schedule Timeline') : (T_KEY(t, 'heatmap.modalTitle') || 'Cost & Token Burn Heatmap')
+),
+React.createElement('div', { style: { fontSize: '11.5px', color: 'var(--dsw-alias-label-secondary, #888)', marginTop: '2px' } },
+tab === 'timeline'
+? (timeline.totalRuns + ' runs projected · ' + (timeline.peakHoursCount ? '⚠️ ' + timeline.peakHoursCount + ' peak hours' : '✓ balanced concurrency'))
+: ('$' + Number(heatmap.totalCostUsd || 0).toFixed(4) + ' USD · ' + Number(heatmap.totalTokens || 0).toLocaleString() + ' tokens')
+)
+)
+),
+React.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '8px' } },
+React.createElement('button', {
+type: 'button',
+className: 'dsh-cron-btn-secondary',
+style: { padding: '4px 12px', fontSize: '12px', fontWeight: tab === 'timeline' ? '600' : '400', background: tab === 'timeline' ? 'var(--dsw-alias-bg-layer-3, #222)' : 'transparent' },
+onClick: () => onSelectTab && onSelectTab('timeline')
+}, '⏱ ' + (T_KEY(t, 'timeline.tabTimeline') || 'Timeline')),
+React.createElement('button', {
+type: 'button',
+className: 'dsh-cron-btn-secondary',
+style: { padding: '4px 12px', fontSize: '12px', fontWeight: tab === 'heatmap' ? '600' : '400', background: tab === 'heatmap' ? 'var(--dsw-alias-bg-layer-3, #222)' : 'transparent' },
+onClick: () => onSelectTab && onSelectTab('heatmap')
+}, '🔥 ' + (T_KEY(t, 'heatmap.tabHeatmap') || 'Heatmap')),
+React.createElement('button', {
+type: 'button',
+className: 'dsh-cron-icon-btn',
+onClick: onClose,
+style: { marginLeft: '8px' }
+}, React.createElement('span', null, '✕'))
+)
+),
+React.createElement('div', {
+style: { padding: '16px 18px', overflowY: 'auto', flex: 1, display: 'flex', flexDirection: 'column', gap: '14px' }
+},
+isLoading ? React.createElement('div', { style: { padding: '40px', textAlign: 'center', color: 'var(--dsw-alias-label-secondary, #888)' } }, 'Loading visualization data...') : (
+tab === 'timeline' ? (
+React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: '8px' } },
+React.createElement('div', { style: { fontSize: '12px', color: 'var(--dsw-alias-label-secondary, #888)', display: 'flex', justifyContent: 'space-between' } },
+React.createElement('span', null, T_KEY(t, 'timeline.legendDesc') || 'Projected run distribution across 24 hourly buckets:'),
+React.createElement('span', { style: { color: 'var(--dsh-cron-warning, #fa0)' } }, '⚠️ ' + (T_KEY(t, 'timeline.peakWarning') || 'Peak hours exceed max concurrent limit') + ' (' + timeline.maxConcurrent + ')')
+),
+React.createElement('div', {
+style: { display: 'grid', gridTemplateColumns: 'repeat(12, 1fr)', gap: '8px', marginTop: '6px' }
+},
+(timeline.buckets || []).map((b) => {
+const isPeak = b.isPeak;
+const hasRuns = b.count > 0;
+return React.createElement('div', {
+key: b.index,
+style: {
+background: isPeak
+? 'color-mix(in srgb, var(--dsh-cron-danger, #e33) 12%, var(--dsw-alias-bg-layer-2, #111))'
+: (hasRuns ? 'var(--dsw-alias-bg-layer-2, #111)' : 'var(--dsw-alias-bg-base, #111)'),
+border: isPeak
+? '1px solid var(--dsh-cron-danger, #e33)'
+: (hasRuns ? '1px solid var(--dsw-alias-border-l2, #333)' : '1px dashed var(--dsw-alias-border-l2, #222)'),
+borderRadius: '6px',
+padding: '8px',
+minHeight: '75px',
+display: 'flex',
+flexDirection: 'column',
+justifyContent: 'space-between'
+}
+},
+React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', fontSize: '11px' } },
+React.createElement('span', { style: { fontWeight: '600', color: isPeak ? 'var(--dsh-cron-danger, #e33)' : 'var(--dsw-alias-label-primary, #fff)' } }, b.label),
+hasRuns ? React.createElement('span', {
+style: { fontSize: '10px', padding: '1px 5px', borderRadius: '8px', background: isPeak ? 'var(--dsh-cron-danger, #e33)' : 'var(--dsw-alias-bg-layer-3, #222)', color: '#fff' }
+}, b.count) : null
+),
+React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: '3px', marginTop: '6px' } },
+(b.runs || []).slice(0, 3).map((r, rIdx) => React.createElement('div', {
+key: rIdx,
+title: r.title + ' (at ' + new Date(r.runAt).toLocaleTimeString() + ')',
+style: {
+fontSize: '10px',
+padding: '2px 4px',
+borderRadius: '3px',
+background: 'var(--dsw-alias-bg-layer-3, #222)',
+color: 'var(--dsw-alias-label-primary, #ddd)',
+overflow: 'hidden',
+textOverflow: 'ellipsis',
+whiteSpace: 'nowrap'
+}
+}, r.title)),
+b.count > 3 ? React.createElement('div', { style: { fontSize: '9px', color: 'var(--dsw-alias-label-secondary, #888)' } }, '+' + (b.count - 3) + ' more') : null
+)
+);
+})
+)
+)
+) : (
+React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: '10px' } },
+React.createElement('div', { style: { fontSize: '12px', color: 'var(--dsw-alias-label-secondary, #888)', display: 'flex', justifyContent: 'space-between' } },
+React.createElement('span', null, T_KEY(t, 'heatmap.matrixDesc') || 'Weekly hour-of-day cost concentration (7 days × 24 hours):'),
+React.createElement('span', null, 'Max hour spend: $' + Number(heatmap.maxCostHour || 0).toFixed(4))
+),
+React.createElement('div', {
+style: { overflowX: 'auto', paddingBottom: '8px' }
+},
+React.createElement('table', {
+style: { borderCollapse: 'collapse', width: '100%', minWidth: '700px', fontSize: '10.5px' }
+},
+React.createElement('thead', null,
+React.createElement('tr', null,
+React.createElement('th', { style: { padding: '4px 6px', textAlign: 'left', color: 'var(--dsw-alias-label-secondary, #888)' } }, 'Day'),
+Array.from({ length: 24 }, (_, h) => React.createElement('th', {
+key: h,
+style: { padding: '4px 2px', textAlign: 'center', color: 'var(--dsw-alias-label-secondary, #888)', fontWeight: '400' }
+}, String(h).padStart(2, '0')))
+)
+),
+React.createElement('tbody', null,
+(heatmap.matrix || []).map((row, dIdx) => React.createElement('tr', { key: dIdx },
+React.createElement('td', { style: { padding: '4px 6px', fontWeight: '600', color: 'var(--dsw-alias-label-primary, #ddd)' } }, (heatmap.dayLabels && heatmap.dayLabels[dIdx]) || 'Day'),
+row.map((cell, hIdx) => {
+const intensity = cell.costIntensity || 0;
+const hasSpend = cell.costUsd > 0;
+const bg = hasSpend
+? 'color-mix(in srgb, var(--dsh-cron-primary, #4af) ' + Math.max(15, Math.round(intensity * 100)) + '%, transparent)'
+: 'transparent';
+return React.createElement('td', {
+key: hIdx,
+title: cell.dayLabel + ' ' + cell.hourLabel + ': $' + cell.costUsd + ' (' + cell.tokens.toLocaleString() + ' tokens, ' + cell.runs + ' runs)',
+style: {
+padding: '3px',
+textAlign: 'center',
+background: bg,
+border: '1px solid var(--dsw-alias-border-l2, #222)',
+cursor: hasSpend ? 'pointer' : 'default'
+}
+}, hasSpend ? React.createElement('span', { style: { fontSize: '9px', color: intensity > 0.5 ? '#fff' : 'var(--dsw-alias-label-primary, #ddd)' } }, '$' + (cell.costUsd >= 0.01 ? cell.costUsd.toFixed(2) : cell.costUsd.toFixed(3).slice(1))) : '·');
+})
+))
+)
+)
+)
+)
+)
+)
+),
+React.createElement('div', {
+style: { display: 'flex', justifyContent: 'flex-end', padding: '12px 18px', borderTop: '1px solid var(--dsw-alias-border-l2, #333)', background: 'var(--dsw-alias-bg-layer-2, #111)' }
+},
+React.createElement('button', {
+type: 'button',
+className: 'dsh-cron-btn-secondary',
+onClick: onClose,
+style: { padding: '6px 16px', fontSize: '12px' }
+}, T_KEY(t, 'chainGraph.close') || 'Close')
+)
+)
+);
+}
 function CronScreen(props) {
 const { ctx, toggle, onClose } = props;
 const t = props.t || translate;
@@ -2711,6 +2908,16 @@ React.createElement('button', {
 type: 'button',
 className: 'dsh-cron-btn-secondary',
 style: { display: 'flex', alignItems: 'center', gap: '6px', height: '36px', padding: '0 12px' },
+title: T_KEY(t, 'timeline.buttonTitle'),
+onClick: () => openTimelineModal('timeline')
+},
+React.createElement('span', { style: { fontSize: '14px' } }, '⏱'),
+T_KEY(t, 'timeline.buttonLabel')
+),
+React.createElement('button', {
+type: 'button',
+className: 'dsh-cron-btn-secondary',
+style: { display: 'flex', alignItems: 'center', gap: '6px', height: '36px', padding: '0 12px' },
 title: T_KEY(t, 'digest.buttonTitle'),
 onClick: openAnalyticsDigest
 },

package/lib/routes.js

@@ -1,3 +1,4 @@
+import { calculateCostHeatmap } from './timeline.js';
 import { buildAnalyticsDigest, formatDigestMarkdown, sendAnalyticsDigest } from './analytics-digest.js';
 import { listVerifiedRecipes } from './recipes-catalog.js';
 import { randomUUID } from 'node:crypto';
@@ -111,6 +112,26 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
         const path = url.pathname;
 
         if (req.method === 'GET') {
+          if (path === '/dsh-cron/analytics/heatmap') {
+            const modelFilter = url.searchParams.get('model') || null;
+            const providerFilter = url.searchParams.get('provider') || null;
+            const costLedger = store.costLedger || [];
+            let history = [];
+            if (store.history) {
+              if (typeof store.history.values === 'function') {
+                for (const runs of store.history.values()) {
+                  if (Array.isArray(runs)) history.push(...runs);
+                }
+              } else if (typeof store.history === 'object') {
+                for (const runs of Object.values(store.history)) {
+                  if (Array.isArray(runs)) history.push(...runs);
+                }
+              }
+            }
+            const heatmap = calculateCostHeatmap({ costLedger, history, modelFilter, providerFilter });
+            sendJson(res, 200, { ok: true, heatmap });
+            return;
+          }
           const days = parseInt(url.searchParams.get('days') || '7', 10);
           const tasks = store.list ? store.list() : Object.values(store.tasks || {});
           let history = [];

package/lib/timeline.js

@@ -0,0 +1,230 @@
+/**
+ * Visual Schedule Timeline & Cost Heatmap Engine (#332, #333)
+ *
+ * 1. 24-hour schedule projection with collision and peak concurrency detection.
+ * 2. 7x24 weekly hour-of-day cost and token burn heatmap matrix.
+ */
+
+import { Cron } from 'croner';
+
+const DAY_LABELS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+
+export function calculate24hTimeline({
+  tasks = [],
+  maxConcurrent = 3,
+  fromTimestamp = Date.now(),
+  hoursCount = 24,
+}) {
+  const limit = Math.max(1, Number(maxConcurrent) || 3);
+  const activeTasks = (Array.isArray(tasks) ? tasks : Object.values(tasks || {})).filter(
+    (t) => t && t.status === 'active'
+  );
+
+  const startMs = typeof fromTimestamp === 'number' ? fromTimestamp : Date.now();
+  const endMs = startMs + hoursCount * 3600000;
+
+  const buckets = Array.from({ length: hoursCount }, (_, i) => {
+    const bucketStart = startMs + i * 3600000;
+    const d = new Date(bucketStart);
+    const hourPad = String(d.getHours()).padStart(2, '0');
+    return {
+      index: i,
+      label: `${hourPad}:00`,
+      startMs: bucketStart,
+      endMs: bucketStart + 3600000,
+      runs: [],
+      count: 0,
+      isPeak: false,
+    };
+  });
+
+  let totalRuns = 0;
+
+  for (const task of activeTasks) {
+    if (task.oneShot) {
+      const runAt = Number(task.nextRunAt || task.targetTimestamp);
+      if (runAt >= startMs && runAt < endMs) {
+        const bIdx = Math.floor((runAt - startMs) / 3600000);
+        if (bIdx >= 0 && bIdx < hoursCount) {
+          buckets[bIdx].runs.push({
+            taskId: task.id,
+            title: task.title || task.id,
+            runAt,
+            durationEstMs: task.avgDuration || 2000,
+            type: task.type || 'llm',
+          });
+          totalRuns += 1;
+        }
+      }
+      continue;
+    }
+
+    if (task.schedule) {
+      try {
+        const c = new Cron(task.schedule, { timezone: task.timezone });
+        let cursor = new Date(startMs - 1);
+        // Bound to max 96 occurrences per task in 24h window
+        for (let step = 0; step < 96; step++) {
+          const nextDate = c.nextRun(cursor);
+          if (!nextDate) break;
+          const runMs = nextDate.getTime();
+          if (runMs >= endMs) break;
+
+          const bIdx = Math.floor((runMs - startMs) / 3600000);
+          if (bIdx >= 0 && bIdx < hoursCount) {
+            buckets[bIdx].runs.push({
+              taskId: task.id,
+              title: task.title || task.id,
+              runAt: runMs,
+              durationEstMs: task.avgDuration || 2000,
+              type: task.type || 'llm',
+            });
+            totalRuns += 1;
+          }
+          cursor = new Date(runMs + 1000);
+        }
+      } catch (err) {
+        // Fallback for custom or invalid cron schedules
+        const runAt = Number(task.nextRunAt);
+        if (runAt >= startMs && runAt < endMs) {
+          const bIdx = Math.floor((runAt - startMs) / 3600000);
+          if (bIdx >= 0 && bIdx < hoursCount) {
+            buckets[bIdx].runs.push({
+              taskId: task.id,
+              title: task.title || task.id,
+              runAt,
+              durationEstMs: task.avgDuration || 2000,
+              type: task.type || 'llm',
+            });
+            totalRuns += 1;
+          }
+        }
+      }
+    }
+  }
+
+  const peakHours = [];
+
+  for (const b of buckets) {
+    b.count = b.runs.length;
+    b.isPeak = b.count > limit;
+    if (b.isPeak) {
+      peakHours.push(b.label);
+    }
+  }
+
+  return {
+    fromTimestamp: startMs,
+    toTimestamp: endMs,
+    maxConcurrent: limit,
+    totalRuns,
+    peakHoursCount: peakHours.length,
+    peakHours,
+    buckets,
+  };
+}
+
+export function calculateCostHeatmap({
+  costLedger = [],
+  history = [],
+  modelFilter = null,
+  providerFilter = null,
+}) {
+  const ledger = Array.isArray(costLedger) ? costLedger : [];
+  const historyList = Array.isArray(history) ? history : [];
+
+  // Matrix: 7 rows (Mon..Sun) x 24 columns (00..23h)
+  const matrix = Array.from({ length: 7 }, (_, dIdx) =>
+    Array.from({ length: 24 }, (_, hIdx) => ({
+      day: dIdx,
+      dayLabel: DAY_LABELS[dIdx],
+      hour: hIdx,
+      hourLabel: `${String(hIdx).padStart(2, '0')}:00`,
+      tokens: 0,
+      costUsd: 0,
+      runs: 0,
+      costIntensity: 0,
+      tokenIntensity: 0,
+    }))
+  );
+
+  let totalCostUsd = 0;
+  let totalTokens = 0;
+  let totalRuns = 0;
+
+  // Aggregate costLedger
+  for (const entry of ledger) {
+    if (!entry || typeof entry.timestamp !== 'number') continue;
+    if (modelFilter && entry.model && entry.model !== modelFilter) continue;
+    if (providerFilter && entry.provider && entry.provider !== providerFilter) continue;
+
+    const d = new Date(entry.timestamp);
+    const dayOfWeek = (d.getUTCDay() + 6) % 7; // Convert Sun(0) to 6, Mon(1) to 0
+    const hour = d.getUTCHours();
+
+    if (dayOfWeek >= 0 && dayOfWeek < 7 && hour >= 0 && hour < 24) {
+      const cell = matrix[dayOfWeek][hour];
+      const cost = typeof entry.costUsd === 'number' ? entry.costUsd : 0;
+      const tokens = typeof entry.tokens === 'number' ? entry.tokens : 0;
+
+      cell.costUsd += cost;
+      cell.tokens += tokens;
+      totalCostUsd += cost;
+      totalTokens += tokens;
+    }
+  }
+
+  // Aggregate run counts from history
+  for (const r of historyList) {
+    if (!r) continue;
+    const t = r.startedAt || r.completedAt || r.timestamp;
+    if (typeof t !== 'number') continue;
+    if (modelFilter && r.model && r.model !== modelFilter) continue;
+    if (providerFilter && r.provider && r.provider !== providerFilter) continue;
+
+    const d = new Date(t);
+    const dayOfWeek = (d.getUTCDay() + 6) % 7;
+    const hour = d.getUTCHours();
+
+    if (dayOfWeek >= 0 && dayOfWeek < 7 && hour >= 0 && hour < 24) {
+      matrix[dayOfWeek][hour].runs += 1;
+      totalRuns += 1;
+    }
+  }
+
+  // Calculate maximums for intensity normalisation
+  let maxCostHour = 0;
+  let maxTokensHour = 0;
+
+  for (let d = 0; d < 7; d++) {
+    for (let h = 0; h < 24; h++) {
+      const cell = matrix[d][h];
+      cell.costUsd = Number(cell.costUsd.toFixed(4));
+      if (cell.costUsd > maxCostHour) maxCostHour = cell.costUsd;
+      if (cell.tokens > maxTokensHour) maxTokensHour = cell.tokens;
+    }
+  }
+
+  // Normalise intensity (0.0 to 1.0)
+  const costDenom = maxCostHour > 0 ? maxCostHour : 1;
+  const tokenDenom = maxTokensHour > 0 ? maxTokensHour : 1;
+
+  for (let d = 0; d < 7; d++) {
+    for (let h = 0; h < 24; h++) {
+      const cell = matrix[d][h];
+      cell.costIntensity = Number((cell.costUsd / costDenom).toFixed(3));
+      cell.tokenIntensity = Number((cell.tokens / tokenDenom).toFixed(3));
+    }
+  }
+
+  return {
+    dayLabels: DAY_LABELS,
+    hourLabels: Array.from({ length: 24 }, (_, i) => `${String(i).padStart(2, '0')}:00`),
+    matrix,
+    maxCostHour,
+    maxTokensHour,
+    totalCostUsd: Number(totalCostUsd.toFixed(4)),
+    totalTokens,
+    totalRuns,
+  };
+}

package/package.json

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