@mzzsfy/dsh-cron-board 0.2.0 → 0.3.0

package/src/executor.mjs

@@ -67,7 +67,12 @@ export function createExecutor({ store, logger, runner, sessionRunner, maxExpans
       await store.runs.update(record.runId, patch)
       // 任务卡状态回填:看板状态点/耗时直接读任务行(手动与 cron 同源更新)
       const jobPatch = { lastStatus: outcome.status, lastDurationMs: patch.durationMs }
-      if (outcome.pinnedNewId !== undefined) jobPatch.pinnedSessionId = outcome.pinnedNewId
+      if (outcome.pinnedNewId !== undefined) {
+        // pinned 绑定必须落 session 子对象(driver 读 job.session.pinnedSessionId),
+        // 浅合并保留 mode 等其余字段;顶层孤立字段以 undefined 覆盖,落盘时自然消失(历史数据自愈)
+        jobPatch.session = { ...job.session, pinnedSessionId: outcome.pinnedNewId }
+        jobPatch.pinnedSessionId = undefined
+      }
       await store.jobs.update(job.id, jobPatch)
     } catch (error) {
       // runner 拒绝(会话服务异常等)也必须有终态,否则运行记录永久停留 running;
@@ -124,6 +129,10 @@ export function createExecutor({ store, logger, runner, sessionRunner, maxExpans
         records.push(record)
         queue.push({ job, record, env: combinations[i], runnerFor })
       }
+      // 单次任务入队即禁用:先占运行再落禁用,封死 cron 连续 tick 的重复触发窗口
+      if (job.runOnce === true) {
+        await store.jobs.update(job.id, { enabled: false })
+      }
       pump()
       return records.map((record) => record.runId)
     },

package/src/index.js

@@ -64,6 +64,10 @@ export function apply(ctx, config) {
         const logger = createLogger({ rootDir: join(dataDir, 'logs') })
         const sessionDriver = createSessionDriver({
           getSessionController: () => sessionControllerRef.current,
+          // 分组解析为可选增强:registry 缺失(旧宿主)时 driver 干净降级为 cwd-only
+          getWorkspaceRegistry: () => ctx.get('workspaceRegistry'),
+          // 执行预设目录为可选增强:服务缺失时任务不带 preset,由宿主解析默认
+          getAgentPresets: () => ctx.get('agentPresets'),
           agents: ctx.get('agents'),
           sessionQuery: ctx.get('sessionQuery'),
         })
@@ -88,6 +92,7 @@ export function apply(ctx, config) {
           sessionState,
           readSidebarTab: () => readBoolean('sidebarTab', false),
           updateUiSettings,
+          getAgentPresets: () => ctx.get('agentPresets'),
           logSystem: (line) => (ctx.logger && ctx.logger.warn ? ctx.logger.warn(line) : undefined),
         })
         return { api, scheduler }
@@ -210,5 +215,6 @@ export function apply(ctx, config) {
   )
 
   // defer 挂起定时器随插件生命周期回收,不遗留生命周期外触发
-  ctx.effect(() => () => schedulerRef.current.dispose(), 'cron-board scheduler lifecycle')
+  // 生命周期钩子:scheduler 无挂起资源时 dispose 可缺省,可选调用保持约定统一
+  ctx.effect(() => () => schedulerRef.current.dispose?.(), 'cron-board scheduler lifecycle')
 }

package/src/schedule-builder.mjs

@@ -0,0 +1,73 @@
+// 调度构建器纯函数:表单结构化状态(freq + 上下文)与 cron 表达式互转。
+// 仅覆盖构建器可表达的形态,反解不出即 custom(表达式原样手输);触发点计算仍归 croner(cron.mjs)。
+
+export const FREQS = ['daily', 'weekly', 'weekdays', 'interval', 'custom']
+
+export const WEEKDAY_ORDER = ['1', '2', '3', '4', '5', '6', '0']
+export const WEEKDAY_LABELS = { '0': '日', '1': '一', '2': '二', '3': '三', '4': '四', '5': '五', '6': '六' }
+
+export const MINUTE_MAX = 59
+export const HOUR_MAX = 23
+export const INTERVAL_MIN_MINUTES = 1
+
+// 结构化调度状态:custom 时 expression 为唯一有效字段,其余字段仍保留(切回结构化频率不丢配置)
+export function createScheduleState(expression) {
+  return {
+    freq: 'daily',
+    hour: 9,
+    minute: 0,
+    weekdays: ['1'],
+    intervalMinutes: 30,
+    expression,
+  }
+}
+
+const clampInt = (raw, min, max, fallback) => {
+  const value = Number(raw)
+  if (!Number.isInteger(value) || value < min || value > max) return fallback
+  return value
+}
+
+// cron(5 段)→ 构建器状态:匹配失败即 custom;非法数值一律归 custom,不猜
+export function parseSchedule(expression) {
+  const raw = String(expression).trim()
+  const parts = raw.split(/\s+/)
+  const state = createScheduleState(raw)
+  if (parts.length !== 5) { state.freq = 'custom'; return state }
+  const [minute, hour, day, month, weekday] = parts
+  if (day !== '*' || month !== '*') { state.freq = 'custom'; return state }
+  if (minute === '*' && hour === '*') { state.freq = 'custom'; return state }
+  if (/^\*\/\d+$/.test(minute) && hour === '*') {
+    state.freq = 'interval'
+    state.intervalMinutes = clampInt(minute.slice(2), INTERVAL_MIN_MINUTES, MINUTE_MAX, 0)
+    if (state.intervalMinutes === 0) state.freq = 'custom'
+    return state
+  }
+  const hourNum = clampInt(hour, 0, HOUR_MAX, NaN)
+  const minuteNum = clampInt(minute, 0, MINUTE_MAX, NaN)
+  if (!Number.isInteger(hourNum) || !Number.isInteger(minuteNum)) { state.freq = 'custom'; return state }
+  state.hour = hourNum
+  state.minute = minuteNum
+  if (weekday === '*') { state.freq = 'daily'; return state }
+  if (weekday === '1-5') { state.freq = 'weekdays'; return state }
+  const days = weekday.split(',')
+  if (days.every((d) => /^\d$/.test(d) && d in WEEKDAY_LABELS)) {
+    state.freq = 'weekly'
+    state.weekdays = WEEKDAY_ORDER.filter((d) => days.includes(d))
+    return state
+  }
+  state.freq = 'custom'
+  return state
+}
+
+// 构建器状态 → cron;custom 直接返回手工表达式
+export function buildSchedule(state) {
+  if (state.freq === 'custom') return String(state.expression).trim()
+  const minute = String(state.minute)
+  const hour = String(state.hour)
+  if (state.freq === 'daily') return minute + ' ' + hour + ' * * *'
+  if (state.freq === 'weekdays') return minute + ' ' + hour + ' * * 1-5'
+  if (state.freq === 'weekly') return minute + ' ' + hour + ' * * ' + [...state.weekdays].sort((a, b) => Number(a) - Number(b)).join(',')
+  if (state.freq === 'interval') return '*/' + state.intervalMinutes + ' * * * *'
+  return String(state.expression).trim()
+}

package/src/scheduler.mjs

@@ -1,19 +1,15 @@
-// scheduler:单一调度循环。tick 固定四步——扫描到期、先推进 nextRunAt 再执行、
-// 经执行链闸门入队、超时与收尾由执行链负责。misfire 语义:错过触发点超过一个
+// scheduler:单一调度循环。tick 固定三步——扫描到期、先推进 nextRunAt 再执行、
+// 经执行链闸门入队,收尾由执行链负责。misfire 语义:错过触发点超过一个
 // tick 周期即视为停机期间错过,不补跑,记 skipped 并推进(轻量取舍,设计 §4.1)。
 
 import { nextRunAtOf } from './cron.mjs'
-import { hasWindow, inWindow, nextWindowStart } from './session-window.mjs'
 
 const SKIPPED_MISFIRE_MESSAGE = '停机期间错过'
-const SKIPPED_WINDOW_MESSAGE = '窗口外跳过'
 const INTERRUPTED_MESSAGE = 'dsh 重启中断'
 
-export function createScheduler({ store, executor, readTickMs, now = () => Date.now(), scheduleAt = (at, fn) => setTimeout(fn, Math.max(0, at - now())) }) {
+export function createScheduler({ store, executor, readTickMs, now = () => Date.now() }) {
   // 重入闸门:上一 tick 未完成(store 写链排队/慢盘)时跳过本轮,防同一触发点双触发
   let ticking = false
-  // defer 挂起句柄登记:dispose 统一清除,不遗留生命周期外触发
-  const deferredCancels = new Set()
 
   // 重启孤儿收尾:上次进程遗留的 queued/running 统一标 interrupted,不误标失败
   async function recover() {
@@ -23,21 +19,6 @@ export function createScheduler({ store, executor, readTickMs, now = () => Date.
     }
   }
 
-  // defer 到点回调:按 id 重读任务,已删/已停/会话形态变化一律放弃(不吃旧快照)
-  function armDeferred(jobId, at) {
-    const handle = scheduleAt(at, () => {
-      deferredCancels.delete(cancel)
-      void (async () => {
-        const job = store.jobs.get(jobId)
-        if (!job || !job.enabled || job.kind !== 'session' || !hasWindow(job.session)) return
-        if (inWindow(job.session, new Date(now()))) await executor.dispatch(job, 'cron')
-      })().catch(() => {})
-    })
-    // 句柄取消形态归一:函数直接调,定时器对象走 clearTimeout
-    const cancel = typeof handle === 'function' ? handle : () => clearTimeout(handle)
-    deferredCancels.add(cancel)
-  }
-
   async function tick() {
     if (ticking) return
     ticking = true
@@ -58,15 +39,6 @@ export function createScheduler({ store, executor, readTickMs, now = () => Date.
           await store.runs.create({ jobId: job.id, trigger: 'cron', status: 'skipped', message: SKIPPED_MISFIRE_MESSAGE })
           continue
         }
-        // 会话任务窗口:窗口外按 onMiss 跳过或顺延至窗口起点(defer 挂起不持久化,重启按 skip)
-        if (job.kind === 'session' && hasWindow(job.session) && !inWindow(job.session, new Date(nowMs))) {
-          if (job.session.onMiss === 'defer') {
-            armDeferred(job.id, nextWindowStart(job.session, new Date(nowMs)).getTime())
-          } else {
-            await store.runs.create({ jobId: job.id, trigger: 'cron', status: 'skipped', message: SKIPPED_WINDOW_MESSAGE })
-          }
-          continue
-        }
         await executor.dispatch(job, 'cron')
       }
     } finally {
@@ -74,13 +46,6 @@ export function createScheduler({ store, executor, readTickMs, now = () => Date.
     }
   }
 
-  function dispose() {
-    for (const cancel of deferredCancels) {
-      try { cancel() } catch { /* 句柄已自行失效即无清理需求 */ }
-    }
-    deferredCancels.clear()
-  }
-
   // 下次触发预览:启用任务中最小的 nextRunAt(面板状态展示用)
   function nextRunAt() {
     const dueList = store.jobs
@@ -92,7 +57,6 @@ export function createScheduler({ store, executor, readTickMs, now = () => Date.
   return {
     recover,
     tick,
-    dispose,
     status: () => executor.status(),
     nextRunAt,
   }

package/src/session-driver.mjs

@@ -1,25 +1,72 @@
 // session-driver:HostApiDriver 会话编排(设计 §4.3,生产实现唯一)。
-// 发起 = 新建/复用会话 + queue 投递;完成判定 = agents 状态脱离 running(轮询 + timeoutMs 收尾);
-// pinned 忙跳过、丢失自愈、发起成功即写 RunRecord.sessionId。变量折叠与掩码由 env 文本构造承担。
+// 发起 = 分组解析 + 新建/复用会话 + queue 投递;投递成功即终态(crontab 语义:看板只管触发,
+// 执行状态归会话本身);pinned 忙跳过、未绑定/丢失自愈(三态区分)、发起成功即写 RunRecord.sessionId。
+// 变量折叠与掩码由 env 文本构造承担。
 
 import { randomUUID } from 'node:crypto'
+import { realpath } from 'node:fs/promises'
 
 import { buildPromptText } from './env-text.mjs'
 
 const BUSY_MESSAGE = '上一轮仍在进行'
+const REBOUND_MESSAGE = '首次运行已创建并绑定会话'
 const RECREATED_MESSAGE = '原会话丢失已重建'
 const REJECTED_MESSAGE = '会话输入投递被拒绝'
+const DELIVERED_MESSAGE = '已投递会话'
 
-const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000
+// 宿主入口(prompt 准入 / listSessions 读取)逐版本形态有差异:prompt 各版本均非可选链校验
+// signal,listSessions 各版本为可选链;进程内调用无取消来源,统一传永不中止的信号,
+// 宿主仅在入口读一次不保留,共享单例安全,宿主将来收紧为非可选链亦无需再改
+const ADMISSION_SIGNAL = new AbortController().signal
 
-export function createSessionDriver({ getSessionController, agents, sessionQuery, pollIntervalMs = 2 * 1000, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = () => Date.now() }) {
+// pinned 自愈三态:未绑定过(首跑)/已绑定但会话丢失;两者都回写新绑定,仅文案不同
+function recreatedMessage(recreated) {
+  return recreated === 'unbound' ? REBOUND_MESSAGE : RECREATED_MESSAGE
+}
+
+// 分组解析(dsh-im workspaceId 同构):按任务 workdir 找已有分组,未命中建同名分组;
+// registry 缺失或 workdir 不存在时降级为无分组,由调用方回落 cwd 路径
+async function resolveWorkspaceId(registry, workdir) {
+  if (!registry || typeof registry.resolveByPath !== 'function' || typeof registry.createCanonical !== 'function') {
+    return undefined
+  }
+  const existing = await registry.resolveByPath(workdir)
+  if (existing) return existing.id
+  const canonical = await realpath(workdir)
+  const created = await registry.createCanonical(canonical)
+  return created.id
+}
+
+export function createSessionDriver({ getSessionController, getWorkspaceRegistry, agents, sessionQuery }) {
   // pinned 会话存在性:持久层 headers 比对(冷会话不在 agents 注册表)
   async function pinnedExists(sessionId) {
     if (!sessionQuery || typeof sessionQuery.listSessions !== 'function') return Boolean(agents.get(sessionId))
-    const records = await sessionQuery.listSessions()
+    const records = await sessionQuery.listSessions(ADMISSION_SIGNAL)
     return records.some((record) => record && record.id === sessionId)
   }
 
+  // pinned 可用性:已删除(不在持久层)或已归档(从所有分组视图隐藏)均视为丢失,触发重建
+  async function pinnedUsable(sessionId) {
+    const registry = getWorkspaceRegistry ? getWorkspaceRegistry() : undefined
+    const archivedIds = registry?.archivedSessionIds
+    if (Array.isArray(archivedIds) && archivedIds.includes(sessionId)) return false
+    return pinnedExists(sessionId)
+  }
+
+  // 建会话请求:分组按 workdir 挂载(dsh-im 同构);执行预设非空才带字段,
+  // 缺省时省略 agentPreset 由宿主解析当前默认
+  async function createSession(sessionController, workdir, agentPreset) {
+    const payload = {}
+    if (workdir) {
+      const registry = getWorkspaceRegistry ? getWorkspaceRegistry() : undefined
+      const workspaceId = await resolveWorkspaceId(registry, workdir).catch(() => undefined)
+      if (workspaceId) payload.workspaceId = workspaceId
+      else payload.cwd = workdir
+    }
+    if (agentPreset) payload.agentPreset = agentPreset
+    return sessionController.create(Object.keys(payload).length > 0 ? payload : undefined)
+  }
+
   async function run({ job, env, mask, updateRecord }) {
     // 控制器运行时动态解析:装配可能先于宿主挂载 sessionController(异步就绪等待中)
     const sessionController = getSessionController ? getSessionController() : undefined
@@ -30,18 +77,20 @@ export function createSessionDriver({ getSessionController, agents, sessionQuery
     let recreated = false
 
     if (isPinned) {
-      // pinned 串行:上轮未完成直接跳过(不排队)
+      // pinned 串行:上轮未完成直接跳过(不排队,agents 实时状态判定)
       const entry = agents ? agents.get(sessionId) : undefined
       if (entry && entry.status === 'running') {
         return { status: 'skipped', message: BUSY_MESSAGE }
       }
-      if (!sessionId || !(await pinnedExists(sessionId))) {
-        recreated = true
+      if (!sessionId) {
+        recreated = 'unbound'
+      } else if (!(await pinnedUsable(sessionId))) {
+        recreated = 'lost'
       }
     }
 
     if (recreated || !isPinned) {
-      const created = await sessionController.create(job.workdir ? { cwd: job.workdir } : undefined)
+      const created = await createSession(sessionController, job.workdir, session.agentPreset)
       sessionId = created.sessionId
     }
 
@@ -50,32 +99,19 @@ export function createSessionDriver({ getSessionController, agents, sessionQuery
       sessionId,
       mode: 'queue',
       content: [{ type: 'text', text: buildPromptText({ prompt: job.prompt || '', env, mask }) }],
-    })
+    }, ADMISSION_SIGNAL)
     if (!submission || submission.accepted !== true) {
       return { status: 'fail', message: REJECTED_MESSAGE, sessionId }
     }
     if (typeof updateRecord === 'function') {
       await updateRecord({ sessionId })
     }
-
-    // 完成等待:状态脱离 running 即结算,timeoutMs 到点收尾
-    const timeoutMs = Number.isInteger(job.timeoutMs) && job.timeoutMs > 0 ? job.timeoutMs : DEFAULT_TIMEOUT_MS
-    const deadline = now() + timeoutMs
-    while (now() < deadline) {
-      const entry = agents ? agents.get(sessionId) : undefined
-      if (!entry || entry.status !== 'running') {
-        return {
-          status: 'success',
-          sessionId,
-          ...(recreated ? { pinnedNewId: sessionId, message: RECREATED_MESSAGE } : {}),
-        }
-      }
-      await sleep(pollIntervalMs)
-    }
+    // 投递即终态:运行记录反映触发结果,执行进展在会话内查看
     return {
-      status: 'timeout',
+      status: 'success',
       sessionId,
-      ...(recreated ? { pinnedNewId: sessionId, message: RECREATED_MESSAGE + ';超时未完成' } : {}),
+      message: recreated ? recreatedMessage(recreated) : DELIVERED_MESSAGE,
+      ...(recreated ? { pinnedNewId: sessionId } : {}),
     }
   }
 

package/test/executor.test.mjs

@@ -55,6 +55,50 @@ test('executor:正常路径终态 success 且任务卡回填', async (t) => {
   assert.equal(store.jobs.get('j1').lastStatus, 'success')
 })
 
+test('executor:runOnce 任务入队即禁用', async (t) => {
+  const { store, executor } = await makeExecutor(t)
+  // Given 启用中的 runOnce 任务
+  await store.jobs.create({ ...JOB_BASE, id: 'j-once', runOnce: true })
+  // When dispatch(入队,不等终态)
+  await executor.dispatch({ ...JOB_BASE, id: 'j-once', runOnce: true }, 'manual')
+  // Then 任务立即禁用(封死 cron 连续触发的重复运行窗口)
+  assert.equal(store.jobs.get('j-once').enabled, false)
+  // 收尾:放行执行到终态,避免悬挂写与临时目录清理赛跑
+  await dispatchAndSettle(executor, store, 'j-once')
+})
+
+test('executor:非 runOnce 任务运行后保持启用', async (t) => {
+  const { store, executor } = await makeExecutor(t)
+  await store.jobs.create({ ...JOB_BASE, id: 'j-keep' })
+  await dispatchAndSettle(executor, store, 'j-keep')
+  assert.equal(store.jobs.get('j-keep').enabled, true)
+})
+
+test('executor:pinned 自愈回写 session.pinnedSessionId 且清除顶层孤立字段', async (t) => {
+  const { store, executor } = await makeExecutor(t)
+  // Given pinned 任务(session 子对象承载绑定),runner 返回 pinnedNewId 模拟自愈
+  const executorWithPinned = createExecutor({
+    store: await (async () => {
+      await store.jobs.create({ ...JOB_BASE, kind: 'session', session: { mode: 'pinned', pinnedSessionId: '' }, id: 'j-pin' })
+      return store
+    })(),
+    logger: createLogger({ rootDir: join(tmpdir(), 'cron-board-exec-pin-logs') }),
+    sessionRunner: { run: async () => ({ status: 'success', sessionId: 's-new', pinnedNewId: 's-new', message: '首次运行已创建并绑定会话' }) },
+    readMaxConcurrent: () => 2,
+  })
+  const [runId] = await executorWithPinned.dispatch({ ...JOB_BASE, kind: 'session', session: { mode: 'pinned', pinnedSessionId: '' }, id: 'j-pin' }, 'manual')
+  for (let i = 0; i < 200; i++) {
+    const row = store.runs.get(runId)
+    if (row && row.status !== 'queued' && row.status !== 'running') break
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  // Then 绑定写入 session 子对象,顶层无孤立残留
+  const job = store.jobs.get('j-pin')
+  assert.equal(job.session.pinnedSessionId, 's-new')
+  assert.equal(job.pinnedSessionId, undefined)
+  assert.equal(store.runs.get(runId).message, '首次运行已创建并绑定会话')
+})
+
 test('executor:runner 拒绝时补写 fail 终态', async (t) => {
   const dir = await mkdtemp(join(tmpdir(), 'cron-board-exec-'))
   t.after(() => rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }))

package/test/index.test.mjs

@@ -21,7 +21,14 @@ test('index:数据目录默认 ~/.dsh/cron-board,env 可覆盖', () => {
 test('index:apply 注册 prefix 路由且请求走通(列表接口)', async () => {
   // Given webServer 桩:收集注册路由(sessionController 经 get 桩供给,就绪等待同步完成)
   const routes = new Map()
-  const sessionController = { create: async () => ({ sessionId: 's-x' }), prompt: async () => ({ accepted: true }) }
+  const sessionController = {
+    create: async () => ({ sessionId: 's-x' }),
+    // 镜像宿主 facade 契约:prompt 准入首行非可选链校验 signal
+    prompt: async (args, signal) => {
+      signal.throwIfAborted()
+      return { accepted: true }
+    },
+  }
   const ctx = {
     effect(fn, label) {
       if (label === 'cron-board session wait') { fn(); return }
@@ -74,7 +81,9 @@ function makeFullCtx({ timerAvailable = true } = {}) {
       sessions.set(sessionId, { id: sessionId, status: 'running' })
       return { sessionId }
     },
-    async prompt(args) {
+    async prompt(args, signal) {
+      // 镜像宿主 facade 契约:prompt 准入首行非可选链校验 signal
+      signal.throwIfAborted()
       queueMicrotask(() => {
         const entry = sessions.get(args.sessionId)
         if (entry) entry.status = 'idle'
@@ -93,7 +102,17 @@ function makeFullCtx({ timerAvailable = true } = {}) {
       if (name === 'settings') return settingsService
       if (name === 'sessionController') return sessionController
       if (name === 'agents') return { get: (id) => sessions.get(id) }
-      if (name === 'sessionQuery') return { listSessions: async () => [...sessions.values()].map((entry) => ({ id: entry.id })) }
+      if (name === 'workspaceRegistry') return { archivedSessionIds: [] }
+      if (name === 'agentPresets') return { defaultId: '', list: async () => [] }
+      if (name === 'sessionQuery') {
+        return {
+          // 镜像宿主最严准入契约:守护 driver 总是传信号(真实宿主各版本为可选链)
+          listSessions: async (signal) => {
+            signal.throwIfAborted()
+            return [...sessions.values()].map((entry) => ({ id: entry.id }))
+          },
+        }
+      }
       return undefined
     },
     inject(deps, fn) {

package/test/parity.test.mjs

@@ -19,7 +19,7 @@ function clientLogic() {
   assert.ok(begin >= 0 && end > begin, 'client.js 缺少 LOGIC 标记段')
   const section = source.slice(begin + '/* LOGIC-BEGIN */'.length, end)
   const factory = new Function(
-    section + '; return { STATUS_META, TRIGGER_META, KIND_LABELS, MODE_LABELS, ONMISS_LABELS, relativeTime, formatDateTime, formatDuration, statusMeta };',
+    section + '; return { STATUS_META, TRIGGER_META, KIND_LABELS, MODE_LABELS, relativeTime, formatDateTime, formatDuration, statusMeta };',
   )
   return factory()
 }

package/test/routes.test.mjs

@@ -24,7 +24,7 @@ async function makeApi(t, overrides = {}) {
   })
   const logger = createLogger({ rootDir: join(dir, 'logs') })
   const executor = createExecutor({ store, logger, readMaxConcurrent: () => 2 })
-  const api = createApi({ store, logger, executor, ...overrides })
+  const api = createApi({ store, logger, executor, getAgentPresets: () => null, ...overrides })
   return { store, api }
 }
 function makeReq(method, body) {
@@ -325,45 +325,85 @@ test('status 路由:timer 缺失降级时 timerRunning=false 且带原因', asyn
 
 test('jobs 路由:会话任务字段校验与默认值', async (t) => {
   const { store, api } = await makeApi(t)
-  // When 建 pinned 会话任务
+  // When 建 pinned 会话任务(携带已废弃的窗口字段与执行预设)
   const created = await call(api, 'POST', '/api/cron-board/jobs', {
     name: '日报', kind: 'session', prompt: '写日报',
     schedule: '0 9 * * *', enabled: true, timeoutMs: 60 * 1000,
-    session: { mode: 'pinned', pinnedSessionId: ' s-9 ', windowStart: '09:00', windowEnd: '23:00', onMiss: 'defer' },
+    session: { mode: 'pinned', pinnedSessionId: ' s-9 ', windowStart: '09:00', windowEnd: '23:00', onMiss: 'defer', agentPreset: ' coder ' },
   })
-  // Then 会话子对象落库,id 已裁剪,默认值正确
+  // Then 会话子对象仅落合法字段(窗口三字段已随功能删除,不再产出),id 已裁剪
   assert.equal(created.status, 200)
-  assert.deepEqual(created.payload.session, {
-    mode: 'pinned', pinnedSessionId: 's-9', windowStart: '09:00', windowEnd: '23:00', onMiss: 'defer',
-  })
+  assert.deepEqual(created.payload.session, { mode: 'pinned', pinnedSessionId: 's-9', agentPreset: 'coder' })
+  assert.equal(created.payload.timeoutMs, undefined)
   // When shell 任务不带 session 字段
   const shellJob = await call(api, 'POST', '/api/cron-board/jobs', {
     name: 's1', kind: 'shell', command: 'echo x', schedule: '* * * * *', enabled: true, timeoutMs: 1000,
   })
-  // Then session 字段缺省
+  // Then session 字段缺省,shell 保留显式超时
   assert.equal(shellJob.payload.session, undefined)
-  // When 窗口只给一端
-  const half = await call(api, 'POST', '/api/cron-board/jobs', {
-    name: 's2', kind: 'session', prompt: 'x', schedule: '* * * * *', enabled: true, timeoutMs: 1000,
-    session: { windowStart: '09:00' },
+  assert.equal(shellJob.payload.timeoutMs, 1000)
+  // When 单次运行开关
+  const once = await call(api, 'POST', '/api/cron-board/jobs', {
+    name: 'once', kind: 'session', prompt: 'x', schedule: '* * * * *', enabled: true, runOnce: true,
+    session: { mode: 'fresh' },
   })
-  // Then 400(窗口须成对)
-  assert.equal(half.status, 400)
-  assert.match(half.payload.error, /窗口/)
-  // When 非法窗口格式
-  const badWindow = await call(api, 'POST', '/api/cron-board/jobs', {
-    name: 's3', kind: 'session', prompt: 'x', schedule: '* * * * *', enabled: true, timeoutMs: 1000,
-    session: { windowStart: '9:0', windowEnd: '23:00' },
+  // Then 落库 true;缺省 false
+  assert.equal(once.payload.runOnce, true)
+  assert.equal(shellJob.payload.runOnce, false)
+  // When 非法会话模式
+  const badMode = await call(api, 'POST', '/api/cron-board/jobs', {
+    name: 's2', kind: 'session', prompt: 'x', schedule: '* * * * *', enabled: true,
+    session: { mode: 'orphan' },
   })
   // Then 400
-  assert.equal(badWindow.status, 400)
-  // When 非法 onMiss
-  const badMiss = await call(api, 'POST', '/api/cron-board/jobs', {
-    name: 's4', kind: 'session', prompt: 'x', schedule: '* * * * *', enabled: true, timeoutMs: 1000,
-    session: { onMiss: 'retry' },
+  assert.equal(badMode.status, 400)
+  // When 非法执行预设 id(大写/下划线均不合目录 id 形态)
+  const badPreset = await call(api, 'POST', '/api/cron-board/jobs', {
+    name: 's3', kind: 'session', prompt: 'x', schedule: '* * * * *', enabled: true,
+    session: { agentPreset: 'Coder_X' },
   })
   // Then 400
-  assert.equal(badMiss.status, 400)
+  assert.equal(badPreset.status, 400)
+})
+
+test('agent-presets 路由:目录来自宿主服务,缺失降级空目录', async (t) => {
+  // Given 宿主 agentPresets 服务返回混合形态列表
+  const service = {
+    defaultId: 'deepseek',
+    list: async () => [
+      { id: 'deepseek', name: 'DeepSeek 默认' },
+      { id: 'coder' },
+      'broken-str',
+      { id: 'Bad_Id' },
+      { id: 'dup' },
+      { id: 'dup', name: '重复项' },
+      { id: 'damaged', broken: true },
+    ],
+  }
+  const { api } = await makeApi(t, { getAgentPresets: () => service })
+  // When 拉取目录
+  const listed = await call(api, 'GET', '/api/cron-board/agent-presets')
+  // Then 非法形态/重复/损坏项剔除,字符串条目按 {id,label:id} 接受(dsh-im catalogItem 同构)
+  assert.equal(listed.status, 200)
+  assert.equal(listed.payload.defaultId, 'deepseek')
+  assert.deepEqual(listed.payload.items, [
+    { id: 'deepseek', label: 'DeepSeek 默认' },
+    { id: 'coder', label: 'coder' },
+    { id: 'broken-str', label: 'broken-str' },
+    { id: 'dup', label: 'dup' },
+  ])
+  // When 服务缺失
+  const bare = await makeApi(t, { getAgentPresets: () => null })
+  const empty = await call(bare.api, 'GET', '/api/cron-board/agent-presets')
+  // Then 空目录 200(前端仅「跟随宿主默认」)
+  assert.equal(empty.status, 200)
+  assert.deepEqual(empty.payload, { defaultId: '', items: [] })
+  // When 服务异常
+  const throwing = await makeApi(t, { getAgentPresets: () => ({ list: async () => { throw new Error('boom') } }) })
+  const failed = await call(throwing.api, 'GET', '/api/cron-board/agent-presets')
+  // Then 仍空目录 200
+  assert.equal(failed.status, 200)
+  assert.deepEqual(failed.payload, { defaultId: '', items: [] })
 })
 
 test('jobs 路由:会话通道禁用时建会话任务 400,脚本任务不受限', async (t) => {