dsh-config-manager 0.1.78 → 0.1.80

package/lib/sync/watch-scope.js

@@ -0,0 +1,95 @@
+/**
+ * m-autosync-realtime：**监听范围**（纯函数，host 侧）。
+ *
+ * 自动同步要「像 VS Code 一样」在本地改动后立刻上行，就必须知道**哪些磁盘路径承载了
+ * 可同步的分区内容**。这份映射不能从注册表的 ZIP 内路径推出来 —— 两者是两件事：
+ *   - 注册表 `SECTION_JSON_PATHS` / `SECTION_FILE_PREFIXES` 说的是**快照 ZIP 内部**的布局；
+ *   - 真正被监视的是 `$DSH_HOME` 下的落盘位置（`skills/`、`settings.yaml`、
+ *     `profiles/<p>/cordis.patch.yml` … 见 `src/core/backup.ts` 的 FILE_BASES 与
+ *     `src/core/patch-layers.ts` 的两层 patch）。
+ *
+ * 因此本文件是「分区 → home 相对路径」的**唯一静态表**，只做事实声明，不做 I/O。
+ * 监听器（`sync-watcher.ts`）只负责 fs.watch + 去抖；判定「变了哪些分区」始终回到引擎的
+ * `hasLocalChanges()`（按分区 hash 比对基线），这里绝不猜。
+ *
+ * 关键取舍（勿“优化”成监听整个 home）：
+ *  - **不递归监听 `$DSH_HOME` 根**：`sessions/`（会话日志，可能几个 GB）、
+ *    `node_modules`、`dsh-config-manager/{sync/work,snapshots,exports,tmp}` 全在里面，
+ *    一旦监听就会自己把自己点着（同步写工作副本 → 触发 → 再同步），且与「sessions 绝不自动
+ *    上下行」的铁律直接冲突；
+ *  - **只监听 `profiles/<p>` 下的具体文件与 `patches/`**，绝不递归 `profiles/`：
+ *    那下面有整个 pnpm 依赖树；
+ *  - `self` 分区只监听白名单里那几个 `*.json`（与 `src/adapters/self.ts` 的
+ *    SELF_CONFIG_FILES 对齐），**刻意不监听 `sync/sync-state.json` / `sync/sync-history.json` /
+ *    `sync/sync-autosync.json` / `sync/backup-schedule.json`** —— 调度器每轮都会改写它们，
+ *    监听就是自激循环；
+ *  - `node_modules` / `.git` / 原子写临时文件在任何层级都被过滤。
+ */
+import path from 'node:path';
+/** 任意层级都要过滤的目录名（依赖树、git 内部、同步工作副本）。 */
+export const WATCH_IGNORED_SEGMENTS = ['node_modules', '.git'];
+/** 任意层级都要过滤的文件名模式（原子写临时文件：`x.json.tmp-1234-0`）。 */
+const TMP_FILE_RE = /\.tmp-/u;
+/**
+ * 组装监听目标清单。
+ *
+ * 清单顺序即日志顺序（稳定，便于测试与排查）；路径一律 posix 相对 `$DSH_HOME`。
+ */
+export function buildWatchTargets(input) {
+    const profile = input.profile !== undefined && input.profile !== '' ? input.profile : 'web';
+    const profileDir = `profiles/${profile}`;
+    const dataBase = 'dsh-config-manager';
+    return [
+        // settings / providers / ui：同一个 settings.yaml 的顶层 namespace
+        { relPath: 'settings.yaml', kind: 'file', recursive: false, sections: ['settings', 'providers', 'ui'] },
+        // prompts / mcp：两层组合 patch 的 home 层
+        { relPath: 'cordis.patch.yml', kind: 'file', recursive: false, sections: ['prompts', 'mcp'] },
+        // agentInstructions：home 根 AGENTS.md
+        { relPath: 'AGENTS.md', kind: 'file', recursive: false, sections: ['agentInstructions'] },
+        // prompts / mcp / plugins：两层组合 patch 的 profile 层 + pnpm 工作区声明 + profile manifest
+        { relPath: `${profileDir}/cordis.patch.yml`, kind: 'file', recursive: false, sections: ['prompts', 'mcp', 'plugins'] },
+        { relPath: `${profileDir}/pnpm-workspace.yaml`, kind: 'file', recursive: false, sections: ['plugins'] },
+        { relPath: `${profileDir}/package.json`, kind: 'file', recursive: false, sections: ['plugins'] },
+        // plugins：pnpm patch 文件（`patchFile:<profile 相对路径>`）
+        { relPath: `${profileDir}/patches`, kind: 'dir', recursive: true, sections: ['plugins'] },
+        // skills / agentPresets：整棵目录
+        { relPath: 'skills', kind: 'dir', recursive: true, sections: ['skills'] },
+        { relPath: '.agent-presets', kind: 'dir', recursive: true, sections: ['agentPresets'] },
+        // self：**只**监听白名单配置文件（与 adapters/self.ts 的 SELF_CONFIG_FILES 对齐）。
+        // 刻意不含 sync-state.json / sync-history.json / sync-autosync.json / backup-schedule.json。
+        { relPath: `${dataBase}/sync/sync-config.json`, kind: 'file', recursive: false, sections: ['self'] },
+        { relPath: `${dataBase}/sync/sync-selection.json`, kind: 'file', recursive: false, sections: ['self'] },
+        { relPath: `${dataBase}/sync/ui-prefs.json`, kind: 'file', recursive: false, sections: ['self'] },
+        { relPath: `${dataBase}/market/market-config.json`, kind: 'file', recursive: false, sections: ['self'] },
+        { relPath: `${dataBase}/exports/.backup-notes.json`, kind: 'file', recursive: false, sections: ['self'] },
+    ];
+}
+/** 把任一绝对路径转成 home 相对 posix 路径；不在 home 内 → null。 */
+export function toHomeRelPath(homeDir, absPath) {
+    const rel = path.relative(homeDir, absPath);
+    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+        return null;
+    return rel.split(path.sep).join('/');
+}
+/**
+ * 该 home 相对路径是否属于「绝不该触发同步」的噪声。
+ *
+ * 判据只有两类（宁少不多：漏过滤只是多跑一轮空同步，误过滤会漏掉真实改动）：
+ * 依赖树 / git 内部目录，以及原子写临时文件。
+ */
+export function isNoiseRelPath(relPath) {
+    if (relPath === '')
+        return true;
+    const segments = relPath.split('/');
+    for (const segment of segments) {
+        if (WATCH_IGNORED_SEGMENTS.includes(segment))
+            return true;
+    }
+    const base = segments[segments.length - 1] ?? '';
+    return TMP_FILE_RE.test(base);
+}
+/** 监视目标的绝对路径。 */
+export function targetAbsPath(homeDir, target) {
+    return path.join(homeDir, target.relPath.split('/').join(path.sep));
+}
+//# sourceMappingURL=watch-scope.js.map

package/lib/sync/webdav/webdav-transport.d.ts

@@ -1,7 +1,7 @@
 import '../messages.ts';
 import type { MsgFunc } from '../../core/messages.ts';
 import { SyncTransportError } from '../transport.ts';
-import type { SyncRetryOptions, SyncSnapshot, SyncSnapshotMeta, SyncTransport, SyncTransportErrorOptions } from '../transport.ts';
+import type { SyncProbeResult, SyncRetryOptions, SyncSnapshot, SyncSnapshotMeta, SyncTransport, SyncTransportErrorOptions } from '../transport.ts';
 /** 请求选项：headers / body / 覆盖默认超时（ms；0 = 不超时） */
 export interface WebDavRequestOptions {
     headers?: Record<string, string>;
@@ -119,8 +119,22 @@ export declare class WebDavTransport implements SyncTransport {
     private indexUrl;
     /** 读取一次 password（错误脱敏用） */
     private passwordOnce;
-    /** 幂等创建 snapshots 集合：MKCOL；已存在（405/2xx/3xx）视为成功。 */
+    /** 幂等创建 snapshots 集合：MKCOL；已存在（2xx/3xx/405/409）视为成功。
+     *
+     * cloud-sync 借鉴项 ③（首连自建）：目标目录的**上级**不存在时（新账号，或用户填了一个还没建的
+     * 目录），按 WebDAV 规范 MKCOL 缺父目录回 409 —— 此前用户必须先去网盘里手工建好目录，否则
+     * 首次同步必然失败。现在：直连 409 时逐级补齐 baseUrl 路径上的每一层，再重试一次。
+     * 返回**本次真正新建**的层级 URL（已存在的层级不进结果，探针据此如实回报，普通上传忽略返回值）。 */
     private ensureCollection;
+    /** 逐级 MKCOL 补齐 baseUrl 的每一层目录（只有缺父目录时才会走到这里）。 */
+    private ensureAncestors;
+    /** 条件写失败（HTTP 412）：远端在本次读取之后被别人改过 —— 中止写入，让用户重跑（cloud-sync 借鉴项 ①）。 */
+    private concurrentWrite;
+    /**
+     * 连通性探针（cloud-sync 借鉴项 ②）：补齐目标目录 → 证明这真的是一个可读的 WebDAV 集合
+     * → 读一次索引回报快照数。只读；唯一写副作用是幂等 MKCOL 补目录（那正是它要修的故障）。
+     */
+    probe(): Promise<SyncProbeResult>;
     /**
      * 读 index。**三态语义**（audit-sync sync-N1 / t66）：
      *  - 200 + 合法数组 → 返回条目（list 用）；

package/lib/sync/webdav/webdav-transport.js

@@ -60,6 +60,40 @@ const BLOBS_INDEX_FILE = 'blobs-index.json';
 /** 内容哈希形状（sha256 hex）：blob 路径只接受它，杜绝路径穿越 */
 const BLOB_HASH_RE = /^[a-f0-9]{64}$/;
 const REDACTED = '[REDACTED]';
+/**
+ * 幂等 MKCOL 的「已存在 / 已建好」状态码（cloud-sync 借鉴项 ③）。
+ * 405 = 资源已存在（WebDAV 规范下的常见回法）；301/302/303 = 反向代理把 MKCOL 重定向到规范 URL；
+ * 409 = 目标已存在（坚果云等网盘对已存在目录回 409，见 cloud-sync 的兼容注释）。
+ */
+const MKCOL_OK_STATUSES = new Set([200, 201, 204, 301, 302, 303, 405, 409]);
+/**
+ * 直连目标集合时可判为「已建好 / 已存在」的状态码（**不含 409**）。
+ *
+ * 为什么把 409 排除：RFC 4918 §9.3.1 规定「父目录不存在」的正确回法就是 **409 Conflict**，
+ * 而部分网盘（坚果云等）对「目标已存在」也回 409 —— 首连直连时两种语义无法区分，
+ * 一律当「已存在」会让「上级目录没建」这条真实故障被吞掉（紧接着的 PUT 才会失败）。
+ * 因此 409 必须先走 ensureAncestors 补齐父目录再重试；只有**重试后**仍 409 才按「已存在」接受。
+ */
+const MKCOL_EXISTS_STATUSES = new Set([200, 201, 204, 301, 302, 303, 405]);
+/**
+ * 条件写头（cloud-sync 借鉴项 ①）：拿到 ETag 就要求「远端仍是我读到的那一版」（If-Match）；
+ * 索引**本来就不存在**（首次推送且远端确无内容）时用 If-None-Match: * 防两个设备同时首推；
+ * 其余情形（服务端不返回 ETag）返回空对象 ⇒ 退化为无条件写，绝不因为加了头把同步判成失败。
+ */
+function conditionalHeaders(etag, indexMissing) {
+    if (etag !== undefined)
+        return { 'If-Match': etag };
+    return indexMissing ? { 'If-None-Match': '*' } : {};
+}
+/** URL 路径段编码：已百分号编码的段原样保留（先 decode 成功才 re-encode），失败则直接编码。 */
+function encodeSegmentSafe(segment) {
+    try {
+        return encodeURIComponent(decodeURIComponent(segment));
+    }
+    catch {
+        return encodeURIComponent(segment);
+    }
+}
 /** 自动跟随的重定向状态码（RFC 7231/9110） */
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 /** 重定向最大跳数（RFC 7231 建议 ≤5；防 302 循环拖死请求） */
@@ -264,7 +298,7 @@ export class WebDavTransport {
         // → 必须照常上传，绝不跳过。
         const meta = computeSnapshotMeta(snapshot);
         // audit-sync sync-N1 覆盖面补全（t66，来自 t22 的 C7）：upload 也是写路径，**不接受 404 = 空集合**。
-        const { entries: idxBefore, missing: indexMissing } = await this.readIndexDetailed(pwd);
+        const { entries: idxBefore, missing: indexMissing, etag: idxEtag } = await this.readIndexDetailed(pwd);
         if (indexMissing && await this.remoteHasPriorContent(pwd)) {
             // 索引 404 只是**缺信息**（不是「远端没有快照」）：远端已有历史内容时，按空索引做读改写会把
             // 权威 index.json PUT 成只有本条目 → 其余快照从列表整体消失，随后 delete + GC 会回收**仍被
@@ -296,7 +330,12 @@ export class WebDavTransport {
         const merged = idxBefore.filter((m) => m.id !== snapshot.id);
         merged.push(meta);
         merged.sort((a, b) => (a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : 0));
-        const putIdx = await this.send('PUT', idxUrl, pwd, { body: JSON.stringify(merged) });
+        const putIdx = await this.send('PUT', idxUrl, pwd, {
+            body: JSON.stringify(merged),
+            headers: conditionalHeaders(idxEtag, indexMissing),
+        });
+        if (putIdx.status === 412)
+            throw this.concurrentWrite(idxUrl, putIdx.status);
         if (!putIdx.ok) {
             throw new WebDavTransportError(await this.failText('PUT', idxUrl, putIdx, pwd), classifyHttpStatus(putIdx.status));
         }
@@ -338,7 +377,7 @@ export class WebDavTransport {
         // 是**缺信息**而非事实，沿用空索引继续会把 index.json 覆盖成 []（其余快照从列表整体消失）并让
         // gcBlobStore 以空引用集回收，删掉仍被现存快照文件引用的会话 blob（不可恢复）。
         // 与 F1 同口径：宁可显式失败，也不制造不可恢复的远端状态。list() 仍保留「404 = 空集合」语义。
-        const { entries: idx, missing: indexMissing } = await this.readIndexDetailed(pwd);
+        const { entries: idx, missing: indexMissing, etag: idxEtag } = await this.readIndexDetailed(pwd);
         // delete 快照文件：404 = 不存在，视为成功
         const url = this.snapshotUrl(id);
         const res = await this.send('DELETE', url, pwd);
@@ -355,7 +394,12 @@ export class WebDavTransport {
         if (remaining.length === idx.length && res.status === 404) {
             return; // 文件与 index 都不存在 → 静默成功，无写回
         }
-        const putIdx = await this.send('PUT', idxUrl, pwd, { body: JSON.stringify(remaining) });
+        const putIdx = await this.send('PUT', idxUrl, pwd, {
+            body: JSON.stringify(remaining),
+            headers: conditionalHeaders(idxEtag, false),
+        });
+        if (putIdx.status === 412)
+            throw this.concurrentWrite(idxUrl, putIdx.status);
         if (!putIdx.ok) {
             throw new WebDavTransportError(await this.failText('PUT', idxUrl, putIdx, pwd), classifyHttpStatus(putIdx.status));
         }
@@ -624,14 +668,78 @@ export class WebDavTransport {
             return '';
         }
     }
-    /** 幂等创建 snapshots 集合：MKCOL；已存在（405/2xx/3xx）视为成功。 */
+    /** 幂等创建 snapshots 集合：MKCOL；已存在（2xx/3xx/405/409）视为成功。
+     *
+     * cloud-sync 借鉴项 ③（首连自建）：目标目录的**上级**不存在时（新账号，或用户填了一个还没建的
+     * 目录），按 WebDAV 规范 MKCOL 缺父目录回 409 —— 此前用户必须先去网盘里手工建好目录，否则
+     * 首次同步必然失败。现在：直连 409 时逐级补齐 baseUrl 路径上的每一层，再重试一次。
+     * 返回**本次真正新建**的层级 URL（已存在的层级不进结果，探针据此如实回报，普通上传忽略返回值）。 */
     async ensureCollection(pwd) {
         const url = this.snapshotsColUrl();
-        const res = await this.send('MKCOL', url, pwd);
-        const okStatuses = new Set([200, 201, 204, 301, 302, 303, 405]);
-        if (okStatuses.has(res.status))
-            return;
-        throw new WebDavTransportError(await this.failText('MKCOL', url, res, pwd), classifyHttpStatus(res.status));
+        const first = await this.send('MKCOL', url, pwd);
+        // 首连只认「确定已存在 / 已建好」的状态；**409 不算**（二义：缺父目录 or 已存在）
+        if (MKCOL_EXISTS_STATUSES.has(first.status))
+            return [];
+        if (first.status !== 409) {
+            // 401/403/5xx/… 不是「目录缺失」，绝不吞掉：如实报错
+            throw new WebDavTransportError(await this.failText('MKCOL', url, first, pwd), classifyHttpStatus(first.status));
+        }
+        // 409：先逐级补齐 baseUrl 每一层（幂等；已存在的层回 405/3xx/409 都按已存在继续），再重试目标集合。
+        const created = await this.ensureAncestors(pwd);
+        const retry = await this.send('MKCOL', url, pwd);
+        // 重试真建出目标集合（201/200/204）也要如实回报 —— 否则界面会**低报**本次实际创建的目录
+        // （用户可见文案「已在远端自动创建目录」，少报一条等于说错）。
+        if (retry.status === 200 || retry.status === 201 || retry.status === 204)
+            created.push(url);
+        // 上级已确保存在：重试仍是 409 ⇒ 按「已存在」接受（部分网盘行为）；真正的权限/路径错误由随后的 PUT 显式报出。
+        if (MKCOL_OK_STATUSES.has(retry.status))
+            return created;
+        throw new WebDavTransportError(await this.failText('MKCOL', url, retry, pwd), classifyHttpStatus(retry.status));
+    }
+    /** 逐级 MKCOL 补齐 baseUrl 的每一层目录（只有缺父目录时才会走到这里）。 */
+    async ensureAncestors(pwd) {
+        const base = new URL(this.o.baseUrl);
+        const segments = base.pathname.split('/').filter((seg) => seg !== '');
+        const created = [];
+        for (let depth = 1; depth <= segments.length; depth += 1) {
+            const path = segments.slice(0, depth).map((seg) => encodeSegmentSafe(seg)).join('/');
+            const url = `${base.origin}/${path}/`;
+            const res = await this.send('MKCOL', url, pwd);
+            // 201/200/204 = 这次真的建出来了；405/409/3xx = 早就存在 → 不写进结果（不谎报「已创建」）
+            if (res.status === 200 || res.status === 201 || res.status === 204)
+                created.push(url);
+            else if (MKCOL_OK_STATUSES.has(res.status))
+                continue;
+            else {
+                throw new WebDavTransportError(this.o.msg('sync.webdav.collectionCreateFailed', { path: url, status: String(res.status) }), classifyHttpStatus(res.status));
+            }
+        }
+        return created;
+    }
+    /** 条件写失败（HTTP 412）：远端在本次读取之后被别人改过 —— 中止写入，让用户重跑（cloud-sync 借鉴项 ①）。 */
+    concurrentWrite(url, status) {
+        return new WebDavTransportError(this.o.msg('sync.webdav.concurrentWrite', { status: String(status), url }), { kind: 'conflict', retryable: false, status });
+    }
+    /**
+     * 连通性探针（cloud-sync 借鉴项 ②）：补齐目标目录 → 证明这真的是一个可读的 WebDAV 集合
+     * → 读一次索引回报快照数。只读；唯一写副作用是幂等 MKCOL 补目录（那正是它要修的故障）。
+     */
+    async probe() {
+        const pwd = await this.passwordOnce();
+        const created = await this.ensureCollection(pwd);
+        const url = this.snapshotsColUrl();
+        const res = await this.send('PROPFIND', url, pwd, { headers: { Depth: '0' } });
+        // 2xx（含 207 Multi-Status）= 真的是 WebDAV 集合；405/501 = 服务端不支持 PROPFIND → 退回「读索引」当证据。
+        if (!res.ok && res.status !== 405 && res.status !== 501) {
+            throw new WebDavTransportError(this.o.msg('sync.webdav.probeUnreachable', { status: String(res.status), url }), classifyHttpStatus(res.status));
+        }
+        const { entries, missing } = await this.readIndexDetailed(pwd);
+        const count = missing ? 0 : entries.length;
+        return {
+            message: this.o.msg('sync.webdav.probeOk', { count: String(count) }),
+            snapshotCount: count,
+            ...(created.length > 0 ? { createdCollections: created } : {}),
+        };
     }
     /**
      * 读 index。**三态语义**（audit-sync sync-N1 / t66）：
@@ -656,7 +764,14 @@ export class WebDavTransport {
         if (!res.ok) {
             throw new WebDavTransportError(await this.failText('GET', url, res, pwd), classifyHttpStatus(res.status));
         }
-        return { entries: this.parseIndex(await res.text(), url, pwd), missing: false };
+        // ETag 是写路径**条件写**的前置条件（cloud-sync 借鉴项 ①）：服务端给了就记下来，没给就退化成无条件写
+        // （绝不因为「服务端不返回 ETag」把同步判成失败）。
+        const etag = res.headers?.['etag'];
+        return {
+            entries: this.parseIndex(await res.text(), url, pwd),
+            missing: false,
+            ...(typeof etag === 'string' && etag !== '' ? { etag } : {}),
+        };
     }
     parseIndex(raw, url, pwd) {
         let parsed;
@@ -696,6 +811,8 @@ export class WebDavTransport {
             Authorization: auth,
             'Content-Type': 'application/json',
             'User-Agent': 'DSH-Config-Manager/0.1.55 (WebDAV Client)',
+            // 条件写头（If-Match / If-None-Match）与探针的 Depth 头从这里注入（cloud-sync 借鉴项 ①②）
+            ...(opts.headers ?? {}),
         };
         if (opts.body !== undefined)
             headers['Content-Length'] = String(Buffer.byteLength(opts.body, 'utf8'));

package/lib/ui/foreign-view.js

@@ -41,6 +41,16 @@ export const FOREIGN_SKIP_KEY = {
     // 档 B（t6）新增两条：把「推导出的 cwd」与「没有自动根」也变成可见事实，绝不静默
     'session-cwd-derived': 'foreign.skip.session-cwd-derived',
     'source-needs-explicit-path': 'foreign.skip.source-needs-explicit-path',
+    // 2026-10-18（8 个新冻结码）：Claude Code 项目级 / 插件 / 权限 / 设置键诊断 + 会话 id 不一致 +
+    // MCP 同名 + 项目扫描触顶 —— 仍用全量 Record 兜住：新增码而没配文案 = 编译失败。
+    'unsupported-permissions': 'foreign.skip.unsupported-permissions',
+    'unsupported-settings-keys': 'foreign.skip.unsupported-settings-keys',
+    'unsupported-agents': 'foreign.skip.unsupported-agents',
+    'unsupported-rules': 'foreign.skip.unsupported-rules',
+    'unsupported-plugins': 'foreign.skip.unsupported-plugins',
+    'session-id-mismatch': 'foreign.skip.session-id-mismatch',
+    'mcp-server-id-conflict': 'foreign.skip.mcp-server-id-conflict',
+    'project-scan-truncated': 'foreign.skip.project-scan-truncated',
 };
 /**
  * 机器码 → 字典键。**未知码（未来版本 / 第三方宿主）回退键名本身**，

package/lib/ui/i18n.d.ts

@@ -86,6 +86,7 @@ export declare const uiZh: {
     readonly 'report.unit.notes': '条说明';
     readonly 'report.action.done': '完成';
     readonly 'error.notMounted': 'config-manager 服务未挂载（插件未加载）：请确认 profile 中已安装 dsh-config-manager 并重启 DSH';
+    readonly 'error.apiPathMissed': '接口路径未命中（HTTP {status}）：请求前缀为 {base}，但该路径没有返回 JSON —— 若你经反向代理挂在子路径下，请检查代理是否转发了这个前缀（issue #108）';
     readonly 'error.httpInvalidJson': 'HTTP {status}: 无效的 JSON 响应';
     readonly 'error.fallback': '操作失败';
     readonly 'error.requestTimeout': '请求超时（{seconds} 秒）：未在时限内收到宿主响应，请重试';
@@ -508,6 +509,14 @@ export declare const uiZh: {
     readonly 'foreign.skip.legacy-rules-file': '旧式规则文件：DSH 无对等结构，只报告';
     readonly 'foreign.skip.instructions-merged': '多份指令源被合并为一个全局指令文件';
     readonly 'foreign.skip.instructions-override-selected': '命中更高优先级的指令文件（override），按它导入';
+    readonly 'foreign.skip.unsupported-permissions': '权限规则（allow/ask/deny）未迁移：DSH 没有权限规则文件的对等结构，这些规则不在本包内，导入后不会生效';
+    readonly 'foreign.skip.unsupported-settings-keys': 'settings.json 里其余未迁移的顶层键：只记录键名与条数，键值一律不读取，也不会写进本包';
+    readonly 'foreign.skip.unsupported-agents': '.claude/agents/*.md 子代理定义未迁移：DSH 的子代理是运行时 provider 注册制，没有文件级对等结构';
+    readonly 'foreign.skip.unsupported-rules': '.claude/rules/*.md（带 frontmatter 作用域）未迁移：并入全局指令会丢掉作用域，故只报告不合并';
+    readonly 'foreign.skip.unsupported-plugins': 'Claude Code 插件本体未迁移：插件的 hooks / 命令靠 Claude 运行时执行，DSH 无法加载，插件代码一律不复制；插件自带的 skills 与 .mcp.json 里的 MCP 定义另行迁移';
+    readonly 'foreign.skip.session-id-mismatch': '会话记录里的 sessionId 与文件名不一致：DSH 按目录名/文件名定位会话，本次以文件名为准，记录里的 id 未采用';
+    readonly 'foreign.skip.mcp-server-id-conflict': '同名 MCP server 在多处出现（全局 / 项目级 / 插件）：先到先得，其余同名项只报告未迁移';
+    readonly 'foreign.skip.project-scan-truncated': '项目较多：项目级扫描只覆盖了上限内的项目，其余项目本次未读取，其配置不在本包内';
     readonly 'foreign.lossy.file-section-secrets.title': '文件类分区的明文不做剥离';
     readonly 'foreign.lossy.file-section-secrets.detail': '技能 / Agent 预设 / 全局指令 / 插件文件 / 历史会话 / 插件自身配置这六个文件类分区承载的是原始文件内容：命中的明文原样进包（导入侧只报告、不改写；本页的产包路径连扫描都不做）。「默认不含秘密」只对结构化分区成立，对这类分区不成立 —— 需要保密请先清理源文件。';
     readonly 'foreign.lossy.entry-backslash.title': '条目名中段反斜杠：跨平台落点可能不同';

package/lib/ui/i18n.js

@@ -93,6 +93,7 @@ export const uiZh = {
     'report.action.done': '完成',
     // 错误
     'error.notMounted': 'config-manager 服务未挂载（插件未加载）：请确认 profile 中已安装 dsh-config-manager 并重启 DSH',
+    'error.apiPathMissed': '接口路径未命中（HTTP {status}）：请求前缀为 {base}，但该路径没有返回 JSON —— 若你经反向代理挂在子路径下，请检查代理是否转发了这个前缀（issue #108）',
     'error.httpInvalidJson': 'HTTP {status}: 无效的 JSON 响应',
     'error.fallback': '操作失败',
     'error.requestTimeout': '请求超时（{seconds} 秒）：未在时限内收到宿主响应，请重试',
@@ -533,6 +534,17 @@ export const uiZh = {
     'foreign.skip.legacy-rules-file': '旧式规则文件：DSH 无对等结构，只报告',
     'foreign.skip.instructions-merged': '多份指令源被合并为一个全局指令文件',
     'foreign.skip.instructions-override-selected': '命中更高优先级的指令文件（override），按它导入',
+    // ---------- 2026-10-18：Claude Code 项目级配置 / 插件 / 权限 / 设置键的如实诊断（8 个新码）----------
+    // 纪律：每条都要能被代码逐条证明 —— 只说「什么没搬、为什么、本项是否可补」，
+    // 绝不写「已支持 / 完全兼容」这类无法被代码证明的话。
+    'foreign.skip.unsupported-permissions': '权限规则（allow/ask/deny）未迁移：DSH 没有权限规则文件的对等结构，这些规则不在本包内，导入后不会生效',
+    'foreign.skip.unsupported-settings-keys': 'settings.json 里其余未迁移的顶层键：只记录键名与条数，键值一律不读取，也不会写进本包',
+    'foreign.skip.unsupported-agents': '.claude/agents/*.md 子代理定义未迁移：DSH 的子代理是运行时 provider 注册制，没有文件级对等结构',
+    'foreign.skip.unsupported-rules': '.claude/rules/*.md（带 frontmatter 作用域）未迁移：并入全局指令会丢掉作用域，故只报告不合并',
+    'foreign.skip.unsupported-plugins': 'Claude Code 插件本体未迁移：插件的 hooks / 命令靠 Claude 运行时执行，DSH 无法加载，插件代码一律不复制；插件自带的 skills 与 .mcp.json 里的 MCP 定义另行迁移',
+    'foreign.skip.session-id-mismatch': '会话记录里的 sessionId 与文件名不一致：DSH 按目录名/文件名定位会话，本次以文件名为准，记录里的 id 未采用',
+    'foreign.skip.mcp-server-id-conflict': '同名 MCP server 在多处出现（全局 / 项目级 / 插件）：先到先得，其余同名项只报告未迁移',
+    'foreign.skip.project-scan-truncated': '项目较多：项目级扫描只覆盖了上限内的项目，其余项目本次未读取，其配置不在本包内',
     // 三类已知有损（F-5）的**逐条文案**：由 src/ui/foreign-view.ts 的 foreignLossyRows 渲染，
     // 卡片标题 / 说明 / 适用性徽章属客户端外壳 chrome，键在 src/client/locales.ts。
     'foreign.lossy.file-section-secrets.title': '文件类分区的明文不做剥离',
@@ -656,6 +668,7 @@ export const uiEn = {
     'report.unit.notes': 'note(s)',
     'report.action.done': 'Done',
     'error.notMounted': 'config-manager service is not mounted (plugin not loaded): make sure dsh-config-manager is installed in the profile and restart DSH',
+    'error.apiPathMissed': 'API path not matched (HTTP {status}): the request prefix is {base} but that path did not return JSON — if you serve DSH under a reverse-proxy sub-path, check that this prefix is proxied (issue #108)',
     'error.httpInvalidJson': 'HTTP {status}: invalid JSON response',
     'error.fallback': 'Operation failed',
     'error.requestTimeout': 'Request timed out ({seconds}s): the host did not respond in time, please retry',
@@ -1081,6 +1094,15 @@ export const uiEn = {
     'foreign.skip.legacy-rules-file': 'Legacy rules file: DSH has no equivalent, reported only',
     'foreign.skip.instructions-merged': 'Several instruction sources were merged into one global instruction file',
     'foreign.skip.instructions-override-selected': 'A higher-priority instruction file (override) was found and is the one imported',
+    // 2026-10-18: honest diagnostics for Claude Code project-level config / plugins / permissions / settings keys (8 new codes)
+    'foreign.skip.unsupported-permissions': 'Permission rules (allow/ask/deny) were not migrated: DSH has no equivalent permission-rule file, so they are not in this bundle and will not take effect after import',
+    'foreign.skip.unsupported-settings-keys': 'Other unmigrated top-level keys in settings.json: only key names and counts are recorded; values are never read and never enter this bundle',
+    'foreign.skip.unsupported-agents': 'Subagent definitions in .claude/agents/*.md were not migrated: DSH subagents are registered at runtime by providers and have no file-level equivalent',
+    'foreign.skip.unsupported-rules': '.claude/rules/*.md files (with frontmatter scoping) were not migrated: merging them into the global instructions would drop their scope, so they are reported only',
+    'foreign.skip.unsupported-plugins': 'Claude Code plugin bodies were not migrated: their hooks and commands run inside the Claude runtime and cannot be loaded by DSH, and plugin code is never copied; skills and MCP definitions inside a plugin .mcp.json are migrated separately',
+    'foreign.skip.session-id-mismatch': 'The sessionId inside the session record does not match the file name: DSH locates sessions by directory and file name, so the file name wins and the recorded id is not used',
+    'foreign.skip.mcp-server-id-conflict': 'The same MCP server name appears in several places (global / project / plugin): the first one wins, and the other duplicates are reported but not migrated',
+    'foreign.skip.project-scan-truncated': 'Many projects were found: the project-level scan only covered the projects within the limit; the remaining projects were not read and their configuration is not in this bundle',
     // Per-item text for the three known lossy behaviours (F-5), rendered by
     // src/ui/foreign-view.ts; the card chrome keys live in src/client/locales.ts.
     'foreign.lossy.file-section-secrets.title': 'Plaintext in file-based sections is never stripped',

package/lib/ui/rollback-view.d.ts

@@ -425,6 +425,12 @@ export interface RollbackSegmentResult {
     /** 无法安全撤销 ⇒ 未写（宿主回传才有） */
     unavailableCount?: number;
     unavailablePaths?: string[];
+    /**
+     * **落点无人认领**（时间窗证据表明那一刻没有任何会话活跃：手改 / 外部工具 / 另一个进程）
+     * ⇒ 未写（宿主回传才有）。与 unavailableCount 分开：成因不同，用户要做的事也不同。
+     */
+    externalCount?: number;
+    externalPaths?: string[];
     /** 写入前发现又被改过（并发）⇒ 未写（宿主回传才有） */
     concurrentCount?: number;
     concurrentPaths?: string[];
@@ -875,6 +881,12 @@ export interface RollbackRewindRowView {
     unavailableCount: number;
     /** 写入前发现又被改过（并发）未写的文件数 */
     concurrentCount: number;
+    /**
+     * **落点无人认领**未写的文件数 + 有界清单（2026-10-18）：时间窗表明改这条路径的那一刻
+     * 没有任何会话活跃 ⇒ 手改 / 外部工具 / 另一个 DSH 进程。0 = 没有（或宿主没回传）。
+     */
+    unclaimedCount: number;
+    unclaimedPaths: string[];
 }
 export declare function rollbackRewindRows(result: RollbackRewindResult | null): RollbackRewindRowView[];
 /** 回退总体结论 → 字典键 + 徽章语义（未知回落 unknown，绝不裸渲染 outcome）。 */

package/lib/ui/rollback-view.js

@@ -737,6 +737,8 @@ export function rollbackRewindRows(result) {
             conflictPaths: redactLines(segment.conflictPaths),
             unavailableCount: numberOrNull(segment.unavailableCount) ?? 0,
             concurrentCount: numberOrNull(segment.concurrentCount) ?? 0,
+            unclaimedCount: numberOrNull(segment.externalCount) ?? 0,
+            unclaimedPaths: redactLines(segment.externalPaths),
         };
     });
 }

package/lib/ui/sync-settings-view.d.ts

@@ -464,4 +464,51 @@ export declare function canRecloneWorkdir(workDir: {
     };
     error?: string;
 } | undefined): boolean;
+/**
+ * 是否可以「采纳远端历史」（issue #104）：前提与「重新克隆」相同（自检成功、目录里确实是 git
+ * 工作副本），区别只在破坏性 —— adopt 不删任何本地提交，可以 revert。
+ *
+ * 为什么**不**要求 workDir.match：issue #104 的触发路径恰恰是 mismatch（用户把仓库地址改成另一个
+ * 仓库后，自检看到 origin 仍指旧地址）。adopt 内部第一步就是 reconcileOrigin + fetch 当前配置地址，
+ * 所以 mismatch 正是该给这个入口的时候。地址还没跟上时先 relink 也行，但两键并不互斥。
+ */
+export declare function canAdoptWorkdir(workDir: {
+    facts?: {
+        exists: boolean;
+        match: boolean;
+    };
+    error?: string;
+} | undefined): boolean;
+/**
+ * 工作副本的「积压」判定（issue #104 建议 3）。
+ *
+ * 要回答的是 issue 里那个拖了两周才暴露的问题：本地一直在攒提交，远端从来没收到过快照，
+ * 而界面没有任何一处说这件事。判定只用状态接口回传的两个数字（`ahead` / `remoteSnapshots`），
+ * 任何一个是 null（没走 detail 自检 / 无远端分支）就不猜 —— 返回 unknown，不渲染告警。
+ *
+ *  - clean：没有未上传的提交；
+ *  - never-synced：本地领先且远端零快照 ⇒ **醒目告警**（这条通道可能一直没在真正备份）；
+ *  - ahead：本地领先，但远端确实收到过快照（只是还没推完）。
+ */
+export type WorkdirBacklog = {
+    kind: 'unknown';
+} | {
+    kind: 'clean';
+    ahead: number;
+    remoteSnapshots: number;
+} | {
+    kind: 'ahead';
+    ahead: number;
+    remoteSnapshots: number;
+} | {
+    kind: 'never-synced';
+    ahead: number;
+};
+export declare function workdirBacklog(workDir: {
+    facts?: {
+        ahead?: number | null;
+        remoteSnapshots?: number | null;
+    };
+    error?: string;
+} | undefined): WorkdirBacklog;
 export declare function formatSyncUrlPreview(url: string, max?: number): string;

package/lib/ui/sync-settings-view.js

@@ -538,6 +538,30 @@ export function needsWorkdirRelink(workDir) {
 export function canRecloneWorkdir(workDir) {
     return workDir !== undefined && workDir.error === undefined && workDir.facts?.exists === true;
 }
+/**
+ * 是否可以「采纳远端历史」（issue #104）：前提与「重新克隆」相同（自检成功、目录里确实是 git
+ * 工作副本），区别只在破坏性 —— adopt 不删任何本地提交，可以 revert。
+ *
+ * 为什么**不**要求 workDir.match：issue #104 的触发路径恰恰是 mismatch（用户把仓库地址改成另一个
+ * 仓库后，自检看到 origin 仍指旧地址）。adopt 内部第一步就是 reconcileOrigin + fetch 当前配置地址，
+ * 所以 mismatch 正是该给这个入口的时候。地址还没跟上时先 relink 也行，但两键并不互斥。
+ */
+export function canAdoptWorkdir(workDir) {
+    return canRecloneWorkdir(workDir);
+}
+export function workdirBacklog(workDir) {
+    if (workDir === undefined || workDir.error !== undefined)
+        return { kind: 'unknown' };
+    const ahead = workDir.facts?.ahead;
+    const remoteSnapshots = workDir.facts?.remoteSnapshots;
+    if (typeof ahead !== 'number' || typeof remoteSnapshots !== 'number')
+        return { kind: 'unknown' };
+    if (ahead <= 0)
+        return { kind: 'clean', ahead, remoteSnapshots };
+    if (remoteSnapshots === 0)
+        return { kind: 'never-synced', ahead };
+    return { kind: 'ahead', ahead, remoteSnapshots };
+}
 export function formatSyncUrlPreview(url, max = 60) {
     return url.slice(0, max);
 }

package/lib/ui/types.d.ts

@@ -234,6 +234,22 @@ export interface RecoveryIncident {
     reason: string;
     createdAt: string;
 }
+/**
+ * 正在**正常执行中**的操作（GET /recovery/status 的 `live`，加法字段）。
+ *
+ * 与 `incidents` 互斥：同一条 active journal 要么是「正在跑」（GLOBAL 锁由它持有、
+ * 且 journal.ownerInstanceId 与锁持有者一致），要么是「一次未正常完成的操作」。
+ * 判别只发生在宿主侧（single source = recovery-orchestrator 的 isLiveInFlight），
+ * 客户端只负责如实展示。
+ *
+ * 旧宿主不返回 → undefined（面板按「无进行中操作」处理）。
+ */
+export interface RecoveryActiveOperation {
+    operationId: string;
+    operationType: string;
+    state: string;
+    startedAt: string;
+}
 /** GET /recovery/status 响应。 */
 export interface RecoveryStatus {
     incidents: RecoveryIncident[];
@@ -241,6 +257,11 @@ export interface RecoveryStatus {
         runId: string;
         status: string;
     }[];
+    /**
+     * 正在正常执行的操作（不是 incident）。用途：面板要能解释「为什么现在什么都点不动」——
+     * 此前这类操作被误报成事故，「执行恢复」永久灰、放弃恢复一直 423，用户拿不到任何原因。
+     */
+    live?: RecoveryActiveOperation[];
     /**
      * 环境锁状态摘要（issue #31）。纯残留锁**不是** journal：进程在 op 期间被杀时
      * `journalId: null`、`transactions/active/` 为空，incidents 恒为 []，而 423 文案却

package/lib/utils/env-lock.d.ts

@@ -409,6 +409,7 @@ export declare class EnvironmentLockManager {
         state: LockState;
         detail?: string;
         corruptOwnership?: boolean;
+        ownerInstanceId?: string;
     }>;
     /**
      * 显式 stale recovery（独立动作；对应 CLI `--recover-stale-lock`）。

package/lib/utils/env-lock.js

@@ -810,7 +810,9 @@ export class EnvironmentLockManager {
         const now = this.now();
         const heartbeatFresh = heartbeat !== null && (now - heartbeat.heartbeatAt) <= this.staleAfterMs;
         if (heartbeatFresh) {
-            return { state: 'LOCKED', detail: `owner op=${rec.op} pid=${rec.owner.pid} (heartbeat fresh)` };
+            // ownerInstanceId 供**宿主内部**做 journal↔锁归属匹配（recovery status 的 in-flight 判定）。
+            // 它不是诊断文案：绝不进 HTTP 响应体（编排器只消费，不回传）。
+            return { state: 'LOCKED', ownerInstanceId: rec.owner.instanceId, detail: `owner op=${rec.op} pid=${rec.owner.pid} (heartbeat fresh)` };
         }
         // heartbeat 已过期：先探测 PID liveness（kill(pid,0) 跨平台可靠；ESRCH = 确证不存在）
         let ident;
@@ -822,7 +824,7 @@ export class EnvironmentLockManager {
         }
         // 确证死亡（ESRCH）→ STALE（不依赖 OS identity 能力）
         if (!ident.alive) {
-            return { state: 'STALE_LOCK_DETECTED', detail: utilsMsg('utils.envLock.ownerConfirmedDead', { pid: rec.owner.pid }) };
+            return { state: 'STALE_LOCK_DETECTED', ownerInstanceId: rec.owner.instanceId, detail: utilsMsg('utils.envLock.ownerConfirmedDead', { pid: rec.owner.pid }) };
         }
         // PID 存活：需 OS identity 区分「reuse」与「同一进程 alive（heartbeat degraded）」
         // —— capability/值缺失 → 无法可靠确定 → UNKNOWN_STATE（保守拒删）
@@ -835,6 +837,7 @@ export class EnvironmentLockManager {
             if (longExpired !== null) {
                 return {
                     state: 'STALE_LOCK_DETECTED',
+                    ownerInstanceId: rec.owner.instanceId,
                     detail: utilsMsg('utils.envLock.ownerAliveUnverifiable', { pid: rec.owner.pid, longExpired }),
                 };
             }
@@ -844,10 +847,10 @@ export class EnvironmentLockManager {
             };
         }
         if (rec.owner.osProcessStartIdentity !== ident.osProcessStartIdentity) {
-            return { state: 'STALE_LOCK_DETECTED', detail: utilsMsg('utils.envLock.pidReuse', { pid: rec.owner.pid }) };
+            return { state: 'STALE_LOCK_DETECTED', ownerInstanceId: rec.owner.instanceId, detail: utilsMsg('utils.envLock.pidReuse', { pid: rec.owner.pid }) };
         }
         // alive 且 identity 相同 → owner alive（heartbeat degraded 保护）
-        return { state: 'LOCKED', detail: utilsMsg('utils.envLock.ownerAliveDegraded') };
+        return { state: 'LOCKED', ownerInstanceId: rec.owner.instanceId, detail: utilsMsg('utils.envLock.ownerAliveDegraded') };
     }
     /* ------------------------------------------------------------ recover (explicit) */
     /**