@noob-stupid/dsh-plugin-console 0.5.98 → 0.5.100

package/lib/server/domain/framework-stale-restore.js

@@ -0,0 +1,215 @@
+// L1 · domain —— framework-stale-restore.js（「改名残留」能不能恢复的**判据**；0.5.99 改错）
+//
+// ── 真机现场（2026-11-02，用户实测）────────────────────────────────────────────────
+// 框架包里出现大量「**真名目录存在，但是空壳**（没有 package.json），真正内容被改名成了
+// `<name>.stale-<ver>-<ts>`」：
+//     真名 cordis\                        → 空（无 package.json）
+//     cordis.stale-4.0.4-1793185607671\   → 有内容（package.json + lib）
+//   该目录下总计 564 项，其中 276 个是 .stale-*。后果：`@deepseek-ai/cordis` 解析失败
+//   （`ERR_MODULE_NOT_FOUND`），插件的 `import` 直接起不来；把 178 个空壳从 .stale-* 恢复后成功。
+//
+// ── 旧判据的缺陷（本次修的正是它）──────────────────────────────────────────────────
+// 旧实现是「真名**缺失**（exists=false）才恢复；真名已存在就跳过」。真机现场恰恰是
+// 「真名存在但是空壳」⇒ 被跳过 ⇒ 坏状态一直留着，框架一直起不来。
+//
+// ── 新判据（三条，全部可离线断言）──────────────────────────────────────────────────
+//   ① **可用**的定义是「这个目录里有 package.json」；目录存在但没有 package.json = **空壳 = 不可用**，
+//      在判据里与"缺失"同等对待（都算"真名此刻不可用"）。
+//   ② 恢复前必须校验候选的 `package.json.name` 与真名一致（`<scope>/<real>`）——
+//      不一致一律不动，记 `failed`（防张冠李戴：把别的包改成这个名字）。
+//   ③ 三类结果分开报告：`restore`（可恢复）/ `noCandidate`（真缺内容且没有可用的 .stale-*）/
+//      `failed`（候选名字不符、候选本身不可用等）—— 调用方要能原样写进升级日志。
+//
+// 本模块只做**判据与计划**（读目录 + 读 package.json，纯读、零写盘）；改名/读回核实/回滚在
+// domain/framework-cleanup.js#restoreStaleBackups（动作层），两处调用方共用同一条路。
+import { readdirSync, readFileSync, lstatSync } from 'node:fs'
+import { basename, join } from 'node:path'
+
+/** 空壳挪开后用的后缀（**挪开不删**，保留可回溯）。 */
+const EMPTY_SUFFIX = '.empty-'
+/** 改名残留的后缀（`<real>.stale-<ver>-<ts>`）。 */
+const STALE_MARK = '.stale-'
+
+function errText(error) {
+  return String(error?.message ?? error)
+}
+
+/** 从目录名拆出真名（`cordis.stale-4.0.4-123` → `cordis`）；不是残留就返回 null。 */
+function staleRealNameOf(name) {
+  if (typeof name !== 'string') return null
+  const at = name.indexOf(STALE_MARK)
+  if (at <= 0) return null
+  return name.slice(0, at)
+}
+
+/** 真名对应的**包名**（scope 目录下是 `@scope/real`；不是 scope 目录就用真名本身）。 */
+function expectedPackageName(scopeDir, real) {
+  const scope = basename(String(scopeDir ?? ''))
+  return scope.startsWith('@') ? `${scope}/${real}` : real
+}
+
+/** 空壳挪开后的名字：`<real>.empty-<stamp>`。 */
+function emptyShellName(real, stamp) {
+  return `${real}${EMPTY_SUFFIX}${stamp}`
+}
+
+/** 读 `<dir>/package.json`：`{ ok, name, version, error }`（读不到/解析不了都如实带原因）。 */
+function packageJsonOf(dir, { readText = (p) => readFileSync(p, 'utf8') } = {}) {
+  try {
+    const raw = JSON.parse(readText(join(dir, 'package.json')))
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return { ok: false, name: null, version: null, error: 'package.json 不是对象' }
+    return { ok: true, name: typeof raw.name === 'string' ? raw.name : null, version: typeof raw.version === 'string' ? raw.version : null, error: null }
+  } catch (error) {
+    return { ok: false, name: null, version: null, error: errText(error) }
+  }
+}
+
+/** 名字里那个"被占用"的东西（空壳 / 链接 / 文件 / 真实目录）：lstat 能立住就算被占着。 */
+function isOccupied(dir, { lstat = lstatSync } = {}) {
+  try { lstat(dir); return true } catch { return false }
+}
+
+/**
+ * **可用**的判据（用户 2026-11-02 定案）：目录里有**能读出来的 package.json**。
+ * 注意它不看包名 —— 「是不是这个包」由 `packageJsonOf().name` 与真名比对，两件事分开判。
+ */
+function isUsablePackageDir(dir, deps = {}) {
+  const lstat = deps.lstat ?? lstatSync
+  let stat = null
+  try { stat = lstat(dir) } catch { return false }
+  try { if (stat?.isDirectory?.() === false && stat?.isSymbolicLink?.() !== true) return false } catch {}
+  return packageJsonOf(dir, deps).ok === true
+}
+
+/** 候选排序用的时间戳（`<real>.stale-<ver>-<ts>` 里尾巴那串数字；没有就是 0）。 */
+function candidateStamp(name) {
+  const m = String(name ?? '').match(/-(\d{6,})$/u)
+  return m === null ? 0 : Number(m[1])
+}
+
+/**
+ * 挑要恢复的那份候选：包名必须与真名一致（防张冠李戴），多份时取**时间戳最新**的那份。
+ * 返回 `{ picked, mismatch, unusable }` —— `mismatch` 是"有 package.json 但名字不对"的候选，
+ * 它们不是可以恢复的对象，但**必须**在报告里点名（否则用户不知道为什么没恢复）。
+ */
+function pickRestoreCandidate({ scopeDir, real, candidates, deps = {} } = {}) {
+  const expected = expectedPackageName(scopeDir, real)
+  const usable = []
+  const mismatch = []
+  const unusable = []
+  for (const name of Array.isArray(candidates) ? candidates : []) {
+    const info = packageJsonOf(join(scopeDir, name), deps)
+    if (info.ok !== true) { unusable.push({ name, error: info.error }); continue }
+    if (info.name !== expected) { mismatch.push({ name, nameInPkg: info.name, expected }); continue }
+    usable.push({ name, version: info.version, stamp: candidateStamp(name) })
+  }
+  usable.sort((a, b) => (b.stamp - a.stamp) || (a.name < b.name ? 1 : a.name > b.name ? -1 : 0))
+  return { picked: usable.length > 0 ? usable[0] : null, usableCount: usable.length, mismatch, unusable }
+}
+
+/**
+ * 计划一次「改名残留修复」（**纯读，零写盘**）。返回每个真名一项：
+ *   `{ real, action: 'restore'|'skip'|'noCandidate'|'failed', staleName, reason, detail,
+ *      realOccupied, realUsable, candidates, mismatch, unusable }`
+ *
+ * 分类规则（顺序即优先级）：
+ *   ① 真名**可用** ⇒ `skip`（reason `real-name-exists`）—— 健康树上一个字节都不动（幂等）；
+ *   ② 真名不可用（缺失 **或空壳**）+ 有可用候选 ⇒ `restore`；
+ *   ③ 真名不可用 + 候选里**有名字不符的** ⇒ `failed`（reason `name-mismatch`，一个都不动）；
+ *   ④ 真名不可用 + 候选都不可用（没 package.json）或压根没有候选 ⇒ `noCandidate`。
+ */
+function planStaleRestore({ scopeDir, deps = {} } = {}) {
+  const empty = { ok: false, items: [], problem: null }
+  if (typeof scopeDir !== 'string' || scopeDir === '') return { ...empty, problem: '没有给 scopeDir' }
+  let entries = []
+  try { entries = deps.readdir ? deps.readdir(scopeDir) : readdirSync(scopeDir, { withFileTypes: true }) } catch (error) {
+    const missing = error?.code === 'ENOENT'
+    return { ...empty, ok: missing, problem: missing ? null : '列不出目录：' + errText(error) }
+  }
+  const byReal = new Map()
+  for (const entry of entries) {
+    const name = typeof entry === 'string' ? entry : entry?.name
+    const isDir = typeof entry === 'string' ? true : entry?.isDirectory?.() === true
+    if (typeof name !== 'string' || !isDir) continue
+    const real = staleRealNameOf(name)
+    if (real === null || real === '') continue
+    if (!byReal.has(real)) byReal.set(real, [])
+    byReal.get(real).push(name)
+  }
+  // 真名一侧也要扫：**空壳本身没有 .stale-* 兄弟**时（真缺内容）同样要报 `noCandidate`，
+  // 否则升级日志里那批"真名在、内容没了"的行一个字都不会出现（真机就是这样被漏掉的）。
+  const realNames = new Set()
+  for (const entry of entries) {
+    const name = typeof entry === 'string' ? entry : entry?.name
+    const isDir = typeof entry === 'string' ? true : entry?.isDirectory?.() === true
+    if (typeof name !== 'string' || !isDir) continue
+    if (name.includes(STALE_MARK) || name.includes(EMPTY_SUFFIX)) continue // 残留/挪开的空壳不是真名
+    realNames.add(name)
+  }
+  for (const real of realNames) if (!byReal.has(real)) byReal.set(real, [])
+  const items = []
+  for (const real of [...byReal.keys()].sort()) {
+    const candidates = byReal.get(real).slice().sort()
+    const target = join(scopeDir, real)
+    const realOccupied = isOccupied(target, deps)
+    const realUsable = realOccupied && isUsablePackageDir(target, deps)
+    const base = { real, staleName: null, realOccupied, realUsable, candidates }
+    if (realUsable) {
+      // 健康行：有候选也只是"旁边留着一份旧残留"，不动（幂等：健康树上零动作、零报告项）
+      if (candidates.length === 0) continue
+      items.push({ ...base, action: 'skip', reason: 'real-name-exists', detail: `真名目录里已有 package.json —— 不动旁边那份 ${candidates[0]}` })
+      continue
+    }
+    const pick = pickRestoreCandidate({ scopeDir, real, candidates, deps })
+    if (pick.picked !== null) {
+      items.push({
+        ...base,
+        action: 'restore',
+        staleName: pick.picked.name,
+        reason: realOccupied ? 'real-name-unusable' : 'real-name-missing',
+        detail: realOccupied
+          ? `真名目录存在但没有可读的 package.json（空壳）—— 用 ${pick.picked.name} 恢复，空壳挪成 ${EMPTY_SUFFIX}<ts>`
+          : `真名缺失 —— 用 ${pick.picked.name} 恢复`,
+        mismatch: pick.mismatch,
+        unusable: pick.unusable,
+      })
+      continue
+    }
+    if (pick.mismatch.length > 0) {
+      items.push({
+        ...base,
+        action: 'failed',
+        reason: 'name-mismatch',
+        detail: `候选的 package.json.name 与真名不符（应为 ${expectedPackageName(scopeDir, real)}）：${pick.mismatch.map((m) => `${m.name}=${String(m.nameInPkg)}`).join('、')} —— 一个都不动`,
+        mismatch: pick.mismatch,
+        unusable: pick.unusable,
+      })
+      continue
+    }
+    items.push({
+      ...base,
+      action: 'noCandidate',
+      reason: 'no-usable-stale',
+      detail: pick.unusable.length > 0
+        ? `真名不可用，且 ${pick.unusable.length} 份 .stale-* 都没有可读的 package.json（不可作为候选）`
+        : '真名不可用，且没有任何 .stale-* 候选（框架真缺内容，需要重装）',
+      mismatch: pick.mismatch,
+      unusable: pick.unusable,
+    })
+  }
+  return { ok: true, items, problem: null }
+}
+
+export {
+  EMPTY_SUFFIX,
+  STALE_MARK,
+  candidateStamp,
+  emptyShellName,
+  expectedPackageName,
+  isOccupied,
+  isUsablePackageDir,
+  packageJsonOf,
+  pickRestoreCandidate,
+  planStaleRestore,
+  staleRealNameOf,
+}

package/lib/server/domain/patch.js

@@ -1,20 +1,70 @@
 // L1 · domain —— patch.js（由 Step 2 从 lib/index.js 原样切出，只搬移未改逻辑）
 // 分层分组：L1 · domain（边界由 tests/test-architecture-guard.mjs 断言）
 
-import { readFile, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { frameworkBases, isFrameworkModuleName } from '../infra/framework-root.js'
 import { queuedWrite } from '../infra/fsx.js'
 import { escapeRegExp } from '../infra/mask.js'
 import { makePackageResolver } from '../infra/package-resolve.js'
 
-/** 读取补丁文件并扫描：停用块与 insert 行的 id。 */
-async function readPatchState(patchPath) {
+/**
+ * 写补丁前先建父目录（issue #27 的**派生缺口**，0.5.99 加法）。
+ *
+ * 为什么必须补：补丁路径是从 loader 的 `cordis:include` 条目推导出来的（见 infra/paths.js），
+ * 推导一旦指向一个**还不存在**的 profile 目录，本文件里原先 7 处 `writeFile` 全是**裸写** ——
+ * 父目录不在就 ENOENT。表现分两种，都很难查：
+ *   ① 调用方 catch 了异常 ⇒ 面板显示"已启用"，文件里却一个字都没有（假成功）；
+ *   ② 异常冒到接口 ⇒ 500，但真正的原因（profile 目录不存在）没人说出来。
+ * ⇒ 现在写前 `mkdir(dirname(p), { recursive: true })`：只把"**本来该成功却失败**"的那条路补上；
+ *   原本就写得成功的路径一个字节都不变（目录已存在时 recursive mkdir 是幂等 no-op）。
+ *
+ * mkdir 自己失败时**原样抛出**（绝不吞成"写成功"）：要么调用方 catch，要么接口如实报错 ——
+ * 但绝不能出现"目录没建出来、函数却正常返回"。
+ * `deps.mkdir` 只是给测试用的注入缝（模拟 EPERM），生产默认就是 node:fs/promises#mkdir。
+ */
+async function ensurePatchParentDir(patchPath, deps = {}) {
+  const make = typeof deps.mkdir === 'function' ? deps.mkdir : mkdir
+  await make(dirname(patchPath), { recursive: true })
+}
+
+/**
+ * 父目录是不是**真的不存在**（`readPatchState` 区分"两种缺失"的判据）。
+ *
+ * 只在 readFile 已经 ENOENT 之后才被调用 —— 文件正常读取时一次 syscall 都不多。
+ * 判据**保守**：只有确证（ENOENT / ENOTDIR）才说"父目录不存在"；
+ * EPERM/EACCES 这类"读不到但不一定没有"的情况一律返回 false（宁可不说，不谎报路径错）。
+ */
+async function parentDirMissing(patchPath, statFn) {
+  try {
+    await statFn(dirname(patchPath))
+    return false
+  } catch (error) {
+    return error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+  }
+}
+
+/** 读取补丁文件并扫描：停用块与 insert 行的 id。
+ *
+ *  ★ 0.5.99 加法：「文件不存在」过去被 ENOENT 一起吞成"空补丁"，于是**路径推导错了**与
+ *    **文件真的是空的**在返回值上完全一样 —— issue #27 那个 bug（补丁全写到废弃的 web profile、
+ *    在用的 desktop 静默收不到）正是靠这条配合才藏了三周。
+ *    现在区分两种缺失，但**一个字都不改既有语义**：
+ *      ① 父目录在、文件还没建（新 profile 第一次写补丁，**正常**）⇒ 空补丁，`parentMissing: false`；
+ *      ② 父目录也不在（**路径推导错了**）⇒ 仍然返回空补丁（不抛错、既有调用方行为不变），
+ *         只多带 `parentMissing: true` + `missingReason: 'parent-missing'`，让上层看得见。
+ *    健康环境下的返回值只比过去多**一个**字段（`parentMissing`）——`missingReason` 仅在缺失时出现。
+ *  `deps.stat` 是给测试用的注入缝；生产默认 node:fs/promises#stat。公开调用面仍是 `readPatchState(path)`。
+ */
+async function readPatchState(patchPath, deps = {}) {
+  const statFn = typeof deps.stat === 'function' ? deps.stat : stat
   let text = ''
+  let parentMissing = false
   try {
     text = await readFile(patchPath, 'utf8')
   } catch (error) {
     if (error.code !== 'ENOENT') throw error
+    parentMissing = await parentDirMissing(patchPath, statFn)
   }
   const disables = []
   const forced = []
@@ -39,7 +89,11 @@ async function readPatchState(patchPath) {
     if (/^ {2}disabled: true\s*$/u.test(next)) disables.push(disableRow[1])
     else if (/^ {2}disabled: false\s*$/u.test(next)) forced.push(disableRow[1])
   }
-  return { disables, forced, inserts, text }
+  // ★ 只增字段：健康环境下 = 既有 4 个字段 + `parentMissing: false`；
+  //   父目录缺失时才多一个 `missingReason`（见上面的注释）。
+  const state = { disables, forced, inserts, text, parentMissing }
+  if (parentMissing) state.missingReason = 'parent-missing'
+  return state
 }
 
 /** 停用：追加 disabled:true 块（已存在则不动）。 */
@@ -49,6 +103,7 @@ async function disableEntry(patchPath, id) {
     if (disables.includes(id)) return { changed: false }
     const clean = sanitizePatchText(text)
     const next = clean.length === 0 || clean.endsWith('\n') ? clean : `${clean}\n`
+    await ensurePatchParentDir(patchPath)
     await writeFile(patchPath, `${next}${disableBlock(id)}`, 'utf8')
     return { changed: true }
   })
@@ -60,12 +115,14 @@ async function enableEntry(patchPath, id) {
     const { disables, forced, text } = await readPatchState(patchPath)
     const blockRe = new RegExp(`^- id: ${escapeRegExp(id)}\\r?\\n  disabled: true\\r?\\n`, 'mu')
     if (blockRe.test(text)) {
+      await ensurePatchParentDir(patchPath)
       await writeFile(patchPath, sanitizePatchText(text.replace(blockRe, '')), 'utf8')
       return { changed: true }
     }
     if (forced.includes(id)) return { changed: false }
     const clean = sanitizePatchText(text)
     const next = clean.length === 0 || clean.endsWith('\n') ? clean : `${clean}\n`
+    await ensurePatchParentDir(patchPath)
     await writeFile(patchPath, `${next}- id: ${id}\n  disabled: false\n`, 'utf8')
     return { changed: true }
   })
@@ -110,6 +167,7 @@ async function appendInsert(patchPath, entryId, packageName) {
     const clean = sanitizePatchText(text)
     const next = clean.length === 0 || clean.endsWith('\n') ? clean : `${clean}\n`
     const block = `- insert:\n    - id: ${entryId}\n      name: '${packageName}'\n`
+    await ensurePatchParentDir(patchPath)
     await writeFile(patchPath, `${next}${block}`, 'utf8')
     return { changed: true }
   })
@@ -123,7 +181,10 @@ async function removeInsertRow(patchPath, rowId) {
     let next = text.replace(blockRe, '')
     const overrideRe = new RegExp(`^- id: ${escapeRegExp(rowId)}\\s*\\r?\\n {2}disabled: (true|false)\\s*\\r?\\n`, 'mu')
     next = next.replace(overrideRe, '')
-    if (next !== text) await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    if (next !== text) {
+      await ensurePatchParentDir(patchPath)
+      await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    }
   })
 }
 
@@ -133,7 +194,10 @@ function removeDisableBlock(patchPath, rowId) {
     const { text } = await readPatchState(patchPath)
     const overrideRe = new RegExp(`^- id: ${escapeRegExp(rowId)}\\s*\\r?\\n {2}disabled: (true|false)\\s*\\r?\\n`, 'mu')
     const next = text.replace(overrideRe, '')
-    if (next !== text) await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    if (next !== text) {
+      await ensurePatchParentDir(patchPath)
+      await writeFile(patchPath, sanitizePatchText(next), 'utf8')
+    }
   })
 }
 
@@ -212,7 +276,12 @@ function parseInsertNames(text) {
 async function healPatchSafety(patchPath, deps = {}) {
   const profileDir = dirname(patchPath)
   const readText = deps.readText ?? ((p) => readFile(p, 'utf8'))
-  const writeText = deps.writeText ?? ((p, data) => writeFile(p, data, 'utf8'))
+  // 默认写盘实现也走「先建父目录」：注入缝只是把 writeFile 换成别的写盘手段，
+  // 不该因此丢掉父目录保证（过去注入 readText/writeText 的调用方拿到的行为不变）。
+  const writeText = deps.writeText ?? (async (p, data) => {
+    await ensurePatchParentDir(p, deps)
+    await writeFile(p, data, 'utf8')
+  })
   const { text } = await readPatchState(patchPath)
   const healed = []
   const autoDisabled = []

package/lib/server/infra/fw-root-detect.js

@@ -103,28 +103,146 @@ function fwRootFromNpxCache({ env = process.env, home = homedir(), deps = {} } =
   return hits[0]
 }
 
-/** 扫 `<dshHome>/profiles/**` 与各类 node_modules，找一棵像框架树的。 */
+/** 路径比较用的归一键（只用于"是不是同一个目录"的去重/比对，不用于任何业务判据）。 */
+function dirKey(dir) {
+  if (typeof dir !== 'string' || dir === '') return ''
+  let out = dir
+  try { out = resolve(dir) } catch {}
+  out = out.replace(/[\\/]+$/u, '')
+  // Windows 路径大小写不敏感（`C:\Users` 与 `c:\users` 是同一个目录）—— 其他平台保持原样
+  return process.platform === 'win32' ? out.toLowerCase() : out
+}
+
+/** 两个路径是不是同一个目录（同上：仅用于比对）。 */
+function sameDir(a, b) {
+  const ka = dirKey(a)
+  return ka !== '' && ka === dirKey(b)
+}
+
+/**
+ * 当前生效的补丁落在哪个 profile 目录？推导不出来返回 `null`（**绝不猜、也绝不报错**）。
+ *
+ * 为什么要它（0.5.99 加法，issue #27 的同一批现场）：`<dshHome>/profiles/` 下**每个**子目录都会
+ * 变成框架树候选（包括早已废弃的那个 profile —— 真机上 desktop 在用、web 是 issue #27 的受害者）。
+ * 废弃 profile 里往往还留着旧框架的残影，`looksLikeFwRoot()` **分不出死活** ⇒ 谁先试谁被选中。
+ * ⇒ 用"当前补丁所在的 profile"给候选排个序：同一 profile 的先试（剩下的照旧）。
+ *
+ * 取值顺序（都拿不到就返回 null，排序优化自动跳过）：
+ *   ① `deps.derivePatchPath()`（调用方注入，一般就是 infra/paths.js#findPatchPath 的包装）
+ *   ② `deps.patchPath`（补丁文件全路径）/ `deps.profileDir`（profile 目录）
+ *   ③ `DSH_PROFILE_DIR`（桌面端/CLI 显式设置，最可信 —— 与 paths.js#defaultPatchPath 同源）
+ *   ④ `DSH_PROFILE`（只给名字时拼 `profiles/<name>`）
+ * ★ 这里刻意**不**去调 `defaultPatchPath()`：它读的是进程级 `process.env` 与真实 home，
+ *   在注入了 `env`/`home` 的调用（测试、预检脚本）里会串味成"另一台机器的 profile"。
+ */
+function activeProfileDirOf({ env = process.env, dshHome, deps = {} } = {}) {
+  const nonEmpty = (v) => typeof v === 'string' && v.trim() !== '' ? v.trim() : null
+  if (typeof deps.derivePatchPath === 'function') {
+    try {
+      const p = nonEmpty(deps.derivePatchPath())
+      if (p !== null) return dirname(resolve(p))
+    } catch {}
+  }
+  const fromPatchPath = nonEmpty(deps.patchPath)
+  if (fromPatchPath !== null) return dirname(resolve(fromPatchPath))
+  const fromProfileDir = nonEmpty(deps.profileDir)
+  if (fromProfileDir !== null) return resolve(fromProfileDir)
+  const fromEnvDir = nonEmpty(env.DSH_PROFILE_DIR)
+  if (fromEnvDir !== null) return resolve(fromEnvDir)
+  const fromEnvName = nonEmpty(env.DSH_PROFILE)
+  if (fromEnvName !== null) return join(dshHome, 'profiles', fromEnvName)
+  return null
+}
+
+/**
+ * 给 `profiles/<name>/node_modules` 这批候选**排序**（只排，不删 —— 判据仍是既有的 looksLikeFwRoot）。
+ *
+ * 优先级：
+ *   0 与当前生效补丁同 profile（"活着的那棵树"）→ 先试；
+ *   1 像框架树（既有判据 `looksLikeFwRoot`）→ 次之；
+ *   2 其余 → 最后。
+ * 同档内保持**传入顺序**（= readdir 原顺序）⇒ 结果稳定，不随目录名排序漂移。
+ *
+ * ★ 排序器只影响**先试谁**，绝不决定"能不能选到"：`fwRootFromDshHome()` 末尾仍会按**旧顺序**
+ *   把每个候选再兜一遍（见那里的 `legacy` 循环），所以任何原本能选到的树都还能选到。
+ */
+function rankProfileCandidates(candidates, { activeProfileDir = null, looksLike = null } = {}) {
+  const list = Array.isArray(candidates) ? candidates.filter((d) => typeof d === 'string' && d !== '') : []
+  const isTree = typeof looksLike === 'function' ? looksLike : (dir) => looksLikeFwRoot(dir)
+  const tierOf = (dir) => {
+    if (activeProfileDir !== null && sameDir(dirname(dir), activeProfileDir)) return 0
+    try { if (isTree(dir)) return 1 } catch {}
+    return 2
+  }
+  return list
+    .map((dir, index) => ({ dir, index, tier: tierOf(dir) }))
+    .sort((a, b) => (a.tier - b.tier) || (a.index - b.index))
+    .map((x) => x.dir)
+}
+
+/** 扫 `<dshHome>/profiles/**` 与各类 node_modules，找一棵像框架树的。
+ *
+ *  ★ 0.5.99 加法（issue #27 的同一批现场）：`profiles/<name>/node_modules` 这批候选**不再按
+ *    readdir 顺序盲试**，而是先试"当前生效补丁同 profile"的那棵、再试像框架树的，其余垫底
+ *    （见 `rankProfileCandidates`）。前三项（DSH_PROFILE_DIR / DSH_PROFILE / profiles/node_modules）
+ *    的顺序与判据**一个字都没动**。
+ *    ⚠ 兜底：排序之后仍按**旧顺序**把每个候选再排进队列尾部（同一个循环里，已试过的自动跳过），
+ *    所以"原本能选到的那棵树"绝不会因为新排序而选不到 —— 这是本改动最重要的不变量。
+ */
 function fwRootFromDshHome({ env = process.env, home = homedir(), deps = {} } = {}) {
   const exists = deps.exists ?? existsSync
   const readdir = deps.readdir ?? ((p) => readdirSync(p))
   const dshHome = (typeof env.DSH_HOME === 'string' && env.DSH_HOME.trim() !== '') ? env.DSH_HOME.trim() : join(home, '.dsh')
 
-  const cands = []
-  // ① 显式 profile 目录（桌面端/CLI 都会设 DSH_PROFILE_DIR）
-  if (typeof env.DSH_PROFILE_DIR === 'string' && env.DSH_PROFILE_DIR.trim() !== '') cands.push(env.DSH_PROFILE_DIR.trim())
+  // 同一次调用里每个候选只判定一次（排序用一次、挑选用一次，别重复扫盘）
+  const looksCache = new Map()
+  const looks = (dir) => {
+    if (!looksCache.has(dir)) looksCache.set(dir, looksLikeFwRoot(dir, { deps }))
+    return looksCache.get(dir)
+  }
+
+  const head = []
+  // ① 显式 profile 目录（桌面端/CLI 都会设 DSH_PROFILE_DIR）—— 既有最高优先级，位置不动
+  if (typeof env.DSH_PROFILE_DIR === 'string' && env.DSH_PROFILE_DIR.trim() !== '') head.push(env.DSH_PROFILE_DIR.trim())
   // ② 按 profile 名
-  if (typeof env.DSH_PROFILE === 'string' && env.DSH_PROFILE.trim() !== '') cands.push(join(dshHome, 'profiles', env.DSH_PROFILE.trim()))
-  // ③ 共享投影层与各 profile
-  cands.push(join(dshHome, 'profiles', 'node_modules'))
+  if (typeof env.DSH_PROFILE === 'string' && env.DSH_PROFILE.trim() !== '') head.push(join(dshHome, 'profiles', env.DSH_PROFILE.trim()))
+  // ③ 共享投影层（各 profile 共用）
+  head.push(join(dshHome, 'profiles', 'node_modules'))
+
+  // ④ 各 profile 自己的 node_modules（readdir 原顺序 = 旧顺序，兜底要用它）
+  const legacy = []
   try {
     for (const d of readdir(join(dshHome, 'profiles'))) {
       if (d === 'node_modules') continue
-      cands.push(join(dshHome, 'profiles', d, 'node_modules'))
+      legacy.push(join(dshHome, 'profiles', d, 'node_modules'))
     }
   } catch {}
 
-  for (const dir of cands) {
-    if (!looksLikeFwRoot(dir, { deps })) continue
+  // 排序（可注入；排序器抛错/返回怪东西时**原样退回旧顺序**，绝不因此少试一棵树）
+  let ranked = legacy
+  if (legacy.length > 0) {
+    const rank = typeof deps.rankCandidates === 'function' ? deps.rankCandidates : rankProfileCandidates
+    try {
+      const out = rank(legacy, { activeProfileDir: activeProfileDirOf({ env, dshHome, deps }), looksLike: looks, deps })
+      if (Array.isArray(out)) ranked = out.filter((d) => typeof d === 'string' && legacy.includes(d))
+    } catch { ranked = legacy }
+  }
+
+  // 一个队列，三段顺序：既有前三项 → 排过序的 profile 候选 → **旧顺序兜底**
+  const ordered = []
+  const seen = new Set()
+  const enqueue = (dir) => {
+    const key = dirKey(dir)
+    if (key === '' || seen.has(key)) return
+    seen.add(key)
+    ordered.push(dir)
+  }
+  for (const dir of head) enqueue(dir)
+  for (const dir of ranked) enqueue(dir)
+  for (const dir of legacy) enqueue(dir)
+
+  for (const dir of ordered) {
+    if (!looks(dir)) continue
     return { fwRoot: dir, via: 'dsh-home' }
   }
   return null
@@ -206,4 +324,4 @@ function detectFrameworkRoot({ pluginDir = null, entryHint = null, env = process
   return { fwRoot: null, via: null, tried }
 }
 
-export { detectFrameworkRoot, fwRootFromBase, fwRootFromDshHome, fwRootFromNpxCache, looksLikeFwRoot, realRootOf }
+export { detectFrameworkRoot, fwRootFromBase, fwRootFromDshHome, fwRootFromNpxCache, looksLikeFwRoot, realRootOf, rankProfileCandidates, activeProfileDirOf }

package/lib/server/infra/paths.js

@@ -1,7 +1,7 @@
 // L0 · infra（paths.js）—— 分层 Step 从 lib/index.js 搬出，只搬移未改逻辑
 // 分层分组：L0 · infra（边界由 tests/test-architecture-guard.mjs 断言）
 
-import { readFileSync, existsSync, statSync } from 'node:fs'
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import { homedir } from 'node:os'
 import { fileURLToPath } from 'node:url'
@@ -12,10 +12,39 @@ function dshHome() {
   return process.env.DSH_HOME?.trim() || join(homedir(), '.dsh')
 }
 
-/** 默认 profile 用户补丁层路径（无 include 条目可推导时的兜底）。 */
+/**
+ * 默认 profile 用户补丁层路径（无 include 条目可推导时的兜底）。
+ *
+ * 硬编码 `profiles/web` 是真实事故（issue #27）：桌面端机器上 `cordis.yml` 里没有
+ * `cordis:include` 条目时兜底必然生效，于是所有补丁写入都落到早已废弃的 `web` profile，
+ * 正在用的 `desktop` 静默收不到——开关插件、改禁用都没反应，而且不报错。
+ *
+ * 现在按可信度排候选，绝不写死 profile 名：
+ *   ① DSH_PROFILE_DIR（桌面端/CLI 会显式设置，最可信）
+ *   ② DSH_PROFILE（只给名字时拼路径）
+ *   ③ `profiles/` 下真实存在补丁文件的目录（desktop 优先，其余按名字排序保证确定性）
+ */
 function defaultPatchPath() {
   const home = dshHome()
-  return join(home, 'profiles', 'web', 'cordis.patch.yml')
+  const explicitDir = process.env.DSH_PROFILE_DIR?.trim()
+  if (explicitDir !== undefined && explicitDir !== '') return join(explicitDir, 'cordis.patch.yml')
+  const candidates = []
+  const profileName = process.env.DSH_PROFILE?.trim()
+  if (profileName !== undefined && profileName !== '') candidates.push(join(home, 'profiles', profileName, 'cordis.patch.yml'))
+  candidates.push(join(home, 'profiles', 'desktop', 'cordis.patch.yml'))
+  try {
+    const base = join(home, 'profiles')
+    for (const name of readdirSync(base).sort()) {
+      if (name === 'node_modules' || name === 'desktop') continue
+      candidates.push(join(base, name, 'cordis.patch.yml'))
+    }
+  } catch {
+    // profiles 读不到就只用已知候选
+  }
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate
+  }
+  return candidates[0]
 }
 
 /** 从 loader 树推导 profile 的 cordis.patch.yml 绝对路径。 */