@mzzsfy/dsh-cron-board 0.2.1 → 0.3.1

package/test/schedule-builder.test.mjs

@@ -0,0 +1,123 @@
+// 调度构建器纯函数行为锁定:结构化状态与 cron 表达式互转,反解不出即 custom。
+// BDD:给定表单状态,生成表达式;给定表达式,反解为表单状态;不可表达形态一律 custom 兜底。
+
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { buildSchedule, createScheduleState, parseSchedule, FREQS } from '../src/schedule-builder.mjs'
+
+test('FREQS 覆盖五种频率形态', () => {
+  assert.deepEqual(FREQS, ['daily', 'weekly', 'weekdays', 'interval', 'custom'])
+})
+
+test('daily:整点状态生成 每天 表达式', () => {
+  const state = createScheduleState('')
+  state.freq = 'daily'
+  state.hour = 2
+  state.minute = 0
+  assert.equal(buildSchedule(state), '0 2 * * *')
+})
+
+test('daily:反解 每天表达式 还原时刻', () => {
+  const state = parseSchedule('30 8 * * *')
+  assert.equal(state.freq, 'daily')
+  assert.equal(state.hour, 8)
+  assert.equal(state.minute, 30)
+})
+
+test('weekdays:工作日状态生成 1-5 表达式', () => {
+  const state = createScheduleState('')
+  state.freq = 'weekdays'
+  state.hour = 9
+  state.minute = 5
+  assert.equal(buildSchedule(state), '5 9 * * 1-5')
+})
+
+test('weekdays:反解 1-5 工作日形态', () => {
+  const state = parseSchedule('0 9 * * 1-5')
+  assert.equal(state.freq, 'weekdays')
+})
+
+test('weekly:多选星期按周序输出', () => {
+  const state = createScheduleState('')
+  state.freq = 'weekly'
+  state.hour = 22
+  state.minute = 0
+  state.weekdays = ['5', '1']
+  assert.equal(buildSchedule(state), '0 22 * * 1,5')
+})
+
+test('weekly:反解多星期表达式按 UI 序(一..六、日)归位', () => {
+  const state = parseSchedule('0 22 * * 6,0,3')
+  assert.equal(state.freq, 'weekly')
+  assert.deepEqual(state.weekdays, ['3', '6', '0'])
+})
+
+test('interval:每 N 分钟生成 */N 表达式', () => {
+  const state = createScheduleState('')
+  state.freq = 'interval'
+  state.intervalMinutes = 30
+  assert.equal(buildSchedule(state), '*/30 * * * *')
+})
+
+test('interval:反解 */N 分钟形态', () => {
+  const state = parseSchedule('*/15 * * * *')
+  assert.equal(state.freq, 'interval')
+  assert.equal(state.intervalMinutes, 15)
+})
+
+test('interval:非法步进(0 或超界)反解为 custom', () => {
+  assert.equal(parseSchedule('*/0 * * * *').freq, 'custom')
+  assert.equal(parseSchedule('*/61 * * * *').freq, 'custom')
+})
+
+test('指定日月的表达式不可表达,归 custom', () => {
+  const state = parseSchedule('0 0 1 * *')
+  assert.equal(state.freq, 'custom')
+  assert.equal(state.expression, '0 0 1 * *')
+})
+
+test('小时步进(0 */2 * * *)非构建器形态,归 custom', () => {
+  assert.equal(parseSchedule('0 */2 * * *').freq, 'custom')
+})
+
+test('非 5 段与乱文本归 custom 且原样保留', () => {
+  assert.equal(parseSchedule('not a cron').freq, 'custom')
+  const six = parseSchedule('0 9 * * * 2026')
+  assert.equal(six.freq, 'custom')
+  assert.equal(six.expression, '0 9 * * * 2026')
+})
+
+test('custom:构建直接透传手工表达式', () => {
+  const state = createScheduleState('  10 1 1 1 *  ')
+  state.freq = 'custom'
+  assert.equal(buildSchedule(state), '10 1 1 1 *')
+})
+
+test('字段越界数值反解归 custom,不猜修正', () => {
+  assert.equal(parseSchedule('99 25 * * *').freq, 'custom')
+  assert.equal(parseSchedule('* 9 * * *').freq, 'custom')
+})
+
+test('parity:client.js SBUILD 段与核心实现逐字镜像', () => {
+  // Given client 半区无模块系统,构建器逻辑必须内联(经典 script)
+  // When 从两侧源码提取函数体文本(SBUILD 标记段 vs schedule-builder.mjs 导出体)
+  // Then 除常量前缀(SB_ 命名空间)与导出关键词外逐字一致,防双实现漂移
+  const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
+  const client = readFileSync(join(pkgRoot, 'src', 'client.js'), 'utf8')
+  const begin = client.indexOf('/* SBUILD-BEGIN */')
+  const end = client.indexOf('/* SBUILD-END */')
+  assert.ok(begin >= 0 && end > begin, 'client.js 缺少 SBUILD 标记段')
+  const block = client.slice(begin, end)
+  const core = readFileSync(join(pkgRoot, 'src', 'schedule-builder.mjs'), 'utf8')
+  // 逐函数对比:剥离 export 关键词后,核心源码的每个可执行行都应出现在 client 镜像段
+  const coreLines = core.split('\n')
+    .map((line) => line.replace(/^export /, '').replace(/\bFREQS\b/g, 'SB_FREQS').replace(/\bWEEKDAY_ORDER\b/g, 'SB_WEEKDAY_ORDER').replace(/\bWEEKDAY_LABELS\b/g, 'SB_WEEKDAY_LABELS').replace(/\bMINUTE_MAX\b/g, 'SB_MINUTE_MAX').replace(/\bHOUR_MAX\b/g, 'SB_HOUR_MAX').replace(/\bINTERVAL_MIN_MINUTES\b/g, 'SB_INTERVAL_MIN_MINUTES').replace(/\bclampInt\b/g, 'sbClampInt').trim())
+    .filter((line) => line !== '' && !line.startsWith('//'))
+  for (const line of coreLines) {
+    assert.ok(block.includes(line), 'client 镜像段缺少核心行: ' + line)
+  }
+})

package/test/scheduler.test.mjs

@@ -11,6 +11,7 @@ import { createStore } from '../src/store.mjs'
 import { createLogger } from '../src/logger.mjs'
 import { createExecutor } from '../src/executor.mjs'
 import { createScheduler } from '../src/scheduler.mjs'
+import { nextRunAtOf } from '../src/cron.mjs'
 
 const TICK_MS = 30 * 1000
 
@@ -144,6 +145,52 @@ test('scheduler:recover 将遗留 queued/running 孤儿记录标 interrupted', a
   assert.equal(store.runs.get('r-done').status, 'success')
 })
 
+test('scheduler:recover 自愈残留触发点——nextRunAt 非当前表达式触发点即重算', async (t) => {
+  // Given 旧版本编辑残留:工作日任务带着非工作日表达式的触发点(历史 bug 数据)
+  const { store, scheduler } = await makeScheduler(t)
+  const legal = nextRunAtOf('55 9 * * 1-5')
+  const stale = nextRunAtOf('0 9 * * *')
+  const jobStale = await store.jobs.create({
+    name: '残留', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: true, timeoutMs: 1000, nextRunAt: stale,
+  })
+  const jobStaleDisabled = await store.jobs.create({
+    name: '残留禁用', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: false, timeoutMs: 1000, nextRunAt: stale,
+  })
+  const jobLegal = await store.jobs.create({
+    name: '合法', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: true, timeoutMs: 1000, nextRunAt: legal,
+  })
+  const jobNull = await store.jobs.create({
+    name: '空值', kind: 'shell', command: 'x', schedule: '0 0 30 2 *',
+    enabled: true, timeoutMs: 1000, nextRunAt: null,
+  })
+  // When 重启恢复
+  await scheduler.recover()
+  // Then 残留值(启用与禁用)按当前 schedule 重算为合法触发点;合法值与空值不动
+  assert.equal(store.jobs.get(jobStale.id).nextRunAt, legal)
+  assert.equal(store.jobs.get(jobStaleDisabled.id).nextRunAt, legal)
+  assert.equal(store.jobs.get(jobLegal.id).nextRunAt, legal)
+  assert.equal(store.jobs.get(jobNull.id).nextRunAt, null)
+})
+
+test('scheduler:recover 自愈幂等——修复后的数据再次恢复不再改写', async (t) => {
+  const { store, scheduler } = await makeScheduler(t)
+  const legal = nextRunAtOf('55 9 * * 1-5')
+  const job = await store.jobs.create({
+    name: '残留', kind: 'shell', command: 'x', schedule: '55 9 * * 1-5',
+    enabled: true, timeoutMs: 1000, nextRunAt: nextRunAtOf('0 9 * * *'),
+  })
+  await scheduler.recover()
+  assert.equal(store.jobs.get(job.id).nextRunAt, legal)
+  // When 时钟推进后再次恢复
+  await new Promise((resolve) => setTimeout(resolve, 1100))
+  await scheduler.recover()
+  // Then 已合法的触发点不被重算推迟
+  assert.equal(store.jobs.get(job.id).nextRunAt, legal)
+})
+
 test('scheduler:并发闸门——maxConcurrent=1 时第二个单元排队,首个完成后推进', async (t) => {
   // Given 两个任务同时到期,全局并发 1
   const { store, runner, scheduler, advance } = await makeScheduler(t, { maxConcurrent: 1 })
@@ -209,137 +256,6 @@ test('scheduler:status 报告活跃与队列深度', async (t) => {
   assert.deepEqual(scheduler.status(), { active: 0, queued: 0 })
 })
 
-test('scheduler:窗口内正常发起,窗口外 skip 记录且节奏不变', async (t) => {
-  // Given 会话任务窗口 09:00-23:00,onMiss=skip,注入会话 runner 桩
-  const dir = await mkdtemp(join(tmpdir(), 'cron-board-win-'))
-  t.after(() => rm(dir, { recursive: true, force: true }))
-  const store = await createStore({ dir })
-  const logger = createLogger({ rootDir: join(dir, 'logs') })
-  const sessionRuns = []
-  const sessionRunner = { run: async () => { sessionRuns.push(1); return { status: 'success' } } }
-  const executor = createExecutor({ store, logger, sessionRunner, readMaxConcurrent: () => 2 })
-  // 虚拟时钟锚定今日 08:00(窗口外)
-  const base = new Date(); base.setHours(8, 0, 0, 0)
-  let nowMs = base.getTime()
-  const scheduler = createScheduler({ store, executor, readTickMs: () => TICK_MS, now: () => nowMs })
-  const job = await store.jobs.create({
-    name: 'w', kind: 'session', prompt: '早报', schedule: '0 8 * * *', enabled: true,
-    timeoutMs: 60 * 1000, session: { mode: 'fresh', windowStart: '09:00', windowEnd: '23:00', onMiss: 'skip' },
-  })
-  await store.jobs.update(job.id, { nextRunAt: nowMs })
-  // When tick(触发点 08:00,窗口外)
-  await scheduler.tick()
-  // Then skipped(窗口外跳过),未发起,节奏正常推进(明日 08:00)
-  const rows = store.runs.list(job.id)
-  assert.equal(rows.length, 1)
-  assert.equal(rows[0].status, 'skipped')
-  assert.equal(rows[0].message, '窗口外跳过')
-  assert.equal(sessionRuns.length, 0)
-  const tomorrow8 = new Date(base); tomorrow8.setDate(tomorrow8.getDate() + 1)
-  assert.equal(store.jobs.get(job.id).nextRunAt, tomorrow8.getTime())
-})
-
-test('scheduler:窗口外 defer 挂起至窗口起点后发起', async (t) => {
-  const dir = await mkdtemp(join(tmpdir(), 'cron-board-defer-'))
-  t.after(() => rm(dir, { recursive: true, force: true }))
-  const store = await createStore({ dir })
-  const logger = createLogger({ rootDir: join(dir, 'logs') })
-  const sessionRuns = []
-  const sessionRunner = { run: async () => { sessionRuns.push(1); return { status: 'success' } } }
-  const executor = createExecutor({ store, logger, sessionRunner, readMaxConcurrent: () => 2 })
-  // defer 定时桩:捕获 (at, fn),测试手动放行
-  const deferred = []
-  const base = new Date(); base.setHours(8, 0, 0, 0)
-  let nowMs = base.getTime()
-  const scheduler = createScheduler({
-    store, executor, readTickMs: () => TICK_MS, now: () => nowMs,
-    scheduleAt: (at, fn) => { deferred.push({ at, fn }) },
-  })
-  const job = await store.jobs.create({
-    name: 'w', kind: 'session', prompt: '早报', schedule: '0 8 * * *', enabled: true,
-    timeoutMs: 60 * 1000, session: { mode: 'fresh', windowStart: '09:00', windowEnd: '23:00', onMiss: 'defer' },
-  })
-  await store.jobs.update(job.id, { nextRunAt: nowMs })
-  // When tick(窗口外 defer)
-  await scheduler.tick()
-  // Then 立即不发起,挂起点 = 今日 09:00
-  assert.equal(sessionRuns.length, 0)
-  assert.equal(deferred.length, 1)
-  const at = new Date(deferred[0].at)
-  assert.equal(at.getHours(), 9)
-  assert.equal(at.getMinutes(), 0)
-  // When 挂起到点放行(真实时钟推进到窗口起点,重读后窗口内才发起)
-  nowMs = at.getTime()
-  deferred[0].fn()
-  await tickMillis(50)
-  // Then 发起会话
-  assert.equal(sessionRuns.length, 1)
-  // 且 cron 节奏不变(明日 08:00)
-  const tomorrow8 = new Date(base); tomorrow8.setDate(tomorrow8.getDate() + 1)
-  assert.equal(store.jobs.get(job.id).nextRunAt, tomorrow8.getTime())
-})
-
-test('scheduler:窗口外 defer 到点重读任务——已禁用任务放弃发起(不吃旧快照)', async (t) => {
-  const dir = await mkdtemp(join(tmpdir(), 'cron-board-defer2-'))
-  t.after(() => rm(dir, { recursive: true, force: true }))
-  const store = await createStore({ dir })
-  const logger = createLogger({ rootDir: join(dir, 'logs') })
-  const sessionRuns = []
-  const sessionRunner = { run: async () => { sessionRuns.push(1); return { status: 'success' } } }
-  const executor = createExecutor({ store, logger, sessionRunner, readMaxConcurrent: () => 2 })
-  const deferred = []
-  const base = new Date(); base.setHours(8, 0, 0, 0)
-  let nowMs = base.getTime()
-  const scheduler = createScheduler({
-    store, executor, readTickMs: () => TICK_MS, now: () => nowMs,
-    scheduleAt: (at, fn) => { deferred.push({ at, fn }); return () => {} },
-  })
-  const job = await store.jobs.create({
-    name: 'w', kind: 'session', prompt: '早报', schedule: '0 8 * * *', enabled: true,
-    timeoutMs: 60 * 1000, session: { mode: 'fresh', windowStart: '09:00', windowEnd: '23:00', onMiss: 'defer' },
-  })
-  await store.jobs.update(job.id, { nextRunAt: nowMs })
-  await scheduler.tick()
-  assert.equal(deferred.length, 1)
-  // When 挂起期间任务被禁用,到点放行
-  await store.jobs.update(job.id, { enabled: false })
-  deferred[0].fn()
-  await tickMillis(50)
-  // Then 不发起
-  assert.equal(sessionRuns.length, 0)
-})
-
-test('scheduler:dispose 清除未到点的 defer 挂起(生命周期外零触发)', async (t) => {
-  const dir = await mkdtemp(join(tmpdir(), 'cron-board-defer3-'))
-  t.after(() => rm(dir, { recursive: true, force: true }))
-  const store = await createStore({ dir })
-  const logger = createLogger({ rootDir: join(dir, 'logs') })
-  const sessionRuns = []
-  const sessionRunner = { run: async () => { sessionRuns.push(1); return { status: 'success' } } }
-  const executor = createExecutor({ store, logger, sessionRunner, readMaxConcurrent: () => 2 })
-  const deferred = []
-  const cancels = []
-  const base = new Date(); base.setHours(8, 0, 0, 0)
-  let nowMs = base.getTime()
-  const scheduler = createScheduler({
-    store, executor, readTickMs: () => TICK_MS, now: () => nowMs,
-    scheduleAt: (at, fn) => { deferred.push({ at, fn }); cancels.push(0); return () => { cancels[cancels.length - 1] = 1 } },
-  })
-  const job = await store.jobs.create({
-    name: 'w', kind: 'session', prompt: '早报', schedule: '0 8 * * *', enabled: true,
-    timeoutMs: 60 * 1000, session: { mode: 'fresh', windowStart: '09:00', windowEnd: '23:00', onMiss: 'defer' },
-  })
-  await store.jobs.update(job.id, { nextRunAt: nowMs })
-  await scheduler.tick()
-  // When dispose 后再放行挂起回调
-  scheduler.dispose()
-  assert.equal(cancels[0], 1)
-  deferred[0].fn()
-  await tickMillis(50)
-  // Then 不发起
-  assert.equal(sessionRuns.length, 0)
-})
-
 test('scheduler:tick 重入闸门——上一轮未完成时下一轮直接跳过(防同点双触发)', async (t) => {
   const { store, runner, scheduler, advance } = await makeScheduler(t)
   await store.jobs.create({

package/test/session-driver.test.mjs

@@ -1,26 +1,33 @@
 // session-driver 测试:HostApiDriver 会话编排语义(设计 §4.3、§7 BDD 会话组)。
-// 桩替 sessionController/agents/sessionQuery,验证 fresh/pinned/忙跳过/丢失自愈/超时/完成判定。
+// 桩替 sessionController/agents/sessionQuery/workspaceRegistry,验证 fresh/pinned/忙跳过/未绑定与丢失自愈/投递即终态/分组挂载。
 
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
-import { setTimeout as delay } from 'node:timers/promises'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
 import { createSessionDriver } from '../src/session-driver.mjs'
 
-// 可控桩:会话注册表 + 控制器(autoIdle 模拟宿主投递后处理完成转 idle;超时场景关掉)
+// 可控桩:会话注册表 + 控制器(autoIdle 模拟宿主投递后处理完成转 idle;投递即终态下仅影响忙判定)
 function makeStubs({ autoIdle = true } = {}) {
   const sessions = new Map()
   let nextId = 0
   const created = []
+  const createRequests = []
   const prompts = []
   const sessionController = {
-    async create({ cwd } = {}) {
-      const sessionId = 's-' + (++nextId)
+    async create(request) {
+      const sessionId = 'sess-' + (++nextId)
+      const cwd = request && request.cwd
       sessions.set(sessionId, { id: sessionId, cwd, status: 'running' })
       created.push({ sessionId, cwd })
+      createRequests.push(request)
       return { sessionId }
     },
-    async prompt(args) {
+    // 镜像宿主 facade 契约(dsh-api-session-controller):prompt 准入首行非可选链校验 signal
+    async prompt(args, signal) {
+      signal.throwIfAborted()
       prompts.push(args)
       if (autoIdle) {
         queueMicrotask(() => {
@@ -35,24 +42,43 @@ function makeStubs({ autoIdle = true } = {}) {
     get: (id) => sessions.get(id),
   }
   const sessionQuery = {
-    async listSessions() {
+    // 镜像宿主最严准入契约:守护 driver 总是传信号(真实宿主各版本为可选链,将来收紧不崩)
+    async listSessions(signal) {
+      signal.throwIfAborted()
       return [...sessions.values()].map((entry) => ({ id: entry.id }))
     },
   }
-  return { sessions, created, prompts, sessionController, agents, sessionQuery }
+  return { sessions, created, createRequests, prompts, sessionController, agents, sessionQuery }
 }
 
-function makeDriver(stubs, overrides = {}) {
+// workspaceRegistry 桩:resolveByPath 按规范化 path 命中,createCanonical 建新组
+function makeRegistry({ paths = {}, archived = [] } = {}) {
+  const workspaces = new Map(Object.entries(paths))
+  let nextId = 0
+  return {
+    archivedSessionIds: archived,
+    async resolveByPath(path) {
+      const id = workspaces.get(path)
+      return id ? { id, path } : undefined
+    },
+    async createCanonical(canonical) {
+      const id = 'w-' + (++nextId)
+      workspaces.set(canonical, id)
+      return { id, path: canonical }
+    },
+  }
+}
+
+function makeDriver(stubs) {
   return createSessionDriver({
     getSessionController: () => stubs.sessionController,
+    getWorkspaceRegistry: stubs.getWorkspaceRegistry,
     agents: stubs.agents,
     sessionQuery: stubs.sessionQuery,
-    pollIntervalMs: 5,
-    ...overrides,
   })
 }
 
-const BASE_JOB = { id: 'j1', kind: 'session', prompt: '跑日报', session: { mode: 'fresh' }, timeoutMs: 60 * 1000 }
+const BASE_JOB = { id: 'j1', kind: 'session', prompt: '跑日报', session: { mode: 'fresh' } }
 const PINNED_S1 = { ...BASE_JOB, session: { mode: 'pinned', pinnedSessionId: 's-1' } }
 const PINNED_GONE = { ...BASE_JOB, session: { mode: 'pinned', pinnedSessionId: 'gone' } }
 
@@ -103,7 +129,7 @@ test('session-driver:pinned 会话丢失自愈:新建并回写', async () => {
   const outcome = await driver.run({ job: PINNED_GONE, env: {} })
   // Then 新建会话顶替,message 含「原会话丢失已重建」
   assert.equal(outcome.status, 'success')
-  assert.equal(outcome.pinnedNewId, 's-1')
+  assert.equal(outcome.pinnedNewId, outcome.sessionId)
   assert.ok(String(outcome.message).includes('原会话丢失已重建'))
   assert.equal(stubs.created.length, 1)
 })
@@ -127,26 +153,14 @@ test('session-driver:发起成功即写 RunRecord.sessionId', async () => {
   assert.ok(updates.some((patch) => typeof patch.sessionId === 'string' && patch.sessionId !== ''))
 })
 
-test('session-driver:会话 idle 即完成(success)', async () => {
-  const stubs = makeStubs()
+test('session-driver:投递即终态,会话持续 running 也不等待', async () => {
+  // 会话持续 running(autoIdle 关):投递成功立即返回,不等执行
+  const stubs = makeStubs({ autoIdle: false })
   const driver = makeDriver(stubs)
-  // When 发起后把会话置 idle(模拟完成)
-  const pending = driver.run({ job: BASE_JOB, env: {} })
-  await delay(30)
-  const sessionId = stubs.created[0].sessionId
-  stubs.sessions.get(sessionId).status = 'idle'
-  const outcome = await pending
-  // Then success 且 RunRecord.sessionId 已写
+  const outcome = await driver.run({ job: BASE_JOB, env: {} })
   assert.equal(outcome.status, 'success')
-  assert.equal(outcome.sessionId, sessionId)
-})
-
-test('session-driver:timeoutMs 到点记 timeout', async () => {
-  // 会话持续 running(autoIdle 关),轮询到超时
-  const stubs = makeStubs({ autoIdle: false })
-  const driver = makeDriver(stubs, { pollIntervalMs: 5 })
-  const outcome = await driver.run({ job: { ...BASE_JOB, timeoutMs: 40 }, env: {} })
-  assert.equal(outcome.status, 'timeout')
+  assert.equal(outcome.message, '已投递会话')
+  assert.equal(stubs.prompts.length, 1)
 })
 
 test('session-driver:prompt 携带变量折叠文本', async () => {
@@ -159,3 +173,125 @@ test('session-driver:prompt 携带变量折叠文本', async () => {
   assert.ok(text.includes('跑日报'))
   assert.ok(text.includes('CITY=hangzhou'))
 })
+
+test('session-driver:prompt 必须携带非中止 AbortSignal(宿主 facade 准入契约)', async () => {
+  const seen = []
+  const stubs = makeStubs()
+  stubs.sessionController.prompt = (args, signal) => {
+    seen.push(signal)
+    queueMicrotask(() => {
+      const entry = stubs.sessions.get(args.sessionId)
+      if (entry) entry.status = 'idle'
+    })
+    return Promise.resolve({ accepted: true })
+  }
+  const driver = makeDriver(stubs)
+  // When 正常发起
+  const outcome = await driver.run({ job: BASE_JOB, env: {} })
+  // Then 传入 AbortSignal 且非中止(宿主首行 throwIfAborted 可通过)
+  assert.equal(outcome.status, 'success')
+  assert.equal(seen.length, 1)
+  assert.ok(seen[0] instanceof AbortSignal)
+  assert.equal(seen[0].aborted, false)
+})
+
+test('session-driver:pinned 首跑未绑定报「已创建并绑定」而非丢失', async () => {
+  const stubs = makeStubs()
+  const driver = makeDriver(stubs)
+  // When pinned 任务尚未绑定会话(pinnedSessionId 为空)
+  const job = { ...BASE_JOB, session: { mode: 'pinned', pinnedSessionId: '' } }
+  const outcome = await driver.run({ job, env: {} })
+  // Then 文案区分:首次绑定,非丢失重建;pinnedNewId 回写供 executor 落库
+  assert.equal(outcome.status, 'success')
+  assert.equal(outcome.message, '首次运行已创建并绑定会话')
+  assert.equal(outcome.pinnedNewId, outcome.sessionId)
+})
+
+test('session-driver:pinned 会话已归档视为丢失,重建并回写', async () => {
+  const stubs = makeStubs()
+  stubs.sessions.set('s-1', { id: 's-1', status: 'idle' })
+  stubs.getWorkspaceRegistry = () => makeRegistry({ archived: ['s-1'] })
+  const driver = makeDriver(stubs)
+  // When pinned 指向的会话存在于持久层但已归档
+  const outcome = await driver.run({ job: PINNED_S1, env: {} })
+  // Then 归档视同丢失:新建会话 + 丢失文案 + pinnedNewId 回写
+  assert.equal(outcome.status, 'success')
+  assert.notEqual(outcome.sessionId, 's-1')
+  assert.equal(outcome.message, '原会话丢失已重建')
+  assert.equal(outcome.pinnedNewId, outcome.sessionId)
+  assert.equal(stubs.created.length, 1)
+})
+
+test('session-driver:pinned 会话已删除视为丢失(既有语义守护)', async () => {
+  const stubs = makeStubs()
+  stubs.getWorkspaceRegistry = () => makeRegistry()
+  const driver = makeDriver(stubs)
+  const outcome = await driver.run({ job: PINNED_GONE, env: {} })
+  assert.equal(outcome.status, 'success')
+  assert.equal(outcome.message, '原会话丢失已重建')
+})
+
+test('session-driver:workdir 命中已有分组时以 workspaceId 建会话(dsh-im 同构)', async () => {
+  const stubs = makeStubs()
+  stubs.getWorkspaceRegistry = () => makeRegistry({ paths: { 'C:\\work\\demo': 'w-1' } })
+  const driver = makeDriver(stubs)
+  // When 任务 workdir 与已有分组 path 一致
+  const outcome = await driver.run({ job: { ...BASE_JOB, workdir: 'C:\\work\\demo' }, env: {} })
+  // Then create 收到 workspaceId 而非 cwd
+  assert.equal(outcome.status, 'success')
+  assert.deepEqual(stubs.createRequests[0], { workspaceId: 'w-1' })
+})
+
+test('session-driver:agentPreset 非空时并入 create 请求', async () => {
+  const stubs = makeStubs()
+  const driver = makeDriver(stubs)
+  // When 任务配置了执行预设
+  await driver.run({ job: { ...BASE_JOB, session: { mode: 'fresh', agentPreset: 'coder' } }, env: {} })
+  // Then create 请求携带 agentPreset
+  assert.deepEqual(stubs.createRequests[0], { agentPreset: 'coder' })
+})
+
+test('session-driver:agentPreset 缺省时请求不带该字段(跟随宿主默认)', async () => {
+  const stubs = makeStubs()
+  const driver = makeDriver(stubs)
+  // When 任务未配置执行预设
+  await driver.run({ job: BASE_JOB, env: {} })
+  // Then create 请求无 agentPreset 键(空载时请求体整体缺省)
+  const request = stubs.createRequests[0] || {}
+  assert.ok(!('agentPreset' in request))
+})
+
+test('session-driver:pinned 复用已有会话不触发 create(preset 不改写)', async () => {
+  const stubs = makeStubs()
+  stubs.sessions.set('s-1', { id: 's-1', status: 'idle' })
+  const driver = makeDriver(stubs)
+  // When pinned 命中可用会话且配置了执行预设
+  await driver.run({ job: { ...PINNED_S1, session: { mode: 'pinned', pinnedSessionId: 's-1', agentPreset: 'coder' } }, env: {} })
+  // Then preset 是 create 语义,复用路径零 create
+  assert.equal(stubs.createRequests.length, 0)
+  assert.equal(stubs.prompts[0].sessionId, 's-1')
+})
+
+test('session-driver:workdir 未命中分组时建组再挂载', async (t) => {
+  // createCanonical 前有 realpath 校验,须用真实存在的目录
+  const dir = await mkdtemp(join(tmpdir(), 'cron-board-ws-'))
+  t.after(() => rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }))
+  const stubs = makeStubs()
+  stubs.getWorkspaceRegistry = () => makeRegistry()
+  const driver = makeDriver(stubs)
+  // When 任务 workdir 无对应分组
+  const outcome = await driver.run({ job: { ...BASE_JOB, workdir: dir }, env: {} })
+  // Then create 收到新建分组的 workspaceId
+  assert.equal(outcome.status, 'success')
+  assert.deepEqual(stubs.createRequests[0], { workspaceId: 'w-1' })
+})
+
+test('session-driver:registry 缺失时降级 cwd 建会话', async () => {
+  const stubs = makeStubs()
+  const driver = makeDriver(stubs)
+  // When 未注入 workspaceRegistry
+  const outcome = await driver.run({ job: { ...BASE_JOB, workdir: 'C:\\work\\x' }, env: {} })
+  // Then 回落 cwd 形态(旧行为),不影响可用性
+  assert.equal(outcome.status, 'success')
+  assert.deepEqual(stubs.createRequests[0], { cwd: 'C:\\work\\x' })
+})

package/src/session-window.mjs

@@ -1,37 +0,0 @@
-// session-window:会话任务时间窗口判定(设计 §4.3)。start>=end 视为跨零点(如 22:00-06:00)。
-
-const MINUTES_PER_DAY = 24 * 60
-
-function parseMinutes(hhmm) {
-  const [hours, minutes] = String(hhmm).split(':').map((part) => parseInt(part, 10))
-  return hours * 60 + minutes
-}
-
-function minutesOfDay(date) {
-  return date.getHours() * 60 + date.getMinutes()
-}
-
-// 触发时刻是否落在窗口内;start>=end 即跨零点区间。session = job.session 子对象
-export function inWindow(session, date) {
-  const start = parseMinutes(session.windowStart)
-  const end = parseMinutes(session.windowEnd)
-  const nowMinutes = minutesOfDay(date)
-  if (start <= end) return nowMinutes >= start && nowMinutes < end
-  return nowMinutes >= start || nowMinutes < end
-}
-
-// 最近的窗口起点时刻(defer 挂起目标):起点未过用今日,已过用明日
-export function nextWindowStart(session, date) {
-  const start = parseMinutes(session.windowStart)
-  const at = new Date(date)
-  at.setSeconds(0, 0)
-  at.setHours(Math.floor(start / 60), start % 60)
-  if (at.getTime() <= date.getTime()) at.setDate(at.getDate() + 1)
-  return at
-}
-
-export function hasWindow(session) {
-  return Boolean(session && session.windowStart && session.windowEnd)
-}
-
-export { MINUTES_PER_DAY }