dsh-config-manager 0.2.4 → 0.3.0

package/lib/sync/sync-config.js

@@ -113,12 +113,26 @@ function parseV2WebDavNamespace(ns) {
         webdav.username = o['username'];
     return webdav;
 }
+/**
+ * 已落盘 repoUrl 的读取侧校验（SEC-01）：与写入侧同一份 validateRepoUrl。
+ * 不合法 → 记一条明确 issue 并让调用方丢弃该配置；绝不把可疑地址继续交给凭据注入与 git 子进程。
+ */
+function acceptPersistedRepoUrl(repoUrl, issues) {
+    const err = validateRepoUrl(repoUrl);
+    if (err === null)
+        return true;
+    issues?.push({ code: 'repo-url-invalid', channel: 'git', message: err });
+    return false;
+}
 /**
  * 读取同步通道配置；文件不存在/损坏/不支持 schema → null（视为未配置，UI 显示空表单）。
  * 兼容旧文件：缺 schemaVersion 字段视为 v1（git 通道）。
  * 恒返回 schemaVersion=2 的规范形态（v1 读取时归一为 git）。
+ *
+ * `issues` 可选：传数组时，被丢弃的 git repoUrl（白名单校验不通过）以结构化成因追加进去，
+ * 供 UI/日志如实呈现（不静默吞掉）。
  */
-export async function readSyncConfig(dir) {
+export async function readSyncConfig(dir, issues) {
     const file = path.join(dir, SYNC_CONFIG_FILE);
     let raw;
     try {
@@ -149,6 +163,8 @@ export async function readSyncConfig(dir) {
         const git = parseV1Git(obj);
         if (git === null)
             return null;
+        if (!acceptPersistedRepoUrl(git.repoUrl, issues))
+            return null;
         return { schemaVersion: 2, transport: 'git', git };
     }
     // v2 / v3：顶层 transport 选择（v3 双命名空间并存，按 transport 返回对应通道）
@@ -160,6 +176,8 @@ export async function readSyncConfig(dir) {
         const git = parseV2GitNamespace(obj['git']);
         if (git === null)
             return null;
+        if (!acceptPersistedRepoUrl(git.repoUrl, issues))
+            return null;
         return { schemaVersion: 2, transport: 'git', git };
     }
     if (transport === 'webdav') {
@@ -219,9 +237,14 @@ function readBothNamespaces(file) {
  * 读取完整的双命名空间配置（供 status 路由回填另一通道的 repoUrl/url）。
  * 文件不存在/损坏/无任何通道配置 → null（视为未配置）。
  */
-export async function readFullSyncConfig(dir) {
+export async function readFullSyncConfig(dir, issues) {
     const file = path.join(dir, SYNC_CONFIG_FILE);
     const both = await readBothNamespaces(file);
+    // SEC-01/03 读侧：已落盘的 git repoUrl 过同一份白名单校验；不合法就当作没配 git 通道
+    // （自动同步/凭据注入都从这里取通道配置，绝不能让可疑地址继续往下走）
+    if (both.git !== undefined && !acceptPersistedRepoUrl(both.git.repoUrl, issues)) {
+        delete both.git;
+    }
     // 云端点通道的配置不在 sync-config.json（见 sync-cloud-config.json）；这里一并对齐成完整视图
     const s3 = await readS3ChannelConfig(dir);
     const gist = await readGistChannelConfig(dir);
@@ -253,8 +276,8 @@ export async function readFullSyncConfig(dir) {
  * 读取指定通道的同步通道配置（供自动同步调度器按通道运行）。
  * 从完整双命名空间配置取对应通道构造可辨识联合 SyncConfig；该通道未配置 → null。
  */
-export async function readSyncConfigFor(dir, channel) {
-    const full = await readFullSyncConfig(dir);
+export async function readSyncConfigFor(dir, channel, issues) {
+    const full = await readFullSyncConfig(dir, issues);
     if (full === null)
         return null;
     switch (channel) {
@@ -372,10 +395,139 @@ export async function clearSyncChannel(dir, channel) {
     await writeSyncConfigTransport(dir, transport);
     return { removed: true, hasRemaining: true, transport };
 }
+/**
+ * repoUrl 形态分类；null = 不认识的形态。
+ *
+ * 为什么要分类而不是只做正则：git 对同一个「地址」支持 http(s)、ssh、scp 式与本机路径，
+ * 而这三类的安全含义完全不同（网络地址要防 SSRF，本机路径要防 argv 注入）。先判形态，
+ * 再按形态分别收紧，比一堆互相打架的正则清楚。
+ */
+export function classifyRepoUrl(repoUrl) {
+    const url = repoUrl.trim();
+    if (url === '' || /\s/.test(url))
+        return null;
+    // SEC-12：以 '-' 开头的「地址」会被 git 当成选项（--upload-pack=… / -c core.pager=…）
+    if (url.startsWith('-'))
+        return null;
+    // 'ext::sh -c …' 一类命令协议（SCM 协议语法里 scheme 与地址之间是 '::'）
+    if (url.includes('::'))
+        return null;
+    const scheme = /^([A-Za-z][A-Za-z0-9+.-]*):\/\//.exec(url);
+    if (scheme !== null) {
+        const name = scheme[1].toLowerCase();
+        if (name !== 'http' && name !== 'https' && name !== 'ssh')
+            return null;
+        // 'https:///r.git' 这类空 authority 会被 URL 解析器「跳过斜杠」后当成主机 r.git —— 必须先拦
+        const rest = url.slice(scheme[0].length);
+        if (rest === '' || rest.startsWith('/') || rest.startsWith('\\'))
+            return null;
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return null;
+        }
+        if (parsed.hostname === '')
+            return null;
+        return { kind: name, host: parsed.hostname };
+    }
+    // scp 式（git@github.com:user/repo.git）：只有 user@host:path 才算网络地址
+    const scp = /^[^\s/@:]+@([^\s/:]+):(.+)$/.exec(url);
+    if (scp !== null)
+        return { kind: 'ssh', host: scp[1] };
+    // 其余按本机路径处理（相对 ../bare、绝对 /home/u/r.git、盘符 D:/repos/bare）
+    return { kind: 'local', host: '' };
+}
+/** 四段点分且每段 0-255 → IPv4 字面量；否则 null（域名里的数字段不算 IP） */
+function parseIpv4(host) {
+    const parts = host.split('.');
+    if (parts.length !== 4)
+        return null;
+    const nums = [];
+    for (const part of parts) {
+        if (!/^\d{1,3}$/.test(part))
+            return null;
+        const n = Number(part);
+        if (n > 255)
+            return null;
+        nums.push(n);
+    }
+    return [nums[0], nums[1], nums[2], nums[3]];
+}
+/**
+ * 环回 / 私网 / 链路本地 / 未指定地址（含云元数据 169.254.169.254）判定。
+ * SEC-03：这类地址让「客户端」去访问内网或本机端口，等于给 SSRF 开一扇门。
+ *
+ * **已知行为变更（有意，非副作用）**：SEC-02/03 之前 `https://192.168.1.10/…`、`http://127.0.0.1:3000/…`、
+ * `http://nas.local/…` 这类地址可以被接受。收紧后一律拒绝 —— 代价是「拿家里 NAS / 局域网 git 服务器
+ * 当同步目标」这条路走不通，收益是「包里的 repoUrl 无法把家目录配置推给内网监听者或云元数据端点」。
+ * 取舍判据：本插件的同步目标是「用户自己的远端仓库」，公网 http(s)/ssh 已覆盖该用途；本机目录仓库
+ * 仍走 `local` 分支（不由本函数判定）。真要支持内网目标，应做成显式开关 + 用户逐目标确认，
+ * 不能靠「地址字符串看起来像内网就放行」——那正是攻击者可控的判据。
+ */
+export function isPrivateRepoHost(host) {
+    const h = host.trim().toLowerCase().replace(/^\[/, '').replace(/\]$/, '').replace(/\.$/, '');
+    if (h === '')
+        return true;
+    if (h === 'localhost' || h.endsWith('.localhost'))
+        return true;
+    const v4 = parseIpv4(h);
+    if (v4 !== null) {
+        const [a, b] = v4;
+        return a === 0 || a === 127 || a === 10
+            || (a === 172 && b >= 16 && b <= 31)
+            || (a === 192 && b === 168)
+            || (a === 169 && b === 254);
+    }
+    if (!h.includes(':'))
+        return false;
+    if (h === '::1' || h === '::')
+        return true;
+    if (/^f[cd][0-9a-f]{2}:/.test(h))
+        return true; // fc00::/7 唯一本地
+    if (/^fe[89ab][0-9a-f]?:/.test(h))
+        return true; // fe80::/10 链路本地
+    const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(h);
+    if (mapped !== null)
+        return isPrivateRepoHost(mapped[1]);
+    return false;
+}
+/**
+ * 文案里回显地址用：剥掉 userinfo（token 可能就藏在这一段），host/path 原样保留。
+ *
+ * 为什么不整串换成 `[REPO_URL]` 占位符：这里拒绝的是**用户自己刚填的**地址，他需要认出
+ * 「被拒的是哪一个」才能改；剥掉 `user:pass@` 之后剩下的部分正是修复所需的定位信息。
+ * 为什么解析失败也要剥：`https://user:tok@` 这类半截地址 `new URL` 会抛，但前缀照样是凭据。
+ */
+export function sanitizeRepoUrlForMessage(url) {
+    const raw = url.trim();
+    try {
+        const parsed = new URL(raw);
+        if (parsed.username === '' && parsed.password === '')
+            return raw;
+        parsed.username = '';
+        parsed.password = '';
+        return parsed.toString();
+    }
+    catch {
+        // 只有「残缺的带 scheme 地址」（`https://user:tok@`，`new URL` 会抛但前缀就是凭据）需要剥。
+        // 无 scheme 的 scp 式（`git@host:path`）里 `git` 是 ssh 登录名、不是凭据 → 原样返回，
+        // 免得用户看到一条认不出是哪个远端的报错。
+        if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(raw))
+            return raw;
+        return raw.replace(/^([A-Za-z][A-Za-z0-9+.-]*:\/\/)[^/@\s]*@/, (_m, scheme) => scheme ?? '');
+    }
+}
 /**
  * 仓库地址合法性校验（返回错误消息；null = 合法）。
- * 安全约束：token 永不拼入 repoUrl —— http(s) 地址带 userinfo（username[:password]@）直接拒绝，
- * 引导用户把 token 放凭据字段（DSH credentials），避免 token 经 URL 泄漏进 git 历史/日志。
+ *
+ * 白名单口径（SEC-02/03/12，写入侧与读取侧共用同一份实现）：
+ * - 只认 http(s)/ssh/scp 式网络地址与本机路径；file://、ext::、ftp://、git:// 一律拒绝；
+ * - 整串以 '-' 开头拒绝（git argv 位置参数以 '-' 开头会被当选项，可执行任意命令）；
+ * - 网络地址拒绝环回/私网/链路本地主机（SSRF）—— 文案单独一条（sync.configPrivateHost），
+ *   不能复用「无法解析」：用户看到「解析不了」只会反复改写法，实际原因是地址指向内网；
+ * - 带 scheme 的地址一律拒绝 userinfo（username[:password]@）—— token 只许放凭据字段。
  */
 export function validateRepoUrl(repoUrl, msg = zhMsg) {
     if (typeof repoUrl !== 'string' || repoUrl.trim() === '') {
@@ -385,15 +537,36 @@ export function validateRepoUrl(repoUrl, msg = zhMsg) {
     if (/\s/.test(url)) {
         return msg('sync.configWhitespace');
     }
-    if (/^https?:\/\//i.test(url)) {
-        let parsed;
-        try {
-            parsed = new URL(url);
-        }
-        catch {
-            return msg('sync.configUnparseable', { url });
-        }
-        if (parsed.username !== '' || parsed.password !== '') {
+    // 回显一律脱敏：错误文案会进日志、进接口响应、进 issue 截图
+    const echo = sanitizeRepoUrlForMessage(url);
+    const shape = classifyRepoUrl(url);
+    if (shape === null) {
+        return msg('sync.configUnparseable', { url: echo });
+    }
+    if (shape.kind === 'local')
+        return null;
+    if (isPrivateRepoHost(shape.host)) {
+        return msg('sync.configPrivateHost', { url: echo });
+    }
+    // userinfo 检查与 scheme 无关（RV1-F7）：原实现只在 http/https 分支内查，于是
+    // `ssh://user:tok@host/r.git` 能过白名单，token 照样进 argv 与 sync-config.json。
+    // 口径（按「这一段是不是凭据」区分，而不是按 scheme 区分）：
+    // - password 位：任何带 scheme 的地址都拒 —— 那是可粘贴的 secret；
+    // - http/https 的 username：Basic 认证的用户名与口令等同，一并拒（保持既有行为）；
+    // - ssh 的 username：就是 ssh 登录名（`ssh://git@host`、`ssh://deploy@host` 是标准写法），
+    //   ssh 认证只认密钥/agent，用户名不具凭据效力，因此放行 —— 拒掉会杀掉合法用法。
+    // scp 式（git@host:path）无 scheme、`new URL` 解析不了，本就不进这条判定。
+    let parsed = null;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        parsed = null;
+    }
+    if (parsed !== null) {
+        const hasPassword = parsed.password !== '';
+        const hasBasicUser = parsed.username !== '' && (shape.kind === 'http' || shape.kind === 'https');
+        if (hasPassword || hasBasicUser) {
             return msg('sync.configUserinfo');
         }
     }

package/lib/sync/sync-engine.d.ts

@@ -326,6 +326,14 @@ export type MergeResolution = {
 export type ApplyMergeResolutionsReport = ApplyReport & {
     pendingConflicts: SectionId[];
 };
+/**
+ * 删除远端快照的结果（F3：显式删除路径此前对「本轮 blob GC 被放弃」完全静默）。
+ * `warnings` 与 push 报告同风格（空数组 = 本轮什么都没被放弃）：快照已按用户意图删除，
+ * 「孤儿 blob 没回收」不是失败（下一轮 GC 还会再试），所以进 warnings、不进 ok。
+ */
+export interface DeleteSnapshotResult {
+    warnings: string[];
+}
 export declare class SyncEngine {
     private readonly ctx;
     private readonly transport;
@@ -489,12 +497,6 @@ export declare class SyncEngine {
      * 本机枚举失败或为空。用「读不到」覆盖成「全删了」会一次性标错几百条墓碑，绝不猜。
      */
     private computeSessionBookkeeping;
-    /**
-     * P1-5：按远端墓碑剔除**将要导入**的会话（旧快照不得复活已删除的对话）。
-     * 只动载荷，不动本机已有数据 —— 墓碑不代用户删除本机文件（那是不可回滚的用户动作）。
-     * @returns 被剔除的会话单元 id（调用方据此出可见报告，绝不静默）
-     */
-    private stripTombstonedSessions;
     /**
      * 裁剪远端快照：调用 transport.list() 获取全部快照（按 createdAt 升序），
      * 按 retentionPolicyProvider() 给出的 GFS 策略（最近 N / 每月一份 / 每年一份）
@@ -523,6 +525,7 @@ export declare class SyncEngine {
      *  - 其余：远端最新快照 id !== lastSnapshotId ⇒ 远端被推进（或本机基线已被裁剪）→ 拦。
      *    两种情况都**无法安全断言「远端没变」**，保守拒绝并给出 force 出口。
      *  - list() 抛错 → 返回 reason（调用方按原样继续并告警），绝不把「读不到」当成「没变」。
+     *  - SYN-02：index 可由 push() 传入（同一轮只列一次远端），缺省自己 list（其它调用点行为不变）。
      */
     private remoteAdvancedCheck;
     /**
@@ -562,8 +565,19 @@ export declare class SyncEngine {
      *  - **与保留策略裁剪共用同一条 `transport.delete`**（两条通道的删除语义只有一份实现），
      *    区别只在「谁点名」：这里是用户显式指定的 id，pruneRemoteSnapshots 由 RetentionPolicy 挑；
      *  - **不存在视为成功**（SyncTransport 契约），所以重复点删除 / 已被裁剪掉都不会报错。
+     *
+     * F3：通道侧的 blob GC 可能「放弃本轮」（SYN-04：引用快照 404 / 读不出 ⇒ 证明不了没人引用）。
+     * 放弃不是删除失败，但**必须可见**（否则孤儿 blob 无人知晓地一直堆）⇒ 放弃码用与 push 报告
+     * 同一条 `gcSkipWarning` 渲染进返回体的 warnings。
+     */
+    deleteSnapshot(id: string): Promise<DeleteSnapshotResult>;
+    /**
+     * SYN-04b：通道最近一轮 GC 的放弃码（无则 null）。
+     *
+     * 保留为 public 只读出口（不删）：属本类已发布的可见 API，路由/诊断不跑删除流程也能读到通道能力；
+     * 引擎内已由 deleteSnapshot 消费（放弃码 → warnings），不再是死方法。读不到（通道没这能力）= null。
      */
-    deleteSnapshot(id: string): Promise<void>;
+    lastGcSkipCode(): string | null;
     /** 列出远端已有快照（按 createdAt 升序）—— 供「选择历史快照」下拉。 */
     listSnapshots(): Promise<SyncSnapshotMeta[]>;
     /**

package/lib/sync/sync-engine.js

@@ -22,6 +22,7 @@ import path from 'node:path';
 import { createAdapters } from '../adapters/index.js';
 import { defaultSecretScanner } from '../core/exporter.js';
 import { Importer } from '../core/importer.js';
+import { DEFAULT_ROLLBACK_ON_ERROR } from '../core/import-defaults.js';
 // issue #91：只读预览与基线 hash 的口径判定（本地源插件在预览里不会被 npm pack）
 import { isLocalPluginSpec } from '../core/local-plugin-pack.js';
 import { isFileSection, SECTION_FILE_PREFIXES, SECTION_JSON_PATHS } from '../schema/config.js';
@@ -34,7 +35,7 @@ import { createSnapshotFs, joinFs } from './fs.js';
 import { writeSnapshotToDir } from './layout.js';
 import { credentialsMapFromYaml, decryptCredentialsPayload, decryptSectionsPayload, encryptCredentialsPayload, encryptSectionsPayload, } from './snapshot-crypto.js';
 import { OPT_IN_SYNC_SECTIONS } from './sync-selection.js';
-import { nextSessionTombstones, sessionUnitIdsOfSection, stripTombstonedUnits } from './session-tombstones.js';
+import { listRemoteSnapshotIndex, planSessionBookkeeping, remoteTombstonesOf, stripTombstonedSessionsInPlace, } from './session-tombstones.js';
 import { DEFAULT_RETENTION_POLICY, selectPruneCandidatesByPolicy } from './retention-policy.js';
 import { hashSection, loadSyncState, resolveDeviceIdentity, saveSyncState } from './sync-state.js';
 import { isEncryptedSections, PROBE_UNSUPPORTED_CODE, SyncTransportError } from './transport.js';
@@ -42,8 +43,9 @@ import { msgOf, zhMsg } from '../core/messages.js';
 import { engineMsg } from './messages.js';
 import { DEFAULT_ANCESTOR_KEEP, pruneAncestors, tryLoadAncestor, writeAncestor, writeEncryptedAncestor } from './ancestor.js';
 import { merge as mergeSections } from './merge.js';
+import { previewTextOf } from './merge-preview-text.js';
+import { gcSkipWarning, readGcSkipCode, reportGcSkipOnce } from './gc-skip.js';
 import { classifyMergePlan } from './risk.js';
-import { redact } from '../security/redaction.js';
 import { registerMessageCatalog } from '../core/engine-locale.js';
 import { createSnapshot, selectPruneCandidates } from '../core/backup.js';
 import { rollback } from '../core/rollback.js';
@@ -58,6 +60,7 @@ import { FileSnapshotStore } from '../core/backup.js';
 const zh = {
     'sync.pushRemoteAdvanced': '远端最新快照 {remote} 与本地基线 {base} 不一致：本次推送未执行（远端未写入、基线未改动）。请先同步远端改动；确认要用本机覆盖远端时，再显式选择强制推送。',
     'sync.pushAdvanceCheckFailed': '无法确认远端是否已被其它设备推进（{reason}）：本次推送按原样继续',
+    'sync.sessionTombstonesInherited': '已从远端快照继承 {count} 条会话删除墓碑：删除继续跨设备传播（本机数据不动）',
     'sync.applyMergeResolutionsNoImporter': 'applyMergeResolutions: SyncEngine 缺少 importer（需在 options 中注入）',
     'sync.mergePendingConflicts': '仍有 {count} 个分区未裁决（{sections}）：已裁决的部分已写入本机，但基线不推进，冲突下一轮会重新出现',
     'sync.baselineRexportFailed': '写回成功但重新导出本机分区失败（{sections}）：无法证明基线与本机一致，本次**不记基线**（远端指针保持原值，下一轮重新合并收敛）',
@@ -65,47 +68,12 @@ const zh = {
 const en = {
     'sync.pushRemoteAdvanced': 'The newest remote snapshot {remote} differs from the local baseline {base}: this push did not run (nothing written remotely, baseline untouched). Sync the remote changes first, or explicitly force the push if this machine should overwrite the remote.',
     'sync.pushAdvanceCheckFailed': 'Cannot tell whether another device advanced the remote ({reason}): this push continues as-is',
+    'sync.sessionTombstonesInherited': 'Inherited {count} session deletion tombstone(s) from the remote snapshot: deletions keep propagating across devices (local data untouched)',
     'sync.applyMergeResolutionsNoImporter': 'applyMergeResolutions: SyncEngine is missing the importer (must be injected via options)',
     'sync.mergePendingConflicts': '{count} section(s) still have no decision ({sections}): the decided parts were written locally, but the baseline is not advanced, so the conflicts will reappear next round',
     'sync.baselineRexportFailed': 'The write succeeded but re-exporting the local section(s) failed ({sections}): the baseline cannot be proven to match this machine, so no baseline was recorded (the remote pointer keeps its old value and the next merge converges again)',
 };
 registerMessageCatalog({ id: 'sync-engine-merge', zh, en });
-/**
- * 单侧预览文本上限（2 KiB **字符**预算）：超出截断并追加省略号。
- *
- * 顺序恒为「先 redact 再截断」：反过来会把跨边界的敏感值切成半个形状，让脱敏匹配不到它
- * （等于把秘密截一半发出去）。redact 之后的剩余文本已不含秘密形状，截断才安全。
- */
-const MERGE_PREVIEW_TEXT_LIMIT = 2048;
-/** 严格 UTF-8 解码器：非法字节序列直接抛错（用于区分文本与二进制文件冲突）。 */
-const STRICT_UTF8 = new TextDecoder('utf-8', { fatal: true });
-/** 把任意冲突侧值转成**可读字符串**；二进制只回传形状与字节数，绝不回传原始值对象。 */
-function previewTextOf(value) {
-    if (value === undefined)
-        return '';
-    if (typeof value === 'string')
-        return finalizePreviewText(value);
-    if (value instanceof Uint8Array) {
-        try {
-            return finalizePreviewText(STRICT_UTF8.decode(value));
-        }
-        catch {
-            // 二进制内容解码只会得到乱码（同样误导用户）→ 只回传形状；JSON 是数据形态，不是文案
-            return JSON.stringify({ binary: true, bytes: value.length });
-        }
-    }
-    try {
-        return finalizePreviewText(JSON.stringify(value) ?? '');
-    }
-    catch {
-        return finalizePreviewText(String(value));
-    }
-}
-/** 预览文本统一出口：先 redact（敏感值绝不回传浏览器），再截断到 2 KiB。 */
-function finalizePreviewText(text) {
-    const masked = redact(text);
-    return masked.length > MERGE_PREVIEW_TEXT_LIMIT ? `${masked.slice(0, MERGE_PREVIEW_TEXT_LIMIT)}…` : masked;
-}
 /** plan 的单个分区结果 → 预览视图（三侧都只回传可读文本，绝不回传原始值）。 */
 function mergePreviewSectionView(result) {
     const conflicts = result.conflicts.map((c) => ({
@@ -519,10 +487,13 @@ export class SyncEngine {
         if (encrypt && (opts.password === undefined || opts.password === '')) {
             throw new Error(this.msg('sync.encryptRequiresPassword'));
         }
+        // SYN-02：本轮只列一次远端 index（推进检测 + 继承会话删除墓碑共用；墓碑累积在最新快照里）
+        const remoteIndex = await listRemoteSnapshotIndex(this.transport);
+        const remoteTombstones = remoteIndex.reason === undefined ? remoteTombstonesOf(remoteIndex.metas) : [];
         // 远端推进检测：不一致 = 远端被别的设备推过（或本机基线已被裁剪）。
         // 此时推上去会覆盖/架空别人的改动 → 直接返回冲突（**不抛错**、不 upload、不记基线、不改 sync-state）。
         if (opts.force !== true) {
-            const check = await this.remoteAdvancedCheck();
+            const check = await this.remoteAdvancedCheck(remoteIndex);
             if (check.reason !== undefined) {
                 // 读不到远端列表 ⇒ 无法判定。按原样继续（上传本身会再暴露通道问题），但如实说明。
                 warnings.push(this.msg('sync.pushAdvanceCheckFailed', { reason: check.reason }));
@@ -575,11 +546,15 @@ export class SyncEngine {
         const credentials = includeSecrets
             ? await this.buildCredentialsPayload(opts.password, warnings)
             : undefined;
-        // P1-5：会话删除墓碑（上一次推过、本机已不存在的会话 = 用户删掉了）
-        const bookkeeping = await this.computeSessionBookkeeping(targets, plainSections);
+        // P1-5 + SYN-02：本机墓碑（上次推过、本机已删）叠加上远端继承的墓碑 ——
+        // 不继承的话「A 删 → B 推」会漏掉墓碑，C 带旧快照就能把已删会话复活（删除只在本机传播）。
+        const bookkeeping = await this.computeSessionBookkeeping(targets, plainSections, remoteTombstones);
         if (bookkeeping.deletedNow.length > 0) {
             warnings.push(this.msg('sync.sessionDeletionsRecorded', { count: String(bookkeeping.deletedNow.length) }));
         }
+        if (bookkeeping.inherited > 0) {
+            warnings.push(this.msg('sync.sessionTombstonesInherited', { count: String(bookkeeping.inherited) }));
+        }
         // ⑥ 设备身份（cloud-sync 借鉴项 ⑥）：首次生成后持久化在 sync-state.json（已有则纯读），
         // 随 manifest 上行 → 别的设备在历史列表里能看到「这份快照是哪台机器推的」。
         const device = await resolveDeviceIdentity(this.stateDir, os.hostname(), this.fsx, this.msg);
@@ -747,50 +722,33 @@ export class SyncEngine {
      * `tracked=false` 的三种情形一律**不动既有记录**：没推 sessions / 适配器不支持全量枚举 /
      * 本机枚举失败或为空。用「读不到」覆盖成「全删了」会一次性标错几百条墓碑，绝不猜。
      */
-    async computeSessionBookkeeping(targets, plainSections) {
+    async computeSessionBookkeeping(targets, plainSections, remoteTombstones = []) {
         const sessions = targets.find((a) => a.id === 'sessions');
         if (sessions === undefined || sessions.listAllUnitIds === undefined) {
-            return { tracked: false, sessionUnits: [], tombstones: [], deletedNow: [] };
+            return { tracked: false, sessionUnits: [], tombstones: [], deletedNow: [], inherited: 0 };
         }
         let localUnits;
         try {
             localUnits = await sessions.listAllUnitIds(this.ctx);
         }
         catch {
-            return { tracked: false, sessionUnits: [], tombstones: [], deletedNow: [] };
+            return { tracked: false, sessionUnits: [], tombstones: [], deletedNow: [], inherited: 0 };
         }
         if (localUnits.length === 0) {
-            return { tracked: false, sessionUnits: [], tombstones: [], deletedNow: [] };
+            return { tracked: false, sessionUnits: [], tombstones: [], deletedNow: [], inherited: 0 };
         }
         const state = await loadSyncState(this.stateDir, this.fsx, this.msg);
-        const { tombstones, deletedNow } = nextSessionTombstones({
-            previousUnits: state.sessionUnits ?? [],
-            localUnits,
-            previousTombstones: state.deletedSessions ?? [],
-        });
         return {
             tracked: true,
-            sessionUnits: sessionUnitIdsOfSection(plainSections['sessions']),
-            tombstones,
-            deletedNow,
+            ...planSessionBookkeeping({
+                previousUnits: state.sessionUnits ?? [],
+                previousTombstones: state.deletedSessions ?? [],
+                localUnits,
+                exportedSessions: plainSections['sessions'],
+                remoteTombstones,
+            }),
         };
     }
-    /**
-     * P1-5：按远端墓碑剔除**将要导入**的会话（旧快照不得复活已删除的对话）。
-     * 只动载荷，不动本机已有数据 —— 墓碑不代用户删除本机文件（那是不可回滚的用户动作）。
-     * @returns 被剔除的会话单元 id（调用方据此出可见报告，绝不静默）
-     */
-    stripTombstonedSessions(snapshot) {
-        const tombstones = snapshot.manifest.deletedSessions ?? [];
-        if (tombstones.length === 0 || isEncryptedSections(snapshot.sections))
-            return [];
-        const plain = snapshot.sections;
-        const stripped = stripTombstonedUnits(plain['sessions'], tombstones);
-        if (stripped.removed.length === 0)
-            return [];
-        plain['sessions'] = stripped.section;
-        return stripped.removed;
-    }
     /**
      * 裁剪远端快照：调用 transport.list() 获取全部快照（按 createdAt 升序），
      * 按 retentionPolicyProvider() 给出的 GFS 策略（最近 N / 每月一份 / 每年一份）
@@ -822,6 +780,10 @@ export class SyncEngine {
         const doomed = selectPruneCandidatesByPolicy(metas.map((m) => ({ id: m.id, createdAt: m.createdAt })), policy, selectPruneCandidates);
         // 刚 push 的快照永不进删除集（防御性：策略三层全关时也保住它）
         const keep = new Set([pushedId]);
+        // SYN-04b：本轮 GC 是否已放弃 —— 每次 transport.delete() 内部会重跑一轮 blob GC，
+        // 而放弃码是「本轮」的结论；同一次 push 里删 N 个快照会设置 N 次同一个原因，
+        // 逐条报会把「一样的事实」刷 N 遍，所以本轮只报一次。
+        const gcReported = { done: false };
         for (const m of metas) {
             if (doomed.includes(m.id) && !keep.has(m.id)) {
                 try {
@@ -831,6 +793,7 @@ export class SyncEngine {
                     const reason = err instanceof Error ? err.message : String(err);
                     warnings.push(this.msg('sync.pruneDeleteFailed', { id: m.id, reason }));
                 }
+                reportGcSkipOnce(this.transport, this.msg, warnings, gcReported);
             }
         }
     }
@@ -852,19 +815,17 @@ export class SyncEngine {
      *  - 其余：远端最新快照 id !== lastSnapshotId ⇒ 远端被推进（或本机基线已被裁剪）→ 拦。
      *    两种情况都**无法安全断言「远端没变」**，保守拒绝并给出 force 出口。
      *  - list() 抛错 → 返回 reason（调用方按原样继续并告警），绝不把「读不到」当成「没变」。
+     *  - SYN-02：index 可由 push() 传入（同一轮只列一次远端），缺省自己 list（其它调用点行为不变）。
      */
-    async remoteAdvancedCheck() {
+    async remoteAdvancedCheck(index) {
         const state = await loadSyncState(this.stateDir, this.fsx, this.msg);
         const base = state.lastSnapshotId;
         if (base === '')
             return { blocked: false, base, latest: '' };
-        let metas;
-        try {
-            metas = await this.transport.list();
-        }
-        catch (err) {
-            return { blocked: false, base, latest: '', reason: err instanceof Error ? err.message : String(err) };
-        }
+        const listed = index ?? await listRemoteSnapshotIndex(this.transport);
+        if (listed.reason !== undefined)
+            return { blocked: false, base, latest: '', reason: listed.reason };
+        const metas = listed.metas;
         if (metas.length === 0)
             return { blocked: false, base, latest: '' };
         const latest = metas[metas.length - 1].id; // list 按 createdAt 升序 → 最新在末
@@ -888,7 +849,7 @@ export class SyncEngine {
         // 加密快照 → 用密码解密回明文（无密码明确报错）；普通快照 → containsSecrets 拒绝
         await this.prepareSnapshot(snapshot, opts.password);
         // P1-5：按远端墓碑剔除已删除的会话（旧快照不复活）
-        const tombstoned = this.stripTombstonedSessions(snapshot);
+        const tombstoned = stripTombstonedSessionsInPlace(snapshot);
         // issue #38：快照携带凭据载荷 → 解密出 ref→值（仅内存），供计划项与后续 apply 使用
         const credentials = await this.decryptSnapshotCredentials(snapshot, opts.password);
         const portableIds = this.pullSectionIds();
@@ -951,7 +912,7 @@ export class SyncEngine {
         await this.prepareSnapshot(snapshot, opts.password);
         // audit-sync sync-F6：剔除结果必须**可见**（与 pull/preview 同一口径）。
         // 此前返回值丢弃了它 —— 产物里少了哪些会话，调用方与用户都无从得知（绝不静默少带）。
-        const tombstonedSessions = this.stripTombstonedSessions(snapshot).length;
+        const tombstonedSessions = stripTombstonedSessionsInPlace(snapshot).length;
         const portableIds = this.pullSectionIds();
         const zipPath = await this.snapshotToZip(snapshot, portableIds);
         // snapshotToZip 产出在临时目录；搬到调用方指定目录（同盘 rename，跨盘退化为复制）
@@ -978,9 +939,26 @@ export class SyncEngine {
      *  - **与保留策略裁剪共用同一条 `transport.delete`**（两条通道的删除语义只有一份实现），
      *    区别只在「谁点名」：这里是用户显式指定的 id，pruneRemoteSnapshots 由 RetentionPolicy 挑；
      *  - **不存在视为成功**（SyncTransport 契约），所以重复点删除 / 已被裁剪掉都不会报错。
+     *
+     * F3：通道侧的 blob GC 可能「放弃本轮」（SYN-04：引用快照 404 / 读不出 ⇒ 证明不了没人引用）。
+     * 放弃不是删除失败，但**必须可见**（否则孤儿 blob 无人知晓地一直堆）⇒ 放弃码用与 push 报告
+     * 同一条 `gcSkipWarning` 渲染进返回体的 warnings。
      */
     async deleteSnapshot(id) {
         await this.transport.delete(id);
+        // transport.delete 内部是 await 完 gcBlobStore 才返回的（两条通道同型），所以此时取到的是
+        // **本次删除那一轮**的放弃码，而不是上一轮的残留。
+        const code = this.lastGcSkipCode();
+        return code === null ? { warnings: [] } : { warnings: [gcSkipWarning(this.msg, code)] };
+    }
+    /**
+     * SYN-04b：通道最近一轮 GC 的放弃码（无则 null）。
+     *
+     * 保留为 public 只读出口（不删）：属本类已发布的可见 API，路由/诊断不跑删除流程也能读到通道能力；
+     * 引擎内已由 deleteSnapshot 消费（放弃码 → warnings），不再是死方法。读不到（通道没这能力）= null。
+     */
+    lastGcSkipCode() {
+        return readGcSkipCode(this.transport);
     }
     /** 列出远端已有快照（按 createdAt 升序）—— 供「选择历史快照」下拉。 */
     async listSnapshots() {
@@ -1083,7 +1061,7 @@ export class SyncEngine {
         // 加密快照 → 用密码解密回明文（无密码明确报错）；普通快照 → containsSecrets 拒绝
         await this.prepareSnapshot(snapshot, opts.password);
         // P1-5：按远端墓碑剔除已删除的会话（旧快照不复活；一键同步复用本 plan）
-        const tombstoned = this.stripTombstonedSessions(snapshot);
+        const tombstoned = stripTombstonedSessionsInPlace(snapshot);
         // issue #38：凭据载荷解密（仅内存；由调用方登记进同步会话，apply-items 时写回本机）
         const credentials = await this.decryptSnapshotCredentials(snapshot, opts.password);
         const portableIds = this.pullSectionIds();
@@ -1128,7 +1106,7 @@ export class SyncEngine {
         // issue #107：记下远端快照是否加密 —— applyMergePlan 据此决定祖先副本也落密文
         this.lastMergedRemoteEncrypted = remote.manifest.encrypted === true;
         // P1-5：按远端墓碑剔除已删除的会话（三方合并的 remote 侧同样不许复活）
-        this.stripTombstonedSessions(remote);
+        stripTombstonedSessionsInPlace(remote);
         // 本次合并的远端基准（P0-7）：紧随其后的 applyMergePlan() 用它写基线远端指针
         this.lastMergedRemoteSnapshotId = targetId;
         // issue #45：把远端快照的 sourceHome 与用户映射一并备忘 —— applyMergePlan 重建临时 ZIP 时
@@ -1571,12 +1549,12 @@ export class SyncEngine {
                     warnings: [this.msg('sync.preApplySnapshotFailed', { err: backupErr instanceof Error ? backupErr.message : String(backupErr) })],
                 };
             }
-            // 3) 真正执行：Importer.executeImportPlan（rollbackOnError=true → 任一失败整体回滚）
+            // 3) 真正执行：Importer.executeImportPlan（rollbackOnError 取单一缺省 → 任一失败整体回滚）
             // 自动同步路径没有密码（凭据载荷无法解密），因此恒不注入 decryptedCredentials；
             // 加密快照本就不会进入自动同步（无密码无法 prepareSnapshot）。
             const result = await this.importer.executeImportPlan(zipPath, plan, {
                 confirm: true,
-                rollbackOnError: true,
+                rollbackOnError: DEFAULT_ROLLBACK_ON_ERROR,
                 secretInputs: undefined,
                 decryptedCredentials: undefined,
                 // 审计 P0-23：把 journal 绑定面透传给引擎（自动同步路径由 autosync-scheduler 提供），
@@ -1680,10 +1658,10 @@ export class SyncEngine {
                 result: null,
             };
         }
-        // 真正执行：Importer.executeImportPlan（confirm:true + rollbackOnError:true → 任一失败整体回滚）
+        // 真正执行：Importer.executeImportPlan（confirm:true + rollbackOnError 取单一缺省 → 任一失败整体回滚）
         const result = await this.importer.executeImportPlan(zipPath, subPlan, {
             confirm: true,
-            rollbackOnError: true,
+            rollbackOnError: DEFAULT_ROLLBACK_ON_ERROR,
             secretInputs: undefined,
             // issue #38：快照凭据载荷解出的 ref→值（仅内存）→ credentials adapter 写回本机
             decryptedCredentials: opts.credentials,