dsh-config-manager 0.1.76 → 0.1.78

package/src/core/types.ts

@@ -147,6 +147,25 @@ export interface ExportUnit {
    * 只下发**事实**，不下发文案 —— 界面按当前语言显示（与 DSH 同口径），绝不用 uuid 冒充标题。
    */
   blank?: boolean;
+  /**
+   * 该插件**声明的第三方数据区域**（只有 \`plugin:<包名>\` 单元可能有值；导出选择器「按插件看」用）。
+   *
+   * 用途：选择器要在**不读任何数据目录**的前提下画出「插件 → 数据目录 / 大文件」的树骨架 ——
+   * 区域清单来自来源注册表（内置来源表 + 插件自述 dsh.dataDirs），是静态知识，零额外 I/O；
+   * 体积与「实际有没有内容」等该分区的清单到货后再填。
+   *
+   * 语义：**纯展示**，不参与勾选/导出契约（契约只认 id）。这里是「注册表说它应该在哪儿」，
+   * **不是**「磁盘上确实有」—— 界面必须把两者分开渲染（unread / 无内容 / 已读到）。
+   */
+  relatedAreas?: readonly PluginAreaRef[];
+}
+
+/** 插件数据区域引用（pluginData / pluginAssets；只读展示用，不参与勾选契约）。 */
+export interface PluginAreaRef {
+  section: 'pluginData' | 'pluginAssets';
+  /** home 相对 POSIX 路径 —— 就是该分区单元的 id 后缀（\`pluginData:.mnemon/runtime\` 的末段） */
+  relPath: string;
+  role: 'config' | 'assets';
 }
 
 export interface ValidationResult {
@@ -215,6 +234,16 @@ export interface PluginInfo {
   inBundles?: string[];
   /** 声明依赖 spec（profile package.json dependencies 原样）；文件视图来自 readInstalled */
   spec?: string;
+  /**
+   * 只在 `dsh.profile.bundles` 里声明、`dependencies` 里没有该包，且本 profile 的
+   * `node_modules` 里也没有它的落盘副本（issue #95）。
+   *
+   * DSH 对这类层从**自己的安装位置**解析（`boot-safety.ts` 的「@deepseek-ai/* 由 DSH 从它自己的
+   * 安装位置解析」与 `RESCUE_KEEP_BUNDLE_PREFIXES` 同一口径），因此导入端**不得**把它当
+   * registry 依赖去 `dsh plugin add`：那会把 npm dist-tag `latest` 的副本装进目标 profile，
+   * 与 host 的版本线脱节（issue #95 的真机故障）。只能把名字声明进目标机的 bundles。
+   */
+  bundlesOnly?: boolean;
 }
 
 export interface PluginsFacade {

package/src/index.facade.test.ts

@@ -427,6 +427,66 @@ test('回退 fork：原会话自己就不在任何工作区时，按**子会话
   )
   assert.deepEqual(membersOf(project), ['someone-else', 'child-cwd'], '只对同目录的那一条调 attachSession')
   assert.deepEqual(membersOf(otherDir), [], '不同目录的工作区一个字节都不许写')
+
+test('回退 fork（2026-10-17 真机）：子会话还没进活会话服务 ⇒ 按**落盘 header** 的 cwd 归位（与 DSH 自己的 readSessionHeader 同源回落）', async () => {
+  const project = workspaceFixture({ id: 'ws-a', path: 'D:/proj/a', sessionIds: [] })
+  const facade = new DshSessionStoreFacade(storeCtx({
+    sessionController: { fork: async () => ({ sessionId: 'child-stored' }) },
+    // 活会话服务里**没有**这个子会话（fork 刚返回、索引还没就绪）——修复前这里直接 cwd-unavailable
+    sessions: { get: () => undefined },
+    sessionPersistence: { list: async () => [{ header: { id: 'child-stored', cwd: 'D:/proj/a' } }] },
+    workspaceRegistry: { list: () => [project] },
+  }), 'C:/home/.dsh', zhMsg, silentLogger(), async (p) => canonicalPath(p))
+
+  assert.deepEqual(
+    await facade.forkSession('parent-nowhere', 5),
+    { childSessionId: 'child-stored' },
+    '落盘 header 读得到 cwd ⇒ 必须归位（修复前报 workspace-attach-failed:cwd-unavailable ⇒ 侧栏「未分组」）',
+  )
+  assert.deepEqual(membersOf(project), ['child-stored'])
+})
+
+test('回退 fork（2026-10-17 真机）：子会话 header 读不出 cwd ⇒ 用**父会话 cwd** 归位（DSH 的 fork 逐字继承父 header.cwd）', async () => {
+  const project = workspaceFixture({ id: 'ws-a', path: 'D:/proj/a', sessionIds: [] })
+  const facade = new DshSessionStoreFacade(storeCtx({
+    sessionController: { fork: async () => ({ sessionId: 'child-nocwd' }) },
+    sessions: {
+      get: (id: string) => {
+        if (id === 'child-nocwd') return { header: { id } }
+        if (id === 'parent-1') return { header: { id, cwd: 'D:/proj/a' } }
+        return undefined
+      },
+    },
+    workspaceRegistry: { list: () => [project] },
+  }), 'C:/home/.dsh', zhMsg, silentLogger(), async (p) => canonicalPath(p))
+
+  assert.deepEqual(await facade.forkSession('parent-1', 5), { childSessionId: 'child-nocwd' })
+  assert.deepEqual(membersOf(project), ['child-nocwd'], '父 cwd 与工作区同目录 ⇒ 必须归位（同源事实，不是猜测）')
+})
+
+test('回退 fork：两条 cwd 来源都拿不到 ⇒ 如实失败，并把**具体理由**落一行可查的归位诊断（桌面版拿不到宿主 stdout）', async () => {
+  const home = mkdtempSync(join(tmpdir(), 'dcm-attach-diag-'))
+  try {
+    const project = workspaceFixture({ id: 'ws-a', path: 'D:/proj/a', sessionIds: [] })
+    const facade = new DshSessionStoreFacade(storeCtx({
+      sessionController: { fork: async () => ({ sessionId: 'child-lost' }) },
+      sessions: { get: () => undefined },
+      workspaceRegistry: { list: () => [project] },
+    }), home, zhMsg, silentLogger(), async (p) => canonicalPath(p))
+
+    assert.deepEqual(await facade.forkSession('parent-nowhere', 5), {
+      childSessionId: 'child-lost',
+      warning: 'workspace-attach-failed:cwd-unavailable',
+    })
+    const log = readFileSync(join(home, 'dsh-config-manager', 'logs', 'rewind-workspace-attach.jsonl'), 'utf8')
+    assert.match(log, /"childId":"child-lost"/)
+    assert.match(log, /"reason":"cwd-unavailable"/)
+    assert.match(log, /child\(/, 'detail 必须带子会话那一侧的读取细节，光有理由码不够排查')
+  } finally {
+    rmSync(home, { recursive: true, force: true })
+  }
+})
+
 })
 
 test('t10 ③ 档（修复前必红）：cwd 与工作区 path 仅大小写/分隔符/短名不同 —— 由 DSH 的 resolveByPath 判同一目录后仍归位', async () => {

package/src/index.ts

@@ -39,6 +39,7 @@ import { randomBytes } from 'node:crypto'
 import { execFile } from 'node:child_process'
 import { createWriteStream, existsSync, mkdirSync, readFileSync } from 'node:fs'
 import fs from 'node:fs/promises'
+import path from 'node:path'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path'
 import { homedir } from 'node:os'
@@ -78,7 +79,8 @@ import { RunRegistry, type RunState } from './core/run-registry.ts'
 import { registerModelTools } from './core/model-tools.ts'
 import { msgOf, zhMsg } from './core/messages.ts'
 import { engineMsg, getEngineLocale, setEngineLanguageSource, setEngineLocale } from './core/engine-locale.ts'
-import { RollbackAutoTracker, RollbackPointEngine, rollbackSessionBindingOf, rollbackTrackedEventOf } from './core/rollback-point.ts'
+import { RollbackAutoTracker, RollbackPointEngine, ROLLBACK_POINTS_DIR_NAME, rollbackSessionBindingOf, rollbackTrackedEventOf } from './core/rollback-point.ts'
+import { ROLLBACK_ATTRIBUTION_FILE_NAME, RollbackWriteAttribution } from './core/rollback-attribution.ts'
 import { isRollbackEnabled, onRollbackEnabledChange, setRollbackEnabled } from './core/rollback-gate.ts'
 import type { RollbackForkCarrier, RollbackRewindResult } from './core/rollback-point.ts'
 // t3：宿主斜杠命令 /rollback（与 HTTP 路由同一道写入门；命令服务惰取，未组合时安静跳过）。
@@ -179,7 +181,7 @@ export const name = 'config-manager'
 export const inject = ['settings', 'credentials']
 
 /** Plugin version, kept in sync with package.json ("version"). */
-export const PLUGIN_VERSION = '0.1.76'
+export const PLUGIN_VERSION = '0.1.78'
 
 /** Plugin own package name — excluded from its own exported plugins list. */
 const PLUGIN_NAME = 'dsh-config-manager'
@@ -807,12 +809,13 @@ type ListedSessions =
   | { ok: false; reason: 'unavailable' | 'shape-unknown'; detail: string }
 
 /** 列举会话存储的用途（内部枚举；渲染时必须经字典键映射 —— **绝不把裸枚举塞进文案**）。 */
-type SessionStorePurpose = 'reindexSessionHeader' | 'parentRelations'
+type SessionStorePurpose = 'reindexSessionHeader' | 'parentRelations' | 'rewindWorkspaceAttach'
 
 /** 用途 → 字典键（本仓纪律：文案只做「原因 → 字典键」映射，禁止渲染裸枚举）。 */
 const SESSION_STORE_PURPOSE_KEY: Record<SessionStorePurpose, string> = {
   reindexSessionHeader: 'host.sessionStorePurposeReindex',
   parentRelations: 'host.sessionStorePurposeParentRelations',
+  rewindWorkspaceAttach: 'host.sessionStorePurposeRewindAttach',
 }
 
 /**
@@ -897,6 +900,16 @@ export interface WorkspaceAttachFailure {
 /** 一次 `attachSession` 尝试（只表达「写调用是否成功」，最终判据在 {@link DshSessionStoreFacade} 的复核里）。 */
 type AttachAttempt = { ok: true } | { ok: false; reason: 'attach-session-missing' | 'attach-rejected'; detail?: string }
 
+/**
+ * 会话 cwd 的读取结果（**多源**：活会话 → 宿主会话存储列举）。
+ *
+ * `source` 只用于诊断与日志（live = `ctx.get('sessions').get(id).header`；stored = `sessionPersistence.list()`），
+ * 调用方**不得**据此改变归位判据 —— 两个来源读的都是 DSH 自己写下的同一个 header.cwd。
+ */
+type SessionCwdLookup =
+  | { ok: true; cwd: string; source: 'live' | 'stored' }
+  | { ok: false; detail: string }
+
 /** 一次工作区归位的结果（成功/失败都带**具体**理由）。 */
 export type WorkspaceAttachOutcome =
   | { ok: true; reason: WorkspaceAttachSuccessReason; workspaceId?: string }
@@ -905,6 +918,20 @@ export type WorkspaceAttachOutcome =
 /** 归位失败时给调用方的 warning 串（稳定前缀 + 具体理由码）。 */
 export const WORKSPACE_ATTACH_FAILED_PREFIX = 'workspace-attach-failed'
 
+/**
+ * 归位失败后的重试次数与间隔（毫秒）。
+ *
+ * 为什么需要（真机 2026-10-17/10-12）：fork 返回时子会话刚由 `agents.create` 建好，
+ * DSH 侧的会话索引 / 持久化列举可能还没就绪 —— 与「目录根本不存在」这类终结性失败不同，
+ * 这是**时序性**失败。归位本身幂等（`attachSession` 自查成员名单、`mutate` 空操作即不改写），
+ * 因此重试零副作用；不重试则子会话永久停在侧栏「未分组」。
+ */
+const WORKSPACE_ATTACH_ATTEMPTS = 2
+const WORKSPACE_ATTACH_RETRY_DELAY_MS = 200
+
+/** 归位诊断文件的相对路径（相对插件数据根；只在**失败**时追加一行 JSON）。 */
+const WORKSPACE_ATTACH_DIAGNOSTIC_REL = 'logs/rewind-workspace-attach.jsonl'
+
 /**
  * DSH 官方 fork 在「子会话已创建、但 `workspace.attachSession` 失败」时抛的错误码。
  *
@@ -975,6 +1002,11 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
   private readonly ctx: Context
   /** DSH 缺省会话根（配置改过时只影响快路径命中率，慢路径仍正确） */
   private readonly root: string
+  /**
+   * 插件数据根（`<DSH_HOME>/dsh-config-manager`）—— **只**用于归位失败的诊断落盘。
+   * 权威状态仍在 DSH（工作区注册表 / 会话存储），这里绝不旁路写任何 DSH 数据。
+   */
+  private readonly dataDir: string
   /**
    * 父子关系的短 TTL 缓存（见 `PARENT_RELATIONS_CACHE_TTL_MS`；同 key 并发合并成一次列举）。
    * F-1 后**只缓存成功结果**：列举失败/形状识别失败会让 `parentRelations()` 抛错，
@@ -1001,6 +1033,7 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
   constructor(ctx: Context, homeDir: string, msg: MsgFunc = zhMsg, log?: Logger, realpath?: (path: string) => Promise<string>) {
     this.ctx = ctx
     this.root = join(homeDir, 'sessions')
+    this.dataDir = join(homeDir, 'dsh-config-manager')
     this.log = log ?? createLogger({ level: 'warn' })
     this.msgFunc = msg
     this.realpath = realpath ?? (async (value: string): Promise<string> => await fs.realpath(value))
@@ -1059,7 +1092,15 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
       childId = recovered
     }
     // 工作区归位：官方已归位 → 只复核；官方没归位（或 attach 抛错被上面救回）→ 本兜底写；写后一律复核。
-    const outcome = await this.attachChildToParentWorkspace(sessionId, childId)
+    //
+    // 失败要重试（真机 2026-10-17）：fork 返回时子会话刚建好，DSH 侧的索引/持久化列举可能还没就绪，
+    // 属**时序性**失败；三档判定与 attach 本身幂等，重试零副作用。不重试的代价是子会话永久停在
+    // 侧栏「未分组」（用户 2026-10-11 起的反馈）。
+    let outcome = await this.attachChildToParentWorkspace(sessionId, childId)
+    for (let attempt = 1; attempt < WORKSPACE_ATTACH_ATTEMPTS && !outcome.ok; attempt += 1) {
+      await new Promise<void>((resolve) => { setTimeout(resolve, WORKSPACE_ATTACH_RETRY_DELAY_MS) })
+      outcome = await this.attachChildToParentWorkspace(sessionId, childId)
+    }
     if (outcome.ok) {
       this.log.info(
         'rewind: child session filed into workspace: ' + childId + ' (' + outcome.reason + (outcome.workspaceId !== undefined ? ' ' + outcome.workspaceId : '') + ')',
@@ -1067,10 +1108,9 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
       return { childSessionId: childId }
     }
     // 归位失败**带具体理由**（绝不静默）：日志留痕 + warning 串交给调用方如实上屏。
-    this.log.warn(
-      'rewind: child session not filed into any workspace: ' + childId + ' reason=' + outcome.reason
-      + (outcome.detail !== undefined ? ' detail=' + outcome.detail : ''),
-    )
+    //
+    // 桌面版 DSH 拿不到宿主 stdout ⇒ 只有理由码还不够排查「为什么进未分组」，故再落一行诊断。
+    await this.recordAttachDiagnostic({ parentId: sessionId, childId, outcome })
     const warning = workspaceAttachWarningOf(outcome)
     return warning === undefined ? { childSessionId: childId } : { childSessionId: childId, warning }
   }
@@ -1139,11 +1179,25 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
         attachFailure ??= attempt
       }
       // ③ 同目录：cwd 与某工作区 path 指向同一目录（目录同一性由 DSH 判定，见方法注释）
-      const cwd = this.liveSessionCwd(childId)
-      if (cwd === undefined) {
-        cwdFailure = { ok: false, reason: 'cwd-unavailable' }
-      } else {
-        const resolution = await this.resolveWorkspaceByCwd(registry, records, cwd)
+      //
+      // cwd 取**多源候选**（真机 2026-10-17）：旧实现只看子会话的活 header，拿不到就直接
+      // `cwd-unavailable` ⇒ 三档全落空 ⇒ 子会话停在「未分组」。两条候选都来自 DSH 自己写下的 header，
+      // 不是猜测：① 子会话（活 / 落盘 header）；② 父会话 —— DSH 的 fork 逐字继承父 cwd
+      // （`SessionCommandController.fork`：`meta.cwd = source.header.cwd`，见 dsh-api-session-controller）。
+      const candidates: { cwd: string; source: string }[] = []
+      const missing: string[] = []
+      const childLookup = await this.sessionCwdOf(childId)
+      if (childLookup.ok) candidates.push({ cwd: childLookup.cwd, source: 'child:' + childLookup.source })
+      else missing.push('child(' + childLookup.detail + ')')
+      const parentLookup = await this.sessionCwdOf(parentId)
+      if (parentLookup.ok) {
+        // 与已入列候选同目录时不重复（同目录再 attach 一次只是白跑一次 list()）
+        if (!candidates.some((c) => foldWorkspacePath(c.cwd) === foldWorkspacePath(parentLookup.cwd))) {
+          candidates.push({ cwd: parentLookup.cwd, source: 'parent:' + parentLookup.source })
+        }
+      } else missing.push('parent(' + parentLookup.detail + ')')
+      for (const candidate of candidates) {
+        const resolution = await this.resolveWorkspaceByCwd(registry, records, candidate.cwd)
         if (resolution.records !== undefined && resolution.records.length > 0) {
           for (const record of resolution.records) {
             const attempt = await this.attachChildTo(record, childId)
@@ -1151,9 +1205,14 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
             attachFailure ??= attempt
           }
         } else {
-          cwdFailure = resolution.failure
+          // 目录不存在 / 不属于任何工作区：按候选来源标注，便于诊断区分「读到的是谁」
+          const failure = resolution.failure
+          if (failure !== undefined) {
+            cwdFailure ??= { ok: false, reason: failure.reason, detail: candidate.source + ':' + (failure.detail ?? '') }
+          }
         }
       }
+      if (candidates.length === 0) cwdFailure = { ok: false, reason: 'cwd-unavailable', detail: missing.join(';') }
       return attachFailure ?? cwdFailure ?? { ok: false, reason: 'no-workspace-for-cwd' }
     } catch (error) {
       const detail = errorMessage(error)
@@ -1331,10 +1390,52 @@ export class DshSessionStoreFacade implements SessionStoreFacade {
     return out
   }
 
-  /** 子会话 header 的 cwd（只读；读不到返回 undefined，绝不猜路径）。 */
-  private liveSessionCwd(sessionId: string): string | undefined {
-    const cwd = this.liveSessionHeader(sessionId)?.['cwd']
-    return typeof cwd === 'string' && cwd !== '' ? cwd : undefined
+  /**
+   * 会话 cwd 的**多源**读取（活会话 → 宿主会话存储列举）。
+   *
+   * 为什么不能只读活会话（真机 2026-10-17 根因之一）：旧实现只看 `ctx.get('sessions').get(id)`，
+   * 拿不到就整体放弃归位 ⇒ fork 出来的子会话停在侧栏「未分组」。而 DSH 自己的读法有**磁盘回落**
+   * （`dsh-workspace` 的 `readSessionHeader`：活会话 → `sessionPersistence.list()` 的 header 缓存），
+   * 本方法与该回落同源，绝不猜路径、绝不拿父会话目录以外的任何东西凑数。
+   *
+   * 失败时返回**具体细节**（哪个来源、为什么），由调用方拼进诊断；绝不静默成 undefined。
+   */
+  private async sessionCwdOf(sessionId: string): Promise<SessionCwdLookup> {
+    const live = this.liveSessionHeader(sessionId)?.['cwd']
+    if (typeof live === 'string' && live !== '') return { ok: true, cwd: live, source: 'live' }
+    const store = readService<SessionListService>(this.ctx, 'sessionPersistence')
+    if (store === undefined) return { ok: false, detail: 'no-live-cwd;session-persistence-unavailable' }
+    const listed = await this.listSessionElements(store, 'rewindWorkspaceAttach')
+    if (!listed.ok) return { ok: false, detail: 'no-live-cwd;' + listed.reason }
+    const view = listed.items.find((item) => item.id === sessionId)
+    if (view === undefined) return { ok: false, detail: 'no-live-cwd;not-in-stored-sessions' }
+    const raw = isRecord(view.raw) ? view.raw['cwd'] : undefined
+    if (typeof raw === 'string' && raw !== '') return { ok: true, cwd: raw, source: 'stored' }
+    return { ok: false, detail: 'no-live-cwd;stored-header-has-no-cwd' }
+  }
+
+  /**
+   * 归位失败的**诊断落盘**（一行 JSON，追加写）。
+   *
+   * 为什么需要：桌面版 DSH 的宿主 stdout 不落盘 ⇒ 用户界面上只有「未挂回原工作区」这句，
+   * 具体理由（registry 拿不到 / attach 被拒 / cwd 读不到 / 复核不过）谁都看不到，
+   * 「为什么会进未分组」于是长期不可排查。这里只记 id、理由码与路径来源，**不含任何凭据**。
+   * 落盘失败绝不升级成回退失败（诊断是旁路，不是回退的一部分）。
+   */
+  private async recordAttachDiagnostic(entry: { parentId: string; childId: string; outcome: WorkspaceAttachFailure }): Promise<void> {
+    try {
+      const target = join(this.dataDir, WORKSPACE_ATTACH_DIAGNOSTIC_REL)
+      await fs.mkdir(dirname(target), { recursive: true })
+      await fs.appendFile(target, JSON.stringify({
+        at: new Date().toISOString(),
+        parentId: entry.parentId,
+        childId: entry.childId,
+        reason: entry.outcome.reason,
+        ...(entry.outcome.detail !== undefined ? { detail: entry.outcome.detail } : {}),
+      }) + '\n')
+    } catch {
+      // 诊断写不进去（只读盘 / 权限 / 配额）：静默 —— 回退本身的结论不受影响。
+    }
   }
 
   /**
@@ -4644,10 +4745,19 @@ export function apply(ctx: Context, config?: Config): void {
   // 不为了这一处调用去改公共接口；端口上确实有 forkSession（DshSessionStoreFacade 实现）才走
   // 真 fork，否则如实结构化 `session-fork-unavailable`（绝不静默降级）。
   const forkPort = host.sessions as unknown as RollbackForkCarrier
+  // 写入归属台账（2026-10-17 定案 B）：只记「哪个会话的哪次**写类**工具调用写了哪个路径」。
+  // 惰性读盘 + best-effort 落盘：读不到 / 写不进只让归属退化成「未判定」——
+  // 既不影响留点与回退，也绝不会把「不知道」当成「别的会话写的」（见 rollback-attribution.ts）。
+  const rollbackAttribution = new RollbackWriteAttribution({
+    file: path.join(dataDir, ROLLBACK_POINTS_DIR_NAME, ROLLBACK_ATTRIBUTION_FILE_NAME),
+    warn: (line) => host.log.warn(line),
+  })
+  void rollbackAttribution.load()
   const rollbackEngine = new RollbackPointEngine({
     dataDir,
     homeDir,
     log: (line) => host.log.warn(line),
+    attribution: rollbackAttribution,
     fork: async ({ sessionId, boundarySeq }) => {
       const forkSession = forkPort.forkSession
       if (typeof forkSession !== 'function') {
@@ -4666,7 +4776,11 @@ export function apply(ctx: Context, config?: Config): void {
       return { ok: false as const, code: 'fork-failed' as const, detail: result.error }
     },
   })
-  const rollbackTracker = new RollbackAutoTracker({ engine: rollbackEngine, log: (line) => host.log.warn(line) })
+  const rollbackTracker = new RollbackAutoTracker({
+    engine: rollbackEngine,
+    log: (line) => host.log.warn(line),
+    attribution: rollbackAttribution,
+  })
   ctx.effect(() => {
     let chain: Promise<unknown> = Promise.resolve()
     // 「会话没有 cwd」这类**形状合法但信息不全**的情况只记一次日志（避免每回合刷屏）；

package/src/routes/recovery.ts

@@ -733,6 +733,17 @@ export function recoveryRoutes(env: RoutesEnv): WebRoute[] {
             // A（用户 2026-10-11 定案）：「回到某点之前」要连文件一起退回去 —— 默认把**回退点之后新建**的路径删掉；
             // 调用方显式传 false 才保留老口径（只报告 leftovers，不删任何东西）。
             rewindInput.removeCreated = body['removeCreated'] !== false
+            // 路径级选择性恢复（2026-10-17 定案 A）：缺省 = 全量口径（一字不变）。
+            // 给了数组就只恢复这些路径；**空数组**视为无效输入（400）—— 「一个都没勾」应当由
+            // 界面拦住，而不是让引擎把整次回退悄悄变成 noop。
+            if (body['onlyPaths'] !== undefined) {
+              const raw = body['onlyPaths']
+              if (!Array.isArray(raw) || raw.length === 0 || raw.some((item) => typeof item !== 'string' || item === '')) {
+                writeJson(res, 400, { ok: false, code: 'invalid-input', error: 'onlyPaths must be a non-empty array of non-empty strings' })
+                return
+              }
+              rewindInput.onlyPaths = raw as string[]
+            }
             if (body['preRewindGuard'] === 'off' || body['preRewindGuard'] === 'require' || body['preRewindGuard'] === 'warn') {
               rewindInput.guardPolicy = body['preRewindGuard']
             }

package/src/schema/section-registry.ts

@@ -227,7 +227,7 @@ export const SECTION_REGISTRY: Record<SectionId, SectionMeta> = {
   },
   plugins: {
     id: 'plugins',
-    displayName: 'Plugins',
+    displayName: 'Plugin list',
     group: 'extensions',
     payload: {
       kind: 'array', zipPath: 'plugins/plugins.json', key: 'plugins',
@@ -324,7 +324,7 @@ export const SECTION_REGISTRY: Record<SectionId, SectionMeta> = {
   },
   pluginFiles: {
     id: 'pluginFiles',
-    displayName: "Other Plugins' Loose Files",
+    displayName: 'Plugin config files',
     group: 'extensions',
     payload: { kind: 'files', filePrefix: 'plugin-files/' },
     dataVersion: SECTION_DATA_VERSION,
@@ -377,7 +377,7 @@ export const SECTION_REGISTRY: Record<SectionId, SectionMeta> = {
   },
   self: {
     id: 'self',
-    displayName: "This Plugin's Own Config",
+    displayName: 'Config Manager settings',
     group: 'extensions',
     payload: { kind: 'files', filePrefix: 'self/' },
     dataVersion: SECTION_DATA_VERSION,
@@ -390,7 +390,7 @@ export const SECTION_REGISTRY: Record<SectionId, SectionMeta> = {
   },
   pluginData: {
     id: 'pluginData',
-    displayName: "Other Plugins' Data",
+    displayName: 'Plugin data dirs',
     group: 'extensions',
     payload: { kind: 'files', filePrefix: 'plugin-data/' },
     dataVersion: SECTION_DATA_VERSION,
@@ -406,7 +406,7 @@ export const SECTION_REGISTRY: Record<SectionId, SectionMeta> = {
   },
   pluginAssets: {
     id: 'pluginAssets',
-    displayName: "Other Plugins' Large Files",
+    displayName: 'Plugin large files',
     group: 'extensions',
     payload: { kind: 'files', filePrefix: 'plugin-assets/' },
     dataVersion: SECTION_DATA_VERSION,

package/src/schema/types.ts

@@ -113,6 +113,20 @@ export interface PluginEntry {
    * 否则按裸包名走 npm 最新版（官方机制）。
    */
   spec?: string;
+  /**
+   * 该层只在 profile 的 `dsh.profile.bundles` 里声明、`dependencies` 里没有它，且该 profile 的
+   * `node_modules` 里也**没有**它的落盘副本（issue #95，导出侧写入）。
+   *
+   * 语义：这不是一个「装在本 profile 里的包」，而是由 DSH 从**自己的安装位置**解析的层
+   * （与 `boot-safety.ts` / `RESCUE_KEEP_BUNDLE_PREFIXES` 同口径）。导入端对这类条目
+   * **只把名字声明进目标机的 `dsh.profile.bundles`，绝不走 npm 安装通道**——按裸包名安装会让
+   * 目标机拿到 `dist-tags.latest` 的副本（2026-10 真机：host 0.2.1-rc.2 + 包 0.2.1-alpha.2
+   * → session-controller 一直 pending → 新建会话 service-unavailable）。
+   *
+   * 缺省（旧备份没有该字段）= 由 `spec` / `version` 形状推断，见
+   * `src/core/plugin-cli.ts` 的 `isBundlesOnlyEntry`。
+   */
+  bundlesOnly?: boolean;
   isBundle: boolean;
   inBundles: string[];
   enabled: boolean;

package/src/ui/badge-tone.test.ts

@@ -0,0 +1,23 @@
+/**
+ * badge-tone 单测：四态 → 原生 Tag tone 的映射必须稳定（React 壳只装配，语义在这一层可测）。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { BADGE_TONE, badgeTone, type BadgeKind } from './badge-tone.ts'
+
+test('badge-tone：四态各自映射到原生 Tag 的 tone', () => {
+  assert.equal(badgeTone('ok'), 'success')
+  assert.equal(badgeTone('warn'), 'warning')
+  assert.equal(badgeTone('error'), 'danger')
+  assert.equal(badgeTone('info'), 'info')
+})
+
+test('badge-tone：映射表覆盖全部四态且 tone 都是原生调色板里的值', () => {
+  const kinds: BadgeKind[] = ['info', 'ok', 'warn', 'error']
+  const palette = new Set(['outline', 'solid', 'neutral', 'quiet', 'success', 'info', 'warning', 'danger'])
+  for (const k of kinds) {
+    assert.ok(BADGE_TONE[k] !== undefined, k + ' 缺少映射')
+    assert.ok(palette.has(BADGE_TONE[k]), BADGE_TONE[k] + ' 不在原生 Tag 调色板内')
+  }
+  assert.equal(Object.keys(BADGE_TONE).length, kinds.length)
+})

package/src/ui/badge-tone.ts

@@ -0,0 +1,27 @@
+/**
+ * 徽章四态 → DSH 原生 Tag tone 的映射（**唯一一份**）。
+ *
+ * 为什么单独成模块：徽章现在优先渲染 DSH 自带的 `Tag`（@deepseek-ai/dsh-client-ui-primitives，
+ * 与宿主同一颗组件），它只有 tone 语义、没有 kind 语义；映射关系是纯函数，放这里可被 node 单测覆盖，
+ * 也让 React 壳保持「只装配」。老宿主拿不到原生包时回落本仓库的 `.badge[data-kind]` 样式，
+ * 两条路径共用同一套 kind → tone 语义，不允许各自漂移。
+ */
+
+/** 插件侧的四态徽章语义。 */
+export type BadgeKind = 'info' | 'ok' | 'warn' | 'error'
+
+/** DSH 原生 Tag 的调色板选项（与其 .d.ts 逐字同形）。 */
+export type DshTagTone = 'outline' | 'solid' | 'neutral' | 'quiet' | 'success' | 'info' | 'warning' | 'danger'
+
+/** 四态 → 原生 tone（ok=success / warn=warning / error=danger / info=info）。 */
+export const BADGE_TONE: Readonly<Record<BadgeKind, DshTagTone>> = {
+  ok: 'success',
+  info: 'info',
+  warn: 'warning',
+  error: 'danger',
+}
+
+/** 取某个四态对应的原生 tone；未知输入按 info 处理（调用方给的是字面量联合，此为防御）。 */
+export function badgeTone(kind: BadgeKind): DshTagTone {
+  return BADGE_TONE[kind] ?? 'info'
+}

package/src/ui/i18n.ts

@@ -548,10 +548,10 @@ export const uiZh = {
   'export.category.settings': 'DSH 全局设置（namespace 分区，redacted）',
   'export.category.providers': 'LLM Provider / Model / 默认模型 / BaseURL',
   'export.category.plugins': '已安装插件清单与启用状态（不含二进制）',
-  'export.category.pluginFiles': '其他插件放在 ~/.dsh 根下的零散配置文件（白名单 + plugin-config/ 目录，整文件复制）',
-  'export.category.self': '本插件自身配置（同步/自动同步/分区选择/UI 偏好/市场；sync-*.json 等，不含凭据值）',
-  'export.category.pluginData': '其他插件在系统主目录下的数据（如 ~/.dsh-wallpaper-engine、~/.mnemon 的配置与状态；可再生成缓存绝不收录）',
-  'export.category.pluginAssets': '其他插件的大体积文件（上传的壁纸、本地数据库等；默认不勾选）',
+  'export.category.pluginFiles': '插件放在 ~/.dsh 根下的配置文件（白名单 + plugin-config/ 目录，整文件复制）',
+  'export.category.self': '配置管理器自身的设置（同步/自动同步/分区选择/UI 偏好/市场；sync-*.json 等，不含凭据值）',
+  'export.category.pluginData': '插件在系统主目录下的数据（如 ~/.dsh-wallpaper-engine、~/.mnemon 的配置与状态；可再生成缓存绝不收录）',
+  'export.category.pluginAssets': '插件的大体积文件（上传的壁纸、本地数据库等；默认不勾选）',
   'export.category.mcp': 'MCP 服务器组合配置（需重启生效）',
   'export.category.prompts': 'System Prompt / Plan Mode 提示',
   'export.category.skills': '用户技能文件（~/.dsh/skills）',
@@ -1097,10 +1097,10 @@ export const uiEn: Record<UiTextKey, string> = {
   'export.category.settings': 'Global DSH settings (namespace sections, redacted)',
   'export.category.providers': 'LLM providers / models / default model / base URL',
   'export.category.plugins': 'Installed plugin list and enablement (binaries excluded)',
-  'export.category.pluginFiles': "Other plugins' loose config files at the ~/.dsh root (allowlist + plugin-config/, copied whole)",
-  'export.category.self': "This plugin's own config (sync / autosync / section selection / UI prefs / market; sync-*.json etc., no credential values)",
-  'export.category.pluginData': "Other plugins' data under the system home directory (e.g. the config/state of ~/.dsh-wallpaper-engine and ~/.mnemon; regenerable caches are never included)",
-  'export.category.pluginAssets': "Other plugins' large files (uploaded wallpapers, local databases, ...; not selected by default)",
+  'export.category.pluginFiles': "Plugin config files at the ~/.dsh root (allowlist + plugin-config/, copied whole)",
+  'export.category.self': "Config Manager's own settings (sync / autosync / section selection / UI prefs / market; sync-*.json etc., no credential values)",
+  'export.category.pluginData': "Plugin data under the system home directory (e.g. the config/state of ~/.dsh-wallpaper-engine and ~/.mnemon; regenerable caches are never included)",
+  'export.category.pluginAssets': "Plugins' large files (uploaded wallpapers, local databases, ...; not selected by default)",
   'export.category.mcp': 'MCP server composition (restart required)',
   'export.category.prompts': 'System prompt / Plan Mode prompts',
   'export.category.skills': 'Your skill files (~/.dsh/skills)',

package/src/ui/rollback-view.test.ts

@@ -834,3 +834,30 @@ test('issue #88：rollbackEntryVisible —— false 收起 / true 显示 / 缺
 })
 
 
+
+/* ------------------------------------------------------------------ A+B：逐文件选择的界面模型 */
+
+test('A/B 选择模型：默认排除别的对话改过的文件；全选时不传 onlyPaths', async () => {
+  const { rollbackSelectionRows, rollbackDefaultSelection, rollbackOnlyPaths, rollbackSelectionBlocksSubmit } = await import('./rollback-view.ts')
+  const preview = {
+    ok: true, id: 'rp-1', storage: { available: true },
+    workspace: {
+      files: [
+        { path: 'C:/ws/a.txt', status: 'overwrite', added: 1, removed: 1, truncated: false },
+        { path: 'C:/ws/b.txt', status: 'overwrite', added: null, removed: null, truncated: true, foreign: true, foreignSessionId: 'session-x' },
+      ],
+    },
+  } as unknown as import('./rollback-view.ts').RollbackPreviewResult
+  const rows = rollbackSelectionRows(preview)
+  assert.equal(rows.length, 2)
+  assert.equal(rows[1]?.foreign, true)
+  assert.equal(rows[1]?.foreignSessionId, 'session-x')
+  const fallback = rollbackDefaultSelection(rows)
+  assert.deepEqual(fallback, ['C:/ws/a.txt'], '默认只勾非 foreign 的文件')
+  assert.deepEqual(rollbackOnlyPaths(rows, fallback), ['C:/ws/a.txt'])
+  assert.equal(rollbackOnlyPaths(rows, rows.map((row) => row.path)), null, '全选 ⇒ null（不传字段，走既有全量口径）')
+  assert.equal(rollbackSelectionBlocksSubmit(rows, []), true, '一个都没勾必须拦住（宿主侧空数组是 400）')
+  assert.equal(rollbackSelectionBlocksSubmit(rows, fallback), false)
+  assert.deepEqual(rollbackSelectionRows(null), [])
+  assert.deepEqual(rollbackSelectionRows({ workspace: { files: 'nope' } } as unknown as import('./rollback-view.ts').RollbackPreviewResult), [])
+})