dsh-config-manager 0.1.76 → 0.1.78

package/lib/core/analyzer.js

@@ -1601,9 +1601,11 @@ function applyTombstoneFilter(items, tombstones) {
 /** PlanItem → 墓碑键（{kind,id}）映射；非「将写入」的条目（Skip 等）与配置类项返回 null 不过滤 */
 function tombstoneKeyForItem(item) {
     // 插件本体（plugin:<pkg>）：Install / Update / Conflict 均视为「将写入该插件」→ 命中墓碑剔除；
+    // issue #95 的 Create = 「把 host 自带的层声明进 dsh.profile.bundles」，同样是写入该插件，
+    // 必须一起被墓碑剔除（用户删过的插件不得被一份旧备份重新声明回来）。
     // patch: 行与 plugins:pnpm-workspace 是配置类项，不按插件墓碑过滤（分区级墓碑可覆盖）。
     if (item.adapter === 'plugins' && item.id.startsWith('plugin:')) {
-        if (item.kind !== 'Install' && item.kind !== 'Update' && item.kind !== 'Conflict')
+        if (item.kind !== 'Install' && item.kind !== 'Update' && item.kind !== 'Conflict' && item.kind !== 'Create')
             return null;
         return { kind: 'plugin', id: item.id.slice('plugin:'.length) };
     }

package/lib/core/backup.d.ts

@@ -38,6 +38,15 @@ export declare function planItemWritesTarget(item: PlanItem, exec?: PlanItemExec
  * 行 id 是任意字符串，无法靠形状判断它是不是一个路径。
  */
 export declare const PLUGIN_PATCH_REF_PREFIX = "patchFile:";
+/**
+ * plugins 分区中「profile 的 package.json」这一文件目标的 ref（issue #95）。
+ *
+ * 声明 host 自带的 bundle 层（`dsh.profile.bundles`）就是写这个文件，因此它必须与
+ * `pnpm-workspace.yaml` 同级：进导入前快照 → 回滚能整文件还原，否则一次导入留下的声明
+ * 撤不掉（照抄 \`patchFile:\` 的做法，用一个符号 ref 而不是真实文件名——ref 空间里还有
+ * 任意 patch 行 id，靠形状判断会撞车）。
+ */
+export declare const PLUGIN_PROFILE_MANIFEST_REF = "profileManifest";
 /**
  * 以**系统 home 为根**的文件类分区（ref 是系统 home 相对路径）。
  *

package/lib/core/backup.js

@@ -118,6 +118,15 @@ for (const id of SECTION_IDS) {
  * 行 id 是任意字符串，无法靠形状判断它是不是一个路径。
  */
 export const PLUGIN_PATCH_REF_PREFIX = 'patchFile:';
+/**
+ * plugins 分区中「profile 的 package.json」这一文件目标的 ref（issue #95）。
+ *
+ * 声明 host 自带的 bundle 层（`dsh.profile.bundles`）就是写这个文件，因此它必须与
+ * `pnpm-workspace.yaml` 同级：进导入前快照 → 回滚能整文件还原，否则一次导入留下的声明
+ * 撤不掉（照抄 \`patchFile:\` 的做法，用一个符号 ref 而不是真实文件名——ref 空间里还有
+ * 任意 patch 行 id，靠形状判断会撞车）。
+ */
+export const PLUGIN_PROFILE_MANIFEST_REF = 'profileManifest';
 /** profile 目录绝对路径（plugins 分区内文件类目标的基准） */
 function profileDirOf(ctx) {
     const profile = ctx.profile !== undefined && ctx.profile !== '' ? ctx.profile : 'web';
@@ -167,6 +176,10 @@ export function resolveFileTarget(ctx, adapter, ref) {
     if (adapter === 'plugins' && ref.startsWith(PLUGIN_PATCH_REF_PREFIX)) {
         return path.join(profileDirOf(ctx), ref.slice(PLUGIN_PATCH_REF_PREFIX.length));
     }
+    // issue #95：声明 host 自带 bundle 层 = 写 profile 的 package.json（快照/回滚必须覆盖它）
+    if (adapter === 'plugins' && ref === PLUGIN_PROFILE_MANIFEST_REF) {
+        return path.join(profileDirOf(ctx), 'package.json');
+    }
     const base = FILE_BASES[adapter] ?? '';
     return path.join(ctx.homeDir, base, ref);
 }
@@ -188,6 +201,8 @@ export function resolveFileTargetRel(adapter, ref, profile) {
         const profileDir = `profiles/${profile !== undefined && profile !== '' ? profile : 'web'}`;
         if (ref === 'pnpm-workspace.yaml')
             return normalizePath(`${profileDir}/pnpm-workspace.yaml`);
+        if (ref === PLUGIN_PROFILE_MANIFEST_REF)
+            return normalizePath(`${profileDir}/package.json`);
         if (ref.startsWith(PLUGIN_PATCH_REF_PREFIX)) {
             return normalizePath(`${profileDir}/${ref.slice(PLUGIN_PATCH_REF_PREFIX.length)}`);
         }
@@ -257,7 +272,7 @@ async function engineSnapshotEntry(ctx, target) {
         case 'plugins':
         case 'prompts': {
             // plugins 分区的 pnpm-workspace.yaml / patch 文件 → 整文件快照（file 类，回滚可整文件还原）
-            if (target.adapter === 'plugins' && (target.ref === 'pnpm-workspace.yaml' || target.ref.startsWith(PLUGIN_PATCH_REF_PREFIX))) {
+            if (target.adapter === 'plugins' && (target.ref === 'pnpm-workspace.yaml' || target.ref === PLUGIN_PROFILE_MANIFEST_REF || target.ref.startsWith(PLUGIN_PATCH_REF_PREFIX))) {
                 const abs = resolveFileTarget(ctx, target.adapter, target.ref);
                 if (!(await ctx.fs.exists(abs))) {
                     return { kind: 'file', adapter: target.adapter, ref: target.ref, before: null, existed: false };

package/lib/core/messages.d.ts

@@ -177,6 +177,7 @@ export declare const zh: {
     readonly 'host.sessionStoreShapeUnknown': '宿主会话存储列举（sessionPersistence.list()）的元素形状无法解析（探测形状 {shape}，{count} 个元素全部认不出）：父子关系判定放弃，绝不当作「本机没有父子关系」（请升级 DSH，或把该形状反馈给插件）';
     readonly 'host.sessionStorePurposeReindex': '会话 header 重新索引';
     readonly 'host.sessionStorePurposeParentRelations': '父子关系判定';
+    readonly 'host.sessionStorePurposeRewindAttach': '回退子会话归位';
     readonly 'host.sessionStoreListFailed': '会话存储列举失败（{purpose}）：{reason}';
     readonly 'host.sessionStoreListNotArray': '会话存储列举返回非数组（{purpose}）：形状未知，按不可用处理';
     readonly 'host.sessionStorePartialUnresolved': '会话存储列举中有 {count}/{total} 个元素形状无法解析（{purpose}）：已解析的照常使用';
@@ -246,6 +247,15 @@ export declare const zh: {
     readonly 'adapter.pluginInstallOk': '插件 {name} 已安装{suffix}';
     readonly 'adapter.pluginUpdateTriggered': '插件 {name} 已触发更新（npm 最新版）{suffix}';
     readonly 'adapter.pluginRestartSuffix': '，重启 dsh 后生效';
+    readonly 'adapter.pluginHostBundleDeclare': '声明插件层 {name}（由 DSH 自带提供，不安装）';
+    readonly 'adapter.pluginHostBundleSame': '插件层 {name} 已在目标机声明（由 DSH 自带提供）';
+    readonly 'adapter.pluginHostBundleDeclared': '已声明插件层 {name}，重启 dsh 后生效';
+    readonly 'adapter.pluginHostBundleDetail': '该层在源机只出现在 dsh.profile.bundles、dependencies 里没有它，由 DSH 从自己的安装位置解析；导入只声明，不装 npm 版本';
+    readonly 'adapter.pluginHostBundleNoManifest': '无法声明插件层 {name}：目标机 profile 缺少 package.json';
+    readonly 'adapter.pluginHostBundleManifestUnreadable': '无法声明插件层 {name}：profile 清单读不到或形态不符（{reason}）';
+    readonly 'adapter.pluginHostBundleWriteFailed': '声明插件层 {name} 失败：{reason}';
+    readonly 'adapter.pluginHostBundleBadJson': 'package.json 不是合法 JSON';
+    readonly 'adapter.pluginHostBundleBadShape': 'dsh.profile.bundles 不是字符串数组';
     readonly 'adapter.pwMissing': '导入数据缺少 pnpm-workspace.yaml 内容';
     readonly 'adapter.pluginInstallFailed': '插件 {name} 安装失败：{msg}。可手动安装：dsh plugin --profile {profile} add {name}（其余配置已导入；可修复依赖后在设置页重试或手动安装）';
     readonly 'adapter.pluginUpdateFailed': '插件 {name} 更新失败：{msg}。可手动安装：dsh plugin --profile {profile} add {name}（其余配置已导入；可修复依赖后在设置页重试或手动安装）';
@@ -317,6 +327,7 @@ export declare const zh: {
     readonly 'adapter.validate.requiredField': '缺少 {subject}';
     readonly 'adapter.validate.sourceNamespace': '缺少来源 namespace';
     readonly 'adapter.validate.number': '{subject} 必须是数字';
+    readonly 'adapter.validate.boolean': '{subject} 必须是布尔值';
     readonly 'adapter.validate.nonEmptyRef': '{subject} 记录必须含非空 ref';
     readonly 'adapter.validate.credentialRef': '凭据记录必须含非空 ref';
     readonly 'adapter.validate.fileRelativePath': '文件记录必须含非空 relativePath';

package/lib/core/messages.js

@@ -166,6 +166,7 @@ export const zh = {
     'host.sessionStoreShapeUnknown': '宿主会话存储列举（sessionPersistence.list()）的元素形状无法解析（探测形状 {shape}，{count} 个元素全部认不出）：父子关系判定放弃，绝不当作「本机没有父子关系」（请升级 DSH，或把该形状反馈给插件）',
     'host.sessionStorePurposeReindex': '会话 header 重新索引',
     'host.sessionStorePurposeParentRelations': '父子关系判定',
+    'host.sessionStorePurposeRewindAttach': '回退子会话归位',
     'host.sessionStoreListFailed': '会话存储列举失败（{purpose}）：{reason}',
     'host.sessionStoreListNotArray': '会话存储列举返回非数组（{purpose}）：形状未知，按不可用处理',
     'host.sessionStorePartialUnresolved': '会话存储列举中有 {count}/{total} 个元素形状无法解析（{purpose}）：已解析的照常使用',
@@ -237,6 +238,15 @@ export const zh = {
     'adapter.pluginInstallOk': '插件 {name} 已安装{suffix}',
     'adapter.pluginUpdateTriggered': '插件 {name} 已触发更新（npm 最新版）{suffix}',
     'adapter.pluginRestartSuffix': '，重启 dsh 后生效',
+    'adapter.pluginHostBundleDeclare': '声明插件层 {name}（由 DSH 自带提供，不安装）',
+    'adapter.pluginHostBundleSame': '插件层 {name} 已在目标机声明（由 DSH 自带提供）',
+    'adapter.pluginHostBundleDeclared': '已声明插件层 {name}，重启 dsh 后生效',
+    'adapter.pluginHostBundleDetail': '该层在源机只出现在 dsh.profile.bundles、dependencies 里没有它，由 DSH 从自己的安装位置解析；导入只声明，不装 npm 版本',
+    'adapter.pluginHostBundleNoManifest': '无法声明插件层 {name}：目标机 profile 缺少 package.json',
+    'adapter.pluginHostBundleManifestUnreadable': '无法声明插件层 {name}：profile 清单读不到或形态不符（{reason}）',
+    'adapter.pluginHostBundleWriteFailed': '声明插件层 {name} 失败：{reason}',
+    'adapter.pluginHostBundleBadJson': 'package.json 不是合法 JSON',
+    'adapter.pluginHostBundleBadShape': 'dsh.profile.bundles 不是字符串数组',
     'adapter.pwMissing': '导入数据缺少 pnpm-workspace.yaml 内容',
     'adapter.pluginInstallFailed': '插件 {name} 安装失败：{msg}。可手动安装：dsh plugin --profile {profile} add {name}（其余配置已导入；可修复依赖后在设置页重试或手动安装）',
     'adapter.pluginUpdateFailed': '插件 {name} 更新失败：{msg}。可手动安装：dsh plugin --profile {profile} add {name}（其余配置已导入；可修复依赖后在设置页重试或手动安装）',
@@ -310,6 +320,7 @@ export const zh = {
     'adapter.validate.requiredField': '缺少 {subject}',
     'adapter.validate.sourceNamespace': '缺少来源 namespace',
     'adapter.validate.number': '{subject} 必须是数字',
+    'adapter.validate.boolean': '{subject} 必须是布尔值',
     'adapter.validate.nonEmptyRef': '{subject} 记录必须含非空 ref',
     'adapter.validate.credentialRef': '凭据记录必须含非空 ref',
     'adapter.validate.fileRelativePath': '文件记录必须含非空 relativePath',
@@ -603,6 +614,7 @@ export const en = {
     'host.sessionStoreShapeUnknown': 'Cannot parse the elements returned by the host session store (sessionPersistence.list(); probed shape {shape}, none of the {count} elements is recognizable): parent/child detection is abandoned rather than treated as "no parent relations on this machine" (please upgrade DSH or report this shape to the plugin)',
     'host.sessionStorePurposeReindex': 'session header re-index',
     'host.sessionStorePurposeParentRelations': 'parent/child detection',
+    'host.sessionStorePurposeRewindAttach': 'rewind child session placement',
     'host.sessionStoreListFailed': 'Session store listing failed ({purpose}): {reason}',
     'host.sessionStoreListNotArray': 'Session store listing returned a non-array ({purpose}): unknown shape, treated as unavailable',
     'host.sessionStorePartialUnresolved': 'Session store listing: {count}/{total} elements have an unrecognized shape ({purpose}); the parsed ones are still used',
@@ -674,6 +686,15 @@ export const en = {
     'adapter.pluginInstallOk': 'Plugin {name} installed{suffix}',
     'adapter.pluginUpdateTriggered': 'Plugin {name} update triggered (npm latest){suffix}',
     'adapter.pluginRestartSuffix': '; takes effect after restarting dsh',
+    'adapter.pluginHostBundleDeclare': 'Declare plugin layer {name} (provided by DSH itself; not installed)',
+    'adapter.pluginHostBundleSame': 'Plugin layer {name} is already declared on the target (provided by DSH itself)',
+    'adapter.pluginHostBundleDeclared': 'Plugin layer {name} declared; takes effect after restarting dsh',
+    'adapter.pluginHostBundleDetail': 'On the source this layer only appears in dsh.profile.bundles (no dependency declaration) and is resolved by DSH from its own installation; the import only declares it and installs no npm version',
+    'adapter.pluginHostBundleNoManifest': 'Cannot declare plugin layer {name}: the target profile has no package.json',
+    'adapter.pluginHostBundleManifestUnreadable': 'Cannot declare plugin layer {name}: the profile manifest is unreadable or has an unexpected shape ({reason})',
+    'adapter.pluginHostBundleWriteFailed': 'Failed to declare plugin layer {name}: {reason}',
+    'adapter.pluginHostBundleBadJson': 'package.json is not valid JSON',
+    'adapter.pluginHostBundleBadShape': 'dsh.profile.bundles is not an array of strings',
     'adapter.pwMissing': 'Import data is missing pnpm-workspace.yaml content',
     'adapter.pluginInstallFailed': 'Plugin {name} install failed: {msg}. You can install it manually: dsh plugin --profile {profile} add {name} (the rest of the config was imported; fix dependencies and retry from the settings page, or install by hand)',
     'adapter.pluginUpdateFailed': 'Plugin {name} update failed: {msg}. You can install it manually: dsh plugin --profile {profile} add {name} (the rest of the config was imported; fix dependencies and retry from the settings page, or install by hand)',
@@ -747,6 +768,7 @@ export const en = {
     'adapter.validate.requiredField': 'Missing {subject}',
     'adapter.validate.sourceNamespace': 'Missing source namespace',
     'adapter.validate.number': '{subject} must be a number',
+    'adapter.validate.boolean': '{subject} must be a boolean',
     'adapter.validate.nonEmptyRef': '{subject} records must have a non-empty ref',
     'adapter.validate.credentialRef': 'Credential records must have a non-empty ref',
     'adapter.validate.fileRelativePath': 'File records must have a non-empty relativePath',

package/lib/core/plugin-cli.d.ts

@@ -118,6 +118,32 @@ export declare function reconcileBundles(profileDir: string): boolean;
 export declare function cleanupAbortedInstall(profileDir: string, pkg: string): void;
 /** 实时读 profile 已装插件清单（先 reconcile bundles，再逐依赖取版本/bundle 属性）。 */
 export declare function listInstalledPlugins(homeDir: string, profile: string): PluginInfo[];
+/**
+ * 「只在 `dsh.profile.bundles` 里声明、`dependencies` 里没有该包」的条目判定（issue #95）。
+ *
+ * 为什么要一个共享判据：导出端的显式字段（`bundlesOnly`）只存在于新备份；旧备份只能按形状
+ * 推断——**有依赖 spec 的绝不是**（那是普通依赖，哪怕本机没装全）；**没有 spec 且读不到已装版本**
+ * 的才是（本 profile 里没有任何东西提供它，DSH 只能从自己的安装位置解析，issue #95）。
+ */
+export declare function isBundlesOnlyEntry(entry: {
+    bundlesOnly?: unknown;
+    spec?: unknown;
+    version?: unknown;
+}): boolean;
+/**
+ * 把 `name` 声明进 profile package.json 的 `dsh.profile.bundles`（issue #95）。
+ *
+ * 只做「追加一个名字」：其余字段逐字保留，重复声明返回 `changed: false`（幂等，不空写文件）。
+ * 形状不可认（JSON 坏 / `dsh.profile` 非对象 / `bundles` 非字符串数组）→ 返回 null：
+ * 调用方必须**如实报告**并放弃这次声明，绝不重建一份清单出来（那会抹掉 profile 的其它字段）。
+ *
+ * `bundles` 字段**缺省也拒绝**：DSH 的语义是「bundles 非空即替换默认插件栈」，凭空造一个只含
+ * 一个名字的数组 = 悄悄改掉目标机的装配语义（应当由 DSH 自己写这个字段）。
+ */
+export declare function mergeBundleDeclaration(pkgText: string, name: string): {
+    text: string;
+    changed: boolean;
+} | null;
 /** 安装目标：非 registry spec 按 spec 安装；其余按裸包名（npm 最新版）。 */
 export declare function installSpecFor(pkg: string, spec?: string): string;
 /** 一次 CLI 调用的启动描述（env 只在需要覆写子进程环境时出现）。 */

package/lib/core/plugin-cli.js

@@ -327,18 +327,78 @@ export function listInstalledPlugins(homeDir, profile) {
             continue;
         if (Object.prototype.hasOwnProperty.call(installed, name))
             continue; // 已在依赖清单里
+        const installedVersion = readInstalledVersion(dir, name) ?? '';
         out.push({
             name,
-            version: readInstalledVersion(dir, name) ?? '',
+            version: installedVersion,
             enabled: true,
             isBundle: true,
             // 直接声明的层自己就是 profile 层
             inBundles: [name],
-            // 无依赖声明 → 无 spec：导入时按裸包名安装（与 registry 依赖同语义）
+            // issue #95：无依赖声明 + **本 profile 也没有它的落盘副本** ⇒ 这个包只可能由 DSH 从自己的
+            // 安装位置解析。导入端只能把它声明进目标机的 bundles，绝不按裸包名走 npm（那会把
+            // dist-tag latest 的副本装进 profile，与 host 版本线脱节）。
+            // 本地**有**落盘副本的手工层不在此列：那种层得靠安装通道才能在目标机上存在，保持旧行为。
+            ...(installedVersion === '' ? { bundlesOnly: true } : {}),
         });
     }
     return out;
 }
+/**
+ * 「只在 `dsh.profile.bundles` 里声明、`dependencies` 里没有该包」的条目判定（issue #95）。
+ *
+ * 为什么要一个共享判据：导出端的显式字段（`bundlesOnly`）只存在于新备份；旧备份只能按形状
+ * 推断——**有依赖 spec 的绝不是**（那是普通依赖，哪怕本机没装全）；**没有 spec 且读不到已装版本**
+ * 的才是（本 profile 里没有任何东西提供它，DSH 只能从自己的安装位置解析，issue #95）。
+ */
+export function isBundlesOnlyEntry(entry) {
+    if (entry.bundlesOnly === true)
+        return true;
+    if (entry.bundlesOnly !== undefined)
+        return false;
+    const spec = typeof entry.spec === 'string' ? entry.spec : '';
+    const version = typeof entry.version === 'string' ? entry.version : '';
+    return spec === '' && version === '';
+}
+/**
+ * 把 `name` 声明进 profile package.json 的 `dsh.profile.bundles`（issue #95）。
+ *
+ * 只做「追加一个名字」：其余字段逐字保留，重复声明返回 `changed: false`（幂等，不空写文件）。
+ * 形状不可认（JSON 坏 / `dsh.profile` 非对象 / `bundles` 非字符串数组）→ 返回 null：
+ * 调用方必须**如实报告**并放弃这次声明，绝不重建一份清单出来（那会抹掉 profile 的其它字段）。
+ *
+ * `bundles` 字段**缺省也拒绝**：DSH 的语义是「bundles 非空即替换默认插件栈」，凭空造一个只含
+ * 一个名字的数组 = 悄悄改掉目标机的装配语义（应当由 DSH 自己写这个字段）。
+ */
+export function mergeBundleDeclaration(pkgText, name) {
+    let parsed;
+    try {
+        parsed = JSON.parse(pkgText);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const pkg = parsed;
+    const dsh = pkg.dsh;
+    if (dsh === null || typeof dsh !== 'object' || Array.isArray(dsh))
+        return null;
+    const profile = dsh.profile;
+    if (profile === null || typeof profile !== 'object' || Array.isArray(profile))
+        return null;
+    const raw = profile.bundles;
+    if (raw === undefined)
+        return null;
+    if (!Array.isArray(raw) || raw.some((entry) => typeof entry !== 'string'))
+        return null;
+    const bundles = raw;
+    if (bundles.includes(name))
+        return { text: pkgText, changed: false };
+    bundles.push(name);
+    profile.bundles = bundles;
+    return { text: `${JSON.stringify(pkg, null, 2)}\n`, changed: true };
+}
 /* --------------------------------------------------------------- CLI 通道 */
 /** 15 分钟默认上限（慢网络 + git 安装），可用环境变量覆盖（CI/测试）。 */
 const INSTALL_TIMEOUT_MS = Number(process.env.DSH_CONFIG_MANAGER_INSTALL_TIMEOUT_MS) || 15 * 60 * 1000;

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

@@ -0,0 +1,81 @@
+/** 台账文件名（与回滚点库同目录：dataDir/rollback-points/attribution.json） */
+export declare const ROLLBACK_ATTRIBUTION_FILE_NAME = "attribution.json";
+/** 条目上限（超出按 at 淘汰最旧）—— 台账无界增长会把宿主拖垮（见 issue #89 的教训） */
+export declare const ROLLBACK_ATTRIBUTION_MAX_ENTRIES = 20000;
+/**
+ * 认得的**写类**工具名。
+ *
+ * 为什么用白名单而不是「参数里有 path 就算写」：`read` / `grep` / `ops_inspect_local_file`
+ * 的参数里也有 path —— 把它们当写入者会让**读**污染归属，进而让回退误跳过本该恢复的文件。
+ */
+export declare const ROLLBACK_WRITE_TOOL_NAMES: readonly string[];
+/** 一条写入归属：谁（会话）在什么时候用哪个工具写了这个路径 */
+export interface RollbackWriteFact {
+    sessionId: string;
+    tool: string;
+    callId: string;
+    /** 毫秒时间戳（本进程时钟） */
+    at: number;
+    turn: number | null;
+}
+/** 引擎只读这一面 */
+export interface RollbackWriteAttributionPort {
+    /** 该路径最后一次的写入归属；undefined = **未判定**（不是「没人写过」） */
+    writerOf(target: string): RollbackWriteFact | undefined;
+}
+/** 采集面（只有留点器的 noteEvent 用得上） */
+export interface RollbackWriteRecorder {
+    /**
+     * 记一次 `tool/call` 事件载荷。返回**记录到的路径条数**：
+     * 0 = 不是写类工具 / 解析不出路径 = **未判定**（绝不代表「没写过」）。
+     */
+    noteToolCall(sessionId: string, data: unknown): number;
+}
+/**
+ * 从一次 `tool/call` 事件载荷里抽出**会被写的路径**。
+ *
+ * `arguments` 在 DSH 的事件里是 **JSON 字符串**（不是对象）——两种形态都收，
+ * 解不出来就返回空数组（= 未判定），绝不抛错。
+ */
+export declare function toolCallWritePaths(name: unknown, argumentsValue: unknown): string[];
+export interface RollbackWriteAttributionOptions {
+    /** 台账文件绝对路径 */
+    file: string;
+    now?: () => number;
+    maxEntries?: number;
+    /** 落盘延迟（毫秒）；<= 0 表示不自动落盘（测试用） */
+    flushDelayMs?: number;
+    warn?: (line: string) => void;
+}
+/**
+ * 内存台账 + best-effort 落盘。
+ *
+ * 落盘的作用只有一个：**进程重启后**打开旧会话回退时，归属还在。
+ * 因此写入是延迟合并的（一次 tool/call 一行，立即落盘会把 I/O 打成筛子）。
+ */
+export declare class RollbackWriteAttribution implements RollbackWriteAttributionPort, RollbackWriteRecorder {
+    private readonly entries;
+    private readonly file;
+    private readonly now;
+    private readonly maxEntries;
+    private readonly flushDelayMs;
+    private readonly warn;
+    private loadPromise;
+    private flushTimer;
+    private writing;
+    constructor(options: RollbackWriteAttributionOptions);
+    /** 台账条目数（测试与诊断用） */
+    get size(): number;
+    /** 惰性读盘（幂等；读失败 = 空表，只 warn） */
+    load(): Promise<void>;
+    private read;
+    /** 记一次 tool/call（返回记录到的路径条数；0 = 不是写类工具或解析不出路径 = 未判定） */
+    noteToolCall(sessionId: string, data: unknown): number;
+    /** 淘汰最旧条目（按 at 升序删到上限内） */
+    private evictOldest;
+    writerOf(target: string): RollbackWriteFact | undefined;
+    /** 延迟落盘（多次调用只落一次） */
+    scheduleFlush(): void;
+    /** 立刻落盘（原子：同目录临时文件 + rename；失败只 warn，绝不上抛） */
+    flush(): Promise<void>;
+}

package/lib/core/rollback-attribution.js

@@ -0,0 +1,236 @@
+/**
+ * 工具调用的**写入归属台账** —— 「这个路径最后一次是哪个会话的哪次工具调用写的」。
+ *
+ * 为什么需要（2026-10-17 用户反馈）：回滚点的「工作区态」是**整个工作区**的快照，
+ * 回退也按整棵树执行 ⇒ 同一工作区里对话 A 改了文件，对话 B 回退时会把 A 的改动一起撤销。
+ * 有了归属，引擎才能在预览里标出「这个文件在留点之后是**别的**会话写的」，
+ * 让界面把它默认排除（用户仍可手动勾回来）。
+ *
+ * 三条不变量（不得放宽）：
+ *  ① 采集**尽力而为**：只有能解析出路径的写类工具（write/edit/ops_replace…）才记。
+ *     `pwsh` / `run_code` / 外部编辑器写的文件**没有归属** ⇒ 查不到 = **未判定**。
+ *  ② **未判定 ≠ 别的会话写的**：只有确知最后写入者是别的会话时才敢标 foreign。
+ *     拿不准就按老口径（照常恢复）—— 少标一次，比误判一次安全。
+ *  ③ 落盘失败只 warn：台账丢了只让归属退化成「未判定」，绝不参与留点 / 回退的成败判定。
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/** 台账文件名（与回滚点库同目录：dataDir/rollback-points/attribution.json） */
+export const ROLLBACK_ATTRIBUTION_FILE_NAME = 'attribution.json';
+/** 条目上限（超出按 at 淘汰最旧）—— 台账无界增长会把宿主拖垮（见 issue #89 的教训） */
+export const ROLLBACK_ATTRIBUTION_MAX_ENTRIES = 20000;
+/**
+ * 认得的**写类**工具名。
+ *
+ * 为什么用白名单而不是「参数里有 path 就算写」：`read` / `grep` / `ops_inspect_local_file`
+ * 的参数里也有 path —— 把它们当写入者会让**读**污染归属，进而让回退误跳过本该恢复的文件。
+ */
+export const ROLLBACK_WRITE_TOOL_NAMES = [
+    'write',
+    'edit',
+    'ops_replace',
+    'ops_edit',
+    'write_file',
+    'str_replace',
+    'multi_edit',
+    'apply_patch',
+];
+/** 写类工具里代表「目标路径」的参数名（DSH 官方 write/edit 用 file_path；本插件工具用 path） */
+const WRITE_PATH_ARG_KEYS = ['file_path', 'path', 'filePath'];
+/** 路径比较键（与 `rollback-point.ts` 的 pathKey 同一口径：resolve + win32 折叠大小写） */
+function attributionPathKey(value) {
+    const resolved = path.resolve(value);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+/**
+ * 从一次 `tool/call` 事件载荷里抽出**会被写的路径**。
+ *
+ * `arguments` 在 DSH 的事件里是 **JSON 字符串**（不是对象）——两种形态都收，
+ * 解不出来就返回空数组（= 未判定），绝不抛错。
+ */
+export function toolCallWritePaths(name, argumentsValue) {
+    if (typeof name !== 'string' || !ROLLBACK_WRITE_TOOL_NAMES.includes(name))
+        return [];
+    let parsed = argumentsValue;
+    if (typeof argumentsValue === 'string') {
+        try {
+            parsed = JSON.parse(argumentsValue);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        return [];
+    const record = parsed;
+    const out = [];
+    for (const key of WRITE_PATH_ARG_KEYS) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim() !== '')
+            out.push(value);
+    }
+    // 同一个调用里两个键指向同一路径是常见的（别名）⇒ 去重，避免同一路径记两次
+    return [...new Set(out)];
+}
+function readFact(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const sessionId = record.sessionId;
+    const at = record.at;
+    if (typeof sessionId !== 'string' || sessionId === '')
+        return null;
+    if (typeof at !== 'number' || !Number.isFinite(at))
+        return null;
+    return {
+        sessionId,
+        at,
+        tool: typeof record.tool === 'string' ? record.tool : '',
+        callId: typeof record.callId === 'string' ? record.callId : '',
+        turn: typeof record.turn === 'number' && Number.isFinite(record.turn) ? record.turn : null,
+    };
+}
+/**
+ * 内存台账 + best-effort 落盘。
+ *
+ * 落盘的作用只有一个：**进程重启后**打开旧会话回退时，归属还在。
+ * 因此写入是延迟合并的（一次 tool/call 一行，立即落盘会把 I/O 打成筛子）。
+ */
+export class RollbackWriteAttribution {
+    entries = new Map();
+    file;
+    now;
+    maxEntries;
+    flushDelayMs;
+    warn;
+    loadPromise = null;
+    flushTimer = null;
+    writing = null;
+    constructor(options) {
+        this.file = path.resolve(options.file);
+        this.now = options.now ?? (() => Date.now());
+        this.maxEntries = Math.max(1, options.maxEntries ?? ROLLBACK_ATTRIBUTION_MAX_ENTRIES);
+        this.flushDelayMs = options.flushDelayMs ?? 1000;
+        this.warn = options.warn ?? (() => { });
+    }
+    /** 台账条目数（测试与诊断用） */
+    get size() {
+        return this.entries.size;
+    }
+    /** 惰性读盘（幂等；读失败 = 空表，只 warn） */
+    async load() {
+        if (this.loadPromise === null)
+            this.loadPromise = this.read();
+        return this.loadPromise;
+    }
+    async read() {
+        try {
+            const text = await fs.readFile(this.file, 'utf8');
+            const parsed = JSON.parse(text);
+            if (parsed.version !== 1 || parsed.entries === null || typeof parsed.entries !== 'object' || Array.isArray(parsed.entries)) {
+                this.warn('rollback attribution ignored (shape): ' + this.file);
+                return;
+            }
+            for (const [key, value] of Object.entries(parsed.entries)) {
+                const fact = readFact(value);
+                // 读盘期间可能已经有本进程新记的条目 ⇒ **新记录优先**（磁盘只是旧快照）
+                if (fact !== null && !this.entries.has(key))
+                    this.entries.set(key, fact);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            // ENOENT = 还没写过台账（正常）；其它错误如实留痕但不抛
+            if (code !== 'ENOENT')
+                this.warn('rollback attribution unreadable: ' + this.file + ' ' + String(code ?? error));
+        }
+    }
+    /** 记一次 tool/call（返回记录到的路径条数；0 = 不是写类工具或解析不出路径 = 未判定） */
+    noteToolCall(sessionId, data) {
+        if (typeof sessionId !== 'string' || sessionId === '')
+            return 0;
+        if (data === null || typeof data !== 'object')
+            return 0;
+        const record = data;
+        const paths = toolCallWritePaths(record.name, record.arguments);
+        if (paths.length === 0)
+            return 0;
+        const fact = {
+            sessionId,
+            tool: typeof record.name === 'string' ? record.name : '',
+            callId: typeof record.callId === 'string' ? record.callId : '',
+            at: this.now(),
+            turn: typeof record.turn === 'number' && Number.isFinite(record.turn) ? record.turn : null,
+        };
+        for (const target of paths)
+            this.entries.set(attributionPathKey(target), fact);
+        if (this.entries.size > this.maxEntries)
+            this.evictOldest();
+        this.scheduleFlush();
+        return paths.length;
+    }
+    /** 淘汰最旧条目（按 at 升序删到上限内） */
+    evictOldest() {
+        const sorted = [...this.entries.entries()].sort((a, b) => a[1].at - b[1].at);
+        const over = this.entries.size - this.maxEntries;
+        for (let i = 0; i < over; i += 1) {
+            const item = sorted[i];
+            if (item !== undefined)
+                this.entries.delete(item[0]);
+        }
+    }
+    writerOf(target) {
+        return this.entries.get(attributionPathKey(target));
+    }
+    /** 延迟落盘（多次调用只落一次） */
+    scheduleFlush() {
+        if (this.flushDelayMs <= 0 || this.flushTimer !== null)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush();
+        }, this.flushDelayMs);
+        this.flushTimer.unref?.();
+    }
+    /** 立刻落盘（原子：同目录临时文件 + rename；失败只 warn，绝不上抛） */
+    async flush() {
+        if (this.writing !== null)
+            return this.writing;
+        this.writing = (async () => {
+            try {
+                await fs.mkdir(path.dirname(this.file), { recursive: true });
+                const entriesSnapshot = Object.fromEntries(this.entries);
+                // **写前合并**（2026-10-17 修）：本进程内存里只有自己见过的写入，而同一个工作区可能同时被
+                // 另一个 DSH 进程写归属 —— 各自「整体覆盖」会把对方的记录抹掉。真机实测：归属里缺了对方
+                // 那次编辑，导致回退时识别不到「别人改过这个文件」，进而把对方的改动静默覆盖掉。
+                // 同键取 `at` 较新者：时间戳是这里唯一可信的先后判据。
+                try {
+                    const existing = JSON.parse(await fs.readFile(this.file, 'utf8'));
+                    if (existing.version === 1 && existing.entries !== null && typeof existing.entries === 'object' && !Array.isArray(existing.entries)) {
+                        for (const [key, value] of Object.entries(existing.entries)) {
+                            const fact = readFact(value);
+                            if (fact === null)
+                                continue;
+                            const mine = entriesSnapshot[key];
+                            if (mine === undefined || fact.at > mine.at)
+                                entriesSnapshot[key] = fact;
+                        }
+                    }
+                }
+                catch { /* 读不到就当没有别人的记录：只写自己这份（绝不因为读失败而放弃落盘） */ }
+                const payload = { version: 1, entries: entriesSnapshot };
+                const tmp = this.file + '.tmp';
+                await fs.writeFile(tmp, JSON.stringify(payload), 'utf8');
+                await fs.rename(tmp, this.file);
+            }
+            catch (error) {
+                this.warn('rollback attribution write failed: ' + this.file + ' ' + String(error.code ?? error));
+            }
+            finally {
+                this.writing = null;
+            }
+        })();
+        return this.writing;
+    }
+}
+//# sourceMappingURL=rollback-attribution.js.map

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

@@ -0,0 +1,22 @@
+/** 合并结论（`ok:false` 时调用方必须**零写入**） */
+export type ThreeWayMergeReason = 'clean' | 'conflict' | 'degraded' | 'binary';
+export interface ThreeWayMergeResult {
+    /** true = 结果可直接写入；false = 必须放弃写入并如实报告 */
+    ok: boolean;
+    /** 合并结果（`ok:false` 时是 theirs 原文 —— 方便调用方做「保持现状」的比较，绝不写入） */
+    text: string;
+    reason: ThreeWayMergeReason;
+    /** 冲突块数（>0 ⇒ ok=false） */
+    conflicts: number;
+    /** 本次合并**撤销**的行数（base 有、ours 没有）与**保留**的对方新增行数（诊断用） */
+    revertedLines: number;
+    /** 依赖风险提示（启发式；空数组 = 未发现明显风险，**不代表安全**） */
+    risks: string[];
+}
+/**
+ * 三方合并（纯函数、无 I/O）。
+ *
+ * 语义：结果是 `ours` 上再应用 `(theirs - base)` —— 撤销「我们从 base 改到 ours 的那部分」，
+ * 同时保留「别人从 base 改到 theirs 的那部分」。
+ */
+export declare function mergeThreeWay(ours: string, base: string, theirs: string): ThreeWayMergeResult;