@mzzsfy/dsh-maintain 0.9.0 → 0.10.0

package/README.md

@@ -9,8 +9,8 @@ DeepSeek Harness 设置页插件:版本与进程运维一体化——监测 npm
 - 追踪通道:在 npm dist-tags 间切换(latest / next / alpha 等,选项由检查结果动态生成),切换后按新通道判定。
 - 一键安装:面板"安装"按钮全版本状态可点(升级、重装修复、回退均从面板直达,不再有"已是最新"禁用与 409 拒绝),点击弹出确认窗,窗内展示版本变更与将执行的实际命令(`{tag}` 已替换为追踪通道)及"安装完成后自动重启宿主"勾选项(默认勾选,本次安装会话级生效,不持久化),确认后才触发。版本变更按安装意图自动表述:命令模板含精确版本号(如 `@0.1.4`)即按"安装指定版本"表述并附改回 `{tag}` 的指引;否则按通道目标与运行版本分类为升级/重装/回退,信息不足(通道最新版未知或版本无法比较)时窗内明示无法判定,仍可确认安装。通道目标等于运行版本即重装(用于本体损坏或异常安装的修复);需要回退时把模板中的 `@{tag}` 改为指定版本号(如 `@0.1.4`),回退完成后改回 `{tag}` 形态,否则后续安装持续钉在该版本。安装期间串行化(含跨进程锁文件:宿主被外部重启后,残留安装子进程的锁在有效期内仍拒绝新安装),单次尝试超时 10 分钟强杀;安装后台执行,触发后可离开页面,右下角浮条持续提示进度,完成或失败时替换为结果提示,长时间无进展转提示刷新,回到页面查看结果并按提示重启生效;继续运行路径下安装完成后自动重新检查版本。
 - 失败分类与自动重试:升级命令失败按输出特征分类(文件锁 EBUSY/EPERM 等 Windows 全局目录占用、网络瞬断与 registry 5xx、命令未找到、超时强杀、其他未知),文件锁与网络类自动重试,最多 3 次尝试,退避序列文件锁 5s/15s、网络 3s/9s,重试时升级锁有效期顺延;命令未找到、超时与未知形态不重试直接落定。重试链的整体观察窗口与宿主侧重试上限同源锁定(parity),浮条不会在宿主仍在重试时抢跑转"状态未知"。
-- 安装结果校验:安装命令成功且宿主继续运行(手动直跑、本次未勾选自动重启或宿主不具备自动退出能力)时复读磁盘版本,按安装意图判定是否达成——钉定版本(命令含精确版本号)时恰装到该版本即达成;通道语义下目标高于来版(升级)时要求版本前进且达通道目标,版本未前进(镜像滞后或静默失败)或未达目标即标注 stale;目标等于来版(重装)时版本不变属预期;目标低于来版(回退,如切通道或装旧版)时恰落到通道目标即达成,静默未动同样拦下。未达成时面板与浮条标注 stale 提示;复读失败不标 stale(版本状态由启动检查兜底),通道目标未知时仅豁免未达目标判定(版本未前进仍拦下)。自动重启路径不做复读与 stale 判定(安装落定钩子禁止网络请求与磁盘读取),版本变化由重启后的启动检查呈现。残留升级锁(宿主被外部重启后的无主锁,疑似安装子进程仍在写全局目录)在有效期内拒绝新安装(409),等待锁过期或手动删除锁文件后重试。
-- 运行环境检测与升级后自动重启:host 启动时检测运行环境(pm2 / systemd / supervisord / Kubernetes / 容器,依据进程环境变量与 POSIX 容器特征,win32 跳过容器探测;stdin+stdout 双 TTY 判定为手动直跑;环境变量 DSH_MAINTAIN_RUNTIME_ENV=managed|manual 可强制指定,最高优先)。升级确认弹窗勾选自动重启且命令成功(退出码 0)时,托管环境下延迟 3 秒自动重启宿主——与面板"确认重启"共用同一退出调度入口(同一互斥、同一审计、同一延迟退出,仅审计行不同),落定钩子零网络请求零磁盘读取(npm 刚替换过宿主文件,避免半写状态故障);浮条提示宿主将自动重启并自动进入重启等待探测,页面随宿主恢复自动刷新;手动直跑环境不自动退出,浮条提示手动重启(弹窗内同步提示该环境约束);检测为未知形态按托管处理(维持自动重启,由重启等待总超时兜底提示)。升级失败或未勾选自动重启时不调度,后者升级完成仅提示,需在面板手动重启。
+- 安装结果校验:安装命令成功且宿主继续运行(本次未勾选自动重启或宿主不具备自动退出能力)时复读磁盘版本,按安装意图判定是否达成——钉定版本(命令含精确版本号)时恰装到该版本即达成;通道语义下目标高于来版(升级)时要求版本前进且达通道目标,版本未前进(镜像滞后或静默失败)或未达目标即标注 stale;目标等于来版(重装)时版本不变属预期;目标低于来版(回退,如切通道或装旧版)时恰落到通道目标即达成,静默未动同样拦下。未达成时面板与浮条标注 stale 提示;复读失败不标 stale(版本状态由启动检查兜底),通道目标未知时仅豁免未达目标判定(版本未前进仍拦下)。自动重启路径不做复读与 stale 判定(安装落定钩子禁止网络请求与磁盘读取),版本变化由重启后的启动检查呈现。残留升级锁(宿主被外部重启后的无主锁,疑似安装子进程仍在写全局目录)在有效期内拒绝新安装(409),等待锁过期或手动删除锁文件后重试。
+- 升级后自动重启:升级确认弹窗勾选自动重启且命令成功(退出码 0)时,延迟 3 秒自动重启宿主——与面板"确认重启"共用同一退出调度入口(同一互斥、同一审计、同一延迟退出,仅审计行不同),动作与运行环境无关:托管启动(pm2 / systemd / 容器等)由进程管理器拉起,手动终端启动则需你重新运行宿主(等同点击重启按钮后的流程)。落定钩子零网络请求零磁盘读取(npm 刚替换过宿主文件,避免半写状态故障);浮条提示宿主将自动重启并自动进入重启等待探测,页面随宿主恢复自动刷新,手动终端启动下该等待按 30 秒总时长超时转人工(见重启须知)。升级失败或未勾选自动重启时不调度,后者升级完成仅提示,需在面板手动重启;宿主不具备就地退出能力(appExit 缺失)时同样不调度。
 - 活跃工作门控:升级与重启前检测运行中的 agent 会话、后台 job 与终端(agents/jobs/terminals 服务全部软依赖方法面守卫;terminals 主路径逐 agent 的 realm 作用域解析,共享根探测仅兜底,无 agent 时服务面不可见属常态不计降级;降级按服务留痕限频一次)。部分降级时已实证的活跃计数仍生效(计数>0 照常拒绝);仅当完全不可用(计数为 0 且检测不可用)时放行,不因安全网缺失死锁操作。存在活跃工作时升级被拒绝(409,不可越过);重启被拒但确认态显示活跃计数,再次点击以 force 越过;概要随 status 提供给面板。
 - 审计日志:升级/重启的触发、落定与拒绝各输出一行结构化日志(`audit endpoint=… outcome=…`),动态串单行化,便于事后排查。
 - 面板设置编辑:升级命令、轮询间隔、镜像地址均可在面板直接编辑保存,与 settings.yaml 等效(轮询间隔保存即重排,镜像地址保存即重查);host 侧拒绝空命令、非 http(s) 地址与带查询串/锚点的镜像地址(拼接 dist-tags 路径时 query 会吞掉路径),面板清空输入即恢复对应默认值。
@@ -57,3 +57,7 @@ maintain:
 ```
 cd packages/dsh-maintain && npm test
 ```
+
+## dsh 版本兼容
+
+三版本全部通过:版本与运维页控件完整、检查/升级/重启入口可用、激活 live。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-maintain",
   "description": "DSH 自身的版本管理:追踪 npm dist-tag 新版本、一键升级、安全重启",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/client.js

@@ -160,8 +160,6 @@ function restartPostLost(error) {
 const VERDICT_OUTDATED = 'outdated'
 const VERDICT_UP_TO_DATE = 'up-to-date'
 const VERDICT_UNKNOWN = 'unknown'
-// 与 host runtime.mjs RUNTIME_KINDS.MANUAL_START 镜像(parity 对拍,单侧改名即测试失败)
-const RUNTIME_KIND_MANUAL = 'manual-start-likely'
 // 与 host AUTO_RESTART_DELAY_MS 镜像(parity 对拍):弹窗文案引用,勿手抄数字
 const AUTO_RESTART_DELAY_SEC = 3
 
@@ -227,8 +225,9 @@ async function recheckUpgradeSettle(previousLast) {
   if (upgradeWatch.generation !== null) return
   if (final !== null) broadcastUpgradeStatus(final)
   const last = final !== null && final.upgrade ? final.upgrade.last : null
-  if (last !== null && (last.autoRestartScheduled === true || last.requiresManualRestart === true)) showUpgradeFloat(last)
-  else showUpgradeFloat(previousLast)
+  if (last !== null && last.autoRestartScheduled === true) showUpgradeFloat(last)
+  // 补查仍无落定结果(观察窗错过且宿主已换代):转状态未知,不再停留进行中文案
+  else showUpgradeFloat(previousLast !== null ? previousLast : 'unknown')
 }
 
 function subscribeUpgradeStatus(listener) {
@@ -258,10 +257,11 @@ function ensureUpgradeWatch() {
       const upgrade = next ? next.upgrade : null
       if (!upgrade || upgrade.running !== true) {
         upgradeWatch.generation = null
-        // 快照归零(last 为空)不做失败渲染,保持进行中文案,由重启流程接管
+        // 落定拍(last 在)但未见调度标记不立即终判:继续运行路径的 stale 复读在
+        // 落定后异步完成,延迟宽限补查一拍再取终态;快照归零(last 空,宿主已换代)
+        // 同样补查,仍无结果即转状态未知,不留永久"进行中"
         if (upgrade && upgrade.last) {
-          // 落定拍可能早于宿主置调度标记:未见标记不立即终判,延迟宽限后补查一拍
-          if (upgrade.last.autoRestartScheduled === true || upgrade.last.requiresManualRestart === true) {
+          if (upgrade.last.autoRestartScheduled === true) {
             showUpgradeFloat(upgrade.last)
             return
           }
@@ -269,6 +269,11 @@ function ensureUpgradeWatch() {
             if (upgradeWatch.generation !== null) return
             void recheckUpgradeSettle(upgrade.last)
           }, UPGRADE_AUTO_RESTART_GRACE_MS)
+        } else if (upgrade) {
+          setTimeout(() => {
+            if (upgradeWatch.generation !== null) return
+            void recheckUpgradeSettle(null)
+          }, UPGRADE_AUTO_RESTART_GRACE_MS)
         }
         return
       }
@@ -306,7 +311,6 @@ function ensureUpgradeFloatStyle() {
 // LOGIC-BEGIN upgradeFinalText
 function upgradeFinalText(state) {
   if (state.stale === true) return '升级命令执行完成,但结果与安装意图不符,详情见版本与运维页'
-  if (state.requiresManualRestart === true) return '升级完成,当前为手动直跑环境,请手动重启宿主后生效'
   if (state.autoRestartScheduled === true) return '升级完成,宿主将自动重启,页面恢复后可直接使用'
   return '升级完成,重启宿主后生效(版本与运维页可重启)'
 }
@@ -661,14 +665,14 @@ function UpgradeDialog(props) {
           label: '安装完成后自动重启宿主',
           checked: autoRestart,
           onChange: setAutoRestart,
+          disabled: status.canRestart !== true,
         }),
         h('div', { className: 'dm-dialog__outcome' },
-          autoRestart
-            ? '已勾选:安装命令执行成功后,宿主将在 ' + AUTO_RESTART_DELAY_SEC + ' 秒后自动退出,由你的进程管理器(docker / pm2 / systemd 等)拉起,本页随宿主恢复自动刷新。安装落定后宿主不再执行任何网络请求与磁盘读取。'
-            : '未勾选:安装完成后宿主继续运行当前版本,面板提示「重启宿主后生效」,需要你手动点击重启按钮才切换到目标版本。'),
-        status.runtimeEnv && status.runtimeEnv.kind === RUNTIME_KIND_MANUAL
-          ? h('div', { className: 'dm-dialog__outcome dm-warn' }, '当前为手动终端直跑环境:没有进程管理器拉起宿主,勾选自动重启也不会自动退出,完成后仍需手动重启。')
-          : null,
+          status.canRestart !== true
+            ? '当前启动方式不支持就地退出:无论是否勾选,安装完成后都需在宿主侧重启生效。'
+            : autoRestart
+              ? '已勾选:安装命令执行成功后,宿主将在 ' + AUTO_RESTART_DELAY_SEC + ' 秒后自动退出——等同点击重启按钮:托管启动时由进程管理器拉起,手动终端启动时需你重新运行宿主;本页随宿主恢复自动刷新。安装落定后宿主不再执行任何网络请求与磁盘读取。'
+              : '未勾选:安装完成后宿主继续运行当前版本,面板提示「重启宿主后生效」,需要你手动点击重启按钮才切换到目标版本。'),
       ),
       h('div', { className: 'dm-row' },
         h('span', { className: 'dm-spacer' }),

package/src/index.js

@@ -26,7 +26,6 @@ import {
   UPGRADE_FAIL_TRANSIENT_NETWORK,
 } from './core.mjs'
 import { runUpgrade } from './upgrade.mjs'
-import { detectRuntimeEnv, RUNTIME_KINDS } from './runtime.mjs'
 
 export const name = 'dsh-maintain'
 
@@ -208,16 +207,15 @@ export async function runUpgradeWithRetry({ command, timeoutMs = UPGRADE_TIMEOUT
   return { attempts, ok: false, kind: null, stillRunning: false, stdoutTail: '', stderrTail: '', error: null }
 }
 
-// 升级后自动重启守卫:四条件缺一不可——成功、非手动直跑、本次勾选 enabled、appExit 可用。
-// 手动直跑(双 TTY)进程退出后无人拉起,只标 requiresManualRestart 交面板指引,
-// 该指引是环境约束事实,不受勾选影响;enabled 由升级路由严格 boolean 校验保证
+// 升级后自动重启守卫:三条件缺一不可——成功、本次勾选 enabled、appExit 可用。
+// 宿主退出动作与面板"确认重启"完全同一调度入口,拉起责任归启动方式:
+// 托管环境由进程管理器拉起,手动直跑等同点了重启按钮后自行再启动
 // 无 stale 条件:版本复读属升级后磁盘读取,关机路径禁止;版本是否前进由重启后的启动检查呈现
-export function judgeAutoRestart({ ok, runtimeKind, hasExit, enabled }) {
-  if (ok !== true) return { schedule: false, requiresManualRestart: false }
-  if (runtimeKind === RUNTIME_KINDS.MANUAL_START) return { schedule: false, requiresManualRestart: true }
-  if (enabled !== true) return { schedule: false, requiresManualRestart: false }
-  if (hasExit !== true) return { schedule: false, requiresManualRestart: false }
-  return { schedule: true, requiresManualRestart: false }
+export function judgeAutoRestart({ ok, hasExit, enabled }) {
+  if (ok !== true) return { schedule: false }
+  if (enabled !== true) return { schedule: false }
+  if (hasExit !== true) return { schedule: false }
+  return { schedule: true }
 }
 
 // 浏览器半区调用的 API 路径清单:client.js 同名常量与之对拍(parity),防单侧改路径生产 404
@@ -386,16 +384,6 @@ export function apply(ctx) {
   const runningVersionReady = resolveCurrentHostVersion()
     .then((version) => { runningVersion = version })
     .catch(() => {})
-
-  // 运行环境:apply 时一次检测;探测异步,以 ready 链收口,异常回退 unknown(维持自动重启)
-  let runtimeEnv = { kind: RUNTIME_KINDS.UNKNOWN, declared: false }
-  const runtimeEnvReady = detectRuntimeEnv({
-    env: process.env,
-    platform: process.platform,
-    isTTY: { stdin: process.stdin.isTTY === true, stdout: process.stdout.isTTY === true },
-  })
-    .then((env) => { runtimeEnv = env })
-    .catch(() => {})
   let upgrade = { running: false, last: null }
   let checkInFlight = null
   let nextDueAt = null
@@ -460,8 +448,8 @@ export function apply(ctx) {
   }
 
   async function currentStatus() {
-    // 等运行版本首读与运行环境检测落定:apply 即发起,此处仅吸收启动窗口的微小延迟
-    await Promise.all([runningVersionReady, runtimeEnvReady])
+    // 等运行版本首读落定:apply 即发起,此处仅吸收启动窗口的微小延迟
+    await runningVersionReady
     const config = readSettings(ctx)
     const judged = judgeNow()
     // running 即视为持锁:省一次盘读,且窗口期语义与 upgrade 路由的门闩一致
@@ -486,7 +474,6 @@ export function apply(ctx) {
       checkedAt: snapshot.checkedAt,
       checkError: snapshot.error,
       upgrade,
-      runtimeEnv,
       autoRestartScheduled,
       activeWork: collectActiveWork(ctx),
       canRestart: typeof exit === 'function',
@@ -592,11 +579,9 @@ export function apply(ctx) {
         + (last.stale === true ? ' stale=' + singleLine(last.reason) : ''))
       audit('upgrade', last.ok === true ? 'ok' : 'failed',
         'durationMs=' + (last.finishedAt - last.startedAt) + ' code=' + last.code + ' kind=' + singleLine(last.kind))
-      // 关机前置判定只取内存输入(启动期缓存的运行环境 + 本次会话勾选):升级命令刚
+      // 关机前置判定只取内存输入(本次会话勾选 + 启动器退出能力):升级命令刚
       // 替换过宿主磁盘文件,落定钩子发起网络请求或读取磁盘都是半写状态下的故障源
-      await runtimeEnvReady
-      const decision = judgeAutoRestart({ ok: last.ok === true, runtimeKind: runtimeEnv.kind, hasExit: typeof exit === 'function', enabled: autoRestart === true })
-      if (decision.requiresManualRestart === true) last.requiresManualRestart = true
+      const decision = judgeAutoRestart({ ok: last.ok === true, hasExit: typeof exit === 'function', enabled: autoRestart === true })
       if (decision.schedule === true) {
         // 关机路径零收尾:与确认重启同一内部动作,直接进入延迟退出
         // last 镜像调度标记:浮条终态文案按其分流(与 status.autoRestartScheduled 同值)
@@ -604,7 +589,7 @@ export function apply(ctx) {
         scheduleHostExit({ detail: 'reason=upgrade-ok', autoRestart: true, delayMs: AUTO_RESTART_DELAY_MS })
         return
       }
-      // 继续运行路径(失败/手动直跑/本次未勾选自动重启):复读磁盘版本标 stale,版本未前进提示保留
+      // 继续运行路径(失败/本次未勾选自动重启/appExit 缺失):复读磁盘版本标 stale,版本未前进提示保留
       if (settle !== null && settle.ok) {
         // 复读属磁盘消费点,拒绝不得以 unhandledRejection 形式逃逸(void 触发即崩宿主):
         // 失败时放弃 stale 判定,保留已装版本 null 由启动检查兜底呈现

package/test/parity.test.mjs

@@ -138,11 +138,11 @@ test('渲染冒烟: UpgradeDialog 工厂化执行不抛错且含版本变更行'
   const useState = (init) => [init, () => {}]
   const Switch = (propsArg) => h('label', propsArg)
   const dialog = new Function('h', 'useState', 'Switch', 'DEFAULT_UPGRADE_TEMPLATE', 'AUTO_RESTART_DELAY_SEC',
-    'RUNTIME_KIND_MANUAL', 'buildInstallChangeLine', 'buildInstallVersionHint',
+    'buildInstallChangeLine', 'buildInstallVersionHint',
     'return (' + match[0] + ')')(
-    h, useState, Switch, 'npm install -g @deepseek-ai/dsh@{tag}', 3, 'manual-start-likely',
+    h, useState, Switch, 'npm install -g @deepseek-ai/dsh@{tag}', 3,
     (status, command) => '变更:' + command, (status) => '提示:' + status.runningVersion)
-  const status = { channel: 'latest', upgradeTemplate: '', runningVersion: '0.1.5', installedVersion: '0.1.5', runtimeEnv: null }
+  const status = { channel: 'latest', upgradeTemplate: '', runningVersion: '0.1.5', installedVersion: '0.1.5' }
   const tree = dialog({ status, onCancel: () => {}, onConfirm: () => {} })
   assert.equal(tree.type, 'div', '弹窗根为遮罩 div')
   assert.ok(calls.some((type) => type === 'pre'), '命令 pre 节点应在树中')
@@ -200,13 +200,6 @@ test('parity: VERDICT 三常量 client 与 core 一致', () => {
   assert.equal(extractConst('VERDICT_UNKNOWN'), VERDICT_UNKNOWN)
 })
 
-// host 侧锚点直接 import runtime.mjs 实现,防测试内手抄字面量漂移假绿
-import { RUNTIME_KINDS } from '../src/runtime.mjs'
-
-test('parity: 手动直跑运行环境常量 client 与 host 一致', () => {
-  assert.equal(extractConst('RUNTIME_KIND_MANUAL'), RUNTIME_KINDS.MANUAL_START)
-})
-
 test('parity: 弹窗文案自动重启延迟秒与 host AUTO_RESTART_DELAY_MS 换算一致', () => {
   assert.equal(extractNumberConst('AUTO_RESTART_DELAY_SEC'), AUTO_RESTART_DELAY_MS / 1000)
 })
@@ -255,12 +248,13 @@ test('parity: client API 路径常量与 host 路由清单逐条一致', () => {
   }
 })
 
-// 窗口关系对拍:重启等待总时长必须大于宿主退出延迟,否则宿主还在延迟退出窗口内客户端已报超时
+// 窗口关系对拍:重启等待总时长必须大于任一退出延迟,否则宿主还在延迟退出窗口内客户端已报超时
 import { RESTART_DELAY_MS } from '../src/index.js'
 
-test('parity: 重启等待总时长大于宿主退出延迟', () => {
+test('parity: 重启等待总时长大于宿主退出延迟(按钮与自动重启取大)', () => {
   const restartTimeoutMs = extractNumberConst('RESTART_TIMEOUT_MS')
-  assert.ok(restartTimeoutMs > RESTART_DELAY_MS, 'RESTART_TIMEOUT_MS 必须大于 RESTART_DELAY_MS')
+  assert.ok(restartTimeoutMs > Math.max(RESTART_DELAY_MS, AUTO_RESTART_DELAY_MS),
+    'RESTART_TIMEOUT_MS 必须大于 max(RESTART_DELAY_MS, AUTO_RESTART_DELAY_MS)')
 })
 
 test('parity: 升级观察上限覆盖宿主重试链上限(防抢跑转状态未知)', () => {
@@ -286,13 +280,12 @@ test('parity: GitHub releases 兜底链接与 host 拉取仓库同源', () => {
   assert.equal(extractConst('RELEASES_PAGE_URL'), 'https://github.com/' + RELEASE_REPO + '/releases')
 })
 
-test('parity: 落定补查宽限覆盖宿主自动重启调度延迟', () => {
-  // 落定拍与调度置位之间存在宿主侧 await 窗口:client 补查宽限必须不小于调度延迟 + 观察裕量
+test('parity: 落定补查宽限不小于观察轮询拍间隔', () => {
+  // 关机路径调度标记与 running=false 同拍置位,宽限不再竞态调度延迟;现职责是
+  // 给继续运行路径的 stale 异步复读留余量,下限锁定为不小于轮询拍间隔(补查不早于一拍)
   const graceMs = extractNumberConst('UPGRADE_AUTO_RESTART_GRACE_MS')
-  assert.ok(
-    graceMs >= AUTO_RESTART_DELAY_MS + 1 * 1000,
-    'UPGRADE_AUTO_RESTART_GRACE_MS(' + graceMs + ') 必须不小于 AUTO_RESTART_DELAY_MS(' + AUTO_RESTART_DELAY_MS + ') 加观察裕量',
-  )
+  assert.ok(graceMs >= 2 * 1000,
+    'UPGRADE_AUTO_RESTART_GRACE_MS(' + graceMs + ') 必须不小于观察轮询拍间隔(2s)')
 })
 
 test('源码契约: 重启轮询与升级观察器不得回退 setInterval 重叠拍形态', () => {

package/test/restart-ready.test.mjs

@@ -197,24 +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 })
+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 才显示仍要重启文案', () => {
@@ -240,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

@@ -424,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, '落定钩子禁止网络请求')
@@ -581,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, [], '未勾选自动重启时禁止调度任何宿主退出')
@@ -647,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], '延迟窗口过后必须调度宿主退出')
@@ -858,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)"' }
@@ -882,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
   }

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 }
-}

package/test/runtime.test.mjs

@@ -1,67 +0,0 @@
-import assert from 'node:assert/strict'
-import { test } from 'node:test'
-import { detectRuntimeEnv, RUNTIME_KINDS } from '../src/runtime.mjs'
-
-const POSIX = 'linux'
-const WIN32 = 'win32'
-const BOTH_TTY = { stdin: true, stdout: true }
-const NO_TTY = { stdin: false, stdout: false }
-const noProbes = { existsImpl: async () => false, readFileImpl: async () => { throw new Error('ENOENT') } }
-
-test('环境检测:env 覆盖最高优先', async () => {
-  const managed = await detectRuntimeEnv({ env: { DSH_MAINTAIN_RUNTIME_ENV: 'managed', pm_id: '0' }, platform: POSIX, isTTY: BOTH_TTY, ...noProbes })
-  assert.deepEqual(managed, { kind: RUNTIME_KINDS.DECLARED_MANAGED, declared: true })
-  const manual = await detectRuntimeEnv({ env: { DSH_MAINTAIN_RUNTIME_ENV: 'manual', pm_id: '0' }, platform: POSIX, isTTY: NO_TTY, ...noProbes })
-  assert.deepEqual(manual, { kind: RUNTIME_KINDS.MANUAL_START, declared: false })
-  // 非法覆盖值不生效,继续走常规判定
-  const bogus = await detectRuntimeEnv({ env: { DSH_MAINTAIN_RUNTIME_ENV: 'sideways' }, platform: POSIX, isTTY: NO_TTY, ...noProbes })
-  assert.deepEqual(bogus, { kind: RUNTIME_KINDS.UNKNOWN, declared: false })
-})
-
-test('环境检测:env 表命中各托管形态', async () => {
-  const table = [
-    [{ pm_id: '0' }, RUNTIME_KINDS.PM2],
-    [{ PM2_HOME: 'C:/pm2' }, RUNTIME_KINDS.PM2],
-    [{ pm_uptime: '123' }, RUNTIME_KINDS.PM2],
-    [{ INVOCATION_ID: 'x' }, RUNTIME_KINDS.SYSTEMD],
-    [{ JOURNAL_STREAM: '9' }, RUNTIME_KINDS.SYSTEMD],
-    [{ NOTIFY_SOCKET: '/run/notify' }, RUNTIME_KINDS.SYSTEMD],
-    [{ SUPERVISOR_ENABLED: '1' }, RUNTIME_KINDS.SUPERVISORD],
-    [{ SUPERVISOR_PROCESS_NAME: 'dsh' }, RUNTIME_KINDS.SUPERVISORD],
-    [{ KUBERNETES_SERVICE_HOST: '10.0.0.1' }, RUNTIME_KINDS.KUBERNETES],
-  ]
-  for (const [env, kind] of table) {
-    const result = await detectRuntimeEnv({ env, platform: POSIX, isTTY: NO_TTY, ...noProbes })
-    assert.deepEqual(result, { kind, declared: true }, JSON.stringify(env))
-  }
-  // 空串环境值不构成声明
-  const empty = await detectRuntimeEnv({ env: { pm_id: '' }, platform: POSIX, isTTY: NO_TTY, ...noProbes })
-  assert.deepEqual(empty, { kind: RUNTIME_KINDS.UNKNOWN, declared: false })
-})
-
-test('环境检测:POSIX 容器探测', async () => {
-  const docker = await detectRuntimeEnv({ env: {}, platform: POSIX, isTTY: NO_TTY, existsImpl: async (p) => p === '/.dockerenv', readFileImpl: async () => { throw new Error('ENOENT') } })
-  assert.deepEqual(docker, { kind: RUNTIME_KINDS.DOCKER, declared: true })
-  for (const [marker, kind] of [['/docker/', RUNTIME_KINDS.DOCKER], ['kubepods', RUNTIME_KINDS.KUBERNETES], ['containerd', RUNTIME_KINDS.CONTAINER], ['lxc', RUNTIME_KINDS.CONTAINER], ['podman', RUNTIME_KINDS.CONTAINER]]) {
-    const result = await detectRuntimeEnv({ env: {}, platform: POSIX, isTTY: NO_TTY, existsImpl: async () => false, readFileImpl: async () => '12:pids:/sys/fs/cgroup/' + marker + 'abc' })
-    assert.deepEqual(result, { kind, declared: true }, marker)
-  }
-  // 探测器异常不致命,继续后续判定
-  const broken = await detectRuntimeEnv({ env: {}, platform: POSIX, isTTY: NO_TTY, existsImpl: async () => { throw new Error('EACCES') }, readFileImpl: async () => { throw new Error('EACCES') } })
-  assert.deepEqual(broken, { kind: RUNTIME_KINDS.UNKNOWN, declared: false })
-})
-
-test('环境检测:win32 跳过 POSIX 探测', async () => {
-  const win = await detectRuntimeEnv({ env: {}, platform: WIN32, isTTY: NO_TTY, existsImpl: async () => true, readFileImpl: async () => '/docker/xyz' })
-  assert.deepEqual(win, { kind: RUNTIME_KINDS.UNKNOWN, declared: false })
-})
-
-test('环境检测:双 TTY 判手动直跑,单 TTY 不构成', async () => {
-  const both = await detectRuntimeEnv({ env: {}, platform: POSIX, isTTY: BOTH_TTY, ...noProbes })
-  assert.deepEqual(both, { kind: RUNTIME_KINDS.MANUAL_START, declared: false })
-  const stdinOnly = await detectRuntimeEnv({ env: {}, platform: POSIX, isTTY: { stdin: true, stdout: false }, ...noProbes })
-  assert.deepEqual(stdinOnly, { kind: RUNTIME_KINDS.UNKNOWN, declared: false })
-  // 托管声明优先于 TTY
-  const declaredWithTty = await detectRuntimeEnv({ env: { pm_id: '0' }, platform: POSIX, isTTY: BOTH_TTY, ...noProbes })
-  assert.deepEqual(declaredWithTty, { kind: RUNTIME_KINDS.PM2, declared: true })
-})