dsh-x-core 0.1.21 → 0.1.23

package/server.js

@@ -16,6 +16,8 @@ import pkg from './package.json' with { type: 'json' }
 import { VERSION_CHANNEL, VERSION_CHANNELS, effectiveChannel, versionChannel, versionInChannel } from './version.js'
 import { createLogWriter } from './log-writer.js'
 import { createStartupDiagnosis } from './startup-diagnosis.js'
+import { applyNativeNotify } from './native-notify.js'
+import { DESKTOP_PLUGINS_SKIP_PROFILES, desktopPluginsToInstall } from './desktop-plugins.js'
 import { bindDiagnosis, checkedRepairPlan, profileFingerprint } from './repair-plan.js'
 import { DiagnosticRepairs, verificationSummary } from './repair-actions.js'
 import { recordedChanges } from './repair-evidence.js'
@@ -117,17 +119,21 @@ import {
   safeProfile,
   safeProxyMode,
   safeProxyUrl,
+  safeNodeRuntime,
+  safeSystemNodePath,
   safeArgs,
   safeUpdateChannel,
   safeWebBind,
+  safeWorkdir,
   saveSettings,
   VERSION_RE,
 } from './settings.js'
 // 带代理的 fetch：Node 的全局 fetch 既不看系统代理也不看 HTTP_PROXY，外网请求都走 netFetch
 import { netFetch, proxyEnv, resetProxyCache, resolveProxy } from './proxy.js'
 import { APP_DIR, fileManager } from './filemanager.js'
+import { DESKTOP_API_VERSION, DESKTOP_CAPABILITIES, parseDesktopRequest } from './desktop.js'
 import { checkCoreUpdate, downloadCoreTarball, extractCoreTarball, stagingExists, stagingStats } from './core-npm.js'
-import { IN_ELECTRON, IS_MAC, IS_WINDOWS, LAUNCHER_NAME, MAC_APP_NAME, NPM_MODE, PACKAGED, RUNTIME_NODE, RUNTIME_NODE_ENV } from './platform.js'
+import { IN_ELECTRON, IS_LINUX, IS_MAC, IS_WINDOWS, LAUNCHER_NAME, MAC_APP_NAME, NPM_MODE, PACKAGED, RUNTIME_NODE, RUNTIME_NODE_ENV } from './platform.js'
 
 const execFileAsync = promisify(execFile)
 
@@ -206,6 +212,13 @@ let UPDATE_SOURCE = updateSourceForDownload(loadSettingsSync().downloadSource)
 let OPEN_MODE = safeOpenMode(loadSettingsSync().openMode)
 // 是否把 dsh 的 shim 目录写进用户 PATH（默认关，改了要新开终端才生效）
 let SYSTEM_PATH = loadSettingsSync().systemPath === true
+// 内置浏览器（官方右侧栏浏览器）的总开关：启动参数里的 --patch 按它在启用 / 关闭之间切换。
+// 外壳那侧还有一道 guest 放行检查（shell/main.mjs），两边读同一份 settings.json。
+let BROWSER_CONTROL = loadSettingsSync().browserControl !== false
+// 右键菜单（dsh-x-context-menu）：关掉后启动补丁把插件行停用（不卸载），也不再自动补装。
+let CONTEXT_MENU = loadSettingsSync().contextMenu !== false
+const CONTEXT_MENU_PLUGIN = 'dsh-x-context-menu'
+const CONTEXT_MENU_ROW_ID = 'x-context-menu'
 
 /** 安装目录里的 lang.txt（安装程序写的），只认 zh / en。 */
 function installLang() {
@@ -220,7 +233,67 @@ const LOG_FILE = join(LOG_DIR, 'manager.log')
 const LOG_MAX_BYTES = 5 * 1024 * 1024
 const NOISY_LOG_RE = /^(?:已安装 \d+\/\d+|已解析 \d+)/
 const logWriter = createLogWriter(LOG_FILE, { maxBytes: LOG_MAX_BYTES })
-process.on('exit', () => logWriter.flush())
+/** 每个启动项一份日志：启动时行里的上下文带上 launchId，`pushLog` 顺手 tee 过来。 */
+const LAUNCH_LOG_DIR = join(APP_DIR, 'launch-logs')
+const LAUNCH_LOG_MAX_BYTES = 2 * 1024 * 1024
+const LAUNCH_ID_RE = /^[A-Za-z0-9_-]{1,64}$/
+const launchLogWriters = new Map()
+function launchLogWriter(id) {
+  let writer = launchLogWriters.get(id)
+  if (!writer) {
+    writer = createLogWriter(join(LAUNCH_LOG_DIR, `launch-${id}.log`), { maxBytes: LAUNCH_LOG_MAX_BYTES })
+    launchLogWriters.set(id, writer)
+  }
+  return writer
+}
+/** 清空某个启动项的原始日志（耗时记录保留，账本和 RSS 还要用）。 */
+function clearLaunchLog(id) {
+  const writer = launchLogWriters.get(id)
+  if (writer) {
+    writer.flush()
+    launchLogWriters.delete(id)
+  }
+  for (const name of [`launch-${id}.log`, `launch-${id}.log.1`]) {
+    try { unlinkSync(join(LAUNCH_LOG_DIR, name)) } catch { /* 没有就算了 */ }
+  }
+}
+
+/** 删除启动项时顺手删掉它自己的日志（分片也一起）。 */
+function dropLaunchLog(id) {
+  const writer = launchLogWriters.get(id)
+  if (writer) {
+    writer.flush()
+    launchLogWriters.delete(id)
+  }
+  for (const name of [`launch-${id}.log`, `launch-${id}.log.1`, `launch-${id}.json`]) {
+    try { unlinkSync(join(LAUNCH_LOG_DIR, name)) } catch { /* 没有就算了 */ }
+  }
+}
+
+/** 记一次启动的阶段耗时（最近 20 次，新的在前），给日志弹窗画分段条。 */
+function recordLaunchRun(id, run) {
+  if (!id || !LAUNCH_ID_RE.test(id)) return
+  const file = join(LAUNCH_LOG_DIR, `launch-${id}.json`)
+  let runs = []
+  try {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    if (Array.isArray(parsed?.runs)) runs = parsed.runs
+  } catch {
+    // 第一次启动还没有记录
+  }
+  runs.unshift(run)
+  if (runs.length > 20) runs.length = 20
+  try {
+    mkdirSync(LAUNCH_LOG_DIR, { recursive: true })
+    writeFileSync(file, `${JSON.stringify({ runs }, null, 2)}\n`)
+  } catch {
+    // 记录不是启动的依赖，写不进去只影响可视化
+  }
+}
+process.on('exit', () => {
+  logWriter.flush()
+  for (const writer of launchLogWriters.values()) writer.flush()
+})
 let pendingLogEvents = []
 let logEventTimer = null
 
@@ -238,6 +311,8 @@ let host = {
   openWindow: (url) => { process.stdout.write(`${OPEN_SIGNAL} ${url}\n`) },
   /** 收尾之后结束服务。外壳同进程时由它决定怎么退（先关窗口、托盘），默认直接退进程。 */
   exit: (code = 0) => process.exit(code),
+  /** 桌面通知（任务完成 / 失败）。浏览器外壳没有这条通道，默认什么都不做。 */
+  notify: () => {},
 }
 const logs = []
 /**
@@ -248,6 +323,8 @@ const logs = []
  * 插件树按 profile 各是各的。同一个组合再点一次启动只会拿回已经在跑的那个。
  */
 const instances = new Map()
+/** 退出 / 换核心时的收尾阶段：这期间实例退出是预期内的，不用发通知。 */
+let shuttingDown = false
 // 删除环境与启动不能穿插：启动准备期间还没 child，也要算作占用这份 profile。
 const startingProfiles = new Set()
 const maintainingProfiles = new Set()
@@ -551,7 +628,11 @@ async function saveConfig(config) {
 /** 把重要日志追加到 manager.log（进度类噪音行丢弃，超过 5MB 轮转一次）。 */
 function persistLog(text) {
   if (NOISY_LOG_RE.test(text)) return
-  logWriter.append(`[${new Date().toISOString()}] ${text}\n`)
+  const line = `[${new Date().toISOString()}] ${text}\n`
+  logWriter.append(line)
+  // 启动项启动/停止期间的行同时落到它自己的日志里；手动启动（没有启动项）只有全局那份。
+  const launchId = launchScope.getStore()?.launchId
+  if (launchId && LAUNCH_ID_RE.test(launchId)) launchLogWriter(launchId).append(line)
 }
 
 function flushLogEvents() {
@@ -985,11 +1066,42 @@ function liveInstanceList() {
   return instanceList().filter((proc) => proc.status === 'running' || proc.status === 'starting')
 }
 
-/** 整个环境的删除/卸载需要停干净；默认选择并不代表多开中只有这一份在跑。 */
-async function withIdleProfile(profile, operation) {
+/**
+ * 读一个进程的常驻内存（RSS，MB）。跨平台各用系统自带的查询，不引原生依赖。
+ *
+ * 只给进程级数字：dsh 的插件都在同一个 Node 进程里，操作系统的 RSS 没有插件维度。
+ *
+ * @param {number} pid - 进程号。
+ * @returns {number|null} MB，读不到时 null。
+ */
+function readProcessRssMB(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return null
+  try {
+    if (IS_WINDOWS) {
+      // "DSH.exe","1234","Console","1","123,456 K"
+      const out = spawnSync('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], { encoding: 'utf8', windowsHide: true, timeout: 4000 }).stdout || ''
+      const match = /^"[^"]*","[^"]*","[^"]*","[^"]*","([\d.,]+) K"/m.exec(out)
+      if (!match) return null
+      const kb = Number(match[1].replace(/[.,]/g, ''))
+      return Number.isFinite(kb) ? Math.round(kb / 1024) : null
+    }
+    const out = spawnSync('ps', ['-o', 'rss=', '-p', String(pid)], { encoding: 'utf8', windowsHide: true, timeout: 4000 }).stdout || ''
+    const kb = Number(out.trim())
+    return Number.isFinite(kb) && kb > 0 ? Math.round(kb / 1024) : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 指名某个用户目录里的 Profile 做「整包」操作：该目录里它有实例在跑、
+ * 或者有人正在改它，都先拒绝。默认目录走 withIdleProfile；跨目录复制 Profile 时
+ * 来源那一份要用它按自己的目录锁（见 createProfile）。
+ */
+async function withIdleProfileIn(home, profile, operation) {
   const name = safeProfile(profile)
-  const key = profileKey(name)
-  if (startingProfiles.has(key) || instanceList().some((proc) => proc.profile === name && proc.home === homeDir())) {
+  const key = `${home}\0${name}`
+  if (startingProfiles.has(key) || instanceList().some((proc) => proc.profile === name && fileManager.samePath(proc.home, home))) {
     throw new Error(`profile「${name}」仍有实例在运行或启动，请先停止这个环境的全部实例`)
   }
   if (maintainingProfiles.has(key) || pluginBusy || syncRunning) {
@@ -998,7 +1110,7 @@ async function withIdleProfile(profile, operation) {
   maintainingProfiles.add(key)
   pluginBusy = true
   try {
-    const dir = profileDirOf(name)
+    const dir = join(home, 'profiles', name)
     // 已被外部删掉的环境只清安装记录，不能为了拿锁又创建一份空目录。
     return await (existsSync(dir) ? withProfileLock(dir, operation) : operation())
   } finally {
@@ -1007,6 +1119,11 @@ async function withIdleProfile(profile, operation) {
   }
 }
 
+/** 默认目录里的那份：老调用点都走这里，行为不变。 */
+async function withIdleProfile(profile, operation) {
+  return withIdleProfileIn(homeDir(), profile, operation)
+}
+
 /** rm 会连 lock 一起删除；进程内的占用标记补上这段窗口，避免热加载写回已删目录。 */
 async function editProfile(profile, operation) {
   const name = safeProfile(profile)
@@ -1031,6 +1148,7 @@ function instanceInfo(proc) {
     status: proc.status,
     url: proc.url,
     startedAt: proc.startedAt,
+    startupMs: proc.startupMs ?? null,
     startupPhase: proc.status === 'starting' ? (proc.startupPhase || 'launching') : '',
     diagnosticWarning: publicFailure(proc.diagnosticWarning),
   }
@@ -1231,6 +1349,16 @@ async function snapshotDefault() {
       return proc ? { version: proc.version, status: proc.status, url: proc.url } : null
     })(),
     autoFix: autoFixForHome(),
+    // 外观设置：设置页可能开在**另一个标签页**里，改完只有那一页自己换了主题，
+    // 管这个窗口的那一页（标签条、卡片、水面背景）要等整页刷新才跟上。
+    // 把这一组放进状态里，页面收到推送就能自己跟，不用刷新。
+    appearance: {
+      theme: THEME,
+      panelTransparency: PANEL_TRANSPARENCY,
+      reduceMotion: REDUCE_MOTION,
+      hideBackground: HIDE_BACKGROUND,
+      hideBigFish: HIDE_BIG_FISH,
+    },
     health: lastHealth,
     failure: publicFailure(lastFailure),
     diagnosticRepairs: publicFailure({ message: '', diagnosis: diagnosticRepairs.history().map(record => ({ ...record, recorded: recordedChanges(record) })) }).diagnosis,
@@ -1289,6 +1417,10 @@ async function publicSettings() {
     systemBinDir: systemBinDir(),
     systemPathMode: IS_WINDOWS ? 'automatic' : 'manual',
     systemPathCommand: manualPathCommand(systemBinDir()),
+    // 跑 dsh 用哪个 node：设置值 + 现在生效的 + 系统里找到的那个（页面据此画提示行）
+    nodeRuntime: safeNodeRuntime(stored.nodeRuntime),
+    systemNodePath: safeSystemNodePath(stored.systemNodePath),
+    nodeRuntimeInfo: nodeRuntimeView(stored),
     updateSource: updateSourceForDownload(stored.downloadSource),
     updateSources: [
       { id: 'mirror', label: '国内加速（先走镜像，连不上再直连）' },
@@ -1317,6 +1449,22 @@ async function publicSettings() {
     reduceMotion: REDUCE_MOTION,
     hideBackground: HIDE_BACKGROUND,
     hideBigFish: HIDE_BIG_FISH,
+    // 桌面端系统开关的当前值。外壳直接读 settings.json（见 shell/prefs.mjs），这里只是给页面回显；
+    // shellPrefs 表明当前外壳懂这组设置（旧外壳不认，页面据此提示更新）。
+    hardwareAcceleration: stored.hardwareAcceleration !== false,
+    autoUpdate: stored.autoUpdate === true,
+    taskNotifications: stored.taskNotifications !== false,
+    notificationSound: stored.notificationSound !== false,
+    closeToTray: stored.closeToTray !== false,
+    keepAwake: stored.keepAwake === true,
+    // 内置浏览器（右侧栏浏览器）：开关与证书策略。browserHost 表明当前外壳能否清理浏览数据
+    // （只有 Electron 外壳拿得到 guest 分区；浏览器里打开管理页 / 旧外壳没有这层能力）。
+    browserControl: stored.browserControl !== false,
+    browserIgnoreCertificate: stored.browserIgnoreCertificate === true,
+    contextMenu: stored.contextMenu !== false,
+    browserHost: Boolean(host.browser),
+    shellPrefs: process.env.DSH_SHELL_PREFS === '1',
+    desktopShell: shellWindowHost(),
     // Web 绑定：设置值 + 插件开关是否压着它（页面要如实说明当前生效的是哪一个）
     webBind: WEB_BIND,
     webBindLan: LAN_TOGGLE,
@@ -1421,6 +1569,30 @@ function resolvePresetVersion(entry, home, config, versions = null) {
   return live?.version || plan.installed[0] || ''
 }
 
+/**
+ * 托盘要的状态文本（外壳每 1.5s 取一次）。外壳和核心同进程时直接调用，
+ * 不用再绕一圈本机 HTTP；`/api/tray` 仍然保留，浏览器外壳和旧外壳照旧读它。
+ */
+export function trayStateText() {
+  // 保留旧外壳的标量字段；新外壳按命名启动项操作，不再把单项停止变成停止全部。
+  const running = primaryInstance()
+  const launches = trayLaunches()
+  return [
+    `status=${running?.status || 'stopped'}`,
+    `url=${running?.url || ''}`,
+    `installed=${trayInstalledVersions().length ? 1 : 0}`,
+    `lang=${LANG}`,
+    // 托盘照着它决定「打开 DSH」是叫内嵌窗口还是丢给系统浏览器
+    `openmode=${OPEN_MODE}`,
+    // 本次是不是由原生外壳托管：外壳缺失时窗口模式不成立，托盘据此退回浏览器
+    `shell=${shellWindowHost() ? 1 : 0}`,
+    `theme=${THEME}`,
+    // 原生标签页要跟随所有实例，不能用「最近启动的实例」去覆盖用户正在看的其他页面。
+    `instances=${JSON.stringify(instanceList().map((proc) => internalTabTarget(proc, launches.find((row) => row.proc === proc)?.name)))}`,
+    `launches=${JSON.stringify(launches.map(({ id, instanceId, name, version, profile, status, busy, installed, target }) => ({ id, instanceId, name, version, profile, status, busy, installed, target })))}`,
+  ].join('\n')
+}
+
 /** 删除入口不会停止实例；这类运行项仍要能从托盘找回和单独停止。 */
 function trayLaunches() {
   const versions = trayInstalledVersions()
@@ -1547,16 +1719,31 @@ async function saveLaunchPresetNow(body) {
   if (!name || name.length > 32) throw new Error('启动项名称请填 1-32 个字符')
   const version = safeVersion(body.version)
   const profile = safeProfile(body.profile)
-  const dshHome = safeDshHome(body.dshHome)
+  // 项目环境（issue #72）：数据目录不再另挑，固定是项目根里的 .dsh；这个派生只做一次，
+  // 页面显示的路径和真正落盘的是同一个。两个字段打架时以项目目录为准 —— 用户填了项目，
+  // 就是「这套环境属于这个项目」，容不下第二个数据目录的答案。
+  const workdir = safeWorkdir(body.workdir)
+  const dshHome = workdir ? join(workdir, '.dsh') : safeDshHome(body.dshHome)
   const home = dshHome || defaultHome()
+  // 项目目录本身允许不存在（「新建项目工作目录」是这个功能的一半），但不校验就可能在启动时
+  // 才炸：先建出来并试写一次，打错的盘符当场报错。
+  if (workdir) await ensureWritableDir(workdir)
   if (dshHome && dshHome !== defaultHome()) await ensureWritableDir(dshHome)
-  // 「添加启动项」的隔离方式引导：Profile 隔离/完全隔离只让人填 Profile 名字，不存在就按名字建。
-  // 建在 home 对应的目录作用域里（和 /api/profiles/create 的 x-dsh-home 同一套语义），页面
-  // 不用先建 Profile 再存启动项——两步之间的失败会留下半截环境。
-  if (body.ensureProfile === true && !listProfiles(join(home, 'profiles')).includes(profile)) {
+  // Profile 不存在时按名字建，建在 home 对应的目录作用域里（和 /api/profiles/create 的
+  // x-dsh-home 同一套语义），页面不用先建 Profile 再存启动项——两步之间的失败会留下半截环境。
+  // 指定了复制来源就先复制：同样一步完成目录、Profile、依赖和启动项，用户不必自己搬配置。
+  // 目标里已经有同名 Profile 时不动它 —— 那份是用户后来自己改的，重试保存也不该被覆盖。
+  const missing = () => !listProfiles(join(home, 'profiles')).includes(profile)
+  const copyFrom = body.copyFrom && typeof body.copyFrom === 'object' ? body.copyFrom : null
+  if (copyFrom && missing()) {
+    const fromProfile = safeProfile(copyFrom.profile)
+    // 空的来源目录 = 当前（默认）用户目录，跟页面上的「沿用全局目录」一个意思。
+    const fromHome = safeDshHome(copyFrom.home) || ''
+    await launchScope.run({ home }, () => createProfile(profile, fromProfile, fromHome))
+  } else if (body.ensureProfile === true && missing()) {
     await launchScope.run({ home }, () => createProfile(profile))
   }
-  if (!listProfiles(join(home, 'profiles')).includes(profile)) throw new Error(`profile ${profile} 不存在`)
+  if (missing()) throw new Error(`profile ${profile} 不存在`)
   const portText = String(body.port ?? '').trim()
   const port = portText && portText !== '0' ? safePort(portText) : 0
   // 没带这个字段就沿用原来的通道（同 autoLaunch）：只改别的字段的调用方，比如「更新到新版」时
@@ -1599,6 +1786,7 @@ async function saveLaunchPresetNow(body) {
     // 用过的版本记录跟着启动项走，编辑参数不该抹掉回退历史。
     ...(existingEntry?.usedVersion ? { usedVersion: existingEntry.usedVersion } : {}),
     ...(existingEntry?.prevVersion ? { prevVersion: existingEntry.prevVersion } : {}),
+    ...(workdir ? { workdir } : {}),
     ...(dshHome ? { dshHome } : {}), ...(icon !== 'terminal' ? { icon } : {}) }
   if (index >= 0) presets[index] = entry
   else presets.push(entry)
@@ -1617,6 +1805,7 @@ async function removeLaunchPresetNow(id) {
   if (next.length === presets.length) throw new Error('这个启动项已不存在，请刷新后重试')
   // 删除快捷入口不改实例端口，避免影响同一组合的手动启动设置。
   await saveSettings({ launchPresets: next })
+  dropLaunchLog(id)
   await emitState()
   return { ok: true }
 }
@@ -1669,6 +1858,15 @@ async function saveManagerSettings(body) {
     throw new Error('正在确认修复或回退，结束后再修改启动设置。')
   }
   let systemPathResult
+  // 系统 node 是路径/命令，保存前先确认真的找得到、而且跑得起来 —— 否则要等下次启动 dsh 才发现选了个空
+  if ('systemNodePath' in body) {
+    const path = safeSystemNodePath(body.systemNodePath)
+    if (path) {
+      const found = findSystemNode(path)
+      if (!found) throw new Error(`找不到这个 node：${path}`)
+      if (!nodeVersionOf(found)) throw new Error(`这个文件不是能用的 node：${found}`)
+    }
+  }
   if (body.dataDir) {
     const dir = safeDataDir(body.dataDir)
     if (dir !== DATA && (instances.size || startingProfiles.size)) throw new Error('请先停止再改版本目录')
@@ -1686,6 +1884,8 @@ async function saveManagerSettings(body) {
     ...('proxyUrl' in body ? { proxyUrl: safeProxyUrl(body.proxyUrl) } : {}),
     ...('openMode' in body ? { openMode: safeOpenMode(body.openMode) } : {}),
     ...('systemPath' in body ? { systemPath: body.systemPath === true } : {}),
+    ...('nodeRuntime' in body ? { nodeRuntime: safeNodeRuntime(body.nodeRuntime) } : {}),
+    ...('systemNodePath' in body ? { systemNodePath: safeSystemNodePath(body.systemNodePath) } : {}),
     ...('dshHome' in body ? { dshHome: safeDshHome(body.dshHome) } : {}),
     ...('webBind' in body ? { webBind: safeWebBind(body.webBind) } : {}),
     ...('lang' in body ? { lang: safeLang(body.lang) } : {}),
@@ -1695,6 +1895,15 @@ async function saveManagerSettings(body) {
     ...('reduceMotion' in body ? { reduceMotion: body.reduceMotion === true } : {}),
     ...('hideBackground' in body ? { hideBackground: body.hideBackground === true } : {}),
     ...('hideBigFish' in body ? { hideBigFish: body.hideBigFish === true } : {}),
+    ...('hardwareAcceleration' in body ? { hardwareAcceleration: body.hardwareAcceleration !== false } : {}),
+    ...('autoUpdate' in body ? { autoUpdate: body.autoUpdate === true } : {}),
+    ...('taskNotifications' in body ? { taskNotifications: body.taskNotifications !== false } : {}),
+    ...('notificationSound' in body ? { notificationSound: body.notificationSound !== false } : {}),
+    ...('closeToTray' in body ? { closeToTray: body.closeToTray !== false } : {}),
+    ...('keepAwake' in body ? { keepAwake: body.keepAwake === true } : {}),
+    ...('browserControl' in body ? { browserControl: body.browserControl !== false } : {}),
+    ...('browserIgnoreCertificate' in body ? { browserIgnoreCertificate: body.browserIgnoreCertificate === true } : {}),
+    ...('contextMenu' in body ? { contextMenu: body.contextMenu !== false } : {}),
     ...('autoStart' in body ? { autoStart: Boolean(body.autoStart) } : {}),
     ...('pluginMarketSources' in body ? { pluginMarketSources: safePluginMarketSources(body.pluginMarketSources) } : {}),
     ...('autoDisablePlugins' in body ? { autoDisablePlugins: body.autoDisablePlugins !== false } : {}),
@@ -1758,11 +1967,59 @@ async function saveManagerSettings(body) {
       pushLog(`dsh 用户目录改为 ${home}${next ? '' : '（默认位置）'}；重启 dsh 后生效`)
     }
   }
+  if ('nodeRuntime' in body || 'systemNodePath' in body) {
+    // 刚改过路径：版本缓存作废，页面下一次读设置就能看到新值
+    nodeVersionCache.clear()
+    const view = nodeRuntimeView(stored)
+    pushLog(view.configured === 'system'
+      ? `跑 dsh 的 node 改为系统 Node（${view.system?.path || '没找到'}）；重启启动器后生效`
+      : '跑 dsh 的 node 改回启动器自带的 Node；重启启动器后生效')
+  }
   if ('autoCleanVersions' in body) {
     pushLog(stored.autoCleanVersions
       ? '装新版本后自动清理旧版本'
       : '不再自动清理旧版本（已装版本全部保留）')
   }
+  if ('taskNotifications' in body) {
+    // 原生通知总开关：外壳按它拦发不发，这里再把原生通知的 loader 行一并停掉 / 恢复。
+    // 处理当前目录与登记过的目录；没登记过的 DSH_HOME 管不到。
+    const current = homeDir()
+    const homes = [...new Set([current, ...safeDshHomes(stored.dshHomes)])]
+    const changed = []
+    for (const home of homes) {
+      try {
+        const result = applyNativeNotify(home, stored.taskNotifications !== false)
+        for (const name of result.profiles) changed.push(home === current ? name : `${name}（${home}）`)
+        for (const failure of result.failed) pushLog(`原生通知开关：${failure.profile} 没改成功（${failure.error}）`)
+      } catch (error) {
+        pushLog(`原生通知开关：${home} 处理失败（${error instanceof Error ? error.message : error}）`)
+      }
+    }
+    pushLog(stored.taskNotifications !== false
+      ? `原生通知已开启${changed.length ? `：${changed.join('、')}，重启 dsh 后生效` : '（没有环境装过原生通知）'}`
+      : `原生通知已关闭${changed.length ? `：${changed.join('、')} 已停用，重启 dsh 后生效` : '（没有环境装过原生通知）'}`)
+  }
+  if ('hardwareAcceleration' in body) {
+    pushLog(stored.hardwareAcceleration ? 'Chrome 硬件加速已开启，重启启动器后生效' : 'Chrome 硬件加速已关闭，重启启动器后生效')
+  }
+  if ('keepAwake' in body) pushLog(stored.keepAwake ? '已阻止系统空闲休眠' : '不再阻止系统空闲休眠')
+  if ('browserControl' in body) {
+    BROWSER_CONTROL = stored.browserControl !== false
+    pushLog(BROWSER_CONTROL
+      ? '内置浏览器已启用：启动新的 dsh 实例后，右侧栏浏览器可用'
+      : '内置浏览器已关闭：启动新的 dsh 实例后不再提供右侧栏浏览器')
+  }
+  if ('browserIgnoreCertificate' in body) {
+    pushLog(stored.browserIgnoreCertificate
+      ? '内置浏览器不再校验 HTTPS 证书（只影响内置浏览器，重启启动器后生效）'
+      : '内置浏览器恢复 HTTPS 证书校验（重启启动器后生效）')
+  }
+  if ('contextMenu' in body) {
+    CONTEXT_MENU = stored.contextMenu !== false
+    pushLog(CONTEXT_MENU
+      ? '右键菜单已启用：启动新的 dsh 实例后生效'
+      : '右键菜单已关闭：启动新的 dsh 实例后不再加载')
+  }
   // profile 立即生效：插件页、启动参数、npmrc 都读这个变量（已经在跑的 dsh 不受影响）
   EXTRA_ARGS = composeExtraArgs(stored.args)
   WEB_BIND = safeWebBind(stored.webBind)
@@ -1806,6 +2063,11 @@ export function dshEnv(version, options = {}) {
     DSH_PROFILE: PROFILE_NAME,
     // 只给官方市场 schema 提供缺省值；用户保存过的 indexes（包括空数组）始终优先。
     DSH_X_PLUGIN_MARKET_SOURCES: JSON.stringify(safePluginMarketSources(loadSettingsSync().pluginMarketSources)),
+    // 插件桌面 API 的发现信息：管理页端口每次启动可能顺延，插件不许硬编码 3780。
+    // DSH_X_DESKTOP 只在真外壳接上 host.desktop 时给（浏览器模式 / 旧外壳没有），
+    // 插件据此静默降级，不必先发一次注定 503 的请求。
+    DSH_X_MANAGER_URL: `http://127.0.0.1:${PORT}`,
+    ...(host.desktop ? { DSH_X_DESKTOP: '1' } : {}),
     // 只有「必须被 dsh 起的 worker 线程继承」的东西留在这里：worker 的 execArgv 是空的，
     // 命令行参数传不进去，只能靠 NODE_OPTIONS（路径写法见 nodeOptionsPath）。
     // dsh 自己要的那几个开关（--use-system-ca、--max-http-header-size、--import 钩子）走命令行，
@@ -2085,6 +2347,117 @@ export function withBundledRuntime(pathValue, preferredPnpm = '') {
   return orderRuntimePaths(parts, dir, preferredPnpm).join(delimiter)
 }
 
+/**
+ * 在 PATH（或用户填的路径）里找系统 node。显式路径优先；只填命令名时按 PATH 找。
+ * 返回路径或空串 —— 设置页据此说明「没找到系统 Node」。可注入 env/platform/exists 便于测试。
+ */
+export function findSystemNode(explicit = '', options = {}) {
+  const env = options.env || process.env
+  const platform = options.platform || process.platform
+  const exists = options.exists || existsSync
+  const name = platform === 'win32' ? 'node.exe' : 'node'
+  const pathDelimiter = platform === 'win32' ? ';' : ':'
+  const dirs = String(env.PATH || '').split(pathDelimiter)
+    .map((dir) => dir.trim().replace(/^"(.*)"$/, '$1'))
+    .filter(Boolean)
+  const given = String(explicit || '').trim().replace(/^"(.*)"$/, '$1').trim()
+  if (given) {
+    if (exists(given)) return given
+    // 只填了命令名（没带路径分隔符）：按 PATH 找。Windows 上还要补 PATHEXT 那几种后缀
+    if (!/[\\/]/.test(given)) {
+      const names = platform === 'win32' && !/\.[a-z0-9]+$/i.test(given)
+        ? [given, `${given}.exe`, `${given}.cmd`, `${given}.bat`]
+        : [given]
+      for (const dir of dirs) {
+        for (const name of names) {
+          const file = join(dir, name)
+          if (exists(file)) return file
+        }
+      }
+    }
+    return ''
+  }
+  for (const dir of dirs) {
+    const file = join(dir, name)
+    if (exists(file)) return file
+  }
+  return ''
+}
+
+const nodeVersionCache = new Map()
+
+/** 问一个 node 可执行文件的版本（`v24.9.0` → `24.9.0`）；跑不起来返回空串（失败不缓存，换文件后还能重问）。 */
+export function nodeVersionOf(file) {
+  if (!file) return ''
+  if (nodeVersionCache.has(file)) return nodeVersionCache.get(file)
+  let version = ''
+  try {
+    const out = spawnSync(file, ['--version'], { encoding: 'utf8', timeout: 5000, windowsHide: true })
+    const match = /^v?(\d+\.\d+\.\d+)/.exec(String(out.stdout || '').trim())
+    if (match) version = match[1]
+  } catch { /* 不是 node / 跑不起来 */ }
+  if (version) nodeVersionCache.set(file, version)
+  return version
+}
+
+/** dsh 的 engines.node 只认 `>=x.y.z`（官方包就是这么写的）；别的范围返回空串，不拿它下结论。 */
+export function parseNodeRange(range) {
+  const match = /^>=\s*(\d+\.\d+\.\d+)$/.exec(String(range || '').trim())
+  return match ? match[1] : ''
+}
+
+/**
+ * 已装版本里最高的 Node 要求（dsh 的 package.json engines.node）。系统 node 低于它时设置页要
+ * 提醒：dsh 自己不拦版本，报错会出现在别处，很难看出是 node 太老。
+ */
+function nodeRequirementForInstalled() {
+  let best = ''
+  for (const version of scanInstalled()) {
+    try {
+      const file = join(dirname(binPath(version)), '..', 'package.json')
+      const min = parseNodeRange(JSON.parse(readFileSync(file, 'utf8')).engines?.node)
+      if (min && (!best || cmpVer(parseVer(min), parseVer(best)) > 0)) best = min
+    } catch { /* 读不到就不算 */ }
+  }
+  return best
+}
+
+/**
+ * 设置页「运行 dsh 的 Node」要显示的一切：配置值、现在生效的那个、系统里找到的那个。
+ *
+ * 「生效」在 Electron 里看 RUNTIME_NODE_ENV：只有落到 Electron 本体时才带 ELECTRON_RUN_AS_NODE。
+ * 源码运行（node start.js）时 dsh 就是用启动它的那个 node，这个设置没有意义（selectable=false）。
+ */
+export function nodeRuntimeView(stored) {
+  const configured = safeNodeRuntime(stored.nodeRuntime)
+  const configuredPath = safeSystemNodePath(stored.systemNodePath)
+  const systemPath = findSystemNode(configuredPath)
+  const system = systemPath ? { path: systemPath, version: nodeVersionOf(systemPath) } : null
+  const bundled = { path: process.execPath, version: process.versions.node }
+  const bundledActive = IN_ELECTRON && Boolean(RUNTIME_NODE_ENV.ELECTRON_RUN_AS_NODE)
+  const effective = !IN_ELECTRON
+    ? { kind: 'system', path: process.execPath, version: process.versions.node }
+    : bundledActive
+      ? { kind: 'bundled', path: process.execPath, version: process.versions.node }
+      : { kind: 'system', path: RUNTIME_NODE, version: nodeVersionOf(RUNTIME_NODE) }
+  const requirement = nodeRequirementForInstalled()
+  const pending = IN_ELECTRON && (configured !== effective.kind
+    || (configured === 'system' && system && !fileManager.samePath(effective.path, system.path)))
+  const below = (version) => Boolean(requirement && version && cmpVer(parseVer(version), parseVer(requirement)) < 0)
+  return {
+    selectable: IN_ELECTRON,
+    configured,
+    configuredPath,
+    bundled,
+    system,
+    effective,
+    pending,
+    requirement,
+    systemTooOld: below(system?.version),
+    effectiveTooOld: below(effective.version),
+  }
+}
+
 function assertLauncherIdle() {
   if (instances.size || startingProfiles.size) throw new Error('请先停止正在运行的 DSH，再安装整合包')
 }
@@ -2112,6 +2485,116 @@ function profileDir() {
   return profileDirOf(PROFILE_NAME)
 }
 
+// ---- profile 配置层备份（每次启动前快照，出事了能回退） ----
+// 为什么不整目录复制：profile 里的 node_modules 动辄几百 MB，每次启动都复制不现实；
+// 真正会被改坏、回退时值得救的是配置层（补丁层、依赖清单、npmrc），加起来几十 KB。
+// 备份放在数据目录 backups/profiles/<用户目录指纹>/<profile>/<时间戳>/，跟数据一起走；
+// 多个 dsh 用户目录里同名 profile 靠指纹分开，互不覆盖。
+const PROFILE_BACKUP_FILES = ['cordis.patch.yml', 'package.json', 'pnpm-lock.yaml', '.npmrc']
+const PROFILE_BACKUP_KEEP = 10
+const PROFILE_BACKUP_ID = /^\d{8}-\d{6}(?:-\d+)?$/
+
+function homeStamp(home = homeDir()) {
+  return createHash('sha1').update(IS_WINDOWS ? home.toLowerCase() : home).digest('hex').slice(0, 12)
+}
+
+function profileBackupRoot(profile, home = homeDir()) {
+  return join(DATA, 'backups', 'profiles', homeStamp(home), safeProfile(profile))
+}
+
+function profileBackupTimestamp(now = new Date()) {
+  const pad = (value) => String(value).padStart(2, '0')
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
+}
+
+function readBackupManifest(dir) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf8'))
+    if (!manifest || !Array.isArray(manifest.files)) return null
+    return manifest
+  } catch { return null }
+}
+
+/** 最近的排前面。目录名是时间戳，但 createdAt 才是权威（手改目录名也不会乱序）。 */
+function listProfileBackups(profile, home = homeDir()) {
+  const root = profileBackupRoot(profile, home)
+  if (!existsSync(root)) return []
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && PROFILE_BACKUP_ID.test(entry.name))
+    .map((entry) => ({ id: entry.name, ...readBackupManifest(join(root, entry.name)) }))
+    .filter((item) => item.files && item.createdAt)
+    .sort((left, right) => (right.createdAt || 0) - (left.createdAt || 0))
+}
+
+function profileConfigSnapshot(profileDirPath) {
+  const files = []
+  for (const name of PROFILE_BACKUP_FILES) {
+    const file = join(profileDirPath, name)
+    if (!existsSync(file)) continue
+    try { files.push({ name, content: readFileSync(file) }) } catch { /* 读不了就跳过，别拦启动 */ }
+  }
+  const hash = createHash('sha256')
+  for (const file of files) hash.update(file.name).update('\0').update(file.content)
+  return { files, signature: hash.digest('hex') }
+}
+
+async function rotateProfileBackups(profile, home = homeDir()) {
+  const root = profileBackupRoot(profile, home)
+  for (const stale of listProfileBackups(profile, home).slice(PROFILE_BACKUP_KEEP)) {
+    await rm(join(root, stale.id), { recursive: true, force: true })
+  }
+}
+
+/**
+ * 给 profile 的配置层拍一份快照；内容跟最近一份一样就不重复存（每次启动都会调用它）。
+ * force 用在回退之前：那份「回退前」的备份即使内容没变也要留着，回退本身才可逆。
+ */
+async function snapshotProfileConfig(profile, { force = false } = {}) {
+  const name = safeProfile(profile || PROFILE_NAME)
+  const dir = profileDirOf(name)
+  if (!existsSync(join(dir, 'package.json'))) return null   // 还没初始化，没什么可救
+  const { files, signature } = profileConfigSnapshot(dir)
+  if (!files.length) return null
+  const home = homeDir()
+  const root = profileBackupRoot(name, home)
+  const latest = listProfileBackups(name, home)[0]
+  if (!force && latest?.signature === signature) return null
+  await mkdir(root, { recursive: true })
+  const stamp = profileBackupTimestamp()
+  let id = stamp
+  for (let index = 2; existsSync(join(root, id)); index += 1) id = `${stamp}-${index}`
+  const target = join(root, id)
+  await mkdir(target)
+  for (const file of files) await writeFile(join(target, file.name), file.content)
+  const manifest = { profile: name, home, createdAt: Date.now(), signature, files: files.map((file) => ({ name: file.name, size: file.content.length })) }
+  await writeFile(join(target, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`)
+  await rotateProfileBackups(name, home)
+  return { id, ...manifest }
+}
+
+/** 回退到某份配置快照：先给当前状态再存一份，所以回退本身也能再退回来。 */
+async function restoreProfileConfig(profile, id) {
+  const name = safeProfile(profile || PROFILE_NAME)
+  if (!PROFILE_BACKUP_ID.test(String(id || ''))) throw new Error('备份编号不对')
+  const home = homeDir()
+  const root = profileBackupRoot(name, home)
+  const source = join(root, String(id))
+  const manifest = readBackupManifest(source)
+  if (!manifest) throw new Error('找不到这份备份')
+  if (!manifest.files.some((file) => file.name === 'package.json')) throw new Error('这份备份里没有 package.json，回退会让 Profile 起不来')
+  if (instanceList().some((proc) => proc.profile === name && ['starting', 'running', 'stopping'].includes(proc.status))) throw new Error('请先停止这个 Profile 的实例再回退')
+  const dir = profileDirOf(name)
+  const saved = await snapshotProfileConfig(name, { force: true })
+  for (const file of PROFILE_BACKUP_FILES) {
+    const target = join(dir, file)
+    const included = manifest.files.some((entry) => entry.name === file)
+    if (included) await writeFile(target, readFileSync(join(source, file)))
+    else if (existsSync(target)) await rm(target, { force: true })
+  }
+  pushLog(`[备份] Profile ${name} 回退到 ${id}${saved ? `（回退前已存一份 ${saved.id}）` : ''}`)
+  return { ok: true, restored: String(id), backup: saved }
+}
+
 /**
  * 当前是否按局域网绑定：设置里选了局域网，或远程访问插件的「局域网访问」开关
  * 开着。两者都是用户明确的局域网意图，任一条成立启动器就不再注入 --host。
@@ -2316,11 +2799,70 @@ function profileBootsWebIn(home, name) {
  * @param {boolean} alongside
  * @param {number} pinned 手工固定或自动记忆的端口（0 = 首次，由系统挑）
  */
+/**
+ * 右侧栏浏览器的覆盖补丁：外壳已经提供原生 webview 载体（见 shell/browser-guests.mjs），
+ * 这里只把官方 `ui-sidebar-browser` 行从 web-app bundle 的「非 desktop profile 禁用」里放开。
+ * 走 `--patch` 叠加层，不改用户的 profile 文件，也不要求 profile 改名叫 desktop。
+ *
+ * 「启用内置浏览器控制」管的是 agent 那一半（dsh-x-sidebar-browser）：侧栏 Browser 本身照旧，
+ * 用户手动看网页不受影响，只是 agent 不能再操作它。关掉时给已装的插件补一行 disabled: true
+ * （没装就不写——不存在的行没必要出现在补丁里）。
+ */
+const SIDEBAR_BROWSER_PATCH_HEADER = '# 由 DSH-X 外壳生成：右侧栏浏览器（原生 webview 载体见 shell/browser-guests.mjs）。'
+/** 让 agent 操作侧栏 Browser 的首方插件；ensureDesktopPlugins 也按同一个开关决定补不补装。 */
+const AGENT_BROWSER_PLUGIN = 'dsh-x-sidebar-browser'
+
+/** profile 的清单里有没有这个插件（依赖或 bundle 列表任一命中，link: / file: 也算装）。 */
+function profileHasPlugin(profile, name) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(profileDirOf(profile), 'package.json'), 'utf8'))
+    const dependencies = manifest?.dependencies
+    const bundles = manifest?.dsh?.profile?.bundles
+    return (dependencies && Object.hasOwn(dependencies, name)) || (Array.isArray(bundles) && bundles.includes(name))
+  } catch {
+    return false
+  }
+}
+
+function sidebarBrowserPatchText(profile, enabled) {
+  const disableAgent = !enabled && profileHasPlugin(profile, AGENT_BROWSER_PLUGIN)
+  // 右键菜单的开关也搭同一趟 --patch：只在装过插件时写停用行，别给没装的环境留一条
+  // 匹配不到的补丁（dsh 会对每条不匹配的补丁打一行警告）。
+  const disableContextMenu = !CONTEXT_MENU && profileHasPlugin(profile, CONTEXT_MENU_PLUGIN)
+  return `${SIDEBAR_BROWSER_PATCH_HEADER}\n- id: ui-sidebar-browser\n  disabled: false\n`
+    + (disableAgent ? `- id: ${AGENT_BROWSER_PLUGIN}\n  disabled: true\n` : '')
+    + (disableContextMenu ? `- id: ${CONTEXT_MENU_ROW_ID}\n  disabled: true\n` : '')
+}
+
+function sidebarBrowserPatchArgs(profile) {
+  const enabled = BROWSER_CONTROL
+  // desktop profile 默认就放开 ui-sidebar-browser，也不装首方插件：浏览器和右键菜单都开着时
+  // 没有要覆盖的；任一个关着就得写补丁（右键菜单关掉在 desktop profile 上同样要生效）。
+  if (enabled && CONTEXT_MENU && String(profile ?? '').toLowerCase() === 'desktop') return []
+  try {
+    const file = join(DATA, 'shell', 'sidebar-browser.patch.yml')
+    mkdirSync(dirname(file), { recursive: true })
+    let current = ''
+    try {
+      current = readFileSync(file, 'utf8')
+    } catch { /* 还没有：写一份 */ }
+    const text = sidebarBrowserPatchText(profile, enabled)
+    if (current !== text) writeFileSync(file, text)
+    return ['--patch', file]
+  } catch (error) {
+    pushLog(`右侧栏浏览器补丁写不出来：${error instanceof Error ? error.message : error}`)
+    return []
+  }
+}
+
 function bootArgs(profile = PROFILE_NAME, alongside = false, pinned = 0) {
   // 不起 web 的 profile（headless / acp / sdk…）不提供 HTTP 服务，也不认这几个 flag：
   // 参数是透传给 profile 对应 app 的，会被它自己的 commander 打回 `unknown option`
   // 并 exit 1（`dsh headless --no-open` 就是这条），所以只对会起 web 的注入
   if (!bootsWebApp(profile)) return [profile, ...EXTRA_ARGS]
+  // profile 名必须排在第一个；launcher 自己的 flag（--patch 等）放在 profile 之后、
+  // app 参数之前（见 dsh 的 `dsh tui --patch ./extra.yml` 示例）。
+  const overlay = sidebarBrowserPatchArgs(profile)
   const port = pinned > 0 ? String(pinned) : '0'
   if (lanBindActive(WEB_BIND, lanBindToggleOn(homeDir(), profile))) {
     // 局域网：--host 不传。CLI 硬禁 --host 0.0.0.0，绑定只能走配置层（远程插件的
@@ -2328,14 +2870,14 @@ function bootArgs(profile = PROFILE_NAME, alongside = false, pinned = 0) {
     // 把插件钉好的端口抹成随机值，所以端口也交给配置层决定。
     // 两个例外，都是「不显式给端口就出事」：多开时配置层里只有一个端口，第二个实例
     // 撞上去就是 EADDRINUSE；用户自己钉了端口，就是要它——这两种情况显式传 --port。
-    if (!pinned && !alongside) return [profile, '--no-open', ...EXTRA_ARGS]
-    return [profile, '--port', port, '--no-open', ...EXTRA_ARGS]
+    if (!pinned && !alongside) return [profile, ...overlay, '--no-open', ...EXTRA_ARGS]
+    return [profile, ...overlay, '--port', port, '--no-open', ...EXTRA_ARGS]
   }
   // 默认姿势：钉死回环 + 端口（首次 --port 0，让 OS 现挑一个；dsh 会把真实地址
   // 打出来，启动器读它，所以顺延也不影响页面拿到链接）。
   // 额外参数放最后：用户可以用它覆盖 --port 之类（启动器是从 dsh 的输出里读真实地址的，
   // 所以换个端口也不影响管理页拿到的链接）
-  return [profile, '--host', '127.0.0.1', '--port', port, '--no-open', ...EXTRA_ARGS]
+  return [profile, ...overlay, '--host', '127.0.0.1', '--port', port, '--no-open', ...EXTRA_ARGS]
 }
 
 /** 这个「版本 × profile」手工固定的端口（0 = 自动分配并记忆）。 */
@@ -2594,6 +3136,12 @@ function spawnDsh(version, extra, profile = '', options = {}) {
   // 统一用 RUNTIME_NODE 拉起 dsh（打包后就是 Electron 自带的 Node，见 platform.js）；#61 的诊断
   // 上下文仍要在这之前建好 env。
   const env = dshEnv(version, options)
+  // 启动 CPU 账本：只有真正拉起实例（bootOnce）时才写报告，插件命令 / 修复命令不写，
+  // 否则会用一次半截运行覆盖掉上一次正常启动的样本。报告按「版本@profile」落盘。
+  if (options.pluginProfile) {
+    env.DSH_X_PLUGIN_PROFILE = `${version}@${profile || PROFILE_NAME}`
+    env.DSH_X_PLUGIN_PROFILE_DIR = join(APP_DIR, 'plugin-profile')
+  }
   if (options.diagnosticContext) {
     env.DSH_X_DIAGNOSTIC_ATTEMPT = options.diagnosticContext.attemptId
     // 取本次实际传入的入口和环境存在性，不扫描另一套安装，也不记录变量值。
@@ -2606,7 +3154,10 @@ function spawnDsh(version, extra, profile = '', options = {}) {
     })
   }
   return spawn(RUNTIME_NODE, dshArgs(version, extra, profile), {
-    cwd: home,
+    // 项目环境（见 launchWorkdir）：子进程在项目根里跑，dsh 的默认工作目录就是 process.cwd()，
+    // 新会话因此落在项目根；数据目录仍是 <项目>/.dsh（DSH_HOME 是绝对路径，不受 cwd 影响）。
+    // 其它情况跟以前一样钉在 DSH_HOME —— 插件命令、修复脚本都靠它。
+    cwd: options.cwd || home,
     env,
     stdio: ['ignore', 'pipe', 'pipe'],
     windowsHide: true,
@@ -2695,10 +3246,96 @@ async function checkSelfUpdate({ force = false } = {}) {
 let stagedApp = null
 let pendingAppUpdate = null
 let appUpdateCache = { at: 0, data: null }
+/** 下载可能被连点或两个标签页同时发起：并到同一份，应用只允许开一次（换了目录进程就退出了）。 */
+let appDownloadInFlight = null
+let appApplyStarted = false
 /** 完整安装包自更新的测试通道：DSH_UPDATE_VERSION 当最新版本。 */
 const TEST_UPDATE_VERSION = String(process.env.DSH_UPDATE_VERSION || '').trim().replace(/^v/i, '')
 const APP_UPDATE_CACHE_MS = 30 * 60 * 1000
 
+/** 下载核心增量包到暂存目录（自动更新与页面共用；并发由 appDownloadInFlight 合并）。 */
+async function downloadAppUpdate() {
+  const data = await checkAppUpdate({ force: true })
+  if (!data.available) {
+    throw new Error(data.reason === 'electron' ? 'Electron 版本不同，需要完整安装包' : '当前没有可用的核心更新')
+  }
+  if (stagedApp && stagedApp.version === data.version && stagingExists(stagedApp.dir)) {
+    return { ok: true, version: stagedApp.version, reused: true }
+  }
+  const tarball = join(tmpdir(), `DSH-X-core-${data.version}-${process.pid}.tgz`)
+  const result = await downloadCoreTarball(pendingAppUpdate.tarball, tarball, {
+    integrity: pendingAppUpdate.integrity,
+    shasum: pendingAppUpdate.shasum,
+    onProgress: ({ done, total }) => emit('selfUpdate', { phase: 'download', kind: 'app', done, total }),
+  })
+  const staging = join(tmpdir(), `DSH-X-core-${data.version}-${process.pid}`)
+  try {
+    const pkg = extractCoreTarball(tarball, staging)
+    if (String(pkg.version) !== String(data.version)) throw new Error(`核心包版本不一致：${pkg.version} != ${data.version}`)
+  } finally {
+    rmSync(tarball, { force: true })
+  }
+  stagedApp = { version: data.version, dir: staging }
+  pushLog(`核心更新已就绪：${data.version}（${(result.bytes / 1048576).toFixed(1)} MB），等用户确认后替换`)
+  emit('selfUpdate', { phase: 'app-ready', latest: data.version })
+  return { ok: true, version: data.version }
+}
+
+/**
+ * 换上暂存的核心并重启外壳。调用前由路由确认过「只开一次」；成功时进程很快会退出，
+ * 所以返回值只是给调用方一个响应。
+ */
+async function applyAppUpdate() {
+  if (!stagedApp || !stagingExists(stagedApp.dir)) throw new Error('还没有下载好的应用更新')
+  const stats = stagingStats(stagedApp.dir)
+  if (stats.files < 100) throw new Error('暂存目录不完整，重新下载一次')
+  const activeCore = join(APP_DIR, 'core', 'current')
+  if (fileManager.samePath(ROOT, activeCore)) {
+    // 已经在用户目录：助手等外壳退出 → 备份 → 换入 → 重启 → 等 update-ok，失败回滚
+    const helper = join(tmpdir(), `dsh-x-apply-${process.pid}-${randomBytes(4).toString('hex')}.mjs`)
+    copyFileSync(join(ROOT, 'apply-update.mjs'), helper)
+    const child = spawn(RUNTIME_NODE, [helper,
+      '--app', ROOT,
+      '--staged', stagedApp.dir,
+      // AppImage 的 process.execPath 是挂载目录里的临时二进制，重启要用 APPIMAGE 本身
+      '--exe', process.env.APPIMAGE || process.execPath,
+      '--pid', String(process.pid),
+      '--backup', `${ROOT}.bak-${APP_VERSION}`,
+      '--marker', join(APP_DIR, 'update-ok'),
+      '--log', join(APP_DIR, 'update.log'),
+    ], {
+      cwd: tmpdir(),
+      env: { ...process.env, ...RUNTIME_NODE_ENV },
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+    })
+    child.unref()
+    pushLog(`核心更新：替换助手已启动（${stagedApp.version}），启动器即将退出`)
+    setTimeout(() => shutdown().finally(() => host.exit(0)), 200)
+    return { ok: true, version: stagedApp.version }
+  }
+  // 内置基线：复制到用户目录，写 pending 标记；外壳下次启动优先加载 current，
+  // 起不来（外壳里的 recoverBaseline）会删掉 current 回退到基线
+  const pending = join(APP_DIR, 'core', 'pending')
+  const version = stagedApp.version
+  const stagedDir = stagedApp.dir
+  await rm(activeCore, { recursive: true, force: true })
+  await mkdir(dirname(activeCore), { recursive: true })
+  await cp(stagedDir, activeCore, { recursive: true })
+  stagedApp = null
+  try { rmSync(stagedDir, { recursive: true, force: true }) } catch { /* 临时目录清不掉不影响 */ }
+  writeFileSync(pending, JSON.stringify({ version, at: Date.now() }))
+  pushLog(`核心更新：已复制到 ${activeCore}（${version}），重启外壳`)
+  // 不能直接 spawn DSH.exe：当前进程还占着单实例锁，新进程会立刻退出。
+  // 外壳的 host.relaunch 用 app.relaunch()，等本进程退出后才拉起新外壳。
+  setTimeout(() => shutdown().finally(() => {
+    if (typeof host.relaunch === 'function') host.relaunch()
+    else host.exit(0)
+  }), 200)
+  return { ok: true, version }
+}
+
 /** 安装器建的两个快捷方式（用户取消勾选时可能不存在）。 */
 function shortcutLinks() {
   const links = []
@@ -2765,12 +3402,13 @@ export async function refreshShortcuts({ installRoot, appDir = APP_DIR, version
  */
 async function checkAppUpdate({ force = false } = {}) {
   if (NPM_MODE) return { available: false, reason: 'npm' }
-  if (!PACKAGED || (!IS_WINDOWS && !IS_MAC)) return { available: false, reason: PACKAGED ? 'platform' : 'source' }
+  if (!PACKAGED || (!IS_WINDOWS && !IS_MAC && !IS_LINUX)) return { available: false, reason: PACKAGED ? 'platform' : 'source' }
   if (!force && appUpdateCache.data && Date.now() - appUpdateCache.at < APP_UPDATE_CACHE_MS) return appUpdateCache.data
   const remember = (data) => { appUpdateCache = { at: Date.now(), data }; return data }
   const latest = APP_VERSION
   let result
   try {
+    // 通道跟着当前版本走（正式版只收正式版，rc 版收 rc / alpha），没有单独的通道开关。
     result = await checkCoreUpdate({
       current: APP_VERSION,
       source: UPDATE_SOURCE,
@@ -3287,6 +3925,66 @@ async function addPlugin(version, spec, { profile = PROFILE_NAME } = {}) {
   }
 }
 
+// ---- 桌面增强：启动前把缺的首方插件补进 profile ----
+/** 本进程正在自动装插件；和插件页的手动安装共用 addPlugin 的那把锁。 */
+let desktopPluginInstalling = false
+/**
+ * 本进程里试过的「home + profile」：一次启动只尝试一轮。
+ *
+ * 失败（多半是离线）不在同一个进程里反复重试——每次点启动都等一遍超时可不行；
+ * 下次启动启动器（新进程）会重新检查。
+ */
+const desktopPluginsAttempted = new Set()
+
+/**
+ * 拉起实例前检查 web profile 缺哪个桌面增强插件，缺的用插件页同一条链路装上。
+ *
+ * - 只认「装没装」：用户在 dsh 里关掉的插件不会被这里重新打开；
+ * - 失败只记日志、不拦启动：离线或 registry 抽风不该让 dsh 起不来，下次启动再试；
+ * - 和用户手动安装撞上（pluginBusy）就跳过这一次，别让两条 pnpm 抢同一个目录。
+ *
+ * @param {string} version - 要启动的 dsh 版本。
+ * @param {string} profile - profile 名。
+ */
+async function ensureDesktopPlugins(version, profile) {
+  if (desktopPluginInstalling) return
+  if (!bootsWebApp(profile)) return
+  if (DESKTOP_PLUGINS_SKIP_PROFILES.includes(String(profile).toLowerCase())) return
+  const attemptKey = `${homeDir()}\0${profile}`
+  if (desktopPluginsAttempted.has(attemptKey)) return
+  let manifest
+  try {
+    manifest = JSON.parse(readFileSync(join(profileDirOf(profile), 'package.json'), 'utf8'))
+  } catch {
+    return
+  }
+  // 「启用内置浏览器控制」关掉时不再补装 agent 工具；「右键菜单」关掉时同样不补装。
+  // 已经装过的由启动补丁停用。
+  const missing = desktopPluginsToInstall(manifest, version)
+    .filter((plugin) => plugin.name !== AGENT_BROWSER_PLUGIN || BROWSER_CONTROL)
+    .filter((plugin) => plugin.name !== CONTEXT_MENU_PLUGIN || CONTEXT_MENU)
+  if (!missing.length) return
+  desktopPluginsAttempted.add(attemptKey)
+  desktopPluginInstalling = true
+  try {
+    for (const plugin of missing) {
+      if (pluginBusy) {
+        pushLog(`桌面增强：${profile} 缺少 ${plugin.label}（${plugin.name}），但插件正在安装，下次启动再补`)
+        continue
+      }
+      pushLog(`桌面增强：${profile} 缺少 ${plugin.label}（${plugin.name}），自动安装`)
+      try {
+        await addPlugin(version, `${plugin.name}@${plugin.spec}`, { profile })
+        pushLog(`桌面增强：${plugin.name} 已装进 ${profile}`)
+      } catch (error) {
+        pushLog(`桌面增强：${plugin.name} 自动安装失败（下次启动再试）：${error instanceof Error ? error.message : error}`)
+      }
+    }
+  } finally {
+    desktopPluginInstalling = false
+  }
+}
+
 // ---- 插件更新：查 registry 上的最新版本，按需升级 profile 里的包 ----
 // 升级复用 addPlugin（peer 404、目录链接读不了这两套回退都在里面），装和升走同一条路。
 const pluginUpdateCache = { at: 0, data: null, profile: '' }
@@ -4096,6 +4794,17 @@ async function terminateProcess(proc) {
   return false
 }
 
+/**
+ * 任务通知：实例启动失败 / 意外退出。文案由外壳按当前语言拼（外壳知道 lang，
+ * 也掌管 Notification 与提示音开关），这里只给结构化事实。
+ */
+function notifyInstance(kind, proc, extra = {}) {
+  if (shuttingDown) return
+  try {
+    host.notify({ kind, name: launchNameOf(proc), version: proc.version, profile: proc.profile, ...extra })
+  } catch { /* 通知失败不能影响实例本身 */ }
+}
+
 function attachProcess(version, profile, child, diagnosticContext) {
   const key = instanceKey(version, profile)
   let ready
@@ -4145,6 +4854,8 @@ function attachProcess(version, profile, child, diagnosticContext) {
     }
   }
   const onLine = (line) => {
+    // 首个输出时间：等待就绪那一段里，从 spawn 到第一行之间通常是 Node 启动与依赖解析
+    if (!proc.firstOutputAt) proc.firstOutputAt = performance.now()
     if (proc.diagnosis.addLine(line)) {
       scheduleDiagnosis()
     }
@@ -4168,6 +4879,8 @@ function attachProcess(version, profile, child, diagnosticContext) {
       scheduleDiagnosis()
       proc.readyAt = performance.now()
       ready()
+      // 正常启动不发通知：用户点了启动就有进度页和窗口，再响一声只是噪音。
+      // 只有失败 / 意外退出（下面那条）才值得打断。
       emitState()
     }
   }
@@ -4191,6 +4904,10 @@ function attachProcess(version, profile, child, diagnosticContext) {
     proc.exit = { code, signal }
     ready()
     pushLog(`${tag}已退出 code=${code ?? '-'} signal=${signal ?? '-'}`)
+    // 没拿到就绪地址 = 启动失败；用户主动停止（stopping）不打扰
+    if (proc.status !== 'stopping') {
+      notifyInstance(proc.url ? 'exited' : 'failed', proc, { code, signal })
+    }
     if (instances.get(key)?.child === child) {
       instances.delete(key)
       lastHealth = null
@@ -4234,7 +4951,7 @@ export async function checkWebPage(origin, token) {
   const base = String(origin).replace(/\/+$/, '')
   const first = await fetch(`${base}/?token=${encodeURIComponent(token)}`, {
     redirect: 'manual',
-    signal: AbortSignal.timeout(8000),
+    signal: AbortSignal.timeout(30000), // 刚就绪时 dsh 还在合成客户端插件包，8 秒经常回不来
   })
   const cookie = (first.headers.getSetCookie?.() || []).map((item) => item.split(';')[0]).join('; ')
   const headers = cookie ? { cookie } : {}
@@ -4257,6 +4974,20 @@ export async function checkWebPage(origin, token) {
   return { origin: base, total: urls.length, ok, failed }
 }
 
+/**
+ * 启动 CPU 账本：正常启动时由 perf/plugin-profile.mjs 在启动窗口内采样写入，这里只读。
+ * 记录不存在时返回 missing，页面据此显示「重启一次后再看」。
+ */
+async function pluginProfileReport(version, profile) {
+  const file = join(APP_DIR, 'plugin-profile', `${version}@${profile}.json`)
+  try {
+    const report = JSON.parse(await readFile(file, 'utf8'))
+    return { ...report, file }
+  } catch {
+    return { version, profile, missing: true, packages: [], native: [], entries: [] }
+  }
+}
+
 /**
  * 从 app 页面 HTML 里挑出客户端插件包的地址。
  *
@@ -4303,6 +5034,27 @@ async function selfCheckPage(url, version) {
   }
 }
 
+/**
+ * 这次启动绑定的项目目录。项目环境是「这套数据目录」的属性，不是某次点击的属性：
+ * 先看这次请求带着哪个启动项，再看有没有哪个启动项把项目目录挂在这个 DSH_HOME 上。
+ * 后者是给手工启动 / 重启 / 自动恢复用的——它们不带启动项 ID，但环境还是那个项目环境。
+ * 目录被用户删掉时不报错：退回老行为照样能起来，只是新会话不在项目根。
+ */
+function launchWorkdir() {
+  const id = launchScope.getStore()?.launchId
+  const presets = safeLaunchPresets(loadSettingsSync().launchPresets)
+  const entry = id
+    ? presets.find((item) => item.id === id)
+    : presets.find((item) => item.workdir && fileManager.samePath(item.dshHome || '', homeDir()))
+  const dir = entry?.workdir || ''
+  if (!dir) return ''
+  if (!existsSync(dir)) {
+    pushLog(`项目目录 ${dir} 不在了，这次启动按普通独立目录处理（新会话不在项目根）`)
+    return ''
+  }
+  return dir
+}
+
 /** 起一个 web 子进程并等到它打印就绪 URL；失败时把子进程输出尾巴留给 AI 当证据。 */
 async function bootOnce(ver, prof, onStarted) {
   const startedAt = performance.now()
@@ -4317,7 +5069,8 @@ async function bootOnce(ver, prof, onStarted) {
     // TIME_WAIT。真起不来时下面那条 catch 会把话说清楚。
     pushLog(`固定端口 ${pinned} 现在被占用，这次启动多半会失败`)
   }
-  pushLog(`启动 ${ver} · profile ${prof}${lanBindActive(WEB_BIND, lanBindToggleOn(homeDir(), prof)) ? ' · Web 绑定 局域网(0.0.0.0，由配置层决定)' : ''}${pinned ? ` · 固定端口 ${pinned}` : ''}${alongside ? '（与已在跑的实例并存）' : ''}`)
+  const workdir = launchWorkdir()
+  pushLog(`启动 ${ver} · profile ${prof}${workdir ? ` · 项目目录 ${workdir}` : ''}${lanBindActive(WEB_BIND, lanBindToggleOn(homeDir(), prof)) ? ' · Web 绑定 局域网(0.0.0.0，由配置层决定)' : ''}${pinned ? ` · 固定端口 ${pinned}` : ''}${alongside ? '（与已在跑的实例并存）' : ''}`)
   if (reused) {
     pushLog(remembered.key === `${ver}@${prof}`
       ? `复用自动端口：${ver}@${prof} → ${reused}`
@@ -4331,7 +5084,7 @@ async function bootOnce(ver, prof, onStarted) {
     home: homeDir(),
     fingerprint: profileFingerprint(homeDir(), prof),
   }
-  const child = spawnDsh(ver, bootArgs(prof, alongside, pinned || reused), prof, { diagnosticContext })
+  const child = spawnDsh(ver, bootArgs(prof, alongside, pinned || reused), prof, { diagnosticContext, cwd: workdir, pluginProfile: true })
   const spawnAt = performance.now()
   const proc = attachProcess(ver, prof, child, diagnosticContext)
   onStarted?.(proc)
@@ -4341,8 +5094,24 @@ async function bootOnce(ver, prof, onStarted) {
     if (automatic) await rememberAutoPort(ver, prof, result.url)
     // 分清启动器准备、子进程输出就绪地址、管理器确认三段，避免把地址可用误当成会话首屏。
     const readyAt = proc.readyAt || performance.now()
+    proc.startupMs = Math.round(readyAt - spawnAt)
     const confirmedAt = performance.now()
-    pushLog(`启动耗时 ${ver}/${prof}：准备 ${Math.round(spawnAt - startedAt)}ms，子进程就绪地址 ${Math.round(readyAt - spawnAt)}ms，确认 ${Math.round(confirmedAt - readyAt)}ms，总计 ${Math.round(confirmedAt - startedAt)}ms`)
+    const prepareMs = Math.round(spawnAt - startedAt)
+    const readyMs = Math.round(readyAt - spawnAt)
+    const confirmMs = Math.round(confirmedAt - readyAt)
+    recordLaunchRun(launchScope.getStore()?.launchId, {
+      at: Date.now(),
+      version: ver,
+      profile: prof,
+      totalMs: Math.round(confirmedAt - startedAt),
+      prepareMs,
+      readyMs,
+      confirmMs,
+      firstOutputMs: proc.firstOutputAt ? Math.round(proc.firstOutputAt - spawnAt) : null,
+      // 启动结算时读一次子进程 RSS：进程级常驻，够用的“大概”
+      startupRssMB: readProcessRssMB(proc.child?.pid),
+    })
+    pushLog(`启动耗时 ${ver}/${prof}：准备 ${prepareMs}ms，子进程就绪地址 ${readyMs}ms，确认 ${confirmMs}ms，总计 ${Math.round(confirmedAt - startedAt)}ms`)
     // 钉了端口却没落到上面（额外参数里另有 --port，或 dsh 自己顺延了）：如实说一句，
     // 否则用户以为存下来的地址还有效
     if (pinned && urlPortOf(result.url) !== pinned) {
@@ -4521,6 +5290,17 @@ async function startWithRepair(version, profile = PROFILE_NAME) {
   // 早于任何一次 add 就有这行，市场里点安装才不会撞上 peer 求交那个坑。
   // 只对当前 profile 做——起别的 profile 不动它的文件，人家可能就是故意留空的
   if (profile === PROFILE_NAME) await ensureProfileNpmrc(profile).catch(() => {})
+  // 启动前给 profile 的配置层留一份快照：插件装崩、补丁写坏时能退回到这次启动前的样子。
+  // 只存配置层（几十 KB），node_modules 不动；内容没变时 snapshotProfileConfig 会跳过。
+  // 快照失败不拦启动——备份是保险，不是启动的前提。
+  await snapshotProfileConfig(profile).catch((error) => {
+    pushLog(`[备份] Profile ${profile} 快照失败：${error instanceof Error ? error.message : error}`)
+  })
+  // 桌面增强（原生通知 / 右键菜单 / 侧栏浏览器控制）：缺哪个补哪个。装在拉起子进程之前，
+  // 这样第一次启动就能用上；失败不影响启动，下次再试。
+  await ensureDesktopPlugins(version, profile).catch((error) => {
+    pushLog(`桌面增强：自动安装检查失败：${error instanceof Error ? error.message : error}`)
+  })
   for (;;) {
     try {
       return await startNow(version, profile)
@@ -4793,20 +5573,31 @@ async function renameProfile(profile, nextName) {
   return { ok: true, ...packsPayload(), renamedProfile: name, profile: name, state: await snapshot(), webProfiles: listProfiles().filter((profile) => profileBootsWebIn(home, profile)) }
 }
 
-async function createProfile(profile, source = '') {
+/**
+ * 建 Profile：`source` 给了就把那份配置复制过来（插件清单、开关、MCP、补丁层），
+ * 复制完在目标环境里重装依赖。`sourceHome` 是来源所在的那个用户目录，空 = 当前环境；
+ * 项目环境（issue #72）常从全局目录里已经调好的 Profile 复制，两个目录互不相干。
+ */
+async function createProfile(profile, source = '', sourceHome = '') {
   const name = safeProfile(profile)
   const from = source ? safeProfile(source) : ''
   if (name.startsWith('.') || name.toLowerCase() === 'node_modules' || TEMPLATE_PROFILES.includes(name.toLowerCase()) || CLI_BLOCKED_PROFILES.has(name.toLowerCase())) {
     throw new Error('这个名称是系统保留名称，请换一个 Profile 名称')
   }
-  const root = join(homeDir(), 'profiles')
+  // 目标永远是「当前作用域」这一份；来源可以另指一个用户目录。
+  const home = homeDir()
+  const fromHome = from ? safeDshHome(sourceHome) || home : ''
+  const root = join(home, 'profiles')
   await mkdir(root, { recursive: true })
   if (readdirSync(root).some((entry) => entry.toLowerCase() === name.toLowerCase())) throw new Error(`Profile「${name}」已存在`)
-  const original = from ? profileDirOf(from) : ''
+  const original = from ? join(fromHome, 'profiles', from) : ''
   if (from && !existsSync(join(original, 'package.json'))) throw new Error(`Profile「${from}」尚未初始化，不能复制`)
-  const target = profileDirOf(name)
-  await withIdleProfile(from || name, async () => {
-    if (from) maintainingProfiles.add(profileKey(name))
+  const target = join(home, 'profiles', name)
+  const targetKey = `${home}\0${name}`
+  if (maintainingProfiles.has(targetKey)) throw new Error(`profile「${name}」正在修改，稍后再试`)
+  // 锁的是来源那一份（同目录复制时就是自己）：来源被删/被改到一半，复制出来的是坏环境。
+  await withIdleProfileIn(from ? fromHome : home, from || name, async () => {
+    if (from) maintainingProfiles.add(targetKey)
     const staging = mkdtempSync(join(root, '.dsh-profile-'))
     let created = false
     try {
@@ -4839,13 +5630,15 @@ async function createProfile(profile, source = '') {
       if (['dependencies', 'devDependencies', 'optionalDependencies'].some((key) => Object.keys(manifest[key] || {}).length)) {
         await runProfileInstall(await pluginCommandVersion(name), { profile: name })
       }
-      pushLog(from ? `已复制 Profile「${from}」为「${name}」` : `已创建 Profile「${name}」`)
+      pushLog(from
+        ? `已复制 Profile「${from}」为「${name}」${fromHome === home ? '' : `（来源目录 ${fromHome}）`}`
+        : `已创建 Profile「${name}」`)
     } catch (error) {
       if (created) await rm(target, { recursive: true, force: true })
       throw error
     } finally {
       await rm(staging, { recursive: true, force: true })
-      if (from) maintainingProfiles.delete(profileKey(name))
+      if (from) maintainingProfiles.delete(targetKey)
     }
   })
   await emitState()
@@ -5026,6 +5819,22 @@ export function openRoute(mode, shellWindow, internalTabs = false) {
 function openExternal(target, mode = OPEN_MODE) {
   const url = String(target)
   if (openRoute(mode, shellWindowHost(), internalTabsHost()) === 'internal') {
+    // 启动等待页占的正是这个实例的标签位（id 与 internalTabTarget 同一套拼法）：
+    // 页面自己跳到 dsh 之后就是实例页，标签条上不会先多出一个「DSH」再被实例页挤掉。
+    const booting = new URL(url)
+    if (booting.pathname === '/booting') {
+      const version = booting.searchParams.get('version') || ''
+      const profile = booting.searchParams.get('profile') || ''
+      const home = booting.searchParams.get('home') || ''
+      host.openTab({
+        id: JSON.stringify([home, version, profile]),
+        title: booting.searchParams.get('name') || [profile, version].filter(Boolean).join(' · ') || 'DSH',
+        url,
+        status: 'starting',
+        managed: true,
+      })
+      return
+    }
     const instance = instanceList().find((proc) => proc.url && new URL(proc.url).origin === new URL(url).origin)
     const tab = instance ? internalTabTarget(instance, launchNameOf(instance)) : { id: new URL(url).origin, title: 'DSH', url, status: 'running', managed: false }
     // 认证地址只在本机管道或同进程调用中传递；标题和实例身份都不包含 token，也不写入日志或设置。
@@ -5244,6 +6053,37 @@ async function exportLogs() {
   return redact(chunks.length ? chunks.join('') : logs.join('\n'), secretValues)
 }
 
+/**
+ * 插件桌面 API 的能力清单（GET /api/desktop）。
+ *
+ * available 只有真外壳接上 host.desktop 时为真：浏览器模式（node start.js）和旧外壳
+ * 都没有这层能力。通知开关和外壳读的是同一份 settings.json，插件可以先看它决定
+ * 要不要退回页面内提示。
+ */
+function desktopPayload() {
+  const desktop = host.desktop
+  // 外壳的 info 坏了不该让整份能力清单失败：插件至少还能看到 available 和 capabilities。
+  let info = {}
+  try {
+    info = (desktop && typeof desktop.info === 'function' ? desktop.info() : null) || {}
+  } catch {
+    info = {}
+  }
+  const settings = loadSettingsSync()
+  return {
+    api: DESKTOP_API_VERSION,
+    available: Boolean(desktop),
+    platform: process.platform,
+    capabilities: desktop ? [...DESKTOP_CAPABILITIES] : [],
+    notifications: {
+      enabled: settings.taskNotifications !== false,
+      sound: settings.notificationSound !== false,
+    },
+    theme: typeof info.theme === 'string' ? info.theme : '',
+    versions: { core: APP_VERSION, ...(info.versions && typeof info.versions === 'object' ? info.versions : {}) },
+  }
+}
+
 async function handleApi(req, res, url) {
   // 身份标记：端口被占用时我们要能分辨那是自己的另一个实例还是别人的程序
   if (url.pathname === '/api/ping') {
@@ -5320,23 +6160,7 @@ async function handleApi(req, res, url) {
     return
   }
   if (req.method === 'GET' && url.pathname === '/api/tray') {
-    // 保留旧外壳的标量字段；新外壳按命名启动项操作，不再把单项停止变成停止全部。
-    const running = primaryInstance()
-    const launches = trayLaunches()
-    send(res, 200, [
-      `status=${running?.status || 'stopped'}`,
-      `url=${running?.url || ''}`,
-      `installed=${trayInstalledVersions().length ? 1 : 0}`,
-      `lang=${LANG}`,
-      // 托盘照着它决定「打开 DSH」是叫内嵌窗口还是丢给系统浏览器
-      `openmode=${OPEN_MODE}`,
-      // 本次是不是由原生外壳托管：外壳缺失时窗口模式不成立，托盘据此退回浏览器
-      `shell=${shellWindowHost() ? 1 : 0}`,
-      `theme=${THEME}`,
-      // 原生标签页要跟随所有实例，不能用「最近启动的实例」去覆盖用户正在看的其他页面。
-      `instances=${JSON.stringify(instanceList().map((proc) => internalTabTarget(proc, launches.find((row) => row.proc === proc)?.name)))}`,
-      `launches=${JSON.stringify(launches.map(({ id, instanceId, name, version, profile, status, busy, installed, target }) => ({ id, instanceId, name, version, profile, status, busy, installed, target })))}`,
-    ].join('\n'), 'text/plain; charset=utf-8')
+    send(res, 200, trayStateText(), 'text/plain; charset=utf-8')
     return
   }
   if (req.method === 'GET' && url.pathname === '/api/changelog') {
@@ -5348,6 +6172,51 @@ async function handleApi(req, res, url) {
     send(res, 200, await publicSettings())
     return
   }
+  if (req.method === 'GET' && url.pathname === '/api/launch-log') {
+    const id = String(url.searchParams.get('id') || '')
+    if (!LAUNCH_ID_RE.test(id)) {
+      send(res, 400, { error: '启动项 id 不合法' })
+      return
+    }
+    const file = join(LAUNCH_LOG_DIR, `launch-${id}.log`)
+    let text = ''
+    let at = null
+    try {
+      text = readFileSync(file, 'utf8')
+      at = statSync(file).mtimeMs
+    } catch {
+      // 还没启动过：空日志，页面显示提示
+    }
+    const limit = 120 * 1024
+    const clipped = text.length > limit
+    if (clipped) text = text.slice(-limit)
+    let runs = []
+    try {
+      const parsed = JSON.parse(readFileSync(join(LAUNCH_LOG_DIR, `launch-${id}.json`), 'utf8'))
+      if (Array.isArray(parsed?.runs)) runs = parsed.runs.slice(0, 20)
+    } catch {
+      // 没有耗时记录：只显示日志
+    }
+    send(res, 200, { id, text, at, clipped, runs })
+    return
+  }
+  if (req.method === 'GET' && url.pathname === '/api/launch-log/export') {
+    const id = String(url.searchParams.get('id') || '')
+    if (!LAUNCH_ID_RE.test(id)) {
+      send(res, 400, { error: '启动项 id 不合法' })
+      return
+    }
+    let text = ''
+    try {
+      text = readFileSync(join(LAUNCH_LOG_DIR, `launch-${id}.log`), 'utf8')
+    } catch {
+      send(res, 404, { error: '这个启动项还没有日志' })
+      return
+    }
+    res.setHeader('content-disposition', `attachment; filename="launch-${id}.log"`)
+    send(res, 200, text, 'text/plain; charset=utf-8')
+    return
+  }
   if (req.method === 'GET' && url.pathname === '/api/logs/export') {
     res.setHeader('content-disposition', 'attachment; filename="dsh-x-logs.txt"')
     send(res, 200, await exportLogs(), 'text/plain; charset=utf-8')
@@ -5357,6 +6226,17 @@ async function handleApi(req, res, url) {
     send(res, 200, await snapshot())
     return
   }
+  if (req.method === 'GET' && url.pathname === '/api/plugin-profile') {
+    // 账本按「版本@profile」存在数据目录里；参数非法回 400，别让它拼进文件路径。
+    try {
+      const version = safeVersion(url.searchParams.get('version') || '')
+      const profile = safeProfile(url.searchParams.get('profile') || PROFILE_NAME)
+      send(res, 200, await pluginProfileReport(version, profile))
+    } catch (error) {
+      send(res, 400, { error: error instanceof Error ? error.message : String(error) })
+    }
+    return
+  }
   if (req.method === 'GET' && url.pathname === '/api/launch-home/profiles') {
     const home = safeDshHome(url.searchParams.get('home')) || defaultHome()
     const profiles = listProfiles(join(home, 'profiles'))
@@ -5373,7 +6253,7 @@ async function handleApi(req, res, url) {
     const body = await readJson(req)
     const copying = url.pathname === '/api/profiles/copy'
     if (copying && !body.source) { send(res, 400, { error: '请选择要复制的 Profile' }); return }
-    try { send(res, 200, await createProfile(body.profile, copying ? body.source : '')) }
+    try { send(res, 200, await createProfile(body.profile, copying ? body.source : '', copying ? body.sourceHome : '')) }
     catch (error) { send(res, 400, { error: error instanceof Error ? error.message : String(error) }) }
     return
   }
@@ -5382,6 +6262,16 @@ async function handleApi(req, res, url) {
     send(res, 200, recoveryPayload(profile))
     return
   }
+  if (req.method === 'GET' && url.pathname === '/api/profile-backups') {
+    // 参数坏了回 400 而不是 500：这接口会被页面直接拼 query，别让半截名字炸进目录操作。
+    try {
+      const profile = safeProfile(url.searchParams.get('profile') || PROFILE_NAME)
+      const id = url.searchParams.get('id')
+      if (id !== null && !PROFILE_BACKUP_ID.test(id)) throw new Error('备份编号不对')
+      send(res, 200, { profile, home: homeDir(), backups: listProfileBackups(profile) })
+    } catch (error) { send(res, 400, { error: error instanceof Error ? error.message : String(error) }) }
+    return
+  }
   if (req.method === 'GET' && url.pathname === '/api/plugins/updates') {
     try {
       const profile = safeProfile(url.searchParams.get('profile') || PROFILE_NAME)
@@ -5443,6 +6333,77 @@ async function handleApi(req, res, url) {
   }
 
   const body = req.method === 'POST' ? await readJson(req) : {}
+  // 插件桌面 API：插件在 dsh 子进程里用本机 HTTP 调这里，真正的 Notification / dialog /
+  // clipboard 由外壳的 host.desktop 执行（见 shell/main.mjs）。GET 只回能力清单。
+  if (url.pathname === '/api/desktop' || url.pathname.startsWith('/api/desktop/')) {
+    if (url.pathname === '/api/desktop') {
+      if (req.method !== 'GET') send(res, 405, { error: '/api/desktop 只支持 GET' })
+      else send(res, 200, desktopPayload())
+      return
+    }
+    if (req.method !== 'POST') {
+      send(res, 405, { error: '桌面能力只支持 POST' })
+      return
+    }
+    if (!host.desktop) {
+      // 浏览器模式 / 旧外壳：能力不存在。插件按 available=false 降级，别重试。
+      send(res, 503, { available: false, error: '桌面能力不可用：当前不是 DSH-X 桌面外壳在运行' })
+      return
+    }
+    const action = url.pathname.slice('/api/desktop/'.length)
+    let request
+    try {
+      request = parseDesktopRequest(action, body)
+    } catch (error) {
+      send(res, 400, { error: error instanceof Error ? error.message : String(error) })
+      return
+    }
+    if (!request) {
+      send(res, 404, { error: `没有 /api/desktop/${action} 这个能力` })
+      return
+    }
+    if (typeof host.desktop[request.action] !== 'function') {
+      send(res, 503, { available: false, error: `这个外壳还不支持 ${request.action}` })
+      return
+    }
+    // 只显示真实存在的路径：这条路由没有鉴权，不能变成任意路径的文件管理器入口。
+    if (request.action === 'reveal' && !existsSync(request.path)) {
+      send(res, 400, { error: '这个路径不存在' })
+      return
+    }
+    try {
+      const result = await host.desktop[request.action](request)
+      send(res, 200, { ok: true, ...(result && typeof result === 'object' ? result : {}) })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      pushLog(`桌面能力 ${request.action} 失败：${message}`)
+      send(res, 500, { error: message })
+    }
+    return
+  }
+  // 设置页「浏览器控制」的两个清理按钮：guest 分区在 Electron 外壳里，核心只能转发。
+  // 只影响内置浏览器（persist:dsh-sidebar-browser-*），管理页和 dsh 页面的数据不动。
+  if (req.method === 'POST' && (url.pathname === '/api/browser/clear-cache' || url.pathname === '/api/browser/clear-data')) {
+    if (!host.browser) {
+      send(res, 503, { available: false, error: '浏览器数据清理不可用：当前不是 DSH-X 桌面外壳在运行，或外壳版本太旧' })
+      return
+    }
+    const action = url.pathname.endsWith('/clear-cache') ? 'clearCache' : 'clearAll'
+    if (typeof host.browser[action] !== 'function') {
+      send(res, 503, { available: false, error: `这个外壳还不支持 ${action}` })
+      return
+    }
+    try {
+      const result = await host.browser[action]()
+      pushLog(action === 'clearCache' ? '内置浏览器缓存已清除' : '内置浏览器的 Cookie、站点数据和缓存已清除')
+      send(res, 200, { ok: true, ...(result && typeof result === 'object' ? result : {}) })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      pushLog(`清理内置浏览器数据失败：${message}`)
+      send(res, 500, { error: message })
+    }
+    return
+  }
   if (req.method === 'POST' && ['/api/diagnosis/repair/preview', '/api/diagnosis/repair/execute', '/api/diagnosis/repair/rollback'].includes(url.pathname)) {
     try {
       let result
@@ -5510,31 +6471,11 @@ async function handleApi(req, res, url) {
   if (req.method === 'POST' && url.pathname === '/api/self/app-download') {
     // 核心更新：从 npm 下载 tarball → 校验 sha512 → 解到暂存目录；进度复用 selfUpdate 事件
     try {
-      const data = await checkAppUpdate({ force: true })
-      if (!data.available) {
-        throw new Error(data.reason === 'electron' ? 'Electron 版本不同，需要完整安装包' : '当前没有可用的核心更新')
-      }
-      if (stagedApp && stagedApp.version === data.version && stagingExists(stagedApp.dir)) {
-        send(res, 200, { ok: true, version: stagedApp.version, reused: true })
-        return
-      }
-      const tarball = join(tmpdir(), `DSH-X-core-${data.version}-${process.pid}.tgz`)
-      const result = await downloadCoreTarball(pendingAppUpdate.tarball, tarball, {
-        integrity: pendingAppUpdate.integrity,
-        shasum: pendingAppUpdate.shasum,
-        onProgress: ({ done, total }) => emit('selfUpdate', { phase: 'download', kind: 'app', done, total }),
-      })
-      const staging = join(tmpdir(), `DSH-X-core-${data.version}-${process.pid}`)
-      try {
-        const pkg = extractCoreTarball(tarball, staging)
-        if (String(pkg.version) !== String(data.version)) throw new Error(`核心包版本不一致：${pkg.version} != ${data.version}`)
-      } finally {
-        rmSync(tarball, { force: true })
+      // 自动更新与页面可能同时发起：并到同一份下载上，免得两个 tarball 抢同一个暂存目录
+      if (!appDownloadInFlight) {
+        appDownloadInFlight = downloadAppUpdate().finally(() => { appDownloadInFlight = null })
       }
-      stagedApp = { version: data.version, dir: staging }
-      pushLog(`核心更新已就绪：${data.version}（${(result.bytes / 1048576).toFixed(1)} MB），等用户确认后替换`)
-      emit('selfUpdate', { phase: 'app-ready', latest: data.version })
-      send(res, 200, { ok: true, version: data.version })
+      send(res, 200, await appDownloadInFlight)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       pushLog(`核心更新下载失败：${message}`)
@@ -5546,55 +6487,15 @@ async function handleApi(req, res, url) {
     // 核心增量：内置基线 → 复制到用户目录 core/current，重启外壳（外壳优先加载它）；
     // 已经在 core/current → 替换助手等外壳退出后原地换目录，失败回滚。
     try {
-      if (!stagedApp || !stagingExists(stagedApp.dir)) throw new Error('还没有下载好的应用更新')
-      const stats = stagingStats(stagedApp.dir)
-      if (stats.files < 100) throw new Error('暂存目录不完整，重新下载一次')
-      const activeCore = join(APP_DIR, 'core', 'current')
-      if (fileManager.samePath(ROOT, activeCore)) {
-        // 已经在用户目录：助手等外壳退出 → 备份 → 换入 → 重启 → 等 update-ok，失败回滚
-        const helper = join(tmpdir(), `dsh-x-apply-${process.pid}-${randomBytes(4).toString('hex')}.mjs`)
-        copyFileSync(join(ROOT, 'apply-update.mjs'), helper)
-        const child = spawn(RUNTIME_NODE, [helper,
-          '--app', ROOT,
-          '--staged', stagedApp.dir,
-          '--exe', process.execPath,
-          '--pid', String(process.pid),
-          '--backup', `${ROOT}.bak-${APP_VERSION}`,
-          '--marker', join(APP_DIR, 'update-ok'),
-          '--log', join(APP_DIR, 'update.log'),
-        ], {
-          cwd: tmpdir(),
-          env: { ...process.env, ...RUNTIME_NODE_ENV },
-          detached: true,
-          stdio: 'ignore',
-          windowsHide: true,
-        })
-        child.unref()
-        pushLog(`核心更新：替换助手已启动（${stagedApp.version}），启动器即将退出`)
-        send(res, 200, { ok: true, version: stagedApp.version })
-        setTimeout(() => shutdown().finally(() => host.exit(0)), 200)
+      // 已经开过一次（连点两下或两个标签页同时点）：重复替换会把刚换好的目录再挪一遍
+      if (appApplyStarted) {
+        send(res, 200, { ok: true, already: true })
         return
       }
-      // 内置基线：复制到用户目录，写 pending 标记；外壳下次启动优先加载 current，
-      // 起不来（外壳里的 recoverBaseline）会删掉 current 回退到基线
-      const pending = join(APP_DIR, 'core', 'pending')
-      const version = stagedApp.version
-      const stagedDir = stagedApp.dir
-      await rm(activeCore, { recursive: true, force: true })
-      await mkdir(dirname(activeCore), { recursive: true })
-      await cp(stagedDir, activeCore, { recursive: true })
-      stagedApp = null
-      try { rmSync(stagedDir, { recursive: true, force: true }) } catch { /* 临时目录清不掉不影响 */ }
-      writeFileSync(pending, JSON.stringify({ version, at: Date.now() }))
-      pushLog(`核心更新：已复制到 ${activeCore}（${version}），重启外壳`)
-      send(res, 200, { ok: true, version })
-      // 不能直接 spawn DSH.exe：当前进程还占着单实例锁，新进程会立刻退出。
-      // 外壳的 host.relaunch 用 app.relaunch()，等本进程退出后才拉起新外壳。
-      setTimeout(() => shutdown().finally(() => {
-        if (typeof host.relaunch === 'function') host.relaunch()
-        else host.exit(0)
-      }), 200)
+      appApplyStarted = true
+      send(res, 200, await applyAppUpdate())
     } catch (error) {
+      appApplyStarted = false
       const message = error instanceof Error ? error.message : String(error)
       pushLog(`核心更新失败：${message}`)
       send(res, 400, { error: message })
@@ -5687,6 +6588,16 @@ async function handleApi(req, res, url) {
     send(res, 200, await saveLaunchPreset(body))
     return
   }
+  if (req.method === 'POST' && url.pathname === '/api/launch-log/clear') {
+    const id = String(body.id || '')
+    if (!LAUNCH_ID_RE.test(id)) {
+      send(res, 400, { error: '启动项 id 不合法' })
+      return
+    }
+    clearLaunchLog(id)
+    send(res, 200, { ok: true })
+    return
+  }
   if (req.method === 'POST' && url.pathname === '/api/launch-presets/remove') {
     send(res, 200, await removeLaunchPreset(String(body.id ?? '')))
     return
@@ -5751,6 +6662,22 @@ async function handleApi(req, res, url) {
     }
     return
   }
+  if (req.method === 'POST' && url.pathname === '/api/profile-backups/snapshot') {
+    try {
+      const profile = safeProfile(String(body.profile || ''))
+      send(res, 200, { ok: true, backup: await snapshotProfileConfig(profile, { force: body.force === true }) })
+    } catch (error) { send(res, 400, { error: error instanceof Error ? error.message : String(error) }) }
+    return
+  }
+  if (req.method === 'POST' && url.pathname === '/api/profile-backups/restore') {
+    try { send(res, 200, await restoreProfileConfig(body.profile, body.id)) }
+    catch (error) {
+      // 备份不存在给 404，参数/状态不对给 400，页面靠这两个码区分提示。
+      const message = error instanceof Error ? error.message : String(error)
+      send(res, /找不到这份备份/.test(message) ? 404 : 400, { error: message })
+    }
+    return
+  }
   if (req.method === 'POST' && url.pathname === '/api/plugins/toggle') {
     const name = String(body.name || '')
     const enabled = body.enabled !== false
@@ -6423,6 +7350,11 @@ export async function startServer() {
   LAN_TOGGLE = lanBindToggleOn(homeDir(), PROFILE_NAME)
   if (CLI_ARGS.length) pushLog(`DSH.exe 传入启动参数：${CLI_ARGS.join(' ')}`)
   const stored = await loadSettings()
+  // 跑 dsh 的 node 不是自带的 Electron 时记一笔：出问题时日志里能看出用的是哪个
+  if (IN_ELECTRON && !RUNTIME_NODE_ENV.ELECTRON_RUN_AS_NODE) {
+    const version = nodeVersionOf(RUNTIME_NODE)
+    pushLog(`跑 dsh 的 node：${RUNTIME_NODE}${version ? `（v${version}）` : ''}`)
+  }
   // 钉死端口的实例表：启动、重启都读它（页面改这张表走 /api/instance-port）
   INSTANCE_PORTS = safeInstancePorts(stored.instancePorts)
   ENVIRONMENT_PORTS = safeEnvironmentPorts(stored.environmentPorts)
@@ -6478,6 +7410,14 @@ export async function startServer() {
         }
         return
       }
+      // 启动等待页：点「启动」后由外壳 / 浏览器新开一个页面，它自己盯着实例状态，
+      // 就绪后跳到 dsh。放在静态分支之前是为了跟管理页共用 __APP_*__ 替换（语言、主题一致），
+      // 并且不让它进条件缓存——升级后第一下就得是新页面。
+      if (req.method === 'GET' && (url.pathname === '/booting' || url.pathname === '/booting/')) {
+        const page = await readFile(join(PUBLIC, 'booting.html'), 'utf8')
+        send(res, 200, page.replaceAll('__APP_LANG__', LANG).replaceAll('__APP_THEME__', THEME), 'text/html; charset=utf-8', { 'cache-control': 'no-store' })
+        return
+      }
       const file = url.pathname === '/' ? 'index.html' : url.pathname.slice(1)
       const path = join(PUBLIC, file)
       if (!path.startsWith(PUBLIC) || !existsSync(path)) {
@@ -6568,6 +7508,7 @@ export async function startServer() {
 }
 
 export async function stopAll() {
+  shuttingDown = true
   // 退出可能发生在端口探测或设置落盘期间；禁止尚未 spawn 的后台启动在收尾后复活。
   startupGeneration++
   // 退出前也要确认子进程真没了：原来杀完就 clear，taskkill 没生效时 dsh 就成了没有父进程的