dsh-config-manager 0.1.80 → 0.1.82

package/lib/core/restore.js

@@ -9,7 +9,7 @@
  *     profile 层 cordis.patch.yml）的 blob 写回 $DSH_HOME；快照时不存在、现已出现
  *     的文件删除（restore = 还原到快照那一刻的状态，含移除导入期间新增激活行）；
  *  2. pre-restore 双保险：任何覆盖/删除前，把当前文件复制到
- *     <snapshotDir>/pre-restore/（可人工反悔）；
+ *     <snapshotDir>/pre-restore/<attemptDir>/（每次执行一个目录，可人工反悔，重跑不覆盖）；
  *  3. 插件撤销：beforePlugins（导入前基线）与当前已装对比 → 导入期间新增的插件
  *     走官方 `dsh plugin --profile <p> remove <pkg>`（runDshPlugin 通道，零新子进程代码）；
  *  4. file 类条目补偿：skills/agentPresets/agentInstructions/pluginFiles/sessions 原文件 blob 写回 /
@@ -21,6 +21,7 @@
  * 旧快照（无 beforePlugins / hostFileBackups）兼容：缺基线的部分只提示不动作。
  */
 import { engineMsg } from './messages-core.js';
+import fssync from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { normalizeDshVersion, resolveFileTarget, verifySnapshot } from './backup.js';
@@ -28,6 +29,7 @@ import { isPatchLayerRel } from './patch-layers.js';
 import { expectedSessionRefs, sweepGhostSessions } from './ghost-sweep.js';
 import { zhMsg } from './messages.js';
 import { classifyDshPluginFailure, readInstalled, readInstalledVersion, resolveProfileDir, runDshPlugin, } from './plugin-cli.js';
+import { collectRestoreWalEntries, createRestoreWal, restoreActionStepId, restoreWalHandlesFromSteps, } from './restore-wal.js';
 import { parseJsonSafe } from '../utils/json.js';
 import { atomicCopyFile, atomicWriteFile } from '../utils/atomic-write.js';
 /* ------------------------------------------------------------ 工具 */
@@ -60,6 +62,19 @@ export function homeAbs(homeDir, relPath, msg) {
         throw new Error(msg('restore.pathEscape', { path: relPath }));
     return abs;
 }
+/**
+ * home 相对目标 → 绝对路径（越界/非法给 null 而不是抛错）。
+ * 供逐动作 WAL 与续跑判定用：这两处都只需要「能不能拿到绝对路径」这一个事实，
+ * 判定失败由调用方决定是跳过该动作还是拒绝整笔。
+ */
+export function resolveRestoreTargetAbs(homeDir, target) {
+    try {
+        return homeAbs(homeDir, target, zhMsg);
+    }
+    catch {
+        return null;
+    }
+}
 /** 快照目录内 blob 绝对路径（防 snapshot.json 里伪造 ../ 越界读） */
 export function blobAbs(snapshotDir, blobPath, msg) {
     const abs = path.resolve(snapshotDir, blobPath);
@@ -73,6 +88,114 @@ function toRelPath(homeDir, abs) {
         return '';
     return path.relative(homeDir, abs).split(path.sep).join('/');
 }
+/* ------------------------- 目标侧真实路径围栏（junction / symlink 防写穿，D4） */
+/**
+ * 目标侧路径安全：字符串前缀围栏 `isWithinHome` 挡不住两类逃逸 ——
+ *  1. `$DSH_HOME` 内某个**目录**本身是链接（Windows junction / POSIX 目录 symlink）：
+ *     字符串前缀成立，真实落点却在 home 之外；
+ *  2. **目标文件本身是 symlink**：`atomicCopyFile` 缺省 `symlink:'follow'`
+ *     （src/utils/atomic-write.ts:305）解析真实路径后改写 home 外的文件，而链接结构不变（肉眼无痕）。
+ * 因此计划期对每个「会被写入 / 删除」的目标做一次 realpath 判定；任一目标不安全 ⇒
+ * **整笔计划作废**（`planRestore` 抛错；`restore()` 是先规划后执行 ⇒ 零写入），
+ * 绝不逐项降级为 skip —— 半套恢复比不恢复更难收拾。
+ *
+ * 判据三条：
+ *  a. 目标存在且 `lstat().isSymbolicLink()` → 拒绝（含指向 home 内的链接：写它等于改写另一份文件）；
+ *  b. 从 `dirname(目标)` 向上找第一个**存在**的祖先，`realpathSync.native` 解析；解析失败 → 拒绝；
+ *  c. 真实落点必须仍在 `realpath(home)` 之内（`path.relative` 判定，Windows 折大小写比较）。
+ *
+ * 为什么 home 侧也 realpath：macOS `/var → /private/var`、Windows 8.3 短名 / 目录 junction 下
+ * 恢复自己的 home 是**正常**场景 —— 只解析目标侧会把正常恢复误判成越界。
+ *
+ * 缓存：按「实际解析过的祖先目录」缓存真实路径（同一父目录只解析一次），
+ * 不缓存不存在的中间层（它们的落点 = 存在祖先的真实路径 + 剩余段推导）。
+ */
+/** realpath，失败（不存在 / 无权限 / 不可解析）返回 null */
+function realpathOrNull(p) {
+    try {
+        return fssync.realpathSync.native(p);
+    }
+    catch {
+        return null;
+    }
+}
+/** 比较键：Windows 文件系统大小写不敏感 */
+function foldPathKey(p) {
+    return process.platform === 'win32' ? p.toLowerCase() : p;
+}
+/** child 是否等于 root 或位于 root 之内（两侧都应是已解析的真实路径） */
+function isRealInside(root, child) {
+    const rel = path.relative(foldPathKey(root), foldPathKey(child));
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel));
+}
+/**
+ * 生成「目标安全性」判定函数；返回 null = 安全，否则返回**机器码**（只作日志/诊断，
+ * 用户可见文案仍走既有 `restore.pathEscape`，不新造自然语言）。
+ */
+function createTargetSafetyChecker(homeDir) {
+    const homeResolved = path.resolve(homeDir);
+    const rootReal = realpathOrNull(homeResolved) ?? homeResolved;
+    const ancestorCache = new Map();
+    /** 父目录的真实落点：向上找第一个存在的祖先，再把不存在的剩余段拼回去 */
+    const projectedParentReal = (parent) => {
+        const parts = [];
+        let cur = parent;
+        for (;;) {
+            const cached = ancestorCache.get(foldPathKey(cur));
+            if (cached !== undefined)
+                return parts.length === 0 ? cached : path.join(cached, ...parts.reverse());
+            const real = realpathOrNull(cur);
+            if (real !== null) {
+                ancestorCache.set(foldPathKey(cur), real);
+                return parts.length === 0 ? real : path.join(real, ...parts.reverse());
+            }
+            const up = path.dirname(cur);
+            if (up === cur)
+                return null; // 上溯到根仍不可解析 ⇒ 保守拒绝
+            parts.push(path.basename(cur));
+            cur = up;
+        }
+    };
+    return (absTarget) => {
+        try {
+            if (fssync.lstatSync(absTarget).isSymbolicLink())
+                return 'target-symlink';
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                return 'target-unreadable';
+        }
+        const parentReal = projectedParentReal(path.dirname(absTarget));
+        if (parentReal === null)
+            return 'parent-unresolvable';
+        if (!isRealInside(rootReal, parentReal))
+            return 'parent-escape';
+        return null;
+    };
+}
+/** 计划里会真正落盘 / 删文件的动作（skip / pluginRemove / credentialHint 不碰目标路径） */
+const WRITE_TARGET_KINDS = new Set([
+    'hostFileRestore', 'hostFileRemove', 'fileRestore', 'fileRemove',
+]);
+/**
+ * 计划期目标侧总闸：任一目标不安全就抛错（整笔拒绝）。
+ * 字符串越界的目标在计划期已降级为 `skip`（不会走到这里），此处只补真实路径这一层。
+ */
+function assertPlanTargetsSafe(actions, homeDir, msg) {
+    const check = createTargetSafetyChecker(homeDir);
+    for (const a of actions) {
+        if (a.target === undefined || !WRITE_TARGET_KINDS.has(a.kind))
+            continue;
+        const abs = path.resolve(homeDir, a.target);
+        if (!isWithinHome(homeDir, abs))
+            continue;
+        const unsafe = check(abs);
+        if (unsafe !== null) {
+            // 复用既有「路径越界」语义与错误码：planRestore 顶层抛出 ⇒ restore() 一个字节都没写。
+            throw new Error(msg('restore.pathEscape', { path: a.target }));
+        }
+    }
+}
 /** file 类条目的目标绝对路径（复用 backup.ts 的基准目录规则；仅读 homeDir） */
 function resolveFileAbs(homeDir, adapter, ref) {
     return resolveFileTarget({ homeDir }, adapter, ref);
@@ -89,7 +212,37 @@ async function resolveSettingsRelPath(homeDir, settingsPath) {
     }
     return undefined;
 }
-/** 把当前文件复制到 <snapshotDir>/pre-restore/（双保险，命名含序号防碰撞） */
+/** pre-restore attempt 目录名：本地时间 yyyyMMdd-HHmmss-SSS */
+function preRestoreStamp(now = new Date()) {
+    const p2 = (n) => String(n).padStart(2, '0');
+    return `${String(now.getFullYear())}${p2(now.getMonth() + 1)}${p2(now.getDate())}-`
+        + `${p2(now.getHours())}${p2(now.getMinutes())}${p2(now.getSeconds())}-`
+        + String(now.getMilliseconds()).padStart(3, '0');
+}
+/**
+ * 新建本次执行的 pre-restore 目录（D5）：`<snapshotDir>/pre-restore/<attemptDir>/`。
+ *
+ * 为什么必须分目录：备份名原来是「seq + relPath」、seq 每次都从 1 重数 ⇒ 崩溃后重跑会把
+ * 第一次的「恢复前原文」覆盖成「第一次恢复后的内容」= 反悔副本静默丢失。
+ * 同名（同一毫秒内重复调用 / 时钟回拨）时追加 `-1`/`-2`…：靠 `mkdir` 的 EEXIST 判定，
+ * **不 pre-stat**（先查后建在并发下会撞车）。
+ */
+export async function createPreRestoreAttemptDir(preRoot) {
+    await fs.mkdir(preRoot, { recursive: true });
+    const stamp = preRestoreStamp();
+    for (let i = 0;; i += 1) {
+        const candidate = path.join(preRoot, i === 0 ? stamp : `${stamp}-${i}`);
+        try {
+            await fs.mkdir(candidate);
+            return candidate;
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+    }
+}
+/** 把当前文件复制到 <snapshotDir>/pre-restore/<attemptDir>/（双保险，命名含序号防碰撞） */
 async function copyToPreRestore(preDir, absPath, label, seq) {
     const safe = label.replace(/[\\/:*?"<>|]/g, '_');
     await fs.mkdir(preDir, { recursive: true });
@@ -476,6 +629,9 @@ export async function planRestore(opts) {
             detail: msg('restore.versionMismatchDetail', { snapshot: snapshotDshVersion, current: currentDshVersion }),
         });
     }
+    // D4：目标侧真实路径总闸（junction / 目录 symlink / 目标自身是 symlink）——
+    // 任一目标不安全 ⇒ 整笔拒绝（抛错，零写入），绝不逐项跳过。
+    assertPlanTargetsSafe(actions, homeDir, msg);
     return {
         snapshotId: snapshot.id,
         createdAt: snapshot.createdAt,
@@ -522,14 +678,14 @@ function summarizeActions(actions) {
 /* ------------------------------------------------------------ restore */
 /**
  * 执行恢复：按计划顺序 整文件还原 → 插件卸载 → file 补偿，
- * 覆盖/删除前全部先复制到 <snapshotDir>/pre-restore/（双保险），
+ * 覆盖/删除前全部先复制到 <snapshotDir>/pre-restore/<attemptDir>/（双保险，每次执行一个新目录），
  * 逐项 try/catch（单项失败不拖垮其余），输出诚实报告。
  */
 export async function restore(opts) {
     const plan = await planRestore(opts);
     const { snapshotDir, homeDir, profile } = opts;
     const msg = opts.msg ?? zhMsg;
-    const preDir = path.join(snapshotDir, 'pre-restore');
+    const preRoot = path.join(snapshotDir, 'pre-restore');
     const profileDir = resolveProfileDir(homeDir, profile);
     const uninstaller = opts.pluginUninstaller
         ?? ((name, dir, prof) => defaultPluginUninstaller(name, dir, prof, msg));
@@ -541,18 +697,71 @@ export async function restore(opts) {
         failed: [],
         skipped: [],
     };
+    // D5：反悔副本按「本次执行」分目录（pre-restore/<attemptDir>/），惰性创建 ——
+    // 计划全是 skip 的恢复不会建空目录（dry-run 连 restore() 都不调，同样零写入）。
+    let preDir;
+    const preDirOf = async () => {
+        if (preDir === undefined) {
+            preDir = await createPreRestoreAttemptDir(preRoot);
+            report.preRestoreDir = preDir;
+        }
+        return preDir;
+    };
+    // 逐动作 WAL（可判进度，见 restore-wal.ts）：绑定可信快照 → 推进 APPLYING → **首个写之前**
+    // 预登记**全部**动盘动作（planned + beforeFp）。预登记而不是边做边记：reconcile 只看 journal 里
+    // 存在的 step，只登记「已执行」的那些会把「崩在第 2 步」误判成「全部完成」。
+    const wal = createRestoreWal(opts.journal);
+    const walByAction = new Map();
+    const resume = opts.resume;
+    if (wal !== null) {
+        const { mutating, entries } = collectRestoreWalEntries(plan.actions, (a) => walAbsOf(a));
+        if (resume === undefined) {
+            const bindSnapshot = opts.journal?.bindSnapshot;
+            if (bindSnapshot !== undefined)
+                await bindSnapshot(plan.snapshotId);
+            const markApplying = opts.journal?.markApplying;
+            if (markApplying !== undefined)
+                await markApplying();
+            const handles = await wal.preRegister(entries);
+            mutating.forEach((a, i) => { walByAction.set(a, handles[i]); });
+        }
+        else {
+            // 续跑：只复原句柄，**绝不重新 preRegister**（见 RestoreOptions.resume 注释）。
+            const handles = restoreWalHandlesFromSteps(entries, resume.steps);
+            mutating.forEach((a, i) => { walByAction.set(a, handles[i]); });
+        }
+    }
+    /** 文件类动作的绝对目标（reconcile 直接拿它读盘算指纹）；插件卸载/越界目标 → null（不可指纹）。 */
+    function walAbsOf(action) {
+        if (action.kind === 'pluginRemove' || action.target === undefined)
+            return null;
+        try {
+            return homeAbs(homeDir, action.target, msg);
+        }
+        catch {
+            return null;
+        }
+    }
     let seq = 0;
     const total = plan.actions.length;
     let actionIndex = 0;
     for (const action of plan.actions) {
         actionIndex += 1;
         opts.onAction?.({ index: actionIndex, total, detail: action.description });
+        if (resume !== undefined && resume.skipStepIds.has(restoreActionStepId(action, walAbsOf(action)))) {
+            // 已证明上次就写成了这个动作的终态 —— 重做只会再覆盖一次（对删除类还会误删用户新放回的文件）。
+            report.skipped.push(msg('restore.resumedSkip', { description: action.description }));
+            continue;
+        }
+        const walHandle = walByAction.get(action);
+        let settleStatus = 'done';
+        let settleMessage = null;
         try {
             switch (action.kind) {
                 case 'hostFileRestore': {
                     const abs = homeAbs(homeDir, action.target, msg);
                     if (await fileExists(abs))
-                        await copyToPreRestore(preDir, abs, action.target, ++seq);
+                        await copyToPreRestore(await preDirOf(), abs, action.target, ++seq);
                     // 流式拷贝（t46）：blob → 目标文件经 copyFile，**不经内存中转**。改动前是
                     // readFile + atomicWriteFile —— 整个 blob 进堆，大 home 下与快照载荷叠加成双份驻留
                     // （本机 32MB blob 实测 +32.0MB arrayBuffers；改用本原语后 +0.0MB）。
@@ -564,7 +773,7 @@ export async function restore(opts) {
                 case 'hostFileRemove': {
                     const abs = homeAbs(homeDir, action.target, msg);
                     if (await fileExists(abs)) {
-                        await copyToPreRestore(preDir, abs, action.target, ++seq);
+                        await copyToPreRestore(await preDirOf(), abs, action.target, ++seq);
                         await fs.rm(abs, { force: true });
                     }
                     report.restored.push(action.target);
@@ -573,7 +782,7 @@ export async function restore(opts) {
                 case 'fileRestore': {
                     const abs = homeAbs(homeDir, action.target, msg);
                     if (await fileExists(abs))
-                        await copyToPreRestore(preDir, abs, action.target, ++seq);
+                        await copyToPreRestore(await preDirOf(), abs, action.target, ++seq);
                     // 流式拷贝（t46）：blob → 目标文件经 copyFile，**不经内存中转**。改动前是
                     // readFile + atomicWriteFile —— 整个 blob 进堆，大 home 下与快照载荷叠加成双份驻留
                     // （本机 32MB blob 实测 +32.0MB arrayBuffers；改用本原语后 +0.0MB）。
@@ -585,7 +794,7 @@ export async function restore(opts) {
                 case 'fileRemove': {
                     const abs = homeAbs(homeDir, action.target, msg);
                     if (await fileExists(abs)) {
-                        await copyToPreRestore(preDir, abs, action.target, ++seq);
+                        await copyToPreRestore(await preDirOf(), abs, action.target, ++seq);
                         await fs.rm(abs, { force: true });
                     }
                     report.restored.push(action.target);
@@ -597,7 +806,11 @@ export async function restore(opts) {
                         report.removedPlugins.push(action.pluginName);
                     }
                     else {
-                        report.failed.push({ item: `plugin:${action.pluginName}`, reason: result.message ?? msg('restore.pluginRemoveFailed') });
+                        const reason = result.message ?? msg('restore.pluginRemoveFailed');
+                        report.failed.push({ item: `plugin:${action.pluginName}`, reason });
+                        // 外部副作用没做成 → 记 attention（绝不记 done：reconcile 对 external step 本就保守）
+                        settleStatus = 'attention';
+                        settleMessage = reason;
                     }
                     break;
                 }
@@ -612,11 +825,14 @@ export async function restore(opts) {
             }
         }
         catch (err) {
-            report.failed.push({
-                item: action.target ?? action.pluginName ?? action.description,
-                reason: err instanceof Error ? err.message : String(err),
-            });
+            const reason = err instanceof Error ? err.message : String(err);
+            report.failed.push({ item: action.target ?? action.pluginName ?? action.description, reason });
+            settleStatus = 'attention';
+            settleMessage = reason;
         }
+        // WAL 终态与导入引擎同口径：持久化失败向上抛（fail-closed），绝不静默丢进度。
+        if (wal !== null && walHandle !== undefined)
+            await wal.settle(walHandle, settleStatus, settleMessage);
     }
     // F5 幽灵会话校验（file 类会话条目写回后）：快照记录的会话清单 vs 磁盘 sessions 目录
     // 实际文件，报告失效归档（备份有记录、磁盘无文件）。DSH 无归档会话 API，仅报告不

package/lib/core/rollback-ignore-rules.d.ts

@@ -28,4 +28,18 @@ export declare function loadIgnoreRules(root: string): Promise<IgnoreRules>;
 export declare function ignoreRuleMatches(rules: IgnoreRules, relPath: string, isDir: boolean): boolean;
 /** 分块根 → 该路径的规则相对路径（斜杠形式）。不在分块内返回 null（调用方按无规则处理）。 */
 export declare function ignoreRelativePath(root: string, target: string): string | null;
+/**
+ * 内置敏感文件判据：命中返回原因码 `'sensitive'`（含凭据，**不回滚**），否则 null。
+ *
+ * `relPath` 是**相对分块根**的斜杠路径（来自 {@link ignoreRelativePath}）——只看文件名与后缀，
+ * 不看目录：密钥常散落在任意子目录（src/a.key）。
+ *
+ * 与用户忽略规则的关键区别：**不可被 `!` 反向取消**。调用方在判定处独立调用本函数，
+ * 而不是把它编译进 parseIgnoreRules 的 patterns —— 用户写 `!.env` 的动机通常是「我要能回滚我的
+ * .env」，但那会把明文密码送进内容寻址仓库；这类文件宁可少回滚，也不明文物化。
+ *
+ * 大小写折半比较（Windows / macOS 上 .ENV 与 .env 是同一个文件）：宁可保守。
+ * 刻意放行：`.env.example` / `.env.sample` / `.env.template`（模板是文档）、`*.pub`（公钥）。
+ */
+export declare function builtinSensitiveReason(relPath: string): string | null;
 export {};

package/lib/core/rollback-ignore-rules.js

@@ -9,10 +9,12 @@
  *  - 尾 / = 只匹配目录；首 / = 相对规则文件所在目录（本实现里一律相对该目录）；
  *  - * / ? 不跨段，** 跨段。
  *
- * 两条硬边界（不得放宽）：
+ * 三条硬边界（不得放宽）：
  *  ① 内置运行时依赖目录（EXCLUDED_DEP_DIR_NAMES，当前 node_modules）不可被反向取消。
  *  ② 被忽略的整个目录不进走查 ⇒ 证明名单不完整 ⇒ 该点的删除集整体拒绝（fail-closed），
  *     由调用方据匹配结果置 ignoreIncomplete；被忽略的文件仍逐条进 skipped，名单照样完整。
+ *  ③ **内置敏感文件（凭据 / 私钥）同样不可被反向取消**：它们不进对象仓（不明文物化），
+ *     但仍进走查名单（pathIndex）⇒ 删除集不会把它们误判成「留点后新建」。见 builtinSensitiveReason。
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -20,6 +22,24 @@ import path from 'node:path';
 export const IGNORE_RULE_FILE_NAME = '.dsh-rollback-ignore';
 /** 内置运行时依赖目录名（与 utils/recursive-walk 的唯一来源保持一致） */
 const EXCLUDED_DEP_SEGMENTS = ['node_modules'];
+/**
+ * 内置敏感文件表（判据见 {@link builtinSensitiveReason}）——**只收明确的凭据形态**，
+ * 不放宽成「名字里带 secret/token 就算」：误判会让用户回滚点静默少文件，比多存几个文件更糟。
+ *
+ * **不按目录名判定**：密钥常放在任意子目录（src/a.key），按目录猜会漏。
+ */
+const SENSITIVE_BASENAMES = new Set([
+    '.npmrc', // npm token（_authToken）
+    '.pypirc', // PyPI token
+    '.netrc', // 明文登录口令
+    '.git-credentials', // git 明文凭据
+    '.htpasswd', // 散列口令（仍是凭据材料）
+    'id_rsa', 'id_ed25519', 'id_ecdsa', 'id_dsa', // OpenSSH 私钥（.pub 公钥已放行）
+]);
+/** 私钥 / 证书容器后缀（文件本身就是凭据材料） */
+const SENSITIVE_KEY_SUFFIXES = ['.pem', '.key', '.p12', '.pfx', '.jks', '.keystore', '.ppk'];
+/** `.env.*` 里属于**模板**的形态：样例文件是文档，必须照常进快照（否则用户拷一份就丢） */
+const ENV_TEMPLATE_SUFFIXES = new Set(['.example', '.sample', '.template']);
 const EMPTY_RULES = { root: '', patterns: [] };
 /** 单个字符是否需要正则转义（glob → RegExp 的唯一入口） */
 function escapeRegExpChar(ch) {
@@ -137,4 +157,37 @@ export function ignoreRelativePath(root, target) {
         return null;
     return rel.split('\\').join('/');
 }
+/**
+ * 内置敏感文件判据：命中返回原因码 `'sensitive'`（含凭据，**不回滚**），否则 null。
+ *
+ * `relPath` 是**相对分块根**的斜杠路径（来自 {@link ignoreRelativePath}）——只看文件名与后缀，
+ * 不看目录：密钥常散落在任意子目录（src/a.key）。
+ *
+ * 与用户忽略规则的关键区别：**不可被 `!` 反向取消**。调用方在判定处独立调用本函数，
+ * 而不是把它编译进 parseIgnoreRules 的 patterns —— 用户写 `!.env` 的动机通常是「我要能回滚我的
+ * .env」，但那会把明文密码送进内容寻址仓库；这类文件宁可少回滚，也不明文物化。
+ *
+ * 大小写折半比较（Windows / macOS 上 .ENV 与 .env 是同一个文件）：宁可保守。
+ * 刻意放行：`.env.example` / `.env.sample` / `.env.template`（模板是文档）、`*.pub`（公钥）。
+ */
+export function builtinSensitiveReason(relPath) {
+    const normalized = relPath.split('\\').join('/').replace(/^\.\//, '');
+    const base = normalized.slice(normalized.lastIndexOf('/') + 1).toLowerCase();
+    if (base === '')
+        return null;
+    // .env 家族：模板放行，其余（.env / .env.local / .env.production …）一律视为凭据
+    if (base === '.env')
+        return 'sensitive';
+    if (base.startsWith('.env.')) {
+        return ENV_TEMPLATE_SUFFIXES.has(base.slice('.env'.length)) ? null : 'sensitive';
+    }
+    if (SENSITIVE_BASENAMES.has(base))
+        return 'sensitive';
+    // 公钥放行（先于后缀判定：foo.pem.pub 之类也不该算凭据）
+    if (base.endsWith('.pub'))
+        return null;
+    if (SENSITIVE_KEY_SUFFIXES.some((suffix) => base.endsWith(suffix)))
+        return 'sensitive';
+    return null;
+}
 //# sourceMappingURL=rollback-ignore-rules.js.map

package/lib/core/rollback-point.d.ts

@@ -265,7 +265,9 @@ export interface RollbackSkippedEntry {
      * link（符号链接/junction，不跟随）/ missing / not-a-file / self-store /
      * dep-dir（运行时依赖目录，整棵忽略）/ ignored（用户忽略规则命中）/ too-large（超单文件上限）/
      * budget-bytes（加它会超总量预算）/ budget-files（文件数预算用尽）/
-     * asar-container（含 `.asar` 段的路径：宿主会把它当容器解析、畸形夹具能带走宿主，因此绝不碰）
+     * asar-container（含 `.asar` 段的路径：宿主会把它当容器解析、畸形夹具能带走宿主，因此绝不碰）/
+     * sensitive（内置敏感文件：.env / 私钥 / 凭据文件 —— 不明文物化进对象仓，也不可被 `!` 规则取消；
+     *   仍进走查名单，故删除集不受影响，见 rollback-ignore-rules.ts 的 builtinSensitiveReason）
      */
     reason: string;
 }

package/lib/core/rollback-point.js

@@ -71,7 +71,7 @@ import { isRecord } from '../utils/guards.js';
 import { EXCLUDED_DEP_DIR_NAMES } from '../utils/recursive-walk.js';
 import { diffLines } from '../utils/line-diff.js';
 import { projectKeyOf } from './session-select.js';
-import { ignoreRelativePath, ignoreRuleMatches, loadIgnoreRules } from './rollback-ignore-rules.js';
+import { builtinSensitiveReason, ignoreRelativePath, ignoreRuleMatches, loadIgnoreRules, } from './rollback-ignore-rules.js';
 import { mergeThreeWay } from './rollback-merge.js';
 import { decodeTextBytes, encodeTextBytes } from './text-fidelity.js';
 import { UndoJournalWriter, findInterruptedUndos, readUndoJournal, replayUndoJournal } from './rollback-undo-journal.js';
@@ -1417,6 +1417,15 @@ export class RollbackPointEngine {
                 // walked（= 路径索引的来源）。否则 skipped 被记录上限截断后，「留点时已存在但被忽略」
                 // 的文件既不在 files、也不在 skipped、更不在 pathIndex ⇒ 被当成「留点后新建」删掉。
                 collect?.push(full);
+                // t8（D3）：内置敏感文件（.env / 私钥 …）**绝不进对象仓** —— 明文凭据不物化。
+                // 与 node_modules 同档：用户 `!` 规则取消不了（这里独立判定，不经过 parseIgnoreRules）。
+                // 位置必须在 collect 之后：它仍进走查名单 ⇒ 删除集不会把它当成「留点后新建」删掉。
+                const relPath = ignoreRelativePath(chunk, full);
+                const sensitive = relPath === null ? null : builtinSensitiveReason(relPath);
+                if (sensitive !== null) {
+                    this.recordSkip(sink, 'skipped', { path: full, reason: sensitive });
+                    continue;
+                }
                 if (ignore !== undefined && this.ignoredByRules(ignore, full, false)) {
                     // 文件级忽略：逐条进 skipped（名单完整时删除照常；被记录上限截断时由 pathIndex 兜底）
                     this.recordSkip(sink, 'skipped', { path: full, reason: 'ignored' });