@mzzsfy/dsh-session-manager 0.9.5 → 0.9.7

package/test/index.test.mjs

@@ -1,1917 +1,1890 @@
-// 路由层 BDD(mock ctx 强制 cordis 注入语义):宿主上下文上任何未声明 inject 的
-// 服务属性访问一律抛 cannot get property ... without inject,与 cordis reflect 行为
-// 一致,防止 inject 声明缺失回归。peer 依赖未安装的仓库环境(禁止 install)下整文件跳过。
-
-import test, { mock } from 'node:test'
-import assert from 'node:assert/strict'
-import { EventEmitter } from 'node:events'
-import { mkdtemp, writeFile, utimes, mkdir, rm, readFile, access } from 'node:fs/promises'
-import { mkdtempSync, rmSync } from 'node:fs'
-import { createHash } from 'node:crypto'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-
-// 仅 peer 依赖缺失允许整文件跳过;其余加载失败(src 自身损坏)直接失败,禁止静默 skip
-const indexModule = await import('../src/index.js').catch((error) => {
-  const missingPeer = error && error.code === 'ERR_MODULE_NOT_FOUND'
-    && (error.message.includes("'@deepseek-ai/") || error.message.includes("'zod"))
-  if (missingPeer) return error
-  throw error
-})
-const apply = indexModule.apply
-const declaredInject = Array.isArray(indexModule.inject) ? indexModule.inject : []
-const dependencyReady = typeof apply === 'function'
-const skipMissingDeps = { skip: dependencyReady ? false : 'peer 依赖未安装,路由层测试跳过' }
-const MESSAGES = indexModule.MESSAGES
-const { DELETE_MESSAGES, DEFAULT_AUTO_ARCHIVE_DAYS, DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS } = await import('../src/core.mjs').catch(() => ({ DELETE_MESSAGES: {} }))
-
-// 回收区目录统一隔离:删除降级路径把产物搬进该目录,防泄漏真实用户目录
-const sharedQuarantineDir = mkdtempSync(path.join(tmpdir(), 'sm-quarantine-shared-'))
-process.env.DSH_QUARANTINE_DIR = sharedQuarantineDir
-test.after(() => {
-  rmSync(sharedQuarantineDir, { recursive: true, force: true })
-})
-// 台账/重挂载夹具路径仅作数据,不落盘;形态与实现一致(会话目录)
-const LEDGER_FIXTURE_PATH = 'C:\\store\\s1'
-// 幽灵产物夹具:tmpdir 下未创建的路径,跨平台 stat 必 ENOENT
-// (POSIX 对纯反斜杠 Windows 字面量取 dirname 会落回 '.',stat 成功使幽灵分支不可达)
-const GHOST_DIR = path.join(tmpdir(), 'sm-ghost-fixture', 's1')
-const GHOST_PATH = path.join(GHOST_DIR, 'session.jsonl.zstd')
-
-function makeRegistry(initialIds) {
-  // 真实注册表契约:archivedSessionIds 是进程内快照的 getter,官方读路径全部经快照;
-  // archiveSession 归档即入集合(官方幂等判定依据),桩保持同语义
-  const registry = {
-    state: { initialized: true, workspaceIds: [], archivedSessionIds: initialIds },
-    list: () => [],
-    archiveCalls: [],
-    archiveSession: async (id) => {
-      const sid = String(id)
-      registry.archiveCalls.push(sid)
-      registry.state.archivedSessionIds = [...registry.state.archivedSessionIds, sid]
-    },
-  }
-  Object.defineProperty(registry, 'archivedSessionIds', {
-    get: () => registry.state.archivedSessionIds,
-  })
-  return registry
-}
-
-// workspace 域句柄:null 表示域未打开(get 返回 undefined)
-function makeDomain(initialIds) {
-  const domain = {
-    state: { archivedSessionIds: initialIds },
-    writes: 0,
-    global: {
-      get: () => domain.state,
-      set: async (next) => {
-        domain.state = { ...next }
-        domain.writes += 1
-      },
-    },
-  }
-  return domain
-}
-
-// 台账域句柄;openRejected 模拟台账域打开失败
-function makeLedgerDomain(entries) {
-  const domain = {
-    state: { deleted: entries, unarchivedAt: 0 },
-    writes: 0,
-    global: {
-      get: () => domain.state,
-      set: async (next) => {
-        domain.state = { ...next }
-        domain.writes += 1
-      },
-    },
-  }
-  return domain
-}
-
-// workspace 注册表实体桩:detach/attach 均为官方实体契约,供删除与重挂载断言
-function makeWorkspace(path, sessionIds, options = {}) {
-  const workspace = {
-    path,
-    sessionIds,
-    attachCalls: [],
-    attachSession: async (id) => {
-      if (options.attachError) throw options.attachError
-      workspace.attachCalls.push(String(id))
-      workspace.sessionIds = [String(id), ...workspace.sessionIds.filter((existing) => existing !== id)]
-    },
-    detachSession: async (id) => {
-      if (options.detachError) throw options.detachError
-      workspace.sessionIds = workspace.sessionIds.filter((existing) => String(existing) !== String(id))
-    },
-  }
-  return workspace
-}
-
-function makeCtx({
-  archivedIds,
-  headers,
-  agents,
-  domain,
-  sessionPersistence,
-  ledger,
-  openRejected,
-  workspaces,
-  settingsValue,
-  settingsService: settingsServiceOverride,
-  timerAvailable,
-  readSessions,
-  configRef,
-  configEditor,
-}) {
-  const routes = []
-  const eventHandlers = {}
-  const pendingInjects = []
-  const disposers = []
-  const ledgerDomain = ledger === undefined ? makeLedgerDomain([]) : ledger
-  const workspaceList = workspaces || []
-  const settingsState = { value: settingsValue }
-  const settingsService = settingsServiceOverride ?? {
-    get: () => settingsState.value,
-    register: () => ({ resolved: undefined }),
-    // 宿主 update 为异步串行:合并进微任务队列后生效,读旧值发生在 flush 前
-    update: (ns, patch) => new Promise((resolve) => queueMicrotask(() => {
-      settingsState.value = { ...(settingsState.value || {}), ...patch }
-      resolve()
-    })),
-  }
-  // timer 服务桩:模拟宿主 timer 激活后的 interval;unref 保证测试进程可自然退出
-  const intervalStub = (fn, ms) => {
-    const timer = setInterval(fn, ms)
-    timer.unref()
-    return () => clearInterval(timer)
-  }
-  // readSession 桩:sessionId → 事件数组(工厂形态则调用后抛错);reads 记录实际读取次数供缓存断言
-  // headers 支持同步或异步函数形态:每次列会话现求值,模拟宿主按产物现状动态列会话;
-  // 数组形态在调用点同步快照(门闩时序测试依赖该语义,禁入 await 链)
-  const readCounts = new Map()
-  const sessionQuery = {
-    listSessions: async () => {
-      if (typeof headers !== 'function') return headers.map((header) => ({ header }))
-      const list = await headers()
-      return list.map((header) => ({ header }))
-    },
-    readSession: async (sessionId) => {
-      readCounts.set(sessionId, (readCounts.get(sessionId) || 0) + 1)
-      const events = readSessions ? readSessions[sessionId] : undefined
-      if (typeof events === 'function') throw events()
-      if (events === undefined) throw new Error('桩未配置该会话产物')
-      const list = typeof headers !== 'function' ? headers : await headers()
-      return { session: list.find((header) => header.id === sessionId), events }
-    },
-  }
-  const services = {
-    webServer: { register: (route) => routes.push(route) },
-    workspaceRegistry: Object.assign(makeRegistry(archivedIds), { list: () => workspaceList }),
-    sessionQuery,
-    storageDomain: {
-      get: (name) => name === 'workspace' ? (domain || undefined) : undefined,
-      open: openRejected ? () => Promise.reject(openRejected) : async () => ledgerDomain,
-    },
-  }
-  const base = {
-    effect: (fn) => fn(),
-    inject: (_deps, fn) => { pendingInjects.push(fn) },
-    // fiber 桩:0.1.7 configure 装配以本条目 fiber 为 owner
-    fiber: { entry: { options: { id: 'session-manager', name: '@mzzsfy/dsh-session-manager' } } },
-    get: (name) => {
-      if (name === 'configEditor') return configEditor
-      return { agents, sessionPersistence, settings: settingsService }[name]
-    },
-    on: (event, handler) => { eventHandlers[event] = handler },
-    // 日志桩:partial 降级点(logger.warn)在测试中可执行且可断言,不再被 undefined 短路
-    logger: { warns: [], warn(message) { this.warns.push(message) }, infos: [], info(message) { this.infos.push(message) } },
-  }
-  const ctx = new Proxy(base, {
-    get(target, prop) {
-      if (typeof prop === 'symbol') return undefined
-      if (prop in target) return target[prop]
-      if (!declaredInject.includes(prop)) {
-        throw new Error(`cannot get property "${String(prop)}" without inject`)
-      }
-      return services[prop]
-    },
-  })
-  apply(ctx, configRef)
-  return {
-    handlers: new Map(routes.map((route) => [route.path, route.handler])),
-    eventHandlers,
-    domain,
-    ledger: ledgerDomain,
-    registry: services.workspaceRegistry,
-    logger: base.logger,
-    readCounts,
-    // 模拟宿主 settings 与 timer 服务激活:触发 inject 回调(注册 + 启动补扫 + 周期武装)
-    activateSettings: () => {
-      const injected = {
-        settings: settingsService,
-        interval: timerAvailable === false ? undefined : intervalStub,
-        // 注入上下文的 effect 桩:0.1.7 分支经它注册 configure 装配
-        effect(fn) {
-          const disposer = fn()
-          if (typeof disposer === 'function') disposers.push(disposer)
-        },
-      }
-      while (pendingInjects.length > 0) pendingInjects.shift()(injected)
-    },
-  }
-}
-
-async function waitFor(predicate) {
-  // performance.now 不受 mock.timers 的 Date 接管影响,周期评估测试中仍可真实计时
-  const deadline = performance.now() + 2000
-  while (performance.now() < deadline) {
-    if (predicate()) return
-    await new Promise((resolve) => setTimeout(resolve, 10))
-  }
-  assert.ok(predicate(), 'waitFor 超时')
-}
-
-function request(sessionId, method = 'POST') {
-  const req = new EventEmitter()
-  req.method = method
-  if (method !== 'GET') {
-    process.nextTick(() => {
-      req.emit('data', Buffer.from(JSON.stringify({ sessionId })))
-      req.emit('end')
-    })
-  }
-  return req
-}
-
-function response() {
-  const state = { status: undefined, body: undefined }
-  state.writeHead = (status) => { state.status = status }
-  state.end = (text) => { state.body = JSON.parse(text) }
-  return state
-}
-
-const HEADER = { id: 's1', cwd: 'C:\\x', createdAt: 0 }
-
-test('inject 声明覆盖路由层触及的全部宿主服务(cordis 未声明即抛 cannot get property)', skipMissingDeps, () => {
-  for (const service of ['webServer', 'workspaceRegistry', 'sessionQuery', 'storageDomain', 'agents', 'sessions', 'sessionPersistence']) {
-    assert.ok(declaredInject.includes(service), `inject 缺少 "${service}"`)
-  }
-})
-
-test('请求体非法 JSON:协议错误与业务错误分通道,不透出引擎 SyntaxError', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [], agents: new Map() })
-  const req = new EventEmitter()
-  req.method = 'POST'
-  process.nextTick(() => {
-    req.emit('data', Buffer.from('{not json'))
-    req.emit('end')
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/unarchive')(req, res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '请求体不是合法 JSON')
-})
-
-test('自动归档评估门闩:评估进行中的新触发被丢弃不排队', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-gate-'))
-  try {
-    const alivePath = path.join(dir, 'alive.jsonl')
-    await writeFile(alivePath, '{"header":1}\n{"event":0}\n')
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(alivePath, stale / 1000, stale / 1000)
-    const cwd = 'C:\\x'
-    const headers = [{ id: 's1', cwd, createdAt: stale }]
-    const { eventHandlers, registry } = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      sessionPersistence: { locate: (header) => ({ path: alivePath }) },
-    })
-    eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
-    // 首轮启动后立即补新候选并连发两触发:首轮候选列表已捕获(s1),门闩正常时
-    // trigger2/3 被丢弃,s2 永不评估;门闩失效则 s2 被归档,断言可见
-    headers.push({ id: 's2', cwd, createdAt: stale })
-    eventHandlers['session/created']({ header: { id: 'trigger2', cwd } })
-    eventHandlers['session/created']({ header: { id: 'trigger3', cwd } })
-    await waitFor(() => registry.archiveCalls.length > 0)
-    // 给在途与迟到轮留完成窗口后断言:仅首轮产出,s2 未被任何一轮归档
-    await new Promise((resolve) => setTimeout(resolve, 150))
-    assert.deepEqual(registry.archiveCalls, ['s1'], '门闩应丢弃在途触发,新候选 s2 不被评估')
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('并发删除:台账串行化不丢条目', skipMissingDeps, async () => {
-  const artifactA = await makeLocatedArtifact('a')
-  const artifactB = await makeLocatedArtifact('b')
-  try {
-    const headers = [
-      { id: 'a', cwd: 'C:\\x', createdAt: 0 },
-      { id: 'b', cwd: 'C:\\x', createdAt: 0 },
-    ]
-    const workspace = makeWorkspace('C:\\x', ['a', 'b'])
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['a', 'b'],
-      headers,
-      agents: new Map([['a', { status: 'idle' }], ['b', { status: 'idle' }]]),
-      domain: makeDomain(['a', 'b']),
-      sessionPersistence: { locate: (header) => header.id === 'a' ? { path: artifactA.locatedPath } : { path: artifactB.locatedPath } },
-      workspaces: [workspace],
-    })
-    const resA = response()
-    const resB = response()
-    await Promise.all([
-      withTrashStub(async () => {}, async () => {
-        await handlers.get('/api/session-manager/delete')(request('a'), resA)
-      }),
-      withTrashStub(async () => {}, async () => {
-        await handlers.get('/api/session-manager/delete')(request('b'), resB)
-      }),
-    ])
-    assert.equal(resA.status, 200)
-    assert.equal(resB.status, 200)
-    // 串行化后两条台账都在;丢失更新会让后写者只剩自己的条目
-    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId).sort(), ['a', 'b'])
-  } finally {
-    await artifactA.cleanup()
-    await artifactB.cleanup()
-  }
-})
-
-test('同 id 并发删除:第二个请求收到 in-flight 提示', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    let releaseTrash
-    const trashGate = new Promise((resolve) => { releaseTrash = resolve })
-    const workspace = makeWorkspace('C:\\x', ['s1'])
-    const { handlers } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      workspaces: [workspace],
-    })
-    const first = response()
-    const firstDone = withTrashStub(async () => { await trashGate }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), first)
-    })
-    // 等 trash 进入挂起后再发第二发
-    await new Promise((resolve) => setTimeout(resolve, 20))
-    const second = response()
-    await handlers.get('/api/session-manager/delete')(request('s1'), second)
-    assert.equal(second.status, 400)
-    assert.equal(second.body.error, '该会话正在删除中,请稍后重试')
-    releaseTrash()
-    await firstDone
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('多工作区 detach:首个失败不终止后续,全部失败进日志', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const broken = makeWorkspace('C:\\one', ['s1'], { detachError: new Error('one boom') })
-    const healthy = makeWorkspace('C:\\two', ['s1'])
-    const { handlers } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      workspaces: [broken, healthy],
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.partial, true)
-    assert.equal(res.body.message, '已移入回收站,但移除列表记录失败')
-    // 健康工作区仍被解除关联
-    assert.deepEqual(healthy.sessionIds, [])
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('取消归档:域领先快照时反向合并清理', skipMissingDeps, async () => {
-  const domain = makeDomain(['s1'])
-  const { handlers, registry } = makeCtx({ archivedIds: [], headers: [HEADER], agents: new Map(), domain })
-  const res = response()
-  await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true })
-  // durable 有而快照无:合并后仍完成移除,防漏清理
-  assert.deepEqual(domain.state.archivedSessionIds, [])
-  assert.equal(domain.writes, 1)
-  assert.deepEqual(registry.state.archivedSessionIds, [])
-})
-
-test('台账 deletedAt 为删除时刻的数值(面板排序依据)', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const before = Date.now()
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    const deletedAt = ledger.state.deleted[0].deletedAt
-    assert.ok(typeof deletedAt === 'number' && deletedAt >= before && deletedAt <= Date.now() + 1000)
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('取消归档路由:从域集合移除目标 id 并写回', skipMissingDeps, async () => {
-  const domain = makeDomain(['s1', 's2'])
-  const { handlers, registry } = makeCtx({ archivedIds: ['s1'], headers: [HEADER], agents: new Map(), domain })
-  const res = response()
-  await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true })
-  assert.deepEqual(domain.state.archivedSessionIds, ['s2'])
-  assert.equal(domain.writes, 1)
-  // 复活守卫:注册表进程内快照必须同步移除,否则官方全量写回与 list 基线会恢复该 id
-  assert.deepEqual(registry.state.archivedSessionIds, ['s2'])
-  assert.deepEqual(registry.archivedSessionIds, ['s2'])
-})
-
-test('取消归档路由:workspace 域未打开时拒绝', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: ['s1'], headers: [HEADER], agents: new Map(), domain: null })
-  const res = response()
-  await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, 'workspace 域未打开')
-})
-
-test('取消归档路由:未归档 id 幂等跳过,不产生写回', skipMissingDeps, async () => {
-  const domain = makeDomain(['s1'])
-  const { handlers, registry } = makeCtx({ archivedIds: ['s1'], headers: [HEADER], agents: new Map(), domain })
-  const res = response()
-  await handlers.get('/api/session-manager/unarchive')(request('s9'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true })
-  assert.deepEqual(domain.state.archivedSessionIds, ['s1'])
-  assert.equal(domain.writes, 0)
-  assert.deepEqual(registry.state.archivedSessionIds, ['s1'])
-})
-
-test('取消归档路由:快照领先域时补全清理(重试路径)', skipMissingDeps, async () => {
-  const domain = makeDomain([])
-  const { handlers, registry } = makeCtx({ archivedIds: ['s1'], headers: [HEADER], agents: new Map(), domain })
-  const res = response()
-  await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true })
-  assert.deepEqual(domain.state.archivedSessionIds, [])
-  assert.equal(domain.writes, 1)
-  assert.deepEqual(registry.state.archivedSessionIds, [])
-})
-
-test('取消归档宽限:恢复后 graceMs 内同进程评估暂停,不秒归档', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-grace-'))
-  try {
-    const artifact = path.join(dir, 's1.jsonl')
-    await writeFile(artifact, '{"header":1}\n{"event":0}\n')
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(artifact, stale / 1000, stale / 1000)
-    const headers = [{ id: 's1', cwd: 'C:\\x', createdAt: stale }]
-    const ctxBundle = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      sessionPersistence: { locate: () => ({ path: artifact }) },
-      domain: makeDomain([]),
-    })
-    const { activateSettings, registry, handlers, eventHandlers } = ctxBundle
-    activateSettings()
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['s1'])
-    // 手动恢复:归档集合移除 + 进程内宽限生效
-    const res = response()
-    await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
-    assert.equal(res.status, 200)
-    assert.deepEqual(registry.state.archivedSessionIds, [])
-    // 宽限内经新会话创建触发评估:同产物仍超期,但不再归档
-    eventHandlers['session/created']({ header: { cwd: 'C:\\x' } })
-    await new Promise((resolve) => setTimeout(resolve, 80))
-    assert.deepEqual(registry.archiveCalls, ['s1'], '宽限期内不得重新归档')
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('info 路由:会话不存在拒绝', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [], agents: new Map() })
-  const res = response()
-  await handlers.get('/api/session-manager/info')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '会话不存在')
-})
-
-test('info 路由:locate 缺失按不支持返回', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [HEADER], agents: new Map() })
-  const res = response()
-  await handlers.get('/api/session-manager/info')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { supported: false })
-})
-
-test('info 路由:产物已缺失按 missing 返回,不裸抛', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/info')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { supported: true, sizeBytes: 0, missing: true })
-})
-
-test('删除路由:运行中会话被守卫拒绝,不触发 locate 与 trash', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: ['s1'],
-    headers: [HEADER],
-    agents: new Map([['s1', { status: 'running' }]]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '运行中的会话不可删除')
-})
-
-test('删除路由:非运行中的已归档会话因 locate 缺失拒绝(守卫未误拦)', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: ['s1'],
-    headers: [HEADER],
-    agents: new Map([['s1', { status: 'idle' }]]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '当前存储后端不支持按会话删除')
-})
-
-test('删除路由:未归档会话拒绝(运行守卫优先于资格)', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map([['s1', { status: 'running' }]]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '运行中的会话不可删除')
-})
-
-test('删除路由:未归档且空闲的会话拒绝', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const { handlers } = makeCtx({
-      archivedIds: [],
-      headers: [HEADER],
-      agents: new Map([['s1', { status: 'idle' }]]),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    assert.equal(res.status, 400)
-    assert.equal(res.body.error, '仅已归档会话可删除')
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('自动归档评估:产物不可读的会话不参与归档(防删除后复活)', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-eval-'))
-  const alivePath = path.join(dir, 'alive.jsonl')
-  await writeFile(alivePath, '{"header":1}\n{"event":0}\n')
-  const DAY_MS = 24 * 60 * 60 * 1000
-  const stale = Date.now() - 30 * DAY_MS
-  await utimes(alivePath, stale / 1000, stale / 1000)
-  const cwd = 'C:\\x'
-  const headers = [
-    { id: 's1', cwd, createdAt: stale },
-    { id: 's2', cwd, createdAt: stale },
-  ]
-  const sessionPersistence = {
-    locate: (header) => header.id === 's1' ? { path: alivePath } : { path: path.join(dir, 'gone.jsonl') },
-  }
-  const { eventHandlers, registry, logger } = makeCtx({
-    archivedIds: [],
-    headers,
-    agents: new Map(),
-    sessionPersistence,
-  })
-  eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
-  await waitFor(() => registry.archiveCalls.length > 0)
-  // s2 产物缺失必须被守卫跳过:否则已删除会话会被重新归档而在面板复活
-  assert.deepEqual(registry.archiveCalls, ['s1'])
-  // 归档成功须落可追溯日志(含会话 id)
-  await waitFor(() => logger.infos.length > 0)
-  assert.ok(logger.infos.some((message) => message.includes('s1')), '归档成功应落 info 日志')
-})
-
-test('自动归档评估:locate 缺失(第三方后端)的会话不参与归档', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-eval-nolocate-'))
-  try {
-    const alivePath = path.join(dir, 'alive.jsonl')
-    await writeFile(alivePath, '{"header":1}\n{"event":0}\n')
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(alivePath, stale / 1000, stale / 1000)
-    const cwd = 'C:\\x'
-    const headers = [
-      { id: 's1', cwd, createdAt: stale },
-      { id: 's2', cwd, createdAt: stale },
-    ]
-    const { eventHandlers, registry } = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      // s2 locate 返回 undefined(抽象后端契约允许):仅凭 createdAt 判活跃会绕过
-      // mtime 保护,与 delete 的 unsupportedBackend 拒绝对齐
-      sessionPersistence: {
-        locate: (header) => header.id === 's1' ? { path: alivePath } : undefined,
-      },
-    })
-    eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['s1'])
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('自动归档评估:subagent 内部会话不参与归档(官方主列表不收录 subagent)', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-eval-subagent-'))
-  try {
-    const plainPath = path.join(dir, 'plain.jsonl')
-    const childPath = path.join(dir, 'child.jsonl')
-    await writeFile(plainPath, '{"header":1}\n{"event":0}\n')
-    await writeFile(childPath, '{"header":1}\n{"event":0}\n')
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(plainPath, stale / 1000, stale / 1000)
-    await utimes(childPath, stale / 1000, stale / 1000)
-    const cwd = 'C:\\x'
-    const headers = [
-      { id: 'plain', cwd, createdAt: stale },
-      { id: 'child', cwd, createdAt: stale, origin: 'subagent', parentSession: 'parent' },
-    ]
-    const { eventHandlers, registry } = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      sessionPersistence: {
-        locate: (header) => ({ path: header.id === 'plain' ? plainPath : childPath }),
-      },
-    })
-    eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['plain'], 'subagent 会话永不入选归档')
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('启动评估:settings 就绪后全量归档超期会话,不限于单工作区', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-startup-'))
-  try {
-    const artifactA = path.join(dir, 'a.jsonl')
-    const artifactB = path.join(dir, 'b.jsonl')
-    await writeFile(artifactA, '{"header":1}\n{"event":0}\n')
-    await writeFile(artifactB, '{"header":1}\n{"event":0}\n')
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(artifactA, stale / 1000, stale / 1000)
-    await utimes(artifactB, stale / 1000, stale / 1000)
-    const headers = [
-      { id: 'a', cwd: 'C:\\x', createdAt: stale },
-      { id: 'b', cwd: 'C:\\y', createdAt: stale },
-    ]
-    const { activateSettings, registry, handlers } = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      sessionPersistence: {
-        locate: (header) => ({ path: header.id === 'a' ? artifactA : artifactB }),
-      },
-    })
-    activateSettings()
-    await waitFor(() => registry.archiveCalls.length >= 2)
-    assert.deepEqual([...registry.archiveCalls].sort(), ['a', 'b'])
-    const status = response()
-    await handlers.get('/api/session-manager/status')(request('x', 'GET'), status)
-    assert.equal(status.status, 200)
-    assert.equal(status.body.periodic.running, true)
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('启动评估:autoArchiveDays=0 时不评估', skipMissingDeps, async () => {
-  const { activateSettings, registry } = makeCtx({
-    archivedIds: [],
-    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-    agents: new Map(),
-    settingsValue: { autoArchiveDays: 0 },
-  })
-  activateSettings()
-  await new Promise((resolve) => setTimeout(resolve, 50))
-  assert.deepEqual(registry.archiveCalls, [])
-})
-
-test('周期评估:每日定时补扫首轮不可评估的会话', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-period-'))
-  // 夹具 mtime 用真实时钟落盘,之后接管 Date 与 setInterval:到期判断(nextDueAt)
-  // 与定时器触发共用同一虚拟时钟,tick 推进 24h 即触发周期轮
-  const artifactA = path.join(dir, 'a.jsonl')
-  const artifactB = path.join(dir, 'b.jsonl')
-  await writeFile(artifactA, '{"header":1}\n{"event":0}\n')
-  await writeFile(artifactB, '{"header":1}\n{"event":0}\n')
-  const DAY_MS = 24 * 60 * 60 * 1000
-  const realNow = Date.now()
-  const stale = realNow - 30 * DAY_MS
-  await utimes(artifactA, stale / 1000, stale / 1000)
-  await utimes(artifactB, stale / 1000, stale / 1000)
-  // 显式传 now:mock.timers 接管 Date 后从 epoch 0 起算,不传则夹具时间戳全成「未来」
-  mock.timers.enable({ apis: ['setInterval', 'Date'], now: realNow })
-  try {
-    // 首轮 b 产物不可读(守卫跳过),周期轮起可读:b 只能经周期评估归档
-    let bReadable = false
-    const { activateSettings, registry } = makeCtx({
-      archivedIds: [],
-      headers: [
-        { id: 'a', cwd: 'C:\\x', createdAt: stale },
-        { id: 'b', cwd: 'C:\\x', createdAt: stale },
-      ],
-      agents: new Map(),
-      sessionPersistence: {
-        locate: (header) => (header.id === 'b' && !bReadable)
-          ? { path: path.join(dir, 'gone.jsonl') }
-          : { path: header.id === 'a' ? artifactA : artifactB },
-      },
-    })
-    activateSettings()
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['a'])
-    bReadable = true
-    mock.timers.tick(DAY_MS)
-    await waitFor(() => registry.archiveCalls.includes('b'))
-    // 桩回写 archivedSessionIds(真实注册表契约):已归档 a 不被周期轮重复选中
-    assert.deepEqual(registry.archiveCalls, ['a', 'b'])
-  } finally {
-    mock.timers.reset()
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('周期评估:autoArchiveDays=0 时不评估', skipMissingDeps, async () => {
-  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
-  try {
-    const { activateSettings, registry } = makeCtx({
-      archivedIds: [],
-      headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-      agents: new Map(),
-      settingsValue: { autoArchiveDays: 0 },
-    })
-    activateSettings()
-    mock.timers.tick(24 * 60 * 60 * 1000)
-    await new Promise((resolve) => setTimeout(resolve, 50))
-    assert.deepEqual(registry.archiveCalls, [])
-  } finally {
-    mock.timers.reset()
-  }
-})
-
-test('周期评估:间隔设置运行时变更经 tick 对账(0 重启用 / 关闭即时暂停)', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-rearm-'))
-  // settings 桩返回同一对象引用:测试中改字段即模拟用户运行时改设置
-  const settingsValue = { autoArchiveIntervalHours: 0 }
-  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
-  try {
-    const artifacts = {}
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const TICK_MS = 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    const readable = { s1: true, s2: false, s3: false }
-    for (const id of ['s1', 's2', 's3']) {
-      const artifact = path.join(dir, id + '.jsonl')
-      await writeFile(artifact, '{"header":1}\n{"event":0}\n')
-      await utimes(artifact, stale / 1000, stale / 1000)
-      artifacts[id] = artifact
-    }
-    const headers = [
-      { id: 's1', cwd: 'C:\\x', createdAt: stale },
-      { id: 's2', cwd: 'C:\\x', createdAt: stale },
-      { id: 's3', cwd: 'C:\\x', createdAt: stale },
-    ]
-    const { activateSettings, registry } = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      settingsValue,
-      sessionPersistence: {
-        locate: (header) => ({ path: readable[header.id] ? artifacts[header.id] : path.join(dir, 'gone-' + header.id) }),
-      },
-    })
-    activateSettings()
-    // 启动补扫只看 autoArchiveDays(默认 7),intervalHours=0 不影响首轮
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['s1'])
-    // intervalHours=0 期间周期轮保持关闭:到期也不评估
-    readable.s2 = true
-    mock.timers.tick(DAY_MS)
-    await new Promise((resolve) => setTimeout(resolve, 50))
-    assert.deepEqual(registry.archiveCalls, ['s1'], '关闭状态下到期不得评估')
-    // 0 重启用:缺失 due 经 tick 对账补排,最迟下个 tick 恢复周期轮
-    settingsValue.autoArchiveIntervalHours = 24
-    mock.timers.tick(TICK_MS)
-    await waitFor(() => registry.archiveCalls.includes('s2'))
-    assert.deepEqual(registry.archiveCalls, ['s1', 's2'])
-    // 再次关闭:即时暂停,s3 不被评估
-    readable.s3 = true
-    settingsValue.autoArchiveIntervalHours = 0
-    mock.timers.tick(DAY_MS)
-    await new Promise((resolve) => setTimeout(resolve, 50))
-    assert.deepEqual(registry.archiveCalls, ['s1', 's2'], '再次关闭后到期不得评估')
-    // 第三次重启用:对账恢复,归档 s3
-    settingsValue.autoArchiveIntervalHours = 24
-    mock.timers.tick(TICK_MS)
-    await waitFor(() => registry.archiveCalls.includes('s3'))
-    assert.deepEqual(registry.archiveCalls, ['s1', 's2', 's3'])
-  } finally {
-    mock.timers.reset()
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('settings 方法面缺失(0.1.7 SettingsForms 形态):tick 与 status 路由不抛错,配置回落默认', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-methodface-'))
-  // 宿主 0.1.7-alpha.1 将 settings 服务换形为 SettingsForms:缺 get/register,仅剩 update。
-  // 旧形态直接 settings.get 会在 timer 回调抛 TypeError 崩进程(实测事故),守卫后应回落默认值
-  const DAY_MS = 24 * 60 * 60 * 1000
-  const TICK_MS = 60 * 1000
-  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
-  try {
-    const artifact = path.join(dir, 'a.jsonl')
-    await writeFile(artifact, '{"header":1}\n{"event":0}\n')
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(artifact, stale / 1000, stale / 1000)
-    const settingsForms = { update: async () => {} }
-    const { activateSettings, handlers, registry } = makeCtx({
-      archivedIds: [],
-      headers: [{ id: 'a', cwd: 'C:\\x', createdAt: stale }],
-      agents: new Map(),
-      settingsService: settingsForms,
-      sessionPersistence: { locate: () => ({ path: artifact }) },
-    })
-    activateSettings()
-    // 守卫生效:配置读不到回落默认(days=7,intervalHours=24),30 天超期夹具到期即按默认轮归档
-    mock.timers.tick(DAY_MS + TICK_MS)
-    await waitFor(() => registry.archiveCalls.includes('a'))
-    assert.deepEqual(registry.archiveCalls, ['a'], '配置缺失按默认间隔正常评估,不因服务形变停摆')
-    // status 路由读设置不抛:回默认 days/intervalHours
-    const statusHandler = handlers.get('/api/session-manager/status')
-    const res = response()
-    await statusHandler(request('s1', 'GET'), res)
-    assert.equal(res.status, 200)
-  } finally {
-    mock.timers.reset()
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('周期评估:缩短间隔经 earliest 钳制前移,不等满旧周期', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-shorten-'))
-  const TICK_MS = 60 * 1000
-  const HOUR_MS = 60 * 60 * 1000
-  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
-  try {
-    const readable = { a: true, b: false }
-    const artifacts = {}
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    for (const id of ['a', 'b']) {
-      const artifact = path.join(dir, id + '.jsonl')
-      await writeFile(artifact, '{"header":1}\n{"event":0}\n')
-      await utimes(artifact, stale / 1000, stale / 1000)
-      artifacts[id] = artifact
-    }
-    const settingsValue = { autoArchiveIntervalHours: 24 }
-    const { activateSettings, registry } = makeCtx({
-      archivedIds: [],
-      headers: [
-        { id: 'a', cwd: 'C:\\x', createdAt: stale },
-        { id: 'b', cwd: 'C:\\x', createdAt: stale },
-      ],
-      agents: new Map(),
-      settingsValue,
-      sessionPersistence: {
-        locate: (header) => readable[header.id] ? { path: artifacts[header.id] } : { path: path.join(dir, 'gone-' + header.id) },
-      },
-    })
-    activateSettings()
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['a'])
-    const afterStartup = registry.archiveCalls.length
-    // T+24h 到期轮(a 已归档无产出);紧接缩短为 1h:earliest 钳制应把 due 前移到
-    // 缩短时刻 + 1h,而非等满旧周期 T+48h;b 在缩短后变可读,由前移后的轮归档
-    mock.timers.tick(DAY_MS)
-    settingsValue.autoArchiveIntervalHours = 1
-    readable.b = true
-    mock.timers.tick(DAY_MS + TICK_MS)
-    await waitFor(() => registry.archiveCalls.length > afterStartup)
-    assert.deepEqual(registry.archiveCalls, ['a', 'b'])
-  } finally {
-    mock.timers.reset()
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('定时服务缺失:周期评估降级,状态接口提示且不影响启动补扫', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-degrade-'))
-  try {
-    const artifact = path.join(dir, 'a.jsonl')
-    await writeFile(artifact, '{"header":1}\n{"event":0}\n')
-    const DAY_MS = 24 * 60 * 60 * 1000
-    const stale = Date.now() - 30 * DAY_MS
-    await utimes(artifact, stale / 1000, stale / 1000)
-    const { activateSettings, handlers, registry } = makeCtx({
-      archivedIds: [],
-      headers: [{ id: 'a', cwd: 'C:\\x', createdAt: stale }],
-      agents: new Map(),
-      sessionPersistence: { locate: () => ({ path: artifact }) },
-      timerAvailable: false,
-    })
-    activateSettings()
-    // 启动补扫照常工作:软依赖缺失只影响周期轮
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['a'])
-    const status = response()
-    await handlers.get('/api/session-manager/status')(request('x', 'GET'), status)
-    assert.equal(status.status, 200)
-    assert.equal(status.body.periodic.running, false)
-    assert.notEqual(status.body.periodic.reason, '')
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('周期评估:到期 tick 恰逢门闩占用时保持到期态,下个 tick 重试而非推后一个周期', skipMissingDeps, async () => {
-  const dir = await mkdtemp(path.join(tmpdir(), 'sm-gate-tick-'))
-  const TICK_MS = 60 * 1000
-  const DAY_MS = 24 * 60 * 60 * 1000
-  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
-  try {
-    const readable = { a: true, b: false, c: false }
-    const artifacts = {}
-    const stale = Date.now() - 30 * DAY_MS
-    for (const id of ['a', 'b', 'c']) {
-      const artifact = path.join(dir, id + '.jsonl')
-      await writeFile(artifact, '{"header":1}\n{"event":0}\n')
-      await utimes(artifact, stale / 1000, stale / 1000)
-      artifacts[id] = artifact
-    }
-    const headers = [
-      { id: 'a', cwd: 'C:\\x', createdAt: stale },
-      { id: 'b', cwd: 'C:\\x', createdAt: stale },
-      { id: 'c', cwd: 'C:\\x', createdAt: stale },
-    ]
-    const { activateSettings, eventHandlers, registry } = makeCtx({
-      archivedIds: [],
-      headers,
-      agents: new Map(),
-      sessionPersistence: {
-        locate: (header) => readable[header.id] ? { path: artifacts[header.id] } : { path: path.join(dir, 'gone-' + header.id) },
-      },
-    })
-    activateSettings()
-    // 启动补扫:a 归档(桩回写 archived),b/c 不可读留候选
-    await waitFor(() => registry.archiveCalls.length > 0)
-    assert.deepEqual(registry.archiveCalls, ['a'])
-    // 挂起归档执行器,再触发一轮评估:门闩被占
-    let releaseArchive
-    const held = new Promise((resolve) => { releaseArchive = resolve })
-    const originalArchive = registry.archiveSession
-    let archiveArrived = false
-    registry.archiveSession = async (id) => {
-      archiveArrived = true
-      await held
-      await originalArchive(id)
-    }
-    readable.b = true
-    eventHandlers['session/created']({ header: headers[1] })
-    await waitFor(() => archiveArrived)
-    assert.deepEqual(registry.archiveCalls, ['a'], '挂起的 b 尚未计入归档调用')
-    // 到期 tick 恰逢门闩占用:被丢弃,不得把周期推后 24h(保持到期态)
-    mock.timers.tick(DAY_MS)
-    // 释放挂起评估并让出事件循环,确保门闩复位(evaluating=false)落定
-    releaseArchive()
-    await new Promise((resolve) => setImmediate(resolve))
-    await new Promise((resolve) => setTimeout(resolve, 0))
-    // c 变可读,60s 后的下个 tick 即应重试并归档 c(若周期被推后 24h 此步超时)
-    readable.c = true
-    mock.timers.tick(TICK_MS)
-    await waitFor(() => registry.archiveCalls.includes('c'))
-    assert.deepEqual(registry.archiveCalls, ['a', 'b', 'c'])
-  } finally {
-    mock.timers.reset()
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-// 执行器桩替:trash 与回收区搬移为进程级 OS 副作用出口,经 executor 注册表注入
-async function withExecutorStub(stubs, run) {
-  const originals = {}
-  for (const [name, stub] of Object.entries(stubs)) {
-    originals[name] = indexModule.executor[name]
-    indexModule.executor[name] = stub
-  }
-  try {
-    await run()
-  } finally {
-    for (const [name, original] of Object.entries(originals)) indexModule.executor[name] = original
-  }
-}
-
-async function withTrashStub(stub, run) {
-  await withExecutorStub({ trashPath: stub }, run)
-}
-
-const IDLE_S1 = new Map([['s1', { status: 'idle' }]])
-
-// locate 契约实证:返回会话目录下的日志文件;stat 为真实 fs,产物以临时文件承载
-async function makeLocatedArtifact(sessionId = 's1') {
-  const root = await mkdtemp(path.join(tmpdir(), 'sm-del-'))
-  const locatedDir = path.join(root, sessionId)
-  const locatedPath = path.join(locatedDir, 'session.jsonl.zstd')
-  await mkdir(locatedDir, { recursive: true })
-  await writeFile(locatedPath, 'log-bytes')
-  return {
-    locatedDir,
-    locatedPath,
-    cleanup: () => rm(root, { recursive: true, force: true }),
-  }
-}
-
-test('删除成功:trash 目标为会话目录,台账记录目录路径', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const domain = makeDomain(['s1'])
-    const workspace = makeWorkspace('C:\\x', ['s1'])
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain,
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      workspaces: [workspace],
-    })
-    const trashed = []
-    const res = response()
-    await withTrashStub(async (p) => { trashed.push(p) }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.deepEqual(res.body, { ok: true, mode: 'os' })
-    // locate 给的是日志文件,trash 必须上移到会话目录,否则残留空目录
-    assert.deepEqual(trashed, [artifact.locatedDir])
-    assert.equal(ledger.state.deleted.length, 1)
-    assert.equal(ledger.state.deleted[0].sessionId, 's1')
-    assert.equal(ledger.state.deleted[0].path, artifact.locatedDir)
-    assert.deepEqual(domain.state.archivedSessionIds, [])
-    assert.deepEqual(workspace.sessionIds, [])
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('删除成功:同 id 残留台账被替换,无重复条目', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      ledger: makeLedgerDomain([{ sessionId: 's1', path: 'old', deletedAt: 1 }]),
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.deepEqual(res.body, { ok: true, mode: 'os' })
-    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s1'])
-    assert.equal(ledger.state.deleted[0].path, artifact.locatedDir)
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-// Given 系统回收站不可用(trash 抛错), When 删除, Then 产物降级搬入插件回收区,
-// 台账记录暂存路径 heldPath,响应 mode=quarantine
-test('删除:系统回收站不可用时降级搬入插件回收区,台账记录暂存路径', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    await withExecutorStub({ trashPath: async () => { throw new Error('gio: not found') } }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.ok, true)
-    assert.equal(res.body.mode, 'quarantine')
-    const entry = ledger.state.deleted[0]
-    assert.equal(entry.sessionId, 's1')
-    assert.equal(entry.path, artifact.locatedDir, '台账 path 仍为原位置,移回时使用')
-    assert.ok(entry.heldPath && entry.heldPath.startsWith(process.env.DSH_QUARANTINE_DIR), '台账记录回收区暂存路径')
-    await assert.rejects(access(artifact.locatedDir), '原位置产物应已搬走')
-    const held = await readFile(path.join(entry.heldPath, 'session.jsonl.zstd'), 'utf8')
-    assert.equal(held, 'log-bytes')
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-// Given 回收站与回收区均不可用, When 删除, Then 400 且台账不写(会话未被删除)
-test('删除:回收站与回收区均失败时拒绝且台账不写', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    await withExecutorStub({
-      trashPath: async () => { throw new Error('gio: not found') },
-      moveToQuarantine: async () => { throw new Error('read-only volume') },
-    }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 400)
-    assert.ok(res.body.error.startsWith(MESSAGES.trashFailed) && res.body.error.includes('均不可用'), '双失败文案区分两级')
-    assert.deepEqual(ledger.state.deleted, [])
-    // 双失败产物原地保留
-    await access(artifact.locatedDir)
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('删除:产物已缺失时跳过 trash 与台账,完成列表清理(同 id 重删场景)', skipMissingDeps, async () => {
-  const domain = makeDomain([])
-  const workspace = makeWorkspace('C:\\x', ['s1'])
-  const { handlers, ledger } = makeCtx({
-    // 幽灵会话已不在归档集合:残留清理不要求归档资格,但要求台账有记录
-    // (首删已记录,重删走幽灵收尾)
-    archivedIds: [],
-    headers: [HEADER],
-    agents: IDLE_S1,
-    domain,
-    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: GHOST_DIR, deletedAt: 1 }]),
-    workspaces: [workspace],
-  })
-  const trashed = []
-  const res = response()
-  await withTrashStub(async (p) => { trashed.push(p) }, async () => {
-    await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  })
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true, message: MESSAGES.ghostCleanup })
-  assert.deepEqual(trashed, [])
-  assert.equal(ledger.writes, 0)
-  // 残留清理仍解除工作区关联与归档集合(幂等)
-  assert.deepEqual(workspace.sessionIds, [])
-  assert.deepEqual(domain.state.archivedSessionIds, [])
-})
-
-test('删除:产物缺失且无归档记录无台账时拒绝(防新建会话未落盘被剥离)', skipMissingDeps, async () => {
-  const workspace = makeWorkspace('C:\\x', ['s1'])
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: IDLE_S1,
-    domain: makeDomain([]),
-    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
-    workspaces: [workspace],
-  })
-  const res = response()
-  await withTrashStub(async () => {}, async () => {
-    await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  })
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, MESSAGES.notArchived)
-  // 拒绝路径不动工作区关联
-  assert.deepEqual(workspace.sessionIds, ['s1'])
-})
-
-test('删除:产物已缺失时运行中守卫仍然生效', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map([['s1', { status: 'running' }]]),
-    domain: makeDomain([]),
-    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
-  })
-  const res = response()
-  await withTrashStub(async () => {}, async () => {
-    await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  })
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, MESSAGES.running)
-})
-
-test('删除:产物已缺失且清理半失败时聚合失败点', skipMissingDeps, async () => {
-  const workspace = makeWorkspace('C:\\x', ['s1'], { detachError: new Error('detach boom') })
-  const { handlers, logger } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: IDLE_S1,
-    domain: null,
-    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: GHOST_DIR, deletedAt: 1 }]),
-    workspaces: [workspace],
-  })
-  const res = response()
-  await withTrashStub(async () => {}, async () => {
-    await handlers.get('/api/session-manager/delete')(request('s1'), res)
-  })
-  assert.equal(res.status, 200)
-  assert.equal(res.body.partial, true)
-  assert.equal(res.body.message, '产物已不存在,但移除列表记录失败,且移除归档记录失败')
-  // 幽灵清理半失败:原始错误进服务端日志(排障契约),响应文案保持摘要
-  assert.ok(logger.warns.some((message) => message.includes('s1') && message.includes('detach boom')), '幽灵 detach 失败应落日志')
-})
-
-// Given 回收窗口内会话恢复运行(runningDuringTrash), When 聚合, Then 警告形态且无 partial 键
-test('删除:回收窗口内会话恢复运行,响应警告形态且无 partial 键', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const agents = new Map([['s1', { status: 'idle' }]])
-    const { handlers } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    // trash 桩内翻转运行态:模拟 OS 回收异步窗口内的执行期翻转
-    await withTrashStub(async () => { agents.set('s1', { status: 'running' }) }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    // 全成功警告态:{ok,message,mode} 形态,无 partial 键
-    assert.deepEqual(res.body, { ok: true, mode: 'os', message: DELETE_MESSAGES.runningDuringTrash })
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('归档评估:超期运行中会话零产物 IO(早退,core 过滤为第二道防线)', skipMissingDeps, async () => {
-  const stale = Date.now() - 30 * 24 * 60 * 60 * 1000
-  let locateCalls = 0
-  const { activateSettings, registry } = makeCtx({
-    archivedIds: [],
-    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: stale }],
-    agents: new Map([['s1', { status: 'running' }]]),
-    sessionPersistence: {
-      locate: (header) => {
-        locateCalls += 1
-        return { path: 'C:\\x\\s1\\session.jsonl.zstd' }
-      },
-    },
-  })
-  // 历史启动对齐(运行中会话即时路径)也走 locate:等它跑完并清零计数,
-  // 此后断言只针对归档评估的产物 IO
-  await new Promise((resolve) => setTimeout(resolve, 30))
-  locateCalls = 0
-  activateSettings()
-  // 等评估轮跑完(正常会话路径必然触达 locate):running 会话不得产生 locate 调用
-  await new Promise((resolve) => setTimeout(resolve, 250))
-  assert.equal(locateCalls, 0, '运行中会话应在产物 IO 前早退')
-  assert.deepEqual(registry.archiveCalls, [])
-})
-
-test('删除:workspace 域未打开时归档清理失败,响应 partial 且台账已记录', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const { handlers, ledger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: null,
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.partial, true)
-    assert.equal(res.body.message, '已移入回收站,但移除归档记录失败')
-    // detach 已完成、台账已记录:仅归档集合清理半失败
-    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s1'])
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('删除:detach 与台账同时失败时,partial 消息聚合两个失败点', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const brokenLedger = makeLedgerDomain([])
-    brokenLedger.global.set = async () => { throw new Error('medium broken') }
-    const workspace = makeWorkspace('C:\\x', ['s1'], { detachError: new Error('detach boom') })
-    const { handlers, logger } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      ledger: brokenLedger,
-      workspaces: [workspace],
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.partial, true)
-    assert.equal(res.body.message, '已移入回收站,但移除列表记录失败,且重挂载记录失败')
-    // 台账与 detach 的原始错误均进服务端日志
-    assert.ok(logger.warns.some((message) => message.includes('s1') && message.includes('medium broken')), '台账失败应落日志')
-    assert.ok(logger.warns.some((message) => message.includes('s1') && message.includes('detach boom')), 'detach 失败应落日志')
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-// (旧「trash 失败整体中止」语义已被回收区降级取代:单 trash 失败见降级用例,
-// 双失败中止见「回收站与回收区均失败时拒绝且台账不写」)
-
-test('台账域打开失败:删除其余成功仍响应 partial', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const domain = makeDomain(['s1'])
-    const { handlers } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain,
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      openRejected: new Error('ledger down'),
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.partial, true)
-    assert.equal(res.body.message, '已移入回收站,但重挂载记录失败')
-    // 台账失败不阻断删除主链路:归档清理照常完成
-    assert.deepEqual(domain.state.archivedSessionIds, [])
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('台账写入失败:删除其余成功仍响应 partial', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const brokenLedger = makeLedgerDomain([])
-    brokenLedger.global.set = async () => { throw new Error('medium broken') }
-    const { handlers } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-      ledger: brokenLedger,
-    })
-    const res = response()
-    await withTrashStub(async () => {}, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.partial, true)
-    assert.equal(res.body.message, '已移入回收站,但重挂载记录失败')
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-test('已删除列表:GET 按存储序全量返回', skipMissingDeps, async () => {
-  const entries = [
-    { sessionId: 's2', path: 'p2', deletedAt: 2 },
-    { sessionId: 's1', path: 'p1', deletedAt: 1 },
-  ]
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [],
-    agents: new Map(),
-    ledger: makeLedgerDomain(entries),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/deleted')(request('x', 'GET'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { deleted: entries })
-})
-
-test('已删除列表:非 GET 拒绝', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [], agents: new Map() })
-  const res = response()
-  await handlers.get('/api/session-manager/deleted')(request('s1'), res)
-  assert.equal(res.status, 405)
-})
-
-test('已删除列表:台账域打开失败拒绝', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [],
-    agents: new Map(),
-    openRejected: new Error('ledger down'),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/deleted')(request('x', 'GET'), res)
-  assert.equal(res.status, 400)
-})
-
-test('重挂载:产物已还原时经官方 attachSession 挂回并清除台账', skipMissingDeps, async () => {
-  const workspace = makeWorkspace('C:\\x', [])
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    workspaces: [workspace],
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true })
-  assert.deepEqual(workspace.attachCalls, ['s1'])
-  assert.deepEqual(workspace.sessionIds, ['s1'])
-  assert.deepEqual(ledger.state.deleted, [])
-  assert.equal(ledger.writes, 1)
-})
-
-test('重挂载:产物未还原(持久层无 header)拒绝', skipMissingDeps, async () => {
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [],
-    agents: new Map(),
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '会话产物不在持久层,请先到系统回收站还原后重试')
-  // 拒绝路径不动台账
-  assert.equal(ledger.writes, 0)
-})
-
-// Given 回收区暂存条目(heldPath)且产物在暂存处, When 重挂载, Then 先移回原位置再挂载,
-// 会话列表随产物回位而可见(动态 headers 模拟宿主按产物现状列会话),台账清除
-test('重挂载:回收区暂存条目自动移回原位置后挂载成功', skipMissingDeps, async () => {
-  const base = await mkdtemp(path.join(tmpdir(), 'sm-held-'))
-  const originalDir = path.join(base, 's1')
-  const locatedPath = path.join(originalDir, 'session.jsonl.zstd')
-  const workspace = makeWorkspace('C:\\x', [])
-  try {
-    await mkdir(originalDir, { recursive: true })
-    await writeFile(locatedPath, 'log-bytes')
-    const { moveToQuarantine } = await import('../src/trash.mjs')
-    const heldPath = await moveToQuarantine(originalDir, path.join(base, 'held'))
-    await access(originalDir).then(() => { throw new Error('夹具前置失败:原位置应已空') }, () => {})
-    const { handlers, ledger } = makeCtx({
-      archivedIds: [],
-      // 宿主按产物现状列会话:移回前不可见,移回后可见
-      headers: async () => ((await access(locatedPath).then(() => true, () => false)) ? [HEADER] : []),
-      agents: new Map(),
-      workspaces: [workspace],
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: locatedPath } : undefined },
-      ledger: makeLedgerDomain([{ sessionId: 's1', path: originalDir, heldPath, deletedAt: 1 }]),
-    })
-    const res = response()
-    await handlers.get('/api/session-manager/remount')(request('s1'), res)
-    assert.equal(res.status, 200)
-    assert.deepEqual(res.body, { ok: true })
-    assert.deepEqual(workspace.attachCalls, ['s1'])
-    assert.deepEqual(ledger.state.deleted, [])
-    // 产物已回到原位置,暂存消失
-    const restored = await readFile(locatedPath, 'utf8')
-    assert.equal(restored, 'log-bytes')
-    await assert.rejects(access(heldPath))
-  } finally {
-    await rm(base, { recursive: true, force: true })
-  }
-})
-
-// Given 回收区暂存条目但暂存已缺失(原位置同样缺失), When 重挂载, Then 专属文案拒绝
-test('重挂载:回收区暂存缺失时拒绝且不动台账', skipMissingDeps, async () => {
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [],
-    agents: new Map(),
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: path.join(tmpdir(), 'sm-gone-original', 's1'), heldPath: path.join(tmpdir(), 'sm-gone-held', 's1-1'), deletedAt: 1 }]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, MESSAGES.heldMissing)
-  assert.equal(ledger.writes, 0)
-})
-
-// Given 回收区暂存条目且原位置产物已被手工还原, When 重挂载, Then 跳过移回直接挂载,暂存保留
-test('重挂载:原位置已有产物时跳过移回(手工还原场景)', skipMissingDeps, async () => {
-  const base = await mkdtemp(path.join(tmpdir(), 'sm-skip-held-'))
-  const originalDir = path.join(base, 's1')
-  const locatedPath = path.join(originalDir, 'session.jsonl.zstd')
-  try {
-    await mkdir(originalDir, { recursive: true })
-    await writeFile(locatedPath, 'restored-by-hand')
-    const heldPath = path.join(base, 'held', 's1-123')
-    await mkdir(heldPath, { recursive: true })
-    await writeFile(path.join(heldPath, 'session.jsonl.zstd'), 'held-copy')
-    const workspace = makeWorkspace('C:\\x', [])
-    const { handlers, ledger } = makeCtx({
-      archivedIds: [],
-      headers: [HEADER],
-      agents: new Map(),
-      workspaces: [workspace],
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: locatedPath } : undefined },
-      ledger: makeLedgerDomain([{ sessionId: 's1', path: originalDir, heldPath, deletedAt: 1 }]),
-    })
-    const res = response()
-    await handlers.get('/api/session-manager/remount')(request('s1'), res)
-    assert.equal(res.status, 200)
-    assert.deepEqual(res.body, { ok: true })
-    assert.deepEqual(workspace.attachCalls, ['s1'])
-    assert.deepEqual(ledger.state.deleted, [])
-    // 原位置内容未被覆盖,暂存目录按已知取舍保留(孤儿清理不做)
-    assert.equal(await readFile(locatedPath, 'utf8'), 'restored-by-hand')
-    await access(heldPath)
-  } finally {
-    await rm(base, { recursive: true, force: true })
-  }
-})
-
-// Given quarantine 降级成功但 detach 失败, When 删除, Then partial 主文案为回收区前缀且 mode=quarantine
-test('删除:回收区降级加 detach 失败聚合为回收区前缀 partial', skipMissingDeps, async () => {
-  const artifact = await makeLocatedArtifact()
-  try {
-    const workspace = makeWorkspace('C:\\x', ['s1'], { detachError: new Error('detach 失败') })
-    const { handlers } = makeCtx({
-      archivedIds: ['s1'],
-      headers: [HEADER],
-      agents: IDLE_S1,
-      domain: makeDomain(['s1']),
-      workspaces: [workspace],
-      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
-    })
-    const res = response()
-    await withExecutorStub({ trashPath: async () => { throw new Error('gio: not found') } }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 200)
-    assert.equal(res.body.partial, true)
-    assert.equal(res.body.mode, 'quarantine')
-    assert.ok(res.body.message.startsWith('已移入插件回收区'), 'partial 主文案为回收区前缀')
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-// Given 台账域打开失败, When 重挂载, Then 入口即拒绝(移回依据不可得,不做静默跳过)
-test('重挂载:台账域打开失败时入口拒绝', skipMissingDeps, async () => {
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    openRejected: new Error('ledger down'),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, MESSAGES.systemError)
-  assert.equal(ledger.writes, 0)
-})
-
-test('重挂载:找不到所属工作区拒绝', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    workspaces: [makeWorkspace('C:\\other', [])],
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.equal(res.body.error, '未找到会话所属工作区,无法重新挂载')
-})
-
-test('重挂载:attachSession 失败时拒绝且台账保留', skipMissingDeps, async () => {
-  const workspace = makeWorkspace('C:\\x', [], { attachError: new Error('cwd 消失') })
-  const entries = [{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    workspaces: [workspace],
-    ledger: makeLedgerDomain(entries),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 400)
-  assert.match(res.body.error, /cwd 消失/)
-  assert.deepEqual(ledger.state.deleted, entries)
-  assert.equal(ledger.writes, 0)
-})
-
-test('重挂载:会话已在工作区时幂等收尾(残留条目重试无副作用)', skipMissingDeps, async () => {
-  const workspace = makeWorkspace('C:\\x', ['s1'])
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    workspaces: [workspace],
-    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.deepEqual(res.body, { ok: true })
-  // 官方契约:id 已在 sessionIds 中,挂载幂等无重复
-  assert.deepEqual(workspace.sessionIds, ['s1'])
-  assert.deepEqual(ledger.state.deleted, [])
-})
-
-test('重挂载:挂载成功但台账清除失败时响应 partial', skipMissingDeps, async () => {
-  const workspace = makeWorkspace('C:\\x', [])
-  const brokenLedger = makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }])
-  brokenLedger.global.set = async () => { throw new Error('medium broken') }
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [HEADER],
-    agents: new Map(),
-    workspaces: [workspace],
-    ledger: brokenLedger,
-  })
-  const res = response()
-  await handlers.get('/api/session-manager/remount')(request('s1'), res)
-  assert.equal(res.status, 200)
-  assert.equal(res.body.partial, true)
-  assert.equal(res.body.message, '已重新挂载,但清除台账记录失败;可在「已删除」区移除记录收尾')
-  assert.deepEqual(workspace.attachCalls, ['s1'])
-})
-
-test('移除记录:命中删除,未命中幂等无写', skipMissingDeps, async () => {
-  const entries = [
-    { sessionId: 's1', path: 'p1', deletedAt: 1 },
-    { sessionId: 's2', path: 'p2', deletedAt: 2 },
-  ]
-  const { handlers, ledger } = makeCtx({
-    archivedIds: [],
-    headers: [],
-    agents: new Map(),
-    ledger: makeLedgerDomain(entries),
-  })
-  const hit = response()
-  await handlers.get('/api/session-manager/forget')(request('s1'), hit)
-  assert.equal(hit.status, 200)
-  assert.deepEqual(hit.body, { ok: true })
-  assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s2'])
-  assert.equal(ledger.writes, 1)
-  const miss = response()
-  await handlers.get('/api/session-manager/forget')(request('s9'), miss)
-  assert.equal(miss.status, 200)
-  assert.equal(ledger.writes, 1)
-})
-
-// ── 自动归档配置 ──
-
-// GET 夹具:任意 URL 的 GET 请求
-function getRequest2(url, method) {
-  const req = new EventEmitter()
-  req.method = method
-  req.url = url
-  return req
-}
-
-// POST 夹具:请求体走 readBody 的 data/end 事件流,handler 按路径查找
-async function postJson(handlers, routePath, body) {
-  const req = new EventEmitter()
-  req.method = 'POST'
-  req.url = routePath
-  const res = response()
-  const done = handlers.get(routePath)(req, res)
-  req.emit('data', Buffer.from(JSON.stringify(body), 'utf8'))
-  req.emit('end')
-  await done
-  return res
-}
-
-test('自动归档配置:GET 回显生效值(未配置回默认),POST 持久,GET 反映新值', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
-  const initial = response()
-  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), initial)
-  assert.deepEqual(initial.body, { days: DEFAULT_AUTO_ARCHIVE_DAYS, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS }, '未配置时回显默认值')
-  const changed = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3, intervalHours: 12 })
-  assert.deepEqual(changed.body, { days: 3, intervalHours: 12 })
-  const reread = response()
-  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), reread)
-  assert.deepEqual(reread.body, { days: 3, intervalHours: 12 }, 'settings 持久化新值')
-})
-
-test('自动归档配置:单字段部分更新,未提交字段保持不变', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
-  const onlyDays = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3 })
-  assert.deepEqual(onlyDays.body, { days: 3, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS }, '仅更新 days')
-  const onlyHours = await postJson(handlers, '/api/session-manager/auto-archive', { intervalHours: 12 })
-  assert.deepEqual(onlyHours.body, { days: 3, intervalHours: 12 }, '仅更新 intervalHours,days 保持')
-})
-
-test('自动归档配置:0 值合法且持久(阈值天数关自动归档,间隔小时数关周期轮)', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
-  const off = await postJson(handlers, '/api/session-manager/auto-archive', { days: 0, intervalHours: 0 })
-  assert.deepEqual(off.body, { days: 0, intervalHours: 0 })
-  const reread = response()
-  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), reread)
-  assert.deepEqual(reread.body, { days: 0, intervalHours: 0 }, '关闭值持久化')
-})
-
-test('自动归档配置:负数/非整数/非数值/空字段一律 400,配置不变', skipMissingDeps, async () => {
-  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
-  const invalidPayloads = [
-    { days: -1, intervalHours: 1 },
-    { days: 1.5, intervalHours: 1 },
-    { days: '3', intervalHours: 1 },
-    { days: true, intervalHours: 1 },
-    { days: null, intervalHours: 1 },
-    {},
-  ]
-  for (const payload of invalidPayloads) {
-    const rejected = await postJson(handlers, '/api/session-manager/auto-archive', payload)
-    assert.equal(rejected.status, 400, JSON.stringify(payload))
-  }
-  const after = response()
-  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), after)
-  assert.deepEqual(after.body, { days: DEFAULT_AUTO_ARCHIVE_DAYS, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS }, '被拒请求不改动配置')
-})
-
-test('自动归档配置提交判定:noop/invalid/post 三态分类', async () => {
-  const { classifyAutoArchiveInput } = await import('../src/core.mjs')
-  assert.deepEqual(classifyAutoArchiveInput('7', '7'), { action: 'noop' }, '值未变不提交')
-  assert.deepEqual(classifyAutoArchiveInput('7', '  7  '), { action: 'noop' }, '空白差异修剪后视为未变')
-  assert.deepEqual(classifyAutoArchiveInput('7', '-1'), { action: 'invalid' }, '负数拒绝')
-  assert.deepEqual(classifyAutoArchiveInput('7', '1.5'), { action: 'invalid' }, '非整数拒绝')
-  assert.deepEqual(classifyAutoArchiveInput('7', 'abc'), { action: 'invalid' }, '非数值拒绝')
-  assert.deepEqual(classifyAutoArchiveInput('7', ''), { action: 'invalid' }, '空文本拒绝')
-  assert.deepEqual(classifyAutoArchiveInput('7', '0'), { action: 'post', value: 0 }, '0 合法(关闭语义)')
-  assert.deepEqual(classifyAutoArchiveInput('7', '3'), { action: 'post', value: 3 }, '正整数可提交')
-})
-
-test('自动归档配置提交判定:client 与 core 镜像同源,提交守卫对照已提交值', { skip: process.env.TEST_SKIP_PARITY }, async () => {
-  const clientSource = await readFile(new URL('../src/client.js', import.meta.url), 'utf8')
-  const declared = clientSource.match(/function classifyAutoArchiveInput\(committedText, text\) \{([\s\S]*?)\n\}/)
-  assert.ok(declared, 'client.js 必须内联声明 classifyAutoArchiveInput')
-  const coreSource = await readFile(new URL('../src/core.mjs', import.meta.url), 'utf8')
-  const coreBody = coreSource.match(/export function classifyAutoArchiveInput\(committedText, text\) \{([\s\S]*?)\n\}/)
-  assert.ok(coreBody, 'core.mjs 必须声明 classifyAutoArchiveInput')
-  assert.equal(declared[1].trim(), coreBody[1].trim(), 'client 内联实现与 core 逐行一致')
-  // 调用点契约:守卫实参必须是已提交基准 committed[field],对照显示值比较恒相等(受控输入击键已同步)
-  assert.match(clientSource, /classifyAutoArchiveInput\(committed\[field\], text\)/, 'commit 必须以 committed[field] 为守卫基准')
-})
-
-
-// --- 0.1.7 settings 面双形适配(maintain a913c2c 同构) ---
-
-test('Config 导出契约:根级 volatile 包装,validate 产整节单 ref,默认值对拍', () => {
-  // Given 静态 Config 导出(0.1.7 节表单事实源)
-  assert.ok(indexModule.Config, 'Config 导出必须在场')
-  // When 空配置校验
-  const resolved = indexModule.Config['~standard'].validate({})
-  // Then 产整节单 ref(get 协议),字段为 schema 默认值
-  assert.equal(resolved.issues, undefined)
-  const section = resolved.value.get()
-  assert.equal(section.autoArchiveDays, DEFAULT_AUTO_ARCHIVE_DAYS)
-  assert.equal(section.autoArchiveIntervalHours, DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS)
-  // When 显式值校验
-  // Then 值透传
-  const provided = indexModule.Config['~standard'].validate({ autoArchiveDays: 3 }).value.get()
-  assert.equal(provided.autoArchiveDays, 3)
-})
-
-test('0.1.7 形态:settings 无 get/register 时读回落 config ref 节值', skipMissingDeps, async () => {
-  // Given settingsForms 只有 update(0.1.7 真实方法面)+ config ref 携带用户值
-  const settingsForms = { update: async () => {} }
-  const configRef = { get: () => ({ autoArchiveDays: 3, autoArchiveIntervalHours: 12 }) }
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-    agents: new Map(),
-    settingsService: settingsForms,
-    configRef,
-  })
-  // When GET auto-archive
-  const res = response()
-  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), res)
-  // Then 返回 config 节值而非默认
-  assert.deepEqual(res.body, { days: 3, intervalHours: 12 })
-})
-
-test('0.1.7 形态:auto-archive POST 经 configEditor.edit 落 fiber.entry 并回显新值', skipMissingDeps, async () => {
-  // Given settingsForms 只有 update + configEditor 桩(合并写回 configStore)
-  const settingsForms = { update: async () => {} }
-  const configStore = { autoArchiveDays: 7 }
-  const editCalls = []
-  const configRef = { get: () => ({ ...configStore }) }
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-    agents: new Map(),
-    settingsService: settingsForms,
-    configRef,
-    configEditor: {
-      async edit(entry, change) {
-        editCalls.push(entry)
-        const next = change({ ...configStore }, {})
-        for (const [key, value] of Object.entries(next)) configStore[key] = value
-      },
-    },
-  })
-  // When POST 写 days
-  const changed = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3 })
-  // Then edit 定位本条目,合并写回,响应回显新值
-  assert.deepEqual(changed.body, { days: 3, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS })
-  assert.equal(editCalls.length, 1)
-  assert.equal(editCalls[0].options.id, 'session-manager')
-  assert.equal(configStore.autoArchiveDays, 3)
-})
-
-test('0.1.7 形态:configEditor 缺失即 400 拒写,配置不变', skipMissingDeps, async () => {
-  // Given settingsForms 只有 update 且无 configEditor
-  const settingsForms = { update: async () => {} }
-  const configRef = { get: () => ({}) }
-  const { handlers } = makeCtx({
-    archivedIds: [],
-    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-    agents: new Map(),
-    settingsService: settingsForms,
-    configRef,
-  })
-  // When POST 写 days
-  const denied = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3 })
-  // Then 400 错误响应
-  assert.equal(denied.status, 400)
-  assert.ok(denied.body.error)
-})
-
-test('0.1.7 形态:settings.configure 在场即关闭原生自动页', skipMissingDeps, () => {
-  // Given settingsForms 带 configure 无 register
-  const configureCalls = []
-  const settingsForms = { configure: (presentation, owner) => { configureCalls.push({ presentation, owner }); return () => {} } }
-  const { activateSettings } = makeCtx({
-    archivedIds: [],
-    headers: [],
-    agents: new Map(),
-    settingsService: settingsForms,
-  })
-  // When 激活 settings 注入
-  activateSettings()
-  // Then 关闭自动页
-  assert.equal(configureCalls.length, 1)
-  assert.deepEqual(configureCalls[0].presentation, { auto: false })
-})
+// 路由层 BDD(mock ctx 强制 cordis 注入语义):宿主上下文上任何未声明 inject 的
+// 服务属性访问一律抛 cannot get property ... without inject,与 cordis reflect 行为
+// 一致,防止 inject 声明缺失回归。peer 依赖未安装的仓库环境(禁止 install)下整文件跳过。
+
+import test, { mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import { mkdtemp, writeFile, utimes, mkdir, rm, readFile, access } from 'node:fs/promises'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+// 仅 peer 依赖缺失允许整文件跳过;其余加载失败(src 自身损坏)直接失败,禁止静默 skip
+const indexModule = await import('../src/index.js').catch((error) => {
+  const missingPeer = error && error.code === 'ERR_MODULE_NOT_FOUND'
+    && (error.message.includes("'@deepseek-ai/") || error.message.includes("'zod"))
+  if (missingPeer) return error
+  throw error
+})
+const apply = indexModule.apply
+const declaredInject = Array.isArray(indexModule.inject) ? indexModule.inject : []
+const dependencyReady = typeof apply === 'function'
+const skipMissingDeps = { skip: dependencyReady ? false : 'peer 依赖未安装,路由层测试跳过' }
+const MESSAGES = indexModule.MESSAGES
+const { DELETE_MESSAGES, DEFAULT_AUTO_ARCHIVE_DAYS, DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS } = await import('../src/core.mjs').catch(() => ({ DELETE_MESSAGES: {} }))
+
+// 回收区目录统一隔离:删除降级路径把产物搬进该目录,防泄漏真实用户目录
+const sharedQuarantineDir = mkdtempSync(path.join(tmpdir(), 'sm-quarantine-shared-'))
+process.env.DSH_QUARANTINE_DIR = sharedQuarantineDir
+test.after(() => {
+  rmSync(sharedQuarantineDir, { recursive: true, force: true })
+})
+// 台账/重挂载夹具路径仅作数据,不落盘;形态与实现一致(会话目录)
+const LEDGER_FIXTURE_PATH = 'C:\\store\\s1'
+// 幽灵产物夹具:tmpdir 下未创建的路径,跨平台 stat 必 ENOENT
+// (POSIX 对纯反斜杠 Windows 字面量取 dirname 会落回 '.',stat 成功使幽灵分支不可达)
+const GHOST_DIR = path.join(tmpdir(), 'sm-ghost-fixture', 's1')
+const GHOST_PATH = path.join(GHOST_DIR, 'session.jsonl.zstd')
+
+function makeRegistry(initialIds) {
+  // 真实注册表契约(0.2.1-rc.2+):archivedSessionIds 是进程内快照的 getter;
+  // archiveSession 归档即入集合,unarchiveSession 串行移除(未归档 id 幂等不写),
+  // 两个官方入口都写穿 state——快照与持久集由注册表自身保证一致
+  const registry = {
+    state: { initialized: true, workspaceIds: [], archivedSessionIds: initialIds },
+    list: () => [],
+    archiveCalls: [],
+    unarchiveCalls: [],
+    archiveSession: async (id) => {
+      const sid = String(id)
+      registry.archiveCalls.push(sid)
+      registry.state.archivedSessionIds = [...registry.state.archivedSessionIds, sid]
+    },
+    unarchiveSession: async (id) => {
+      const sid = String(id)
+      const next = registry.state.archivedSessionIds.filter((existing) => String(existing) !== sid)
+      if (next.length === registry.state.archivedSessionIds.length) return
+      registry.unarchiveCalls.push(sid)
+      registry.state.archivedSessionIds = next
+    },
+  }
+  Object.defineProperty(registry, 'archivedSessionIds', {
+    get: () => registry.state.archivedSessionIds,
+  })
+  return registry
+}
+
+// workspace 域句柄:null 表示域未打开(get 返回 undefined)
+function makeDomain(initialIds) {
+  const domain = {
+    state: { archivedSessionIds: initialIds },
+    writes: 0,
+    global: {
+      get: () => domain.state,
+      set: async (next) => {
+        domain.state = { ...next }
+        domain.writes += 1
+      },
+    },
+  }
+  return domain
+}
+
+// 台账域句柄;openRejected 模拟台账域打开失败
+function makeLedgerDomain(entries) {
+  const domain = {
+    state: { deleted: entries, unarchivedAt: 0 },
+    writes: 0,
+    global: {
+      get: () => domain.state,
+      set: async (next) => {
+        domain.state = { ...next }
+        domain.writes += 1
+      },
+    },
+  }
+  return domain
+}
+
+// workspace 注册表实体桩:detach/attach 均为官方实体契约,供删除与重挂载断言
+function makeWorkspace(path, sessionIds, options = {}) {
+  const workspace = {
+    path,
+    sessionIds,
+    attachCalls: [],
+    attachSession: async (id) => {
+      if (options.attachError) throw options.attachError
+      workspace.attachCalls.push(String(id))
+      workspace.sessionIds = [String(id), ...workspace.sessionIds.filter((existing) => existing !== id)]
+    },
+    detachSession: async (id) => {
+      if (options.detachError) throw options.detachError
+      workspace.sessionIds = workspace.sessionIds.filter((existing) => String(existing) !== String(id))
+    },
+  }
+  return workspace
+}
+
+function makeCtx({
+  archivedIds,
+  headers,
+  agents,
+  domain,
+  sessionPersistence,
+  ledger,
+  openRejected,
+  workspaces,
+  settingsValue,
+  settingsService: settingsServiceOverride,
+  timerAvailable,
+  readSessions,
+  configRef,
+  configEditor,
+}) {
+  const routes = []
+  const eventHandlers = {}
+  const pendingInjects = []
+  const disposers = []
+  const ledgerDomain = ledger === undefined ? makeLedgerDomain([]) : ledger
+  const workspaceList = workspaces || []
+  const settingsState = { value: settingsValue }
+  const settingsService = settingsServiceOverride ?? {
+    get: () => settingsState.value,
+    register: () => ({ resolved: undefined }),
+    // 宿主 update 为异步串行:合并进微任务队列后生效,读旧值发生在 flush 前
+    update: (ns, patch) => new Promise((resolve) => queueMicrotask(() => {
+      settingsState.value = { ...(settingsState.value || {}), ...patch }
+      resolve()
+    })),
+  }
+  // timer 服务桩:模拟宿主 timer 激活后的 interval;unref 保证测试进程可自然退出
+  const intervalStub = (fn, ms) => {
+    const timer = setInterval(fn, ms)
+    timer.unref()
+    return () => clearInterval(timer)
+  }
+  // readSession 桩:sessionId → 事件数组(工厂形态则调用后抛错);reads 记录实际读取次数供缓存断言
+  // headers 支持同步或异步函数形态:每次列会话现求值,模拟宿主按产物现状动态列会话;
+  // 数组形态在调用点同步快照(门闩时序测试依赖该语义,禁入 await 链)
+  const readCounts = new Map()
+  const sessionQuery = {
+    listSessions: async () => {
+      if (typeof headers !== 'function') return headers.map((header) => ({ header }))
+      const list = await headers()
+      return list.map((header) => ({ header }))
+    },
+    readSession: async (sessionId) => {
+      readCounts.set(sessionId, (readCounts.get(sessionId) || 0) + 1)
+      const events = readSessions ? readSessions[sessionId] : undefined
+      if (typeof events === 'function') throw events()
+      if (events === undefined) throw new Error('桩未配置该会话产物')
+      const list = typeof headers !== 'function' ? headers : await headers()
+      return { session: list.find((header) => header.id === sessionId), events }
+    },
+  }
+  const services = {
+    webServer: { register: (route) => routes.push(route) },
+    workspaceRegistry: Object.assign(makeRegistry(archivedIds), { list: () => workspaceList }),
+    sessionQuery,
+    storageDomain: {
+      get: (name) => name === 'workspace' ? (domain || undefined) : undefined,
+      open: openRejected ? () => Promise.reject(openRejected) : async () => ledgerDomain,
+    },
+  }
+  const base = {
+    effect: (fn) => fn(),
+    inject: (_deps, fn) => { pendingInjects.push(fn) },
+    // fiber 桩:0.1.7 configure 装配以本条目 fiber 为 owner
+    fiber: { entry: { options: { id: 'session-manager', name: '@mzzsfy/dsh-session-manager' } } },
+    get: (name) => {
+      if (name === 'configEditor') return configEditor
+      return { agents, sessionPersistence, settings: settingsService }[name]
+    },
+    on: (event, handler) => { eventHandlers[event] = handler },
+    // 日志桩:partial 降级点(logger.warn)在测试中可执行且可断言,不再被 undefined 短路
+    logger: { warns: [], warn(message) { this.warns.push(message) }, infos: [], info(message) { this.infos.push(message) } },
+  }
+  const ctx = new Proxy(base, {
+    get(target, prop) {
+      if (typeof prop === 'symbol') return undefined
+      if (prop in target) return target[prop]
+      if (!declaredInject.includes(prop)) {
+        throw new Error(`cannot get property "${String(prop)}" without inject`)
+      }
+      return services[prop]
+    },
+  })
+  apply(ctx, configRef)
+  return {
+    handlers: new Map(routes.map((route) => [route.path, route.handler])),
+    eventHandlers,
+    domain,
+    ledger: ledgerDomain,
+    registry: services.workspaceRegistry,
+    logger: base.logger,
+    readCounts,
+    // 模拟宿主 settings 与 timer 服务激活:触发 inject 回调(注册 + 启动补扫 + 周期武装)
+    activateSettings: () => {
+      const injected = {
+        settings: settingsService,
+        interval: timerAvailable === false ? undefined : intervalStub,
+        // 注入上下文的 effect 桩:0.1.7 分支经它注册 configure 装配
+        effect(fn) {
+          const disposer = fn()
+          if (typeof disposer === 'function') disposers.push(disposer)
+        },
+      }
+      while (pendingInjects.length > 0) pendingInjects.shift()(injected)
+    },
+  }
+}
+
+async function waitFor(predicate) {
+  // performance.now 不受 mock.timers 的 Date 接管影响,周期评估测试中仍可真实计时
+  const deadline = performance.now() + 2000
+  while (performance.now() < deadline) {
+    if (predicate()) return
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  assert.ok(predicate(), 'waitFor 超时')
+}
+
+function request(sessionId, method = 'POST') {
+  const req = new EventEmitter()
+  req.method = method
+  if (method !== 'GET') {
+    process.nextTick(() => {
+      req.emit('data', Buffer.from(JSON.stringify({ sessionId })))
+      req.emit('end')
+    })
+  }
+  return req
+}
+
+function response() {
+  const state = { status: undefined, body: undefined }
+  state.writeHead = (status) => { state.status = status }
+  state.end = (text) => { state.body = JSON.parse(text) }
+  return state
+}
+
+const HEADER = { id: 's1', cwd: 'C:\\x', createdAt: 0 }
+
+test('inject 声明覆盖路由层触及的全部宿主服务(cordis 未声明即抛 cannot get property)', skipMissingDeps, () => {
+  for (const service of ['webServer', 'workspaceRegistry', 'sessionQuery', 'storageDomain', 'agents', 'sessions', 'sessionPersistence']) {
+    assert.ok(declaredInject.includes(service), `inject 缺少 "${service}"`)
+  }
+})
+
+test('请求体非法 JSON:协议错误与业务错误分通道,不透出引擎 SyntaxError', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [], agents: new Map() })
+  const req = new EventEmitter()
+  req.method = 'POST'
+  process.nextTick(() => {
+    req.emit('data', Buffer.from('{not json'))
+    req.emit('end')
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/unarchive')(req, res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '请求体不是合法 JSON')
+})
+
+test('自动归档评估门闩:评估进行中的新触发被丢弃不排队', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-gate-'))
+  try {
+    const alivePath = path.join(dir, 'alive.jsonl')
+    await writeFile(alivePath, '{"header":1}\n{"event":0}\n')
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(alivePath, stale / 1000, stale / 1000)
+    const cwd = 'C:\\x'
+    const headers = [{ id: 's1', cwd, createdAt: stale }]
+    const { eventHandlers, registry } = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      sessionPersistence: { locate: (header) => ({ path: alivePath }) },
+    })
+    eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
+    // 首轮启动后立即补新候选并连发两触发:首轮候选列表已捕获(s1),门闩正常时
+    // trigger2/3 被丢弃,s2 永不评估;门闩失效则 s2 被归档,断言可见
+    headers.push({ id: 's2', cwd, createdAt: stale })
+    eventHandlers['session/created']({ header: { id: 'trigger2', cwd } })
+    eventHandlers['session/created']({ header: { id: 'trigger3', cwd } })
+    await waitFor(() => registry.archiveCalls.length > 0)
+    // 给在途与迟到轮留完成窗口后断言:仅首轮产出,s2 未被任何一轮归档
+    await new Promise((resolve) => setTimeout(resolve, 150))
+    assert.deepEqual(registry.archiveCalls, ['s1'], '门闩应丢弃在途触发,新候选 s2 不被评估')
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('并发删除:台账串行化不丢条目', skipMissingDeps, async () => {
+  const artifactA = await makeLocatedArtifact('a')
+  const artifactB = await makeLocatedArtifact('b')
+  try {
+    const headers = [
+      { id: 'a', cwd: 'C:\\x', createdAt: 0 },
+      { id: 'b', cwd: 'C:\\x', createdAt: 0 },
+    ]
+    const workspace = makeWorkspace('C:\\x', ['a', 'b'])
+    const { handlers, ledger } = makeCtx({
+      archivedIds: ['a', 'b'],
+      headers,
+      agents: new Map([['a', { status: 'idle' }], ['b', { status: 'idle' }]]),
+      domain: makeDomain(['a', 'b']),
+      sessionPersistence: { locate: (header) => header.id === 'a' ? { path: artifactA.locatedPath } : { path: artifactB.locatedPath } },
+      workspaces: [workspace],
+    })
+    const resA = response()
+    const resB = response()
+    await Promise.all([
+      withTrashStub(async () => {}, async () => {
+        await handlers.get('/api/session-manager/delete')(request('a'), resA)
+      }),
+      withTrashStub(async () => {}, async () => {
+        await handlers.get('/api/session-manager/delete')(request('b'), resB)
+      }),
+    ])
+    assert.equal(resA.status, 200)
+    assert.equal(resB.status, 200)
+    // 串行化后两条台账都在;丢失更新会让后写者只剩自己的条目
+    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId).sort(), ['a', 'b'])
+  } finally {
+    await artifactA.cleanup()
+    await artifactB.cleanup()
+  }
+})
+
+test('同 id 并发删除:第二个请求收到 in-flight 提示', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    let releaseTrash
+    const trashGate = new Promise((resolve) => { releaseTrash = resolve })
+    const workspace = makeWorkspace('C:\\x', ['s1'])
+    const { handlers } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      workspaces: [workspace],
+    })
+    const first = response()
+    const firstDone = withTrashStub(async () => { await trashGate }, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), first)
+    })
+    // 等 trash 进入挂起后再发第二发
+    await new Promise((resolve) => setTimeout(resolve, 20))
+    const second = response()
+    await handlers.get('/api/session-manager/delete')(request('s1'), second)
+    assert.equal(second.status, 400)
+    assert.equal(second.body.error, '该会话正在删除中,请稍后重试')
+    releaseTrash()
+    await firstDone
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('多工作区 detach:首个失败不终止后续,全部失败进日志', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const broken = makeWorkspace('C:\\one', ['s1'], { detachError: new Error('one boom') })
+    const healthy = makeWorkspace('C:\\two', ['s1'])
+    const { handlers } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      workspaces: [broken, healthy],
+    })
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.partial, true)
+    assert.equal(res.body.message, '已移入回收站,但移除列表记录失败')
+    // 健康工作区仍被解除关联
+    assert.deepEqual(healthy.sessionIds, [])
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('取消归档路由:走官方 unarchiveSession 写穿注册表', skipMissingDeps, async () => {
+  const domain = makeDomain(['s1', 's2'])
+  const { handlers, registry } = makeCtx({ archivedIds: ['s1', 's2'], headers: [HEADER], agents: new Map(), domain })
+  const res = response()
+  await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { ok: true })
+  // 官方 API 写穿:注册表快照移除,无私有直写路径
+  assert.deepEqual(registry.unarchiveCalls, ['s1'])
+  assert.deepEqual(registry.state.archivedSessionIds, ['s2'])
+  assert.deepEqual(registry.archivedSessionIds, ['s2'])
+})
+
+test('台账 deletedAt 为删除时刻的数值(面板排序依据)', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const before = Date.now()
+    const { handlers, ledger } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    const deletedAt = ledger.state.deleted[0].deletedAt
+    assert.ok(typeof deletedAt === 'number' && deletedAt >= before && deletedAt <= Date.now() + 1000)
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('取消归档路由:未归档 id 幂等,注册表零写', skipMissingDeps, async () => {
+  const { handlers, registry } = makeCtx({ archivedIds: ['s1'], headers: [HEADER], agents: new Map() })
+  const res = response()
+  await handlers.get('/api/session-manager/unarchive')(request('s9'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { ok: true })
+  assert.deepEqual(registry.unarchiveCalls, [])
+  assert.deepEqual(registry.state.archivedSessionIds, ['s1'])
+})
+
+test('取消归档宽限:恢复后 graceMs 内同进程评估暂停,不秒归档', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-grace-'))
+  try {
+    const artifact = path.join(dir, 's1.jsonl')
+    await writeFile(artifact, '{"header":1}\n{"event":0}\n')
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(artifact, stale / 1000, stale / 1000)
+    const headers = [{ id: 's1', cwd: 'C:\\x', createdAt: stale }]
+    const ctxBundle = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      sessionPersistence: { locate: () => ({ path: artifact }) },
+      domain: makeDomain([]),
+    })
+    const { activateSettings, registry, handlers, eventHandlers } = ctxBundle
+    activateSettings()
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['s1'])
+    // 手动恢复:归档集合移除 + 进程内宽限生效
+    const res = response()
+    await handlers.get('/api/session-manager/unarchive')(request('s1'), res)
+    assert.equal(res.status, 200)
+    assert.deepEqual(registry.state.archivedSessionIds, [])
+    // 宽限内经新会话创建触发评估:同产物仍超期,但不再归档
+    eventHandlers['session/created']({ header: { cwd: 'C:\\x' } })
+    await new Promise((resolve) => setTimeout(resolve, 80))
+    assert.deepEqual(registry.archiveCalls, ['s1'], '宽限期内不得重新归档')
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('info 路由:会话不存在拒绝', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [], agents: new Map() })
+  const res = response()
+  await handlers.get('/api/session-manager/info')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '会话不存在')
+})
+
+test('info 路由:locate 缺失按不支持返回', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [HEADER], agents: new Map() })
+  const res = response()
+  await handlers.get('/api/session-manager/info')(request('s1'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { supported: false })
+})
+
+test('info 路由:产物已缺失按 missing 返回,不裸抛', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/info')(request('s1'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { supported: true, sizeBytes: 0, missing: true })
+})
+
+test('删除路由:运行中会话被守卫拒绝,不触发 locate 与 trash', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: ['s1'],
+    headers: [HEADER],
+    agents: new Map([['s1', { status: 'running' }]]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '运行中的会话不可删除')
+})
+
+test('删除路由:非运行中的已归档会话因 locate 缺失拒绝(守卫未误拦)', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: ['s1'],
+    headers: [HEADER],
+    agents: new Map([['s1', { status: 'idle' }]]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '当前存储后端不支持按会话删除')
+})
+
+test('删除路由:未归档会话拒绝(运行守卫优先于资格)', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map([['s1', { status: 'running' }]]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '运行中的会话不可删除')
+})
+
+test('删除路由:未归档且空闲的会话拒绝', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const { handlers } = makeCtx({
+      archivedIds: [],
+      headers: [HEADER],
+      agents: new Map([['s1', { status: 'idle' }]]),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    const res = response()
+    await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    assert.equal(res.status, 400)
+    assert.equal(res.body.error, '仅已归档会话可删除')
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('自动归档评估:产物不可读的会话不参与归档(防删除后复活)', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-eval-'))
+  const alivePath = path.join(dir, 'alive.jsonl')
+  await writeFile(alivePath, '{"header":1}\n{"event":0}\n')
+  const DAY_MS = 24 * 60 * 60 * 1000
+  const stale = Date.now() - 30 * DAY_MS
+  await utimes(alivePath, stale / 1000, stale / 1000)
+  const cwd = 'C:\\x'
+  const headers = [
+    { id: 's1', cwd, createdAt: stale },
+    { id: 's2', cwd, createdAt: stale },
+  ]
+  const sessionPersistence = {
+    locate: (header) => header.id === 's1' ? { path: alivePath } : { path: path.join(dir, 'gone.jsonl') },
+  }
+  const { eventHandlers, registry, logger } = makeCtx({
+    archivedIds: [],
+    headers,
+    agents: new Map(),
+    sessionPersistence,
+  })
+  eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
+  await waitFor(() => registry.archiveCalls.length > 0)
+  // s2 产物缺失必须被守卫跳过:否则已删除会话会被重新归档而在面板复活
+  assert.deepEqual(registry.archiveCalls, ['s1'])
+  // 归档成功须落可追溯日志(含会话 id)
+  await waitFor(() => logger.infos.length > 0)
+  assert.ok(logger.infos.some((message) => message.includes('s1')), '归档成功应落 info 日志')
+})
+
+test('自动归档评估:locate 缺失(第三方后端)的会话不参与归档', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-eval-nolocate-'))
+  try {
+    const alivePath = path.join(dir, 'alive.jsonl')
+    await writeFile(alivePath, '{"header":1}\n{"event":0}\n')
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(alivePath, stale / 1000, stale / 1000)
+    const cwd = 'C:\\x'
+    const headers = [
+      { id: 's1', cwd, createdAt: stale },
+      { id: 's2', cwd, createdAt: stale },
+    ]
+    const { eventHandlers, registry } = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      // s2 locate 返回 undefined(抽象后端契约允许):仅凭 createdAt 判活跃会绕过
+      // mtime 保护,与 delete 的 unsupportedBackend 拒绝对齐
+      sessionPersistence: {
+        locate: (header) => header.id === 's1' ? { path: alivePath } : undefined,
+      },
+    })
+    eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['s1'])
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('自动归档评估:subagent 内部会话不参与归档(官方主列表不收录 subagent)', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-eval-subagent-'))
+  try {
+    const plainPath = path.join(dir, 'plain.jsonl')
+    const childPath = path.join(dir, 'child.jsonl')
+    await writeFile(plainPath, '{"header":1}\n{"event":0}\n')
+    await writeFile(childPath, '{"header":1}\n{"event":0}\n')
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(plainPath, stale / 1000, stale / 1000)
+    await utimes(childPath, stale / 1000, stale / 1000)
+    const cwd = 'C:\\x'
+    const headers = [
+      { id: 'plain', cwd, createdAt: stale },
+      { id: 'child', cwd, createdAt: stale, origin: 'subagent', parentSession: 'parent' },
+    ]
+    const { eventHandlers, registry } = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      sessionPersistence: {
+        locate: (header) => ({ path: header.id === 'plain' ? plainPath : childPath }),
+      },
+    })
+    eventHandlers['session/created']({ header: { id: 'trigger', cwd } })
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['plain'], 'subagent 会话永不入选归档')
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('启动评估:settings 就绪后全量归档超期会话,不限于单工作区', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-startup-'))
+  try {
+    const artifactA = path.join(dir, 'a.jsonl')
+    const artifactB = path.join(dir, 'b.jsonl')
+    await writeFile(artifactA, '{"header":1}\n{"event":0}\n')
+    await writeFile(artifactB, '{"header":1}\n{"event":0}\n')
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(artifactA, stale / 1000, stale / 1000)
+    await utimes(artifactB, stale / 1000, stale / 1000)
+    const headers = [
+      { id: 'a', cwd: 'C:\\x', createdAt: stale },
+      { id: 'b', cwd: 'C:\\y', createdAt: stale },
+    ]
+    const { activateSettings, registry, handlers } = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      sessionPersistence: {
+        locate: (header) => ({ path: header.id === 'a' ? artifactA : artifactB }),
+      },
+    })
+    activateSettings()
+    await waitFor(() => registry.archiveCalls.length >= 2)
+    assert.deepEqual([...registry.archiveCalls].sort(), ['a', 'b'])
+    const status = response()
+    await handlers.get('/api/session-manager/status')(request('x', 'GET'), status)
+    assert.equal(status.status, 200)
+    assert.equal(status.body.periodic.running, true)
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('启动评估:autoArchiveDays=0 时不评估', skipMissingDeps, async () => {
+  const { activateSettings, registry } = makeCtx({
+    archivedIds: [],
+    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
+    agents: new Map(),
+    settingsValue: { autoArchiveDays: 0 },
+  })
+  activateSettings()
+  await new Promise((resolve) => setTimeout(resolve, 50))
+  assert.deepEqual(registry.archiveCalls, [])
+})
+
+test('周期评估:每日定时补扫首轮不可评估的会话', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-period-'))
+  // 夹具 mtime 用真实时钟落盘,之后接管 Date 与 setInterval:到期判断(nextDueAt)
+  // 与定时器触发共用同一虚拟时钟,tick 推进 24h 即触发周期轮
+  const artifactA = path.join(dir, 'a.jsonl')
+  const artifactB = path.join(dir, 'b.jsonl')
+  await writeFile(artifactA, '{"header":1}\n{"event":0}\n')
+  await writeFile(artifactB, '{"header":1}\n{"event":0}\n')
+  const DAY_MS = 24 * 60 * 60 * 1000
+  const realNow = Date.now()
+  const stale = realNow - 30 * DAY_MS
+  await utimes(artifactA, stale / 1000, stale / 1000)
+  await utimes(artifactB, stale / 1000, stale / 1000)
+  // 显式传 now:mock.timers 接管 Date 后从 epoch 0 起算,不传则夹具时间戳全成「未来」
+  mock.timers.enable({ apis: ['setInterval', 'Date'], now: realNow })
+  try {
+    // 首轮 b 产物不可读(守卫跳过),周期轮起可读:b 只能经周期评估归档
+    let bReadable = false
+    const { activateSettings, registry } = makeCtx({
+      archivedIds: [],
+      headers: [
+        { id: 'a', cwd: 'C:\\x', createdAt: stale },
+        { id: 'b', cwd: 'C:\\x', createdAt: stale },
+      ],
+      agents: new Map(),
+      sessionPersistence: {
+        locate: (header) => (header.id === 'b' && !bReadable)
+          ? { path: path.join(dir, 'gone.jsonl') }
+          : { path: header.id === 'a' ? artifactA : artifactB },
+      },
+    })
+    activateSettings()
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['a'])
+    bReadable = true
+    mock.timers.tick(DAY_MS)
+    await waitFor(() => registry.archiveCalls.includes('b'))
+    // 桩回写 archivedSessionIds(真实注册表契约):已归档 a 不被周期轮重复选中
+    assert.deepEqual(registry.archiveCalls, ['a', 'b'])
+  } finally {
+    mock.timers.reset()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('周期评估:autoArchiveDays=0 时不评估', skipMissingDeps, async () => {
+  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
+  try {
+    const { activateSettings, registry } = makeCtx({
+      archivedIds: [],
+      headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
+      agents: new Map(),
+      settingsValue: { autoArchiveDays: 0 },
+    })
+    activateSettings()
+    mock.timers.tick(24 * 60 * 60 * 1000)
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    assert.deepEqual(registry.archiveCalls, [])
+  } finally {
+    mock.timers.reset()
+  }
+})
+
+test('周期评估:间隔设置运行时变更经 tick 对账(0 重启用 / 关闭即时暂停)', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-rearm-'))
+  // settings 桩返回同一对象引用:测试中改字段即模拟用户运行时改设置
+  const settingsValue = { autoArchiveIntervalHours: 0 }
+  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
+  try {
+    const artifacts = {}
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const TICK_MS = 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    const readable = { s1: true, s2: false, s3: false }
+    for (const id of ['s1', 's2', 's3']) {
+      const artifact = path.join(dir, id + '.jsonl')
+      await writeFile(artifact, '{"header":1}\n{"event":0}\n')
+      await utimes(artifact, stale / 1000, stale / 1000)
+      artifacts[id] = artifact
+    }
+    const headers = [
+      { id: 's1', cwd: 'C:\\x', createdAt: stale },
+      { id: 's2', cwd: 'C:\\x', createdAt: stale },
+      { id: 's3', cwd: 'C:\\x', createdAt: stale },
+    ]
+    const { activateSettings, registry } = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      settingsValue,
+      sessionPersistence: {
+        locate: (header) => ({ path: readable[header.id] ? artifacts[header.id] : path.join(dir, 'gone-' + header.id) }),
+      },
+    })
+    activateSettings()
+    // 启动补扫只看 autoArchiveDays(默认 7),intervalHours=0 不影响首轮
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['s1'])
+    // intervalHours=0 期间周期轮保持关闭:到期也不评估
+    readable.s2 = true
+    mock.timers.tick(DAY_MS)
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    assert.deepEqual(registry.archiveCalls, ['s1'], '关闭状态下到期不得评估')
+    // 0 重启用:缺失 due 经 tick 对账补排,最迟下个 tick 恢复周期轮
+    settingsValue.autoArchiveIntervalHours = 24
+    mock.timers.tick(TICK_MS)
+    await waitFor(() => registry.archiveCalls.includes('s2'))
+    assert.deepEqual(registry.archiveCalls, ['s1', 's2'])
+    // 再次关闭:即时暂停,s3 不被评估
+    readable.s3 = true
+    settingsValue.autoArchiveIntervalHours = 0
+    mock.timers.tick(DAY_MS)
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    assert.deepEqual(registry.archiveCalls, ['s1', 's2'], '再次关闭后到期不得评估')
+    // 第三次重启用:对账恢复,归档 s3
+    settingsValue.autoArchiveIntervalHours = 24
+    mock.timers.tick(TICK_MS)
+    await waitFor(() => registry.archiveCalls.includes('s3'))
+    assert.deepEqual(registry.archiveCalls, ['s1', 's2', 's3'])
+  } finally {
+    mock.timers.reset()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('settings 方法面缺失(0.1.7 SettingsForms 形态):tick 与 status 路由不抛错,配置回落默认', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-methodface-'))
+  // 宿主 0.1.7-alpha.1 将 settings 服务换形为 SettingsForms:缺 get/register,仅剩 update。
+  // 旧形态直接 settings.get 会在 timer 回调抛 TypeError 崩进程(实测事故),守卫后应回落默认值
+  const DAY_MS = 24 * 60 * 60 * 1000
+  const TICK_MS = 60 * 1000
+  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
+  try {
+    const artifact = path.join(dir, 'a.jsonl')
+    await writeFile(artifact, '{"header":1}\n{"event":0}\n')
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(artifact, stale / 1000, stale / 1000)
+    const settingsForms = { update: async () => {} }
+    const { activateSettings, handlers, registry } = makeCtx({
+      archivedIds: [],
+      headers: [{ id: 'a', cwd: 'C:\\x', createdAt: stale }],
+      agents: new Map(),
+      settingsService: settingsForms,
+      sessionPersistence: { locate: () => ({ path: artifact }) },
+    })
+    activateSettings()
+    // 守卫生效:配置读不到回落默认(days=7,intervalHours=24),30 天超期夹具到期即按默认轮归档
+    mock.timers.tick(DAY_MS + TICK_MS)
+    await waitFor(() => registry.archiveCalls.includes('a'))
+    assert.deepEqual(registry.archiveCalls, ['a'], '配置缺失按默认间隔正常评估,不因服务形变停摆')
+    // status 路由读设置不抛:回默认 days/intervalHours
+    const statusHandler = handlers.get('/api/session-manager/status')
+    const res = response()
+    await statusHandler(request('s1', 'GET'), res)
+    assert.equal(res.status, 200)
+  } finally {
+    mock.timers.reset()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('周期评估:缩短间隔经 earliest 钳制前移,不等满旧周期', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-shorten-'))
+  const TICK_MS = 60 * 1000
+  const HOUR_MS = 60 * 60 * 1000
+  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
+  try {
+    const readable = { a: true, b: false }
+    const artifacts = {}
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    for (const id of ['a', 'b']) {
+      const artifact = path.join(dir, id + '.jsonl')
+      await writeFile(artifact, '{"header":1}\n{"event":0}\n')
+      await utimes(artifact, stale / 1000, stale / 1000)
+      artifacts[id] = artifact
+    }
+    const settingsValue = { autoArchiveIntervalHours: 24 }
+    const { activateSettings, registry } = makeCtx({
+      archivedIds: [],
+      headers: [
+        { id: 'a', cwd: 'C:\\x', createdAt: stale },
+        { id: 'b', cwd: 'C:\\x', createdAt: stale },
+      ],
+      agents: new Map(),
+      settingsValue,
+      sessionPersistence: {
+        locate: (header) => readable[header.id] ? { path: artifacts[header.id] } : { path: path.join(dir, 'gone-' + header.id) },
+      },
+    })
+    activateSettings()
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['a'])
+    const afterStartup = registry.archiveCalls.length
+    // T+24h 到期轮(a 已归档无产出);紧接缩短为 1h:earliest 钳制应把 due 前移到
+    // 缩短时刻 + 1h,而非等满旧周期 T+48h;b 在缩短后变可读,由前移后的轮归档
+    mock.timers.tick(DAY_MS)
+    settingsValue.autoArchiveIntervalHours = 1
+    readable.b = true
+    mock.timers.tick(DAY_MS + TICK_MS)
+    await waitFor(() => registry.archiveCalls.length > afterStartup)
+    assert.deepEqual(registry.archiveCalls, ['a', 'b'])
+  } finally {
+    mock.timers.reset()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('定时服务缺失:周期评估降级,状态接口提示且不影响启动补扫', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-degrade-'))
+  try {
+    const artifact = path.join(dir, 'a.jsonl')
+    await writeFile(artifact, '{"header":1}\n{"event":0}\n')
+    const DAY_MS = 24 * 60 * 60 * 1000
+    const stale = Date.now() - 30 * DAY_MS
+    await utimes(artifact, stale / 1000, stale / 1000)
+    const { activateSettings, handlers, registry } = makeCtx({
+      archivedIds: [],
+      headers: [{ id: 'a', cwd: 'C:\\x', createdAt: stale }],
+      agents: new Map(),
+      sessionPersistence: { locate: () => ({ path: artifact }) },
+      timerAvailable: false,
+    })
+    activateSettings()
+    // 启动补扫照常工作:软依赖缺失只影响周期轮
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['a'])
+    const status = response()
+    await handlers.get('/api/session-manager/status')(request('x', 'GET'), status)
+    assert.equal(status.status, 200)
+    assert.equal(status.body.periodic.running, false)
+    assert.notEqual(status.body.periodic.reason, '')
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('周期评估:到期 tick 恰逢门闩占用时保持到期态,下个 tick 重试而非推后一个周期', skipMissingDeps, async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'sm-gate-tick-'))
+  const TICK_MS = 60 * 1000
+  const DAY_MS = 24 * 60 * 60 * 1000
+  mock.timers.enable({ apis: ['setInterval', 'Date'], now: Date.now() })
+  try {
+    const readable = { a: true, b: false, c: false }
+    const artifacts = {}
+    const stale = Date.now() - 30 * DAY_MS
+    for (const id of ['a', 'b', 'c']) {
+      const artifact = path.join(dir, id + '.jsonl')
+      await writeFile(artifact, '{"header":1}\n{"event":0}\n')
+      await utimes(artifact, stale / 1000, stale / 1000)
+      artifacts[id] = artifact
+    }
+    const headers = [
+      { id: 'a', cwd: 'C:\\x', createdAt: stale },
+      { id: 'b', cwd: 'C:\\x', createdAt: stale },
+      { id: 'c', cwd: 'C:\\x', createdAt: stale },
+    ]
+    const { activateSettings, eventHandlers, registry } = makeCtx({
+      archivedIds: [],
+      headers,
+      agents: new Map(),
+      sessionPersistence: {
+        locate: (header) => readable[header.id] ? { path: artifacts[header.id] } : { path: path.join(dir, 'gone-' + header.id) },
+      },
+    })
+    activateSettings()
+    // 启动补扫:a 归档(桩回写 archived),b/c 不可读留候选
+    await waitFor(() => registry.archiveCalls.length > 0)
+    assert.deepEqual(registry.archiveCalls, ['a'])
+    // 挂起归档执行器,再触发一轮评估:门闩被占
+    let releaseArchive
+    const held = new Promise((resolve) => { releaseArchive = resolve })
+    const originalArchive = registry.archiveSession
+    let archiveArrived = false
+    registry.archiveSession = async (id) => {
+      archiveArrived = true
+      await held
+      await originalArchive(id)
+    }
+    readable.b = true
+    eventHandlers['session/created']({ header: headers[1] })
+    await waitFor(() => archiveArrived)
+    assert.deepEqual(registry.archiveCalls, ['a'], '挂起的 b 尚未计入归档调用')
+    // 到期 tick 恰逢门闩占用:被丢弃,不得把周期推后 24h(保持到期态)
+    mock.timers.tick(DAY_MS)
+    // 释放挂起评估并让出事件循环,确保门闩复位(evaluating=false)落定
+    releaseArchive()
+    await new Promise((resolve) => setImmediate(resolve))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    // c 变可读,60s 后的下个 tick 即应重试并归档 c(若周期被推后 24h 此步超时)
+    readable.c = true
+    mock.timers.tick(TICK_MS)
+    await waitFor(() => registry.archiveCalls.includes('c'))
+    assert.deepEqual(registry.archiveCalls, ['a', 'b', 'c'])
+  } finally {
+    mock.timers.reset()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+// 执行器桩替:trash 与回收区搬移为进程级 OS 副作用出口,经 executor 注册表注入
+async function withExecutorStub(stubs, run) {
+  const originals = {}
+  for (const [name, stub] of Object.entries(stubs)) {
+    originals[name] = indexModule.executor[name]
+    indexModule.executor[name] = stub
+  }
+  try {
+    await run()
+  } finally {
+    for (const [name, original] of Object.entries(originals)) indexModule.executor[name] = original
+  }
+}
+
+async function withTrashStub(stub, run) {
+  await withExecutorStub({ trashPath: stub }, run)
+}
+
+const IDLE_S1 = new Map([['s1', { status: 'idle' }]])
+
+// locate 契约实证:返回会话目录下的日志文件;stat 为真实 fs,产物以临时文件承载
+async function makeLocatedArtifact(sessionId = 's1') {
+  const root = await mkdtemp(path.join(tmpdir(), 'sm-del-'))
+  const locatedDir = path.join(root, sessionId)
+  const locatedPath = path.join(locatedDir, 'session.jsonl.zstd')
+  await mkdir(locatedDir, { recursive: true })
+  await writeFile(locatedPath, 'log-bytes')
+  return {
+    locatedDir,
+    locatedPath,
+    cleanup: () => rm(root, { recursive: true, force: true }),
+  }
+}
+
+test('删除成功:trash 目标为会话目录,台账记录目录路径', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const domain = makeDomain(['s1'])
+    const workspace = makeWorkspace('C:\\x', ['s1'])
+    const { handlers, ledger, registry } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain,
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      workspaces: [workspace],
+    })
+    const trashed = []
+    const res = response()
+    await withTrashStub(async (p) => { trashed.push(p) }, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.deepEqual(res.body, { ok: true, mode: 'os' })
+    // locate 给的是日志文件,trash 必须上移到会话目录,否则残留空目录
+    assert.deepEqual(trashed, [artifact.locatedDir])
+    assert.equal(ledger.state.deleted.length, 1)
+    assert.equal(ledger.state.deleted[0].sessionId, 's1')
+    assert.equal(ledger.state.deleted[0].path, artifact.locatedDir)
+    // 取消归档走官方 unarchiveSession:注册表快照为事实源,域不再被插件直写
+    assert.deepEqual(registry.state.archivedSessionIds, [])
+    assert.deepEqual(workspace.sessionIds, [])
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('删除成功:同 id 残留台账被替换,无重复条目', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const { handlers, ledger } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      ledger: makeLedgerDomain([{ sessionId: 's1', path: 'old', deletedAt: 1 }]),
+    })
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.deepEqual(res.body, { ok: true, mode: 'os' })
+    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s1'])
+    assert.equal(ledger.state.deleted[0].path, artifact.locatedDir)
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+// Given 系统回收站不可用(trash 抛错), When 删除, Then 产物降级搬入插件回收区,
+// 台账记录暂存路径 heldPath,响应 mode=quarantine
+test('删除:系统回收站不可用时降级搬入插件回收区,台账记录暂存路径', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const { handlers, ledger } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    const res = response()
+    await withExecutorStub({ trashPath: async () => { throw new Error('gio: not found') } }, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.ok, true)
+    assert.equal(res.body.mode, 'quarantine')
+    const entry = ledger.state.deleted[0]
+    assert.equal(entry.sessionId, 's1')
+    assert.equal(entry.path, artifact.locatedDir, '台账 path 仍为原位置,移回时使用')
+    assert.ok(entry.heldPath && entry.heldPath.startsWith(process.env.DSH_QUARANTINE_DIR), '台账记录回收区暂存路径')
+    await assert.rejects(access(artifact.locatedDir), '原位置产物应已搬走')
+    const held = await readFile(path.join(entry.heldPath, 'session.jsonl.zstd'), 'utf8')
+    assert.equal(held, 'log-bytes')
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+// Given 回收站与回收区均不可用, When 删除, Then 400 且台账不写(会话未被删除)
+test('删除:回收站与回收区均失败时拒绝且台账不写', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const { handlers, ledger } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    const res = response()
+    await withExecutorStub({
+      trashPath: async () => { throw new Error('gio: not found') },
+      moveToQuarantine: async () => { throw new Error('read-only volume') },
+    }, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 400)
+    assert.ok(res.body.error.startsWith(MESSAGES.trashFailed) && res.body.error.includes('均不可用'), '双失败文案区分两级')
+    assert.deepEqual(ledger.state.deleted, [])
+    // 双失败产物原地保留
+    await access(artifact.locatedDir)
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('删除:产物已缺失时跳过 trash 与台账,完成列表清理(同 id 重删场景)', skipMissingDeps, async () => {
+  const domain = makeDomain([])
+  const workspace = makeWorkspace('C:\\x', ['s1'])
+  const { handlers, ledger } = makeCtx({
+    // 幽灵会话已不在归档集合:残留清理不要求归档资格,但要求台账有记录
+    // (首删已记录,重删走幽灵收尾)
+    archivedIds: [],
+    headers: [HEADER],
+    agents: IDLE_S1,
+    domain,
+    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: GHOST_DIR, deletedAt: 1 }]),
+    workspaces: [workspace],
+  })
+  const trashed = []
+  const res = response()
+  await withTrashStub(async (p) => { trashed.push(p) }, async () => {
+    await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  })
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { ok: true, message: MESSAGES.ghostCleanup })
+  assert.deepEqual(trashed, [])
+  assert.equal(ledger.writes, 0)
+  // 残留清理仍解除工作区关联与归档集合(幂等)
+  assert.deepEqual(workspace.sessionIds, [])
+  assert.deepEqual(domain.state.archivedSessionIds, [])
+})
+
+test('删除:产物缺失且无归档记录无台账时拒绝(防新建会话未落盘被剥离)', skipMissingDeps, async () => {
+  const workspace = makeWorkspace('C:\\x', ['s1'])
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: IDLE_S1,
+    domain: makeDomain([]),
+    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
+    workspaces: [workspace],
+  })
+  const res = response()
+  await withTrashStub(async () => {}, async () => {
+    await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  })
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, MESSAGES.notArchived)
+  // 拒绝路径不动工作区关联
+  assert.deepEqual(workspace.sessionIds, ['s1'])
+})
+
+test('删除:产物已缺失时运行中守卫仍然生效', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map([['s1', { status: 'running' }]]),
+    domain: makeDomain([]),
+    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
+  })
+  const res = response()
+  await withTrashStub(async () => {}, async () => {
+    await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  })
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, MESSAGES.running)
+})
+
+test('删除:产物已缺失且归档清理半失败时聚合失败点', skipMissingDeps, async () => {
+  const workspace = makeWorkspace('C:\\x', ['s1'], { detachError: new Error('detach boom') })
+  const { handlers, logger, registry } = makeCtx({
+    archivedIds: ['s1'],
+    headers: [HEADER],
+    agents: IDLE_S1,
+    sessionPersistence: { locate: (header) => header.id === 's1' ? { path: GHOST_PATH } : undefined },
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: GHOST_DIR, deletedAt: 1 }]),
+    workspaces: [workspace],
+  })
+  // 官方取消归档半失败:注入 unarchiveSession 抛错
+  registry.unarchiveSession = async () => { throw new Error('unarchive boom') }
+  const res = response()
+  await withTrashStub(async () => {}, async () => {
+    await handlers.get('/api/session-manager/delete')(request('s1'), res)
+  })
+  assert.equal(res.status, 200)
+  assert.equal(res.body.partial, true)
+  assert.equal(res.body.message, '产物已不存在,但移除列表记录失败,且移除归档记录失败')
+  // 幽灵清理半失败:原始错误进服务端日志(排障契约),响应文案保持摘要
+  assert.ok(logger.warns.some((message) => message.includes('s1') && message.includes('detach boom')), '幽灵 detach 失败应落日志')
+})
+
+// Given 回收窗口内会话恢复运行(runningDuringTrash), When 聚合, Then 警告形态且无 partial 键
+test('删除:回收窗口内会话恢复运行,响应警告形态且无 partial 键', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const agents = new Map([['s1', { status: 'idle' }]])
+    const { handlers } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    const res = response()
+    // trash 桩内翻转运行态:模拟 OS 回收异步窗口内的执行期翻转
+    await withTrashStub(async () => { agents.set('s1', { status: 'running' }) }, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    // 全成功警告态:{ok,message,mode} 形态,无 partial 键
+    assert.deepEqual(res.body, { ok: true, mode: 'os', message: DELETE_MESSAGES.runningDuringTrash })
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('归档评估:超期运行中会话零产物 IO(早退,core 过滤为第二道防线)', skipMissingDeps, async () => {
+  const stale = Date.now() - 30 * 24 * 60 * 60 * 1000
+  let locateCalls = 0
+  const { activateSettings, registry } = makeCtx({
+    archivedIds: [],
+    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: stale }],
+    agents: new Map([['s1', { status: 'running' }]]),
+    sessionPersistence: {
+      locate: (header) => {
+        locateCalls += 1
+        return { path: 'C:\\x\\s1\\session.jsonl.zstd' }
+      },
+    },
+  })
+  // 历史启动对齐(运行中会话即时路径)也走 locate:等它跑完并清零计数,
+  // 此后断言只针对归档评估的产物 IO
+  await new Promise((resolve) => setTimeout(resolve, 30))
+  locateCalls = 0
+  activateSettings()
+  // 等评估轮跑完(正常会话路径必然触达 locate):running 会话不得产生 locate 调用
+  await new Promise((resolve) => setTimeout(resolve, 250))
+  assert.equal(locateCalls, 0, '运行中会话应在产物 IO 前早退')
+  assert.deepEqual(registry.archiveCalls, [])
+})
+
+test('删除:取消归档半失败时响应 partial 且台账已记录', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const { handlers, ledger, registry } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    registry.unarchiveSession = async () => { throw new Error('unarchive boom') }
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.partial, true)
+    assert.equal(res.body.message, '已移入回收站,但移除归档记录失败')
+    // detach 已完成、台账已记录:仅归档集合清理半失败
+    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s1'])
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('删除:detach 与台账同时失败时,partial 消息聚合两个失败点', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const brokenLedger = makeLedgerDomain([])
+    brokenLedger.global.set = async () => { throw new Error('medium broken') }
+    const workspace = makeWorkspace('C:\\x', ['s1'], { detachError: new Error('detach boom') })
+    const { handlers, logger } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      ledger: brokenLedger,
+      workspaces: [workspace],
+    })
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.partial, true)
+    assert.equal(res.body.message, '已移入回收站,但移除列表记录失败,且重挂载记录失败')
+    // 台账与 detach 的原始错误均进服务端日志
+    assert.ok(logger.warns.some((message) => message.includes('s1') && message.includes('medium broken')), '台账失败应落日志')
+    assert.ok(logger.warns.some((message) => message.includes('s1') && message.includes('detach boom')), 'detach 失败应落日志')
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+// (旧「trash 失败整体中止」语义已被回收区降级取代:单 trash 失败见降级用例,
+// 双失败中止见「回收站与回收区均失败时拒绝且台账不写」)
+
+test('台账域打开失败:删除其余成功仍响应 partial', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const { handlers, registry } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      openRejected: new Error('ledger down'),
+    })
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.partial, true)
+    assert.equal(res.body.message, '已移入回收站,但重挂载记录失败')
+    // 台账失败不阻断删除主链路:归档清理经官方 API 照常完成
+    assert.deepEqual(registry.state.archivedSessionIds, [])
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('台账写入失败:删除其余成功仍响应 partial', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const brokenLedger = makeLedgerDomain([])
+    brokenLedger.global.set = async () => { throw new Error('medium broken') }
+    const { handlers } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+      ledger: brokenLedger,
+    })
+    const res = response()
+    await withTrashStub(async () => {}, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.partial, true)
+    assert.equal(res.body.message, '已移入回收站,但重挂载记录失败')
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+test('已删除列表:GET 按存储序全量返回', skipMissingDeps, async () => {
+  const entries = [
+    { sessionId: 's2', path: 'p2', deletedAt: 2 },
+    { sessionId: 's1', path: 'p1', deletedAt: 1 },
+  ]
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [],
+    agents: new Map(),
+    ledger: makeLedgerDomain(entries),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/deleted')(request('x', 'GET'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { deleted: entries })
+})
+
+test('已删除列表:非 GET 拒绝', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [], agents: new Map() })
+  const res = response()
+  await handlers.get('/api/session-manager/deleted')(request('s1'), res)
+  assert.equal(res.status, 405)
+})
+
+test('已删除列表:台账域打开失败拒绝', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [],
+    agents: new Map(),
+    openRejected: new Error('ledger down'),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/deleted')(request('x', 'GET'), res)
+  assert.equal(res.status, 400)
+})
+
+test('重挂载:产物已还原时经官方 attachSession 挂回并清除台账', skipMissingDeps, async () => {
+  const workspace = makeWorkspace('C:\\x', [])
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    workspaces: [workspace],
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { ok: true })
+  assert.deepEqual(workspace.attachCalls, ['s1'])
+  assert.deepEqual(workspace.sessionIds, ['s1'])
+  assert.deepEqual(ledger.state.deleted, [])
+  assert.equal(ledger.writes, 1)
+})
+
+test('重挂载:产物未还原(持久层无 header)拒绝', skipMissingDeps, async () => {
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [],
+    agents: new Map(),
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '会话产物不在持久层,请先到系统回收站还原后重试')
+  // 拒绝路径不动台账
+  assert.equal(ledger.writes, 0)
+})
+
+// Given 回收区暂存条目(heldPath)且产物在暂存处, When 重挂载, Then 先移回原位置再挂载,
+// 会话列表随产物回位而可见(动态 headers 模拟宿主按产物现状列会话),台账清除
+test('重挂载:回收区暂存条目自动移回原位置后挂载成功', skipMissingDeps, async () => {
+  const base = await mkdtemp(path.join(tmpdir(), 'sm-held-'))
+  const originalDir = path.join(base, 's1')
+  const locatedPath = path.join(originalDir, 'session.jsonl.zstd')
+  const workspace = makeWorkspace('C:\\x', [])
+  try {
+    await mkdir(originalDir, { recursive: true })
+    await writeFile(locatedPath, 'log-bytes')
+    const { moveToQuarantine } = await import('../src/trash.mjs')
+    const heldPath = await moveToQuarantine(originalDir, path.join(base, 'held'))
+    await access(originalDir).then(() => { throw new Error('夹具前置失败:原位置应已空') }, () => {})
+    const { handlers, ledger } = makeCtx({
+      archivedIds: [],
+      // 宿主按产物现状列会话:移回前不可见,移回后可见
+      headers: async () => ((await access(locatedPath).then(() => true, () => false)) ? [HEADER] : []),
+      agents: new Map(),
+      workspaces: [workspace],
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: locatedPath } : undefined },
+      ledger: makeLedgerDomain([{ sessionId: 's1', path: originalDir, heldPath, deletedAt: 1 }]),
+    })
+    const res = response()
+    await handlers.get('/api/session-manager/remount')(request('s1'), res)
+    assert.equal(res.status, 200)
+    assert.deepEqual(res.body, { ok: true })
+    assert.deepEqual(workspace.attachCalls, ['s1'])
+    assert.deepEqual(ledger.state.deleted, [])
+    // 产物已回到原位置,暂存消失
+    const restored = await readFile(locatedPath, 'utf8')
+    assert.equal(restored, 'log-bytes')
+    await assert.rejects(access(heldPath))
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// Given 回收区暂存条目但暂存已缺失(原位置同样缺失), When 重挂载, Then 专属文案拒绝
+test('重挂载:回收区暂存缺失时拒绝且不动台账', skipMissingDeps, async () => {
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [],
+    agents: new Map(),
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: path.join(tmpdir(), 'sm-gone-original', 's1'), heldPath: path.join(tmpdir(), 'sm-gone-held', 's1-1'), deletedAt: 1 }]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, MESSAGES.heldMissing)
+  assert.equal(ledger.writes, 0)
+})
+
+// Given 回收区暂存条目且原位置产物已被手工还原, When 重挂载, Then 跳过移回直接挂载,暂存保留
+test('重挂载:原位置已有产物时跳过移回(手工还原场景)', skipMissingDeps, async () => {
+  const base = await mkdtemp(path.join(tmpdir(), 'sm-skip-held-'))
+  const originalDir = path.join(base, 's1')
+  const locatedPath = path.join(originalDir, 'session.jsonl.zstd')
+  try {
+    await mkdir(originalDir, { recursive: true })
+    await writeFile(locatedPath, 'restored-by-hand')
+    const heldPath = path.join(base, 'held', 's1-123')
+    await mkdir(heldPath, { recursive: true })
+    await writeFile(path.join(heldPath, 'session.jsonl.zstd'), 'held-copy')
+    const workspace = makeWorkspace('C:\\x', [])
+    const { handlers, ledger } = makeCtx({
+      archivedIds: [],
+      headers: [HEADER],
+      agents: new Map(),
+      workspaces: [workspace],
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: locatedPath } : undefined },
+      ledger: makeLedgerDomain([{ sessionId: 's1', path: originalDir, heldPath, deletedAt: 1 }]),
+    })
+    const res = response()
+    await handlers.get('/api/session-manager/remount')(request('s1'), res)
+    assert.equal(res.status, 200)
+    assert.deepEqual(res.body, { ok: true })
+    assert.deepEqual(workspace.attachCalls, ['s1'])
+    assert.deepEqual(ledger.state.deleted, [])
+    // 原位置内容未被覆盖,暂存目录按已知取舍保留(孤儿清理不做)
+    assert.equal(await readFile(locatedPath, 'utf8'), 'restored-by-hand')
+    await access(heldPath)
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// Given quarantine 降级成功但 detach 失败, When 删除, Then partial 主文案为回收区前缀且 mode=quarantine
+test('删除:回收区降级加 detach 失败聚合为回收区前缀 partial', skipMissingDeps, async () => {
+  const artifact = await makeLocatedArtifact()
+  try {
+    const workspace = makeWorkspace('C:\\x', ['s1'], { detachError: new Error('detach 失败') })
+    const { handlers } = makeCtx({
+      archivedIds: ['s1'],
+      headers: [HEADER],
+      agents: IDLE_S1,
+      domain: makeDomain(['s1']),
+      workspaces: [workspace],
+      sessionPersistence: { locate: (header) => header.id === 's1' ? { path: artifact.locatedPath } : undefined },
+    })
+    const res = response()
+    await withExecutorStub({ trashPath: async () => { throw new Error('gio: not found') } }, async () => {
+      await handlers.get('/api/session-manager/delete')(request('s1'), res)
+    })
+    assert.equal(res.status, 200)
+    assert.equal(res.body.partial, true)
+    assert.equal(res.body.mode, 'quarantine')
+    assert.ok(res.body.message.startsWith('已移入插件回收区'), 'partial 主文案为回收区前缀')
+  } finally {
+    await artifact.cleanup()
+  }
+})
+
+// Given 台账域打开失败, When 重挂载, Then 入口即拒绝(移回依据不可得,不做静默跳过)
+test('重挂载:台账域打开失败时入口拒绝', skipMissingDeps, async () => {
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    openRejected: new Error('ledger down'),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, MESSAGES.systemError)
+  assert.equal(ledger.writes, 0)
+})
+
+test('重挂载:找不到所属工作区拒绝', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    workspaces: [makeWorkspace('C:\\other', [])],
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.equal(res.body.error, '未找到会话所属工作区,无法重新挂载')
+})
+
+test('重挂载:attachSession 失败时拒绝且台账保留', skipMissingDeps, async () => {
+  const workspace = makeWorkspace('C:\\x', [], { attachError: new Error('cwd 消失') })
+  const entries = [{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    workspaces: [workspace],
+    ledger: makeLedgerDomain(entries),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 400)
+  assert.match(res.body.error, /cwd 消失/)
+  assert.deepEqual(ledger.state.deleted, entries)
+  assert.equal(ledger.writes, 0)
+})
+
+test('重挂载:会话已在工作区时幂等收尾(残留条目重试无副作用)', skipMissingDeps, async () => {
+  const workspace = makeWorkspace('C:\\x', ['s1'])
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    workspaces: [workspace],
+    ledger: makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }]),
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 200)
+  assert.deepEqual(res.body, { ok: true })
+  // 官方契约:id 已在 sessionIds 中,挂载幂等无重复
+  assert.deepEqual(workspace.sessionIds, ['s1'])
+  assert.deepEqual(ledger.state.deleted, [])
+})
+
+test('重挂载:挂载成功但台账清除失败时响应 partial', skipMissingDeps, async () => {
+  const workspace = makeWorkspace('C:\\x', [])
+  const brokenLedger = makeLedgerDomain([{ sessionId: 's1', path: LEDGER_FIXTURE_PATH, deletedAt: 1 }])
+  brokenLedger.global.set = async () => { throw new Error('medium broken') }
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [HEADER],
+    agents: new Map(),
+    workspaces: [workspace],
+    ledger: brokenLedger,
+  })
+  const res = response()
+  await handlers.get('/api/session-manager/remount')(request('s1'), res)
+  assert.equal(res.status, 200)
+  assert.equal(res.body.partial, true)
+  assert.equal(res.body.message, '已重新挂载,但清除台账记录失败;可在「已删除」区移除记录收尾')
+  assert.deepEqual(workspace.attachCalls, ['s1'])
+})
+
+test('移除记录:命中删除,未命中幂等无写', skipMissingDeps, async () => {
+  const entries = [
+    { sessionId: 's1', path: 'p1', deletedAt: 1 },
+    { sessionId: 's2', path: 'p2', deletedAt: 2 },
+  ]
+  const { handlers, ledger } = makeCtx({
+    archivedIds: [],
+    headers: [],
+    agents: new Map(),
+    ledger: makeLedgerDomain(entries),
+  })
+  const hit = response()
+  await handlers.get('/api/session-manager/forget')(request('s1'), hit)
+  assert.equal(hit.status, 200)
+  assert.deepEqual(hit.body, { ok: true })
+  assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s2'])
+  assert.equal(ledger.writes, 1)
+  const miss = response()
+  await handlers.get('/api/session-manager/forget')(request('s9'), miss)
+  assert.equal(miss.status, 200)
+  assert.equal(ledger.writes, 1)
+})
+
+// ── 自动归档配置 ──
+
+// GET 夹具:任意 URL 的 GET 请求
+function getRequest2(url, method) {
+  const req = new EventEmitter()
+  req.method = method
+  req.url = url
+  return req
+}
+
+// POST 夹具:请求体走 readBody 的 data/end 事件流,handler 按路径查找
+async function postJson(handlers, routePath, body) {
+  const req = new EventEmitter()
+  req.method = 'POST'
+  req.url = routePath
+  const res = response()
+  const done = handlers.get(routePath)(req, res)
+  req.emit('data', Buffer.from(JSON.stringify(body), 'utf8'))
+  req.emit('end')
+  await done
+  return res
+}
+
+test('自动归档配置:GET 回显生效值(未配置回默认),POST 持久,GET 反映新值', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
+  const initial = response()
+  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), initial)
+  assert.deepEqual(initial.body, { days: DEFAULT_AUTO_ARCHIVE_DAYS, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS }, '未配置时回显默认值')
+  const changed = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3, intervalHours: 12 })
+  assert.deepEqual(changed.body, { days: 3, intervalHours: 12 })
+  const reread = response()
+  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), reread)
+  assert.deepEqual(reread.body, { days: 3, intervalHours: 12 }, 'settings 持久化新值')
+})
+
+test('自动归档配置:单字段部分更新,未提交字段保持不变', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
+  const onlyDays = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3 })
+  assert.deepEqual(onlyDays.body, { days: 3, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS }, '仅更新 days')
+  const onlyHours = await postJson(handlers, '/api/session-manager/auto-archive', { intervalHours: 12 })
+  assert.deepEqual(onlyHours.body, { days: 3, intervalHours: 12 }, '仅更新 intervalHours,days 保持')
+})
+
+test('自动归档配置:0 值合法且持久(阈值天数关自动归档,间隔小时数关周期轮)', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
+  const off = await postJson(handlers, '/api/session-manager/auto-archive', { days: 0, intervalHours: 0 })
+  assert.deepEqual(off.body, { days: 0, intervalHours: 0 })
+  const reread = response()
+  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), reread)
+  assert.deepEqual(reread.body, { days: 0, intervalHours: 0 }, '关闭值持久化')
+})
+
+test('自动归档配置:负数/非整数/非数值/空字段一律 400,配置不变', skipMissingDeps, async () => {
+  const { handlers } = makeCtx({ archivedIds: [], headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }], agents: new Map() })
+  const invalidPayloads = [
+    { days: -1, intervalHours: 1 },
+    { days: 1.5, intervalHours: 1 },
+    { days: '3', intervalHours: 1 },
+    { days: true, intervalHours: 1 },
+    { days: null, intervalHours: 1 },
+    {},
+  ]
+  for (const payload of invalidPayloads) {
+    const rejected = await postJson(handlers, '/api/session-manager/auto-archive', payload)
+    assert.equal(rejected.status, 400, JSON.stringify(payload))
+  }
+  const after = response()
+  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), after)
+  assert.deepEqual(after.body, { days: DEFAULT_AUTO_ARCHIVE_DAYS, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS }, '被拒请求不改动配置')
+})
+
+test('自动归档配置提交判定:noop/invalid/post 三态分类', async () => {
+  const { classifyAutoArchiveInput } = await import('../src/core.mjs')
+  assert.deepEqual(classifyAutoArchiveInput('7', '7'), { action: 'noop' }, '值未变不提交')
+  assert.deepEqual(classifyAutoArchiveInput('7', '  7  '), { action: 'noop' }, '空白差异修剪后视为未变')
+  assert.deepEqual(classifyAutoArchiveInput('7', '-1'), { action: 'invalid' }, '负数拒绝')
+  assert.deepEqual(classifyAutoArchiveInput('7', '1.5'), { action: 'invalid' }, '非整数拒绝')
+  assert.deepEqual(classifyAutoArchiveInput('7', 'abc'), { action: 'invalid' }, '非数值拒绝')
+  assert.deepEqual(classifyAutoArchiveInput('7', ''), { action: 'invalid' }, '空文本拒绝')
+  assert.deepEqual(classifyAutoArchiveInput('7', '0'), { action: 'post', value: 0 }, '0 合法(关闭语义)')
+  assert.deepEqual(classifyAutoArchiveInput('7', '3'), { action: 'post', value: 3 }, '正整数可提交')
+})
+
+test('自动归档配置提交判定:client 与 core 镜像同源,提交守卫对照已提交值', { skip: process.env.TEST_SKIP_PARITY }, async () => {
+  const clientSource = await readFile(new URL('../src/client.js', import.meta.url), 'utf8')
+  const declared = clientSource.match(/function classifyAutoArchiveInput\(committedText, text\) \{([\s\S]*?)\n\}/)
+  assert.ok(declared, 'client.js 必须内联声明 classifyAutoArchiveInput')
+  const coreSource = await readFile(new URL('../src/core.mjs', import.meta.url), 'utf8')
+  const coreBody = coreSource.match(/export function classifyAutoArchiveInput\(committedText, text\) \{([\s\S]*?)\n\}/)
+  assert.ok(coreBody, 'core.mjs 必须声明 classifyAutoArchiveInput')
+  assert.equal(declared[1].trim(), coreBody[1].trim(), 'client 内联实现与 core 逐行一致')
+  // 调用点契约:守卫实参必须是已提交基准 committed[field],对照显示值比较恒相等(受控输入击键已同步)
+  assert.match(clientSource, /classifyAutoArchiveInput\(committed\[field\], text\)/, 'commit 必须以 committed[field] 为守卫基准')
+})
+
+
+// --- 0.1.7 settings 面双形适配(maintain a913c2c 同构) ---
+
+test('Config 导出契约:根级 volatile 包装,validate 产整节单 ref,默认值对拍', () => {
+  // Given 静态 Config 导出(0.1.7 节表单事实源)
+  assert.ok(indexModule.Config, 'Config 导出必须在场')
+  // When 空配置校验
+  const resolved = indexModule.Config['~standard'].validate({})
+  // Then 产整节单 ref(get 协议),字段为 schema 默认值
+  assert.equal(resolved.issues, undefined)
+  const section = resolved.value.get()
+  assert.equal(section.autoArchiveDays, DEFAULT_AUTO_ARCHIVE_DAYS)
+  assert.equal(section.autoArchiveIntervalHours, DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS)
+  // When 显式值校验
+  // Then 值透传
+  const provided = indexModule.Config['~standard'].validate({ autoArchiveDays: 3 }).value.get()
+  assert.equal(provided.autoArchiveDays, 3)
+})
+
+test('0.1.7 形态:settings 无 get/register 时读回落 config ref 节值', skipMissingDeps, async () => {
+  // Given settingsForms 只有 update(0.1.7 真实方法面)+ config ref 携带用户值
+  const settingsForms = { update: async () => {} }
+  const configRef = { get: () => ({ autoArchiveDays: 3, autoArchiveIntervalHours: 12 }) }
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
+    agents: new Map(),
+    settingsService: settingsForms,
+    configRef,
+  })
+  // When GET auto-archive
+  const res = response()
+  await handlers.get('/api/session-manager/auto-archive')(getRequest2('/api/session-manager/auto-archive', 'GET'), res)
+  // Then 返回 config 节值而非默认
+  assert.deepEqual(res.body, { days: 3, intervalHours: 12 })
+})
+
+test('0.1.7 形态:auto-archive POST 经 configEditor.edit 落 fiber.entry 并回显新值', skipMissingDeps, async () => {
+  // Given settingsForms 只有 update + configEditor 桩(合并写回 configStore)
+  const settingsForms = { update: async () => {} }
+  const configStore = { autoArchiveDays: 7 }
+  const editCalls = []
+  const configRef = { get: () => ({ ...configStore }) }
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
+    agents: new Map(),
+    settingsService: settingsForms,
+    configRef,
+    configEditor: {
+      async edit(entry, change) {
+        editCalls.push(entry)
+        const next = change({ ...configStore }, {})
+        for (const [key, value] of Object.entries(next)) configStore[key] = value
+      },
+    },
+  })
+  // When POST 写 days
+  const changed = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3 })
+  // Then edit 定位本条目,合并写回,响应回显新值
+  assert.deepEqual(changed.body, { days: 3, intervalHours: DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS })
+  assert.equal(editCalls.length, 1)
+  assert.equal(editCalls[0].options.id, 'session-manager')
+  assert.equal(configStore.autoArchiveDays, 3)
+})
+
+test('0.1.7 形态:configEditor 缺失即 400 拒写,配置不变', skipMissingDeps, async () => {
+  // Given settingsForms 只有 update 且无 configEditor
+  const settingsForms = { update: async () => {} }
+  const configRef = { get: () => ({}) }
+  const { handlers } = makeCtx({
+    archivedIds: [],
+    headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
+    agents: new Map(),
+    settingsService: settingsForms,
+    configRef,
+  })
+  // When POST 写 days
+  const denied = await postJson(handlers, '/api/session-manager/auto-archive', { days: 3 })
+  // Then 400 错误响应
+  assert.equal(denied.status, 400)
+  assert.ok(denied.body.error)
+})
+
+test('0.1.7 形态:settings.configure 在场即关闭原生自动页', skipMissingDeps, () => {
+  // Given settingsForms 带 configure 无 register
+  const configureCalls = []
+  const settingsForms = { configure: (presentation, owner) => { configureCalls.push({ presentation, owner }); return () => {} } }
+  const { activateSettings } = makeCtx({
+    archivedIds: [],
+    headers: [],
+    agents: new Map(),
+    settingsService: settingsForms,
+  })
+  // When 激活 settings 注入
+  activateSettings()
+  // Then 关闭自动页
+  assert.equal(configureCalls.length, 1)
+  assert.deepEqual(configureCalls[0].presentation, { auto: false })
+})