@mzzsfy/dsh-session-manager 0.7.1 → 0.9.0

package/test/index.test.mjs

@@ -1,1968 +1,1730 @@
-// 路由层 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 } from 'node:fs/promises'
-import { mkdtempSync, rmSync } from 'node:fs'
-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, HISTORY_INPUT_LIMIT, HISTORY_STARTUP_SCAN_LIMIT, HISTORY_INPUT_MAX_CHARS, HISTORY_PROMPTS_MAX, HISTORY_SCOPES, DEFAULT_AUTO_ARCHIVE_DAYS, DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS } = await import('../src/core.mjs').catch(() => ({ DELETE_MESSAGES: {} }))
-const { ensureCacheDir, writeWorkspaceCache } = await import('../src/history-cache.mjs')
-
-// 插件激活即跑历史缓存启动对齐:所有测试统一隔离缓存目录,
-// 防止夹具工作区经默认路径(~/.dsh/historyPrompt)泄漏进真实用户目录
-const sharedCacheDir = mkdtempSync(path.join(tmpdir(), 'sm-hist-shared-'))
-process.env.DSH_HISTORY_CACHE_DIR = sharedCacheDir
-test.after(() => { rmSync(sharedCacheDir, { 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 },
-    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,
-  timerAvailable,
-  readSessions,
-}) {
-  const routes = []
-  const eventHandlers = {}
-  const pendingInjects = []
-  const ledgerDomain = ledger === undefined ? makeLedgerDomain([]) : ledger
-  const workspaceList = workspaces || []
-  const settingsState = { value: settingsValue }
-  const settingsService = {
-    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 记录实际读取次数供缓存断言
-  const readCounts = new Map()
-  const sessionQuery = {
-    listSessions: async () => headers.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('桩未配置该会话产物')
-      return { session: headers.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) },
-    get: (name) => ({ 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, undefined)
-  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 }
-      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('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('周期评估:缩短间隔经 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 注册表注入(README 已知测试缺口的基建扩展)
-async function withTrashStub(stub, run) {
-  const original = indexModule.executor.trashPath
-  indexModule.executor.trashPath = stub
-  try {
-    await run()
-  } finally {
-    indexModule.executor.trashPath = original
-  }
-}
-
-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 })
-    // 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 })
-    assert.deepEqual(ledger.state.deleted.map((item) => item.sessionId), ['s1'])
-    assert.equal(ledger.state.deleted[0].path, 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 失败应落日志')
-})
-
-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} 形态,无 partial 键
-    assert.deepEqual(res.body, { ok: true, 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()
-  }
-})
-
-test('trash 失败:整体中止,台账不写', 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 withTrashStub(async () => { throw new Error('no trash') }, async () => {
-      await handlers.get('/api/session-manager/delete')(request('s1'), res)
-    })
-    assert.equal(res.status, 400)
-    assert.deepEqual(ledger.state.deleted, [])
-    assert.equal(ledger.writes, 0)
-  } finally {
-    await artifact.cleanup()
-  }
-})
-
-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)
-})
-
-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 /api/session-manager/inputs;工作区持久缓存)──
-
-function getRequest(query) {
-  const req = new EventEmitter()
-  req.method = 'GET'
-  req.url = '/api/session-manager/inputs' + query
-  return req
-}
-
-function userMessageEvent(text, at) {
-  return {
-    type: 'user/message',
-    seq: at,
-    time: at,
-    data: { id: 'm' + at, role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text }] },
-  }
-}
-
-function makeHistoryCtx() {
-  return makeCtx({
-    archivedIds: [],
-    headers: [
-      { id: 's1', cwd: 'C:\\x', createdAt: 0 },
-      { id: 's2', cwd: 'C:\\x', createdAt: 0 },
-      { id: 's3', cwd: 'C:\\other', createdAt: 0 },
-    ],
-    agents: new Map(),
-    readSessions: {
-      s1: [userMessageEvent('更早的输入', 100), userMessageEvent('最新输入', 900)],
-      s2: [userMessageEvent('第二条', 500)],
-      s3: [userMessageEvent('别的工作区', 999)],
-    },
-  })
-}
-
-// 后台对齐是异步的:轮询等待响应满足条件(默认 aligned 翻真,可断言数据就绪)
-async function requestUntil(handlers, query, predicate, maxMs = 3000) {
-  for (let waited = 0; waited <= maxMs; waited += 100) {
-    const res = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest(query), res)
-    if (predicate(res.body)) return res
-    await new Promise((resolve) => setTimeout(resolve, 100))
-  }
-  throw new Error('条件未满足: ' + query)
-}
-
-function requestUntilAligned(handlers, query) {
-  return requestUntil(handlers, query, (body) => body.aligned)
-}
-
-// 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
-}
-
-// 每个测试独占临时缓存目录:插件 factory 在 makeCtx 时读取 env 解析缓存目录。
-// 后台对齐 fire-and-forget,测试结束仍在写目录——清理重试躲开 Windows 文件占用
-async function withHistoryCacheDir(run) {
-  const cacheDir = await mkdtemp(path.join(tmpdir(), 'sm-hist-'))
-  process.env.DSH_HISTORY_CACHE_DIR = cacheDir
-  try {
-    return await run(cacheDir)
-  } finally {
-    delete process.env.DSH_HISTORY_CACHE_DIR
-    for (let attempt = 0; attempt < 6; attempt += 1) {
-      try {
-        await rm(cacheDir, { recursive: true, force: true })
-        break
-      } catch {
-        await new Promise((resolve) => setTimeout(resolve, 150))
-      }
-    }
-  }
-}
-
-test('历史输入路由:首次 aligned=false 触发后台对齐,对齐后三范围正确且 session 按 sid 过滤', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const { handlers } = makeHistoryCtx()
-    const first = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=workspace'), first)
-    assert.equal(first.status, 200)
-    assert.deepEqual(first.body.inputs, [])
-    assert.equal(first.body.aligned, false)
-    const workspaceRes = await requestUntilAligned(handlers, '?sessionId=s1&scope=workspace')
-    assert.deepEqual(workspaceRes.body.inputs.map((item) => item.text), ['最新输入', '第二条', '更早的输入'])
-    const sessionRes = await requestUntilAligned(handlers, '?sessionId=s1&scope=session')
-    assert.deepEqual(sessionRes.body.inputs.map((item) => item.text), ['最新输入', '更早的输入'])
-    const otherSessionRes = await requestUntilAligned(handlers, '?sessionId=s2&scope=session')
-    assert.deepEqual(otherSessionRes.body.inputs.map((item) => item.text), ['第二条'])
-    // global 合并全部工作区缓存:先触发 C:\other 对齐(模拟其已就绪),再等 global 汇聚
-    await requestUntilAligned(handlers, '?sessionId=s3&scope=workspace')
-    const globalRes = await requestUntil(handlers, '?sessionId=s1&scope=global',
-      (body) => body.aligned && body.inputs.some((item) => item.text === '别的工作区'))
-    assert.deepEqual(globalRes.body.inputs.map((item) => item.text), ['别的工作区', '最新输入', '第二条', '更早的输入'])
-  })
-})
-
-test('历史输入路由:对齐与既有缓存合并——旧条目保留、新输入追加、sid 溯源不变', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    await ensureCacheDir(process.env.DSH_HISTORY_CACHE_DIR)
-    await writeWorkspaceCache(process.env.DSH_HISTORY_CACHE_DIR, 'C:\\x', {
-      entries: [
-        { text: '更早的输入', at: 100, sid: 's1' },
-        { text: '已消失会话的输入', at: 50, sid: 'gone' },
-      ],
-      extracts: {},
-    })
-    const { handlers } = makeHistoryCtx()
-    const res = await requestUntil(handlers, '?sessionId=s1&scope=workspace',
-      (body) => body.aligned && body.inputs.some((item) => item.text === '最新输入'))
-    assert.deepEqual(res.body.inputs.map((item) => item.text), ['最新输入', '第二条', '更早的输入', '已消失会话的输入'])
-    const sessionRes = await requestUntil(handlers, '?sessionId=s1&scope=session',
-      (body) => body.aligned && body.inputs.some((item) => item.text === '最新输入'))
-    assert.deepEqual(sessionRes.body.inputs.map((item) => item.text), ['最新输入', '更早的输入'])
-  })
-})
-
-test('历史输入路由:scope 缺省回退 session;未知会话/非 GET/缺 sessionId 拒绝', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const { handlers } = makeHistoryCtx()
-    const defaultRes = await requestUntilAligned(handlers, '?sessionId=s1')
-    assert.deepEqual(defaultRes.body.inputs.map((item) => item.text), ['最新输入', '更早的输入'])
-    const invalidRes = await requestUntilAligned(handlers, '?sessionId=s1&scope=bogus')
-    assert.deepEqual(invalidRes.body.inputs.map((item) => item.text), ['最新输入', '更早的输入'])
-    const unknown = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=ghost'), unknown)
-    assert.equal(unknown.status, 400)
-    assert.equal(unknown.body.error, MESSAGES.unknownSession)
-    const wrongMethod = response()
-    await handlers.get('/api/session-manager/inputs')(request('s1'), wrongMethod)
-    assert.equal(wrongMethod.status, 405)
-    const missing = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest(''), missing)
-    assert.equal(missing.status, 400)
-  })
-})
-
-test('历史输入路由:损坏会话对齐跳过不中断;无 cwd 会话 workspace/session 返回空且 aligned', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const { handlers, logger } = makeCtx({
-      archivedIds: [],
-      headers: [
-        { id: 's1', cwd: 'C:\\x', createdAt: 0 },
-        { id: 'broken', cwd: 'C:\\x', createdAt: 0 },
-        { id: 'nocwd', createdAt: 0 },
-      ],
-      agents: new Map(),
-      readSessions: {
-        s1: [userMessageEvent('存活输入', 100)],
-        broken: () => { throw new Error('产物损坏') },
-      },
-    })
-    const res = await requestUntilAligned(handlers, '?sessionId=s1&scope=workspace')
-    assert.deepEqual(res.body.inputs.map((item) => item.text), ['存活输入'])
-    assert.ok(logger.warns.some((line) => line.includes('broken')), '对齐失败未进服务端日志')
-    const noCwdWorkspace = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=nocwd&scope=workspace'), noCwdWorkspace)
-    assert.deepEqual(noCwdWorkspace.body, { inputs: [], aligned: true })
-    const noCwdSession = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=nocwd&scope=session'), noCwdSession)
-    assert.deepEqual(noCwdSession.body, { inputs: [], aligned: true })
-  })
-})
-
-test('历史输入路由:运行中会话参与对齐(实时追加),缓存上限裁剪保留最新', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const agents = new Map([['running1', { status: 'running' }]])
-    const manyEvents = Array.from({ length: HISTORY_INPUT_LIMIT + 50 }, (_, i) => userMessageEvent('运行输入' + i, 1000 + i))
-    const { handlers, readCounts } = makeCtx({
-      archivedIds: [],
-      headers: [
-        { id: 's1', cwd: 'C:\\x', createdAt: 0 },
-        { id: 'running1', cwd: 'C:\\x', createdAt: 0 },
-      ],
-      agents,
-      readSessions: {
-        s1: [userMessageEvent('历史输入', 1000 + manyEvents.length + 10)],
-        running1: manyEvents,
-      },
-    })
-    const res = await requestUntil(handlers, '?sessionId=s1&scope=workspace',
-      (body) => body.aligned && body.inputs.length === HISTORY_INPUT_LIMIT + 1)
-    const texts = res.body.inputs.map((item) => item.text)
-    // 运行中会话输入量远超上限:limit 之外仅追加该会话去重后最早一条(s1 首条已在 limit 内)
-    assert.equal(texts.length, HISTORY_INPUT_LIMIT + 1)
-    assert.ok(texts.includes('历史输入'), '最新既有输入保留')
-    assert.ok(texts.includes('运行输入' + (HISTORY_INPUT_LIMIT + 49)), '次新运行输入保留')
-    assert.ok(texts.includes('运行输入0'), '运行中会话最早输入受首条保护')
-    assert.ok(!texts.includes('运行输入1'), '首条之外的旧输入仍被上限裁剪')
-    assert.ok(readCounts.get('running1') >= 1, '运行中会话被对齐解压')
-    const sessionRes = await requestUntilAligned(handlers, '?sessionId=running1&scope=session')
-    assert.ok(sessionRes.body.inputs.length > 0, 'session 范围可取运行中会话自身输入')
-  })
-})
-
-test('历史输入路由:再次请求读缓存不再解压产物(对齐节流内)', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const { handlers, readCounts } = makeCtx({
-      archivedIds: [],
-      headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-      agents: new Map(),
-      readSessions: { s1: [userMessageEvent('工作区输入', 100)] },
-    })
-    await requestUntilAligned(handlers, '?sessionId=s1&scope=workspace')
-    const readsAfterAlign = readCounts.get('s1')
-    const second = response()
-    await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=workspace'), second)
-    assert.deepEqual(second.body.inputs.map((item) => item.text), ['工作区输入'])
-    assert.equal(second.body.aligned, true)
-    assert.equal(readCounts.get('s1'), readsAfterAlign, '读路径不得解压产物')
-  })
-})
-
-test('历史输入路由:会话产物变化即席聚焦对齐,单次请求内拿到新输入(首条<3s)', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), 'sm-hist-focus-'))
-    const artifactPath = path.join(dir, 'session.jsonl.zstd')
-    await writeFile(artifactPath, 'log-v1')
-    try {
-      const shared = {
-        archivedIds: [],
-        headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-        agents: new Map(),
-        sessionPersistence: { locate: (header) => ({ path: artifactPath }) },
-      }
-      const first = makeCtx({ ...shared, readSessions: { s1: [userMessageEvent('旧输入', 100)] } })
-      await requestUntilAligned(first.handlers, '?sessionId=s1&scope=session')
-      // 产物增长(会话有新输入):指纹失效——路由就地等待聚焦对齐,
-      // 测试桩的 readSession 立即完成,单次请求内应直接拿到新输入且 aligned
-      await writeFile(artifactPath, 'log-v1-much-longer-appended')
-      const second = makeCtx({ ...shared, readSessions: { s1: [userMessageEvent('旧输入', 100), userMessageEvent('新输入XYZ', 200)] } })
-      const res = response()
-      await second.handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=session'), res)
-      assert.equal(res.body.aligned, true, '焦点对齐快于等待时限,首请求即就绪')
-      assert.deepEqual(res.body.inputs.map((item) => item.text), ['新输入XYZ', '旧输入'])
-    } finally {
-      await rm(dir, { recursive: true, force: true })
-    }
-  })
-})
-
-test('历史输入路由:聚焦对齐只更新目标会话,不抹其他会话的持久 extracts', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), 'sm-hist-prune-'))
-    const artifactPath = path.join(dir, 'session.jsonl.zstd')
-    await writeFile(artifactPath, 'log-v1')
-    try {
-      await ensureCacheDir(process.env.DSH_HISTORY_CACHE_DIR)
-      await writeWorkspaceCache(process.env.DSH_HISTORY_CACHE_DIR, 'C:\\x', {
-        entries: [{ text: '更早的输入', at: 100, sid: 's1' }],
-        extracts: { s2: { mtimeMs: 1, size: 2, entries: [{ text: '邻居会话输入', at: 50 }] } },
-      })
-      const { handlers } = makeCtx({
-        archivedIds: [],
-        headers: [
-          { id: 's1', cwd: 'C:\\x', createdAt: 0 },
-          { id: 's2', cwd: 'C:\\x', createdAt: 0 },
-        ],
-        agents: new Map(),
-        sessionPersistence: { locate: (header) => ({ path: artifactPath }) },
-        readSessions: { s1: [userMessageEvent('更早的输入', 100), userMessageEvent('聚焦新输入', 200)] },
-      })
-      await requestUntil(handlers, '?sessionId=s1&scope=session',
-        (body) => body.aligned && body.inputs.some((item) => item.text === '聚焦新输入'))
-      const cached = JSON.parse(await readFile(path.join(process.env.DSH_HISTORY_CACHE_DIR, 'x-5358b306.json'), 'utf8'))
-      assert.ok(cached.extracts.s2, '邻居会话 extracts 不得被聚焦对齐抹掉')
-      assert.ok(cached.extracts.s1, '目标会话 extracts 已更新')
-    } finally {
-      await rm(dir, { recursive: true, force: true })
-    }
-  })
-})
-
-test('历史输入路由:产物未变的会话跨对齐零解压(磁盘 extracts 指纹命中)', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), 'sm-hist-art-'))
-    const artifactPath = path.join(dir, 'session.jsonl.zstd')
-    await writeFile(artifactPath, 'log-bytes')
-    try {
-      const { handlers, readCounts } = makeCtx({
-        archivedIds: [],
-        headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-        agents: new Map(),
-        sessionPersistence: { locate: (header) => ({ path: artifactPath }) },
-        readSessions: { s1: [userMessageEvent('工作区输入', 100)] },
-      })
-      await requestUntilAligned(handlers, '?sessionId=s1&scope=workspace')
-      const readsAfterFirstAlign = readCounts.get('s1')
-      assert.ok(readsAfterFirstAlign >= 1, '首次对齐必然解压')
-      // 节流壳 30s 挡住同工作区二次触发:直接以新 makeCtx(新节流 Map)模拟"重启后再次对齐"
-      const { handlers: handlers2, readCounts: readCounts2 } = makeCtx({
-        archivedIds: [],
-        headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-        agents: new Map(),
-        sessionPersistence: { locate: (header) => ({ path: artifactPath }) },
-        readSessions: { s1: [userMessageEvent('工作区输入', 100)] },
-      })
-      // 同一缓存目录(env 未变,withHistoryCacheDir 复用):指纹命中 → 零解压
-      const second = response()
-      await handlers2.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=workspace'), second)
-      assert.equal(second.body.aligned, true)
-      assert.deepEqual(second.body.inputs.map((item) => item.text), ['工作区输入'])
-      // 触发一次对齐(绕过节流:新 ctx 节流 Map 为空,请求即触发)
-      await new Promise((resolve) => setTimeout(resolve, 300))
-      assert.equal(readCounts2.get('s1') === undefined, true, '产物未变,重启后对齐零解压')
-    } finally {
-      await rm(dir, { recursive: true, force: true })
-    }
-  })
-})
-
-test('历史输入路由:启动对齐只回溯最近 STARTUP_SCAN 个会话,老会话不解压', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const total = HISTORY_STARTUP_SCAN_LIMIT + 20
-    // 宿主 listSessions 为最新在前:数组首元素即最新会话
-    const headers = Array.from({ length: total }, (_, i) => ({ id: 's' + (total - 1 - i), cwd: 'C:\\x', createdAt: 0 }))
-    const readSessions = {}
-    for (let i = 0; i < total; i++) readSessions['s' + i] = [userMessageEvent('输入' + i, 1000 + i)]
-    const { handlers, readCounts } = makeCtx({ archivedIds: [], headers, agents: new Map(), readSessions })
-    // 触发对齐(请求工作区),等队列排空后窗口外老会话(s0..s19)不得被解压
-    await requestUntil(handlers, '?sessionId=s' + (total - 1) + '&scope=workspace',
-      (body) => body.aligned && body.inputs.length > 0)
-    assert.equal(readCounts.get('s0'), undefined, '窗口外最老会话不被启动对齐解压')
-    assert.ok(readCounts.get('s' + (total - 1)) >= 1, '窗口内最新会话被解压')
-  })
-})
-
-test('常用提示词:toggle 收藏/取消,prompts 范围可见,与工作区缓存互不污染', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), 'sm-hist-prompts-'))
-    const artifactPath = path.join(dir, 'session.jsonl.zstd')
-    try {
-      await writeFile(artifactPath, 'log-v1')
-      const { handlers } = makeCtx({
-        archivedIds: [],
-        headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-        agents: new Map(),
-        sessionPersistence: { locate: (header) => ({ path: artifactPath }) },
-        readSessions: { s1: [userMessageEvent('历史输入A', 100)] },
-      })
-      // 初始为空
-      const empty = response()
-      await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=prompts'), empty)
-      assert.deepEqual(empty.body.inputs, [])
-      // 收藏 → prompts 可见;工作区范围不混入
-      await postJson(handlers, '/api/session-manager/prompts/toggle', { text: '常用句子X' })
-      const listed = response()
-      await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=prompts'), listed)
-      assert.deepEqual(listed.body.inputs.map((item) => item.text), ['常用句子X'])
-      const workspace = await requestUntil(handlers, '?sessionId=s1&scope=workspace',
-        (body) => body.aligned && body.inputs.some((item) => item.text === '历史输入A'))
-      assert.equal(workspace.body.inputs.some((item) => item.text === '常用句子X'), false, '收藏不混入工作区历史')
-      // 再 toggle = 取消
-      await postJson(handlers, '/api/session-manager/prompts/toggle', { text: '常用句子X' })
-      const cleared = response()
-      await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=prompts'), cleared)
-      assert.deepEqual(cleared.body.inputs, [])
-    } finally {
-      await rm(dir, { recursive: true, force: true })
-    }
-  })
-})
-
-test('常用提示词:超长截断、上限裁剪、空 text 拒绝', skipMissingDeps, async () => {
-  await withHistoryCacheDir(async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), 'sm-hist-prompts-cap-'))
-    const artifactPath = path.join(dir, 'session.jsonl.zstd')
-    try {
-      await writeFile(artifactPath, 'log-v1')
-      const { handlers } = makeCtx({
-        archivedIds: [],
-        headers: [{ id: 's1', cwd: 'C:\\x', createdAt: 0 }],
-        agents: new Map(),
-        sessionPersistence: { locate: (header) => ({ path: artifactPath }) },
-        readSessions: { s1: [userMessageEvent('占位', 100)] },
-      })
-      await requestUntilAligned(handlers, '?sessionId=s1&scope=prompts')
-      // 空白文本拒绝
-      const blank = await postJson(handlers, '/api/session-manager/prompts/toggle', { text: '   ' })
-      assert.equal(blank.status, 400)
-      // 截断:HISTORY_INPUT_MAX_CHARS 以上裁到上限
-      const long = '长'.repeat(HISTORY_INPUT_MAX_CHARS + 10)
-      await postJson(handlers, '/api/session-manager/prompts/toggle', { text: long })
-      const listed = response()
-      await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=prompts'), listed)
-      assert.equal(listed.body.inputs[0].text.length, HISTORY_INPUT_MAX_CHARS)
-      await postJson(handlers, '/api/session-manager/prompts/toggle', { text: '长'.repeat(HISTORY_INPUT_MAX_CHARS) })
-      // 上限:超过 HISTORY_PROMPTS_MAX 后最旧被裁
-      for (let i = 0; i < HISTORY_PROMPTS_MAX + 1; i++) {
-        await postJson(handlers, '/api/session-manager/prompts/toggle', { text: '条目' + i })
-      }
-      const capped = response()
-      await handlers.get('/api/session-manager/inputs')(getRequest('?sessionId=s1&scope=prompts'), capped)
-      assert.equal(capped.body.inputs.length, HISTORY_PROMPTS_MAX)
-      assert.equal(capped.body.inputs.some((item) => item.text === '条目0'), false, '最旧条目被裁掉')
-      assert.equal(capped.body.inputs[0].text, '条目' + HISTORY_PROMPTS_MAX, '最新条目在顶部')
-    } finally {
-      await rm(dir, { recursive: true, force: true })
-    }
-  })
-})
-
-test('常用提示词:client 与 core 的 HISTORY_SCOPES 镜像同序同值,默认落点为当前会话', { skip: process.env.TEST_SKIP_PARITY }, async () => {
-  const clientSource = await readFile(new URL('../src/client.js', import.meta.url), 'utf8')
-  const declared = clientSource.match(/const HISTORY_SCOPES = (\[[^\]]*\])/)
-  assert.ok(declared, 'client.js 必须内联声明 HISTORY_SCOPES')
-  assert.deepEqual(JSON.parse(declared[1].replace(/'/g, '"')), HISTORY_SCOPES)
-  const labels = clientSource.match(/const HISTORY_SCOPE_LABELS = (\[[^\]]*\])/)
-  assert.ok(labels, 'client.js 必须内联声明 HISTORY_SCOPE_LABELS')
-  assert.equal(JSON.parse(labels[1].replace(/'/g, '"')).length, HISTORY_SCOPES.length, '标签与范围一一对应')
-  assert.equal(HISTORY_SCOPES.indexOf('session'), 1, '浮层默认落点为当前会话(索引 1)')
-})
-
-test('历史浮层启停:GET 默认启用,POST 切换经 settings 持久,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/history-enabled')(getRequest2('/api/session-manager/history-enabled', 'GET'), initial)
-  assert.equal(initial.body.enabled, true, '默认启用')
-  const off = await postJson(handlers, '/api/session-manager/history-enabled', { enabled: false })
-  assert.equal(off.body.enabled, false)
-  // settings 持久:重读反映关闭态;POST 回 true 恢复
-  const reread = response()
-  await handlers.get('/api/session-manager/history-enabled')(getRequest2('/api/session-manager/history-enabled', 'GET'), reread)
-  assert.equal(reread.body.enabled, false, 'settings 持久化关闭态')
-  await postJson(handlers, '/api/session-manager/history-enabled', { enabled: true })
-  const restored = response()
-  await handlers.get('/api/session-manager/history-enabled')(getRequest2('/api/session-manager/history-enabled', 'GET'), restored)
-  assert.equal(restored.body.enabled, true)
-})
-
-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] 为守卫基准')
-})
-
-function getRequest2(url, method) {
-  const req = new EventEmitter()
-  req.method = method
-  req.url = url
-  return req
-}
+// 路由层 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 },
+    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,
+  timerAvailable,
+  readSessions,
+}) {
+  const routes = []
+  const eventHandlers = {}
+  const pendingInjects = []
+  const ledgerDomain = ledger === undefined ? makeLedgerDomain([]) : ledger
+  const workspaceList = workspaces || []
+  const settingsState = { value: settingsValue }
+  const settingsService = {
+    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) },
+    get: (name) => ({ 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, undefined)
+  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 }
+      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('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('周期评估:缩短间隔经 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] 为守卫基准')
+})
+