dsh-config-manager 0.1.78 → 0.1.80

package/src/sync/webdav/webdav-transport.ts

@@ -41,7 +41,7 @@ import {
 } from '../transport.ts';
 import type { FilesSection, SectionData, SectionId } from '../../schema/types.ts';
 import type {
-  SyncRetryOptions, SyncSnapshot, SyncSnapshotMeta, SyncTransport, SyncTransportErrorOptions,
+  SyncProbeResult, SyncRetryOptions, SyncSnapshot, SyncSnapshotMeta, SyncTransport, SyncTransportErrorOptions,
 } from '../transport.ts';
 import { parseJsonSafe } from '../../utils/json.ts';
 
@@ -70,6 +70,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: string | undefined, indexMissing: boolean): Record<string, string> {
+  if (etag !== undefined) return { 'If-Match': etag };
+  return indexMissing ? { 'If-None-Match': '*' } : {};
+}
+
+/** URL 路径段编码：已百分号编码的段原样保留（先 decode 成功才 re-encode），失败则直接编码。 */
+function encodeSegmentSafe(segment: string): string {
+  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 循环拖死请求） */
@@ -341,7 +375,7 @@ export class WebDavTransport implements SyncTransport {
     // → 必须照常上传，绝不跳过。
     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 会回收**仍被
@@ -376,7 +410,11 @@ export class WebDavTransport implements SyncTransport {
     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));
     }
@@ -422,7 +460,7 @@ export class WebDavTransport implements SyncTransport {
     // 是**缺信息**而非事实，沿用空索引继续会把 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);
@@ -438,7 +476,11 @@ export class WebDavTransport implements SyncTransport {
     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));
     }
@@ -706,13 +748,85 @@ export class WebDavTransport implements SyncTransport {
     }
   }
 
-  /** 幂等创建 snapshots 集合：MKCOL；已存在（405/2xx/3xx）视为成功。 */
-  private async ensureCollection(pwd: string): Promise<void> {
+  /** 幂等创建 snapshots 集合：MKCOL；已存在（2xx/3xx/405/409）视为成功。
+   *
+   * cloud-sync 借鉴项 ③（首连自建）：目标目录的**上级**不存在时（新账号，或用户填了一个还没建的
+   * 目录），按 WebDAV 规范 MKCOL 缺父目录回 409 —— 此前用户必须先去网盘里手工建好目录，否则
+   * 首次同步必然失败。现在：直连 409 时逐级补齐 baseUrl 路径上的每一层，再重试一次。
+   * 返回**本次真正新建**的层级 URL（已存在的层级不进结果，探针据此如实回报，普通上传忽略返回值）。 */
+  private async ensureCollection(pwd: string): Promise<string[]> {
     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 的每一层目录（只有缺父目录时才会走到这里）。 */
+  private async ensureAncestors(pwd: string): Promise<string[]> {
+    const base = new URL(this.o.baseUrl);
+    const segments = base.pathname.split('/').filter((seg) => seg !== '');
+    const created: string[] = [];
+    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 借鉴项 ①）。 */
+  private concurrentWrite(url: string, status: number): WebDavTransportError {
+    return new WebDavTransportError(
+      this.o.msg('sync.webdav.concurrentWrite', { status: String(status), url }),
+      { kind: 'conflict', retryable: false, status },
+    );
+  }
+
+  /**
+   * 连通性探针（cloud-sync 借鉴项 ②）：补齐目标目录 → 证明这真的是一个可读的 WebDAV 集合
+   * → 读一次索引回报快照数。只读；唯一写副作用是幂等 MKCOL 补目录（那正是它要修的故障）。
+   */
+  async probe(): Promise<SyncProbeResult> {
+    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 } : {}),
+    };
   }
 
   /**
@@ -730,14 +844,21 @@ export class WebDavTransport implements SyncTransport {
    * 写路径（**upload / delete**）必须用本方法：`missing` 时既不写回索引、也不触发 GC
    * （upload 另加「远端已有内容 ⇒ 显式中止」的判据，见 upload() 注释）。
    */
-  private async readIndexDetailed(pwd: string): Promise<{ entries: SyncSnapshotMeta[]; missing: boolean }> {
+  private async readIndexDetailed(pwd: string): Promise<{ entries: SyncSnapshotMeta[]; missing: boolean; etag?: string }> {
     const url = this.indexUrl();
     const res = await this.send('GET', url, pwd);
     if (res.status === 404) return { entries: [], missing: true };
     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 } : {}),
+    };
   }
 
   private parseIndex(raw: string, url: string, pwd: string): SyncSnapshotMeta[] {
@@ -789,13 +910,15 @@ export class WebDavTransport implements SyncTransport {
     method: string,
     url: string,
     pwd: string,
-    opts: { body?: string } = {},
+    opts: { body?: string; headers?: Record<string, string> } = {},
   ): Promise<WebDavResponse> {
     const auth = 'Basic ' + Buffer.from(`${this.o.username}:${pwd}`, 'utf8').toString('base64');
     const headers: Record<string, string> = {
       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'));
     try {

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

@@ -62,6 +62,40 @@ test('foreign-view：冻结码逐个有字典键，且键在字典里真实存
   }
 });
 
+/**
+ * 本轮（2026-10-18）新增的 8 个冻结码 —— **显式列出**（不从 Object.keys 派生）：
+ * 全量映射测试只保证「键存在」，本用例额外钉住这几条的 zh/en **都是真文案**（非空、不等于键名、
+ * 且中英不同文）。某一条被删或退回键名时，这里会单独变红，而不是被其它码的表绿掩盖。
+ */
+const NEW_CODES_2026_10_18: readonly ForeignSkipCode[] = [
+  'unsupported-permissions',
+  'unsupported-settings-keys',
+  'unsupported-agents',
+  'unsupported-rules',
+  'unsupported-plugins',
+  'session-id-mismatch',
+  'mcp-server-id-conflict',
+  'project-scan-truncated',
+];
+
+test('foreign-view：8 个新码在中英两套字典里都有非空文案（缺一即裸机器码）', () => {
+  assert.equal(NEW_CODES_2026_10_18.length, 8, '本用例只覆盖本轮那 8 个码（数量变了就必须同步改这里）');
+  for (const code of NEW_CODES_2026_10_18) {
+    const key = FOREIGN_SKIP_KEY[code];
+    assert.equal(key, 'foreign.skip.' + code, code + ' 的键形必须是 foreign.skip.<code>');
+    assert.ok(
+      Object.prototype.hasOwnProperty.call(uiZh, key),
+      code + ' 的字典键 ' + key + ' 在 uiZh 里不存在 —— 界面会显示裸机器码',
+    );
+    for (const [lang, t] of [['zh', zh], ['en', en]] as const) {
+      const text = t(key);
+      assert.ok(text.trim().length > 0, code + ' 的 ' + lang + ' 文案为空');
+      assert.notEqual(text, key, code + ' 的 ' + lang + ' 文案缺失（回退成了键名）');
+    }
+    assert.notEqual(zh(key), en(key), code + ' 的 zh/en 不得同文');
+  }
+});
+
 test('foreign-view：foreignSkipKey 的未知码回退为可搜索的稳定标识（绝不 undefined）', () => {
   const line = foreignSkipLine({ code: 'brand-new-code-from-third-party' as ForeignSkipCode }, zh);
   assert.equal(line.code, 'brand-new-code-from-third-party');

package/src/ui/foreign-view.ts

@@ -137,6 +137,16 @@ export const FOREIGN_SKIP_KEY: Record<ForeignSkipCode, UiTextKey> = {
   // 档 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/src/ui/i18n.ts

@@ -94,6 +94,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} 秒）：未在时限内收到宿主响应，请重试',
@@ -534,6 +535,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': '文件类分区的明文不做剥离',
@@ -660,6 +672,7 @@ export const uiEn: Record<UiTextKey, string> = {
   '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',
@@ -1085,6 +1098,15 @@ export const uiEn: Record<UiTextKey, string> = {
   '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/src/ui/rollback-view.ts

@@ -613,6 +613,12 @@ export interface RollbackSegmentResult {
   /** 无法安全撤销 ⇒ 未写（宿主回传才有） */
   unavailableCount?: number
   unavailablePaths?: string[]
+  /**
+   * **落点无人认领**（时间窗证据表明那一刻没有任何会话活跃：手改 / 外部工具 / 另一个进程）
+   * ⇒ 未写（宿主回传才有）。与 unavailableCount 分开：成因不同，用户要做的事也不同。
+   */
+  externalCount?: number
+  externalPaths?: string[]
   /** 写入前发现又被改过（并发）⇒ 未写（宿主回传才有） */
   concurrentCount?: number
   concurrentPaths?: string[]
@@ -1447,6 +1453,12 @@ export interface RollbackRewindRowView {
   unavailableCount: number
   /** 写入前发现又被改过（并发）未写的文件数 */
   concurrentCount: number
+  /**
+   * **落点无人认领**未写的文件数 + 有界清单（2026-10-18）：时间窗表明改这条路径的那一刻
+   * 没有任何会话活跃 ⇒ 手改 / 外部工具 / 另一个 DSH 进程。0 = 没有（或宿主没回传）。
+   */
+  unclaimedCount: number
+  unclaimedPaths: string[]
 }
 
 export function rollbackRewindRows(result: RollbackRewindResult | null): RollbackRewindRowView[] {
@@ -1480,6 +1492,8 @@ export function rollbackRewindRows(result: RollbackRewindResult | null): Rollbac
       conflictPaths: redactLines(segment.conflictPaths),
       unavailableCount: numberOrNull(segment.unavailableCount) ?? 0,
       concurrentCount: numberOrNull(segment.concurrentCount) ?? 0,
+      unclaimedCount: numberOrNull(segment.externalCount) ?? 0,
+      unclaimedPaths: redactLines(segment.externalPaths),
     }
   })
 }

package/src/ui/sync-settings-view.test.ts

@@ -12,6 +12,7 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 
 import {
+  workdirBacklog,
   autosyncIntervalKey, buildSelectionRequest, buildSyncChannelBody, buildSyncConfigBody, buildSyncPushBody,
   channelBackfillFromStatus, computeEncryptInvalid, encryptToggle, formatSyncStatusTimestamp,
   formatSyncUrlPreview, githubPollDecision, hasSelectedSections, includeSecretsToggle,
@@ -23,8 +24,9 @@ import {
   validateCloudEndpoint, validateCloudForm, validateCloudPrefix, validateCloudRegion, validateGistForm,
   validateGistId, validateS3Form, DEFAULT_S3_PROVIDER, S3_PROVIDERS,
   // issue #79：工作副本自检 → 状态 / 入口判定
-  workdirStateKey, workdirStateBadgeKind, needsWorkdirRelink, canRecloneWorkdir,
+  workdirStateKey, workdirStateBadgeKind, needsWorkdirRelink, canRecloneWorkdir, canAdoptWorkdir,
   type SaveQueueState, type SyncChannelSettings, type SyncFormSnapshot,
+
 } from './sync-settings-view.ts'
 
 /* ------------------------------------------------------------- 夹具 */
@@ -548,3 +550,28 @@ test('issue #79：入口判定 —— 只有地址不一致才给「重指向」
   assert.equal(canRecloneWorkdir({ error: '读取失败' }), false, '读不出来不得提供破坏性入口')
   assert.equal(canRecloneWorkdir(undefined), false)
 })
+
+/* ---------------------------------------------------------------- issue #104 采纳远端历史 */
+
+test('issue #104：canAdoptWorkdir —— 只在工作副本确实存在时给「采纳远端历史」，且不要求 origin 已跟随', () => {
+  // 触发路径恰恰是 mismatch：改仓库地址后 origin 仍指旧地址，pull --ff-only 因两条历史不相交失败。
+  assert.equal(canAdoptWorkdir(workdirFacts({ match: false })), true, 'mismatch 才是主场景（内部会先 reconcile origin）')
+  assert.equal(canAdoptWorkdir(workdirFacts()), true, '已跟随也能用：远端被重写后同样分叉')
+  assert.equal(canAdoptWorkdir(workdirFacts({ exists: false })), false, '目录都不存在 → 没有可合并的工作副本（应走首次克隆）')
+  assert.equal(canAdoptWorkdir({ error: '读取失败' }), false, '读不出来就不得提供写入口')
+  assert.equal(canAdoptWorkdir(undefined), false, '非 git 通道不得出现该入口')
+})
+
+test('issue #104 建议 3：workdirBacklog —— 本地领先且远端零快照才算「从没备份过」', () => {
+  // 没有工作副本 / 自检失败 / 数字缺一项：一律不猜，不给告警
+  assert.equal(workdirBacklog(undefined).kind, 'unknown');
+  assert.equal(workdirBacklog({ error: 'git not found' }).kind, 'unknown');
+  assert.equal(workdirBacklog({ facts: { ahead: null, remoteSnapshots: null } }).kind, 'unknown');
+  assert.equal(workdirBacklog({ facts: { ahead: 3, remoteSnapshots: null } }).kind, 'unknown');
+  // 没有未上传提交 → clean（不是告警）
+  assert.deepEqual(workdirBacklog({ facts: { ahead: 0, remoteSnapshots: 14 } }), { kind: 'clean', ahead: 0, remoteSnapshots: 14 });
+  // 关键现场：本地攒着提交、远端一个快照都没有
+  assert.deepEqual(workdirBacklog({ facts: { ahead: 14, remoteSnapshots: 0 } }), { kind: 'never-synced', ahead: 14 });
+  // 远端有过快照 ⇒ 只是没推完，语气不同
+  assert.deepEqual(workdirBacklog({ facts: { ahead: 3, remoteSnapshots: 5 } }), { kind: 'ahead', ahead: 3, remoteSnapshots: 5 });
+});

package/src/ui/sync-settings-view.ts

@@ -870,6 +870,49 @@ export function canRecloneWorkdir(
   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: { facts?: { exists: boolean; match: boolean }; error?: string } | undefined,
+): boolean {
+  return canRecloneWorkdir(workDir)
+}
+
+/**
+ * 工作副本的「积压」判定（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 function workdirBacklog(
+  workDir: { facts?: { ahead?: number | null; remoteSnapshots?: number | null }; error?: string } | undefined,
+): WorkdirBacklog {
+  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: string, max = 60): string {
   return url.slice(0, max)
 }

package/src/ui/types.ts

@@ -303,10 +303,32 @@ export interface RecoveryIncident {
   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[];
   running: { runId: string; status: string }[];
+  /**
+   * 正在正常执行的操作（不是 incident）。用途：面板要能解释「为什么现在什么都点不动」——
+   * 此前这类操作被误报成事故，「执行恢复」永久灰、放弃恢复一直 423，用户拿不到任何原因。
+   */
+  live?: RecoveryActiveOperation[];
   /**
    * 环境锁状态摘要（issue #31）。纯残留锁**不是** journal：进程在 op 期间被杀时
    * `journalId: null`、`transactions/active/` 为空，incidents 恒为 []，而 423 文案却

package/src/utils/env-lock.ts

@@ -974,7 +974,7 @@ export class EnvironmentLockManager {
    *  heartbeat expired + PID alive + identity 相同 → LOCKED (owner alive / heartbeat degraded)
    *  probe 无法可靠确定                 → UNKNOWN_STATE
    */
-  async inspectLockState(): Promise<{ state: LockState; detail?: string; corruptOwnership?: boolean }> {
+  async inspectLockState(): Promise<{ state: LockState; detail?: string; corruptOwnership?: boolean; ownerInstanceId?: string }> {
     const st = await this.readOwnershipState()
     if (st.kind === 'missing') {
       // 无所有权文件：可能在创建中、也已被清除 —— **报告**层如实说「没有锁」（issue #79）。
@@ -1002,7 +1002,9 @@ export class EnvironmentLockManager {
     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 = 确证不存在）
@@ -1014,7 +1016,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（保守拒删）
@@ -1027,6 +1029,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 }),
         }
       }
@@ -1036,10 +1039,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) */