dsh-config-manager 0.1.76 → 0.1.78

package/src/core/messages.ts

@@ -191,6 +191,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}）：已解析的照常使用',
@@ -264,6 +265,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}（其余配置已导入；可修复依赖后在设置页重试或手动安装）',
@@ -339,6 +349,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',
@@ -640,6 +651,7 @@ export const en: Record<keyof typeof zh, string> = {
   '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',
@@ -713,6 +725,15 @@ export const en: Record<keyof typeof zh, string> = {
   '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)',
@@ -788,6 +809,7 @@ export const en: Record<keyof typeof zh, string> = {
   '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/src/core/plugin-cli.fs.test.ts

@@ -13,8 +13,8 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import {
-  listInstalledPlugins, readInstalled, readInstalledVersion, reconcileBundles,
-  resolveProfileDir,
+  isBundlesOnlyEntry, listInstalledPlugins, mergeBundleDeclaration, readInstalled, readInstalledVersion,
+  reconcileBundles, resolveProfileDir,
 } from './plugin-cli.ts';
 import { enterRescueMode } from './boot-rescue.ts';
 import type { PluginInfo } from './types.ts';
@@ -146,7 +146,9 @@ test('issue #28: 仅由 dsh.profile.bundles 声明的层必须出现在已装清
     assert.equal(bundleOnly?.version, '0.3.1', '版本取 node_modules 落盘版本');
     assert.equal(bundleOnly?.isBundle, true);
     assert.deepEqual(bundleOnly?.inBundles, ['@linxin666/dsh-web-ui-all']);
-    assert.equal(bundleOnly?.spec, undefined, '无依赖声明 → 无 spec（导入按裸包名装最新版）');
+    assert.equal(bundleOnly?.spec, undefined, '无依赖声明 → 无 spec');
+    // issue #95：本机**有**落盘副本的手工层不是「host 自带层」，标记不得出现（保持安装通道行为）
+    assert.equal(bundleOnly?.bundlesOnly, undefined, '本机有副本 → 不标记 bundlesOnly');
     // 从未落盘的 bundles 条目：仍列出（它确实是启动时会挂载的层），版本空串不抛
     assert.equal(list.find((p) => p.name === 'stale-pkg')?.version, '');
     // in-box bundle 依然不出现（无论来自 dependencies 还是 bundles）
@@ -234,3 +236,63 @@ test('reconcileBundles：救援模式下必须停手（不得把收窄掉的用
     cleanup();
   }
 });
+
+test('issue #95: 只在 bundles 里声明、且本机没有落盘副本的层必须标记 bundlesOnly', () => {
+  const { homeDir, profileDir, cleanup } = makeTempProfile(
+    { 'pkg-a': '1.0.0' },
+    ['@deepseek-ai/dsh-experimental-session-search', '@linxin666/dsh-web-ui-all'],
+  );
+  try {
+    writeInstalledPkg(profileDir, 'pkg-a', '1.0.0');
+    writeInstalledPkg(profileDir, '@linxin666/dsh-web-ui-all', '0.3.1', 'patch.yml');
+
+    const list = listInstalledPlugins(homeDir, 'web');
+    const hostLayer = list.find((p) => p.name === '@deepseek-ai/dsh-experimental-session-search');
+    assert.equal(hostLayer?.version, '', '本 profile 没装它 → 版本空串');
+    assert.equal(hostLayer?.bundlesOnly, true, '无依赖 + 无落盘副本 ⇒ 只能由 DSH 自己提供');
+    assert.equal(list.find((p) => p.name === '@linxin666/dsh-web-ui-all')?.bundlesOnly, undefined, '有落盘副本 → 保持旧行为');
+    assert.equal(list.find((p) => p.name === 'pkg-a')?.bundlesOnly, undefined, '普通依赖不得带标记');
+  } finally {
+    cleanup();
+  }
+});
+
+test('issue #95: isBundlesOnlyEntry —— 显式字段优先，旧备份按形状推断', () => {
+  assert.equal(isBundlesOnlyEntry({ bundlesOnly: true, spec: '^1.0.0', version: '1.0.0' }), true, '显式字段优先');
+  assert.equal(isBundlesOnlyEntry({ bundlesOnly: false, version: '' }), false, '显式 false 不得被形状覆盖');
+  assert.equal(isBundlesOnlyEntry({ version: '' }), true, '旧备份：无 spec 且无已装版本');
+  assert.equal(isBundlesOnlyEntry({ spec: '^1.0.0', version: '' }), false, '有依赖声明 → 普通依赖（哪怕本机没装全）');
+  assert.equal(isBundlesOnlyEntry({ version: '0.3.1' }), false, '本机有落盘副本 → 手工层');
+});
+
+test('issue #95: mergeBundleDeclaration 只追加一个名字；形状不符一律拒绝', () => {
+  const base = `${JSON.stringify({ name: 'dsh-profile-web', dependencies: { a: '1.0.0' }, dsh: { profile: { bundles: ['x'] } } }, null, 2)}\n`;
+  const merged = mergeBundleDeclaration(base, 'y');
+  assert.equal(merged?.changed, true);
+  const parsed = JSON.parse(merged!.text) as {
+    dependencies: Record<string, string>;
+    dsh: { profile: { bundles: string[] } };
+  };
+  assert.deepEqual(parsed.dsh.profile.bundles, ['x', 'y'], '名字追加在尾部');
+  assert.deepEqual(parsed.dependencies, { a: '1.0.0' }, '其余字段逐字保留');
+  assert.equal(mergeBundleDeclaration(merged!.text, 'y')?.changed, false, '幂等：重复声明不空写');
+
+  assert.equal(mergeBundleDeclaration('{', 'y'), null, 'JSON 坏 → null（绝不重建清单）');
+  assert.equal(mergeBundleDeclaration('[]', 'y'), null, '顶层非对象 → null');
+  assert.equal(mergeBundleDeclaration(JSON.stringify({ name: 'p' }), 'y'), null, '缺 dsh.profile → null');
+  assert.equal(
+    mergeBundleDeclaration(JSON.stringify({ dsh: { profile: { bundles: 'x' } } }), 'y'),
+    null,
+    'bundles 非数组 → null',
+  );
+  assert.equal(
+    mergeBundleDeclaration(JSON.stringify({ dsh: { profile: { bundles: ['x', 1] } } }), 'y'),
+    null,
+    'bundles 含非字符串 → null',
+  );
+  assert.equal(
+    mergeBundleDeclaration(JSON.stringify({ dsh: { profile: {} } }), 'y'),
+    null,
+    'bundles 字段缺省 → null（非空 bundles 会替换默认插件栈，绝不凭空造）',
+  );
+});

package/src/core/plugin-cli.ts

@@ -340,19 +340,72 @@ export function listInstalledPlugins(homeDir: string, profile: string): PluginIn
   for (const name of Array.isArray(declaredBundles) ? declaredBundles : []) {
     if (INBOX_BUNDLES.has(name)) 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: { bundlesOnly?: unknown; spec?: unknown; version?: unknown }): boolean {
+  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: string, name: string): { text: string; changed: boolean } | null {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(pkgText)
+  } catch {
+    return null
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  const pkg = parsed as Record<string, unknown>
+  const dsh = pkg.dsh
+  if (dsh === null || typeof dsh !== 'object' || Array.isArray(dsh)) return null
+  const profile = (dsh as Record<string, unknown>).profile
+  if (profile === null || typeof profile !== 'object' || Array.isArray(profile)) return null
+  const raw = (profile as Record<string, unknown>).bundles
+  if (raw === undefined) return null
+  if (!Array.isArray(raw) || raw.some((entry) => typeof entry !== 'string')) return null
+  const bundles = raw as string[]
+  if (bundles.includes(name)) return { text: pkgText, changed: false }
+  bundles.push(name)
+  ;(profile as Record<string, unknown>).bundles = bundles
+  return { text: `${JSON.stringify(pkg, null, 2)}\n`, changed: true }
+}
+
 /* --------------------------------------------------------------- CLI 通道 */
 
 /** 15 分钟默认上限（慢网络 + git 安装），可用环境变量覆盖（CI/测试）。 */

package/src/core/rollback-attribution.test.ts

@@ -0,0 +1,120 @@
+/**
+ * 写入归属台账（2026-10-17 定案 B）的单元测试。
+ *
+ * 三条不变量逐条钉住：① 只有写类工具才算写入（读工具里的 path 不算）；
+ * ② 解析不出来 = **未判定**（空数组，不抛）；③ 落盘失败只 warn，绝不影响调用方。
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import {
+  ROLLBACK_ATTRIBUTION_MAX_ENTRIES,
+  RollbackWriteAttribution,
+  toolCallWritePaths,
+} from './rollback-attribution.ts'
+
+test('B-1 只有写类工具才算写入：读工具的 path 绝不进归属', () => {
+  // 白名单之外一律空数组 —— 否则 read/grep 会把「读」记成「写」，回退就会误跳过文件
+  assert.deepEqual(toolCallWritePaths('read', '{"file_path":"a.txt"}'), [])
+  assert.deepEqual(toolCallWritePaths('grep', '{"path":"a.txt"}'), [])
+  assert.deepEqual(toolCallWritePaths('ops_inspect_local_file', '{"path":"a.txt"}'), [])
+  assert.deepEqual(toolCallWritePaths('write', '{"file_path":"a.txt"}'), ['a.txt'])
+  assert.deepEqual(toolCallWritePaths('edit', { path: 'b.txt' }), ['b.txt'])
+  assert.deepEqual(toolCallWritePaths('ops_replace', JSON.stringify({ path: 'c.txt', find: 'x' })), ['c.txt'])
+})
+
+test('B-2 参数字符串解不出来 = 未判定（空数组，绝不抛）', () => {
+  assert.deepEqual(toolCallWritePaths('write', '{not json'), [])
+  assert.deepEqual(toolCallWritePaths('write', null), [])
+  assert.deepEqual(toolCallWritePaths('write', '[1,2]'), [])
+  assert.deepEqual(toolCallWritePaths('write', '{"file_path":""}'), [])
+  assert.deepEqual(toolCallWritePaths(undefined, '{"file_path":"a.txt"}'), [])
+})
+
+test('B-3 同一调用里两个路径键指向同一路径 ⇒ 去重', () => {
+  assert.deepEqual(toolCallWritePaths('write', '{"file_path":"x.txt","path":"x.txt"}'), ['x.txt'])
+})
+
+test('B-4 noteToolCall 记录归属：写类工具进表，非写类工具返回 0 且不进表', () => {
+  const attr = new RollbackWriteAttribution({ file: path.join(os.tmpdir(), 'attr-never-written.json'), flushDelayMs: 0 })
+  assert.equal(attr.noteToolCall('session-a', { name: 'read', arguments: '{"file_path":"r.txt"}' }), 0)
+  assert.equal(attr.writerOf(path.resolve('r.txt')), undefined)
+  assert.equal(attr.noteToolCall('session-a', { name: 'write', callId: 'call-1', turn: 3, arguments: '{"file_path":"w.txt"}' }), 1)
+  const fact = attr.writerOf(path.resolve('w.txt'))
+  assert.equal(fact?.sessionId, 'session-a')
+  assert.equal(fact?.callId, 'call-1')
+  assert.equal(fact?.tool, 'write')
+  assert.equal(fact?.turn, 3)
+  // 后写者覆盖前写者（台账只关心「最后一次是谁写的」）
+  attr.noteToolCall('session-b', { name: 'edit', callId: 'call-2', arguments: '{"path":"w.txt"}' })
+  assert.equal(attr.writerOf(path.resolve('w.txt'))?.sessionId, 'session-b')
+})
+
+test('B-5 读盘：形状不符当空表；本进程新记录优先于磁盘旧值', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'attr-'))
+  const file = path.join(dir, 'attribution.json')
+  try {
+    await fs.writeFile(file, JSON.stringify({ version: 2, entries: { [path.resolve('old.txt')]: { sessionId: 'x', at: 1 } } }), 'utf8')
+    const wrong = new RollbackWriteAttribution({ file, flushDelayMs: 0 })
+    await wrong.load()
+    assert.equal(wrong.size, 0, '未知版本必须当空表，绝不猜字段含义')
+
+    await fs.writeFile(file, JSON.stringify({
+      version: 1,
+      entries: { [path.resolve('old.txt')]: { sessionId: 'disk', at: 5, tool: 'write', callId: 'c', turn: null } },
+    }), 'utf8')
+    const attr = new RollbackWriteAttribution({ file, flushDelayMs: 0 })
+    // 读盘之前先记一条同路径的新事实 ⇒ 读盘**不得**把它覆盖回磁盘旧值
+    attr.noteToolCall('session-new', { name: 'write', arguments: '{"file_path":"' + path.resolve('old.txt').replace(/\\/g, '\\\\') + '"}' })
+    await attr.load()
+    assert.equal(attr.writerOf(path.resolve('old.txt'))?.sessionId, 'session-new')
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('B-6 落盘 + 回读：flush 原子写，写完能读回来', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'attr-'))
+  const file = path.join(dir, 'attribution.json')
+  try {
+    const attr = new RollbackWriteAttribution({ file, flushDelayMs: 0 })
+    attr.noteToolCall('session-x', { name: 'write', callId: 'c9', arguments: '{"file_path":"' + path.join(dir, 'z.txt').replace(/\\/g, '\\\\') + '"}' })
+    await attr.flush()
+    const reread = new RollbackWriteAttribution({ file })
+    await reread.load()
+    assert.equal(reread.writerOf(path.join(dir, 'z.txt'))?.callId, 'c9')
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('B-7 超过上限淘汰最旧（台账不得无界增长）', () => {
+  const attr = new RollbackWriteAttribution({ file: path.join(os.tmpdir(), 'attr-unused.json'), flushDelayMs: 0, maxEntries: 2 })
+  for (const name of ['a', 'b', 'c']) {
+    attr.noteToolCall('s', { name: 'write', arguments: '{"file_path":"' + name + '.txt"}' })
+  }
+  assert.equal(attr.size, 2)
+  assert.equal(attr.writerOf(path.resolve('a.txt')), undefined, '最旧的被淘汰')
+  assert.equal(attr.writerOf(path.resolve('c.txt'))?.sessionId, 's')
+})
+
+test('B-8 落盘失败只 warn，不上抛（台账坏掉绝不能拖垮留点/回退）', async () => {
+  const warnings: string[] = []
+  // 目录名当成文件路径 ⇒ mkdir/写必然失败
+  const attr = new RollbackWriteAttribution({ file: path.join(os.tmpdir(), 'attr-dir-as-file', 'attribution.json'), flushDelayMs: 0, warn: (line) => warnings.push(line) })
+  await fs.mkdir(path.join(os.tmpdir(), 'attr-dir-as-file', 'attribution.json'), { recursive: true })
+  try {
+    attr.noteToolCall('s', { name: 'write', arguments: '{"file_path":"q.txt"}' })
+    await attr.flush()
+    assert.equal(warnings.length > 0, true, '写不进去必须留痕')
+  } finally {
+    await fs.rm(path.join(os.tmpdir(), 'attr-dir-as-file'), { recursive: true, force: true })
+  }
+})
+
+test('B-9 条目上限常量是有限值（0/Infinity 会让台账无界）', () => {
+  assert.equal(Number.isFinite(ROLLBACK_ATTRIBUTION_MAX_ENTRIES) && ROLLBACK_ATTRIBUTION_MAX_ENTRIES > 0, true)
+})

package/src/core/rollback-attribution.ts

@@ -0,0 +1,267 @@
+/**
+ * 工具调用的**写入归属台账** —— 「这个路径最后一次是哪个会话的哪次工具调用写的」。
+ *
+ * 为什么需要（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: readonly string[] = [
+  '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: readonly string[] = ['file_path', 'path', 'filePath']
+
+/** 路径比较键（与 `rollback-point.ts` 的 pathKey 同一口径：resolve + win32 折叠大小写） */
+function attributionPathKey(value: string): string {
+  const resolved = path.resolve(value)
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved
+}
+
+/** 一条写入归属：谁（会话）在什么时候用哪个工具写了这个路径 */
+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 function toolCallWritePaths(name: unknown, argumentsValue: unknown): string[] {
+  if (typeof name !== 'string' || !ROLLBACK_WRITE_TOOL_NAMES.includes(name)) return []
+  let parsed: unknown = 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 as Record<string, unknown>
+  const out: string[] = []
+  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)]
+}
+
+/** 台账载荷形状（形状不符一律当空表：读不出 ≠ 归属为某会话） */
+interface AttributionFileV1 {
+  version: 1
+  entries: Record<string, RollbackWriteFact>
+}
+
+function readFact(value: unknown): RollbackWriteFact | null {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return null
+  const record = value as Record<string, unknown>
+  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,
+  }
+}
+
+export interface RollbackWriteAttributionOptions {
+  /** 台账文件绝对路径 */
+  file: string
+  now?: () => number
+  maxEntries?: number
+  /** 落盘延迟（毫秒）；<= 0 表示不自动落盘（测试用） */
+  flushDelayMs?: number
+  warn?: (line: string) => void
+}
+
+/**
+ * 内存台账 + best-effort 落盘。
+ *
+ * 落盘的作用只有一个：**进程重启后**打开旧会话回退时，归属还在。
+ * 因此写入是延迟合并的（一次 tool/call 一行，立即落盘会把 I/O 打成筛子）。
+ */
+export class RollbackWriteAttribution implements RollbackWriteAttributionPort, RollbackWriteRecorder {
+  private readonly entries = new Map<string, RollbackWriteFact>()
+  private readonly file: string
+  private readonly now: () => number
+  private readonly maxEntries: number
+  private readonly flushDelayMs: number
+  private readonly warn: (line: string) => void
+  private loadPromise: Promise<void> | null = null
+  private flushTimer: ReturnType<typeof setTimeout> | null = null
+  private writing: Promise<void> | null = null
+
+  constructor(options: RollbackWriteAttributionOptions) {
+    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(): number {
+    return this.entries.size
+  }
+
+  /** 惰性读盘（幂等；读失败 = 空表，只 warn） */
+  async load(): Promise<void> {
+    if (this.loadPromise === null) this.loadPromise = this.read()
+    return this.loadPromise
+  }
+
+  private async read(): Promise<void> {
+    try {
+      const text = await fs.readFile(this.file, 'utf8')
+      const parsed = JSON.parse(text) as { version?: unknown; entries?: unknown }
+      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 as Record<string, unknown>)) {
+        const fact = readFact(value)
+        // 读盘期间可能已经有本进程新记的条目 ⇒ **新记录优先**（磁盘只是旧快照）
+        if (fact !== null && !this.entries.has(key)) this.entries.set(key, fact)
+      }
+    } catch (error) {
+      const code = (error as { code?: unknown }).code
+      // ENOENT = 还没写过台账（正常）；其它错误如实留痕但不抛
+      if (code !== 'ENOENT') this.warn('rollback attribution unreadable: ' + this.file + ' ' + String(code ?? error))
+    }
+  }
+
+  /** 记一次 tool/call（返回记录到的路径条数；0 = 不是写类工具或解析不出路径 = 未判定） */
+  noteToolCall(sessionId: string, data: unknown): number {
+    if (typeof sessionId !== 'string' || sessionId === '') return 0
+    if (data === null || typeof data !== 'object') return 0
+    const record = data as Record<string, unknown>
+    const paths = toolCallWritePaths(record.name, record.arguments)
+    if (paths.length === 0) return 0
+    const fact: RollbackWriteFact = {
+      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 升序删到上限内） */
+  private evictOldest(): void {
+    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: string): RollbackWriteFact | undefined {
+    return this.entries.get(attributionPathKey(target))
+  }
+
+  /** 延迟落盘（多次调用只落一次） */
+  scheduleFlush(): void {
+    if (this.flushDelayMs <= 0 || this.flushTimer !== null) return
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null
+      void this.flush()
+    }, this.flushDelayMs)
+    // 台账不该阻止进程退出
+    ;(this.flushTimer as { unref?: () => void }).unref?.()
+  }
+
+  /** 立刻落盘（原子：同目录临时文件 + rename；失败只 warn，绝不上抛） */
+  async flush(): Promise<void> {
+    if (this.writing !== null) return this.writing
+    this.writing = (async () => {
+      try {
+        await fs.mkdir(path.dirname(this.file), { recursive: true })
+        const entriesSnapshot: Record<string, RollbackWriteFact> = Object.fromEntries(this.entries)
+        // **写前合并**（2026-10-17 修）：本进程内存里只有自己见过的写入，而同一个工作区可能同时被
+        // 另一个 DSH 进程写归属 —— 各自「整体覆盖」会把对方的记录抹掉。真机实测：归属里缺了对方
+        // 那次编辑，导致回退时识别不到「别人改过这个文件」，进而把对方的改动静默覆盖掉。
+        // 同键取 `at` 较新者：时间戳是这里唯一可信的先后判据。
+        try {
+          const existing = JSON.parse(await fs.readFile(this.file, 'utf8')) as { version?: unknown; entries?: unknown }
+          if (existing.version === 1 && existing.entries !== null && typeof existing.entries === 'object' && !Array.isArray(existing.entries)) {
+            for (const [key, value] of Object.entries(existing.entries as Record<string, unknown>)) {
+              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: AttributionFileV1 = { 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 as { code?: unknown }).code ?? error))
+      } finally {
+        this.writing = null
+      }
+    })()
+    return this.writing
+  }
+}