@goodandready/dsh-cron 0.3.14 → 0.3.16

package/README.md

@@ -205,7 +205,7 @@ Every task picks its own runtime; non-LLM runtimes need no model and consume no
 * **SSH** (`ssh`) — execute a command on a remote host through a `dsh-remote-workspace` profile (`sshProfileId`) or standalone host/key fields.
 * **Docker** (`docker`) — run the command in a container image (`dockerImage`).
 * **Environment variables** — a per-task `env` map (KEY VALUE per line in the UI) applied to external runtimes; secrets do not belong here.
-* **Workspaces and worktrees** — bind a task to a harness workspace (`workspaceId`) and, for code-modifying agent tasks, run it in an isolated git worktree (`worktree`, `keepWorktree`).
+* **Workspaces and worktrees** — bind a task to a harness workspace (`workspaceId`, resolved through host `workspaceRegistry`) or path, and run code-modifying agent tasks in an isolated git worktree (`worktree`, `keepWorktree`).
 
 ### 7. Cost Control: Fallback Model & Burn Guard
 * **Fallback Model** — A task can run on the cheap model by default and still finish on the strong one: set `fallbackModel` (and optionally `fallbackProvider`) and a failed run — `error` or `timeout` — is retried **once** on that model before the ordinary retry backoff applies. History records which model produced the result and whether the fallback was used, usage and cost of both attempts are summed, and the `{model}` template variable renders the model that finished the run. Only agent-mediated tasks (`llm`, `skill`, `workflow`) can use a fallback.

package/README.ru.md

@@ -205,7 +205,7 @@ cron({
 * **SSH** (`ssh`) — выполнение команды на удалённом хосте через профиль `dsh-remote-workspace` (`sshProfileId`) или отдельные поля host/key.
 * **Docker** (`docker`) — выполнение команды в контейнере образа (`dockerImage`).
 * **Переменные окружения** — карта `env` на задачу (в UI — строки KEY VALUE) для внешних рантаймов; секретам здесь не место.
-* **Workspace и worktree** — привязка задачи к workspace харнесса (`workspaceId`) и, для изменяющих код агентских задач, запуск в изолированном git worktree (`worktree`, `keepWorktree`).
+* **Workspace и worktree** — привязка задачи к workspace харнесса (`workspaceId`, разрешаемому через службу `workspaceRegistry`) или пути, и запуск в изолированном git worktree (`worktree`, `keepWorktree`).
 
 ### 7. Экономия: fallback-модель и защита бюджета (Burn Guard)
 * **Fallback-модель** — задача может идти на дешёвой модели по умолчанию и всё же завершиться на сильной: задайте `fallbackModel` (и при необходимости `fallbackProvider`), и сбойный запуск (`error` или `timeout`) один раз повторится на этой модели, прежде чем включится обычный retry с задержкой. В истории видно, какая модель произвела результат и был ли использован fallback; расход и стоимость обеих попыток суммируются; переменная шаблона `{model}` подставляет модель, завершившую запуск. Fallback доступен только агентским типам (`llm`, `skill`, `workflow`).

package/README.zh.md

@@ -205,7 +205,7 @@ cron({
 * **SSH**（`ssh`）—— 通过 `dsh-remote-workspace` 配置（`sshProfileId`）或独立 host/key 字段在远程主机执行命令。
 * **Docker**（`docker`）—— 在镜像容器（`dockerImage`）中执行命令。
 * **环境变量** —— 按任务的 `env` 映射（界面中每行 KEY VALUE）应用于外部运行时；请勿在此存放密钥。
-* **工作区与 worktree** —— 将任务绑定到 Harness 工作区（`workspaceId`）；对会修改代码的智能体任务，可在隔离的 git worktree 中运行（`worktree`、`keepWorktree`）。
+* **工作区与 worktree** —— 将任务绑定到 Harness 工作区（`workspaceId`，通过宿主 `workspaceRegistry` 服务解析）或直接路径；对会修改代码的智能体任务，可在隔离的 git worktree 中运行（`worktree`、`keepWorktree`）。
 
 ### 7. 成本控制：回退模型与支出保护（Burn Guard）
 * **回退模型** —— 任务可以默认使用便宜模型，失败时改用更强模型完成：设置 `fallbackModel`（可选 `fallbackProvider`），失败（`error` 或 `timeout`）的运行会在该模型上重试一次，之后才进入常规重试退避。历史记录会标明最终产出结果的模型以及是否使用了回退，两次尝试的用量与成本都会累计，模板变量 `{model}` 渲染完成运行的模型。回退仅适用于智能体类型（`llm`、`skill`、`workflow`）。

package/lib/api-actions.js

@@ -0,0 +1,317 @@
+import { randomUUID } from 'node:crypto';
+import { captureGitDiff, discardGitChanges, applyGitDiff } from './git-diff.js';
+import { applyDoctorFix, revertDoctorFix, diagnoseFailure } from './doctor.js';
+import { rollbackPromptVersion } from './prompt-evolver.js';
+import { approvalManager } from './approval.js';
+import { MANAGED_BY_CONFIG } from './config-jobs.js';
+import { sendJson, readBody, redactTaskSecrets } from './http-utils.js';
+import { buildDuplicateTask } from './task-transfer.js';
+import { refuseConfigOwned, NOT_FOUND } from './api-collection.js';
+
+export async function handleItemPost({ store, scheduler, req, res, url, id, action, subAction }) {
+  if (action === 'git-diff' && (subAction === 'discard' || subAction === 'revert')) {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const targetDir = task.cwd;
+    if (!targetDir) {
+      sendJson(res, 400, { ok: false, error: 'Task does not define a working directory (cwd)' });
+      return true;
+    }
+    const result = await discardGitChanges(targetDir);
+    sendJson(res, result.ok ? 200 : 500, result);
+    return true;
+  }
+
+  if (action === 'git-diff' && subAction === 'apply') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    let patch = bodyData.diff || bodyData.patch;
+    if (!patch) {
+      const runs = store.getHistory(id, 5);
+      const targetRun = runs.find((r) => r.gitDiff?.diff);
+      patch = targetRun?.gitDiff?.diff;
+    }
+    if (!patch) {
+      sendJson(res, 400, { ok: false, error: 'No diff patch provided or found in run history' });
+      return true;
+    }
+    const targetDir = task.cwd;
+    if (!targetDir) {
+      sendJson(res, 400, { ok: false, error: 'Task does not define a working directory (cwd)' });
+      return true;
+    }
+    const result = await applyGitDiff(targetDir, patch);
+    sendJson(res, result.ok ? 200 : 500, result);
+    return true;
+  }
+
+  if ((action === 'doctor' && subAction === 'apply') || action === 'doctor-apply') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    let fix = bodyData.fix || bodyData.doctorReport;
+    if (!fix) {
+      const runs = store.getHistory(id, 5);
+      const reportRun = runs.find((r) => r.doctorReport);
+      fix = reportRun?.doctorReport;
+    }
+    if (!fix || !fix.suggestedFix) {
+      sendJson(res, 400, { ok: false, error: 'No doctor fix found to apply' });
+      return true;
+    }
+    try {
+      const result = await applyDoctorFix(task, fix, { store, user: bodyData.user || 'operator' });
+      if (!result.ok) {
+        sendJson(res, 400, { ok: false, error: result.error });
+        return true;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        taskId: id,
+        task: redactTaskSecrets(task),
+        revision: result.revision,
+      });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+  }
+
+  if ((action === 'doctor' && subAction === 'revert') || action === 'doctor-revert') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    try {
+      const result = await revertDoctorFix(task, { store, user: bodyData.user || 'operator' });
+      if (!result.ok) {
+        sendJson(res, 400, { ok: false, error: result.error });
+        return true;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        taskId: id,
+        task: redactTaskSecrets(task),
+        revertedCode: result.revertedCode,
+      });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+  }
+
+  if ((action === 'doctor' && subAction === 'diagnose') || action === 'doctor-diagnose') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    const runId = bodyData.runId;
+    const runs = store.getHistory(id, 10);
+    const targetRun = runId ? runs.find((r) => r.id === runId) : runs[0];
+    if (!targetRun) {
+      sendJson(res, 404, { ok: false, error: 'No run history found to diagnose' });
+      return true;
+    }
+    try {
+      const doctorReport = await diagnoseFailure({
+        task,
+        runInfo: targetRun,
+        ask: scheduler?.askModel,
+      });
+      targetRun.doctorReport = doctorReport;
+      sendJson(res, 200, { ok: true, taskId: id, doctorReport });
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+  }
+  if (action === 'prompt-rollback') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBodyJson(req).catch(() => ({}));
+    const targetVersion = Number(body.version || url.searchParams.get('version'));
+    if (!targetVersion || targetVersion < 1) {
+      sendJson(res, 400, { ok: false, error: 'A valid target prompt version is required' });
+      return true;
+    }
+    try {
+      rollbackPromptVersion(task, targetVersion);
+      store.set(task);
+      sendJson(res, 200, {
+        ok: true,
+        task: redactTaskSecrets(task),
+        promptVersion: task.promptVersion,
+        promptHistory: task.promptHistory,
+      });
+    } catch (err) {
+      sendJson(res, 400, { ok: false, error: err.message });
+    }
+    return true;
+  }
+  if (action === 'retry-delivery') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBodyJson(req).catch(() => ({}));
+    const runId = body.runId || url.searchParams.get('runId');
+    const runs = store.history.get(id) || [];
+    const run = runId ? runs.find(r => r.id === runId) : runs[0];
+    if (!run) {
+      sendJson(res, 404, { ok: false, error: 'Run not found' });
+      return true;
+    }
+    const delivery = await scheduler.deliverNotifications(task, run);
+    run.delivery = delivery;
+    if (Array.isArray(run.stages)) {
+      const deliveryStage = run.stages.find(s => s.name === 'delivery');
+      if (deliveryStage) {
+        deliveryStage.status = delivery?.status || 'delivered';
+        deliveryStage.delivered = delivery?.delivered;
+        deliveryStage.failures = delivery?.failures;
+      }
+    }
+    store.scheduleSave();
+    sendJson(res, 200, { ok: true, delivery, run });
+    return true;
+  }
+  if (action === 'approve' || action === 'reject') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBodyJson(req).catch(() => ({}));
+    const proposalId = body.proposalId || url.searchParams.get('proposalId');
+    const proposal = proposalId
+      ? approvalManager.getProposal(proposalId)
+      : approvalManager.getPendingProposalForTask(id);
+
+    if (!proposal) {
+      sendJson(res, 404, { ok: false, error: 'No pending approval proposal found for this task' });
+      return true;
+    }
+
+    const decision = action === 'approve' ? 'approve' : 'reject';
+    const result = approvalManager.decide(proposal.id, decision, {
+      decidedBy: body.decidedBy || 'web-user',
+      reason: body.reason || '',
+    });
+
+    if (!result.ok) {
+      sendJson(res, 400, result);
+      return true;
+    }
+
+    if (decision === 'approve') {
+      scheduler.runTask(id, { approvedBy: body.decidedBy || 'web-user' }).catch(() => {});
+    }
+
+    sendJson(res, 200, { ok: true, proposal: result.proposal });
+    return true;
+  }
+  if (action === 'resolve-uncertain') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req).then(b => JSON.parse(b || '{}')).catch(() => ({}));
+    const runId = body.runId || url.searchParams.get('runId');
+    if (!runId) {
+      sendJson(res, 400, { ok: false, error: 'runId is required' });
+      return true;
+    }
+    const result = store.durableJournal.resolveUncertain(id, runId, {
+      decision: body.decision || 'mark_failed',
+      note: body.note || '',
+      resolvedBy: body.resolvedBy || 'user',
+    });
+    if (!result.ok) {
+      sendJson(res, 400, result);
+      return true;
+    }
+    sendJson(res, 200, result);
+    return true;
+  }
+  if (action === 'run') {
+    if (!store.get(id)) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    await scheduler.triggerManualRun(id);
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(store.get(id)) });
+    return true;
+  }
+  if (action === 'duplicate') {
+    const source = store.get(id);
+    if (!source) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const copy = buildDuplicateTask(source, { id: randomUUID() });
+    try {
+      store.set(copy);
+    } catch (err) {
+      sendJson(res, 500, { ok: false, error: 'Failed to persist duplicate task: ' + err.message });
+      return true;
+    }
+    // A copy starts paused: it must never fire on its own before the user
+    // reviews the schedule (a duplicated one-shot may point at a past time).
+    scheduler.pauseTask(copy.id);
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(copy) });
+    return true;
+  }
+  if (action === 'pause' || action === 'resume') {
+    if (store.get(id) && store.get(id).managedBy === MANAGED_BY_CONFIG) {
+      refuseConfigOwned(res, id);
+      return true;
+    }
+    const task = action === 'pause' ? scheduler.pauseTask(id) : scheduler.resumeTask(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(task) });
+    return true;
+  }
+  if (action === 'toggle' || (!action && url.searchParams.get('action') === 'toggle')) {
+    const stored = store.get(id);
+    if (!stored) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    if (stored.managedBy === MANAGED_BY_CONFIG) {
+      refuseConfigOwned(res, id);
+      return true;
+    }
+    const task = scheduler.toggleTask(id);
+    sendJson(res, 200, { ok: true, task: redactTaskSecrets(task) });
+    return true;
+  }
+  return false;
+}
+
+

package/lib/api-collection.js

@@ -0,0 +1,249 @@
+import { createHash } from 'node:crypto';
+import { parseScheduleExpression } from './scheduler.js';
+import { normalizeTaskType, CODE_EXECUTING_TYPES, EXTERNAL_RUNTIMES } from './runtimes.js';
+import { CHANNEL_IDS, unknownChannelIds } from './channels.js';
+import { MANAGED_BY_CONFIG, configOwnedMessage } from './config-jobs.js';
+import { sendJson, rejectCrossOrigin, readBody, SCRIPT_CONFIRM_HEADER, redactTaskSecrets, restoreTaskSecrets } from './http-utils.js';
+import {
+  validateTaskType,
+  RESERVED_TASK_IDS,
+  isCodeExecutingTask,
+} from './task-transfer.js';
+import { sanitizeAdaptiveConfig } from './adaptive.js';
+import { sanitizeValidators } from './validators.js';
+
+export const NOT_FOUND = { ok: false, error: 'Task not found' };
+export const NOT_ALLOWED = { ok: false, error: 'Method not allowed' };
+
+/**
+ * A task declared in the profile config is owned by that file (#50): the next
+ * plugin start would revert any change made here, so every mutating route
+ * refuses it and says where the task really lives.
+ */
+export function refuseConfigOwned(res, id) {
+  sendJson(res, 409, { ok: false, error: configOwnedMessage(id) });
+}
+
+// ------------------------------------------------------------- collection
+
+export async function handleTaskCollection({ store, scheduler, collection, req, res, url, scope, apiToken, ctx }) {
+  // The alias family only exists for individual tasks.
+  if (scope === 'action' || !collection) {
+    sendJson(res, 405, NOT_ALLOWED);
+    return;
+  }
+  if (req.method === 'GET') {
+    if (rejectCrossOrigin(req, res, { apiToken, ctx })) return;
+    listTasks({ store, scheduler, collection, req, res, url });
+    return;
+  }
+  if (req.method === 'POST') {
+    await createOrUpdateTask({ store, scheduler, req, res, apiToken, ctx: undefined });
+    return;
+  }
+  sendJson(res, 405, NOT_ALLOWED);
+}
+
+export function listTasks({ store, scheduler, collection, req, res, url }) {
+  const status = url.searchParams.get('status') || 'all';
+  const query = url.searchParams.get('query') || '';
+  const list = store.list({ status, query }).map((t) => ({
+    ...redactTaskSecrets(t),
+    running: scheduler.isRunning(t.id),
+    runningSince: scheduler.runningSince(t.id),
+  }));
+  const stats = store.getAggregatedStats();
+  const payload = { ok: true, tasks: list, recommendations: collection.recommendations, stats };
+
+  // Calculate ETag based on payload JSON representation (#134)
+  const bodyString = JSON.stringify(payload);
+  const etag = 'W/"' + createHash('sha1').update(bodyString).digest('hex') + '"';
+
+  if (req && req.headers) {
+    const ifNoneMatch = req.headers['if-none-match'];
+    if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === etag.slice(2))) {
+      res.writeHead(304, { 'ETag': etag, 'Cache-Control': 'no-cache' });
+      res.end();
+      return;
+    }
+  }
+
+  if (typeof res.setHeader === 'function') {
+    res.setHeader('ETag', etag);
+    res.setHeader('Cache-Control', 'no-cache');
+  }
+  sendJson(res, 200, payload);
+}
+
+export async function createOrUpdateTask({ store, scheduler, req, res, apiToken, ctx }) {
+  if (rejectCrossOrigin(req, res, { apiToken, ctx })) return;
+  const { body: rawBody, error } = await readBody(req, res);
+  if (error) return;
+  const existing = rawBody.id ? store.get(rawBody.id) : null;
+  const body = existing ? restoreTaskSecrets(rawBody, existing) : rawBody;
+  if (!body.title || !body.schedule || !body.prompt) {
+    sendJson(res, 400, { ok: false, error: 'Fields title, schedule and prompt are required' });
+    return;
+  }
+  const unknownChannels = unknownChannelIds(body.channels);
+  if (unknownChannels.length) {
+    sendJson(res, 400, {
+      ok: false,
+      error: 'Unknown channel ids: ' + unknownChannels.join(', '),
+      unknownChannels,
+    });
+    return;
+  }
+  const taskType = normalizeTaskType(body.type);
+  if ((CODE_EXECUTING_TYPES.includes(taskType) || isCodeExecutingTask(body)) && req.headers[SCRIPT_CONFIRM_HEADER] !== 'script') {
+    sendJson(res, 403, { ok: false, error: `Creating code-executing tasks over HTTP requires the x-dsh-cron-confirm: script header` });
+    return;
+  }
+  const typeError = validateTaskType(taskType, body);
+  if (typeError) {
+    sendJson(res, 400, { ok: false, error: typeError });
+    return;
+  }
+  let parsed;
+  try {
+    parsed = parseScheduleExpression(body.schedule);
+  } catch (err) {
+    sendJson(res, 400, { ok: false, error: err.message });
+    return;
+  }
+  // A client-supplied id must not shadow the collection routes under
+  // /dsh-cron/tasks, otherwise that task could never be fetched or deleted
+  // again (#42 review finding).
+  if (body.id && RESERVED_TASK_IDS.includes(String(body.id))) {
+    sendJson(res, 400, { ok: false, error: `Task id "${body.id}" is reserved` });
+    return;
+  }
+  // Create-or-update with an existing id is an update too, so the config-owned
+  // refusal must apply here as well — otherwise the POST route would be a way
+  // around the guard on PATCH (#50 review finding).
+  if (body.id) {
+    const existing = store.get(body.id);
+    if (existing && existing.managedBy === MANAGED_BY_CONFIG) {
+      refuseConfigOwned(res, body.id);
+      return;
+    }
+  }
+  let task;
+  try {
+    task = store.set(buildTaskRecord(store, body, taskType, parsed));
+  } catch (err) {
+    sendJson(res, 500, { ok: false, error: 'Failed to persist task: ' + err.message });
+    return;
+  }
+  if (task.status === 'active') {
+    scheduler.scheduleTask(task);
+  } else {
+    scheduler.pauseTask(task.id);
+  }
+  sendJson(res, 200, { ok: true, task: redactTaskSecrets(task) });
+}
+
+/** Merge a create/update payload onto the stored task, if any. */
+export function buildTaskRecord(store, body, taskType, parsed) {
+  const current = body.id ? store.get(body.id) : null;
+  const resolvedStatus = body.status || (current ? current.status : 'active');
+  return {
+    id: body.id,
+    title: body.title,
+    schedule: parsed.cronPattern || body.schedule,
+    scheduleText: body.scheduleText || parsed.humanText,
+    prompt: body.prompt,
+    type: taskType,
+    delivery: body.delivery || 'current',
+    status: resolvedStatus,
+    provider: body.provider || undefined,
+    model: body.model || undefined,
+    fallbackProvider: body.fallbackProvider || undefined,
+    fallbackModel: body.fallbackModel || undefined,
+    notifyTelegram: body.notifyTelegram !== undefined ? Boolean(body.notifyTelegram) : (current ? current.notifyTelegram : undefined),
+    onlyOnFailure: body.onlyOnFailure !== undefined ? Boolean(body.onlyOnFailure) : (current ? current.onlyOnFailure : undefined),
+    timeoutSeconds: body.timeoutSeconds !== undefined ? Number(body.timeoutSeconds) : (current ? current.timeoutSeconds : 1800),
+    overlapPolicy: body.overlapPolicy || (current ? current.overlapPolicy : 'skip'),
+    kanbanMode: body.kanbanMode || (current ? current.kanbanMode : 'none'),
+    timezone: body.timezone !== undefined ? String(body.timezone).trim() : (current ? current.timezone : ''),
+    misfirePolicy: ['skip', 'runOnce', 'catchUpAll'].includes(body.misfirePolicy) ? body.misfirePolicy : (current ? (current.misfirePolicy || 'skip') : 'skip'),
+    maxRetries: body.maxRetries !== undefined ? Math.max(0, Number(body.maxRetries) || 0) : (current ? (Number(current.maxRetries) || 0) : 0),
+    retryBackoffMs: body.retryBackoffMs !== undefined ? Math.max(1000, Number(body.retryBackoffMs) || 30000) : (current ? (Number(current.retryBackoffMs) || 30000) : 30000),
+    permissionPreset: !EXTERNAL_RUNTIMES.includes(taskType) && ['default', 'read-only', 'workspace-write', 'full'].includes(body.permissionPreset) ? body.permissionPreset : (current && !EXTERNAL_RUNTIMES.includes(taskType) ? (current.permissionPreset || 'default') : 'default'),
+    validators: Array.isArray(body.validators) ? sanitizeValidators(body.validators) : (current ? current.validators : undefined),
+    ...mergeExecutionFields(current, body, parsed),
+  };
+}
+
+// export/import logic moved to ./api-import-export.js
+
+/**
+ * Runtime and execution settings of a task, merged onto the stored one. Split
+ * out of buildTaskRecord so both stay readable.
+ */
+export function mergeExecutionFields(current, body, parsed) {
+  return {
+    env: body.env && typeof body.env === 'object' ? body.env : (current ? current.env : undefined),
+    cwd: body.cwd !== undefined ? String(body.cwd).trim() : (current ? current.cwd : ''),
+    channels: Array.isArray(body.channels)
+      ? body.channels.filter((c) => CHANNEL_IDS.includes(c))
+      : (current ? current.channels : undefined),
+    template: body.template !== undefined ? String(body.template) : (current ? current.template : ''),
+    silentRule: body.silentRule !== undefined ? String(body.silentRule) : (current ? current.silentRule : ''),
+    inspectOnFailure: body.inspectOnFailure !== undefined ? Boolean(body.inspectOnFailure) : (current ? Boolean(current.inspectOnFailure) : false),
+    workspaceId: body.workspaceId !== undefined ? String(body.workspaceId).trim() : (current ? current.workspaceId : ''),
+    worktree: body.worktree !== undefined ? Boolean(body.worktree) : (current ? Boolean(current.worktree) : false),
+    keepWorktree: body.keepWorktree !== undefined ? Boolean(body.keepWorktree) : (current ? Boolean(current.keepWorktree) : false),
+    httpMethod: body.httpMethod ? String(body.httpMethod).toUpperCase() : (current ? current.httpMethod : 'GET'),
+    httpUrl: body.httpUrl !== undefined ? String(body.httpUrl).trim() : (current ? current.httpUrl : ''),
+    httpHeaders: body.httpHeaders !== undefined ? body.httpHeaders : (current ? current.httpHeaders : undefined),
+    httpBody: body.httpBody !== undefined ? String(body.httpBody) : (current ? current.httpBody : ''),
+    sshProfileId: body.sshProfileId !== undefined ? String(body.sshProfileId).trim() : (current ? current.sshProfileId : ''),
+    sshTarget: body.sshTarget !== undefined ? String(body.sshTarget).trim() : (current ? current.sshTarget : ''),
+    sshPort: body.sshPort !== undefined ? Number(body.sshPort) || 0 : (current ? current.sshPort : 0),
+    sshKeyPath: body.sshKeyPath !== undefined ? String(body.sshKeyPath).trim() : (current ? current.sshKeyPath : ''),
+    dockerImage: body.dockerImage !== undefined ? String(body.dockerImage).trim() : (current ? current.dockerImage : ''),
+    pythonPath: body.pythonPath !== undefined ? String(body.pythonPath).trim() : (current ? current.pythonPath : ''),
+    nodePath: body.nodePath !== undefined ? String(body.nodePath).trim() : (current ? current.nodePath : ''),
+    skillName: body.skillName !== undefined ? String(body.skillName).trim() : (current ? current.skillName : ''),
+    workflowName: body.workflowName !== undefined ? String(body.workflowName).trim() : (current ? current.workflowName : ''),
+    oneShot: Boolean((parsed && parsed.isOneShot) || (body && body.oneShot)),
+    targetTimestamp: parsed && parsed.isOneShot
+      ? (current && current.schedule === (parsed.cronPattern || body.schedule) ? (current.targetTimestamp || parsed.targetTimestamp) : parsed.targetTimestamp)
+      : (current ? current.targetTimestamp : undefined),
+    costLimitUsd: body.costLimitUsd !== undefined ? (body.costLimitUsd === null ? null : (Number(body.costLimitUsd) > 0 ? Number(body.costLimitUsd) : null)) : (current ? current.costLimitUsd : undefined),
+    dailyCostLimitUsd: body.dailyCostLimitUsd !== undefined ? (body.dailyCostLimitUsd === null ? null : (Number(body.dailyCostLimitUsd) > 0 ? Number(body.dailyCostLimitUsd) : null)) : (current ? current.dailyCostLimitUsd : undefined),
+    tokenLimit: body.tokenLimit !== undefined ? (body.tokenLimit === null ? null : (Number(body.tokenLimit) > 0 ? Number(body.tokenLimit) : null)) : (current ? current.tokenLimit : undefined),
+    pausedReason: body.pausedReason !== undefined ? (body.pausedReason ? String(body.pausedReason) : null) : (current ? current.pausedReason : undefined),
+    agentPreset: body.agentPreset !== undefined ? String(body.agentPreset).trim() : (current ? (current.agentPreset || '') : ''),
+    targetSessionId: body.targetSessionId !== undefined ? String(body.targetSessionId).trim() : (current ? (current.targetSessionId || '') : ''),
+    targetSessionReset: body.targetSessionReset !== undefined ? String(body.targetSessionReset).trim() : (current ? (current.targetSessionReset || 'never') : 'never'),
+    sessionTitle: body.sessionTitle !== undefined ? String(body.sessionTitle).trim() : (current ? (current.sessionTitle || '') : ''),
+    webhookEnabled: body.webhookEnabled !== undefined
+      ? Boolean(body.webhookEnabled)
+      : (body.webhookTrigger?.enabled !== undefined ? Boolean(body.webhookTrigger.enabled) : (current ? Boolean(current.webhookEnabled || current.webhookTrigger?.enabled) : false)),
+    webhookToken: body.webhookToken !== undefined
+      ? String(body.webhookToken).trim()
+      : (body.webhookTrigger?.token ? String(body.webhookTrigger.token).trim() : (current ? (current.webhookToken || current.webhookTrigger?.token || '') : '')),
+    webhookSecret: body.webhookSecret !== undefined
+      ? String(body.webhookSecret).trim()
+      : (body.webhookTrigger?.secret ? String(body.webhookTrigger.secret).trim() : (current ? (current.webhookSecret || current.webhookTrigger?.secret || '') : '')),
+    webhookDebounceMs: body.webhookDebounceMs !== undefined
+      ? (Number(body.webhookDebounceMs) || 0)
+      : (body.webhookTrigger?.debounceMs !== undefined ? (Number(body.webhookTrigger.debounceMs) || 0) : (current ? (Number(current.webhookDebounceMs || current.webhookTrigger?.debounceMs) || 0) : 0)),
+    onSuccess: body.onSuccess !== undefined ? String(body.onSuccess).trim() : (current ? (current.onSuccess || '') : ''),
+    onFailure: body.onFailure !== undefined ? String(body.onFailure).trim() : (current ? (current.onFailure || '') : ''),
+    heartbeatIntervalSeconds: body.heartbeatIntervalSeconds !== undefined ? Number(body.heartbeatIntervalSeconds) : (current ? (Number(current.heartbeatIntervalSeconds) || 0) : 0),
+    gracePeriodSeconds: body.gracePeriodSeconds !== undefined ? Number(body.gracePeriodSeconds) : (current ? (Number(current.gracePeriodSeconds) || 300) : 300),
+    preflightType: body.preflightType !== undefined ? String(body.preflightType).trim().toLowerCase() : (current ? (current.preflightType || 'none') : 'none'),
+    preflightTarget: body.preflightTarget !== undefined ? String(body.preflightTarget).trim() : (current ? (current.preflightTarget || '') : ''),
+    priority: body.priority !== undefined ? (Number(body.priority) || 5) : (current ? (Number(current.priority) || 5) : 5),
+    concurrencyGroup: body.concurrencyGroup !== undefined ? String(body.concurrencyGroup).trim() : (current ? (current.concurrencyGroup || 'default') : 'default'),
+    selfHealingCommand: body.selfHealingCommand !== undefined ? String(body.selfHealingCommand).trim() : (current ? (current.selfHealingCommand || '') : ''),
+    autoDiagnose: body.autoDiagnose !== undefined ? Boolean(body.autoDiagnose) : (current ? Boolean(current.autoDiagnose) : false),
+    adaptive: body.adaptive !== undefined ? sanitizeAdaptiveConfig(body.adaptive) : (current ? current.adaptive : undefined),
+    adaptiveState: current ? current.adaptiveState : undefined,
+  };
+}
+
+