dsh-paoding 0.4.6 → 0.4.8

package/plugins/paoding-config-ui/stats-core.mjs

@@ -29,6 +29,16 @@
  * 志带上一轮化身的历史，那段 turn 天然平衡；继承切点打在轮次边界（实测 73 处
  * mid 位 end-seed 前一事件以 turn/end 为主），owned 段计数不受污染。时长与
  * 窗口过滤同样只用 owned 段，防跨化身膨胀。
+ *
+ * ── mtime 预过滤与缺省回落 ────────────────────────────────────────────────
+ * 开读句柄前先看日志文件 mtime：事件产生即落盘，文件末次写入（mtime）加松弛
+ * 量仍早于窗口起点 ⇒ 文件里不可能有窗口内事件，聚合窗口过滤本就会剔除，直接
+ * 跳过不开句柄——大库冷读从「全库逐个解压」降到「只读窗口内还活跃过的文件」。
+ * 预过滤条目不进摘要缓存（mtime 日后前移时本检查自然放行重开；缓存留 null 反
+ * 要额外对账）。project 缺省 = cwd 换算 slug，而 desktop 等宿主 profile 的
+ * 进程 cwd 停在 profile 目录、换算出的 slug 恒无会话，面板于是恒见「暂无委
+ * 派记录」——故缺省扫描零委派记录时自动回落一轮全项目聚合，响应 project 标
+ * 'all'（客户端标题加「全部项目」角标）；显式传 project（含 'all'）不回落。
  */
 
 import { readdirSync, statSync } from 'node:fs'
@@ -41,6 +51,9 @@ import { ROLE_PRESET_ID_PREFIX } from '../../tools/lib/compose.mjs'
 export const STATS_DEFAULT_DAYS = 30
 export const STATS_MAX_DAYS = 365
 
+/** mtime 预过滤松弛量（1h）：挡时钟偏斜与落盘延迟——宁可多开几个句柄，不误跳。 */
+const MTIME_SLACK_MS = 60 * 60 * 1000
+
 // ── 参数清洗 ─────────────────────────────────────────────────────────────────
 
 /** days 清洗：parseInt 夹取 [1, 365]；NaN / 负数 / 0 回落缺省或夹到下限。 */
@@ -140,6 +153,15 @@ function listSessionIds(sessionsRoot, slug) {
   }
 }
 
+/** 列会话根下全部项目目录名（'all' 的枚举口径）。根缺失 / 不可读 → 空数组。 */
+function allProjectSlugs(sessionsRoot) {
+  try {
+    return readdirSync(sessionsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+  } catch {
+    return []
+  }
+}
+
 // ── 冷读摘要 ─────────────────────────────────────────────────────────────────
 
 /** 一个会话的抽摘要结果（JSON-safe 纯数据，可进缓存）。 */
@@ -279,35 +301,19 @@ async function mapLimited(items, limit, worker) {
 
 const summaryCache = new Map()
 
+// ── 扫描 + 聚合（一轮冷读，缺省 / 回落两路共用）─────────────────────────────
+
 /**
- * 委派效果统计主入口。ctx 缺 sessionPersistence（reflect 软探测，绝不进
- * inject——硬注入会让缺服务的老宿主挂载即炸）→ { ok:false,
- * reason:'persistence-unavailable' }，面板据此整卡不渲染。project 非法抛
- * 422（外层 catch 统一回 { error } 信封）。
+ * 一轮「枚举 → 冷读 → 聚合」。slugs 是待扫的项目目录名列表（单 slug 或 'all'
+ * 枚举皆可）；collectDelegationStats 的「缺省 slug 一轮」与「回落全项目一轮」
+ * 都走这里，两轮的 sessionsScanned / skipped 口径由此保持一致。worker 里：
+ * 先 mtime 预过滤（见文件头）——事件产生即落盘，文件末次写入时刻即 mtime，
+ * mtime+slack 仍早于窗口起点 ⇒ 文件内一切事件都在窗口外，聚合窗口过滤本就会
+ * 剔除，直接返回 null 摘要不开读句柄；预过滤条目不进缓存（mtime 日后前移时
+ * 本检查自然放行重开）。null 摘要不进聚合、不计 skipped（那是读错误的计数），
+ * 但照常计入 sessionsScanned（目录确实扫过）。
  */
-export async function collectDelegationStats(ctx, { project, days } = {}) {
-  const persistence = reflectService(ctx, 'sessionPersistence')
-  if (!persistence) return { ok: false, reason: 'persistence-unavailable' }
-
-  const windowDays = sanitizeStatsDays(days)
-  const sessionsRoot = path.join(resolveDshHome(), 'sessions')
-  const slug = sanitizeProjectSlug(project !== undefined && project !== null && project !== '' ? project : currentProjectSlug(), sessionsRoot)
-  if (slug === null) {
-    const err = new Error(`project 参数不合法（仅允许 [A-Za-z0-9._-]，或 all）: ${String(project).slice(0, 64)}`)
-    err.statusCode = 422
-    throw err
-  }
-
-  // 枚举：all = 列会话根下全部项目目录；单 slug 只列该目录。
-  const slugs = slug === 'all'
-    ? (() => {
-        try {
-          return readdirSync(sessionsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
-        } catch {
-          return []
-        }
-      })()
-    : [slug]
+async function scanAndAggregate(sessionsRoot, slugs, windowDays, nowMs, persistence) {
   const targets = []
   for (const dir of slugs) {
     for (const id of listSessionIds(sessionsRoot, dir)) {
@@ -315,12 +321,14 @@ export async function collectDelegationStats(ctx, { project, days } = {}) {
     }
   }
 
-  const nowMs = Date.now()
   const reads = await mapLimited(targets, 4, async ({ slug: dir, id }) => {
     const sessionDir = path.join(sessionsRoot, dir, id)
     const file = currentSessionFile(sessionDir)
     if (file === null) throw new Error('no session log file')
     const st = statSync(path.join(sessionDir, file)) // stat 失败 → 跳过计数
+    if (st.mtimeMs + MTIME_SLACK_MS < nowMs - windowDays * 86400000) {
+      return { id, summary: null }
+    }
     const cacheKey = dir + '\u0000' + id
     const hit = summaryCache.get(cacheKey)
     if (hit && hit.file === file && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
@@ -334,20 +342,71 @@ export async function collectDelegationStats(ctx, { project, days } = {}) {
   let skipped = 0
   const summaries = []
   for (const r of reads) {
-    if (r.ok) summaries.push(r.value.summary)
-    else skipped++
+    if (!r.ok) {
+      skipped++ // 只有 open/read 真失败才计；预过滤出局不是错
+      continue
+    }
+    if (r.value.summary !== null) summaries.push(r.value.summary)
   }
   const { roles, delegatedSessions } = aggregateRoles(summaries, windowDays, nowMs)
+  return { roles, delegatedSessions, sessionsScanned: targets.length, skipped }
+}
+
+/** 单一响应形状（ok:true 信封）：两路扫描的结果都从这里出，字段恒齐。 */
+function statsEnvelope(project, result, windowDays, nowMs) {
   return {
     ok: true,
-    project: slug,
+    project,
     windowDays,
     generatedAt: new Date(nowMs).toISOString(),
-    roles,
-    sessionsScanned: targets.length,
-    delegatedSessions,
-    skipped,
+    roles: result.roles,
+    sessionsScanned: result.sessionsScanned,
+    delegatedSessions: result.delegatedSessions,
+    skipped: result.skipped,
+  }
+}
+
+/**
+ * 委派效果统计主入口。ctx 缺 sessionPersistence（reflect 软探测，绝不进
+ * inject——硬注入会让缺服务的老宿主挂载即炸）→ { ok:false,
+ * reason:'persistence-unavailable' }，面板据此整卡不渲染。project 非法抛
+ * 422（外层 catch 统一回 { error } 信封）。
+ *
+ * project 口径：显式传参（非空字符串，含 'all'）按传参扫，绝不回落；缺省 =
+ * cwd 换算的当前面板项目，该 slug 一轮扫完 delegatedSessions=0 时自动回落
+ * 一轮全项目聚合（响应 project 标 'all'；会话根缺失时枚举为空 → 空 roles
+ * 仍 ok:true，不 422 不 5xx）。
+ */
+export async function collectDelegationStats(ctx, { project, days } = {}) {
+  const persistence = reflectService(ctx, 'sessionPersistence')
+  if (!persistence) return { ok: false, reason: 'persistence-unavailable' }
+
+  const windowDays = sanitizeStatsDays(days)
+  const sessionsRoot = path.join(resolveDshHome(), 'sessions')
+  const explicit = project !== undefined && project !== null && project !== ''
+  const slug = sanitizeProjectSlug(explicit ? project : currentProjectSlug(), sessionsRoot)
+  if (slug === null) {
+    const err = new Error(`project 参数不合法（仅允许 [A-Za-z0-9._-]，或 all）: ${String(project).slice(0, 64)}`)
+    err.statusCode = 422
+    throw err
+  }
+
+  const nowMs = Date.now()
+  const result = await scanAndAggregate(
+    sessionsRoot,
+    slug === 'all' ? allProjectSlugs(sessionsRoot) : [slug],
+    windowDays,
+    nowMs,
+    persistence,
+  )
+
+  // 缺省回落：cwd slug 恒空的宿主 profile（desktop 进程 cwd 停在 profile 目录）
+  // 靠这一步救回面板——零委派记录才回落，显式 project 永不回落。
+  if (!explicit && slug !== 'all' && result.delegatedSessions === 0) {
+    const all = await scanAndAggregate(sessionsRoot, allProjectSlugs(sessionsRoot), windowDays, nowMs, persistence)
+    return statsEnvelope('all', all, windowDays, nowMs)
   }
+  return statsEnvelope(slug, result, windowDays, nowMs)
 }
 
 /** reflect 软探测（与 persistenceAvailableOf 同款口径，任何异常按缺失处理）。 */

package/tools/lib/config.mjs

@@ -1,6 +1,7 @@
 /**
  * dsh-paoding.config.yml 键规范化与读写：main_agent_display_name /
- * roles.<toolName>.name /
+ * patch_layer（声明行落盘层 'home' | 'profile'，缺省自动判定，非法值 warn 回
+ * 未设置）/ roles.<toolName>.name /
  * roles.<toolName>.model / roles.<toolName>.provider（角色专用模型，生成层映射到
  * dsh-tool-subagent 的 agentOptions）/ roles.<toolName>.start_mode（角色启动方式，
  * 生成层把内置委派块的块级 provider 行改写为 fork，'fresh' | 'fork'）/
@@ -212,11 +213,26 @@ export function normalizeConfig(data) {
   }
   return {
     profile: typeof data.profile === 'string' && data.profile !== '' ? data.profile : null,
+    patch_layer: normalizePatchLayer(data.patch_layer),
     ...normalizeTargetFields(data),
     workspaces: normalizeWorkspaces(data.workspaces),
   }
 }
 
+/**
+ * 声明行落盘层（顶层键 patch_layer，仅 'home' | 'profile' 两个合法值）：缺省 /
+ * null = 按环境自动判定（Android compat 壳 / 容器路径走 profile 层，其余 home，
+ * 判定在 preset-system.resolvePatchTargetLayer）；非法值（类型或取值不对）warn
+ * 后当未设置——配置错了降级提醒而非中断加载，与 background_mode / start_mode
+ * 的非法值口径一致。normalize 后恒为 'home' | 'profile' | null。
+ */
+function normalizePatchLayer(value) {
+  if (value === null || value === undefined || value === '') return null
+  if (value === 'home' || value === 'profile') return value
+  warn(`patch_layer: 非法值已忽略（${JSON.stringify(value)}），按自动判定（可选: 'home' / 'profile'）`)
+  return null
+}
+
 /**
  * 工作区条目段（顶层键 workspaces）规范化：只收 trim 后非空的字符串键（键 =
  * 工作区目录绝对路径），值过 normalizeTargetFields；值不是映射、键为空串则
@@ -606,6 +622,12 @@ function writeWorkspaces(lines, workspaces) {
 export function serializeConfig(config) {
   const lines = ['# dsh-paoding（庖丁）安装配置 —— 可手编；改后在侧栏底部「庖丁配置」入口应用，或重跑 node tools/install.mjs --auto']
   lines.push(`profile: ${config.profile ?? 'web'}`)
+  // patch_layer 显式钉层才落盘（null/缺省 = 自动判定，输出与旧版逐字节一致）；
+  // 落盘它才能在 loadConfig → saveConfig 往返中保住用户手编的层钉（否则面板
+  // 一保存该键就被抹掉，层判定退回自动）。
+  if (config.patch_layer === 'home' || config.patch_layer === 'profile') {
+    lines.push(`patch_layer: ${config.patch_layer}`)
+  }
   writeTargetFields(lines, '', config)
   // workspaces 段可选：键缺失 / 空对象整段省略（不含 workspaces 的配置输出与
   // 旧版逐字节一致）。

package/tools/lib/doctor.mjs

@@ -2,7 +2,8 @@
  * `dsh-paoding doctor` 的检查本体：只读体检，不动任何盘。与 health.mjs 的分工
  * ——healthCheck 管「这次保存/应用会怎样」（面向 preview / apply 响应与
  * --dry-run 报告的单次配置体检）；本模块管「这台机器装得正不正」（配置文件、
- * 预设安装轨道、托管声明行、孤儿工作区预设目录、版本标记、预设漂移六项环境
+ * 预设安装轨道、托管声明行（home + profile 层双层：托管块损坏 / 整文件解析 /
+ * 可疑坏行 / 行对账 / 层漂移）、孤儿工作区预设目录、版本标记、预设漂移六项环境
  * 对账），结果形状是人读导向的 { items: [{ status, label, detail }] }：
  *   status: 'ok' | 'warn' | 'error' | 'skip'（skip = 前置事实缺失，降级不炸——
  *   无 DSH_HOME / 无配置的干净机器上各项依此跳过）。
@@ -30,11 +31,14 @@ import {
   detectAgentRolesFlavor,
   detectHostVersionInfo,
   detectPresetSystem,
+  findSuspectPresetRows,
   isDeclarativeTriple,
   isPtcWorkerHost,
   parseGeneratorMarker,
   presetRolesFlavorOf,
   readHomePatchRows,
+  resolvePatchTargetLayer,
+  validatePatchYaml,
 } from './preset-system.mjs'
 import { healthCheck } from './health.mjs'
 
@@ -117,43 +121,99 @@ export async function runDoctor({ dshHome, configFile, profile = null, state = n
     }
   }
 
-  // ── 3. 声明行托管块（~/.dsh/cordis.patch.yml）────────────────────────────
-  // readHomePatchRows 对损坏块自捕返 []，读不出「损坏」——这里直接扫标记行补一道：
-  // 有 BEGIN 没 END = 托管块损坏，所有托管写盘都会被拒绝。
-  let patchText = null
-  try {
-    patchText = readFileSync(path.join(dshHome, 'cordis.patch.yml'), 'utf8')
-  } catch (err) {
-    if (err?.code === 'ENOENT') add('skip', '声明行托管块', 'cordis.patch.yml 不存在（尚无声明行；目录轨宿主也不需要）')
-    else add('skip', '声明行托管块', `cordis.patch.yml 读取失败（${err?.message ?? err}），跳过该项`)
-  }
-  if (patchText !== null) {
+  // ── 3. 声明行托管块（home + 目标 profile 层 patch 双层对账）───────────────
+  // 层判定与写盘侧同一条链（resolvePatchTargetLayer：config 可用时按
+  // patch_layer / profile 键，否则按环境自动——compat 壳 → profile 层）。
+  // 每层四查：托管块损坏（error，既有口径）→ 整文件 YAML 解析（error：compat
+  // 壳压平的坏行会让宿主在任何插件代码运行前死掉，dsh-maoying#1）→ 可疑坏行
+  // （warn，只点名行号不删）→ 行对账（目录轨残留 / 孤儿行，既有口径）。最后
+  // 层漂移：托管块只落在非目标层 → warn（下次自愈 / 保存会写目标层并撤遗留）。
+  const layerTarget = resolvePatchTargetLayer(dshHome, { config })
+  const layerEntries = [
+    { layer: 'home', profileName: null, patchFile: path.join(dshHome, 'cordis.patch.yml') },
+    { layer: 'profile', profileName: layerTarget.profileName, patchFile: layerTarget.patchPath },
+  ]
+  const seenPatchFiles = new Set()
+  let blockLayerSeen = null
+  for (const entry of layerEntries) {
+    if (seenPatchFiles.has(entry.patchFile)) continue // 目标 profile 恰为 'web' 时与 home 同文件，不双报
+    seenPatchFiles.add(entry.patchFile)
+    let patchText = null
+    try {
+      patchText = readFileSync(entry.patchFile, 'utf8')
+    } catch (err) {
+      // home 层缺失维持既有 skip 口径（干净机器各项依此跳过）；profile 层缺失
+      // 是常态（非 compat 壳 / 从未迁移过），静默。
+      if (entry.layer === 'home' && err?.code === 'ENOENT') {
+        add('skip', '声明行托管块', 'cordis.patch.yml 不存在（尚无声明行；目录轨宿主也不需要）')
+      } else if (err?.code !== 'ENOENT') {
+        add('skip', '声明行托管块', `${entry.patchFile} 读取失败（${err?.message ?? err}），跳过该层`)
+      }
+      continue
+    }
+    const layerName = entry.layer === 'home' ? '' : `（profile 层 ${entry.patchFile}）`
     const markers = managedMarkerLines(patchText)
     const hasBegin = markers.has(MANAGED_BEGIN)
     const hasEnd = markers.has(MANAGED_END)
+    if (hasBegin) blockLayerSeen = blockLayerSeen ?? entry.layer
     if (hasBegin && !hasEnd) {
-      add('error', '声明行托管块', '托管块损坏（只有起始标记没有结束标记）：补回结束标记或删除整块，否则面板保存 / 自愈都会拒绝写盘')
-    } else {
+      add('error', '声明行托管块', `${layerName}托管块损坏（只有起始标记没有结束标记）：补回结束标记或删除整块，否则面板保存 / 自愈都会拒绝写盘`)
+    }
+    // 整文件 YAML 解析（宿主 yaml 包口径，与写盘校验 validatePatchYaml 同源；
+    // yaml 包缺失退内置子集解析器——lenient，只兜 gross 损坏挡不住坏缩进）。
+    const parseVerdict = validatePatchYaml(dshHome, patchText)
+    if (!parseVerdict.ok) {
+      add(
+        'error',
+        'patch 文件解析',
+        `${entry.patchFile} 无法解析：${parseVerdict.message}——宿主启动会直接失败。请删除坏行或从 .bak-1 备份恢复` +
+          '（Android compat 壳重写 patch 压平坏行的特征参见 dsh-maoying#1）',
+      )
+    }
+    // 可疑坏行（maoying 坏行形状）：warn 点名行号，只诊断不删——删行可能踩
+    // 用户手写内容，修复交给人或清理侧的行级手术。
+    const suspects = findSuspectPresetRows(patchText)
+    if (suspects.length > 0) {
+      const lineNos = suspects.map((s) => s.lineNo).join('、')
+      add(
+        'warn',
+        '声明行可疑行',
+        `${entry.patchFile} 第 ${lineNos} 行检出可疑声明行（如 "- id: ${suspects[0].id}"——id 含空白或非 ASCII，` +
+          '形如 compat 壳把显示名压平进 id 位产生的坏行，宿主 YAML 解析会失败，参见 dsh-maoying#1）' +
+          '——请删除坏行或从 .bak-1 备份恢复后重试',
+      )
+    }
+    // 行对账（损坏块时 readHomePatchRows 自捕返空数组——损坏已单独报，这里
+    // 只在块结构完好时做逐行对账，避免损坏块上报出误导性的「无声明行」）。
+    if (!hasBegin || hasEnd) {
       let rows = []
       try {
-        rows = readHomePatchRows(dshHome)
+        rows = readHomePatchRows(dshHome, { layer: entry.layer, profileName: entry.profileName ?? 'web' })
       } catch {
         rows = []
       }
       if (rows.length === 0) {
-        add('ok', '声明行托管块', hasBegin ? '托管块存在但无声明行' : 'cordis.patch.yml 无托管块（目录轨宿主无需声明行）')
+        add('ok', '声明行托管块', hasBegin ? `${layerName}托管块存在但无声明行` : `${entry.layer === 'home' ? '' : `${entry.patchFile} `}无托管块（目录轨宿主无需声明行）`)
       } else {
         const orphans = rows.filter((row) => row.presetId && !existsSync(path.join(dshHome, '.agent-presets', row.presetId)))
         if (track === 'directory') {
-          add('warn', '声明行托管块', `检出 ${rows.length} 条声明行，但宿主是目录轨（≤ 0.1.6）——残留声明行会让 profile 启动失败，重启 DSH 触发自愈撤下`)
+          add('warn', '声明行托管块', `${layerName}检出 ${rows.length} 条声明行，但宿主是目录轨（≤ 0.1.6）——残留声明行会让 profile 启动失败，重启 DSH 触发自愈撤下`)
         } else if (orphans.length > 0) {
-          add('warn', '声明行托管块', `孤儿声明行（指向已删目录）：${orphans.map((o) => o.rowId).join('、')}——重启 DSH 自愈会撤下，或重新应用一次同步`)
+          add('warn', '声明行托管块', `${layerName}孤儿声明行（指向已删目录）：${orphans.map((o) => o.rowId).join('、')}——重启 DSH 自愈会撤下，或重新应用一次同步`)
         } else {
-          add('ok', '声明行托管块', `${rows.length} 条声明行均指向存在的预设目录`)
+          add('ok', '声明行托管块', `${layerName}${rows.length} 条声明行均指向存在的预设目录`)
         }
       }
     }
   }
+  if (blockLayerSeen !== null && blockLayerSeen !== layerTarget.layer) {
+    add(
+      'warn',
+      'patch 层漂移',
+      `声明行托管块在 ${blockLayerSeen} 层，当前判定目标层是 ${layerTarget.layer}（${layerTarget.patchPath}）` +
+        '——下次自愈 / 保存会写目标层并撤下这层的遗留块（compat 壳迁移行为，参见 dsh-maoying#1）',
+    )
+  }
 
   // ── 4. 孤儿工作区预设目录（.agent-presets/orchestrator-*）─────────────────
   if (!configUsable && existsSync(configFile)) {

package/tools/lib/lifecycle.mjs

@@ -5,9 +5,11 @@
  * 体检同源（孤儿目录 = workspacePresetOrphans，孤儿声明行 = presetId 指向的
  * 目录已不存在），本模块把「怎么删」收敛在一处，两个命令只决定「删哪些」。
  *
- * 备份纪律：一次清理调用对 cordis.patch.yml 至多备份一份 .bak-1（首次写盘前
- * 拷贝，已有同名备份覆盖——只保「本次改动前」的原貌），同一次调用里的后续写
- * 不再覆盖这份首备。配置文件 dsh-paoding.config.yml 是用户数据，只有 uninstall
+ * 备份纪律：一次清理调用对每个 patch 文件（home 层 cordis.patch.yml 与各
+ * profile 层 profiles/<name>/cordis.patch.yml——compat 壳把托管块搬进 profile
+ * 层，见 managedBlockStateAll）至多备份一份 .bak-1（首次写盘前拷贝，已有同名
+ * 备份覆盖——只保「本次改动前」的原貌），同一次调用里对同一文件的后续写不再
+ * 覆盖这份首备。配置文件 dsh-paoding.config.yml 是用户数据，只有 uninstall
  * --purge 才动，删除前列在计划里。
  *
  * 依赖 preset-system（托管块手术与轨道原语）/ workspaces（slug 名册）/
@@ -69,6 +71,38 @@ export function managedBlockState(dshHome) {
   return { present, corrupt: present && !marks.has(MANAGED_END) }
 }
 
+/**
+ * 全层托管块在场状态（managedBlockState 的双层版；managedBlockState 本身保持
+ * 只报 home 层的旧口径不动）：home 层恒在列表首位（文件缺失 present=false），
+ * 其后是 profiles/<name>/cordis.patch.yml 里真实存在的每一层。每项
+ * { layer: 'home'|'profile', profileName: null|<name>, patchFile, present,
+ * corrupt }。compat 壳把托管块搬进 profile 层后，uninstall / doctor --fix
+ * 必须两层都过一遍，否则卸载会在 home 层空转、profile 层残留整块声明行。
+ */
+export function managedBlockStateAll(dshHome) {
+  const entries = [{ layer: 'home', profileName: null, patchFile: path.join(dshHome, 'cordis.patch.yml') }]
+  try {
+    for (const name of readdirSync(path.join(dshHome, 'profiles')).sort()) {
+      const patchFile = path.join(dshHome, 'profiles', name, 'cordis.patch.yml')
+      if (existsSync(patchFile)) entries.push({ layer: 'profile', profileName: name, patchFile })
+    }
+  } catch { /* 无 profiles 目录：只有 home 层 */ }
+  return entries.map((entry) => {
+    let text = null
+    try {
+      text = readFileSync(entry.patchFile, 'utf8')
+    } catch {
+      return { ...entry, present: false, corrupt: false }
+    }
+    const marks = new Set(String(text).split(/\r?\n/).map((l) => l.trim()))
+    const present = marks.has(MANAGED_BEGIN)
+    return { ...entry, present, corrupt: present && !marks.has(MANAGED_END) }
+  })
+}
+
+/** managedBlockStateAll 条目 → preset-system 手术 opts（home 层恒 home 口径）。 */
+const layerOptsOf = (entry) => ({ layer: entry.layer, profileName: entry.profileName ?? 'web' })
+
 /**
  * 配置文件对账读法（doctor 配置文件项同一判据）：缺失返回 { config: null,
  * exists: false, usable: false }；存在但解析失败 → { exists: true, usable:
@@ -106,10 +140,22 @@ export function workspacePresetOrphans(dshHome, config) {
  * 不存在的 paoding-config-ui 的声明行）——判据只认「目录没了」，不认行名。
  * presetId 解析不出的行不在此列（doctor 不点名它，清理侧也不动它，交给用户）。
  * 托管块损坏时返回空数组（损坏块只能整块手工处理，行级手术做不了）。
+ * 双层扫描：home 与各 profile 层的孤儿行并集（rowId 去重——同一 preset 的行
+ * 理论上只在一层，两层都在场时清理侧会逐层各撤一遍）。
  */
 export function orphanManagedRows(dshHome) {
-  const rows = readHomePatchRows(dshHome)
-  return rows.filter((row) => row.presetId && !existsSync(path.join(dshHome, '.agent-presets', row.presetId)))
+  const seen = new Set()
+  const out = []
+  for (const entry of managedBlockStateAll(dshHome)) {
+    if (!entry.present || entry.corrupt) continue
+    for (const row of readHomePatchRows(dshHome, layerOptsOf(entry))) {
+      const key = `${entry.layer}:${row.rowId}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      if (row.presetId && !existsSync(path.join(dshHome, '.agent-presets', row.presetId))) out.push(row)
+    }
+  }
+  return out
 }
 
 /**
@@ -121,13 +167,17 @@ export function orphanManagedRows(dshHome) {
  *     generateAndInstall 的孤儿回收口径一致）
  *   - 删完目录后 .generator-version 若仍在（理论上随基础目录已走，防御性兜底）
  *     一并删除并在结果里注明
- * 备份纪律见模块头：对 cordis.patch.yml 的首次写前备份 .bak-1，之后不再覆盖。
- * 返回结构化结果（字段见实现），全程不 throw——单步失败折进对应字段，由调用
- * 方决定退出码与文案。
+ * 备份纪律见模块头：对每个 patch 文件（home / 各 profile 层）的首次写前备份
+ * .bak-1，之后不再覆盖；backupPath 兼容旧字段（首个备份），backupPaths 列全。
+ * 托管块手术双层循环（managedBlockStateAll：compat 壳把块搬进 profile 层后，
+ * 只清 home 层的旧卸载会空转），损坏块不碰：preset-system 会拒绝写盘，降级
+ * 给调用方报需手工。返回结构化结果（字段见实现），全程不 throw——单步失败
+ * 折进对应字段，由调用方决定退出码与文案。
  */
 export function cleanupPaodingArtifacts(dshHome, { stripBlock = false, pruneRowIds = [], removeDirIds = [] } = {}) {
   const result = {
-    backupPath: null,
+    backupPath: null, // 旧字段：首个写前备份（向后兼容 cli 打印）
+    backupPaths: [], // 本次实际落下的全部备份（每层 patch 至多一份）
     blockPresent: false,
     blockCorrupt: false,
     blockRemoved: false,
@@ -137,35 +187,43 @@ export function cleanupPaodingArtifacts(dshHome, { stripBlock = false, pruneRowI
     dirFailures: [],
   }
 
-  const block = managedBlockState(dshHome)
-  result.blockPresent = block.present
-  result.blockCorrupt = block.corrupt
+  const layers = managedBlockStateAll(dshHome)
+  result.blockPresent = layers.some((l) => l.present)
+  result.blockCorrupt = layers.filter((l) => l.present).some((l) => l.corrupt)
+  const prunedSeen = new Set()
 
-  let backupDone = false
-  const backupOnce = () => {
-    if (backupDone) return
-    backupDone = true
-    result.backupPath = backupBeforeWrite(path.join(dshHome, 'cordis.patch.yml'))
+  const backupDone = new Set()
+  const backupOnce = (patchFile) => {
+    if (backupDone.has(patchFile)) return
+    backupDone.add(patchFile)
+    const backupPath = backupBeforeWrite(patchFile)
+    if (backupPath !== null) {
+      result.backupPaths.push(backupPath)
+      if (result.backupPath === null) result.backupPath = backupPath
+    }
   }
 
-  // 1) 托管块手术（损坏块不碰：preset-system 会拒绝写盘，降级给调用方报需手工）
-  if (block.present && !block.corrupt) {
-    const rowsOnDisk = readHomePatchRows(dshHome).map((r) => r.rowId)
+  // 1) 托管块手术（逐层；损坏块不碰：preset-system 会拒绝写盘，降级给调用方报需手工）
+  for (const entry of layers.filter((l) => l.present && !l.corrupt)) {
+    const opts = layerOptsOf(entry)
+    const rowsOnDisk = readHomePatchRows(dshHome, opts).map((r) => r.rowId)
     if (stripBlock) {
-      backupOnce()
-      result.blockRemoved = stripHomePatchRows(dshHome, null)
+      backupOnce(entry.patchFile)
+      if (stripHomePatchRows(dshHome, null, opts)) result.blockRemoved = true
     } else if (pruneRowIds.length > 0) {
       const present = pruneRowIds.filter((id) => rowsOnDisk.includes(id))
       if (present.length > 0) {
-        backupOnce()
+        backupOnce(entry.patchFile)
         // stripHomePatchRows 返回 true = 指定段确已撤下；块里本来就没有的 id
-        // 不算撤（present 已过滤），不虚报。
-        if (stripHomePatchRows(dshHome, present)) result.prunedRowIds = present
+        // 不算撤（present 已过滤），不虚报。同一 rowId 两层都在场时各撤一遍，
+        // 结果里只记一次（Set 去重）。
+        if (stripHomePatchRows(dshHome, present, opts)) for (const id of present) prunedSeen.add(id)
       }
     }
   }
+  result.prunedRowIds = [...prunedSeen]
 
-  // 2) 预设目录删除 + 声明行同步（目录先删，行后撤——与孤儿回收同序）
+  // 2) 预设目录删除 + 声明行同步（目录先删，行后撤——与孤儿回收同序；行逐层清）
   if (removeDirIds.length > 0) {
     for (const id of removeDirIds) {
       const dir = path.join(dshHome, '.agent-presets', id)
@@ -177,12 +235,15 @@ export function cleanupPaodingArtifacts(dshHome, { stripBlock = false, pruneRowI
       }
     }
     const removedIds = new Set(result.removedDirs)
-    const danglingRowIds = readHomePatchRows(dshHome)
-      .filter((r) => r.presetId && removedIds.has(r.presetId))
-      .map((r) => r.rowId)
-    if (danglingRowIds.length > 0 && !result.blockCorrupt) {
-      backupOnce()
-      stripHomePatchRows(dshHome, danglingRowIds)
+    for (const entry of layers.filter((l) => l.present && !l.corrupt)) {
+      const opts = layerOptsOf(entry)
+      const danglingRowIds = readHomePatchRows(dshHome, opts)
+        .filter((r) => r.presetId && removedIds.has(r.presetId))
+        .map((r) => r.rowId)
+      if (danglingRowIds.length > 0) {
+        backupOnce(entry.patchFile)
+        stripHomePatchRows(dshHome, danglingRowIds, opts)
+      }
     }
   }
 
@@ -202,17 +263,25 @@ export function cleanupPaodingArtifacts(dshHome, { stripBlock = false, pruneRowI
 /**
  * 卸载计划（只读侦察，不落盘）：给确认提示、非 TTY 防呆打印与「无事可做」
  * 判定共用。不加载配置文件内容（卸载不依赖配置语义），只看存在性。
+ * blockPresent / blockCorrupt / blockRowCount 聚合双层（compat 壳的 profile 层
+ * 托管块也算在场）；patchFile 保留 home 层路径的旧字段口径，patchFiles 列出
+ * 各层实际在场托管块的文件（供调用方点名 profile 层残留）。
  */
 export function planUninstall({ dshHome, configFile } = {}) {
-  const block = managedBlockState(dshHome)
+  const layers = managedBlockStateAll(dshHome)
   const markerPath = generatorMarkerPath(dshHome)
+  let blockRowCount = 0
+  for (const entry of layers.filter((l) => l.present && !l.corrupt)) {
+    blockRowCount += readHomePatchRows(dshHome, layerOptsOf(entry)).length
+  }
   return {
     dshHome,
     configFile,
     patchFile: path.join(dshHome, 'cordis.patch.yml'),
-    blockPresent: block.present,
-    blockCorrupt: block.corrupt,
-    blockRowCount: readHomePatchRows(dshHome).length,
+    patchFiles: layers.filter((l) => l.present).map((l) => l.patchFile),
+    blockPresent: layers.some((l) => l.present),
+    blockCorrupt: layers.filter((l) => l.present).some((l) => l.corrupt),
+    blockRowCount,
     presetDirs: listOrchestratorPresetIds(dshHome),
     markerPath,
     markerExists: existsSync(markerPath),