metame-cli 1.4.15 → 1.4.18

package/scripts/daemon-task-envelope.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const ALLOWED_STATUS = new Set(['queued', 'running', 'blocked', 'done', 'failed']);
+const ALLOWED_PRIORITY = new Set(['low', 'normal', 'high', 'urgent']);
+const ALLOWED_TASK_KIND = new Set(['team', 'heartbeat']);
+
+function sanitizeText(input, maxLen = 800) {
+  return String(input || '').replace(/[\x00-\x1F\x7F]/g, ' ').trim().slice(0, maxLen);
+}
+
+function normalizeScopeId(value, fallbackTaskId) {
+  const raw = sanitizeText(value, 120) || sanitizeText(fallbackTaskId, 120);
+  if (!raw) return '';
+  const cleaned = raw
+    .replace(/[^a-zA-Z0-9_-]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '');
+  return cleaned.slice(0, 120);
+}
+
+function sanitizeStringArray(values, maxItems = 20, maxItemLen = 300) {
+  if (!Array.isArray(values)) return [];
+  const out = [];
+  const seen = new Set();
+  for (const item of values) {
+    const v = sanitizeText(item, maxItemLen);
+    if (!v || seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+    if (out.length >= maxItems) break;
+  }
+  return out;
+}
+
+function normalizeInputs(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(input)) {
+    const key = sanitizeText(k, 80);
+    if (!key) continue;
+    if (typeof v === 'string') out[key] = sanitizeText(v, 500);
+    else if (typeof v === 'number' || typeof v === 'boolean') out[key] = v;
+    else if (Array.isArray(v)) out[key] = sanitizeStringArray(v, 12, 240);
+    else if (v && typeof v === 'object') out[key] = JSON.parse(JSON.stringify(v));
+  }
+  return out;
+}
+
+function normalizeDefinitionOfDone(raw) {
+  if (Array.isArray(raw)) return sanitizeStringArray(raw, 12, 240);
+  const text = sanitizeText(raw, 1200);
+  if (!text) return [];
+  return sanitizeStringArray(
+    text.split(/\r?\n|;|；/g).map(s => s.trim()).filter(Boolean),
+    12,
+    240
+  );
+}
+
+function newTaskId(now = new Date()) {
+  const y = now.getUTCFullYear();
+  const m = String(now.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(now.getUTCDate()).padStart(2, '0');
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `t_${y}${m}${d}_${rand}`;
+}
+
+function newHandoffId() {
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `h_${Date.now()}_${rand}`;
+}
+
+function normalizeTaskEnvelope(raw, overrides = {}) {
+  const nowIso = new Date().toISOString();
+  const src = (raw && typeof raw === 'object') ? raw : {};
+  const merged = { ...src, ...overrides };
+
+  const taskId = sanitizeText(merged.task_id, 80) || newTaskId();
+  const parentTaskId = sanitizeText(merged.parent_task_id, 80) || null;
+  const fromAgent = sanitizeText(merged.from_agent, 80) || 'unknown';
+  const toAgent = sanitizeText(merged.to_agent, 80);
+  const scopeId = normalizeScopeId(merged.scope_id, taskId) || taskId;
+  const goal = sanitizeText(merged.goal, 500);
+  const definitionOfDone = normalizeDefinitionOfDone(merged.definition_of_done);
+  const artifacts = sanitizeStringArray(merged.artifacts, 30, 500);
+  const ownedPaths = sanitizeStringArray(merged.owned_paths, 30, 500);
+  const participantBase = sanitizeStringArray(merged.participants, 30, 80);
+  if (fromAgent) participantBase.push(fromAgent);
+  if (toAgent) participantBase.push(toAgent);
+  const participants = sanitizeStringArray(participantBase, 30, 80);
+  const statusRaw = sanitizeText(merged.status, 20).toLowerCase();
+  const priorityRaw = sanitizeText(merged.priority, 20).toLowerCase();
+  const kindRaw = sanitizeText(merged.task_kind, 20).toLowerCase();
+  const status = ALLOWED_STATUS.has(statusRaw) ? statusRaw : 'queued';
+  const priority = ALLOWED_PRIORITY.has(priorityRaw) ? priorityRaw : 'normal';
+  const taskKind = ALLOWED_TASK_KIND.has(kindRaw) ? kindRaw : 'team';
+  const createdAt = sanitizeText(merged.created_at, 64) || nowIso;
+  const updatedAt = sanitizeText(merged.updated_at, 64) || nowIso;
+  const inputs = normalizeInputs(merged.inputs);
+
+  return {
+    task_id: taskId,
+    scope_id: scopeId,
+    parent_task_id: parentTaskId,
+    from_agent: fromAgent,
+    to_agent: toAgent,
+    participants,
+    goal,
+    definition_of_done: definitionOfDone,
+    inputs,
+    artifacts,
+    owned_paths: ownedPaths,
+    task_kind: taskKind,
+    priority,
+    status,
+    created_at: createdAt,
+    updated_at: updatedAt,
+  };
+}
+
+function validateTaskEnvelope(env) {
+  if (!env || typeof env !== 'object') return { ok: false, error: 'envelope_missing' };
+  if (!sanitizeText(env.task_id, 80)) return { ok: false, error: 'task_id_required' };
+  if (!normalizeScopeId(env.scope_id, env.task_id)) return { ok: false, error: 'scope_id_required' };
+  if (!sanitizeText(env.from_agent, 80)) return { ok: false, error: 'from_agent_required' };
+  if (!sanitizeText(env.to_agent, 80)) return { ok: false, error: 'to_agent_required' };
+  if (!sanitizeText(env.goal, 500)) return { ok: false, error: 'goal_required' };
+  if (!ALLOWED_TASK_KIND.has(String(env.task_kind || '').toLowerCase())) return { ok: false, error: 'invalid_task_kind' };
+  if (!ALLOWED_STATUS.has(String(env.status || '').toLowerCase())) return { ok: false, error: 'invalid_status' };
+  if (!ALLOWED_PRIORITY.has(String(env.priority || '').toLowerCase())) return { ok: false, error: 'invalid_priority' };
+  return { ok: true };
+}
+
+module.exports = {
+  ALLOWED_STATUS,
+  ALLOWED_PRIORITY,
+  ALLOWED_TASK_KIND,
+  newTaskId,
+  newHandoffId,
+  normalizeScopeId,
+  normalizeTaskEnvelope,
+  validateTaskEnvelope,
+};

package/scripts/daemon-task-envelope.test.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  normalizeTaskEnvelope,
+  validateTaskEnvelope,
+  newTaskId,
+  newHandoffId,
+} = require('./daemon-task-envelope');
+
+test('normalizeTaskEnvelope sets defaults for team task', () => {
+  const env = normalizeTaskEnvelope({
+    from_agent: 'assistant',
+    to_agent: 'coder',
+    goal: 'run tests',
+  });
+  assert.ok(env.task_id.startsWith('t_'));
+  assert.equal(env.scope_id, env.task_id);
+  assert.equal(env.task_kind, 'team');
+  assert.equal(env.status, 'queued');
+  assert.equal(env.priority, 'normal');
+  assert.equal(env.from_agent, 'assistant');
+  assert.equal(env.to_agent, 'coder');
+  assert.equal(env.goal, 'run tests');
+  assert.deepEqual(env.participants.sort(), ['assistant', 'coder'].sort());
+});
+
+test('validateTaskEnvelope rejects missing goal', () => {
+  const env = normalizeTaskEnvelope({
+    from_agent: 'assistant',
+    to_agent: 'coder',
+    goal: '',
+  });
+  const v = validateTaskEnvelope(env);
+  assert.equal(v.ok, false);
+  assert.equal(v.error, 'goal_required');
+});
+
+test('id generators return expected prefixes', () => {
+  const taskId = newTaskId(new Date('2026-02-25T00:00:00.000Z'));
+  const handoffId = newHandoffId();
+  assert.ok(taskId.startsWith('t_20260225_'));
+  assert.ok(handoffId.startsWith('h_'));
+});
+
+test('normalizeTaskEnvelope keeps explicit scope and merges participants', () => {
+  const env = normalizeTaskEnvelope({
+    task_id: 't_1',
+    scope_id: 'scope#A/1',
+    from_agent: 'assistant',
+    to_agent: 'reviewer',
+    participants: ['assistant', 'coder'],
+    goal: 'review changes',
+  });
+  assert.equal(env.scope_id, 'scope_A_1');
+  assert.deepEqual(env.participants.sort(), ['assistant', 'coder', 'reviewer'].sort());
+});

package/scripts/daemon-task-scheduler.js

@@ -1,5 +1,159 @@
 'use strict';
 
+const { classifyTaskUsage } = require('./usage-classifier');
+
+const WEEKDAY_INDEX = Object.freeze({
+  sun: 0,
+  sunday: 0,
+  mon: 1,
+  monday: 1,
+  tue: 2,
+  tues: 2,
+  tuesday: 2,
+  wed: 3,
+  wednesday: 3,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  thursday: 4,
+  fri: 5,
+  friday: 5,
+  sat: 6,
+  saturday: 6,
+});
+
+function parseAtTime(raw) {
+  const text = String(raw || '').trim();
+  const m = text.match(/^([01]?\d|2[0-3]):([0-5]\d)$/);
+  if (!m) return null;
+  return { hour: Number(m[1]), minute: Number(m[2]) };
+}
+
+function parseDays(raw) {
+  if (raw === undefined || raw === null || raw === '') return { ok: true, days: null };
+
+  let tokens = [];
+  if (Array.isArray(raw)) {
+    tokens = raw;
+  } else if (typeof raw === 'string') {
+    const lower = raw.trim().toLowerCase();
+    if (!lower || lower === 'daily' || lower === 'everyday' || lower === 'all') {
+      return { ok: true, days: null };
+    }
+    if (lower === 'weekdays' || lower === 'workdays') {
+      return { ok: true, days: new Set([1, 2, 3, 4, 5]) };
+    }
+    if (lower === 'weekends') {
+      return { ok: true, days: new Set([0, 6]) };
+    }
+    tokens = lower.split(/[\s,|/]+/).filter(Boolean);
+  } else {
+    return { ok: false, error: 'days must be string or array' };
+  }
+
+  const out = new Set();
+  for (const token of tokens) {
+    let day = null;
+    if (typeof token === 'number' && Number.isInteger(token)) {
+      day = token;
+    } else if (typeof token === 'string' && token.trim()) {
+      const t = token.trim().toLowerCase();
+      if (/^\d+$/.test(t)) day = Number(t);
+      else if (Object.prototype.hasOwnProperty.call(WEEKDAY_INDEX, t)) day = WEEKDAY_INDEX[t];
+    }
+    if (!Number.isInteger(day) || day < 0 || day > 6) {
+      return { ok: false, error: `invalid day token: ${String(token)}` };
+    }
+    out.add(day);
+  }
+
+  return { ok: true, days: out.size > 0 ? out : null };
+}
+
+function dayAllowed(days, day) {
+  if (!days || days.size === 0) return true;
+  return days.has(day);
+}
+
+function nextClockRunAfter(schedule, fromMs) {
+  const baseMs = Number.isFinite(fromMs) ? fromMs : Date.now();
+  const start = new Date(baseMs + 1000);
+  start.setSeconds(0, 0);
+
+  for (let offset = 0; offset <= 8; offset++) {
+    const candidate = new Date(start);
+    candidate.setDate(start.getDate() + offset);
+    candidate.setHours(schedule.hour, schedule.minute, 0, 0);
+    const ts = candidate.getTime();
+    if (ts <= baseMs) continue;
+    if (!dayAllowed(schedule.days, candidate.getDay())) continue;
+    return ts;
+  }
+
+  return baseMs + 24 * 60 * 60 * 1000;
+}
+
+function buildTaskSchedule(task, parseInterval) {
+  const atRaw = typeof task.at === 'string' ? task.at.trim() : '';
+  if (atRaw) {
+    const at = parseAtTime(atRaw);
+    if (!at) return { ok: false, error: `invalid at time "${task.at}"` };
+    const parsedDays = parseDays(task.days !== undefined ? task.days : task.weekdays);
+    if (!parsedDays.ok) return { ok: false, error: parsedDays.error };
+    return {
+      ok: true,
+      schedule: {
+        mode: 'clock',
+        hour: at.hour,
+        minute: at.minute,
+        days: parsedDays.days,
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    schedule: {
+      mode: 'interval',
+      intervalSec: parseInterval(task.interval),
+    },
+  };
+}
+
+function nextRunAfter(schedule, fromMs) {
+  if (!schedule || schedule.mode !== 'clock') {
+    const intervalSec = schedule && Number.isFinite(schedule.intervalSec)
+      ? schedule.intervalSec
+      : 3600;
+    return fromMs + intervalSec * 1000;
+  }
+  return nextClockRunAfter(schedule, fromMs);
+}
+
+function computeInitialNextRun(task, schedule, state, nowMs, checkIntervalSec, newTaskIndex) {
+  if (!schedule || schedule.mode !== 'clock') {
+    const intervalSec = schedule && Number.isFinite(schedule.intervalSec)
+      ? schedule.intervalSec
+      : 3600;
+    const lastRun = state.tasks[task.name] && state.tasks[task.name].last_run;
+    if (lastRun) {
+      const elapsed = (nowMs - new Date(lastRun).getTime()) / 1000;
+      return nowMs + Math.max(0, (intervalSec - elapsed)) * 1000;
+    }
+    return nowMs + checkIntervalSec * 1000 * newTaskIndex;
+  }
+
+  const lastRun = state.tasks[task.name] && state.tasks[task.name].last_run;
+  if (lastRun) {
+    const lastMs = new Date(lastRun).getTime();
+    if (Number.isFinite(lastMs) && lastMs > 0) {
+      const dueAfterLast = nextClockRunAfter(schedule, lastMs);
+      if (dueAfterLast <= nowMs) return nowMs;
+    }
+  }
+  return nextClockRunAfter(schedule, nowMs);
+}
+
 function createTaskScheduler(deps) {
   const {
     fs,
@@ -134,7 +288,11 @@ function createTaskScheduler(deps) {
     if (task.type === 'script') {
       log('INFO', `Executing script task: ${task.name} → ${task.command}`);
       try {
-        const scriptEnv = { ...process.env, METAME_ROOT: process.env.METAME_ROOT || '' };
+        const scriptEnv = {
+          ...process.env,
+          METAME_ROOT: process.env.METAME_ROOT || '',
+          METAME_INTERNAL_PROMPT: '1',
+        };
         delete scriptEnv.CLAUDECODE;
         const output = execSync(task.command, {
           encoding: 'utf8',
@@ -232,7 +390,12 @@ function createTaskScheduler(deps) {
     // executeTask now returns a Promise — callers must handle it with .then() or await.
     const timeoutMs = resolveTimeoutMs(task.timeout, 120);
     const asyncArgs = [...claudeArgs];
-    const asyncEnv = { ...process.env, ...getDaemonProviderEnv(), CLAUDECODE: undefined };
+    const asyncEnv = {
+      ...process.env,
+      ...getDaemonProviderEnv(),
+      CLAUDECODE: undefined,
+      METAME_INTERNAL_PROMPT: '1',
+    };
 
     return new Promise((resolve) => {
       const child = spawn(CLAUDE_BIN, asyncArgs, {
@@ -299,7 +462,7 @@ function createTaskScheduler(deps) {
           return resolve({ success: false, error: errMsg, output: '' });
         }
         const estimatedTokens = Math.ceil((fullPrompt.length + output.length) / 4);
-        recordTokens(state, estimatedTokens);
+        recordTokens(state, estimatedTokens, { category: classifyTaskUsage(task) });
         const prevSessionId = state.tasks[task.name]?.session_id;
         const prevCreatedAt = state.tasks[task.name]?.session_created_at;
         state.tasks[task.name] = {
@@ -367,7 +530,17 @@ function createTaskScheduler(deps) {
       log('INFO', `Workflow ${task.name} step ${i + 1}/${steps.length}: ${step.skill || 'prompt'}`);
       try {
         const output = execFileSync(CLAUDE_BIN, args, {
-          input: prompt, encoding: 'utf8', timeout: resolveTimeoutMs(step.timeout, 300), maxBuffer: 5 * 1024 * 1024, cwd, env: { ...process.env, ...getDaemonProviderEnv(), CLAUDECODE: undefined },
+          input: prompt,
+          encoding: 'utf8',
+          timeout: resolveTimeoutMs(step.timeout, 300),
+          maxBuffer: 5 * 1024 * 1024,
+          cwd,
+          env: {
+            ...process.env,
+            ...getDaemonProviderEnv(),
+            CLAUDECODE: undefined,
+            METAME_INTERNAL_PROMPT: '1',
+          },
         }).trim();
         const tk = Math.ceil((prompt.length + output.length) / 4);
         totalTokens += tk;
@@ -378,14 +551,14 @@ function createTaskScheduler(deps) {
         log('ERROR', `Workflow ${task.name} step ${i + 1} failed: ${e.message.slice(0, 200)}`);
         outputs.push({ step: i + 1, skill: step.skill || null, error: e.message.slice(0, 200) });
         if (!step.optional) {
-          recordTokens(loadState(), totalTokens);
+          recordTokens(loadState(), totalTokens, { category: classifyTaskUsage(task) });
           state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'error', error: `Step ${i + 1} failed`, steps_completed: i, steps_total: steps.length };
           saveState(state);
           return { success: false, error: `Step ${i + 1} failed`, output: outputs.map(o => `Step ${o.step}: ${o.error ? 'FAILED' : 'OK'}`).join('\n'), tokens: totalTokens };
         }
       }
     }
-    recordTokens(loadState(), totalTokens);
+    recordTokens(loadState(), totalTokens, { category: classifyTaskUsage(task) });
     const lastOk = [...outputs].reverse().find(o => !o.error);
     state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'success', output_preview: (lastOk ? lastOk.output : '').slice(0, 200), steps_completed: outputs.filter(o => !o.error).length, steps_total: steps.length };
     saveState(state);
@@ -418,7 +591,19 @@ function createTaskScheduler(deps) {
 
     const enabledTasks = tasks.filter(t => t.enabled !== false);
     const checkIntervalSec = (config.daemon && config.daemon.heartbeat_check_interval) || 60;
-    log('INFO', `Heartbeat scheduler started (check every ${checkIntervalSec}s, ${enabledTasks.length}/${tasks.length} tasks enabled)`);
+    const taskSchedules = new Map();
+    const runnableTasks = [];
+    for (const task of enabledTasks) {
+      const parsed = buildTaskSchedule(task, parseInterval);
+      if (!parsed.ok) {
+        log('WARN', `Skipping task "${task.name}": ${parsed.error}`);
+        continue;
+      }
+      taskSchedules.set(task.name, parsed.schedule);
+      runnableTasks.push(task);
+    }
+
+    log('INFO', `Heartbeat scheduler started (check every ${checkIntervalSec}s, ${runnableTasks.length}/${tasks.length} tasks enabled)`);
 
     // Even with zero tasks, the physiological heartbeat still runs
 
@@ -428,18 +613,11 @@ function createTaskScheduler(deps) {
     const state = loadState();
 
     let newTaskIndex = 0;
-    for (const task of enabledTasks) {
-      const intervalSec = parseInterval(task.interval);
-      const lastRun = state.tasks[task.name] && state.tasks[task.name].last_run;
-      if (lastRun) {
-        const elapsed = (now - new Date(lastRun).getTime()) / 1000;
-        nextRun[task.name] = now + Math.max(0, (intervalSec - elapsed)) * 1000;
-      } else {
-        // First run: stagger new tasks to avoid thundering herd
-        // Each new task waits an additional check interval beyond the first
-        newTaskIndex++;
-        nextRun[task.name] = now + checkIntervalSec * 1000 * newTaskIndex;
-      }
+    for (const task of runnableTasks) {
+      const schedule = taskSchedules.get(task.name);
+      if (!schedule) continue;
+      if (schedule.mode !== 'clock') newTaskIndex++;
+      nextRun[task.name] = computeInitialNextRun(task, schedule, state, now, checkIntervalSec, newTaskIndex);
     }
 
     // Tracks tasks currently running (prevents concurrent runs of the same task)
@@ -463,9 +641,10 @@ function createTaskScheduler(deps) {
 
       // ② Task heartbeat (burns tokens on schedule)
       const currentTime = Date.now();
-      for (const task of enabledTasks) {
+      for (const task of runnableTasks) {
+        const schedule = taskSchedules.get(task.name);
+        if (!schedule) continue;
         if (currentTime >= (nextRun[task.name] || 0)) {
-          const intervalSec = parseInterval(task.interval);
           // Dream tasks: only run when user is idle
           if (task.require_idle && !isUserIdle()) {
             // Retry on next scheduler tick instead of waiting full interval.
@@ -476,12 +655,12 @@ function createTaskScheduler(deps) {
 
           if (runningTasks.has(task.name)) {
             // Task is still running; skip this cycle and keep full interval cadence.
-            nextRun[task.name] = currentTime + intervalSec * 1000;
+            nextRun[task.name] = nextRunAfter(schedule, currentTime);
             log('WARN', `Task ${task.name} still running — skipping this interval`);
             continue;
           }
 
-          nextRun[task.name] = currentTime + intervalSec * 1000;
+          nextRun[task.name] = nextRunAfter(schedule, currentTime);
           runningTasks.add(task.name);
           // executeTask now returns a Promise (async, non-blocking, process-group kill)
           Promise.resolve(executeTask(task, config))
@@ -509,6 +688,7 @@ function createTaskScheduler(deps) {
           const notifications = skillEvolution.checkEvolutionQueue();
           for (const item of notifications) {
             let msg = '';
+            const idHint = item.id ? `\nID: \`${item.id}\`` : '';
             if (item.type === 'skill_gap') {
               msg = `🧬 *技能缺口检测*\n${item.reason}`;
               if (item.search_hint) msg += `\n搜索建议: \`${item.search_hint}\``;
@@ -517,6 +697,8 @@ function createTaskScheduler(deps) {
             } else if (item.type === 'user_complaint') {
               msg = `⚠️ *技能反馈*\n技能 \`${item.skill_name}\` 收到用户反馈\n${item.reason}`;
             }
+            if (msg && item.id) msg += `${idHint}\n处理: \`/skill-evo done ${item.id}\` 或 \`/skill-evo dismiss ${item.id}\``;
+            else if (msg) msg += idHint;
             if (msg && notifyFn) notifyFn(msg);
           }
         } catch (e) { log('WARN', `Skill evolution queue check failed: ${e.message}`); }
@@ -536,4 +718,14 @@ function createTaskScheduler(deps) {
   };
 }
 
-module.exports = { createTaskScheduler };
+module.exports = {
+  createTaskScheduler,
+  _private: {
+    parseAtTime,
+    parseDays,
+    nextClockRunAfter,
+    buildTaskSchedule,
+    computeInitialNextRun,
+    nextRunAfter,
+  },
+};

package/scripts/daemon-task-scheduler.test.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const { _private } = require('./daemon-task-scheduler');
+
+const {
+  parseAtTime,
+  parseDays,
+  nextClockRunAfter,
+  buildTaskSchedule,
+  computeInitialNextRun,
+  nextRunAfter,
+} = _private;
+
+function nextDayOfWeek(base, day) {
+  const d = new Date(base);
+  while (d.getDay() !== day) d.setDate(d.getDate() + 1);
+  return d;
+}
+
+describe('daemon-task-scheduler private helpers', () => {
+  it('parses HH:MM time for clock tasks', () => {
+    assert.deepEqual(parseAtTime('09:30'), { hour: 9, minute: 30 });
+    assert.deepEqual(parseAtTime('23:59'), { hour: 23, minute: 59 });
+    assert.equal(parseAtTime('24:00'), null);
+    assert.equal(parseAtTime('9:7'), null);
+  });
+
+  it('parses days keywords and weekday names', () => {
+    assert.deepEqual([...parseDays('weekdays').days], [1, 2, 3, 4, 5]);
+    assert.deepEqual([...parseDays('weekends').days], [0, 6]);
+    assert.deepEqual([...parseDays(['mon', 'wed', 'fri']).days], [1, 3, 5]);
+    assert.equal(parseDays('daily').days, null);
+    assert.equal(parseDays().days, null);
+    assert.equal(parseDays('funday').ok, false);
+  });
+
+  it('computes next run for daily fixed-time schedule', () => {
+    const schedule = { mode: 'clock', hour: 9, minute: 30, days: null };
+    const fromBefore = new Date(2026, 1, 25, 8, 0, 0, 0).getTime();
+    const fromAfter = new Date(2026, 1, 25, 10, 0, 0, 0).getTime();
+
+    const next1 = new Date(nextClockRunAfter(schedule, fromBefore));
+    const next2 = new Date(nextClockRunAfter(schedule, fromAfter));
+
+    assert.equal(next1.getHours(), 9);
+    assert.equal(next1.getMinutes(), 30);
+    assert.equal(next1.getDate(), 25);
+
+    assert.equal(next2.getHours(), 9);
+    assert.equal(next2.getMinutes(), 30);
+    assert.equal(next2.getDate(), 26);
+  });
+
+  it('computes next run for weekday-only fixed-time schedule', () => {
+    const saturdayBase = nextDayOfWeek(new Date(2026, 1, 1, 8, 0, 0, 0), 6);
+    const schedule = { mode: 'clock', hour: 9, minute: 0, days: parseDays('weekdays').days };
+    const next = new Date(nextClockRunAfter(schedule, saturdayBase.getTime()));
+    const monday = nextDayOfWeek(new Date(saturdayBase), 1);
+
+    assert.equal(next.getDay(), 1);
+    assert.equal(next.getHours(), 9);
+    assert.equal(next.getMinutes(), 0);
+    assert.equal(next.getDate(), monday.getDate());
+    assert.equal(next.getMonth(), monday.getMonth());
+    assert.equal(next.getFullYear(), monday.getFullYear());
+  });
+
+  it('builds interval or clock schedule from task config', () => {
+    const intervalTask = { name: 'a', interval: '2h' };
+    const clockTask = { name: 'b', at: '07:15', days: 'weekdays' };
+
+    const interval = buildTaskSchedule(intervalTask, () => 7200);
+    const clock = buildTaskSchedule(clockTask, () => 3600);
+    const invalid = buildTaskSchedule({ name: 'bad', at: '25:99' }, () => 3600);
+
+    assert.equal(interval.ok, true);
+    assert.equal(interval.schedule.mode, 'interval');
+    assert.equal(interval.schedule.intervalSec, 7200);
+
+    assert.equal(clock.ok, true);
+    assert.equal(clock.schedule.mode, 'clock');
+    assert.equal(clock.schedule.hour, 7);
+    assert.equal(clock.schedule.minute, 15);
+    assert.deepEqual([...clock.schedule.days], [1, 2, 3, 4, 5]);
+
+    assert.equal(invalid.ok, false);
+  });
+
+  it('does catch-up for missed fixed-time runs and computes next run after execution', () => {
+    const task = { name: 'daily-report', at: '09:00' };
+    const schedule = { mode: 'clock', hour: 9, minute: 0, days: null };
+    const now = new Date(2026, 1, 25, 10, 0, 0, 0).getTime();
+    const yesterday = new Date(2026, 1, 24, 9, 0, 0, 0).toISOString();
+    const state = { tasks: { 'daily-report': { last_run: yesterday } } };
+
+    const initial = computeInitialNextRun(task, schedule, state, now, 60, 1);
+    const next = new Date(nextRunAfter(schedule, now));
+
+    assert.equal(initial, now);
+    assert.equal(next.getDate(), 26);
+    assert.equal(next.getHours(), 9);
+    assert.equal(next.getMinutes(), 0);
+  });
+});