dsh-config-manager 0.1.78 → 0.1.80

package/lib/sync/merge.js

@@ -1,4 +1,5 @@
 import { hashSection } from './sync-state.js';
+import { mergeBytesThreeWay, mergeJsonValues } from './text-merge.js';
 /** 收集 local/remote/ancestor 三个快照中出现过的所有分区 id。 */
 function unionSectionIds(local, remote, ancestor) {
     const ids = new Set();
@@ -57,75 +58,71 @@ function deepEqual(a, b) {
             return false;
     return true;
 }
-/** JSON 分区精细合并：按 top-level key 走三方合并。
- *  - 双侧均未改 → 跳过
- *  - 仅一侧改   → 采纳该侧
- *  - 双侧均改   → 若 deepEqual 自动合并；否则留为冲突 */
-function mergeJsonSectionGranular(local, remote, ancestor) {
-    const merged = {};
-    const conflicts = [];
-    const keys = new Set([...Object.keys(local), ...Object.keys(remote), ...(ancestor ? Object.keys(ancestor) : [])]);
-    for (const k of keys) {
-        const lHas = Object.prototype.hasOwnProperty.call(local, k);
-        const rHas = Object.prototype.hasOwnProperty.call(remote, k);
-        const aHas = ancestor ? Object.prototype.hasOwnProperty.call(ancestor, k) : false;
-        const lv = lHas ? local[k] : undefined;
-        const rv = rHas ? remote[k] : undefined;
-        const av = aHas ? ancestor[k] : undefined;
-        if (lHas && rHas) {
-            if (deepEqual(lv, rv)) {
-                merged[k] = lv;
-                continue;
-            }
-            // 双侧都有该 key 但值不同 → 看是否都改过
-            const lChanged = !aHas || !deepEqual(lv, av);
-            const rChanged = !aHas || !deepEqual(rv, av);
-            if (lChanged && rChanged) {
-                if (deepEqual(lv, rv)) {
-                    merged[k] = lv; // 两侧改后恰好相同
-                }
-                else {
-                    conflicts.push({ path: k, kind: 'key', local: lv, remote: rv, ancestor: av });
-                }
-            }
-            else if (lChanged) {
-                merged[k] = lv;
-            }
-            else if (rChanged) {
-                merged[k] = rv;
-            }
-            else {
-                merged[k] = lv; // 双侧都未相对祖先改但 deepEqual 已失败——保持一致
-            }
-        }
-        else if (lHas && !rHas) {
-            // 仅本地有：删/改/增？
-            const lChanged = !aHas || !deepEqual(lv, av);
-            if (lChanged) {
-                // 本地增/改，远程删 → 冲突
-                conflicts.push({ path: k, kind: 'key', local: lv, remote: undefined, ancestor: av });
-            }
-            else {
-                // 本地等于祖先、远程缺：远程删 → 跟随删除
-            }
-        }
-        else if (!lHas && rHas) {
-            const rChanged = !aHas || !deepEqual(rv, av);
-            if (rChanged) {
-                // 本地删、远程增 → 冲突
-                conflicts.push({ path: k, kind: 'key', local: undefined, remote: rv, ancestor: av });
-            }
-            else {
-                // 远程等于祖先、本地缺：本地删 → 跟随删除
-            }
-        }
-        else {
-            // 仅祖先有：双侧都删 → 跟随删除
-        }
+function isPlainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+/** 与 sync-state 的判定保持一致（鸭子类型）：{ version: 1, files: [...] }。 */
+function isFilesSectionData(data) {
+    if (data === null || typeof data !== 'object')
+        return false;
+    const obj = data;
+    return obj.version === 1 && Array.isArray(obj.files);
+}
+function bytesEqual(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/** 文本/字节级合并产出的冲突成因 → 统一冲突成因。 */
+function mapConflictReason(reason) {
+    switch (reason) {
+        case 'array': return 'array';
+        case 'format': return 'format';
+        case 'binary': return 'binary';
+        case 'too-large': return 'too-large';
+        default: return 'both-modified'; // 'overlap'（文本行重叠）= 双侧改同一处，统一口径
+    }
+}
+function fromTextConflicts(list) {
+    return list.map((c) => ({
+        path: c.path === '' ? '$' : c.path,
+        kind: 'key',
+        reason: mapConflictReason(c.reason),
+        autoMergeAttempted: true,
+        ...(c.local !== undefined ? { local: c.local } : {}),
+        ...(c.remote !== undefined ? { remote: c.remote } : {}),
+        ...(c.ancestor !== undefined ? { ancestor: c.ancestor } : {}),
+    }));
+}
+/**
+ * 统计「自动合并并入了几个变更点」：叶子级比较，双侧值不同且合并结果取到一侧即计 1。
+ * 只统计对象叶子（数组按整体 1 个点），口径 = 用户能感知的「两边各自的改动都保住了」处数。
+ */
+function countMergePoints(local, remote, merged) {
+    if (isPlainObject(local) && isPlainObject(remote) && isPlainObject(merged)) {
+        const keys = new Set([...Object.keys(local), ...Object.keys(remote), ...Object.keys(merged)]);
+        let n = 0;
+        for (const k of keys)
+            n += countMergePoints(local[k], remote[k], merged[k]);
+        return n;
+    }
+    if (Array.isArray(local) || Array.isArray(remote) || Array.isArray(merged)) {
+        return deepEqual(local, remote) ? 0 : 1;
     }
-    return { merged, conflicts };
+    return deepEqual(local, remote) ? 0 : 1;
 }
-/** FilesSection 精细合并：按 relativePath 走三方合并（按文件字节 deepEqual）。 */
+/**
+ * FilesSection 精细合并：按 relativePath 逐文件三方合并。
+ *  - 双侧都改且内容不同 → 先尝试行级三方合并（文本/JSON）；成功并入，失败留冲突（reason 如实）；
+ *  - 只有一侧改 → 采纳改动侧；
+ *  - 一侧删、另一侧改/新增 → modify-delete / delete-modify 冲突（绝不直接删数据）；
+ *  - 一侧删、另一侧未改 → 跟随删除。
+ */
 function mergeFilesSectionGranular(local, remote, ancestor) {
     const lMap = new Map();
     for (const f of local.files)
@@ -140,84 +137,197 @@ function mergeFilesSectionGranular(local, remote, ancestor) {
     const paths = new Set([...lMap.keys(), ...rMap.keys(), ...aMap.keys()]);
     const mergedFiles = [];
     const conflicts = [];
-    for (const p of paths) {
-        const l = lMap.get(p);
-        const r = rMap.get(p);
-        const a = aMap.get(p);
-        const eq = (x, y) => {
-            if (x === undefined || y === undefined)
-                return x === y;
-            if (x.length !== y.length)
-                return false;
-            for (let i = 0; i < x.length; i++)
-                if (x[i] !== y[i])
-                    return false;
-            return true;
-        };
-        if (l && r) {
-            if (eq(l, r)) {
-                mergedFiles.push({ relativePath: p, data: l, contentHash: '' });
+    let mergePoints = 0;
+    const push = (relativePath, data) => {
+        mergedFiles.push({ relativePath, data, contentHash: '' });
+    };
+    for (const path of [...paths].sort()) {
+        const l = lMap.get(path);
+        const r = rMap.get(path);
+        const a = aMap.get(path);
+        if (l !== undefined && r !== undefined) {
+            if (bytesEqual(l, r)) {
+                push(path, l);
                 continue;
             }
-            const lChanged = !a || !eq(l, a);
-            const rChanged = !a || !eq(r, a);
+            const lChanged = a === undefined || !bytesEqual(l, a);
+            const rChanged = a === undefined || !bytesEqual(r, a);
             if (lChanged && rChanged) {
-                conflicts.push({ path: p, kind: 'file', local: l, remote: r, ancestor: a });
-            }
-            else if (lChanged) {
-                mergedFiles.push({ relativePath: p, data: l, contentHash: '' });
+                const attempt = mergeBytesThreeWay(a, l, r);
+                if (attempt.ok && attempt.merged !== undefined) {
+                    push(path, attempt.merged);
+                    mergePoints += 1;
+                    continue;
+                }
+                conflicts.push({
+                    path,
+                    kind: 'file',
+                    reason: attempt.kind === 'binary' || attempt.kind === 'too-large'
+                        ? (attempt.kind === 'binary' ? 'binary' : 'too-large')
+                        : 'both-modified',
+                    autoMergeAttempted: true,
+                    local: l,
+                    remote: r,
+                    ancestor: a,
+                });
+                continue;
             }
-            else if (rChanged) {
-                mergedFiles.push({ relativePath: p, data: r, contentHash: '' });
+            if (lChanged) {
+                push(path, l);
+                mergePoints += 1;
+                continue;
             }
-            else {
-                mergedFiles.push({ relativePath: p, data: l, contentHash: '' });
+            if (rChanged) {
+                push(path, r);
+                mergePoints += 1;
+                continue;
             }
+            push(path, l);
+            continue;
         }
-        else if (l && !r) {
+        if (l !== undefined && r === undefined) {
             const aExists = a !== undefined;
-            const lChanged = aExists ? !eq(l, a) : true;
-            if (lChanged) {
-                if (!aExists) {
-                    // 纯本地新增（祖先里也没有）→ keepLocal
-                    mergedFiles.push({ relativePath: p, data: l, contentHash: '' });
-                }
-                else {
-                    // 本地改/增 vs 远程删 → 冲突
-                    conflicts.push({ path: p, kind: 'file', local: l, remote: undefined, ancestor: a });
-                }
-            }
+            if (aExists && bytesEqual(l, a))
+                continue; // 本地未改、远端删 → 跟随删除
+            if (!aExists) {
+                push(path, l);
+                mergePoints += 1;
+                continue;
+            } // 纯本地新增
+            conflicts.push({ path, kind: 'file', reason: 'modify-delete', local: l, remote: undefined, ancestor: a });
+            continue;
         }
-        else if (!l && r) {
+        if (l === undefined && r !== undefined) {
             const aExists = a !== undefined;
-            const rChanged = aExists ? !eq(r, a) : true;
-            if (rChanged) {
-                if (!aExists) {
-                    // 纯远程新增（祖先里也没有）→ useRemote
-                    mergedFiles.push({ relativePath: p, data: r, contentHash: '' });
-                }
-                else {
-                    // 本地删 vs 远程改/增 → 冲突
-                    conflicts.push({ path: p, kind: 'file', local: undefined, remote: r, ancestor: a });
-                }
-            }
+            if (aExists && bytesEqual(r, a))
+                continue; // 远端未改、本地删 → 跟随删除
+            if (!aExists) {
+                push(path, r);
+                mergePoints += 1;
+                continue;
+            } // 纯远端新增
+            conflicts.push({ path, kind: 'file', reason: 'delete-modify', local: undefined, remote: r, ancestor: a });
+            continue;
         }
+        // 双侧都删（或仅祖先有）：跟随删除，不产生动作。
     }
-    return { merged: { version: 1, files: mergedFiles }, conflicts };
+    return { merged: { version: 1, files: mergedFiles }, conflicts, mergePoints };
 }
-/** 识别 JSON 分区的「键级合并」键值映射（如 settings/ui 的 namespaces、providers 的 providers）。
- * 返回 undefined → 该分区无法做键级合并，调用方应退化为整分区冲突。 */
-function keyMapOf(data) {
-    const obj = data;
-    if (obj && typeof obj === 'object' && obj['version'] === 1) {
-        const ns = obj['namespaces'];
-        if (ns && typeof ns === 'object' && !Array.isArray(ns))
-            return ns;
-        const prov = obj['providers'];
-        if (prov && typeof prov === 'object' && !Array.isArray(prov))
-            return prov;
+/** 单分区三方合并（决策链见文件头注释）。 */
+function mergeSectionTriple(id, lData, rData, aData, h) {
+    // ⓪ 形状闸门（先于一切取舍）：远端载荷来自不可信输入（解析层只保证整体是合法 JSON，
+    //    不保证每个分区的值形状正确）。值形状不对时**绝不原样采用** —— 那等于把畸形数据
+    //    写进本机配置；一律按 conflict(reason='format') 交用户裁决。
+    if (lData !== undefined && !isPlainObject(lData)) {
+        return {
+            id,
+            decision: 'conflict',
+            conflicts: [{ path: '$', kind: 'key', reason: 'format', autoMergeAttempted: false, local: lData, remote: rData, ancestor: aData }],
+        };
+    }
+    if (rData !== undefined && !isPlainObject(rData)) {
+        return {
+            id,
+            decision: 'conflict',
+            conflicts: [{ path: '$', kind: 'key', reason: 'format', autoMergeAttempted: false, local: lData, remote: rData, ancestor: aData }],
+        };
+    }
+    // ① 远端无该分区：本地未改 → 无变化；本地改了 → 冲突（不准把本地改动当垃圾丢掉）
+    if (rData === undefined && lData !== undefined) {
+        const lChanged = h.ancestor === undefined || h.local !== h.ancestor;
+        if (!lChanged)
+            return { id, decision: 'skip', conflicts: [] };
+        return {
+            id,
+            decision: 'conflict',
+            conflicts: [{
+                    path: '$',
+                    kind: 'key',
+                    reason: h.ancestor === undefined ? 'no-ancestor' : 'modify-delete',
+                    autoMergeAttempted: false,
+                    local: lData,
+                    remote: undefined,
+                    ancestor: aData,
+                }],
+        };
+    }
+    // ② 本地无该分区、远端有：远端未改 → 无变化；远端改了 → 采用远端（分区缺失不是删除语义，见文件头）
+    if (lData === undefined && rData !== undefined) {
+        const rChanged = h.ancestor === undefined || h.remote !== h.ancestor;
+        if (!rChanged)
+            return { id, decision: 'skip', conflicts: [] };
+        return { id, decision: 'useRemote', merged: rData, conflicts: [] };
     }
-    return undefined;
+    if (lData === undefined && rData === undefined)
+        return { id, decision: 'skip', conflicts: [] };
+    const local = lData;
+    const remote = rData;
+    if (h.local === h.remote)
+        return { id, decision: 'skip', conflicts: [] };
+    // 分区形态互换（一侧 FilesSection、一侧 JSON 分区）→ 早于 useRemote/keepLocal 判冲突：
+    // 「远端改了、本地没改」不足以支撑把另一种形态的数据整分区写进本机（语义不同，采用必错）。
+    if (isFilesSectionData(local) !== isFilesSectionData(remote)) {
+        return {
+            id,
+            decision: 'conflict',
+            conflicts: [{ path: '$', kind: 'key', reason: 'section', autoMergeAttempted: false, local, remote, ancestor: aData }],
+        };
+    }
+    if (h.ancestor === undefined) {
+        return {
+            id,
+            decision: 'conflict',
+            conflicts: [{ path: '$', kind: 'key', reason: 'no-ancestor', autoMergeAttempted: false, local, remote, ancestor: undefined }],
+        };
+    }
+    if (h.local === h.ancestor)
+        return { id, decision: 'useRemote', merged: remote, conflicts: [] };
+    if (h.remote === h.ancestor)
+        return { id, decision: 'keepLocal', merged: local, conflicts: [] };
+    // ③ 双侧相对祖先都改 → 精细合并（形状与形态闸门已在 ⓪/前段通过）
+    if (isFilesSectionData(local) && isFilesSectionData(remote)) {
+        const aFiles = aData !== undefined && isFilesSectionData(aData) ? aData : undefined;
+        const { merged, conflicts, mergePoints } = mergeFilesSectionGranular(local, remote, aFiles);
+        if (conflicts.length === 0 && mergePoints > 0) {
+            return { id, decision: 'merge', merged, conflicts: [], autoMerged: mergePoints };
+        }
+        if (conflicts.length === 0) {
+            // 双侧都改但合并结果与某一侧逐字相同 → 如实报是哪一侧赢了（不谎称「合并」）
+            const mh = hashSection(merged);
+            if (mh === h.remote)
+                return { id, decision: 'useRemote', merged, conflicts: [] };
+            if (mh === h.local)
+                return { id, decision: 'keepLocal', merged, conflicts: [] };
+            return { id, decision: 'merge', merged, conflicts: [], autoMerged: 0 };
+        }
+        return { id, decision: 'conflict', conflicts };
+    }
+    if (isPlainObject(local) && isPlainObject(remote)) {
+        const aJson = aData !== undefined && isPlainObject(aData) ? aData : undefined;
+        const res = mergeJsonValues(aJson, local, remote);
+        if (!res.ok || res.merged === undefined) {
+            const conflicts = res.conflicts.length > 0
+                ? fromTextConflicts(res.conflicts)
+                : [{ path: '$', kind: 'key', reason: 'format', autoMergeAttempted: true, local, remote, ancestor: aData }];
+            return { id, decision: 'conflict', conflicts };
+        }
+        const merged = res.merged;
+        if (res.conflicts.length === 0) {
+            const mh = hashSection(merged);
+            if (mh === h.remote)
+                return { id, decision: 'useRemote', merged, conflicts: [] };
+            if (mh === h.local)
+                return { id, decision: 'keepLocal', merged, conflicts: [] };
+            return { id, decision: 'merge', merged, conflicts: [], autoMerged: countMergePoints(local, remote, merged) };
+        }
+        return { id, decision: 'conflict', conflicts: fromTextConflicts(res.conflicts) };
+    }
+    // 类型不一致（一侧 FilesSection、一侧 JSON）或非对象 → 整分区冲突，交用户裁决
+    return {
+        id,
+        decision: 'conflict',
+        conflicts: [{ path: '$', kind: 'key', reason: 'section', autoMergeAttempted: false, local, remote, ancestor: aData }],
+    };
 }
 /** 主入口：三方合并。纯函数，无副作用。 */
 export function merge(local, remote, ancestor) {
@@ -228,98 +338,8 @@ export function merge(local, remote, ancestor) {
     const hashes = computeHashes(l, r, a, ids);
     const results = [];
     for (const id of ids) {
-        const h = hashes.get(id);
-        const lData = l[id];
-        const rData = r[id];
-        const aData = a ? a[id] : undefined;
-        // 远端无 → skip（不在本轮考虑；本地有但远端没有 = 远端"删了"，视作 useRemote=删除）
-        // 本实现按远端视角：远端缺 + 本地存在 + 本地未改祖先 → skip(无变化)；否则冲突。
-        if (rData === undefined && lData !== undefined) {
-            const lChanged = h.ancestor === undefined || h.local !== h.ancestor;
-            if (!lChanged) {
-                results.push({ id, decision: 'skip', conflicts: [] });
-                continue;
-            }
-            results.push({ id, decision: 'conflict', conflicts: [{ path: '$', kind: 'key', local: lData, remote: undefined, ancestor: aData }] });
-            continue;
-        }
-        // 本地无、远端有：远端新增；本地删除过（=等于祖先空）+祖先空→skip；否则按 useRemote。
-        if (lData === undefined && rData !== undefined) {
-            const rChanged = h.ancestor === undefined || h.remote !== h.ancestor;
-            if (!rChanged) {
-                results.push({ id, decision: 'skip', conflicts: [] });
-                continue;
-            }
-            results.push({ id, decision: 'useRemote', merged: rData, conflicts: [] });
-            continue;
-        }
-        // 双方都没有 → skip
-        if (lData === undefined && rData === undefined) {
-            results.push({ id, decision: 'skip', conflicts: [] });
-            continue;
-        }
-        // 双方都有
-        if (h.local === h.remote) {
-            results.push({ id, decision: 'skip', conflicts: [] });
-            continue;
-        }
-        if (h.ancestor === undefined) {
-            // 无祖先 → 两方差异视为整分区冲突（不猜测）
-            results.push({ id, decision: 'conflict', conflicts: [{ path: '$', kind: 'key', local: lData, remote: rData, ancestor: undefined }] });
-            continue;
-        }
-        if (h.local === h.ancestor) {
-            results.push({ id, decision: 'useRemote', merged: rData, conflicts: [] });
-            continue;
-        }
-        if (h.remote === h.ancestor) {
-            results.push({ id, decision: 'keepLocal', merged: lData, conflicts: [] });
-            continue;
-        }
-        // 双侧相对祖先都改 → 进入精细合并
-        if (isFilesSectionData(lData)) {
-            const { merged, conflicts } = mergeFilesSectionGranular(lData, rData, aData);
-            if (conflicts.length === 0) {
-                results.push({ id, decision: 'useRemote', merged: merged, conflicts: [] });
-            }
-            else {
-                results.push({ id, decision: 'conflict', conflicts, merged: undefined });
-            }
-            continue;
-        }
-        // JSON 分区：识别可键级合并的子映射（namespaces / providers）
-        const lKeyMap = keyMapOf(lData);
-        const rKeyMap = keyMapOf(rData);
-        const aKeyMap = aData ? keyMapOf(aData) : undefined;
-        if (lKeyMap && rKeyMap) {
-            const { merged: mergedKeys, conflicts } = mergeJsonSectionGranular(lKeyMap, rKeyMap, aKeyMap);
-            // 重组 SectionData：用 l/r 中较新者保留非键级合并字段（version 等），键级合并字段用 mergedKeys
-            const lObj = lData;
-            const rObj = rData;
-            const base = { ...lObj, ...rObj };
-            // 找到键级合并字段在 base 中的键名
-            const keyFieldName = lKeyMap === lObj['namespaces'] ? 'namespaces'
-                : lKeyMap === lObj['providers'] ? 'providers' : undefined;
-            if (keyFieldName)
-                base[keyFieldName] = mergedKeys;
-            if (conflicts.length === 0) {
-                results.push({ id, decision: 'useRemote', merged: base, conflicts: [] });
-            }
-            else {
-                results.push({ id, decision: 'conflict', conflicts, merged: undefined });
-            }
-            continue;
-        }
-        // 非键级合并 JSON 分区（plugins/mcp/prompts/workspaces 等）：退化为整分区冲突
-        results.push({ id, decision: 'conflict', conflicts: [{ path: '$', kind: 'key', local: lData, remote: rData, ancestor: aData }] });
+        results.push(mergeSectionTriple(id, l[id], r[id], a ? a[id] : undefined, hashes.get(id)));
     }
     return { sections: results };
 }
-/** 分区是否为文件类（FilesSection）—— 鸭子类型，复用 sync-state 的判定以保持一致。 */
-function isFilesSectionData(data) {
-    if (data === null || typeof data !== 'object')
-        return false;
-    const obj = data;
-    return obj.version === 1 && Array.isArray(obj.files);
-}
 //# sourceMappingURL=merge.js.map

package/lib/sync/messages.d.ts

@@ -58,6 +58,14 @@ export declare const zh: {
     readonly 'sync.backupHistorySkipped': '{trigger}跳过：{reason}';
     readonly 'sync.backupHistoryFailed': '{trigger}失败';
     readonly 'sync.pushPreviewUnpackedLocalSources': '本地源插件（link:/file:）需打包才能精确比对变更，分区 {sections} 本次按「有变化」展示';
+    readonly 'sync.probeUnsupported': '当前同步通道不支持连通性自检';
+    readonly 'sync.webdav.concurrentWrite': '远端索引已被其它设备更新（HTTP 412）：本次写入已中止，请重新同步后再试';
+    readonly 'sync.webdav.probeOk': '连接正常（远端 {count} 份快照）';
+    readonly 'sync.webdav.probeUnreachable': 'WebDAV 目录不可访问（HTTP {status}）：{url}';
+    readonly 'sync.webdav.collectionCreated': '已自动创建远端目录：{path}';
+    readonly 'sync.webdav.collectionCreateFailed': '创建远端目录失败（HTTP {status}）：{path}';
+    readonly 'sync.deviceNameFallback': '未命名设备';
+    readonly 'sync.git.probeOk': '连接正常（远端可达、凭据可用）';
 };
 export declare const en: Record<keyof typeof zh, string>;
 /** 本域活翻译器（与 core 的 engineMsg 同一实现；导入本模块即完成目录注册）。 */

package/lib/sync/messages.js

@@ -85,6 +85,17 @@ export const zh = {
     'sync.backupHistoryFailed': '{trigger}失败',
     // ---------- 推送前只读预览（issue #91） ----------
     'sync.pushPreviewUnpackedLocalSources': '本地源插件（link:/file:）需打包才能精确比对变更，分区 {sections} 本次按「有变化」展示',
+    // ---------- cloud-sync 借鉴项 ①②③：条件写 / 探针 / 首连自建目录 ----------
+    'sync.probeUnsupported': '当前同步通道不支持连通性自检',
+    'sync.webdav.concurrentWrite': '远端索引已被其它设备更新（HTTP 412）：本次写入已中止，请重新同步后再试',
+    'sync.webdav.probeOk': '连接正常（远端 {count} 份快照）',
+    'sync.webdav.probeUnreachable': 'WebDAV 目录不可访问（HTTP {status}）：{url}',
+    'sync.webdav.collectionCreated': '已自动创建远端目录：{path}',
+    'sync.webdav.collectionCreateFailed': '创建远端目录失败（HTTP {status}）：{path}',
+    // ---------- cloud-sync 借鉴项 ⑥：设备身份 ----------
+    'sync.deviceNameFallback': '未命名设备',
+    // ---------- git 通道连通性探针（cloud-sync 借鉴项 ②，补齐四通道） ----------
+    'sync.git.probeOk': '连接正常（远端可达、凭据可用）',
 };
 export const en = {
     'sync.ancestorSnapshotIdRequired': 'loadAncestor: snapshotId must not be empty',
@@ -145,6 +156,14 @@ export const en = {
     'sync.backupHistorySkipped': '{trigger} skipped: {reason}',
     'sync.backupHistoryFailed': '{trigger} failed',
     'sync.pushPreviewUnpackedLocalSources': 'Local-source plugins (link:/file:) must be packed to compare changes exactly; section(s) {sections} are shown as changed',
+    'sync.probeUnsupported': 'This sync channel does not support a connectivity self-check',
+    'sync.webdav.concurrentWrite': 'The remote index was updated by another device (HTTP 412): this write was aborted, please sync again',
+    'sync.webdav.probeOk': 'Connection OK ({count} remote snapshots)',
+    'sync.webdav.probeUnreachable': 'The WebDAV directory is unreachable (HTTP {status}): {url}',
+    'sync.webdav.collectionCreated': 'Created the remote directory automatically: {path}',
+    'sync.webdav.collectionCreateFailed': 'Failed to create the remote directory (HTTP {status}): {path}',
+    'sync.deviceNameFallback': 'Unnamed device',
+    'sync.git.probeOk': 'Connection OK (remote reachable, credentials accepted)',
 };
 registerMessageCatalog({ id: 'sync-domain', zh, en });
 /** 本域活翻译器（与 core 的 engineMsg 同一实现；导入本模块即完成目录注册）。 */

package/lib/sync/risk.d.ts

@@ -9,8 +9,16 @@
  *    本模块只做分流，`SECTION_RISK_TIER` 是注册表的派生视图（保留给既有调用方）；
  *  - 双向 conflict 分区永远进 review（无论风险与 firstSync 与否）；
  *  - firstSync=true 时所有非 skip 项一律进 review（安全第一：人工确认后才开启自动）；
- *  - firstSync=false 时按风险等级分流：低风险且 useRemote/keepLocal 进 autoApply；
- *    中风险、high、双向冲突 → review；skip 或无变化 → skipped。
+ *  - firstSync=false 时按风险等级分流：决策明确（useRemote / keepLocal / **merge** 即三方精细
+    合并成功）且「风险等级 ≤ maxAutoTier」的分区进 autoApply；超过阈值的、high、双向冲突 → review；
+    skip 或无变化 → skipped。
+ *  - 'merge' 与 useRemote/keepLocal 同等对待：它的 merged 是双方改动的合并结果（不是单侧原值）。
+ *
+ * maxAutoTier（真·自动同步，2026-10）：
+ *  - 缺省 'low' = 改造前的口径（只有低风险分区自动落盘），既有调用方（预览/UI）行为不变；
+ *  - 自动同步按用户配置传 'medium' ⇒ plugins / mcp 的中风险改动也自动落盘。
+ *    这是用户拍板的产品决策：不改这条，「同步所有更改」就只是句口号（中风险分区永远停在待确认）。
+ *  - **high 永远不参与自动应用**：类型上就只允许 low|medium，杜绝「传 high 顺手放行全部」。
  */
 import type { MergePlan, MergeSectionResult } from './merge.ts';
 import type { SectionId } from '../schema/types.ts';
@@ -40,7 +48,16 @@ export interface ClassifyOptions {
      * 调用方在 SyncEngine 中维护 firstSyncCompleted 标志。
      */
     firstSync: boolean;
+    /**
+     * 允许自动落盘的最高风险等级（缺省 'low' = 改造前的行为）。
+     *
+     * 只有自动同步路径会传 'medium'（用户在配置里显式选的，缺省也是 medium）；
+     * high 在类型层面就被排除 —— 那不是「配置项」，是安全边界。
+     */
+    maxAutoTier?: 'low' | 'medium';
 }
+/** 该风险等级是否在允许自动落盘的阈值之内。 */
+export declare function tierWithinAutoApply(tier: RiskTier, maxAutoTier: 'low' | 'medium'): boolean;
 /** 自动应用三组结果（互斥：同一 sectionId 只出现在一组） */
 export interface SyncApplyPlan {
     autoApply: MergeSectionResult[];

package/lib/sync/risk.js

@@ -15,6 +15,12 @@ export const SECTION_RISK_TIER = Object.fromEntries(SECTION_IDS.map((id) => [id,
 export function riskTierOf(id) {
     return sectionMetaOf(id)?.riskTier;
 }
+/** 风险等级序（用于「等级 ≤ 阈值」比较；high 永不满足自动应用，因为阈值上限就是 medium）。 */
+const TIER_RANK = { low: 0, medium: 1, high: 2 };
+/** 该风险等级是否在允许自动落盘的阈值之内。 */
+export function tierWithinAutoApply(tier, maxAutoTier) {
+    return TIER_RANK[tier] <= TIER_RANK[maxAutoTier];
+}
 /**
  * 按风险等级 + firstSync 标志将 MergePlan 分流到三组。
  * 纯函数：相同输入 → 相同输出；不读 fs、不发网络。
@@ -23,6 +29,7 @@ export function classifyMergePlan(plan, opts) {
     const autoApply = [];
     const review = [];
     const skipped = [];
+    const maxAutoTier = opts.maxAutoTier ?? 'low';
     for (const r of plan.sections) {
         // 跳过：决策为 skip（远端缺且本地未改 / 完全无变化）
         if (r.decision === 'skip') {
@@ -45,12 +52,12 @@ export function classifyMergePlan(plan, opts) {
             review.push(r);
             continue;
         }
-        if (tier === 'low') {
-            // 低风险且决策明确（useRemote / keepLocal）→ 自动应用
+        if (tierWithinAutoApply(tier, maxAutoTier)) {
+            // 决策明确（useRemote / keepLocal / merge）且等级在阈值内 → 自动应用
             autoApply.push(r);
         }
         else {
-            // medium / high → 待审
+            // 超过阈值（缺省阈值下即 medium / high）→ 待审
             review.push(r);
         }
     }