@hyzyn/dsh-safe 0.14.2 → 0.15.0

package/README.en.md

@@ -48,8 +48,7 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 | `dsh-safe doctor` | environment check: versions, DSH_HOME, profiles, ledger, patch health |
 | `dsh-safe restore [--profile <name>] (--id <id> \| --all) [--dry-run]` | re-enable auto-disabled plugins (omit `--profile` to cover every profile in the ledger) |
 | `dsh-safe explain [id] [--profile <name> \| --file <path>]` | interpret failure info with AI: an `id` interprets that quarantine record (with repair advice); defaults to the last failure log, falling back to the ledger; `--file`/stdin read any log (needs `DSH_SAFE_AI_KEY`) |
-| `dsh-safe -r [dsh args…]` | repair all repairable quarantined plugins first, then boot in wrap mode (`--repair` alias; mirrors `-u`) |
-| `dsh-safe repair [id] [--all] [--profile <name>] [--to <version>] [-y] [--dry-run]` | reinstall/upgrade a quarantined plugin and auto-restore it (failures a reinstall/upgrade may fix: package resolution, export mismatches; installs via `dsh plugin`'s pnpm channel); duplicate mounts support auto-dedup (interactively pick which source to keep) |
+| `dsh-safe repair [id] [--all] [--profile <name>] [--to <version>] [-y] [--dry-run]` | reinstall/upgrade a quarantined plugin and auto-restore it (failures a reinstall/upgrade may fix: package resolution, export mismatches; installs via `dsh plugin`'s pnpm channel); duplicate mounts support auto-dedup (interactively pick which source to keep); well suited to being run by the AI agent in the web UI |
 | `dsh-safe help` (`-h` / `--help`) | show help |
 | `dsh-safe --version` (`-V`) | show version |
 
@@ -61,7 +60,7 @@ Every short flag has an equivalent long form (`-u` = `--update`, `-y` = `--yes`,
 | --- | --- |
 | `--dry-run` | Parse and report only; no files are modified |
 | `--max-retries <n>` | Max startup retries after an auto-quarantine (default 2; `0` means pass through without quarantining) |
-| `--allow-first-party` | Allow auto-disabling first-party `@deepseek-ai/*` plugins (skipped by default; handle manually) |
+| `--allow-first-party` | Allow auto-disabling first-party `@deepseek-ai/*` plugins and removing official bundles during duplicate dedupe (skipped by default; handle manually) |
 | `--exclude <id-or-pkg>` | Quarantine exclusion list (repeatable) — matched rows are never auto-disabled; can also live in `config.json` |
 
 ### update / -u options (after `-u` or `update`; wrapper flags before the dsh args still apply)
@@ -96,6 +95,25 @@ How upgrading works: `dsh-safe update` auto-detects the dsh package name and ins
 3. **Managed block writing**: it appends a marker-commented managed block at the end of the matching patch file (same convention as `dsh-mcp-config managed`), setting matched rows to `disabled: true`. Existing user content and comments are preserved; a fresh profile's `[]` template is correctly replaced with a block sequence.
 4. **Ledger & restore**: quarantine records live in `$DSH_HOME/dsh-safe/quarantine.json`. Once a plugin upgrade fixes the issue, `dsh-safe restore --profile web --all` removes the managed block and re-mounts the plugin (hot-applied for profiles with `patchReload: live`).
 
+### Let the AI agent in the web UI take over repairs (recommended)
+
+The wrapped boot already owns keep-alive end to end: failing plugins are auto-quarantined and retried, duplicate mounts are auto-deduped and retried. After boot, the ledger records left behind are the "fix-me list" — hand repairs to the AI agent in the web UI. Add the following snippet to a dsh agent preset (or system prompt) so the agent can discover and fix issues proactively:
+
+```text
+dsh-safe is installed on this machine (a startup fuse for dsh). When the user
+reports a missing plugin feature, a boot warning, or misbehaving plugins:
+1. Run dsh-safe list --json to inspect the quarantine ledger (which plugins
+   are auto-disabled, why, when).
+2. If interpretation is needed, run dsh-safe explain <id> (requires DSH_SAFE_AI_KEY).
+3. Repair based on the cause:
+   - missing/stale package → dsh-safe repair <id> -y (reinstall latest)
+   - known compatible version → dsh-safe repair <id> --to <version> -y
+   - duplicate mount → dsh-safe repair <id> -y (redundant source removed)
+   - no compatible upstream release yet → keep it disabled and say so.
+4. Verify with dsh-safe --profile <name>; still-broken plugins are
+   auto-quarantined again and never take down the boot.
+```
+
 ### AI Capabilities (optional)
 
 Enabled by setting `DSH_SAFE_AI_KEY` (defaults to DeepSeek; OpenAI-compatible — swap providers via `DSH_SAFE_AI_BASE_URL` / `DSH_SAFE_AI_MODEL`):
@@ -106,7 +124,7 @@ Enabled by setting `DSH_SAFE_AI_KEY` (defaults to DeepSeek; OpenAI-compatible
 
 ## Safety Boundaries
 
-- **First-party protection**: rows of `@deepseek-ai/*` plugins are skipped by default (disabling plugins like `dsh-web-app` would strip dsh of its core capabilities); pass `--allow-first-party` to touch them.
+- **First-party protection**: rows of `@deepseek-ai/*` plugins are skipped by default (disabling plugins like `dsh-web-app` would strip dsh of its core capabilities); pass `--allow-first-party` to touch them. Duplicate dedupe is guarded the same way: official sources are kept by default, and removing an official bundle requires an explicit flag or interactive confirmation, so official rows like webserver are never unmounted as collateral.
 - **Startup-phase failures only**: module resolution failures / `apply` throws / timed-out service injection. Uncaught runtime exceptions are still handled by dsh's own fail-loud policy and are out of scope for boot quarantine.
 - **Auditable**: every write records the reason and a timestamp; `--dry-run` previews which plugins would be disabled.
 - **Faithful pass-through**: when no broken plugin can be identified, the retry limit is exceeded, or for `dsh plugin` (pnpm forwarding), the exit code is passed through untouched and no files are modified.

package/README.md

@@ -48,8 +48,7 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 | `dsh-safe doctor` | 环境体检：版本、DSH_HOME、profiles、台账、各 patch 健康度 |
 | `dsh-safe restore [--profile <名>] (--id <id> \| --all) [--dry-run]` | 恢复被自动禁用的插件（省略 `--profile` 时遍历台账全部 profile） |
 | `dsh-safe explain [id] [--profile <名> \| --file <路径>]` | 用 AI 解读失败信息：指定 `id` 解读该条隔离记录（给 repair 建议）；默认解读最近一次失败日志，无日志则解读隔离台账；`--file`/stdin 读任意日志（需 `DSH_SAFE_AI_KEY`） |
-| `dsh-safe -r [dsh 参数…]` | 先修复全部可修复的隔离记录，再按包装模式启动（`--repair` 等价；与 `-u` 对称） |
-| `dsh-safe repair [id] [--all] [--profile <名>] [--to <版本>] [-y] [--dry-run]` | 重装/升级被隔离的插件并自动恢复（限重装/升级可能修复的失败：包解析失败、导出版本不匹配等；经 `dsh plugin` 的 pnpm 通道安装）；重复挂载类支持自动去重（交互选择保留哪个来源，从 bundles 移除冗余） |
+| `dsh-safe repair [id] [--all] [--profile <名>] [--to <版本>] [-y] [--dry-run]` | 重装/升级被隔离的插件并自动恢复（限重装/升级可能修复的失败：包解析失败、导出版本不匹配等；经 `dsh plugin` 的 pnpm 通道安装）；重复挂载类支持自动去重（交互选择保留哪个来源，从 bundles 移除冗余）；适合交给 web UI 里的 AI agent 执行 |
 | `dsh-safe help`（`-h` / `--help`） | 显示帮助 |
 | `dsh-safe --version`（`-V`） | 显示版本 |
 
@@ -61,7 +60,7 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 | --- | --- |
 | `--dry-run` | 只解析与报告，不修改任何文件 |
 | `--max-retries <n>` | 自动隔离后最多重试启动的次数（默认 2；`0` 表示不隔离只透传） |
-| `--allow-first-party` | 允许自动禁用 `@deepseek-ai/*` 第一方插件（默认跳过，需手动处理） |
+| `--allow-first-party` | 允许自动禁用 `@deepseek-ai/*` 第一方插件，duplicate 去重时允许移除官方 bundle（默认跳过，需手动处理） |
 | `--exclude <id或包名>` | 隔离豁免名单（可重复），命中的行永不自动禁用；也可写进 `config.json` |
 
 ### update / -u 选项（写在 `-u` 或 `update` 之后；其前的包装旗标照常生效）
@@ -104,9 +103,27 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 - **AI 兜底识别**（`DSH_SAFE_AI_RECOVER=1`）：正则特征识别不出坏插件时（如 dsh 升级换格式），让 AI 从 stderr 里挑元凶——**结果必须仍走同一验证管线**（对照真实 patch 行、第一方保护、dry-run 预览），命中不了照旧透传。仅在启动失败时调用。
 - 隐私：发送前 home 路径脱敏为 `~`；AI 任何失败都静默降级。
 
+### 让 web UI 里的 AI agent 接管修复（推荐）
+
+包装启动自带完整的保活：插件失败自动隔离重试，重复挂载自动去重后重试。启动成功后，台账里留下的记录就是"待修复清单"——把修复交给 web UI 里的 AI agent。将下面片段加入 dsh 的 Agent 预设（或系统提示），agent 就能主动发现并修复：
+
+```text
+本机装有 dsh-safe（dsh 的启动保险丝）。当用户报告插件功能缺失、启动
+警告或插件行为异常时：
+1. 运行 dsh-safe list --json 查看隔离台账（哪些插件被自动禁用、原因、时间）。
+2. 需要解读时运行 dsh-safe explain <id>（设置 DSH_SAFE_AI_KEY 后可用）。
+3. 按原因修复：
+   - 包缺失/版本落后 → dsh-safe repair <id> -y（重装 latest）
+   - 已知兼容版本 → dsh-safe repair <id> --to <版本> -y（降级/指定版本）
+   - 重复挂载 → dsh-safe repair <id> -y（自动移除冗余挂载来源）
+   - 上游暂无兼容版本 → 保持禁用，并向用户说明。
+4. 修复后用 dsh-safe --profile <名> 重启验证；仍失败的会被自动重新隔离，
+   不会拖垮启动。
+```
+
 ## 安全边界
 
-- **第一方保护**：`@deepseek-ai/*` 的行默认跳过（禁用 `dsh-web-app` 这类插件会让 dsh 失去核心能力），需要 `--allow-first-party` 才会动。
+- **第一方保护**：`@deepseek-ai/*` 的行默认跳过（禁用 `dsh-web-app` 这类插件会让 dsh 失去核心能力），需要 `--allow-first-party` 才会动；duplicate 自动去重同受保护——缺省保留官方来源，移除官方 bundle 需显式允许或交互确认，避免连带卸载 webserver 等官方行。
 - **只动启动期失败**：模块解析失败 / `apply` 抛错 / 等不到注入服务。运行期的未捕获异常仍由 dsh 自身的 fail-loud 策略处理，不属于启动隔离范围。
 - **可审计**：每次写入都带原因与时间戳；`--dry-run` 可以先看会禁用谁。
 - **原样透传**：识别不出坏插件、超过重试上限、`dsh plugin`（pnpm 转发）等情况，退出码原样透传，不做任何修改。

package/lib/cli.js

@@ -8,12 +8,15 @@
  *   dsh-safe help | --version
  */
 import { createRequire } from 'node:module'
+import { writeFileSync } from 'node:fs'
 import { loadLedger, restoreQuarantine } from './quarantine.js'
 import { runWrapped } from './wrap.js'
 import { cmdUpdate, cmdUpdateAndBoot, maybeNotifySelfUpdate } from './update.js'
-import { cmdRepair, cmdRepairAndBoot } from './repair.js'
+import { cmdRepair } from './repair.js'
 import { printDoctor } from './doctor.js'
 import { cmdExplain } from './ai.js'
+import { profileDirs, profilePatchPath, readIfExists } from './dshpaths.js'
+import { applyManagedBlock, managedBlockText, scanPatchRows } from './patchfile.js'
 import { t } from './i18n.js'
 
 const require = createRequire(import.meta.url)
@@ -60,19 +63,37 @@ function takeIds(args) {
   return [ids, rest]
 }
 
+/**
+ * 孤儿禁用行：托管区块里有、台账里没有的行。克隆 profile 会把 patch（含
+ * 托管区块）复制过来，而台账按 profile 记录、不会跟着克隆——这些行既不可
+ * 见也不可恢复，只能靠这里暴露。
+ */
+function orphanRows(profile, ledger) {
+  const block = managedBlockText(readIfExists(profilePatchPath(profile)) ?? '')
+  if (block === null) return []
+  const ledgerIds = new Set((ledger.profiles[profile] ?? []).map((e) => e.id))
+  return scanPatchRows(block).filter((r) => !ledgerIds.has(r.id))
+}
+
 function cmdList(args) {
   const [profile, rest] = takeProfile(args)
   const ledger = loadLedger()
+  const scanProfiles = profile ? [profile] : [...new Set([...Object.keys(ledger.profiles), ...profileDirs()])]
+  const orphansByProfile = {}
+  for (const p of scanProfiles) {
+    const orphans = orphanRows(p, ledger)
+    if (orphans.length) orphansByProfile[p] = orphans.map((r) => ({ id: r.id, name: r.name }))
+  }
   if (rest.includes('--json')) {
     const profiles = profile ? { [profile]: ledger.profiles[profile] ?? [] } : ledger.profiles
-    process.stdout.write(`${JSON.stringify({ version: ledger.version ?? 1, profiles }, null, 2)}\n`)
+    process.stdout.write(`${JSON.stringify({ version: ledger.version ?? 1, profiles, orphans: orphansByProfile }, null, 2)}\n`)
     return 0
   }
-  const profiles = profile ? [profile] : Object.keys(ledger.profiles).sort()
   let found = 0
-  for (const p of profiles) {
+  for (const p of scanProfiles) {
     const entries = ledger.profiles[p] ?? []
-    if (!entries.length) continue
+    const orphans = orphansByProfile[p] ?? []
+    if (!entries.length && !orphans.length) continue
     process.stdout.write(`${p}:\n`)
     for (const e of entries) {
       found++
@@ -80,6 +101,11 @@ function cmdList(args) {
         `  - ${e.name ?? t('unknownName')} (id: ${e.id})\n${t('quarantinedAt', { time: e.quarantinedAt })}\n${t('reasonLine', { reason: e.reason })}\n${t('locationLine', { file: e.file })}\n`,
       )
     }
+    for (const o of orphans) {
+      found++
+      process.stdout.write(`${t('listOrphanRow', { id: o.id, name: o.name ?? t('unknownName') })}\n`)
+    }
+    if (orphans.length) process.stdout.write(`${t('listOrphanHint')}\n`)
   }
   if (!found) process.stdout.write(profile ? `${t('noRecordsProfile', { profile })}\n` : `${t('noRecords')}\n`)
   return 0
@@ -94,11 +120,15 @@ function cmdRestore(args) {
     process.stderr.write(`${t('restoreNeedsId')}\n`)
     return 2
   }
-  // 省略 --profile 时遍历台账里所有有记录的 profile（与 update 的恢复对齐）
+  // 省略 --profile 时：--all 遍历台账 profile 与全部 profile 目录（孤儿托管
+  // 区块可能存在于任何 profile——克隆产物台账里没有），否则只遍历台账里有
+  // 记录的 profile（与 update 的恢复对齐）
   const ledger = loadLedger()
   const profiles = profile0
     ? [profile0]
-    : Object.keys(ledger.profiles).filter((p) => (ledger.profiles[p] ?? []).length)
+    : all
+      ? [...new Set([...Object.keys(ledger.profiles), ...profileDirs()])]
+      : Object.keys(ledger.profiles).filter((p) => (ledger.profiles[p] ?? []).length)
   const verb = t(dryRun ? 'restoredDry' : 'restored')
   let anyRestored = false
   for (const p of profiles) {
@@ -109,6 +139,20 @@ function cmdRestore(args) {
       if (kept.length) process.stdout.write(`${t('stillQuarantined', { profile: p, count: kept.length })}\n`)
       else process.stdout.write(`${t('ledgerCleared')}\n`)
     }
+    // 孤儿托管区块：恢复后该 profile 台账已空，patch 里却仍有托管区块——
+    // 区块由 dsh-safe 全权生成，台账为空即整体失效（克隆/手删台账的产物），
+    // 直接摘除，让那些禁用行重新可见、可修复。
+    const remaining = loadLedger().profiles[p] ?? []
+    const block = managedBlockText(readIfExists(profilePatchPath(p)) ?? '')
+    const orphans = block === null ? [] : scanPatchRows(block).filter((r) => !remaining.some((e) => e.id === r.id))
+    if (orphans.length) {
+      anyRestored = true
+      const params = { profile: p, count: orphans.length }
+      if (!dryRun) {
+        writeFileSync(profilePatchPath(p), applyManagedBlock(readIfExists(profilePatchPath(p)), null).text)
+      }
+      process.stdout.write(`${t(dryRun ? 'orphanBlockRemovedDry' : 'orphanBlockRemoved', params)}\n`)
+    }
   }
   if (!anyRestored) process.stdout.write(`${t('noMatching')}\n`)
   return 0
@@ -142,7 +186,13 @@ export async function main(argv) {
     return 0
   }
   if (cmd === '-u' || cmd === '--update') return cmdUpdateAndBoot(argv.slice(1), { boot: runWrapperMode })
-  if (cmd === '-r' || cmd === '--repair') return cmdRepairAndBoot(argv.slice(1), { boot: runWrapperMode })
+  // 0.15.0 起移除：保活由包装启动全权承担（隔离重试 + duplicate 自愈），
+  // 修复走 repair 原语（用户手动或 web UI 里的 AI agent）。留一句迁移提示，
+  // 避免老命令直接落进包装模式被 dsh 当成未知参数。
+  if (cmd === '-r' || cmd === '--repair') {
+    process.stderr.write(`${t('repairFlagRemoved')}\n`)
+    return 2
+  }
 
   // 包装模式：剥掉 dsh-safe 自己的旗标（必须出现在第一个位置参数之前），
   // 其余原样转发给 dsh。

package/lib/dedupe.js

@@ -0,0 +1,139 @@
+/**
+ * @hyzyn/dsh-safe — 重复挂载（duplicate loader entry id）的去重。
+ *
+ * 同一 id 被多个 bundle 挂载时，加载器在 include 挂载阶段整体拒绝启动；
+ * 它发生在 profile 层 disabled 覆盖合并之前，禁用行管不住，隔离无效。
+ * 去重 = 保留一个来源，从 manifest bundles 移除其余来源（包本身保留在
+ * node_modules，聚合包的挂载行仍解析到根安装的版本）。保留哪一个：
+ * 交互终端让用户选；非交互（-y、dry-run、无 TTY）缺省保留官方 bundle
+ * （@deepseek-ai/*，社区复刻与官方同 id 重复挂载时不能把官方挂载下线），
+ * 没有官方来源则保留先声明者。第一方守卫：移除方案含官方 bundle 时，
+ * 仅 allowFirstParty 或交互终端显式确认才放行，否则拒绝并由调用方给
+ * 手动指引——移除一个 bundle 会把它挂载的其它条目一并卸载，官方 bundle
+ * 背后往往是 webserver 等核心行。
+ *
+ * repair 与 wrap 两条路径共用：repair 负责额外的台账恢复，wrap 在启动
+ * 失败自愈时调用。注意 dsh 会在每次 plugin add 时把 dependencies 里的
+ * bundle 型包重新 reconcile 进 bundles——去重的成果可能被下一次 add
+ * 复活，属于 dsh 的设计行为（见 repair/wrap 的调用处说明）。
+ */
+import { createInterface } from 'node:readline/promises'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { profileManifestPath, readIfExists } from './dshpaths.js'
+import { collectKnownRows } from './knownrows.js'
+import { t } from './i18n.js'
+
+const err = (line) => process.stderr.write(`${line}\n`)
+
+export const FIRST_PARTY_PREFIX = '@deepseek-ai/'
+
+/** 第一方（dsh 官方）包/bundle：@deepseek-ai/* 域下的名字。 */
+export const isFirstParty = (name) => typeof name === 'string' && name.startsWith(FIRST_PARTY_PREFIX)
+
+/** 该 id 的 bundle 挂载来源（profile/home 层是 override，不算挂载来源）。 */
+export function bundleMountSources(known, id) {
+  return [
+    ...new Set(
+      known.rows.filter((r) => r.id === id && r.source !== 'profile' && r.source !== 'home').map((r) => r.source),
+    ),
+  ]
+}
+
+/** 从 manifest bundles 移除指定来源；没有变化返回 false。 */
+export function removeFromManifestBundles(profile, removeNames) {
+  const manifestPath = profileManifestPath(profile)
+  let manifest
+  try {
+    manifest = JSON.parse(readIfExists(manifestPath) ?? 'null')
+  } catch {
+    return false
+  }
+  const current = manifest?.dsh?.profile?.bundles
+  if (!Array.isArray(current)) return false
+  const next = current.filter((b) => !removeNames.includes(b))
+  if (next.length === current.length) return false
+  manifest.dsh.profile.bundles = next
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+  return true
+}
+
+/**
+ * 去重一个被多来源挂载的 id。
+ * @param {string} profile
+ * @param {string} id
+ * @param {{
+ *   yes?: boolean,   // 跳过交互选择（缺省保留官方来源，否则保留先声明者）
+ *   tty?: boolean,   // 非交互终端不提示，直接按缺省来源去重（默认 false；
+ *                    // 注意调用方传 undefined 也会落到默认值）
+ *   dryRun?: boolean,
+ *   allowFirstParty?: boolean,  // 允许移除官方 bundle（默认保护）
+ *   log?: (line: string) => void,
+ * }} [opts]
+ * @returns {Promise<{ kept: string, removed: string[] } | { error: 'no-duplicate' | 'no-manifest' | 'first-party' }>}
+ *   no-duplicate = 该 id 实际只有 ≤1 个可识别的挂载来源（扫描器盲区或已修复）
+ *   first-party  = 保留方案会移除官方 bundle 且未获允许/确认
+ */
+export async function dedupeMountSources(
+  profile,
+  id,
+  { yes = false, tty = false, dryRun = false, allowFirstParty = false, log = err } = {},
+) {
+  const sources = bundleMountSources(collectKnownRows(profile), id)
+  if (sources.length < 2) return { error: 'no-duplicate' }
+
+  // 按 manifest bundles 的声明顺序排序：先声明者优先保留
+  let manifest
+  try {
+    manifest = JSON.parse(readIfExists(profileManifestPath(profile)) ?? 'null')
+  } catch {
+    manifest = null
+  }
+  const declared = manifest?.dsh?.profile?.bundles
+  const ordered = Array.isArray(declared)
+    ? [...sources].sort(
+        (a, b) =>
+          (declared.indexOf(a) < 0 ? 999 : declared.indexOf(a)) - (declared.indexOf(b) < 0 ? 999 : declared.indexOf(b)),
+      )
+    : sources
+
+  // 缺省保留官方 bundle：社区复刻与官方同 id 重复挂载时，保官方、去社区
+  const firstPartySources = ordered.filter(isFirstParty)
+  const defaultKeep = firstPartySources.length ? firstPartySources[0] : ordered[0]
+
+  let keep = defaultKeep
+  if (!yes && !dryRun && tty) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr })
+    log(t('repairDedupePick', { id }))
+    ordered.forEach((b, i) => log(`${i + 1}. ${b}${b === defaultKeep ? t('repairDedupeDefault') : ''}`))
+    const answer = await rl.question(t('repairDedupeChoose'))
+    rl.close()
+    const fallback = ordered.indexOf(defaultKeep) + 1
+    const pick = Math.min(Math.max(parseInt(answer, 10) || fallback, 1), ordered.length)
+    keep = ordered[pick - 1]
+  }
+  const remove = ordered.filter((b) => b !== keep)
+
+  log(t('repairDedupePlan', { keep, remove: remove.join(', '), id }))
+  // 第一方守卫：移除官方 bundle 会连带卸载它挂载的其它条目（webserver 等
+  // 核心行），仅在显式允许或交互确认后放行
+  const removeFirstParty = remove.filter(isFirstParty)
+  if (removeFirstParty.length && !allowFirstParty) {
+    if (!yes && !dryRun && tty) {
+      log(t('dedupeFirstPartyWarn', { bundles: removeFirstParty.join(', ') }))
+      const rl = createInterface({ input: process.stdin, output: process.stderr })
+      const answer = await rl.question(t('dedupeFirstPartyConfirm'))
+      rl.close()
+      if (!/^(y|yes)$/i.test(answer.trim())) {
+        log(t('dedupeFirstPartyBlocked', { bundles: removeFirstParty.join(', ') }))
+        return { error: 'first-party' }
+      }
+    } else {
+      log(t('dedupeFirstPartyBlocked', { bundles: removeFirstParty.join(', ') }))
+      return { error: 'first-party' }
+    }
+  }
+  if (dryRun) return { kept: keep, removed: remove }
+
+  if (!removeFromManifestBundles(profile, remove)) return { error: 'no-manifest' }
+  return { kept: keep, removed: remove }
+}

package/lib/dshpaths.js

@@ -4,7 +4,7 @@
  * 与 dsh 运行时（@deepseek-ai/dsh-home-paths）保持一致的 home 解析规则：
  * `DSH_HOME` 环境变量优先（支持 `~` 前缀展开），默认 `~/.dsh`。
  */
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { dirname, resolve, join } from 'node:path'
 
@@ -22,6 +22,17 @@ export const profileDir = (profile) => join(dshHome(), 'profiles', profile)
 export const profilePatchPath = (profile) => join(profileDir(profile), 'cordis.patch.yml')
 export const profileManifestPath = (profile) => join(profileDir(profile), 'package.json')
 
+/** $DSH_HOME/profiles 下的全部 profile 目录名；目录不存在返回空数组。 */
+export function profileDirs() {
+  try {
+    return readdirSync(join(dshHome(), 'profiles'), { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name)
+  } catch {
+    return []
+  }
+}
+
 /** dsh home 层的公共 patch（对所有 profile 生效）。 */
 export const homePatchPath = () => join(dshHome(), 'cordis.patch.yml')
 

package/lib/i18n.js

@@ -26,8 +26,7 @@ const ZH = {
                                     升级 dsh 与 dsh-safe 自身，并自动恢复被隔离的插件
   dsh-safe explain [id] [--profile <名> | --file <路径>]  用 AI 解读：最近失败日志 / 隔离台账 / 任意日志
   dsh-safe repair [id] [--all] [--profile <名>] [--to <版本>] [-y] [--dry-run]
-                                    重装/升级被隔离的插件并自动恢复（--all 批量；限可自动修复类；省略 id 时只有一条记录则直接修）
-  dsh-safe -r [dsh 参数…]            先修复全部可修复的隔离记录，再启动（--repair 等价）
+                                    重装/升级被隔离的插件并自动恢复（--all 批量；限重装/升级可能修复的失败；省略 id 时只有一条记录则直接修；可交给 web UI 里的 AI agent 执行）
   dsh-safe help                     显示本帮助
   dsh-safe --version                显示版本
 
@@ -139,11 +138,14 @@ const ZH = {
   repairDuplicate: '[dsh-safe] 这是重复挂载问题（id: {id}）。一键修复：dsh-safe repair {id}（自动移除冗余来源并恢复挂载）',
   repairDuplicateManual: '[dsh-safe] 这是重复挂载问题（同一 id 被多个 bundle/行挂载），重装包无法修复。请从 profile 的 bundles 清单或 patch 中移除多余的挂载来源，然后 dsh-safe restore 恢复。',
   repairDedupePick: '[dsh-safe] {id} 同时由以下 bundle 挂载，保留哪个来源？',
-  repairDedupeDefault: '（bundles 中先声明，缺省保留）',
+  repairDedupeDefault: '（缺省保留）',
   repairDedupeChoose: '保留哪个？输入编号 [1]: ',
   repairDedupePlan: '[dsh-safe] 修复方案：保留 {keep} 的挂载，从 bundles 移除 {remove}，并摘除 {id} 的禁用行',
   repairDedupeNoManifest: '[dsh-safe] profile 清单中没有可编辑的 bundles 数组，请手动处理。',
   repairDedupeDone: '[dsh-safe] 去重完成：已从 bundles 移除 {removed}；{keep} 的挂载保留、禁用行已摘除。跑 dsh-safe <启动命令> 验证。',
+  dedupeFirstPartyWarn: '[dsh-safe] 注意：该方案会移除官方 bundle {bundles}（@deepseek-ai/*），由它挂载的其它条目也会一并下线。',
+  dedupeFirstPartyConfirm: '确认移除官方 bundle？(y/N) ',
+  dedupeFirstPartyBlocked: '[dsh-safe] 已跳过自动去重：保留方案会移除官方 bundle {bundles}（@deepseek-ai/*，默认保护）。请手动编辑 profile manifest 的 bundles 移除冗余来源，或在交互终端确认后重试。',
   repairAllConflict: '[dsh-safe] --all 与 <id> 不能同时使用。',
   repairUnknownArg: '[dsh-safe] repair 无法识别的参数: {arg}',
   repairBatchPlan: '[dsh-safe] 将修复 {count} 条隔离记录: {ids}',
@@ -151,6 +153,13 @@ const ZH = {
   repairBatchDone: '[dsh-safe] 批量修复完成：成功 {repaired} 条，失败 {failed} 条。',
   repairInstallFailed: '[dsh-safe] 插件安装失败（退出码 {code}），隔离状态保持不变。',
   repairDone: '[dsh-safe] 修复完成：跑 dsh-safe <启动命令> 验证；若仍失败会被自动重新隔离。',
+  repairFlagRemoved: '[dsh-safe] -r/--repair 已移除（0.15.0 起）：保活由包装启动全权承担（隔离重试 + duplicate 自愈）；修复用 dsh-safe repair --all，或交给 web UI 里的 AI agent 执行。',
+  ledgerReminder: '[dsh-safe] 提醒: 本 profile 有 {count} 个插件处于自动禁用状态（查看: dsh-safe list，修复: dsh-safe repair --all）',
+  bootQuarantineSummary: '[dsh-safe] 本次启动已自动禁用 {count} 个插件: {names}\n           查看: dsh-safe list    修复: dsh-safe repair --all    AI 解读: dsh-safe explain',
+  orphanBlockRemoved: '[dsh-safe] 已摘除孤儿托管区块：{count} 行禁用行在台账无对应记录（profile: {profile}）',
+  orphanBlockRemovedDry: '[dsh-safe] （dry-run）将摘除孤儿托管区块：{count} 行禁用行在台账无对应记录（profile: {profile}）',
+  listOrphanRow: '  - {id}（{name}）孤儿禁用行（托管区块有、台账无记录）',
+  listOrphanHint: '[dsh-safe] 孤儿禁用行不在台账里，repair/restore 不会碰它们；dsh-safe restore --profile <名> --all 可整体摘除',
 }
 
 const EN = {
@@ -174,8 +183,7 @@ Usage:
                                     upgrade dsh and dsh-safe itself, auto-restore quarantined plugins
   dsh-safe explain [id] [--profile <name> | --file <path>]  interpret with AI: last failure log / ledger / any log
   dsh-safe repair [id] [--all] [--profile <name>] [--to <ver>] [-y] [--dry-run]
-                                    reinstall/upgrade quarantined plugins and auto-restore (--all for batch; repairable failures only; omit id when there is exactly one record)
-  dsh-safe -r [dsh args…]            repair all repairable quarantined plugins, then boot (--repair alias)
+                                    reinstall/upgrade quarantined plugins and auto-restore (--all for batch; repairable failures only; omit id when there is exactly one record; hand it to the AI agent in the web UI)
   dsh-safe help                     show this help
   dsh-safe --version                show version
 
@@ -290,11 +298,14 @@ Notes:
   repairDuplicate: '[dsh-safe] duplicate-mount issue (id: {id}). One-command fix: dsh-safe repair {id} (removes the redundant source and restores automatically)',
   repairDuplicateManual: '[dsh-safe] duplicate-mount issue (the same id is mounted by multiple bundles/rows); reinstalling cannot fix it. Remove the redundant mount source from the profile bundles/patch, then run dsh-safe restore.',
   repairDedupePick: '[dsh-safe] {id} is mounted by the following bundles; which source to keep?',
-  repairDedupeDefault: ' (declared first in bundles; default keep)',
+  repairDedupeDefault: ' (default keep)',
   repairDedupeChoose: 'which one to keep? number [1]: ',
   repairDedupePlan: '[dsh-safe] fix plan: keep {keep} mounted, remove {remove} from bundles, and drop the disabled row for {id}',
   repairDedupeNoManifest: '[dsh-safe] the profile manifest has no editable bundles array; handle it manually.',
   repairDedupeDone: '[dsh-safe] dedupe finished: removed {removed} from bundles; {keep} stays mounted and the disabled row was dropped. Run dsh-safe <boot command> to verify.',
+  dedupeFirstPartyWarn: '[dsh-safe] warning: this plan removes official bundle(s) {bundles} (@deepseek-ai/*); everything else they mount goes offline too.',
+  dedupeFirstPartyConfirm: 'remove the official bundle(s)? (y/N) ',
+  dedupeFirstPartyBlocked: '[dsh-safe] dedupe skipped: the plan would remove official bundle(s) {bundles} (@deepseek-ai/*, protected by default). Edit the profile manifest bundles manually, or retry from an interactive terminal to confirm.',
   repairAllConflict: '[dsh-safe] --all and <id> are mutually exclusive.',
   repairUnknownArg: '[dsh-safe] unrecognized argument for repair: {arg}',
   repairBatchPlan: '[dsh-safe] repairing {count} quarantine record(s): {ids}',
@@ -302,6 +313,13 @@ Notes:
   repairBatchDone: '[dsh-safe] batch repair finished: {repaired} succeeded, {failed} failed.',
   repairInstallFailed: '[dsh-safe] plugin install failed (exit code {code}); quarantine state left unchanged.',
   repairDone: '[dsh-safe] repair finished: run dsh-safe <boot command> to verify; a still-broken plugin will be auto-quarantined again.',
+  repairFlagRemoved: '[dsh-safe] -r/--repair has been removed (since 0.15.0): the wrapped boot fully owns keep-alive (quarantine retries + duplicate self-heal); repair via `dsh-safe repair --all` or the AI agent in the web UI.',
+  ledgerReminder: '[dsh-safe] reminder: {count} plugin(s) are auto-disabled in this profile (inspect: dsh-safe list, repair: dsh-safe repair --all)',
+  bootQuarantineSummary: '[dsh-safe] auto-disabled {count} plugin(s) during this boot: {names}\n           inspect: dsh-safe list    repair: dsh-safe repair --all    interpret: dsh-safe explain',
+  orphanBlockRemoved: '[dsh-safe] stripped orphan managed block: {count} disabled row(s) absent from the ledger (profile: {profile})',
+  orphanBlockRemovedDry: '[dsh-safe] (dry-run) would strip orphan managed block: {count} disabled row(s) absent from the ledger (profile: {profile})',
+  listOrphanRow: '  - {id} ({name}) orphan disabled row (in managed block, absent from ledger)',
+  listOrphanHint: '[dsh-safe] orphan disabled rows are not in the ledger; repair/restore skip them — dsh-safe restore --profile <name> --all strips them all',
 }
 
 const CATALOG = { zh: ZH, en: EN }

package/lib/knownrows.js

@@ -64,6 +64,10 @@ export function collectKnownRows(profile) {
  * 把失败报告对照到真实存在的 patch 行。
  * 包名命中该包的全部行（一个包可能挂多个 id）；行 id 命中对应行。
  * 同一 id 在多层重复出现时，取合成顺序里最后出现的行（profile/托管区块覆盖 home/bundle）。
+ * 该行没有包名时，回退到同 id 其它层行声明的包名（合成顺序里最后一个非空者）：
+ * profile 覆盖行通常只写 config 不重述 name（如 webserver 的 host/port 覆盖），
+ * 若照搬本层行会把包名丢成 null，wrap 的第一方保护（@deepseek-ai/* 前缀）
+ * 随之失效、误禁官方插件。
  * @param {{ names: Array<[string, string]>, entryIds: Array<[string, string]> }} report
  * @param {{ rows: Array<{ id: string, name: string|null, disabled: boolean, file: string }> }} known
  * @returns {Array<{ id: string, name: string|null, disabled: boolean, file: string, line: string }>}
@@ -71,9 +75,11 @@ export function collectKnownRows(profile) {
 export function matchFailures(report, known) {
   const byId = new Map()
   const byName = new Map()
+  const nameById = new Map()
   for (const row of known.rows) {
     byId.set(row.id, row) // 同 id 后写覆盖
     if (row.name) {
+      nameById.set(row.id, row.name)
       if (!byName.has(row.name)) byName.set(row.name, [])
       byName.get(row.name).push(row)
     }
@@ -84,7 +90,7 @@ export function matchFailures(report, known) {
   }
   for (const [id, line] of report.entryIds) {
     const row = byId.get(id)
-    if (row) hits.set(row.id, { ...row, line })
+    if (row) hits.set(row.id, { ...row, name: row.name ?? nameById.get(id) ?? null, line })
   }
   return [...hits.values()]
 }

package/lib/patchfile.js

@@ -92,6 +92,21 @@ export function stripManagedBlocks(text) {
   return kept.join('\n').replace(/\n+$/, '')
 }
 
+/**
+ * 提取托管区块内的文本（首尾标记行之间，不含标记行）；没有区块返回 null。
+ * 用于发现"区块在、台账无记录"的孤儿禁用行（克隆 profile / 手删台账）。
+ * @param {string} text patch 文件内容
+ * @returns {string | null}
+ */
+export function managedBlockText(text) {
+  const lines = text.split(/\r?\n/)
+  const start = lines.findIndex((l) => l.trim() === MANAGED_START)
+  if (start < 0) return null
+  const end = lines.findIndex((l, i) => i > start && l.trim() === MANAGED_END)
+  if (end < 0) return null
+  return lines.slice(start + 1, end).join('\n')
+}
+
 /**
  * 在 patch 文本上应用托管区块：先移除旧区块，再追加新区块（block 为 null 只移除）。
  *

package/lib/repair.js

@@ -1,5 +1,5 @@
 /**
- * @hyzyn/dsh-safe — `dsh-safe repair` 与 `dsh-safe -r`：修复被隔离的插件。
+ * @hyzyn/dsh-safe — `dsh-safe repair`：修复被隔离的插件。
  *
  * repair 可修复的失败特征：问题出在"包的安装状态或版本适配"上，重装/升级
  * 插件包可能修复——
@@ -8,67 +8,80 @@
  *     当前 dsh API 版本不兼容，升级插件到适配版本可能修复（真实案例：
  *     describe-image 隔离于 dsh-settings 导出变更）。修复失败不恢复、无损。
  * 注意：台账 reason 经 summarizeLine 截断过（160 字符），关键短语可能被
- * "…" 切断，因此导出不匹配的特征只匹配到 "does not provide an" 为止。
+ * "…" 切断，因此导出不匹配的特征只匹配到 "does not provide an" 为止；
+ * 但 id/包名特别长时（如 dsh-client-ui-web-ui-settings）连这个短语都会被
+ * 切掉，只剩 "does not p…"——所以再补 "The requested module"（ESM 具名
+ * 导出报错的固定开头，位置靠前不会被截掉）。
  *
  * duplicate（同一 id 被多个 bundle 挂载）是配置层问题，重装无意义——但
- * 支持自动去重：从 profile 清单的 bundles 移除一个来源（交互选择保留哪个，
- * -y 保留先声明者），并摘除无效的禁用行。include 子文件里的重复不在
- * bundle 层对照表内，自动去重帮不上，给手动指引。
+ * 支持自动去重（见 dedupe.js）：从 profile 清单的 bundles 移除一个来源
+ * （交互选择保留哪个；非交互缺省保留官方 bundle，否则保留先声明者；移除
+ * 官方 bundle 受第一方守卫约束），并摘除无效的禁用行。include
+ * 子文件里的重复不在 bundle 层对照表内，自动去重帮不上，给手动指引。
  *
  * 安装路径修复完成后会复查该 id 的挂载来源：修复的插件若同时被聚合包等
  * 其它 bundle 挂载，恢复后下次启动会 duplicate——自动去重防复发。
+ * 注意 dsh 会在每次 plugin add 时把 dependencies 里的 bundle 型包重新
+ * reconcile 进 bundles，去重成果可能被复活——包装启动的自愈（wrap.js）
+ * 与本命令的预检都会再次兜住。
  *
- * `--all` 批量修复台账里全部可修复记录；`-r/--repair` = 批量修复 + 启动
- * （与 -u 对称：位置参数全部是 dsh 启动参数）。
+ * `--all` 批量修复台账里全部可修复记录（含未入账 duplicate 预检）。
+ * （0.15.0 起 `-r/--repair` 组合命令已移除：保活全部由包装启动承担——隔离
+ * 重试与 duplicate 自愈见 wrap.js；修复交给 repair 原语，由用户手动调用
+ * 或 web UI 里的 AI agent 执行。）
  */
 import { spawnSync } from 'node:child_process'
 import { createInterface } from 'node:readline/promises'
-import { readFileSync, writeFileSync } from 'node:fs'
 import { loadLedger, restoreQuarantine } from './quarantine.js'
 import { summarizeLine } from './failures.js'
-import { profileManifestPath, readIfExists, resolveDshSpawnTarget } from './dshpaths.js'
+import { profileDirs, resolveDshSpawnTarget } from './dshpaths.js'
 import { collectKnownRows } from './knownrows.js'
+import { dedupeMountSources } from './dedupe.js'
 import { t } from './i18n.js'
 
 const err = (line) => process.stderr.write(`${line}\n`)
 const out = (line) => process.stdout.write(`${line}\n`)
 
 const REPAIRABLE_RE =
-  /Cannot find package|could not be resolved|ERR_MODULE_NOT_FOUND|does not provide an( (?:export|import binding))?/i
+  /Cannot find package|could not be resolved|ERR_MODULE_NOT_FOUND|The requested module|does not provide an( (?:export|import binding))?/i
 const DUPLICATE_RE = /duplicate loader entry id/i
 
 const isRepairable = (reason) => REPAIRABLE_RE.test(reason ?? '') || DUPLICATE_RE.test(reason ?? '')
 
-const readJsonIfExists = (path) => {
-  const raw = readIfExists(path)
-  if (raw === undefined) return undefined
-  try {
-    return JSON.parse(raw)
-  } catch {
-    return undefined
+/**
+ * 预检未入账的 duplicate：duplicate 失败不产生台账条目（0.12.1 起的设计），
+ * 只能按挂载来源发现——某 profile 下该 id 被 ≥2 个 bundle 挂载即视为目标。
+ * @param {Array<{ profile: string, entry: { id: string } }>} targets 已收集的修复目标（其中的 id 视为已入账，不重复预检）
+ * @param {string=} profileFilter 指定 profile 时只扫它
+ * @param {{ allProfiles?: boolean }} [opts] 无 profileFilter 时是否补扫全部 profile 目录（repair --all 用）
+ * @returns {Array<{ profile: string, entry: { id: string, name: string|null, reason: string } }>}
+ */
+function findUnledgeredDuplicates(targets, profileFilter, { allProfiles = false } = {}) {
+  const ledgerIds = new Map()
+  for (const t of targets) {
+    if (!ledgerIds.has(t.profile)) ledgerIds.set(t.profile, new Set())
+    ledgerIds.get(t.profile).add(t.entry.id)
   }
-}
-
-/** 该 id 的 bundle 挂载来源（profile/home 层是 override，不算挂载来源）。 */
-function bundleMountSources(known, id) {
-  return [
-    ...new Set(
-      known.rows.filter((r) => r.id === id && r.source !== 'profile' && r.source !== 'home').map((r) => r.source),
-    ),
-  ]
-}
-
-/** 从 profile 清单的 bundles 数组移除指定来源；没有变化返回 false。 */
-function removeFromManifestBundles(profile, removeNames) {
-  const manifestPath = profileManifestPath(profile)
-  const manifest = readJsonIfExists(manifestPath)
-  const current = manifest?.dsh?.profile?.bundles
-  if (!Array.isArray(current)) return false
-  const next = current.filter((b) => !removeNames.includes(b))
-  if (next.length === current.length) return false
-  manifest.dsh.profile.bundles = next
-  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
-  return true
+  const scanProfiles = profileFilter
+    ? [profileFilter]
+    : [...new Set([...targets.map((t) => t.profile), ...(allProfiles ? profileDirs() : [])])]
+  const found = []
+  for (const p of scanProfiles) {
+    const known = collectKnownRows(p)
+    const byId = new Map()
+    for (const row of known.rows) {
+      if (row.source === 'profile' || row.source === 'home') continue
+      if (!byId.has(row.id)) byId.set(row.id, new Set())
+      byId.get(row.id).add(row.source)
+    }
+    const ledgered = ledgerIds.get(p) ?? new Set()
+    for (const [dupId, srcs] of byId) {
+      if (srcs.size < 2 || ledgered.has(dupId)) continue
+      const nameRow = known.rows.find((r) => r.id === dupId)
+      found.push({ profile: p, entry: { id: dupId, name: nameRow?.name ?? null, reason: 'duplicate loader entry id' } })
+    }
+  }
+  return found
 }
 
 function askConfirm(question) {
@@ -94,51 +107,25 @@ function askConfirm(question) {
 async function repairEntry({ profile, entry, to = undefined, yes = false, tty = true, dryRun = false, spawn = spawnSync, log = err, write = out }) {
   const id = entry.id
 
-  // duplicate：自动去重（多 bundle 来源），来源不足给手动指引
+  // duplicate：自动去重（多 bundle 来源），来源不足给手动指引；
+  // 保留方案涉及官方 bundle 时被 dedupe 的第一方守卫拒绝（原因由其打印）
   if (DUPLICATE_RE.test(entry.reason ?? '')) {
-    const sources = bundleMountSources(collectKnownRows(profile), id)
-    if (sources.length < 2) {
-      log(t('repairDuplicateManual'))
-      return { code: 1, outcome: 'skipped' }
+    const res = await dedupeMountSources(profile, id, { yes, tty, dryRun, log })
+    if ('error' in res) {
+      if (res.error === 'no-manifest') log(t('repairDedupeNoManifest'))
+      else if (res.error !== 'first-party') log(t('repairDuplicateManual'))
+      return { code: 1, outcome: res.error === 'no-manifest' ? 'failed' : 'skipped' }
     }
-    const manifest = readJsonIfExists(profileManifestPath(profile))
-    const declared = manifest?.dsh?.profile?.bundles
-    const ordered = Array.isArray(declared)
-      ? [...sources].sort(
-          (a, b) =>
-            (declared.indexOf(a) < 0 ? 999 : declared.indexOf(a)) - (declared.indexOf(b) < 0 ? 999 : declared.indexOf(b)),
-        )
-      : sources
-    let keep = ordered[0]
-    if (!yes && !dryRun) {
-      if (!tty) {
-        log(t('updateNonInteractive'))
-        return { code: 1, outcome: 'failed' }
-      }
-      const rl = createInterface({ input: process.stdin, output: process.stderr })
-      log(t('repairDedupePick', { id }))
-      ordered.forEach((b, i) => log(`${i + 1}. ${b}${i === 0 ? t('repairDedupeDefault') : ''}`))
-      const answer = await rl.question(t('repairDedupeChoose'))
-      rl.close()
-      const pick = Math.min(Math.max(parseInt(answer, 10) || 1, 1), ordered.length)
-      keep = ordered[pick - 1]
-    }
-    const remove = ordered.filter((b) => b !== keep)
-    log(t('repairDedupePlan', { keep, remove: remove.join(', '), id }))
     if (dryRun) {
       log(t('dryRunNotice'))
       return { code: 0, outcome: 'deduped' }
     }
-    if (!removeFromManifestBundles(profile, remove)) {
-      log(t('repairDedupeNoManifest'))
-      return { code: 1, outcome: 'failed' }
-    }
     const { restored } = restoreQuarantine(profile, [id], false)
     if (restored.length) {
       const e = restored[0]
       write(`[dsh-safe] ${t('restored')} ${e.name ?? e.id} (id: ${e.id})`)
     }
-    log(t('repairDedupeDone', { removed: remove.join(', '), keep }))
+    log(t('repairDedupeDone', { keep: res.kept, removed: res.removed.join(', ') }))
     log(t('repairDone'))
     return { code: 0, outcome: 'deduped' }
   }
@@ -178,32 +165,10 @@ async function repairEntry({ profile, entry, to = undefined, yes = false, tty =
   }
 
   // 防复发：修复的插件若同时被多个 bundle 挂载（如聚合包已内置同一插件），
-  // 恢复后下次启动会 duplicate——自动去重（交互选择保留来源，-y 保留先声明者）
-  const knownAfter = collectKnownRows(profile)
-  const sources = bundleMountSources(knownAfter, id)
-  if (sources.length >= 2) {
-    const manifest = readJsonIfExists(profileManifestPath(profile))
-    const declared = manifest?.dsh?.profile?.bundles
-    const ordered = Array.isArray(declared)
-      ? [...sources].sort(
-          (a, b) =>
-            (declared.indexOf(a) < 0 ? 999 : declared.indexOf(a)) - (declared.indexOf(b) < 0 ? 999 : declared.indexOf(b)),
-        )
-      : sources
-    let keep = ordered[0]
-    if (!yes) {
-      const rl = createInterface({ input: process.stdin, output: process.stderr })
-      log(t('repairDedupePick', { id }))
-      ordered.forEach((b, i) => log(`${i + 1}. ${b}${i === 0 ? t('repairDedupeDefault') : ''}`))
-      const answer = await rl.question(t('repairDedupeChoose'))
-      rl.close()
-      const pick = Math.min(Math.max(parseInt(answer, 10) || 1, 1), ordered.length)
-      keep = ordered[pick - 1]
-    }
-    const removed = ordered.filter((b) => b !== keep)
-    if (removeFromManifestBundles(profile, removed)) {
-      log(t('repairDedupeDone', { removed: removed.join(', '), keep }))
-    }
+  // 恢复后下次启动会 duplicate——自动去重（缺省保留官方来源，否则先声明来源）
+  const res = await dedupeMountSources(profile, id, { yes, tty, log })
+  if (!('error' in res)) {
+    log(t('repairDedupeDone', { keep: res.kept, removed: res.removed.join(', ') }))
   }
 
   log(t('repairDone'))
@@ -247,7 +212,8 @@ function collectTargets(opts, ledger) {
   return matches
 }
 
-/** 批量修复：一次确认，逐条执行，汇总结果。返回失败的条数。 */
+/** 批量修复：一次确认，逐条执行，汇总结果。返回 { failed, repaired, done }，
+ * done 只收安装修复成功的条目（去重成功不算——去重后暴露出的新失败仍值得再修）。 */
 async function repairBatch(targets, { to = undefined, yes = false, dryRun = false, spawn = spawnSync, log = err, write = out }) {
   const repairable = targets.filter((t) => isRepairable(t.entry.reason))
   const unsupported = targets.filter((t) => !repairable.includes(t))
@@ -265,28 +231,33 @@ async function repairBatch(targets, { to = undefined, yes = false, dryRun = fals
       await repairEntry({ profile: t.profile, entry: t.entry, to: to, yes: true, tty: true, dryRun: true, spawn, log, write })
     }
     log(t('dryRunNotice'))
-    return { failed: 0 }
+    return { failed: 0, repaired: 0, done: [] }
   }
   if (!yes) {
     if (!process.stdin.isTTY) {
       log(t('updateNonInteractive'))
-      return { failed: targets.length }
+      return { failed: targets.length, repaired: 0, done: [] }
     }
     const ok = await askConfirm(t('updateConfirm'))
     if (!ok) {
       log(t('updateAborted'))
-      return { failed: 0 }
+      return { failed: 0, repaired: 0, done: [] }
     }
   }
   let repaired = 0
   let failed = 0
+  const done = []
   for (const t of repairable) {
-    const { code } = await repairEntry({ profile: t.profile, entry: t.entry, to: to, yes: true, tty: true, spawn, log, write })
-    if (code === 0) repaired++
-    else failed++
+    const { code, outcome } = await repairEntry({ profile: t.profile, entry: t.entry, to: to, yes: true, tty: true, spawn, log, write })
+    if (code === 0) {
+      repaired++
+      if (outcome === 'repaired') done.push({ profile: t.profile, id: t.entry.id })
+    } else {
+      failed++
+    }
   }
   log(t('repairBatchDone', { repaired, failed }))
-  return { failed }
+  return { failed, repaired, done }
 }
 
 /**
@@ -312,8 +283,10 @@ export async function cmdRepair(args, { spawn = spawnSync, log = err, write = ou
   const ledger = loadLedger()
   const matches = collectTargets(opts, ledger)
 
-  // --all：批量修复（一次确认，默认策略）
+  // --all：批量修复（一次确认，默认策略）；先预检未入账的 duplicate
+  // （与包装启动的自愈对齐：duplicate 不产生台账条目，台账为空也可能有修复目标）
   if (opts.all) {
+    matches.push(...findUnledgeredDuplicates(matches, opts.profile, { allProfiles: true }))
     if (!matches.length) {
       log(t('noRecords'))
       return 0
@@ -342,27 +315,9 @@ export async function cmdRepair(args, { spawn = spawnSync, log = err, write = ou
   if (!matches.length) {
     // duplicate 类失败不会产生台账条目（0.12.1 起的设计）——台账查无记录时，
     // 按挂载来源直接支持去重：该 id 被 ≥2 个 bundle 挂载即视为重复挂载目标。
-    const candidates = opts.profile
-      ? [opts.profile]
-      : (() => {
-          try {
-            return readdirSync(join(dshHome(), 'profiles'), { withFileTypes: true })
-              .filter((e) => e.isDirectory())
-              .map((e) => e.name)
-          } catch {
-            return []
-          }
-        })()
-    for (const p of candidates) {
-      if (bundleMountSources(collectKnownRows(p), opts.id).length >= 2) {
-        const rows = collectKnownRows(p).rows.filter((r) => r.id === opts.id)
-        matches.push({
-          profile: p,
-          entry: { id: opts.id, name: rows[0]?.name ?? null, reason: 'duplicate loader entry id' },
-        })
-        break
-      }
-    }
+    // 不指定 --profile 时扫全部 profile 目录（与修复目标跨 profile 的语义一致）。
+    const dup = findUnledgeredDuplicates([], opts.profile, { allProfiles: true }).find((m) => m.entry.id === opts.id)
+    if (dup) matches.push(dup)
   }
   if (!matches.length) {
     log(t('repairEntryMissing', { id: opts.id }))
@@ -388,85 +343,3 @@ export async function cmdRepair(args, { spawn = spawnSync, log = err, write = ou
   const { code } = await repairEntry({ profile, entry, to: opts.to, yes: opts.yes || !opts.dryRun ? true : false, tty: true, dryRun: opts.dryRun, spawn, log, write })
   return code
 }
-
-/**
- * `-r/--repair [dsh 参数…]`：批量修复全部可修复的隔离记录，再按包装模式
- * 启动（与 -u 对称：位置参数全部是 dsh 启动参数）。
- * @param {string[]} args
- * @param {{
- *   spawn?: typeof spawnSync,
- *   boot?: (args: string[]) => Promise<number>,
- *   log?: (line: string) => void,
- *   write?: (line: string) => void,
- *   isTTY?: boolean,
- *   readStdin?: never,
- * }} [hooks]
- * @returns {Promise<number>} 退出码
- */
-export async function cmdRepairAndBoot(args, { boot, spawn = spawnSync, log = err, write = out, isTTY = process.stdin.isTTY } = {}) {
-  if (args.includes('-h') || args.includes('--help')) {
-    out(t('helpText', {}))
-    return 0
-  }
-  // 位置参数全部是 dsh 启动参数（修全部可修复记录）；前缀旗标为 repair 选项
-  const opts = { profile: undefined, to: undefined, yes: false, dryRun: false }
-  let i = 0
-  for (; i < args.length; i++) {
-    const a = args[i]
-    if (a === '-y' || a === '--yes') opts.yes = true
-    else if (a === '--dry-run') opts.dryRun = true
-    else if (a === '--profile' && args[i + 1] !== undefined) opts.profile = args[++i]
-    else if (a.startsWith('--profile=')) opts.profile = a.slice('--profile='.length)
-    else if (a === '--to' && args[i + 1] !== undefined) opts.to = args[++i]
-    else if (a.startsWith('--to=')) opts.to = a.slice('--to='.length)
-    else break
-  }
-  if (opts.to !== undefined && !/^[\w.+-]+$/.test(opts.to)) {
-    log(t('updateToInvalid'))
-    return 2
-  }
-  const bootArgs = args.slice(i)
-
-  const ledger = loadLedger()
-  const targets = []
-  for (const [profile, entries] of Object.entries(ledger.profiles)) {
-    if (opts.profile && profile !== opts.profile) continue
-    for (const entry of entries ?? []) targets.push({ profile, entry })
-  }
-
-  // 预检：duplicate 失败不产生台账条目——按挂载来源找出未入账的重复挂载，
-  // 并入修复目标（否则 -r 对这类 profile 空手而归）
-  const scanProfiles = opts.profile ? [opts.profile] : [...new Set(targets.map((t) => t.profile))]
-  for (const p of scanProfiles) {
-    const known = collectKnownRows(p)
-    const ledgerIds = new Set(targets.filter((t) => t.profile === p).map((t) => t.entry.id))
-    const byId = new Map()
-    for (const row of known.rows) {
-      if (row.source === 'profile' || row.source === 'home') continue
-      if (!byId.has(row.id)) byId.set(row.id, new Set())
-      byId.get(row.id).add(row.source)
-    }
-    for (const [dupId, srcs] of byId) {
-      if (srcs.size < 2 || ledgerIds.has(dupId)) continue
-      const nameRow = known.rows.find((r) => r.id === dupId)
-      targets.unshift({ profile: p, entry: { id: dupId, name: nameRow?.name ?? null, reason: 'duplicate loader entry id' } })
-    }
-  }
-
-  // --profile 同时作用于修复与启动：启动参数未显式给 --profile 时自动补上
-  const finalBootArgs =
-    opts.profile && !bootArgs.some((a) => a === '--profile' || a.startsWith('--profile='))
-      ? ['--profile', opts.profile, ...bootArgs]
-      : bootArgs
-
-  if (!targets.length) {
-    log(t('noRecords'))
-    if (bootArgs.length) return boot(finalBootArgs)
-    return 0
-  }
-
-  const { failed } = await repairBatch(targets, { to: opts.to, yes: opts.yes, dryRun: opts.dryRun, spawn, log, write })
-
-  if (bootArgs.length) return boot(finalBootArgs)
-  return failed ? 1 : 0
-}

package/lib/wrap.js

@@ -4,8 +4,10 @@
  * 运行 dsh（stderr 进管道并同步回显），进程退出后：
  *   - 正常退出（0）→ 结束；
  *   - 失败退出 → 从 stderr 解析坏插件，对照 patch 行后把对应行置为 disabled
- *     （写入托管区块 + 台账），然后重试；识别不出、超过重试上限、或命中
- *     第一方插件（@deepseek-ai/*，默认保护）时原样透传退出码。
+ *     （写入托管区块 + 台账），然后重试；duplicate loader entry id 是禁用行
+ *     管不住的硬失败，自动去重冗余来源后重试（去重同样受第一方保护，见
+ *     dedupe.js）；识别不出、超过重试上限、或命中第一方插件（@deepseek-ai/*，
+ *     默认保护）时原样透传退出码。
  *
  * Windows 上经 resolveDshSpawnTarget 把 dsh 的 .cmd shim 解析成 `node <入口>`
  * 再启动（见 dshpaths.js），其余平台原样 spawn。
@@ -16,15 +18,13 @@ import { dirname } from 'node:path'
 import { summarizeLine, parseFailureReport } from './failures.js'
 import { collectKnownRows, matchFailures } from './knownrows.js'
 import { detectInvocation, lastFailureFile, resolveDshSpawnTarget } from './dshpaths.js'
-import { writeQuarantine } from './quarantine.js'
+import { loadLedger, writeQuarantine } from './quarantine.js'
+import { dedupeMountSources, isFirstParty } from './dedupe.js'
 import { loadConfig } from './config.js'
 import { aiEnabled, detectFailureWithAI } from './ai.js'
 import { t } from './i18n.js'
 
 const CAPTURE_LIMIT = 512 * 1024
-const FIRST_PARTY_PREFIX = '@deepseek-ai/'
-
-const isFirstParty = (name) => typeof name === 'string' && name.startsWith(FIRST_PARTY_PREFIX)
 
 /** 启动失败时把捕获的 stderr 存到 last-failure-<profile>.log（供 explain 默认解读与人工翻阅）。 */
 function persistFailure(profile, stderr) {
@@ -105,9 +105,26 @@ export async function runWrapped(options) {
     detect = null,
   } = options
   const invocation = detectInvocation(forwardArgs)
+  // 台账非空提醒：让"有插件处于自动禁用状态"在每次启动都可见（否则用户
+  // 只会感知到"某个功能没了"，不知道是隔离造成的、也不知道怎么恢复）
+  if (!dryRun && invocation.profile) {
+    const count = (loadLedger().profiles[invocation.profile] ?? []).length
+    if (count) log(t('ledgerReminder', { count }))
+  }
+  const quarantined = [] // 本次运行期间被自动禁用的插件（成功后汇总）
   for (let attempt = 0; ; attempt++) {
     const { code, stderr } = await spawnFn(forwardArgs)
-    if (code === 0) return 0
+    if (code === 0) {
+      if (quarantined.length) {
+        log(
+          t('bootQuarantineSummary', {
+            count: quarantined.length,
+            names: quarantined.map((target) => target.name ?? target.id).join(', '),
+          }),
+        )
+      }
+      return 0
+    }
     if (invocation.mode === 'plugin') {
       log(t('pluginPassthrough'))
       return code
@@ -119,10 +136,27 @@ export async function runWrapped(options) {
     if (!dryRun) persistFailure(invocation.profile, stderr)
     // 重复挂载（同一 id 被多个 bundle/行挂载）发生在 include 挂载阶段，
     // 早于 profile 层 disabled 覆盖的合并——禁用行管不住它，隔离无效。
-    // 给出一键修复指引（repair 会移除冗余来源并恢复）并透传。
+    // 自动去重（交互选来源 / 非交互保留先声明者）后重试；识别不出可去重
+    // 来源（扫描器盲区）、dry-run 或超过重试上限时给一键修复指引并透传。
     if (stderr.includes('duplicate loader entry id')) {
       const m = /duplicate loader entry id: ([\w:\-]+)/.exec(stderr)
-      log(t('repairDuplicate', { id: m ? m[1] : '' }))
+      const dupId = m ? m[1] : ''
+      let fixed = null
+      if (!dryRun && attempt < maxRetries) {
+        const res = await dedupeMountSources(invocation.profile, dupId, {
+          tty: process.stdin.isTTY,
+          log,
+          allowFirstParty,
+        })
+        if (!('error' in res)) fixed = res
+      }
+      if (fixed) {
+        log(t('repairDedupeDone', { keep: fixed.kept, removed: fixed.removed.join(', ') }))
+        log(t('retrying'))
+        continue
+      }
+      if (!dryRun && attempt >= maxRetries) log(t('maxRetriesReached', { count: maxRetries }))
+      log(t('repairDuplicate', { id: dupId }))
       log(t('explainHint'))
       return code
     }
@@ -167,6 +201,7 @@ export async function runWrapped(options) {
       file: hit.file,
     }))
     writeQuarantine(invocation.profile, targets, dryRun)
+    quarantined.push(...targets)
     for (const target of targets) {
       const verb = t(dryRun ? 'willDisable' : 'disabled')
       log(`[dsh-safe] ${verb} ${target.name ?? target.id} (id: ${target.id}) → ${target.file}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyzyn/dsh-safe",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "description": "dsh 启动保险丝：社区插件不兼容导致 dsh 启动失败时，自动禁用坏插件并重试",
   "type": "module",
   "license": "MIT",