dsh-config-manager 0.1.85 → 0.2.0

package/lib/utils/workdir-lock.js

@@ -19,7 +19,10 @@
  *  - 锁文件放 `os.tmpdir()`（按工作目录绝对路径哈希命名），**不写进工作副本**：
  *    工作副本还没 clone 出来也能先锁住，且绝不让 `git status` 看到脏文件；
  *  - 跨进程独占用 `open(path,'wx')`（O_EXCL，原子）；等待方轮询，超时抛 WorkdirLockError；
- *  - holder 崩溃留下的陈旧锁按 mtime 回收（超过 staleMs 才回收，避免误抢仍在跑的长时间任务）；
+ *  - holder 崩溃留下的陈旧锁：先问 holder pid 是否还存在（ESRCH ⇒ 已被杀，立即回收），
+ *    读不出 pid 或进程仍存活时才按 mtime 超过 staleMs 回收（避免误抢仍在跑的长时间任务）；
+ *  - 等待方是**有界**的：等文件锁与进程内链上排队共用同一个 timeoutMs 上限，超时即抛，
+ *    绝不在界面早已放弃之后仍去驱动工作副本；
  *  - 进程内再串一条 Promise 链：同进程两个 GitTransport 实例（autosync / 路由）共用同一条链，
  *    不依赖文件锁的轮询延迟。
  */
@@ -56,6 +59,102 @@ export function workdirLockKey(workDir) {
 export function workdirLockPath(workDir) {
     return path.join(os.tmpdir(), `dshcm-workdir-${workdirLockKey(workDir)}.lock`);
 }
+/**
+ * holder 进程是否还活着（三态：true = 存活、false = 确定已死、null = 判不了）。
+ *
+ * 为什么必须问：holder 被强杀时（DSH 重启 / 崩溃 / 任务管理器结束进程）`finally` 不会执行，
+ * 锁文件就留在 tmpdir 里；只按 mtime 判定要等满 staleMs（15 分钟）才接管。这段窗口里**所有**
+ * 同步与只读自检都排在锁上 —— 真机 2026-10-27：DSH 重启踩在一次 push 中间，pid 28888 的锁留在
+ * %TEMP%，之后每次打开同步页 `GET /sync/status` 都要等满 10 s 预算再 503。
+ *
+ * 误差方向：只有 `ESRCH`（pid 完全不存在）才判死；`EPERM`（进程存在但无权发信号，如 Linux 跨用户）
+ * 判活；pid 复用也会把「别人的锁」判成活 —— 两种误判都偏向保守（最多退化成 mtime 规则），
+ * 绝不会把仍在跑的 holder 的锁抢走。
+ */
+export function workdirLockHolderAlive(pid) {
+    if (typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0)
+        return null;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ESRCH')
+            return false;
+        if (code === 'EPERM')
+            return true;
+        return null;
+    }
+}
+/** 读锁文件里记录的 holder（读不出 / 半写入 / 不是对象 ⇒ null，一律退回 mtime 规则） */
+async function readLockHolder(lockPath) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(lockPath, 'utf8'));
+        if (parsed === null || typeof parsed !== 'object')
+            return null;
+        const holder = parsed;
+        return { pid: holder.pid, workDir: holder.workDir };
+    }
+    catch {
+        return null;
+    }
+}
+const LOCK_FILE_PREFIX = 'dshcm-workdir-';
+let pruneScheduled = false;
+/**
+ * 一次性清扫本机所有「holder 已死」的工作副本锁（每进程只跑一次）。
+ *
+ * 为什么需要：pid 回收只在**自己被这把锁挡住时**生效，而残留锁可能属于早已不再使用的工作目录
+ * （换过仓库、换过数据目录、临时实例）—— 它们永远不会再被查询，却一直躺在 %TEMP%（真机 2026-10-27
+ * 见到 8 个，最久 3.4 天）。只删 pid 确定不存在的锁：读不出 holder 的不动（保守，宁可留下）。
+ */
+export async function pruneDeadWorkdirLocksOnce() {
+    if (pruneScheduled)
+        return;
+    pruneScheduled = true;
+    const dir = os.tmpdir();
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    const remove = async (lockPath) => {
+        try {
+            await fs.unlink(lockPath);
+        }
+        catch {
+            // 别人同时也在清扫 / 已被释放：无事可做
+        }
+    };
+    await Promise.all(names
+        .filter((name) => name.startsWith(LOCK_FILE_PREFIX) && name.endsWith('.lock'))
+        .map(async (name) => {
+        const lockPath = path.join(dir, name);
+        const holder = await readLockHolder(lockPath);
+        if (holder === null)
+            return; // 读不出 holder：保守留下
+        const alive = workdirLockHolderAlive(holder.pid);
+        if (alive === false)
+            return await remove(lockPath); // holder 确定已死
+        if (alive !== true)
+            return; // 判不了：留下
+        // pid 复用陷阱：holder pid 此刻可能属于一个毫不相干的进程（本机实测 2026-10-27：一条测试残留锁的
+        // pid 9704 已被 `NoiseCancelingEngine.exe` 复用）。只有「它声明的工作目录确实不存在 + 锁已过
+        // staleMs」才清 —— 那说明 holder 早就不在这把锁上了，而不是正在干活。
+        const st = await fs.stat(lockPath).catch(() => null);
+        if (st === null || Date.now() - st.mtimeMs <= DEFAULT_WORKDIR_LOCK_STALE_MS)
+            return;
+        const workDir = typeof holder.workDir === 'string' ? holder.workDir : '';
+        if (workDir === '')
+            return;
+        if (await fs.stat(workDir).then(() => true, () => false))
+            return;
+        await remove(lockPath);
+    }));
+}
 async function tryAcquire(lockPath, workDir, staleMs, now) {
     const token = randomUUID();
     try {
@@ -84,7 +183,18 @@ async function tryAcquire(lockPath, workDir, staleMs, now) {
         const code = err.code;
         if (code !== 'EEXIST')
             throw err;
-        // 陈旧锁回收：holder 崩溃/被杀后留下的文件不能让同步永久卡死
+        // ① holder pid 已经不存在 ⇒ 这把锁必然陈旧，立即回收，不等 staleMs（重启/崩溃后的现场）
+        const holder = await readLockHolder(lockPath);
+        if (workdirLockHolderAlive(holder?.pid) === false) {
+            try {
+                await fs.unlink(lockPath);
+            }
+            catch {
+                // 别人刚好也判定并回收、或 holder 的 finally 刚好跑到：下一轮重试即可
+            }
+            return null;
+        }
+        // ② 读不出 holder / holder 仍存活 ⇒ 只有超过 staleMs 才视为崩溃残留（绝不抢正在跑的长任务）
         try {
             const st = await fs.stat(lockPath);
             if (now() - st.mtimeMs > staleMs)
@@ -109,8 +219,15 @@ export async function withWorkdirLock(workDir, fn, options = {}) {
     const now = options.now ?? Date.now;
     const key = workdirLockKey(workDir);
     const lockPath = workdirLockPath(workDir);
+    // 顺带清扫本机别的死 holder 残留（每进程一次，失败不影响本次取锁）
+    void pruneDeadWorkdirLocksOnce().catch(() => undefined);
+    // 计时必须在进入串行链**之前**取：链上排队同样属于「在等这把锁」。否则一个只读调用排在
+    // 上一个 300 s 的同步后面时，计时从轮到它那一刻才清零，超时上限形同失效（2026-10-27 现场）。
+    const started = now();
     const run = async () => {
-        const started = now();
+        // 排队期间调用方已超时放弃：轮到它时直接失败，**不执行 fn**，免得被遗弃的请求稍后仍去驱动工作副本
+        if (now() - started >= timeoutMs)
+            throw new WorkdirLockError(workDir, now() - started);
         // 先同步做一次尝试，再进入轮询：无竞争的常见情形零额外延迟
         let release = await tryAcquire(lockPath, workDir, staleMs, now);
         while (release === null) {
@@ -132,16 +249,27 @@ export async function withWorkdirLock(workDir, fn, options = {}) {
     // 链里只保留「尾巴」的完成状态，异常不向下游传染
     const tail = current.then(() => undefined, () => undefined);
     chains.set(key, tail);
+    // 硬上界：timeoutMs 是「拿到锁」的上限，不是「开始计时后」的上限。只用 run 内的计时不够 ——
+    // 排在长任务后面的调用永远轮不到自己计时，界面就被历史任务拖着走。这里直接对链头 race，
+    // 超时 reject；被放弃的 run 之后还会被链唤醒，但入口的过期检查让它立刻抛（不碰工作副本）。
+    let rejectDeadline;
+    const deadline = new Promise((_, reject) => { rejectDeadline = reject; });
+    const timer = setTimeout(() => { rejectDeadline?.(new WorkdirLockError(workDir, timeoutMs)); }, timeoutMs);
+    // unref：这个计时器不该拖住进程退出（缺省 300 s）
+    if (typeof timer.unref === 'function')
+        timer.unref();
     try {
-        return await current;
+        return await Promise.race([current, deadline]);
     }
     finally {
+        clearTimeout(timer);
         if (chains.get(key) === tail)
             chains.delete(key);
     }
 }
-/** 仅供测试：清空进程内串行链（不影响磁盘上的锁文件） */
+/** 仅供测试：清空进程内串行链与一次性清扫标记（不影响磁盘上的锁文件） */
 export function resetWorkdirLockChainsForTest() {
     chains.clear();
+    pruneScheduled = false;
 }
 //# sourceMappingURL=workdir-lock.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-config-manager",
-  "version": "0.1.85",
+  "version": "0.2.0",
   "license": "MIT",
   "description": "Backup, restore, export, import, migrate and sync your DeepSeek Harness (DSH) configuration: settings, plugins, MCP servers, skills, agent presets and workspaces. One-click migration to another machine. DSH 配置一键备份、恢复、导出、导入、迁移与同步插件。",
   "icon": "./icon.svg",
@@ -199,7 +199,7 @@
     "lightningcss": "1.33.0",
     "lucide": "^1.61.0",
     "lucide-react": "^1.61.0",
-    "morphicons": "^1.7.1",
+    "morphicons": "^2.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "schemastery": "^3.18.0",

package/src/cli/web/page.ts

@@ -5,7 +5,7 @@
  * HTML：**零脚本、零外部资源、零构建产物**，配合 http.ts 里收紧的 CSP。
  * 样式内联在 <style> 里（独立于插件 UI 的 CSS Modules；该新 pattern 已登记进 DESIGN.md）。
  * 这套样式表**有一份外部出处**（亮色 IBM Carbon / 暗色 Raycast 阶梯）与逐条对照表：
- * docs/design/2026-10-04-cli-rescue-console-carbon.md —— 改 STYLE 前先读它，改完跑 web.test.ts 的 R3-02。
+ * docs/components/cli-rescue-console.md —— 改 STYLE 前先读它，改完跑 web.test.ts 的 R3-02。
  *
  * 呈现纪律：每个数字都要能回答「你怎么知道的」—— 离线拿不到的（结构化分区/凭据/同步令牌）
  * 一律显式列出并说明原因，绝不显示为 0 或留空。
@@ -32,7 +32,7 @@ export interface PageChrome {
 
 const STYLE = [
   // ---- 设计 token：IBM Carbon（亮色语义四色）+ Raycast（暗色 surface 阶梯）----
-  // 映射表、取的章节与全部偏离记录：docs/design/2026-10-04-cli-rescue-console-carbon.md
+  // 映射表、取的章节与全部偏离记录：docs/components/cli-rescue-console.md
   // 文字色一律取「能读」的那一档：Carbon 的 #24a148 / #f1c21b 只做填充，正文用 #198038 / #8e6a00
   // （AA 对比度由 web.test.ts 的 R3-02 逐对钉住，改色先过那条测试）。
 ':root{color-scheme:light dark;--font:system-ui,-apple-system,"Segoe UI",Roboto,"PingFang SC","Hiragino Sans GB","Microsoft YaHei","Noto Sans SC",sans-serif;--mono:ui-monospace,SFMono-Regular,Menlo,Consolas,"Liberation Mono",monospace;--fg:#161616;--muted:#525252;--bg:#f4f4f4;--card:#fff;--surface:#f4f4f4;--line:#e0e0e0;--accent:#0f62fe;--accent-hover:#0043ce;--on-accent:#fff;--ok:#198038;--warn:#8e6a00;--bad:#da1e28;--scrim:rgba(22,22,22,.45)}',

package/src/client/ConfigManagerSection.tsx

@@ -165,15 +165,6 @@ const navLayoutResult = navWidths === null
    */
   const [libraryPending, setLibraryPending] = useState<ArtifactPendingAction | null>(null)
 
-  /**
-   * 导入面板当前是否停在「从其它 agent 导入」这一页（t17）。
-   *
-   * 为什么是壳层 state 而不是 runStore：它与「导入面板」同生命周期，且**不该被持久化** ——
-   * 刷新后重放一个「正在选来源」的界面只会骗人（来源检测结果要重新拉）。
-   * 关面板 / 切走即随组件卸载归零，与 libraryAction 同一档语义。
-   */
-  const [foreignImportOpen, setForeignImportOpen] = useState(false)
-
   /* ---------------- m-star-prompt：Star 引导弹窗（保持既有能力） ---------------- */
   const [starPromptOpen, setStarPromptOpen] = useState(false)
   /** 弹窗展示的 GitHub 仓库地址（GET /star-prompt 返回；不落 store） */
@@ -441,7 +432,7 @@ const navLayoutResult = navWidths === null
       case 'market.publish.open': openTask('market', { subView: 'myconfigs' }); return
       // 维护与诊断是全屏子视图：命令直达它，而不是只把用户送到环境页
       // 从其它 agent 导入：开导入面板并停在来源选择（与首页工具栏同一路径）
-      case 'import.foreign': openTask('import'); setForeignImportOpen(true); return
+      case 'import.foreign': openTask('import', { foreign: true }); return
       case 'maintenance.open': openMaintenance(); return
       case 'activity.open': openTask('runs'); return
       case 'history.open': openTask('history'); return
@@ -468,10 +459,7 @@ const navLayoutResult = navWidths === null
           t={t}
           syncT={syncT}
           // 直达来源选择：开导入面板 + 把面板切到「从其它 agent 导入」那一步
-          openForeignImport={() => {
-            openTask('import')
-            setForeignImportOpen(true)
-          }}
+          openForeignImport={() => { openTask('import', { foreign: true }) }}
         />
       )
       break
@@ -638,7 +626,7 @@ const navLayoutResult = navWidths === null
             {/* 导入与逛市场都是多阶段流程（§1），同样由本面板承载。
                 此前只渲染了 export / runs / history / about —— 从产物库点「导入」会开到**一个空面板**，
                 而导入其实在页面那条路径里跑（返回后正好看到它），两处状态分叉。 */}
-            {activeTask.kind === 'import' && (foreignImportOpen ? (
+            {activeTask.kind === 'import' && (importTaskForeign(activeTask.payload) ? (
               /* 「从其它 agent 导入」（t17）：页面级步骤，复用同一块面板 ——
                  与既有导入向导并列，避免「弹窗套向导」。产包成功后把 zipPath 写进
                  runStore.library.pendingZip（产物库「一键导入」那条已验证的通道），
@@ -648,8 +636,9 @@ const navLayoutResult = navWidths === null
                 t={t}
                 uiT={uiT}
                 onReady={(result) => {
-                  setForeignImportOpen(false)
+                  // 产包成功 = 这一页的使命结束：入参改回「向导」，并把 zipPath 交给既有导入通道
                   runStore.patch({
+                    task: { ...activeTask, payload: { foreign: false } },
                     library: {
                       pendingZip: { zipPath: result.zipPath, name: result.name },
                     },
@@ -661,7 +650,8 @@ const navLayoutResult = navWidths === null
                 api={api}
                 t={t}
                 uiT={uiT}
-                onOpenForeignImport={() => { setForeignImportOpen(true) }}
+                // 向导 → 来源选择：同样是改 Task 入参（面板状态只有一个事实源）
+                onOpenForeignImport={() => { runStore.patch({ task: { ...activeTask, payload: { foreign: true } } }) }}
               />
             ))}
             {activeTask.kind === 'market' && (
@@ -783,6 +773,19 @@ function marketTaskSubView(payload: unknown): 'browse' | 'myconfigs' | undefined
   return v === 'myconfigs' || v === 'browse' ? v : undefined
 }
 
+/**
+ * Task 入参里取「导入面板停在来源选择」（t17「从其它 agent 导入」）。
+ *
+ * 为什么放进 Task 入参而不是壳层 useState（原 bug 的根因）：壳层 state 与「导入面板」**不同**
+ * 生命周期 —— 关面板只是 `task: null`，壳层不重挂，于是「先点从其它 agent 导入 → 关掉 → 再点导入」
+ * 会带着旧的 true 进来，看到的是来源选择页而不是导入向导。入参随 Task 一起生灭（且 Task 本身
+ * 不持久化，见 run-store 的 `task: null`），开一个**新的**导入面板自然就是向导。
+ */
+function importTaskForeign(payload: unknown): boolean {
+  if (typeof payload !== 'object' || payload === null) return false
+  return (payload as { foreign?: unknown }).foreign === true
+}
+
 function marketTaskItemId(payload: unknown): string | undefined {
   if (typeof payload !== 'object' || payload === null) return undefined
   const id: unknown = (payload as { marketId?: unknown }).marketId

package/src/client/api.ts

@@ -42,6 +42,8 @@ import type { SessionExportProbe } from './session-export/session-export-view.ts
 import type { ForeignSkip } from '../foreign/types.ts';
 import type { ForeignSourcesResponse as ForeignSourcesViewInput } from '../ui/foreign-view.ts';
 import type { DiskUsageReport } from '../core/disk-usage.ts';
+import type { BrowseResult } from '../core/path-browse.ts';
+import type { NativePickResult } from '../core/native-path-picker.ts';
 import type { UiT } from '../ui/i18n.ts';
 import { failedSectionsFromResponse } from '../ui/export-flow.ts';
 import type { SessionFormatDisposition } from '../ui/session-format-disposition.ts';
@@ -291,6 +293,8 @@ const LONG_OPTS: RequestOptions = { timeoutMs: LONG_REQUEST_TIMEOUT_MS };
 
 /** 插件自更新请求的超时：宿主侧安装上限 15 分钟，客户端留出余量（16 分钟）避免误报「请求超时」。 */
 const SELF_UPDATE_OPTS: RequestOptions = { timeoutMs: 16 * 60 * 1000 };
+/** 原生目录选择器：宿主侧 10 分钟上限，这里留出传输余量。 */
+const NATIVE_PICK_OPTS: RequestOptions = { timeoutMs: 11 * 60 * 1000 };
 
 /** query-string 辅助（跳过 undefined/空串，与 dsh-ssh 一致） */
 function query(params: Record<string, string | number | undefined>): string {
@@ -337,6 +341,14 @@ function triggerBlobDownload(blob: Blob, filename: string): void {
   setTimeout(() => { URL.revokeObjectURL(url) }, 15_000)
 }
 
+/**
+ * DSH 宿主自带目录选择器的结果。
+ *  - `ok`：用户选中（`path` 非空）；
+ *  - `canceled`：用户点了取消，调用方静默收手；
+ *  - `unavailable`：宿主没有这个能力（非桌面宿主 / 版本较旧 / 调用抛错），调用方回落下一层。
+ */
+export type DshPickResult = { ok: true; path: string } | { ok: false; reason: 'canceled' | 'unavailable' }
+
 /**
  * Config Manager 浏览器半的唯一数据入口。
  * 同时实现 `ExportPort`（export-flow 用）与 `ImportPort`（import-wizard 用）。
@@ -350,9 +362,16 @@ export class ConfigManagerApi {
   exportPassword: string | null = null
   /** 客户端展示层翻译器（zh 源 / en 镜像，见 ui/i18n.ts）。 */
   readonly t: UiT
+  /**
+   * DSH 自带目录选择器（桌面壳全局 `__DSH_DIRECTORY_PICKER__.pick` 或客户端服务 `ctx.get('uiWorkspace').pickDirectory`），
+   * 由 `apply(ctx)` 注入的**惰取** thunk（解析顺序见 `import/dsh-directory-pick.ts`）。
+   * 宿主没提供该能力时保持 `undefined`。
+   */
+  private readonly dshDirectoryPicker: (() => Promise<string | null>) | undefined
 
-  constructor(t: UiT) {
+  constructor(t: UiT, dshDirectoryPicker?: () => Promise<string | null>) {
     this.t = t
+    this.dshDirectoryPicker = dshDirectoryPicker
   }
 
   // ------------------------------------------------------------- status
@@ -575,6 +594,46 @@ export class ConfigManagerApi {
     );
   }
 
+  /**
+   * 列出一层本机目录（只读；路径映射「选本机路径」弹窗的数据源）。
+   * `target` 缺省或空串 = 「此电脑」根列表（Windows 盘符 / POSIX `/`）。
+   * 失败不抛异常：宿主回 `error: 'not-found'|'denied'|'failed'|'not-absolute'`，弹窗照常可用。
+   */
+  async browsePath(target?: string): Promise<BrowseResult> {
+    const suffix = target === undefined || target === '' ? '' : query({ path: target });
+    return getJson<BrowseResult>(CONFIG_MANAGER_API.pathBrowse + suffix, this.t);
+  }
+
+  /**
+   * 弹**系统原生**目录选择器（同一端点的 POST 形态）。
+   *
+   * 用户可能在系统对话框里逛几分钟，所以超时必须远大于常规请求：内核侧 10 分钟兜底，这里再加一道。
+   * 回 `reason: 'unsupported' | 'failed'` 时调用方回落到内置目录浏览器，不当错误处理。
+   */
+  async pickNativePath(startPath?: string, title?: string): Promise<NativePickResult> {
+    const body: Record<string, string> = {};
+    if (startPath !== undefined && startPath !== '') body.startPath = startPath;
+    if (title !== undefined && title !== '') body.title = title;
+    return postJson<NativePickResult>(CONFIG_MANAGER_API.pathBrowse, body, this.t, NATIVE_PICK_OPTS);
+  }
+
+  /**
+   * 复用 **DSH 宿主自带**的原生目录选择器（就是「选择工作区目录」那个窗口）。
+   *
+   * 比插件自己起系统对话框更稳：窗口由 DSH 主进程弹，跟着宿主走，不受插件宿主的进程形态限制。
+   * 完全不设客户端超时 —— 用户可能在原生窗口里逛几分钟，宿主侧 `host.pickDirectory` 也是 caller-signal-only。
+   * 宿主没有该能力或调用抛错一律归成 `unavailable`，由调用方回落插件自己的原生对话框，不当错误处理。
+   */
+  async pickDshPath(): Promise<DshPickResult> {
+    if (this.dshDirectoryPicker === undefined) return { ok: false, reason: 'unavailable' }
+    try {
+      const path = await this.dshDirectoryPicker()
+      return typeof path === 'string' && path !== '' ? { ok: true, path } : { ok: false, reason: 'canceled' }
+    } catch {
+      return { ok: false, reason: 'unavailable' }
+    }
+  }
+
   /** ImportPort.decryptArchive：解锁整体加密备份容器 → 明文 ZIP 路径 + 解密覆盖的凭据 ref 名 */
   async decryptArchive(zipPath: string, password: string): Promise<DecryptArchiveResponse> {
     return postJson<DecryptArchiveResponse>(CONFIG_MANAGER_API.decryptArchive, { zipPath, password }, this.t, LONG_OPTS);

package/src/client/bundle-selfcontained.test.ts

@@ -73,6 +73,15 @@ test('lib/client.js 自包含：只 require 运行时白名单内的外部包',
       `修复方向：把该依赖加回 tsdown.config.ts 的 deps.alwaysBundle（并保留在 devDependencies）。`,
   )
 
+  // 相对 require = 依赖同目录 chunk：loader 只取 lib/client.js，不会请求 ./client2.js。
+  const relativeSpecifiers = result.specifiers.filter((s) => s.startsWith('.'))
+  assert.deepEqual(
+    relativeSpecifiers,
+    [],
+    `lib/client.js 依赖了同目录 chunk（loader 不会请求它们）：${relativeSpecifiers.join(', ')}\n` +
+      '修复方向：tsdown.config.ts 的 outputOptions.inlineDynamicImports = true。',
+  )
+
   // node:* 内置模块不属于本护栏判定范围（浏览器半不应依赖它们，但那是另一条不变量）。
   if (result.nodeBuiltins.length > 0) {
     t.diagnostic(`注意：bundle 内出现 Node 内置 require：${result.nodeBuiltins.join(', ')}`)

package/src/client/chat/chat-entry-view.test.ts

@@ -475,7 +475,7 @@ test('动作行图标走宿主原生（复制 → 对勾 → 回退），拿不
 /**
  * 2026-10-17（用户要求「与 DSH 原生气泡完全一致」）：§15b 的几何/字号必须与宿主
  * MessageItem + MessageIconActions 的**同一条取值**逐字同式（宿主产物抽出的取值清单见
- * docs/spec/known-gaps.md 的「G-39 增量（八）」）。这张用例是那条口径的源级护栏：
+ * docs/maintenance/known-gaps.md 的「G-39 增量（八）」）。这张用例是那条口径的源级护栏：
  * 谁把圆角/内边距/动作行/文件卡改回「近似档」，这里立刻红。
  */
 test('气泡与动作行逐值对齐宿主：圆角 xl(20px) / 内边距 10·16 / 动作行 28+delta / 文件卡 240·64', () => {

package/src/client/chat/rollback-entry-view.test.ts

@@ -443,6 +443,20 @@ test('A 真机回归：workspaces.archiveSession 依赖 this —— 抽方法时
   assert.deepEqual(service.archived, ['c1'])
 })
 
+test('A 真机回归（0.2.x 服务名）：归档能力只在 uiWorkspace 上，也必须取得到', async () => {
+  const service = {
+    archived: [] as string[],
+    async archiveSession(this: { archived: string[] }, id: string): Promise<unknown> {
+      this.archived.push(id)
+      return { ok: true, value: { archivedSessionIds: [id] } }
+    },
+  }
+  // 老版本才有 workspaces 服务；只照这个名字取 = 真机上永远拿不到（本轮修的就是这个）。
+  const sources = navigationSourcesOf({ get: (key: string) => (key === 'uiWorkspace' ? service : undefined) })
+  assert.deepEqual(await archiveParentSession(sources.workspaces, 'c2'), { ok: true })
+  assert.deepEqual(service.archived, ['c2'])
+})
+
 test('A：归档失败码 → 文案键（子串映射；成功不提示；界面绝不裸渲染机器码）', () => {
   assert.equal(archiveHintKey({ ok: true }), null)
   assert.equal(archiveHintKey({ ok: false, code: 'archive-unavailable' }), 'rollback.rewind.archive.unavailable')

package/src/client/chat/rollback-entry-view.ts

@@ -839,7 +839,8 @@ export function navigationSourcesOf(ctx: unknown): NavigationSources {
   return {
     workspace: asWorkspaceSource(safeGet('uiWorkspace')),
     sessions: asSessionListSource(safeGet('sessions')),
-    workspaces: asArchiveSource(safeGet('workspaces')),
+    // 归档能力挂在 uiWorkspace 上（真机 DSH 0.2.x 只有这个服务名；老版本才有 workspaces）——两个都试，不猜。
+    workspaces: asArchiveSource(safeGet('uiWorkspace')) ?? asArchiveSource(safeGet('workspaces')),
   }
 }
 

package/src/client/common/CopyButton.tsx

@@ -21,6 +21,7 @@ import { useEffect, useRef, useState } from 'react'
 import type { TranslateNS } from '../client-types.ts'
 import { toast } from './toast-store.ts'
 import { CopyStateIcon } from './Icon.tsx'
+import { hostIcon } from './host-primitives.ts'
 import { copyTextToClipboard } from './clipboard.ts'
 import css from '../config-manager.module.css'
 
@@ -63,9 +64,27 @@ export function CopyButton({ text, label, t }: CopyButtonProps) {
     })
   }
 
+  /**
+   * 图标 = **对话（聊天）回退条用的那两颗宿主原生图**（2026-10-28 用户要求「复制图标统一替换成
+   * 对话回退的复制 icon」）：`IconCopyOutlineRegular → IconCheckOutlineRegular` 的**瞬时换图**，
+   * 与宿主 MessageIconActions / ChatEntryCopyAction 同一对、同一字形与描边重量。
+   * 拿不到宿主图标的老宿主回落 morphicons 的 `CopyStateIcon`（绝不能变成空白按钮）。
+   */
+  const HostCopyIcon = hostIcon('IconCopyOutlineRegular')
+  const HostCheckIcon = hostIcon('IconCheckOutlineRegular')
+
   return (
-    <button type="button" className={css.copyBtn} aria-label={label} title={label} onClick={onClick}>
-      <CopyStateIcon done={copied} size={12} />
+    <button
+      type="button"
+      className={css.copyBtn}
+      aria-label={label}
+      title={label}
+      onClick={onClick}
+      data-copy-state={copied ? 'copied' : 'idle'}
+    >
+      {HostCopyIcon !== null && HostCheckIcon !== null
+        ? (copied ? <HostCheckIcon size={12} /> : <HostCopyIcon size={12} />)
+        : <CopyStateIcon done={copied} size={12} />}
     </button>
   )
 }

package/src/client/common/Icon.tsx

@@ -30,7 +30,9 @@ import DatabaseBackup from 'lucide-react/dist/esm/icons/database-backup.mjs'
 import Download from 'lucide-react/dist/esm/icons/download.mjs'
 import Eye from 'lucide-react/dist/esm/icons/eye.mjs'
 import File from 'lucide-react/dist/esm/icons/file.mjs'
+import Folder from 'lucide-react/dist/esm/icons/folder.mjs'
 import FolderInput from 'lucide-react/dist/esm/icons/folder-input.mjs'
+import FolderOpen from 'lucide-react/dist/esm/icons/folder-open.mjs'
 import HardDriveDownload from 'lucide-react/dist/esm/icons/hard-drive-download.mjs'
 import History from 'lucide-react/dist/esm/icons/history.mjs'
 import Info from 'lucide-react/dist/esm/icons/info.mjs'
@@ -68,6 +70,8 @@ const ICONS = {
   close: X,
   delete: Trash2,
   file: File,
+  folder: Folder,
+  folderOpen: FolderOpen,
   download: Download,
   inspect: Search,
   view: Eye,
@@ -238,6 +242,9 @@ export const CloseIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name
 export const DeleteIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="delete" {...p} />
 export const DownloadIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="download" {...p} />
 export const InspectIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="inspect" {...p} />
+export const FolderIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="folder" {...p} />
+export const FolderOpenIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="folderOpen" {...p} />
+export const FileIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="file" {...p} />
 export const ArrowRightIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="arrowRight" {...p} />
 export const ChevronDownIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="chevronDown" {...p} />
 export const PreviewIcon = (p: Omit<IconProps, 'name'>): JSX.Element => <Icon name="preview" {...p} />

package/src/client/common/routes.ts

@@ -106,6 +106,11 @@ export const CONFIG_MANAGER_API = {
    * 带 `sessionId` = 流式代理 DSH 自己的 `/api/session.export`（原始日志 ZIP，含子会话与附件）。
    */
   sessionExport: `${API_BASE}/session-export`,
+  /**
+   * 本机目录列举（**只读**）：`?path=` 缺省 = 「此电脑」根列表。
+   * 导入向导「路径映射 → 选本机路径」弹窗的唯一数据源（浏览器拿不到真实目录树）。
+   */
+  pathBrowse: `${API_BASE}/path-browse`,
 } as const;
 
 /** 远程同步路由族（git / webdav 通道、GitHub device flow、历史快照、自动同步、分区选择）。 */

package/src/client/config-manager.module.css

@@ -3972,6 +3972,11 @@ body {
 
 .pathOld,
 .pathNew {
+  /* 黑块溢出面板的根因：本仓库**没有**全局 `*{box-sizing:border-box}` 复位，而这块是
+     width:100% + padding 4/8px + border 1px 的 content-box ⇒ 实际外框比父内容盒宽 18px，
+     深色底块右缘冲出 .pathRow 约 7px（实测卡片 39..570 vs 内部块 51..577）。
+     声明式修法：本块自己算 border-box（与 .input 的既有做法一致）。 */
+  box-sizing: border-box;
   min-width: 0;
   width: 100%;
   /* 纵向列容器：让内部 input 拉满块宽（等价于旧版全局 .input{width:100%} 的效果，
@@ -3998,6 +4003,71 @@ body {
   flex: none;
 }
 
+/* 新路径输入行：手打输入 + 浏览按钮同一行（窄画布下按钮 flex:none 不换行，输入可收缩） */
+.pathInputRow {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  min-width: 0;
+}
+
+.pathInputRow > .input {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+/* 路径选择弹窗：当前目录条 + 一层条目列表（长列表由 Modal.Body scroll 限高内滚） */
+.pickerPath {
+  box-sizing: border-box;
+  width: 100%;
+  padding: 4px 8px;
+  border-radius: var(--cm-r-2);
+  background: var(--dsw-alias-bg-layer-2);
+  color: var(--dsw-alias-label-secondary);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: var(--cm-fs-meta);
+  overflow-wrap: anywhere;
+}
+
+.pickerList {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.pickerRow {
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 8px;
+  border: 1px solid transparent;
+  border-radius: var(--cm-r-2);
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-size: var(--cm-fs-meta);
+  text-align: left;
+  cursor: pointer;
+}
+
+.pickerRow:hover {
+  background: var(--dsw-alias-bg-layer-2);
+}
+
+.pickerRow:focus-visible {
+  outline: 2px solid var(--cm-accent);
+  outline-offset: -1px;
+}
+
+/* 文件名可任意折行，绝不横向撑破弹窗 */
+.pickerName {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
 /* 密钥补录 */
 .secretsList {
   display: flex;

package/src/client/import/ImportWizardView.tsx

@@ -648,6 +648,7 @@ function ImportWizardBody({ api, t, uiT, onOpenForeignImport }: ImportWizardView
         onBack={() => { setPhase('preview') }}
         onNext={finishPathMapping}
         t={t}
+        api={api}
       />
     )
   }