@mzzsfy/dsh-maintain 0.8.0 → 0.10.0

package/test/restart-ready.test.mjs

@@ -197,23 +197,23 @@ test('restartTick 调用点实参完整性:轮询 effect 必须传 readyStreak=p
   assert.match(callSite[1], /readyStreak:\s*prev\.readyStreak/, 'restartTick 调用点缺少 readyStreak: prev.readyStreak 实参')
 })
 
-// 升级浮条终态文案:ok 落定后 stale / 手动直跑 / 自动重启三条终态分流,失败与未知不在此列
+// 升级浮条终态文案:ok 落定后 stale / 自动重启两条终态分流,失败与未知不在此列
 const clientUpgradeFinalText = extractLogic('upgradeFinalText')
 
 // 重启确认态文案:armed 且有活跃计数时改「仍要重启」
 const clientRestartConfirmLabel = extractLogic('restartConfirmLabel')
 
-test('upgradeFinalText: stale 优先于两种重启指引,不得引导重启', () => {
-  const text = clientUpgradeFinalText({ ok: true, stale: true, requiresManualRestart: true, autoRestartScheduled: true })
-  assert.match(text, /未前进|未达目标/)
+test('upgradeFinalText: stale 优先于重启指引,不得引导重启', () => {
+  const text = clientUpgradeFinalText({ ok: true, stale: true, autoRestartScheduled: true })
+  // stale 口径泛化:未前进/未达目标/未落到目标/未装到指定版本统称与安装意图不符
+  assert.match(text, /意图不符/)
   assert.doesNotMatch(text, /重启/)
 })
 
-test('upgradeFinalText: 手动直跑终态指向手动重启,自动重启终态指向页面自恢复', () => {
-  assert.match(clientUpgradeFinalText({ ok: true, stale: false, requiresManualRestart: true, autoRestartScheduled: false }), /手动重启/)
-  assert.match(clientUpgradeFinalText({ ok: true, stale: false, requiresManualRestart: false, autoRestartScheduled: true }), /自动重启/)
+test('upgradeFinalText: 自动重启终态指向页面自恢复,默认终态指向手动重启', () => {
+  assert.match(clientUpgradeFinalText({ ok: true, stale: false, autoRestartScheduled: true }), /自动重启/)
   // 默认成功终态
-  assert.match(clientUpgradeFinalText({ ok: true, stale: false, requiresManualRestart: false, autoRestartScheduled: false }), /重启宿主/)
+  assert.match(clientUpgradeFinalText({ ok: true, stale: false, autoRestartScheduled: false }), /重启宿主/)
 })
 
 test('restartConfirmLabel: armed 且活跃计数>0 才显示仍要重启文案', () => {
@@ -239,7 +239,7 @@ test('client 自动重启接管:单一守卫函数,订阅回调与初始加载
 
 test('client 落定补查:未见自动重启标记时延迟宽限补查一拍再终判', () => {
   const source = clientSource()
-  // 落定拍 running 翻转与宿主置调度标记之间存在 await 窗口:未见标记不得立即终判
+  // 落定拍可见时继续运行路径的 stale 复读可能尚未完成:未见调度标记不得立即终判
   assert.match(source, /setTimeout\(\(\)\s*=>\s*\{[\s\S]*?recheckUpgradeSettle\(/, '落定拍未见标记必须延迟补查')
   assert.match(source, /async function recheckUpgradeSettle\([\s\S]*?broadcastUpgradeStatus\(final\)/, '补查必须广播以驱动接管守卫')
   assert.match(source, /upgradeWatch\.generation !== null\) return[\s\S]*?recheckUpgradeSettle|recheckUpgradeSettle\([\s\S]*?upgradeWatch\.generation !== null\) return/, '补查前后必须验让位新观察')

package/test/route.test.mjs

@@ -6,7 +6,7 @@ import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { EventEmitter } from 'node:events'
 
-import { apply, RESTART_DELAY_MS, AUTO_RESTART_DELAY_MS, UPGRADE_LOCK_PATH, collectActiveWork } from '../src/index.js'
+import { apply, RESTART_DELAY_MS, AUTO_RESTART_DELAY_MS, UPGRADE_LOCK_PATH, RELEASE_NOTES_CACHE_MAX, collectActiveWork } from '../src/index.js'
 import { rmSync, readFileSync } from 'node:fs'
 
 // 锁文件是固定共享路径:测试进程中断可能残留幽灵锁毒化后续运行,用例前预热清理
@@ -137,10 +137,10 @@ const realSleep = (ms) => new Promise((resolve) => {
   setImmediate(spin)
 })
 
-test('挂载:8 条路由注册,启动检查后快照就绪', async () => {
+test('挂载:9 条路由注册,启动检查后快照就绪', async () => {
   const { ctx, routes } = makeCtx()
   apply(ctx)
-  assert.equal(routes.size, 8)
+  assert.equal(routes.size, 9)
   assert.deepEqual(
     [...routes.keys()].sort(),
     [
@@ -148,6 +148,7 @@ test('挂载:8 条路由注册,启动检查后快照就绪', async () => {
       '/api/maintain/poll-interval',
       '/api/maintain/refresh',
       '/api/maintain/registry-base',
+      '/api/maintain/release-notes',
       '/api/maintain/restart',
       '/api/maintain/status',
       '/api/maintain/upgrade',
@@ -156,16 +157,7 @@ test('挂载:8 条路由注册,启动检查后快照就绪', async () => {
   )
   // 启动检查是异步链(mock fetch 微任务 + resolveHostVersion 真实文件读),
   // 轮询等快照落定后再断言
-  let snapshotReady = false
-  for (let waited = 0; waited < 5000; waited += 25) {
-    const poll = await call(routes, '/api/maintain/status', makeReq({ method: 'GET' }))
-    if (poll.payload.checkedAt !== null) {
-      snapshotReady = true
-      break
-    }
-    await new Promise((resolve) => setTimeout(resolve, 25))
-  }
-  assert.ok(snapshotReady, '启动检查 5 秒内未完成')
+  assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
   const res = await call(routes, '/api/maintain/status', makeReq({ method: 'GET' }))
   assert.equal(res.status, 200)
   assert.equal(res.payload.packageName, '@deepseek-ai/dsh')
@@ -209,8 +201,10 @@ test('interval dispose 回归:fiber 停用后轮询 tick 失效(防双 interval
 test('方法守卫:全部路由错误方法一律 405', async () => {
   const { ctx, routes } = makeCtx()
   apply(ctx)
+  // GET 端点(status/release-notes)以 POST 拒绝,其余以 GET 拒绝
+  const readPaths = ['/api/maintain/status', '/api/maintain/release-notes']
   for (const path of routes.keys()) {
-    const expected = path === '/api/maintain/status' ? 'POST' : 'GET'
+    const expected = readPaths.indexOf(path) >= 0 ? 'POST' : 'GET'
     const res = await call(routes, path, makeReq({ method: expected }))
     assert.equal(res.status, 405, path + ' 应拒绝 ' + expected)
   }
@@ -295,28 +289,38 @@ test('registry-base:非法 scheme 400;合法值持久化', async () => {
   assert.equal(store.registryBase, 'https://mirror.example')
 })
 
-test('upgrade:运行版本已是通道最新 409 拒绝(防降级),unknown 放行', async () => {
+test('upgrade:运行版本已是通道最新放行(重装/回退场景),不再 409 拒绝', async () => {
   const store = { upgradeCommandTemplate: 'node -e "process.exit(0)"' }
   // 版本探测注入受控值:CI 无 dsh 本体,真实盘读回 null 会把 verdict 打成 unknown,
-  // 防降级门控(核心断言)在 CI 恒不触发
+  // 重装放行断言(本用例核心)在 CI 恒不触发
   const { ctx, routes } = makeCtx({
     settingsStore: store,
     services: { hostVersionProbe: () => Promise.resolve('5.4.3') },
   })
   apply(ctx)
-  // 注入运行版本远低于假目标版本:verdict 应转 up-to-date,升级入口拒绝
+  // 注入运行版本远高于假目标版本:verdict 应转 up-to-date,安装入口照常放行
   const originalFetch = globalThis.fetch
   globalThis.fetch = async () => tagsBody({ latest: '0.0.1', next: '0.0.2' })
+  const warns = []
+  const originalWarn = console.warn
+  console.warn = (text) => warns.push(String(text))
   try {
     const refreshed = await post(routes, '/api/maintain/refresh')
     assert.equal(refreshed.status, 200)
     assert.equal(refreshed.payload.verdict, 'up-to-date', '前置:注入运行版本应高于 0.0.1 假目标')
-    const denied = await post(routes, '/api/maintain/upgrade', { autoRestart: true })
-    assert.equal(denied.status, 409)
-    assert.match(denied.payload.error, /已是通道最新版/)
-    assert.equal(store.upgradeCommandTemplate, 'node -e "process.exit(0)"', '拒绝路径不得触发升级')
+    const accepted = await post(routes, '/api/maintain/upgrade', { autoRestart: true })
+    assert.equal(accepted.status, 200, '已是通道最新必须放行:重装修复与回退是显式用户意图')
+    assert.equal(accepted.payload.upgrade.running, true)
+    for (let i = 0; i < 50; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      const status = await get(routes, '/api/maintain/status').then((r) => r.payload).catch(() => null)
+      if (status && status.upgrade && status.upgrade.running === false && status.upgrade.last !== null) break
+    }
+    assert.equal(store.upgradeCommandTemplate, 'node -e "process.exit(0)"', '放行路径命令模板不得被改动')
+    assert.ok(warns.some((text) => /audit endpoint=upgrade outcome=triggered/.test(text)), '放行安装须留审计行')
   } finally {
     globalThis.fetch = originalFetch
+    console.warn = originalWarn
   }
 })
 
@@ -420,10 +424,8 @@ test('upgrade:托管+勾选自动重启,命令成功即调度关机且落定钩
     // 关机路径零复读:版本复读属升级后磁盘读取,是明确的故障源,砍掉
     assert.equal(settled.upgrade.last.installedVersion, null, '关机路径禁止复读磁盘版本')
     assert.equal(settled.upgrade.last.stale, null, '关机路径无 stale 判定')
-    assert.equal(settled.upgrade.last.requiresManualRestart, undefined)
     assert.equal(settled.autoRestartScheduled, true, '命令成功即调度关机(stale 不再抑制)')
     assert.equal(settled.upgradeLockHeld, false, '升级结束后锁文件应删除')
-    assert.ok(typeof settled.runtimeEnv === 'object' && typeof settled.runtimeEnv.kind === 'string', 'runtimeEnv 必须进 status')
     // 落定钩子零网络:观察窗口内 fetch 计数不得增长(runCheck 已随关机路径移除)
     await realSleep(300)
     assert.equal(fetchCalls, baseline, '落定钩子禁止网络请求')
@@ -577,7 +579,6 @@ test('upgrade:未勾选自动重启,升级成功落定继续运行并标 stale',
     assert.equal(settled.upgrade.last.stale, true, '继续运行路径必须复读并标注 stale')
     assert.ok(typeof settled.upgrade.last.reason === 'string' && settled.upgrade.last.reason.length > 0, 'stale 必须带原因')
     assert.equal(settled.autoRestartScheduled, false, '未勾选不得置调度标记')
-    assert.equal(settled.upgrade.last.requiresManualRestart, undefined, '托管环境未勾选不标手动指引')
     // 推过完整调度延迟:若误调度,延迟窗口内 exit 必被调用
     t.mock.timers.tick(AUTO_RESTART_DELAY_MS + 1)
     assert.deepEqual(exits, [], '未勾选自动重启时禁止调度任何宿主退出')
@@ -586,6 +587,39 @@ test('upgrade:未勾选自动重启,升级成功落定继续运行并标 stale',
   }
 })
 
+test('upgrade:模板钉定版本时按钉定意图判 fresh(通道目标不参与对拍)', async (t) => {
+  // 假命令携带钉定 token(参数位),语义等同 `npm i -g pkg@1.0.0` 但不真装
+  const store = { upgradeCommandTemplate: 'node -e "process.exit(0)" @deepseek-ai/dsh@1.0.0' }
+  const exits = []
+  const { ctx, routes } = makeCtx({
+    settingsStore: store,
+    appExit: (code) => exits.push(code),
+    // 探针恒读 1.0.0:钉定 1.0.0 时"磁盘未变"即达成,不得按通道目标误报 stale
+    services: { hostVersionProbe: () => Promise.resolve('1.0.0') },
+  })
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  apply(ctx)
+  await drainMicrotasks()
+  const trigger = await post(routes, '/api/maintain/upgrade', { autoRestart: false })
+  assert.equal(trigger.status, 200)
+  let settled = null
+  try {
+    for (let i = 0; i < 50 && settled === null; i += 1) {
+      await realSleep(30)
+      const status = await get(routes, '/api/maintain/status').then((r) => r.payload).catch(() => null)
+      if (status && status.upgrade && status.upgrade.running === false && status.upgrade.last !== null) settled = status
+    }
+    assert.ok(settled, '升级应在假命令退出后落定')
+    assert.equal(settled.upgrade.last.ok, true)
+    assert.equal(settled.upgrade.last.stale, false, '钉定版本装到位即达成')
+    assert.equal(settled.upgrade.last.reason, null)
+    t.mock.timers.tick(AUTO_RESTART_DELAY_MS + 1)
+    assert.deepEqual(exits, [])
+  } finally {
+    rmSync(UPGRADE_LOCK_PATH, { force: true })
+  }
+})
+
 test('upgrade:勾选自动重启+落定,延迟窗口后调度宿主退出', async (t) => {
   const store = { upgradeCommandTemplate: 'node -e "process.exit(0)"' }
   const exits = []
@@ -610,9 +644,8 @@ test('upgrade:勾选自动重启+落定,延迟窗口后调度宿主退出', asyn
     assert.ok(settled, '升级应在假命令退出后落定')
     assert.equal(settled.upgrade.last.ok, true)
     assert.equal(settled.upgrade.last.stale, null, '关机路径零复读,stale 不再判定')
-    // 落定可见与调度置位之间隔 runtimeEnvReady 的 await:await 一次 status 让微任务链走完再断言
-    const scheduled = await get(routes, '/api/maintain/status').then((r) => r.payload)
-    assert.equal(scheduled.autoRestartScheduled, true, '勾选自动重启时升级成功必须调度')
+    // 调度标记与 running=false 同拍置位,落定快照直接可断言
+    assert.equal(settled.autoRestartScheduled, true, '勾选自动重启时升级成功必须调度')
     assert.deepEqual(exits, [], '调度延迟窗口内不得提前退出')
     t.mock.timers.tick(AUTO_RESTART_DELAY_MS + 1)
     assert.deepEqual(exits, [0], '延迟窗口过后必须调度宿主退出')
@@ -821,16 +854,17 @@ test('restart:null 体按空体处理,内部形态不泄漏', async (t) => {
   assert.deepEqual(exits, [0], 'null 体等价空体:正常调度退出')
 })
 
-test('自动重启接线:落定链消费运行环境并分流调度与手动指引(源码形态锁定)', () => {
+test('自动重启接线:落定链只取内存输入并直接分流调度(源码形态锁定)', () => {
   const source = readFileSync(new URL('../src/index.js', import.meta.url), 'utf8')
   const settle = source.match(/const decision = judgeAutoRestart\(\{([\s\S]*?)\}\)/)
   assert.ok(settle, '落定链缺少 judgeAutoRestart 判定')
-  assert.match(settle[1], /runtimeKind: runtimeEnv\.kind/, '落定判定必须消费运行环境检测结果')
-  assert.match(source, /if \(decision\.requiresManualRestart === true\) last\.requiresManualRestart = true/, '手动直跑指引必须回写 last')
+  assert.doesNotMatch(settle[1], /runtimeKind|runtimeEnv/, '落定判定禁止消费运行环境:升级即调度与启动形态无关')
+  assert.doesNotMatch(source, /requiresManualRestart/, '手动直跑指引链必须整体移除,不得残留回写')
   assert.match(source, /if \(decision\.schedule === true\) \{[\s\S]*?last\.autoRestartScheduled = true[\s\S]*?scheduleHostExit\(\{ detail: 'reason=upgrade-ok', autoRestart: true/, '调度链必须置位标记并经统一退出入口关机')
 })
 
-test('upgrade:env 注入手动直跑环境,落定链保守分流零退出', async () => {
+test('upgrade:运行环境不参与自动重启判定(env 注入 manual 仍调度关机)', async () => {
+  // DSH_MAINTAIN_RUNTIME_ENV 已无消费者:注入历史值证明判定与运行环境彻底解耦
   process.env.DSH_MAINTAIN_RUNTIME_ENV = 'manual'
   try {
     const store = { upgradeCommandTemplate: 'node -e "process.exit(0)"' }
@@ -845,11 +879,9 @@ test('upgrade:env 注入手动直跑环境,落定链保守分流零退出', asyn
       if (status && status.upgrade && status.upgrade.running === false && status.upgrade.last !== null) settled = status
     }
     assert.ok(settled, '升级应在假命令退出后落定')
-    assert.equal(settled.runtimeEnv.kind, 'manual-start-likely', 'env 注入必须经 apply 检测进 status')
-    assert.equal(settled.autoRestartScheduled, false, '手动直跑禁止调度自动重启')
-    assert.deepEqual(exits, [], '手动直跑禁止任何宿主退出')
-    // 手动直跑标环境指引:命令成功即提示手动重启(指引不再被 stale 抑制)
-    assert.equal(settled.upgrade.last.requiresManualRestart, true, '手动直跑必须标手动重启指引')
+    assert.equal(settled.autoRestartScheduled, true, '升级成功勾选即调度,运行环境不得抑制')
+    assert.equal(settled.upgrade.last.requiresManualRestart, undefined, '手动指引链已移除')
+    assert.deepEqual(exits, [], '调度延迟窗口内不得提前退出')
   } finally {
     delete process.env.DSH_MAINTAIN_RUNTIME_ENV
   }
@@ -891,4 +923,216 @@ test('audit:触发/落定/拒绝各留一行结构化日志', async () => {
   }
   assert.equal(plainWarns.some((text) => /audit endpoint=upgrade outcome=triggered/.test(text)), true, '升级触发须留审计行')
   assert.equal(plainWarns.some((text) => /audit endpoint=upgrade outcome=(ok|failed) durationMs=[0-9]+ code=/.test(text)), true, '升级落定须留审计行')
-})
+})
+
+// ---- release notes 路由 ----
+
+const RELEASE_PATH = '/api/maintain/release-notes'
+// 发布页 fixture:与真实页面同构(relative-time + markdown-body 正文容器),正文映射由 core 提取器完成
+const RELEASE_HTML = '<!doctype html><html><body>'
+  + '<relative-time datetime="2026-09-10T03:09:00Z"></relative-time>'
+  + '<div data-test-selector="body-content" class="markdown-body">'
+  + '<h3>更新内容</h3>'
+  + '<ul><li>新功能</li><li>问题修复</li></ul>'
+  + '<p>详情见发布页。</p>'
+  + '</div></body></html>'
+const RELEASE_URL = 'https://github.com/deepseek-ai/deepseek-harness/releases/tag/dsh-v9.9.9'
+const RELEASE_BODY = ['### 更新内容', '- 新功能', '- 问题修复', '', '详情见发布页。'].join('\n')
+
+function releaseHtmlBody() {
+  const chunks = [new TextEncoder().encode(RELEASE_HTML)]
+  return {
+    getReader: () => ({
+      read: async () => (chunks.length ? { done: false, value: chunks.shift() } : { done: true, value: undefined }),
+      cancel: async () => {},
+    }),
+  }
+}
+
+// dist-tags 与 GitHub 发布页双上游分流:registry 路径回 tags 形态,GitHub 路径回页面形态
+function installDualUpstream({ requestedUrls, releaseThrows }) {
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async (url, options) => {
+    const text = String(url)
+    if (text.includes('/releases/tag/')) {
+      requestedUrls.push(text)
+      if (releaseThrows) throw new Error(releaseThrows)
+      return { ok: true, status: 200, body: releaseHtmlBody() }
+    }
+    void options
+    return tagsBody(MOCK_TAGS)
+  }
+  return () => { globalThis.fetch = originalFetch }
+}
+
+async function waitSnapshotReady(routes) {
+  for (let waited = 0; waited < 5000; waited += 25) {
+    const poll = await get(routes, '/api/maintain/status').then((r) => r.payload).catch(() => null)
+    if (poll && poll.checkedAt !== null) return poll
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+  return null
+}
+
+test('release-notes:默认取通道最新版,200 返回发布说明', async () => {
+  const requestedUrls = []
+  const restore = installDualUpstream({ requestedUrls })
+  try {
+    const { ctx, routes } = makeCtx({ services: { hostVersionProbe: () => Promise.resolve('5.4.3') } })
+    apply(ctx)
+    assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
+    const res = await get(routes, RELEASE_PATH)
+    assert.equal(res.status, 200)
+    assert.deepEqual(res.payload, {
+      version: '9.9.9',
+      url: RELEASE_URL,
+      publishedAt: '2026-09-10T03:09:00Z',
+      body: RELEASE_BODY,
+    })
+    assert.equal(requestedUrls.length, 1)
+    assert.ok(requestedUrls[0].endsWith('/releases/tag/dsh-v9.9.9'), '默认版本必须取通道 latest 的目标')
+  } finally {
+    restore()
+  }
+})
+
+test('release-notes:缓存生效,切通道后按新通道版本拉取', async () => {
+  const requestedUrls = []
+  const restore = installDualUpstream({ requestedUrls })
+  try {
+    const { ctx, routes } = makeCtx()
+    apply(ctx)
+    assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
+    const first = await get(routes, RELEASE_PATH)
+    assert.equal(first.status, 200)
+    assert.equal(first.payload.version, '9.9.9')
+    assert.ok(requestedUrls[0].endsWith('/releases/tag/dsh-v9.9.9'))
+    const again = await get(routes, RELEASE_PATH)
+    assert.equal(again.status, 200)
+    assert.equal(requestedUrls.length, 1, '同版本两次调用必须命中缓存,上游仅一次')
+    const switched = await post(routes, '/api/maintain/channel', { channel: 'next' })
+    assert.equal(switched.status, 200)
+    assert.equal(switched.payload.channelLatest, '10.0.0')
+    const after = await get(routes, RELEASE_PATH)
+    assert.equal(after.status, 200)
+    assert.equal(after.payload.version, '10.0.0')
+    assert.equal(requestedUrls.length, 2, '通道版本变化必须重新拉取')
+    assert.ok(requestedUrls[1].endsWith('/releases/tag/dsh-v10.0.0'))
+  } finally {
+    restore()
+  }
+})
+
+test('release-notes:tags 未就绪且无 version 400 提示先检查更新', async () => {
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async () => { throw new Error('ECONNREFUSED') }
+  try {
+    const { ctx, routes } = makeCtx()
+    apply(ctx)
+    assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
+    const res = await get(routes, RELEASE_PATH)
+    assert.equal(res.status, 400)
+    assert.match(res.payload.error, /检查更新/)
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('release-notes:通道标签非 semver,构建上游标签前归一 400', async () => {
+  const requestedUrls = []
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async (url, options) => {
+    const text = String(url)
+    if (text.includes('/releases/tag/')) {
+      requestedUrls.push(text)
+      return { ok: true, status: 200, body: releaseHtmlBody() }
+    }
+    return tagsBody({ latest: 'banana' })
+  }
+  try {
+    const { ctx, routes } = makeCtx()
+    apply(ctx)
+    assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
+    const res = await get(routes, RELEASE_PATH)
+    assert.equal(res.status, 400)
+    assert.match(res.payload.error, /semver/, '病理标签必须在触达上游前被 semver 白名单拦截')
+    assert.equal(requestedUrls.length, 0, '拒绝路径不得触达上游')
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('release-notes:重启调度窗口内 409,不发起上游请求', async (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const requestedUrls = []
+  const restore = installDualUpstream({ requestedUrls })
+  try {
+    const { ctx, routes } = makeCtx({ appExit: () => {} })
+    apply(ctx)
+    const restart = await post(routes, '/api/maintain/restart')
+    assert.equal(restart.status, 200)
+    const res = await get(routes, RELEASE_PATH)
+    assert.equal(res.status, 409, '关机窗口内查询更新内容必须拒绝')
+    assert.match(res.payload.error, /重启已调度/)
+    assert.equal(requestedUrls.length, 0, '关机窗口内不得发起上游请求')
+    t.mock.timers.tick(RESTART_DELAY_MS + 1)
+  } finally {
+    restore()
+  }
+})
+
+test('release-notes:缓存超限 FIFO 淘汰,最早键被逐出', async () => {
+  // N+1 个通道各配独立版本:逐个切换并查看,第 N+1 键入缓存时第 1 键必被淘汰;
+  // 回访第 1 通道触发重新拉取,回访末位通道命中缓存不再拉取
+  const channels = {}
+  for (let i = 1; i <= RELEASE_NOTES_CACHE_MAX + 1; i += 1) channels['c' + i] = '1.0.' + i
+  const requestedUrls = []
+  const originalFetch = globalThis.fetch
+  globalThis.fetch = async (url) => {
+    if (String(url).includes('/releases/tag/')) {
+      requestedUrls.push(String(url))
+      return { ok: true, status: 200, body: releaseHtmlBody() }
+    }
+    return tagsBody(channels)
+  }
+  try {
+    const { ctx, routes } = makeCtx()
+    apply(ctx)
+    assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
+    for (const [name, version] of Object.entries(channels)) {
+      const switched = await post(routes, '/api/maintain/channel', { channel: name })
+      assert.equal(switched.status, 200)
+      const res = await get(routes, RELEASE_PATH)
+      assert.equal(res.status, 200)
+      assert.equal(res.payload.version, version)
+    }
+    assert.equal(requestedUrls.length, RELEASE_NOTES_CACHE_MAX + 1, '每通道版本独立,各拉取一次')
+    const first = Object.keys(channels)[0]
+    const last = Object.keys(channels)[RELEASE_NOTES_CACHE_MAX]
+    const backToFirst = await post(routes, '/api/maintain/channel', { channel: first })
+    assert.equal(backToFirst.status, 200)
+    await get(routes, RELEASE_PATH)
+    assert.equal(requestedUrls.length, RELEASE_NOTES_CACHE_MAX + 2, '最早键已被淘汰,回访必须重新拉取')
+    const backToLast = await post(routes, '/api/maintain/channel', { channel: last })
+    assert.equal(backToLast.status, 200)
+    await get(routes, RELEASE_PATH)
+    assert.equal(requestedUrls.length, RELEASE_NOTES_CACHE_MAX + 2, '未淘汰键回访必须命中缓存')
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('release-notes:上游失败 400 带错误信息', async () => {
+  const requestedUrls = []
+  const restore = installDualUpstream({ requestedUrls, releaseThrows: 'ECONNRESET' })
+  try {
+    const { ctx, routes } = makeCtx()
+    apply(ctx)
+    assert.ok(await waitSnapshotReady(routes), '启动检查 5 秒内未完成')
+    const res = await get(routes, RELEASE_PATH)
+    assert.equal(res.status, 400)
+    assert.match(res.payload.error, /ECONNRESET/)
+  } finally {
+    restore()
+  }
+})

package/test/upgrade.test.mjs

@@ -12,7 +12,6 @@ import {
   UPGRADE_FAIL_NPM_MISSING,
   UPGRADE_FAIL_TIMEOUT,
 } from '../src/core.mjs'
-import { RUNTIME_KINDS } from '../src/runtime.mjs'
 
 // 脚本体一律单引号:Windows shell 化 spawn 经 cmd.exe,双层双引号会被截断。
 const NODE = 'node'
@@ -219,29 +218,20 @@ test('重试:假命令真实进程 文件锁失败后重试成功', async () =>
   }
 })
 
-test('自动重启:四条件守卫(成功/非手动直跑/enabled/appExit 可用)', () => {
-  // 成功+托管(含 unknown)+enabled=true → 调度
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: true, enabled: true }), { schedule: true, requiresManualRestart: false })
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.DECLARED_MANAGED, hasExit: true, enabled: true }), { schedule: true, requiresManualRestart: false })
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.PM2, hasExit: true, enabled: true }), { schedule: true, requiresManualRestart: false })
+test('自动重启:三条件守卫(成功/enabled/appExit 可用),运行环境不参与判定', () => {
+  // 成功+enabled → 调度:宿主退出动作与重启按钮同一入口,拉起责任在启动方式
+  assert.deepEqual(judgeAutoRestart({ ok: true, hasExit: true, enabled: true }), { schedule: true })
   // 失败不调度
-  assert.deepEqual(judgeAutoRestart({ ok: false, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: true, enabled: true }), { schedule: false, requiresManualRestart: false })
-  // 手动直跑 → 手动指引,不调度
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.MANUAL_START, hasExit: true, enabled: true }), { schedule: false, requiresManualRestart: true })
+  assert.deepEqual(judgeAutoRestart({ ok: false, hasExit: true, enabled: true }), { schedule: false })
   // appExit 缺失不调度
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: false, enabled: true }), { schedule: false, requiresManualRestart: false })
-  // 手动直跑与 appExit 缺失并存 → 仍以手动指引标记(指引面板,与退出能力无关)
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.MANUAL_START, hasExit: false, enabled: true }), { schedule: false, requiresManualRestart: true })
+  assert.deepEqual(judgeAutoRestart({ ok: true, hasExit: false, enabled: true }), { schedule: false })
 })
 
 test('自动重启:enabled 严格 boolean,仅 true 调度', () => {
-  // 显式 false:托管(含 unknown)不调度、不标手动指引
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: true, enabled: false }), { schedule: false, requiresManualRestart: false })
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.DECLARED_MANAGED, hasExit: true, enabled: false }), { schedule: false, requiresManualRestart: false })
-  // 手动直跑指引是环境约束事实,不受勾选影响
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.MANUAL_START, hasExit: true, enabled: false }), { schedule: false, requiresManualRestart: true })
+  // 显式 false 不调度
+  assert.deepEqual(judgeAutoRestart({ ok: true, hasExit: true, enabled: false }), { schedule: false })
   // 非 true 一律不调度:调用点经升级路由严格 boolean 校验,此处锁定纯函数自身契约
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: true, enabled: undefined }), { schedule: false, requiresManualRestart: false })
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: true, enabled: null }), { schedule: false, requiresManualRestart: false })
-  assert.deepEqual(judgeAutoRestart({ ok: true, runtimeKind: RUNTIME_KINDS.UNKNOWN, hasExit: true, enabled: 'true' }), { schedule: false, requiresManualRestart: false })
+  assert.deepEqual(judgeAutoRestart({ ok: true, hasExit: true, enabled: undefined }), { schedule: false })
+  assert.deepEqual(judgeAutoRestart({ ok: true, hasExit: true, enabled: null }), { schedule: false })
+  assert.deepEqual(judgeAutoRestart({ ok: true, hasExit: true, enabled: 'true' }), { schedule: false })
 })

package/src/runtime.mjs

@@ -1,69 +0,0 @@
-// 运行环境检测:判定宿主进程是否处于托管启动形态,决定升级后可否自动重启。
-// 纯函数,探测点经参数注入;顺序:env 显式覆盖 > 进程环境表 > POSIX 容器探测 > 双 TTY > unknown。
-import { stat, readFile } from 'node:fs/promises'
-
-export const RUNTIME_KINDS = Object.freeze({
-  DECLARED_MANAGED: 'declared-managed',
-  PM2: 'pm2',
-  SYSTEMD: 'systemd',
-  SUPERVISORD: 'supervisord',
-  KUBERNETES: 'kubernetes',
-  DOCKER: 'docker',
-  CONTAINER: 'container',
-  MANUAL_START: 'manual-start-likely',
-  UNKNOWN: 'unknown',
-})
-
-// 环境覆盖键:managed|manual,测试与用户显式纠偏用
-const RUNTIME_ENV_OVERRIDE = 'DSH_MAINTAIN_RUNTIME_ENV'
-const OVERRIDE_MANAGED = 'managed'
-const OVERRIDE_MANUAL = 'manual'
-
-// 各托管形态的特征环境变量表:命中任一即声明
-const MANAGED_ENV_KEYS = Object.freeze([
-  [RUNTIME_KINDS.PM2, Object.freeze(['pm_id', 'PM2_HOME', 'pm_uptime'])],
-  [RUNTIME_KINDS.SYSTEMD, Object.freeze(['INVOCATION_ID', 'JOURNAL_STREAM', 'NOTIFY_SOCKET'])],
-  [RUNTIME_KINDS.SUPERVISORD, Object.freeze(['SUPERVISOR_ENABLED', 'SUPERVISOR_PROCESS_NAME'])],
-  [RUNTIME_KINDS.KUBERNETES, Object.freeze(['KUBERNETES_SERVICE_HOST'])],
-])
-
-const DOCKERENV_PATH = '/.dockerenv'
-const CGROUP_PATH = '/proc/1/cgroup'
-// cgroup 归类:/docker/ 与 dockerenv 同为 docker;kubepods 即 k8s;其余容器运行时归 container
-const CGROUP_DOCKER_PATTERN = /\/docker\//
-const CGROUP_K8S_PATTERN = /kubepods/
-const CGROUP_CONTAINER_PATTERN = /containerd|lxc|podman/
-
-const fallbackExists = async (path) => {
-  try {
-    await stat(path)
-    return true
-  } catch {
-    return false
-  }
-}
-
-const fallbackRead = async (path) => readFile(path, 'utf8')
-
-export async function detectRuntimeEnv({ env, platform, isTTY, existsImpl = fallbackExists, readFileImpl = fallbackRead }) {
-  const override = env[RUNTIME_ENV_OVERRIDE]
-  if (override === OVERRIDE_MANAGED) return { kind: RUNTIME_KINDS.DECLARED_MANAGED, declared: true }
-  if (override === OVERRIDE_MANUAL) return { kind: RUNTIME_KINDS.MANUAL_START, declared: false }
-
-  for (const [kind, keys] of MANAGED_ENV_KEYS) {
-    if (keys.some((key) => env[key])) return { kind, declared: true }
-  }
-
-  if (platform !== 'win32') {
-    try {
-      if (await existsImpl(DOCKERENV_PATH)) return { kind: RUNTIME_KINDS.DOCKER, declared: true }
-      const cgroup = await readFileImpl(CGROUP_PATH)
-      if (CGROUP_DOCKER_PATTERN.test(cgroup)) return { kind: RUNTIME_KINDS.DOCKER, declared: true }
-      if (CGROUP_K8S_PATTERN.test(cgroup)) return { kind: RUNTIME_KINDS.KUBERNETES, declared: true }
-      if (CGROUP_CONTAINER_PATTERN.test(cgroup)) return { kind: RUNTIME_KINDS.CONTAINER, declared: true }
-    } catch { /* 探测失败按未声明继续 */ }
-  }
-
-  if (isTTY.stdin === true && isTTY.stdout === true) return { kind: RUNTIME_KINDS.MANUAL_START, declared: false }
-  return { kind: RUNTIME_KINDS.UNKNOWN, declared: false }
-}