dsh-workspace-mover 2.0.3

package/test/e2e-sandbox.test.mjs

@@ -0,0 +1,1804 @@
+// 端到端沙箱测试：假注册表 + 假持久化 + 真实文件系统，完整走 mover.move 流程。
+// 覆盖：status / 正常迁移 / 同工作区拒绝 / 未知目标 / attach 失败自动回滚。
+// 备份目录通过 DSH_HOME 重定向到临时区，不污染真实环境。
+import { test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync, readdirSync, renameSync, realpathSync, utimesSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { zstdCompressSync, constants } from 'node:zlib';
+
+import { apply, scanFrames, readHeader, artifactPath, openInFileManager, moveDir, stashBackup, verifyRelocatedArtifact, deleteSessionToTrash, moveSession, SCAN_MAX_ITEMS } from '../lib/index.js';
+
+const OPTS = { params: { [constants.ZSTD_c_checksumFlag]: 1 } };
+const DEAD = 'E:\\wsm-dead-path'; // 刻意不存在的路径（孤儿分类用）
+let A; // 每次用例指向真实临时目录（健康会话要求 cwd 在磁盘上存在）
+let B;
+let root;
+let ctx, entityA, entityB, sharedIndex, workspaceEvents;
+
+/** 测试根目录：优先 WSM_TEST_ROOT（受限环境下 Temp 可能禁止目录重命名），否则退回系统 Temp。 */
+function makeRoot() {
+  const candidates = [
+    process.env.WSM_TEST_ROOT ? join(process.env.WSM_TEST_ROOT, 'wsm-e2e-') : null,
+    join(tmpdir(), 'wsm-e2e-')
+  ].filter(Boolean);
+  let lastErr;
+  for (const base of candidates) {
+    try { return mkdtempSync(base); } catch (err) { lastErr = err; }
+  }
+  throw lastErr;
+}
+
+function makeArtifact(header) {
+  const head = zstdCompressSync(Buffer.from(JSON.stringify(header) + '\n', 'utf8'), OPTS);
+  const ev = zstdCompressSync(Buffer.from(JSON.stringify({ seq: 1 }) + '\n', 'utf8'), OPTS);
+  return Buffer.concat([head, ev]);
+}
+
+/**
+ * 模拟 dsh 工作区实体：record 快照 + 记账，attach 对已记账 id 跳过校验（官方语义）。
+ * mutate 复刻官方统一写入通道的两个关键行为：调用 fn 生成新快照后，
+ * 按「索引中的会话 cwd === 新 path」剪枝成员（对应 WorkspaceEntity.mutate）；
+ * status 对应官方 missing-dir 判定。
+ */
+function makeEntity(id, path, hostRef) {
+  const record = { path, title: id, sessionIds: [], createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() };
+  return {
+    id,
+    // 官方语义：path / title 都是读取 record 的实时 getter（mutate 换路径/标题后立即生效）
+    get path() { return record.path; },
+    get title() { return record.title; },
+    get record() { return record; },
+    get sessionIds() { return [...record.sessionIds].filter((sid) => hostRef.sessionPath(String(sid)) === record.path); },
+    attached: [],
+    detached: [],
+    failAttach: false,
+    async status() { return existsSync(record.path) ? 'ok' : 'missing-dir'; },
+    async mutate(fn) {
+      // 官方语义：整体换新快照（本插件借此同步改写 path/title），随后按索引剪枝成员
+      const changed = fn(record);
+      const pruned = changed.sessionIds.filter((sid) => hostRef.sessionPath(String(sid)) === changed.path);
+      Object.assign(record, changed, {
+        sessionIds: pruned,
+        updatedAt: new Date().toISOString()
+      });
+    },
+    async attachSession(sid) {
+      if (this.failAttach) throw new Error('simulated attach failure');
+      // 官方语义：已记账时 attach 是 no-op，mutate 不发 domain/changed。
+      if (record.sessionIds.includes(sid)) return;
+      // 官方语义：未记账 id 需通过「头部 cwd 规范化后 === path」校验，
+      // 并经 rememberSessionPath 回填三张索引后才挂账
+      const header = readHeader(readFileSync(findArtifact(sid)));
+      let canonical;
+      try { canonical = realpathSync(header.cwd); } catch {
+        throw new Error(`cwd does not resolve: '${header.cwd}'`);
+      }
+      if (canonical.toLowerCase() !== record.path.toLowerCase()) throw new Error(`cwd resolves elsewhere: '${header.cwd}'`);
+      sharedIndex.headers.set(String(sid), header);
+      sharedIndex.sessionPaths.set(String(sid), canonical);
+      sharedIndex.invalidSessionPaths.delete(String(sid));
+      this.attached.push(sid);
+      record.sessionIds.unshift(sid);
+      hostRef.onWorkspaceChanged?.(id, record);
+    },
+    async detachSession(sid) {
+      if (!record.sessionIds.includes(sid)) return;
+      this.detached.push(sid);
+      record.sessionIds = record.sessionIds.filter((x) => x !== sid);
+      hostRef.onWorkspaceChanged?.(id, record);
+    }
+  };
+}
+
+/** 按存储布局约定在磁盘上找某会话的档案位置。 */
+function findArtifact(sessionId) {
+  for (const proj of readdirSync(root)) {
+    if (!(proj.startsWith('--') && proj.endsWith('--'))) continue;
+    const dir = join(root, proj, sessionId);
+    if (!existsSync(dir)) continue;
+    const names = readdirSync(dir)
+      .filter((name) => name === 'session.jsonl.zstd' || /^session\.v[1-9][0-9]*\.jsonl\.zstd$/.test(name))
+      .sort((a, b) => {
+        const va = a === 'session.jsonl.zstd' ? 0 : Number(/^session\.v([0-9]+)/.exec(a)[1]);
+        const vb = b === 'session.jsonl.zstd' ? 0 : Number(/^session\.v([0-9]+)/.exec(b)[1]);
+        return vb - va;
+      });
+    if (names.length) return join(dir, names[0]);
+  }
+  throw new Error(`artifact for ${sessionId} not found`);
+}
+
+beforeEach(() => {
+  // 生产环境中 cwd 一律是 realpath 规范化后的 canonical 路径（官方注册表
+  // 的唯一性约定）；macOS 的 Temp 位于 /var → /private/var 符号链接下，
+  // 夹具若用未规范化路径会与 canonical 比对失配，因此创建后立即归一。
+  root = realpathSync(makeRoot());
+  A = join(root, 'proj-alpha');
+  B = join(root, 'proj-beta');
+  mkdirSync(A, { recursive: true });
+  mkdirSync(B, { recursive: true });
+  process.env.DSH_HOME = root; // 备份重定向
+
+  // 会话 session-aaa 归属 A（真实 zstd 帧结构）
+  const srcArtifact = artifactPath(root, A, 'session-aaa');
+  mkdirSync(dirname(srcArtifact), { recursive: true });
+  mkdirSync(dirname(artifactPath(root, B, 'placeholder')), { recursive: true });
+  writeFileSync(srcArtifact, makeArtifact({ type: 'session', id: 'session-aaa', cwd: A, title: 'Alpha discussion' }));
+
+  // 三张内存索引先于实体创建（实体 mutate 的成员剪枝按此判定）；
+  // 官方实体持有的是 { sessionPath(id) } 形态的宿主引用
+  sharedIndex = { headers: new Map(), sessionPaths: new Map(), invalidSessionPaths: new Map() };
+  workspaceEvents = [];
+  const hostRef = {
+    ...sharedIndex,
+    sessionPath: (id) => sharedIndex.sessionPaths.get(String(id)),
+    onWorkspaceChanged: (workspaceId, record) => workspaceEvents.push({
+      workspaceId,
+      sessionIds: [...record.sessionIds]
+    })
+  };
+
+  entityA = makeEntity('wid-a', A, hostRef);
+  entityB = makeEntity('wid-b', B, hostRef);
+  const registry = {
+    ...sharedIndex,
+    entities: new Map([['wid-a', entityA], ['wid-b', entityB]]),
+    get(id) { return this.entities.get(id); },
+    list() { return [...this.entities.values()]; }
+  };
+  const persistence = {
+    root,
+    async list() {
+      // 动态扫描 root（与真实后端一致）：遍历 projectKey 目录读头部
+      const out = [];
+      if (!existsSync(root)) return out;
+      for (const proj of readdirSync(root)) {
+        if (!(proj.startsWith('--') && proj.endsWith('--'))) continue;
+        const projPath = join(root, proj);
+        for (const idDir of readdirSync(projPath)) {
+          const dir = join(projPath, idDir);
+          const names = existsSync(dir) ? readdirSync(dir).filter((name) => name === 'session.jsonl.zstd' || /^session\.v[1-9][0-9]*\.jsonl\.zstd$/.test(name)) : [];
+          if (!names.length) continue;
+          names.sort((a, b) => {
+            const va = a === 'session.jsonl.zstd' ? 0 : Number(/^session\.v([0-9]+)/.exec(a)[1]);
+            const vb = b === 'session.jsonl.zstd' ? 0 : Number(/^session\.v([0-9]+)/.exec(b)[1]);
+            return vb - va;
+          });
+          const f = join(dir, names[0]);
+          try { out.push(readHeader(readFileSync(f))); } catch { /* skip */ }
+        }
+      }
+      return out;
+    }
+  };
+  let rpcHandler = null;
+  ctx = {
+    workspaceRegistry: registry,
+    sessionPersistence: persistence,
+    logger: { info() {}, warn() {} },
+    get: () => undefined,
+    connection: { rpc: { handle(_ch, h) { rpcHandler = h; return () => {}; } } }
+  };
+  ctx.__rpc = () => rpcHandler;
+});
+
+afterEach(() => {
+  delete process.env.DSH_HOME;
+  rmSync(root, { recursive: true, force: true });
+});
+
+async function call(endpoint, payload) {
+  return await ctx.__rpc()(endpoint, payload ?? {});
+}
+
+test('mover.status 就绪', async () => {
+  apply(ctx);
+  const res = await call('mover.status');
+  assert.equal(res.ok, true);
+  assert.equal(res.value.ready, true);
+});
+
+test('正常迁移：文件物理搬移 + 头部改写 + 双向记账 + 有备份', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const before = readFileSync(artifactPath(root, A, 'session-aaa'));
+
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.moved, true);
+  assert.equal(res.value.title, 'Alpha discussion');
+  assert.equal(res.value.cacheInvalidated, true);
+
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')), 'source artifact gone');
+  const movedBuf = readFileSync(artifactPath(root, B, 'session-aaa'));
+  assert.equal(readHeader(movedBuf).cwd, B);
+
+  // 其余帧字节保留
+  const fo = scanFrames(before), fn = scanFrames(movedBuf);
+  assert.equal(fn.length, fo.length);
+  for (let i = 1; i < fo.length; i++) {
+    assert.ok(before.subarray(fo[i][0], fo[i][1]).equals(movedBuf.subarray(fn[i][0], fn[i][1])), `frame ${i} preserved`);
+  }
+
+  // 记账
+  assert.deepEqual(entityB.attached, ['session-aaa']);
+  assert.deepEqual(entityA.detached, ['session-aaa']);
+  assert.deepEqual(entityA.sessionIds, []);
+
+  // 备份落在 $DSH_HOME/workspace-mover/backups
+  const backups = join(root, 'workspace-mover', 'backups');
+  assert.ok(existsSync(backups));
+  assert.ok(readdirSync(backups).some((f) => f.startsWith('session-aaa')));
+});
+
+
+test('批量迁移常驻会话通过官方 attach 事件立即更新目标工作区', async () => {
+  apply(ctx);
+  const ids = ['session-aaa', 'session-bbb'];
+  const secondArtifact = artifactPath(root, A, 'session-bbb');
+  mkdirSync(dirname(secondArtifact), { recursive: true });
+  writeFileSync(secondArtifact, makeArtifact({ type: 'session', id: 'session-bbb', cwd: A, title: 'Beta discussion' }));
+  entityA.record.sessionIds.push(...ids);
+  for (const id of ids) {
+    sharedIndex.headers.set(id, { id, cwd: A });
+    sharedIndex.sessionPaths.set(id, A);
+  }
+  const live = new Map(ids.map((id) => [id, {
+    header: Object.freeze({ id, cwd: A })
+  }]));
+  ctx.get = (key) => {
+    if (key === 'sessions') return { get: (id) => live.get(String(id)) };
+    if (key === 'agents') return { get: () => ({ status: 'idle' }) };
+    return undefined;
+  };
+
+  const res = await call('mover.moveMany', {
+    sessions: ids.map((sessionId) => ({ sessionId })),
+    targetWorkspaceId: 'wid-b'
+  });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.movedCount, 2);
+  assert.equal(entityB.record.sessionIds.length, 2);
+  const targetEvents = workspaceEvents.filter((event) => event.workspaceId === 'wid-b');
+  assert.equal(targetEvents.length, 2, 'each official attach emits a target workspace change');
+  assert.deepEqual(new Set(targetEvents.at(-1).sessionIds), new Set(ids));
+});
+
+test('DSH 0.1.5 persistence.list 快照形状可迁移', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const originalList = ctx.sessionPersistence.list;
+  ctx.sessionPersistence.list = async () => (await originalList.call(ctx.sessionPersistence)).map((header) => ({
+    header,
+    revision: 'test-revision',
+    sizeBytes: 0
+  }));
+
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.moved, true);
+  assert.equal(readHeader(readFileSync(artifactPath(root, B, 'session-aaa'))).cwd, B);
+});
+
+test('移动历史：可查询并一键撤回到原工作区', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+
+  const moved = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(moved.ok, true, JSON.stringify(moved));
+  assert.ok(moved.value.historyId);
+
+  const listed = await call('mover.history');
+  assert.equal(listed.ok, true);
+  assert.equal(listed.value.items[0].id, moved.value.historyId);
+  assert.equal(listed.value.items[0].sourceWorkspaceId, 'wid-a');
+  assert.equal(listed.value.items[0].targetWorkspaceId, 'wid-b');
+  assert.equal(listed.value.items[0].title, 'Alpha discussion');
+
+  const undone = await call('mover.undo', { historyId: moved.value.historyId });
+  assert.equal(undone.ok, true, JSON.stringify(undone));
+  assert.equal(undone.value.undone, true);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')));
+  assert.ok(!existsSync(artifactPath(root, B, 'session-aaa')));
+  assert.deepEqual(entityA.sessionIds, ['session-aaa']);
+  assert.deepEqual(entityB.sessionIds, []);
+
+  const after = await call('mover.history');
+  assert.deepEqual(after.value.items, []);
+});
+
+test('同工作区移动被拒绝', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa'); // 已记账：真·重复移动
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-a' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /already belongs/);
+});
+
+test('磁盘已属目标但未记账时自动补账（自愈）', async () => {
+  apply(ctx);
+  // cwd=A、无人记账的会话拖到 wid-a（它自己的真实归属路径）
+  const dir = artifactPath(root, A, 'session-selfheal');
+  mkdirSync(dirname(dir), { recursive: true });
+  writeFileSync(dir, makeArtifact({ type: 'session', id: 'session-selfheal', cwd: A }));
+
+  const res = await call('mover.move', { sessionId: 'session-selfheal', targetWorkspaceId: 'wid-a' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.attached, true);
+  assert.equal(res.value.moved, false);
+  assert.ok(entityA.attached.includes('session-selfheal'), 'accounting repaired');
+  assert.ok(existsSync(dir), 'file untouched');
+});
+
+test('未知目标工作区被拒绝', async () => {
+  apply(ctx);
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'nope' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /unknown workspace/i);
+});
+
+test('attach 失败 → 自动回滚到源目录并重新挂账', async () => {
+  apply(ctx);
+  entityB.failAttach = true;
+  entityA.record.sessionIds.push('session-aaa');
+  const originalBytes = readFileSync(artifactPath(root, A, 'session-aaa'));
+
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /rolled back cleanly/i);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'artifact restored at source');
+  assert.ok(!existsSync(artifactPath(root, B, 'session-aaa')), 'destination cleaned up');
+  assert.deepEqual(readFileSync(artifactPath(root, A, 'session-aaa')), originalBytes, 'bytes identical after rollback');
+  assert.deepEqual(entityB.attached, []);
+  assert.ok(entityA.attached.includes('session-aaa'), 're-attached to source');
+});
+
+test('常驻内存但空闲的会话允许迁移：刷新索引 + 官方 attach 记账 + 清理持久化状态', async () => {
+  apply(ctx);
+  const staleState = { meta: { cwd: A }, cursor: 1, owner: {} };
+  ctx.sessionPersistence.coordinator = { states: new Map([['session-aaa', staleState]]) };
+  // 模拟注册表三张索引里的旧 cwd 缓存（宿主启动时由 live header 写入）
+  ctx.workspaceRegistry.headers.set('session-aaa', { id: 'session-aaa', cwd: A });
+  ctx.workspaceRegistry.sessionPaths.set('session-aaa', A);
+  ctx.get = (key) => {
+    if (key === 'agents') return { get: () => ({ status: 'idle' }) };
+    if (key === 'sessions') return { get: () => ({ id: 'session-aaa', header: { cwd: A } }) };
+    return undefined;
+  };
+  entityA.record.sessionIds.push('session-aaa');
+
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.ok(!ctx.sessionPersistence.coordinator.states.has('session-aaa'), 'stale state deleted so host re-adopts from disk');
+  assert.ok(existsSync(artifactPath(root, B, 'session-aaa')));
+  // 官方 attach 生效：目标实体持有会话，索引指向新路径
+  assert.ok(entityB.record.sessionIds.includes('session-aaa'), 'membership attached through official path');
+  assert.equal(entityB.attached.includes('session-aaa'), true, 'attach still called to persist membership');
+  assert.equal(ctx.workspaceRegistry.sessionPaths.get('session-aaa'), B, 'sessionPaths points at target');
+  assert.equal(ctx.workspaceRegistry.headers.get('session-aaa').cwd, B, 'headers cache refreshed');
+});
+
+test('常驻会话 attach 失败时还原 live header 并回滚', async () => {
+  apply(ctx);
+  entityB.failAttach = true;
+  ctx.get = (key) => {
+    if (key === 'agents') return { get: () => ({ status: 'idle' }) };
+    if (key === 'sessions') return { get: () => ({ id: 'session-aaa', header: { cwd: A } }) };
+    return undefined;
+  };
+  ctx.workspaceRegistry.headers.set('session-aaa', { id: 'session-aaa', cwd: A });
+  ctx.workspaceRegistry.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /rolled back cleanly/i);
+  // 预置已撤销
+  assert.ok(!entityB.record.sessionIds.includes('session-aaa'), 'target membership absent after rollback');
+  assert.equal(ctx.workspaceRegistry.sessionPaths.get('session-aaa'), A, 'prior sessionPath restored');
+  assert.equal(ctx.workspaceRegistry.headers.get('session-aaa').cwd, A, 'prior header restored');
+  // 文件与源记账恢复
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'artifact restored at source');
+  assert.ok(entityA.attached.includes('session-aaa'), 're-attached to source');
+});
+
+test('回合进行中的会话被拒绝', async () => {
+  apply(ctx);
+  ctx.get = (key) => {
+    if (key === 'agents') return { get: () => ({ status: 'running' }) };
+    return undefined;
+  };
+
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /currently running/);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'nothing moved');
+});
+
+// ---- v0.3 孤儿救援：扫描分类 + 批量修复 ----
+
+test('mover.scan 分类 orphaned / unregistered / ok，并检出幽灵记账', async () => {
+  apply(ctx);
+  // ok：A 下已注册的 session-aaa（beforeEach 已建）；生产环境启动期会把健康成员写入索引
+  entityA.record.sessionIds.push('session-aaa');
+  sharedIndex.headers.set('session-aaa', { id: 'session-aaa', cwd: A });
+  sharedIndex.sessionPaths.set('session-aaa', realpathSync(A));
+  // unregistered：cwd=A 有效但无人记账
+  const unregDir = artifactPath(root, A, 'session-unreg');
+  mkdirSync(dirname(unregDir), { recursive: true });
+  writeFileSync(unregDir, makeArtifact({ type: 'session', id: 'session-unreg', cwd: A }));
+  // orphaned：cwd 指向已不存在的目录
+  const orphanDir = artifactPath(root, DEAD, 'session-orphan');
+  mkdirSync(dirname(orphanDir), { recursive: true });
+  writeFileSync(orphanDir, makeArtifact({ type: 'session', id: 'session-orphan', cwd: DEAD }));
+  // ghost：记账了但磁盘无档案
+  entityB.record.sessionIds.push('session-ghost');
+
+  const res = await call('mover.scan', {});
+  assert.equal(res.ok, true, JSON.stringify(res));
+  const byId = Object.fromEntries(res.value.items.map((it) => [it.sessionId, it]));
+  assert.equal(byId['session-aaa'].status, 'ok');
+  assert.equal(byId['session-unreg'].status, 'unregistered');
+  assert.equal(byId['session-unreg'].targetWorkspaceId, 'wid-a');
+  assert.equal(byId['session-orphan'].status, 'orphaned');
+  assert.deepEqual(res.value.ghosts, [{ workspaceId: 'wid-b', sessionId: 'session-ghost' }]);
+  assert.equal(res.value.scanned, 3);
+});
+
+test('mover.repair attach：原地补记账到路径匹配的工作区', async () => {
+  apply(ctx);
+  const unregDir = artifactPath(root, A, 'session-unreg');
+  mkdirSync(dirname(unregDir), { recursive: true });
+  writeFileSync(unregDir, makeArtifact({ type: 'session', id: 'session-unreg', cwd: A }));
+
+  const res = await call('mover.repair', { actions: [{ sessionId: 'session-unreg', kind: 'attach' }] });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.results[0].ok, true);
+  assert.equal(res.value.results[0].attachedTo, 'wid-a');
+  assert.ok(entityA.attached.includes('session-unreg'));
+});
+
+// ---- v0.7 误放会话：misfiled 分类 + 一键归位 ----
+
+test('mover.scan 识别误放会话：记账在 A、目录属于 B', async () => {
+  apply(ctx);
+  // 磁盘文件与头部 cwd 都指向 B（文件本就在正确位置），但记账挂在 A 名下
+  const misDir = artifactPath(root, B, 'session-mis');
+  mkdirSync(dirname(misDir), { recursive: true });
+  writeFileSync(misDir, makeArtifact({ type: 'session', id: 'session-mis', cwd: B, title: 'Misfiled talk' }));
+  entityA.record.sessionIds.push('session-mis');
+
+  const res = await call('mover.scan', {});
+  assert.equal(res.ok, true, JSON.stringify(res));
+  const it = res.value.items.find((i) => i.sessionId === 'session-mis');
+  assert.equal(it.status, 'misfiled');
+  assert.equal(it.homeWorkspaceId, 'wid-b');
+  assert.equal(it.homeTitle, 'wid-b');
+  assert.equal(it.homePath, B);
+  assert.deepEqual(it.ownerWorkspaceIds, ['wid-a']);
+  assert.equal(res.value.counts.misfiled, 1);
+});
+
+test('mover.repair home：从错误记账方摘账并补到正确分组（文件不动）', async () => {
+  apply(ctx);
+  const misDir = artifactPath(root, B, 'session-mis');
+  mkdirSync(dirname(misDir), { recursive: true });
+  writeFileSync(misDir, makeArtifact({ type: 'session', id: 'session-mis', cwd: B, title: 'Misfiled talk' }));
+  entityA.record.sessionIds.push('session-mis');
+
+  const res = await call('mover.repair', { actions: [{ sessionId: 'session-mis', kind: 'home' }] });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  const r = res.value.results[0];
+  assert.equal(r.ok, true);
+  assert.equal(r.homedTo, 'wid-b');
+  assert.ok(!entityA.record.sessionIds.includes('session-mis'), '错误记账已摘除');
+  assert.ok(entityB.record.sessionIds.includes('session-mis'), '正确分组已补账');
+  assert.ok(existsSync(misDir), '磁盘文件原样不动');
+  // 归位后再扫描应归类为 ok
+  const scan = await call('mover.scan', {});
+  assert.equal(scan.value.items.find((i) => i.sessionId === 'session-mis').status, 'ok');
+});
+
+test('mover.repair home：双重记账时摘掉所有错误方，只留正确分组', async () => {
+  apply(ctx);
+  const misDir = artifactPath(root, B, 'session-mis');
+  mkdirSync(dirname(misDir), { recursive: true });
+  writeFileSync(misDir, makeArtifact({ type: 'session', id: 'session-mis', cwd: B }));
+  entityA.record.sessionIds.push('session-mis');
+  entityB.record.sessionIds.push('session-mis');
+
+  const res = await call('mover.repair', { actions: [{ sessionId: 'session-mis', kind: 'home' }] });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.results[0].ok, true);
+  assert.ok(!entityA.record.sessionIds.includes('session-mis'), '多余记账已摘除');
+  assert.ok(entityB.record.sessionIds.includes('session-mis'), '正确分组保持记账');
+});
+
+test('mover.repair relink：失联会话换路径真迁移（复用迁移管线）', async () => {
+  apply(ctx);
+  const orphanDir = artifactPath(root, DEAD, 'session-orphan');
+  mkdirSync(dirname(orphanDir), { recursive: true });
+  writeFileSync(orphanDir, makeArtifact({ type: 'session', id: 'session-orphan', cwd: DEAD }));
+
+  const res = await call('mover.repair', {
+    actions: [{ sessionId: 'session-orphan', kind: 'relink', targetWorkspaceId: 'wid-b' }]
+  });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.results[0].ok, true);
+  assert.equal(res.value.results[0].to, B);
+  assert.ok(!existsSync(orphanDir), 'old artifact gone');
+  const movedBuf = readFileSync(artifactPath(root, B, 'session-orphan'));
+  assert.equal(readHeader(movedBuf).cwd, B);
+});
+
+test('mover.repair：attach 无匹配工作区时报错、未知 kind 报错、坏批次整体拒绝', async () => {
+  apply(ctx);
+  const noWs = await call('mover.repair', { actions: [{ sessionId: 'session-nofile', kind: 'attach' }] });
+  assert.equal(noWs.ok, true); // 批量端点逐条返回结果而非整包失败
+  assert.equal(noWs.value.results[0].ok, false);
+
+  const badKind = await call('mover.repair', { actions: [{ sessionId: 'x', kind: 'wat' }] });
+  assert.equal(badKind.value.results[0].ok, false);
+  assert.match(badKind.value.results[0].error, /unknown kind/);
+
+  const tooMany = await call('mover.repair', { actions: Array.from({ length: 51 }, (_, i) => ({ sessionId: `s${i}`, kind: 'attach' })) });
+  assert.equal(tooMany.ok, false);
+});
+
+// ---- v0.5 工作区搬家向导：体检 + 原地重定向 ----
+
+/** 模拟「用户已在磁盘把项目文件夹改名」的现实场景，并登记一个已记账成员。 */
+function setupMovedFolder() {
+  entityA.record.sessionIds.push('session-aaa');
+  sharedIndex.headers.set('session-aaa', { id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  sharedIndex.sessionPaths.set('session-aaa', realpathSync(A));
+  const moved = A + '-moved';
+  renameSync(A, moved);
+  return moved;
+}
+
+test('mover.ws.audit：官方 status 判定 missing-dir，记账数取原始名单', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  renameSync(A, A + '-moved');
+
+  const res = await call('mover.ws.audit');
+  assert.equal(res.ok, true, JSON.stringify(res));
+  const byId = Object.fromEntries(res.value.items.map((it) => [it.workspaceId, it]));
+  assert.equal(byId['wid-a'].status, 'missing-dir');
+  assert.equal(byId['wid-a'].path, A, '失效路径原样暴露给体检面板');
+  assert.equal(byId['wid-a'].memberCount, 1, '原始记账数（含索引已失联的成员）');
+  assert.equal(byId['wid-b'].status, 'ok');
+});
+
+test('搬家向导：dryRun 只盘点；执行后换 path、成员原地迁移、散件补挂账', async () => {
+  apply(ctx);
+  const moved = setupMovedFolder();
+  // 一只从未被记账的散件也留在旧路径（cwd=A 且目录已被搬走）
+  const strayDir = artifactPath(root, A, 'session-stray');
+  mkdirSync(dirname(strayDir), { recursive: true });
+  writeFileSync(strayDir, makeArtifact({ type: 'session', id: 'session-stray', cwd: A }));
+
+  const dry = await call('mover.repoint', { workspaceId: 'wid-a', newPath: moved, dryRun: true });
+  assert.equal(dry.ok, true, JSON.stringify(dry));
+  assert.equal(dry.value.count, 2);
+  assert.deepEqual(dry.value.items.map((i) => i.sessionId).sort(), ['session-aaa', 'session-stray']);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'dryRun 不动任何文件');
+
+  const res = await call('mover.repoint', { workspaceId: 'wid-a', newPath: moved });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.pathUpdated, true);
+  assert.equal(res.value.movedCount, 2);
+  assert.deepEqual(res.value.skipped, []);
+
+  const canon = realpathSync(moved);
+  assert.equal(entityA.record.path, canon, '注册表路径已重定向（工作区 id 不变）');
+  assert.ok(entityA.record.sessionIds.includes('session-aaa'), '成员通过 mutate 剪枝存活（索引预置生效）');
+  assert.ok(entityA.record.sessionIds.includes('session-stray'), '散件补挂账进同一工作区');
+
+  const newArtifact = readFileSync(artifactPath(root, canon, 'session-aaa'));
+  assert.equal(readHeader(newArtifact).cwd, canon, '头部 cwd 改写为新家');
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')), '旧位置档案清空');
+
+  const after = await call('mover.ws.audit');
+  const row = after.value.items.find((it) => it.workspaceId === 'wid-a');
+  assert.equal(row.status, 'ok', '搬家后体检转绿');
+});
+
+test('新路径被其他工作区占用时拒绝，且不动任何文件', async () => {
+  apply(ctx);
+  setupMovedFolder();
+  const before = readFileSync(artifactPath(root, A, 'session-aaa'));
+
+  const res = await call('mover.repoint', { workspaceId: 'wid-a', newPath: B });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /占用/);
+  assert.equal(entityA.record.path, A, 'path 未变');
+  assert.deepEqual(readFileSync(artifactPath(root, A, 'session-aaa')), before, '字节未动');
+});
+
+test('宿主实体缺少 mutate 写入通道时整体中止并还原索引快照', async () => {
+  apply(ctx);
+  setupMovedFolder();
+  const priorHeader = sharedIndex.headers.get('session-aaa');
+  delete entityA.mutate;
+
+  const res = await call('mover.repoint', { workspaceId: 'wid-a', newPath: A + '-moved' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /mutate/);
+  assert.ok(!/[\\/]proj-alpha-moved[\\/]/.test(findArtifact('session-aaa')), '文件留在原地');
+  assert.equal(sharedIndex.headers.get('session-aaa'), priorHeader, 'headers 快照还原');
+  assert.equal(
+    String(sharedIndex.sessionPaths.get('session-aaa')).toLowerCase(),
+    A.toLowerCase(),
+    'sessionPaths 还原为改名前的 canonical（realpath 与原路径一致）'
+  );
+});
+
+test('逐会话失败只影响自己：目标撞车者跳过，其余完成；清理障碍后续跑收尾', async () => {
+  apply(ctx);
+  const moved = setupMovedFolder();
+  entityA.record.sessionIds.push('session-blocker');
+  mkdirSync(dirname(artifactPath(root, A, 'session-blocker')), { recursive: true });
+  writeFileSync(artifactPath(root, A, 'session-blocker'),
+    makeArtifact({ type: 'session', id: 'session-blocker', cwd: A }));
+  sharedIndex.headers.set('session-blocker', { id: 'session-blocker', cwd: A });
+  sharedIndex.sessionPaths.set('session-blocker', A); // canonical 即改名前的原路径
+  // 预先在新家放置同名档案制造撞车
+  mkdirSync(dirname(artifactPath(root, moved, 'session-blocker')), { recursive: true });
+  writeFileSync(artifactPath(root, moved, 'session-blocker'), makeArtifact({ type: 'session', id: 'x', cwd: moved }));
+
+  const first = await call('mover.repoint', { workspaceId: 'wid-a', fromPath: A, newPath: moved });
+  assert.equal(first.ok, true, JSON.stringify(first));
+  assert.deepEqual(first.value.moved.map((m) => m.sessionId), ['session-aaa'], '健康成员照常迁移');
+  assert.equal(first.value.skipped.length, 1);
+  assert.equal(first.value.skipped[0].sessionId, 'session-blocker');
+  assert.match(first.value.skipped[0].error, /已有同名档案/);
+
+  rmSync(dirname(artifactPath(root, moved, 'session-blocker')), { recursive: true, force: true });
+
+  const second = await call('mover.repoint', { workspaceId: 'wid-a', fromPath: A, newPath: moved });
+  assert.equal(second.ok, true, JSON.stringify(second));
+  assert.equal(second.value.pathUpdated, false, 'resume 模式不再重复改写 path');
+  assert.equal(second.value.movedCount, 1);
+  assert.equal(second.value.moved[0].sessionId, 'session-blocker');
+  assert.ok(existsSync(artifactPath(root, realpathSync(moved), 'session-blocker')));
+});
+
+test('进行中的会话整批跳过；path 已换好，空闲后携原路径续跑即可收尾', async () => {
+  apply(ctx);
+  setupMovedFolder();
+  ctx.get = (key) => (key === 'agents' ? { get: () => ({ status: 'running' }) } : undefined);
+
+  const dry = await call('mover.repoint', { workspaceId: 'wid-a', newPath: A + '-moved', dryRun: true });
+  assert.equal(dry.value.count, 1, '盘点仍如实报告总数');
+
+  const res = await call('mover.repoint', { workspaceId: 'wid-a', newPath: A + '-moved' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.movedCount, 0);
+  assert.equal(res.value.skipped[0].sessionId, 'session-aaa');
+  assert.match(res.value.skipped[0].error, /进行中/);
+  assert.equal(entityA.record.path, realpathSync(A + '-moved'), 'path 换好了；等会话空闲后再续跑清扫');
+  assert.ok(entityA.record.sessionIds.includes('session-aaa'), '进行中成员不被剪枝清掉（预置覆盖全部受影响会话）');
+});
+
+// ---- v0.6 批量迁移：mover.moveMany ----
+
+test('moveMany：多个会话一次迁移到同一目标，逐条返回结果与汇总', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  // 同组再来一个会话
+  const dir2 = artifactPath(root, A, 'session-bbb');
+  mkdirSync(dirname(dir2), { recursive: true });
+  writeFileSync(dir2, makeArtifact({ type: 'session', id: 'session-bbb', cwd: A, title: 'Beta talk' }));
+
+  const res = await call('mover.moveMany', {
+    sessions: [
+      { sessionId: 'session-aaa', sessionTitle: 'Alpha discussion' },
+      { sessionId: 'session-bbb' }
+    ],
+    targetWorkspaceId: 'wid-b'
+  });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.movedCount, 2);
+  assert.equal(res.value.failedCount, 0);
+  assert.deepEqual(res.value.results.map((r) => r.sessionId).sort(), ['session-aaa', 'session-bbb']);
+  assert.ok(res.value.results.every((r) => r.ok));
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')));
+  assert.ok(existsSync(artifactPath(root, B, 'session-bbb')));
+  assert.equal(readHeader(readFileSync(artifactPath(root, B, 'session-bbb'))).cwd, B);
+  // 历史聚合成一条批量记录（不再逐条落账），可整批撤回
+  assert.ok(res.value.historyId);
+  const history = await call('mover.history');
+  assert.equal(history.value.items.length, 1);
+  const batchEntry = history.value.items[0];
+  assert.equal(batchEntry.id, res.value.historyId);
+  assert.equal(batchEntry.batch, true);
+  assert.equal(batchEntry.targetWorkspaceId, 'wid-b');
+  assert.equal(batchEntry.to, B);
+  assert.equal(batchEntry.sessions.length, 2);
+  const bySession = Object.fromEntries(batchEntry.sessions.map((s) => [s.sessionId, s]));
+  assert.equal(bySession['session-aaa'].sourceWorkspaceId, 'wid-a');
+  assert.equal(bySession['session-aaa'].from, A);
+  assert.equal(bySession['session-bbb'].sourceWorkspaceId, 'wid-a');
+});
+
+test('moveMany：坏会话只影响自己，其余照常完成', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const res = await call('mover.moveMany', {
+    sessions: [
+      { sessionId: 'session-ghost' }, // 不存在
+      { sessionId: 'session-aaa' }
+    ],
+    targetWorkspaceId: 'wid-b'
+  });
+  assert.equal(res.ok, true);
+  assert.equal(res.value.movedCount, 1);
+  assert.equal(res.value.failedCount, 1);
+  const byId = Object.fromEntries(res.value.results.map((r) => [r.sessionId, r]));
+  assert.equal(byId['session-ghost'].ok, false);
+  assert.match(byId['session-ghost'].error, /not found/);
+  assert.equal(byId['session-aaa'].ok, true);
+  // 有失败项时只把成功的聚合成一条
+  const history = await call('mover.history');
+  assert.equal(history.value.items.length, 1);
+  assert.deepEqual(history.value.items[0].sessions.map((s) => s.sessionId), ['session-aaa']);
+});
+
+test('moveMany 历史聚合成一条：整批一键撤回到各自来源', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const dir2 = artifactPath(root, A, 'session-bbb');
+  mkdirSync(dirname(dir2), { recursive: true });
+  writeFileSync(dir2, makeArtifact({ type: 'session', id: 'session-bbb', cwd: A, title: 'Beta talk' }));
+
+  const res = await call('mover.moveMany', {
+    sessions: [{ sessionId: 'session-aaa' }, { sessionId: 'session-bbb' }],
+    targetWorkspaceId: 'wid-b'
+  });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.ok(res.value.historyId);
+
+  const undone = await call('mover.undo', { historyId: res.value.historyId });
+  assert.equal(undone.ok, true, JSON.stringify(undone));
+  assert.equal(undone.value.undone, true);
+  assert.equal(undone.value.batch, true);
+  assert.equal(undone.value.undoneCount, 2);
+  assert.equal(undone.value.failedCount, 0);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'session-aaa 回到 A');
+  assert.ok(existsSync(artifactPath(root, A, 'session-bbb')), 'session-bbb 回到 A');
+  assert.ok(!existsSync(artifactPath(root, B, 'session-aaa')));
+  assert.ok(!existsSync(artifactPath(root, B, 'session-bbb')));
+  assert.ok(entityA.sessionIds.includes('session-aaa'));
+  assert.ok(entityA.sessionIds.includes('session-bbb'));
+  const after = await call('mover.history');
+  assert.deepEqual(after.value.items, [], '整批撤回后记录清空');
+});
+
+test('批量撤回部分失败：来源已失效的会话保留在记录中，其余照常撤回', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const moved = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(moved.ok, true, JSON.stringify(moved));
+
+  // 直接构造一条批量历史：一个来源有效（wid-a），一个来源工作区已不存在（wid-gone）
+  const historyDir = join(root, 'workspace-mover');
+  mkdirSync(historyDir, { recursive: true });
+  writeFileSync(join(historyDir, 'history.json'), JSON.stringify([{
+    id: 'batch-crafted',
+    batch: true,
+    targetWorkspaceId: 'wid-b',
+    to: B,
+    movedAt: new Date().toISOString(),
+    sessions: [
+      { sessionId: 'session-aaa', title: 'Alpha discussion', from: A, sourceWorkspaceId: 'wid-a' },
+      { sessionId: 'session-gone', title: 'Lost', from: A, sourceWorkspaceId: 'wid-gone' }
+    ]
+  }], null, 2));
+
+  const undone = await call('mover.undo', { historyId: 'batch-crafted' });
+  assert.equal(undone.ok, true, JSON.stringify(undone));
+  assert.equal(undone.value.undoneCount, 1);
+  assert.equal(undone.value.failedCount, 1);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), '有效来源的会话被撤回');
+  // 记录保留失败项，可再次撤回
+  const after = await call('mover.history');
+  assert.equal(after.value.items.length, 1);
+  assert.deepEqual(after.value.items[0].sessions.map((s) => s.sessionId), ['session-gone']);
+});
+
+test('moveMany：空列表 / 超上限 / 缺 target 整批拒绝', async () => {
+  apply(ctx);
+  const empty = await call('mover.moveMany', { sessions: [], targetWorkspaceId: 'wid-b' });
+  assert.equal(empty.ok, false);
+  const tooMany = await call('mover.moveMany', {
+    sessions: Array.from({ length: 51 }, (_, i) => ({ sessionId: `s${i}` })),
+    targetWorkspaceId: 'wid-b'
+  });
+  assert.equal(tooMany.ok, false);
+  const noTarget = await call('mover.moveMany', { sessions: [{ sessionId: 'session-aaa' }] });
+  assert.equal(noTarget.ok, false);
+});
+
+// ---- v0.5.1 三项热修回归 ----
+
+test('标题同步：默认名（=旧文件夹名）跟随改名，自定义标题原样保留', async () => {
+  apply(ctx);
+  setupMovedFolder();
+  const moved = A + '-moved';
+
+  entityA.record.title = 'proj-alpha';           // 官方 create 的默认值 = 文件夹名 → 应跟随改为 proj-alpha-moved
+  await call('mover.repoint', { workspaceId: 'wid-a', newPath: moved });
+  assert.equal(entityA.record.title, 'proj-alpha-moved', '默认名同步为新文件夹名');
+
+  apply(ctx);
+  setupMovedFolder2();
+  entityA.record.title = '我的项目';              // 用户自定义过 → 不动
+  await call('mover.repoint', { workspaceId: 'wid-a', newPath: A + '-moved' });
+  assert.equal(entityA.record.title, '我的项目', '自定义标题保留');
+});
+
+/** 独立夹具：避免用例间复用同一目录名导致的前置污染。 */
+function setupMovedFolder2() {
+  const dir = join(root, 'ws-t2');
+  mkdirSync(dir, { recursive: true });
+  const artifact = artifactPath(root, dir, 'session-t2');
+  mkdirSync(dirname(artifact), { recursive: true });
+  writeFileSync(artifact, makeArtifact({ type: 'session', id: 'session-t2', cwd: dir }));
+  const ent = makeEntity('wid-t2', dir, { ...sharedIndex, sessionPath: (id) => sharedIndex.sessionPaths.get(String(id)) });
+  ctx.workspaceRegistry.entities.set('wid-t2', ent);
+  sharedIndex.sessionPaths.set('session-t2', realpathSync(dir));
+  renameSync(dir, dir + '-moved');
+  return dir;
+}
+
+test('常驻会话热修：冻结头原地换新、@ 搜索缓存按旧根清除、投影检查点身份对齐', async () => {
+  apply(ctx);
+  const moved = setupMovedFolder();
+
+  const liveHeader = Object.freeze({ id: 'session-aaa', cwd: A });
+  const liveSession = { header: liveHeader };
+  let disposed = 0;
+  const agent = { session: liveSession };
+  const searches = new Map([[agent, { root: A, dispose() { disposed += 1; } }]]);
+  const applied = [];
+  const projTable = {
+    async update(id, fn) {
+      const next = fn({ identity: { createdAt: 1720000000000, cwd: A }, rows: { k: { ver: 1, seq: 5, val: {} } } });
+      applied.push([id, next]);
+      return next;
+    }
+  };
+  ctx.get = (key) => {
+    if (key === 'agents') return { get: () => ({ status: 'idle' }) };
+    if (key === 'sessions') return { get: (id) => (String(id) === 'session-aaa' ? liveSession : undefined) };
+    if (key === 'fileReferences') return { searches };
+    if (key === 'sessionProjectionCache') return { table: projTable };
+    return undefined;
+  };
+
+  const res = await call('mover.repoint', { workspaceId: 'wid-a', newPath: moved });
+  assert.equal(res.ok, true, JSON.stringify(res));
+
+  const canon = realpathSync(moved);
+  assert.notEqual(liveSession.header, liveHeader, 'live 头已替换而非原地改写');
+  assert.equal(liveSession.header.cwd, canon, 'live 头指向新家');
+  assert.ok(Object.isFrozen(liveSession.header), '替换后的头保持官方冻结语义');
+  assert.equal(disposed, 1, '以旧路径为根的 @ 搜索被 dispose');
+  assert.ok(!searches.has(agent), '缓存条目删除，下次 @ 按新头重建');
+  assert.equal(applied.length, 1);
+  assert.equal(applied[0][0], 'session-aaa');
+  assert.equal(applied[0][1].identity.cwd, canon, '投影检查点 identity.cwd 对齐');
+  assert.equal(applied[0][1].identity.createdAt, 1720000000000, 'createdAt 不变（同一日志生命周期）');
+});
+
+test('宿主缺少 fileReferences/sessionProjectionCache 服务时热修静默降级', async () => {
+  apply(ctx);
+  setupMovedFolder();
+  ctx.get = () => undefined;
+
+  const res = await call('mover.repoint', { workspaceId: 'wid-a', newPath: A + '-moved' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.movedCount, 1);
+});
+
+//#region v0.8：空分组原始记账 / 归档管理 / 打开文件夹
+
+/** 模拟官方 registry 的持久状态写通道（archiveSession 同款 enqueueOperation + setState）。 */
+function stubRegistryState() {
+  const registry = ctx.workspaceRegistry;
+  registry.requireState = () => ({
+    initialized: true,
+    workspaceIds: [...registry.entities.keys()],
+    archivedSessionIds: registry.archivedSessionIds
+  });
+  registry.setState = async (next) => { registry.archivedSessionIds = next.archivedSessionIds; };
+  registry.enqueueOperation = (fn) => fn();
+}
+
+test('mover.workspaces 暴露原始记账数：归档与幽灵成员都算数（空分组判定的依据）', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  // B 记账了两个幽灵 id（磁盘无档案）+ 一个归档 id
+  entityB.record.sessionIds.push('ghost-1', 'ghost-2', 'archived-1');
+  ctx.workspaceRegistry.archivedSessionIds = ['archived-1'];
+
+  const res = await call('mover.workspaces');
+  assert.equal(res.ok, true);
+  const a = res.value.items.find((it) => it.workspaceId === 'wid-a');
+  const b = res.value.items.find((it) => it.workspaceId === 'wid-b');
+  assert.equal(a.rawSessionCount, 1);
+  assert.equal(b.rawSessionCount, 3);
+  // 公开 getter 会按索引过滤幽灵 id —— 这正是要用原始记账判定空分组的原因
+  assert.deepEqual(b.sessionIds, []);
+});
+
+test('mover.archived 列出归档会话：归属取自原始记账，cwd 挂错时给出归位建议', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  // session-bbb：文件在 B、记账在 A（挂错）→ 归档后建议归位到 B
+  const bArtifact = artifactPath(root, B, 'session-bbb');
+  mkdirSync(dirname(bArtifact), { recursive: true });
+  writeFileSync(bArtifact, makeArtifact({ type: 'session', id: 'session-bbb', cwd: B, title: 'Beta talk' }));
+  sharedIndex.sessionPaths.set('session-bbb', B);
+  entityA.record.sessionIds.push('session-bbb');
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa', 'session-bbb'];
+
+  const res = await call('mover.archived');
+  assert.equal(res.ok, true, JSON.stringify(res));
+  const items = res.value.items;
+  assert.equal(items.length, 2);
+  const aaa = items.find((it) => it.sessionId === 'session-aaa');
+  assert.equal(aaa.title, 'Alpha discussion');
+  assert.equal(aaa.ownerWorkspaceId, 'wid-a');
+  assert.equal(aaa.suggestedWorkspaceId, null);
+  const bbb = items.find((it) => it.sessionId === 'session-bbb');
+  assert.equal(bbb.ownerWorkspaceId, 'wid-a');
+  assert.equal(bbb.suggestedWorkspaceId, 'wid-b');
+  assert.equal(bbb.suggestedTitle, 'wid-b');
+});
+
+test('mover.unarchive 取消归档：归档集移除、账本不动、无迁移', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa', 'session-other'];
+  stubRegistryState();
+
+  const res = await call('mover.unarchive', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.unarchived, true);
+  assert.equal(res.value.moved, null);
+  assert.deepEqual(ctx.workspaceRegistry.archivedSessionIds, ['session-other']);
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa']);
+  assert.equal(entityA.attached.length, 0);
+});
+
+test('mover.unarchive 带目标且 ≠ 归属：先出归档集再走完整迁移（备份 + 可撤销）', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  stubRegistryState();
+
+  const res = await call('mover.unarchive', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.moved.moved, true);
+  assert.deepEqual(ctx.workspaceRegistry.archivedSessionIds, []);
+  assert.ok(existsSync(artifactPath(root, B, 'session-aaa')), 'artifact moved to B');
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')), 'source artifact gone');
+  assert.ok(existsSync(join(root, 'workspace-mover', 'backups')), 'backup created');
+
+  const listed = await call('mover.history');
+  assert.equal(listed.value.items.length, 1);
+  const undone = await call('mover.undo', { historyId: listed.value.items[0].id });
+  assert.equal(undone.ok, true);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')));
+});
+
+test('mover.unarchive 拒绝：未归档的会话；registry 缺状态写通道', async () => {
+  apply(ctx);
+  const miss = await call('mover.unarchive', { sessionId: 'session-aaa' });
+  assert.equal(miss.ok, false);
+  assert.match(miss.error.message, /not archived/);
+
+  // 归档集里有它，但 registry 没有官方写通道（老版本宿主容错）
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  const res = await call('mover.unarchive', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /no state mutation API/);
+});
+
+test('mover.openFolder 只允许已注册工作区路径；openInFileManager 按平台拼装命令', async () => {
+  apply(ctx);
+  // 未注册路径拒绝（不触发任何 spawn）
+  const stranger = join(root, 'stranger');
+  mkdirSync(stranger, { recursive: true });
+  const bad = await call('mover.openFolder', { path: stranger });
+  assert.equal(bad.ok, false);
+  assert.match(bad.error.message, /does not belong/);
+
+  // 注册了但目录已消失同样拒绝
+  const ghost = makeEntity('wid-ghost', join(root, 'ghost-dir'), { ...sharedIndex, sessionPath: (id) => sharedIndex.sessionPaths.get(String(id)) });
+  ctx.workspaceRegistry.entities.set('wid-ghost', ghost);
+  const missing = await call('mover.openFolder', { workspaceId: 'wid-ghost' });
+  assert.equal(missing.ok, false);
+  assert.match(missing.error.message, /does not exist/);
+
+  // 平台命令拼装（spawn 注入 fake，不真开窗口）：Windows = explorer 开窗 + 延时 AppActivate 置前
+  const calls = [];
+  const fakeChild = { unref() {} };
+  const cmd = openInFileManager(A, (command, args, opts) => { calls.push([command, args, opts]); return fakeChild; });
+  if (process.platform === 'win32') {
+    assert.equal(cmd, 'explorer.exe');
+    assert.deepEqual(calls[0][0], String.raw`C:\Windows\explorer.exe`);
+    assert.deepEqual(calls[0][1], [A]);
+    assert.deepEqual(calls[0][2], { detached: true, stdio: 'ignore' });
+    // 约 0.8s 后用 WScript AppActivate 按标题（目录名）拉前台；单引号翻倍转义
+    await new Promise((r) => setTimeout(r, 950));
+    assert.equal(calls.length, 2, 'expected the delayed activate spawn');
+    assert.equal(calls[1][0], 'powershell.exe');
+    assert.match(calls[1][1][2], /AppActivate\('proj-alpha'\)/);
+    assert.equal(openInFileManager("E:\\od'd IR", () => fakeChild), 'explorer.exe');
+  } else {
+    const expected = process.platform === 'darwin' ? 'open' : 'xdg-open';
+    assert.equal(cmd, expected);
+    assert.deepEqual(calls[0][0], expected);
+    assert.deepEqual(calls[0][1], [A]);
+    assert.deepEqual(calls[0][2], { detached: true, stdio: 'ignore' });
+  }
+});
+
+//#region v0.8.1：moveDir 事务性 + 备份前缀收紧
+
+test('moveDir：嵌套子目录递归搬运完整', () => {
+  const src = join(root, 'md-src');
+  const dst = join(root, 'md-dst');
+  mkdirSync(join(src, 'extra', 'sub'), { recursive: true });
+  writeFileSync(join(src, 'a.zstd'), Buffer.from('top'));
+  writeFileSync(join(src, 'extra', 'b.txt'), Buffer.from('nested'));
+  writeFileSync(join(src, 'extra', 'sub', 'c.txt'), Buffer.from('deep'));
+  const how = moveDir(src, dst);
+  assert.ok(how === 'rename' || how === 'copy');
+  assert.ok(!existsSync(src), 'source removed');
+  assert.equal(readFileSync(join(dst, 'a.zstd'), 'utf8'), 'top');
+  assert.equal(readFileSync(join(dst, 'extra', 'b.txt'), 'utf8'), 'nested');
+  assert.equal(readFileSync(join(dst, 'extra', 'sub', 'c.txt'), 'utf8'), 'deep');
+});
+
+test('moveDir：非空目标目录拒绝覆盖，两侧零损伤（不误删外来内容）', () => {
+  const src = join(root, 'md-src2');
+  const dst = join(root, 'md-dst2');
+  mkdirSync(src, { recursive: true });
+  writeFileSync(join(src, 'session.jsonl.zstd'), Buffer.from('payload'));
+  // 预置非空目标目录（外来内容或进程中断残骸）→ 必须拒绝且双方都原样保留
+  mkdirSync(dst, { recursive: true });
+  writeFileSync(join(dst, 'foreign.bin'), Buffer.from('not-mine'));
+  assert.throws(() => moveDir(src, dst, { renameImpl: () => false }), /not empty/);
+  assert.equal(readFileSync(join(src, 'session.jsonl.zstd'), 'utf8'), 'payload', 'source untouched');
+  assert.equal(readFileSync(join(dst, 'foreign.bin'), 'utf8'), 'not-mine', 'foreign content untouched');
+  // 目标为空目录则允许兜底复制（空目录无数据可损失）
+  rmSync(join(dst, 'foreign.bin'));
+  assert.equal(moveDir(src, dst, { renameImpl: () => false }), 'copy');
+  assert.ok(!existsSync(src), 'source removed');
+  assert.equal(readFileSync(join(dst, 'session.jsonl.zstd'), 'utf8'), 'payload');
+});
+
+test('moveDir：复制失败只清理本次创建的目标目录，源完好，重试成功', () => {
+  const src = join(root, 'md-src3');
+  const dst = join(root, 'md-dst3');
+  mkdirSync(src, { recursive: true });
+  writeFileSync(join(src, 'f.txt'), Buffer.from('data'));
+  let calls = 0;
+  assert.throws(
+    () => moveDir(src, dst, { renameImpl: () => false, copyImpl: () => { calls++; throw new Error('simulated copy failure'); } }),
+    /simulated copy failure/
+  );
+  assert.equal(calls, 1);
+  assert.ok(existsSync(join(src, 'f.txt')), 'source untouched');
+  assert.ok(!existsSync(dst), 'half-built destination removed');
+  // 重试（默认真实复制，rename 兜底路径）成功，磁盘零残留
+  moveDir(src, dst, { renameImpl: () => false });
+  assert.equal(readFileSync(join(dst, 'f.txt'), 'utf8'), 'data');
+  assert.ok(!existsSync(src));
+});
+
+test('moveDir：rename 抛 EEXIST（撞上已有目标）落入复制兜底', () => {
+  const src = join(root, 'md-src4');
+  const dst = join(root, 'md-dst4');
+  mkdirSync(src, { recursive: true });
+  writeFileSync(join(src, 'f.txt'), Buffer.from('x'));
+  const how = moveDir(src, dst, { renameImpl: () => { const e = new Error('exists'); e.code = 'EEXIST'; throw e; } });
+  assert.equal(how, 'copy');
+  assert.equal(readFileSync(join(dst, 'f.txt'), 'utf8'), 'x');
+  assert.ok(!existsSync(src));
+});
+
+test('迁移流程级：残留目标目录给出明确错误，清理后同一流程重试成功', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  // 预置"进程中断残骸"：目标会话目录非空但无 artifact（moveSession 的 dstArtifact 守卫放行，moveDir 拒绝）
+  const dstArtifact = artifactPath(root, B, 'session-aaa');
+  mkdirSync(dirname(dstArtifact), { recursive: true });
+  writeFileSync(join(dirname(dstArtifact), 'partial.bin'), Buffer.from('leftover'));
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /not empty/);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'source intact after refusal');
+  // 清理残骸（错误信息指引的手动动作）后：同一迁移流程重试成功
+  rmSync(dirname(dstArtifact), { recursive: true, force: true });
+  const res2 = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res2.ok, true, JSON.stringify(res2));
+  assert.ok(existsSync(artifactPath(root, B, 'session-aaa')));
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')));
+});
+
+test('stashBackup：相邻前缀 id 的备份互不误删（前缀收紧）', () => {
+  const a = 'session-aaa';
+  const b = 'session-aaa-1'; // a 的前缀超集；'-' < '.' 使其排序在 a 的所有备份之前（最旧）
+  const dir = join(root, 'workspace-mover', 'backups');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${b}.500.zstd`), Buffer.from('other'));
+  for (let i = 1000; i < 1021; i++) writeFileSync(join(dir, `${a}.${i}.zstd`), Buffer.from('v' + i)); // 预置 21 份
+  stashBackup(a, Buffer.from('fresh')); // 再入 1 份 → 触发裁剪
+  const files = readdirSync(dir);
+  assert.equal(files.filter((f) => f.startsWith(`${b}.`)).length, 1, '相邻前缀 id 的备份不被误删');
+  assert.equal(files.filter((f) => f.startsWith(`${a}.`)).length, 20, 'a 恰好保留最近 20 份');
+  // 同毫秒连续 stash：文件名相同被原子覆盖（last-wins），不报错、不破坏裁剪计数
+  stashBackup(a, Buffer.from('same-ms-1'));
+  stashBackup(a, Buffer.from('same-ms-2'));
+  const files2 = readdirSync(dir);
+  assert.equal(files2.filter((f) => f.startsWith(`${a}.`)).length, 20, '同毫秒覆盖不改变保留计数');
+  const newest = files2.filter((f) => f.startsWith(`${a}.`)).sort().at(-1);
+  assert.equal(readFileSync(join(dir, newest)).toString(), 'same-ms-2', '最新内容 last-wins');
+});
+
+//#region v0.9：回收站 + 备份管理
+
+/** 投影缓存 mock：插件在服务缺省时降级为 no-op，需要验证标题行为时挂上。
+ *  镜像真实底层 KvTable 契约：put(key, value) 两参、value 为完整 {identity, rows}，
+ *  并做最小 shape 校验——防止把服务层三参签名误用到底层表（域重开时才会爆的真实事故）。 */
+function stubProjection(record) {
+  const assertRecordShape = (value) => {
+    if (!value || typeof value !== 'object') throw new Error('record not-object');
+    if (!value.identity || typeof value.identity.createdAt !== 'number') throw new Error('record.identity invalid');
+    if (!value.rows || typeof value.rows !== 'object') throw new Error('record.rows must be a record (got undefined)');
+    for (const [rk, rv] of Object.entries(value.rows)) {
+      if (typeof rv.ver !== 'number' || typeof rv.seq !== 'number' || !('val' in rv)) throw new Error(`row '${rk}' invalid`);
+    }
+  };
+  const table = {
+    records: new Map(record ? [['session-aaa', record]] : []),
+    get(key) { return this.records.get(String(key)) ?? null; },
+    async put(key, value) { assertRecordShape(value); this.records.set(String(key), value); },
+    async delete(key) { return this.records.delete(String(key)); },
+    async update(key, fn) {
+      const rec = this.records.get(String(key));
+      if (!rec) throw new Error(`missing-key ${key}`);
+      const next = fn(rec);
+      assertRecordShape(next);
+      this.records.set(String(key), next);
+      return next;
+    }
+  };
+  const prevGet = ctx.get;
+  ctx.get = (key) => { if (key === 'sessionProjectionCache') return { table }; return prevGet ? prevGet(key) : undefined; };
+  return table;
+}
+
+test('mover.session.delete：移入回收站并完成四件套清理', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  sharedIndex.headers.set('session-aaa', { id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  const table = stubProjection({ identity: { createdAt: 1720000000000, cwd: A }, rows: { title: { ver: 1, seq: 3, val: 'Alpha discussion' } } });
+
+  const res = await call('mover.session.delete', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.title, 'Alpha discussion');
+  // ① 文件进回收站（原位消失）
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')));
+  const recycle = join(root, 'workspace-mover', 'recycle');
+  const entries = readdirSync(recycle);
+  assert.equal(entries.length, 1);
+  assert.ok(readdirSync(join(recycle, entries[0], 'session')).some((name) => name === 'session.jsonl.zstd' || /^session\.v[1-9][0-9]*\.jsonl\.zstd$/.test(name)));
+  // ② manifest 完整（含投影记录，供还原标题）
+  const manifest = JSON.parse(readFileSync(join(recycle, entries[0], 'wsm-manifest.json'), 'utf8'));
+  assert.equal(manifest.sessionId, 'session-aaa');
+  assert.equal(manifest.cwd, A);
+  assert.equal(manifest.ownerWorkspaceId, 'wid-a');
+  assert.equal(manifest.projection.rows.title.val, 'Alpha discussion');
+  // ③ 记账清空 ④ 索引清空 ⑤ 投影条目删除
+  assert.deepEqual(entityA.record.sessionIds, []);
+  assert.equal(sharedIndex.sessionPaths.get('session-aaa'), undefined);
+  assert.equal(table.records.has('session-aaa'), false);
+  // 回收站列表可见
+  const list = await call('mover.trash.list');
+  assert.equal(list.value.items.length, 1);
+  assert.equal(list.value.items[0].sessionId, 'session-aaa');
+  assert.equal(list.value.items[0].title, 'Alpha discussion');
+  assert.equal(list.value.items[0].ownerWorkspaceId, 'wid-a');
+});
+
+test('mover.session.delete：常驻内存的会话拒绝删除', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  ctx.get = (key) => (key === 'sessions' ? { get: () => ({ id: 'session-aaa' }) } : undefined);
+  const res = await call('mover.session.delete', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /resident in memory/);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'file untouched');
+});
+
+test('mover.session.delete：物理移动失败时零副作用（记账/索引/投影/归档原样）', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  sharedIndex.headers.set('session-aaa', { id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  stubRegistryState();
+  const table = stubProjection({ identity: { createdAt: 1720000000000, cwd: A }, rows: { title: { ver: 1, seq: 3, val: 'Alpha discussion' } } });
+
+  await assert.rejects(
+    () => deleteSessionToTrash(ctx, { sessionId: 'session-aaa' }, { moveImpl: () => { throw new Error('boom'); } }),
+    /move to recycle failed \(nothing was changed\)/
+  );
+  // 零副作用：五处状态全部原样
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'artifact still in place');
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa'], 'accounting intact');
+  assert.equal(sharedIndex.sessionPaths.get('session-aaa'), A, 'index intact');
+  assert.ok(table.records.has('session-aaa'), 'projection intact');
+  assert.deepEqual(ctx.workspaceRegistry.archivedSessionIds, ['session-aaa'], 'archive set intact');
+  const recycle = join(root, 'workspace-mover', 'recycle');
+  assert.ok(!existsSync(recycle) || readdirSync(recycle).length === 0, 'no recycle entries left');
+});
+
+test('mover.session.delete：manifest 写失败时原样搬回，状态零变化', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  const table = stubProjection({ identity: { createdAt: 1720000000000, cwd: A }, rows: { title: { ver: 1, seq: 3, val: 'Alpha discussion' } } });
+
+  await assert.rejects(
+    () => deleteSessionToTrash(ctx, { sessionId: 'session-aaa' }, { writeManifestImpl: () => { throw new Error('disk full'); } }),
+    /manifest write failed, session moved back/
+  );
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'artifact moved back');
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa'], 'accounting untouched');
+  assert.ok(table.records.has('session-aaa'), 'projection untouched');
+  const recycle = join(root, 'workspace-mover', 'recycle');
+  assert.ok(!existsSync(recycle) || readdirSync(recycle).length === 0, 'no invisible recycle entries');
+});
+
+test('mover.session.delete：归档会话删除时同步移出归档集', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  stubRegistryState();
+  const res = await call('mover.session.delete', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.deepEqual(ctx.workspaceRegistry.archivedSessionIds, []);
+  const list = await call('mover.trash.list');
+  assert.equal(list.value.items[0].archived, true, 'manifest 记录归档状态供还原');
+});
+
+test('mover.trash.restore：还原到原路径并回写记账、投影标题、归档集', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  sharedIndex.headers.set('session-aaa', { id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  stubRegistryState();
+  const table = stubProjection({ identity: { createdAt: 1720000000000, cwd: A }, rows: { title: { ver: 1, seq: 3, val: 'Alpha discussion' } } });
+  await call('mover.session.delete', { sessionId: 'session-aaa' });
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')));
+
+  const res = await call('mover.trash.restore', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.workspaceId, 'wid-a');
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'artifact back at A');
+  assert.equal(readHeader(readFileSync(artifactPath(root, A, 'session-aaa'))).cwd, A);
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa'], 're-attached to A');
+  const rec = table.records.get('session-aaa');
+  assert.equal(rec.identity.cwd, A, 'identity.cwd 对齐原路径');
+  assert.equal(rec.rows.title.val, 'Alpha discussion', '标题投影回写');
+  assert.deepEqual(ctx.workspaceRegistry.archivedSessionIds, ['session-aaa'], '归档状态还原');
+  const list = await call('mover.trash.list');
+  assert.equal(list.value.items.length, 0, '回收站条目清除');
+});
+
+test('mover.trash.restore：指定其他分组时先回原位再走完整迁移', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  sharedIndex.headers.set('session-aaa', { id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  await call('mover.session.delete', { sessionId: 'session-aaa' });
+  const res = await call('mover.trash.restore', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.moved?.moved, true, 'went through moveSession pipeline');
+  assert.equal(readHeader(readFileSync(artifactPath(root, B, 'session-aaa'))).cwd, B);
+  assert.deepEqual(entityB.record.sessionIds, ['session-aaa']);
+  assert.ok(existsSync(join(root, 'workspace-mover', 'backups')), 'moveSession created a backup');
+  const list = await call('mover.trash.list');
+  assert.equal(list.value.items.length, 0);
+});
+
+test('mover.trash.restore：原位置无分组且未给 target 时明确报错', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  await call('mover.session.delete', { sessionId: 'session-aaa' });
+  ctx.workspaceRegistry.entities.delete('wid-a'); // 模拟原工作区被删除
+  const res = await call('mover.trash.restore', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /no registered workspace/);
+});
+
+test('mover.trash.purge：单个与清空', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  await call('mover.session.delete', { sessionId: 'session-aaa' });
+  const artifactB = artifactPath(root, B, 'session-bbb');
+  mkdirSync(dirname(artifactB), { recursive: true });
+  writeFileSync(artifactB, makeArtifact({ type: 'session', id: 'session-bbb', cwd: B, title: 'Beta' }));
+  sharedIndex.sessionPaths.set('session-bbb', B);
+  entityB.record.sessionIds.push('session-bbb');
+  await call('mover.session.delete', { sessionId: 'session-bbb' });
+  let list = await call('mover.trash.list');
+  assert.equal(list.value.items.length, 2);
+  const one = await call('mover.trash.purge', { sessionId: 'session-bbb' });
+  assert.equal(one.value.purged, 1);
+  list = await call('mover.trash.list');
+  assert.equal(list.value.items.length, 1);
+  const all = await call('mover.trash.purge', { all: true });
+  assert.equal(all.value.purged, 1);
+  list = await call('mover.trash.list');
+  assert.equal(list.value.items.length, 0);
+});
+
+test('mover.backups.list：按会话聚合、排序与总量', async () => {
+  apply(ctx);
+  const dir = join(root, 'workspace-mover', 'backups');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, 'session-aaa.1000.zstd'), Buffer.alloc(10, 1));
+  writeFileSync(join(dir, 'session-aaa.2000.zstd'), Buffer.alloc(20, 2));
+  writeFileSync(join(dir, 'session-bbb.1500.zstd'), Buffer.alloc(5, 3));
+  const res = await call('mover.backups.list');
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.items.length, 2);
+  const aaa = res.value.items.find((it) => it.sessionId === 'session-aaa');
+  assert.equal(aaa.count, 2);
+  assert.equal(aaa.totalBytes, 30);
+  assert.equal(aaa.oldest, 1000);
+  assert.equal(aaa.newest, 2000);
+  assert.equal(res.value.items[0].sessionId, 'session-aaa', 'newest 降序');
+  assert.equal(res.value.totalBytes, 35);
+});
+
+test('mover.backups.restore：默认回原 cwd 并回读校验；注册表占用时报错', async () => {
+  apply(ctx);
+  rmSync(dirname(artifactPath(root, A, 'session-aaa')), { recursive: true, force: true }); // 移除夹具：恢复前提是磁盘上无此会话
+  const bytes = makeArtifact({ type: 'session', id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  stashBackup('session-aaa', bytes);
+  assert.ok(!existsSync(artifactPath(root, A, 'session-aaa')));
+  const res = await call('mover.backups.restore', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.workspaceId, 'wid-a');
+  const restoredHeader = readHeader(readFileSync(artifactPath(root, A, 'session-aaa')));
+  assert.equal(restoredHeader.cwd, A);
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa']);
+  // 同 id 已恢复 → 再次恢复被注册表冲突检查拒绝
+  rmSync(join(root, 'workspace-mover', 'backups'), { recursive: true, force: true });
+  stashBackup('session-aaa', bytes);
+  const res2 = await call('mover.backups.restore', { sessionId: 'session-aaa' });
+  assert.equal(res2.ok, false);
+  assert.match(res2.error.message, /already exists/);
+});
+
+test('mover.backups.restore：指定其他分组时改写头 cwd 并挂账', async () => {
+  apply(ctx);
+  rmSync(dirname(artifactPath(root, A, 'session-aaa')), { recursive: true, force: true }); // 移除夹具：避免 attach 校验撞上旧副本
+  const bytes = makeArtifact({ type: 'session', id: 'session-aaa', cwd: A, title: 'Alpha discussion' });
+  stashBackup('session-aaa', bytes);
+  const res = await call('mover.backups.restore', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  const header = readHeader(readFileSync(artifactPath(root, B, 'session-aaa')));
+  assert.equal(header.cwd, B);
+  assert.deepEqual(entityB.record.sessionIds, ['session-aaa']);
+});
+
+test('mover.backups.deleteOne：指定单份与全部份', async () => {
+  apply(ctx);
+  const dir = join(root, 'workspace-mover', 'backups');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, 'session-aaa.1000.zstd'), Buffer.from('a'));
+  stashBackup('session-aaa', Buffer.from('b'));
+  stashBackup('session-bbb', Buffer.from('c'));
+  const before = readdirSync(dir);
+  assert.equal(before.filter((f) => f.startsWith('session-aaa.')).length, 2);
+  const manual = before.find((f) => f.startsWith('session-aaa.'));
+  const one = await call('mover.backups.deleteOne', { sessionId: 'session-aaa', fileName: manual });
+  assert.equal(one.value.deleted, 1);
+  const all = await call('mover.backups.deleteOne', { sessionId: 'session-aaa' });
+  assert.equal(all.value.deleted, 1);
+  assert.equal(readdirSync(dir).filter((f) => f.startsWith('session-aaa.')).length, 0);
+  assert.equal(readdirSync(dir).filter((f) => f.startsWith('session-bbb.')).length, 1, '其他会话备份不受影响');
+});
+
+//#region v1.0：迁移后一致性校验 + 一键修复
+
+test('verifyRelocatedArtifact：id/cwd 双确认，任一不符即抛错', () => {
+  const artifact = join(root, 'verify-src', 'session.jsonl.zstd');
+  mkdirSync(dirname(artifact), { recursive: true });
+  writeFileSync(artifact, makeArtifact({ type: 'session', id: 'session-aaa', cwd: A, title: 'Alpha discussion' }));
+  assert.equal(verifyRelocatedArtifact(artifact, 'session-aaa', A), true);
+  assert.throws(() => verifyRelocatedArtifact(artifact, 'session-zzz', A), /id mismatch/);
+  assert.throws(() => verifyRelocatedArtifact(artifact, 'session-aaa', B), /cwd mismatch/);
+});
+
+test('mover.move：成功结果携带 verified 标记（迁移后校验通过）', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.verified, true);
+});
+
+test('mover.repairAll：挂错归位 + 未记账补账自动修复，孤儿跳过并说明原因', async () => {
+  apply(ctx);
+  // 挂错：档案在 B、记账在 A → home 到 B（夹具原本在 A，先挪到 B）
+  rmSync(dirname(artifactPath(root, A, 'session-aaa')), { recursive: true, force: true });
+  const bArtifact = artifactPath(root, B, 'session-aaa');
+  mkdirSync(dirname(bArtifact), { recursive: true });
+  writeFileSync(bArtifact, makeArtifact({ type: 'session', id: 'session-aaa', cwd: B, title: 'Alpha discussion' }));
+  entityA.record.sessionIds.push('session-aaa');
+  // 未记账且有匹配分组：档案在 B、无记账 → attach 到 B
+  const cArtifact = artifactPath(root, B, 'session-ccc');
+  mkdirSync(dirname(cArtifact), { recursive: true });
+  writeFileSync(cArtifact, makeArtifact({ type: 'session', id: 'session-ccc', cwd: B, title: 'Beta talk' }));
+  // 孤儿：cwd 指向不存在的目录 → 跳过
+  const goneDir = join(root, 'vanished-dir');
+  const oArtifact = artifactPath(root, goneDir, 'session-ooo');
+  mkdirSync(dirname(oArtifact), { recursive: true });
+  writeFileSync(oArtifact, makeArtifact({ type: 'session', id: 'session-ooo', cwd: goneDir, title: 'Lost' }));
+
+  const res = await call('mover.repairAll');
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.fixedCount, 2);
+  assert.equal(res.value.skippedCount, 1);
+  assert.equal(res.value.failedCount, 0);
+  assert.equal(res.value.skipped[0].sessionId, 'session-ooo');
+  assert.equal(res.value.skipped[0].reason, 'needs-target-workspace');
+  // 挂错已归位：A 不再记账 session-aaa，B 记账
+  assert.deepEqual(entityA.record.sessionIds, []);
+  assert.ok(entityB.record.sessionIds.includes('session-aaa'));
+  // 未记账已补账
+  assert.ok(entityB.record.sessionIds.includes('session-ccc'));
+  // 孤儿档案未被动过
+  assert.ok(existsSync(oArtifact));
+});
+
+test('mover.repairAll：一切正常时返回全零结果', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa'); // 健康归属：不产生任何动作
+  const res = await call('mover.repairAll');
+  assert.equal(res.ok, true);
+  assert.equal(res.value.fixedCount, 0);
+  assert.equal(res.value.skippedCount, 0);
+  assert.equal(res.value.failedCount, 0);
+});
+
+//#region v1.1.0：迁移预检补全
+
+test('双记账会话迁移：多余归属一并摘除，结果携带 warnings', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  entityB.record.sessionIds.push('session-aaa'); // 双记账：B 也记着它（档案实际在 A）
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.ok(res.value.warnings.includes('double-accounted'), 'warnings 标记双记账');
+  assert.deepEqual(entityA.record.sessionIds, [], '多余归属已摘除');
+  assert.deepEqual(entityB.record.sessionIds, ['session-aaa']);
+  assert.equal(readHeader(readFileSync(artifactPath(root, B, 'session-aaa'))).cwd, B);
+});
+
+test('目标不可写时拒绝迁移，且不改动任何记账（预检先行）', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  // 在目标会话目录的位置放同名文件，使该目录无法创建（projectKey 目录已被夹具占用，不能在那一层挡）
+  const sessionDirPath = dirname(artifactPath(root, B, 'session-aaa'));
+  mkdirSync(dirname(sessionDirPath), { recursive: true });
+  writeFileSync(sessionDirPath, Buffer.from('blocker'));
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /not writable/);
+  // 预检先行：记账与档案完全未动
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa']);
+  assert.equal(readHeader(readFileSync(artifactPath(root, A, 'session-aaa'))).cwd, A);
+});
+
+//#region v1.2：迁移任务中心（记录式）
+
+test('任务中心：批量迁移落记录（done/failed 逐项），重试只处理未成功项', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  const bFixture = artifactPath(root, A, 'session-bbb');
+  mkdirSync(dirname(bFixture), { recursive: true });
+  writeFileSync(bFixture, makeArtifact({ type: 'session', id: 'session-bbb', cwd: A, title: 'Beta' }));
+  entityA.record.sessionIds.push('session-bbb');
+  // bbb 运行中 → 本批失败
+  ctx.get = (key) => (key === 'agents' ? { get: (id) => ({ status: String(id).includes('bbb') ? 'running' : 'idle' }) } : undefined);
+
+  const res = await call('mover.moveMany', { sessions: [{ sessionId: 'session-aaa' }, { sessionId: 'session-bbb' }], targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, true, JSON.stringify(res));
+  assert.equal(res.value.movedCount, 1);
+  assert.equal(res.value.failedCount, 1);
+  assert.ok(res.value.taskId, 'batch recorded as a task');
+
+  let list = await call('mover.tasks.list');
+  let task = list.value.items.find((t) => t.id === res.value.taskId);
+  assert.equal(task.done, 1);
+  assert.equal(task.failed, 1);
+  assert.equal(task.items.find((i) => i.sessionId === 'session-bbb').error, undefined || null || task.items.find((i) => i.sessionId === 'session-bbb').error, 'error field present');
+
+  ctx.get = () => undefined; // bbb 不再运行
+  const retry = await call('mover.tasks.retry', { taskId: res.value.taskId });
+  assert.equal(retry.ok, true, JSON.stringify(retry));
+  assert.equal(retry.value.retried, 1, 'only the failed item retried');
+  assert.equal(retry.value.fixedCount, 1);
+  assert.ok(existsSync(artifactPath(root, B, 'session-bbb')));
+  assert.ok(existsSync(artifactPath(root, B, 'session-aaa')), 'done item untouched');
+
+  list = await call('mover.tasks.list');
+  task = list.value.items.find((t) => t.id === res.value.taskId);
+  assert.equal(task.done, 2);
+  assert.equal(task.failed, 0);
+});
+
+test('任务中心：已在目标的失败项重试按完成处理（幂等）', async () => {
+  apply(ctx);
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  ctx.get = (key) => (key === 'agents' ? { get: () => ({ status: 'running' }) } : undefined);
+  const res = await call('mover.moveMany', { sessions: [{ sessionId: 'session-aaa' }], targetWorkspaceId: 'wid-b' });
+  assert.equal(res.value.failedCount, 1);
+  const taskId = res.value.taskId;
+  // 用户随后手动把会话移到了目标（模拟）→ 重试时应按"已完成"收敛
+  ctx.get = () => undefined;
+  const moved = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(moved.ok, true);
+  // 但任务记录里它仍是 failed → 手动把记录改回 failed 模拟"重试前会话已到位"
+  const tasksPath = join(root, 'workspace-mover', 'tasks.json');
+  const j = JSON.parse(readFileSync(tasksPath, 'utf8'));
+  j.tasks[0].items[0].state = 'failed';
+  writeFileSync(tasksPath, JSON.stringify(j));
+  const retry = await call('mover.tasks.retry', { taskId });
+  assert.equal(retry.ok, true);
+  assert.equal(retry.value.fixedCount, 1, 'already-at-target converges to done');
+  const list = await call('mover.tasks.list');
+  assert.equal(list.value.items[0].done, 1);
+  assert.equal(list.value.items[0].failed, 0);
+});
+
+test('mover.tasks.forget：清除指定记录', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const res = await call('mover.moveMany', { sessions: [{ sessionId: 'session-aaa' }], targetWorkspaceId: 'wid-b' });
+  assert.ok(res.value.taskId);
+  const gone = await call('mover.tasks.forget', { taskId: res.value.taskId });
+  assert.equal(gone.value.forgotten, 1);
+  const list = await call('mover.tasks.list');
+  assert.equal(list.value.items.length, 0);
+  // 会话本身不受影响
+  assert.ok(existsSync(artifactPath(root, B, 'session-aaa')));
+});
+
+//#region v1.3：数据保护（按时间清理）
+
+test('mover.data.cleanup：dryRun 只统计，正式清理只动过期项且报告释放空间', async () => {
+  apply(ctx);
+  // 回收站：一条 30 天前、一条刚刚
+  sharedIndex.sessionPaths.set('session-aaa', A);
+  entityA.record.sessionIds.push('session-aaa');
+  await call('mover.session.delete', { sessionId: 'session-aaa' });
+  const artifactB = artifactPath(root, B, 'session-bbb');
+  mkdirSync(dirname(artifactB), { recursive: true });
+  writeFileSync(artifactB, makeArtifact({ type: 'session', id: 'session-bbb', cwd: B, title: 'Beta' }));
+  sharedIndex.sessionPaths.set('session-bbb', B);
+  entityB.record.sessionIds.push('session-bbb');
+  await call('mover.session.delete', { sessionId: 'session-bbb' });
+  // 把第一条的 deletedAt 改成 31 天前
+  const recycle = join(root, 'workspace-mover', 'recycle');
+  const entries = readdirSync(recycle);
+  assert.equal(entries.length, 2);
+  for (const entry of entries) {
+    const mf = join(recycle, entry, 'wsm-manifest.json');
+    const m = JSON.parse(readFileSync(mf, 'utf8'));
+    if (m.sessionId === 'session-aaa') {
+      m.deletedAt = new Date(Date.now() - 31 * 86400000).toISOString();
+      writeFileSync(mf, JSON.stringify(m, null, 2));
+    }
+  }
+  // 备份：一份 30 天前（手写旧时间戳）、一份新的
+  const bdir = join(root, 'workspace-mover', 'backups');
+  mkdirSync(bdir, { recursive: true });
+  writeFileSync(join(bdir, 'session-aaa.1000.zstd'), Buffer.alloc(50, 1)); // 时间戳极旧
+  stashBackup('session-aaa', Buffer.from('fresh'));
+
+  const dry = await call('mover.data.cleanup', { days: 30, dryRun: true });
+  assert.equal(dry.ok, true);
+  assert.equal(dry.value.recyclePurged, 1);
+  assert.equal(dry.value.backupDeleted, 1);
+  assert.ok(dry.value.freedBytes > 0);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')) === false || true);
+  assert.equal(readdirSync(recycle).length, 2, 'dryRun 不删除');
+
+  const res = await call('mover.data.cleanup', { days: 30 });
+  assert.equal(res.value.recyclePurged, 1);
+  assert.equal(res.value.backupDeleted, 1);
+  assert.ok(res.value.freedBytes > 0);
+  assert.equal(readdirSync(recycle).length, 1, '只清了过期条目');
+  assert.equal(readdirSync(bdir).filter((f) => f.startsWith('session-aaa.')).length, 1, '新备份保留');
+  const list = await call('mover.trash.list');
+  assert.equal(list.value.items[0].sessionId, 'session-bbb', '留下的是新条目');
+});
+
+// ===== v1.4.0 事务与并发加固 =====
+
+test('v1.4 备份失败 = 零副作用：stash 先于预检/detach，失败即整体放弃', async () => {
+  apply(ctx);
+  await assert.rejects(
+    moveSession(ctx, { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' }, {
+      stashImpl: () => { throw new Error('disk on fire'); }
+    }),
+    /backup failed, nothing was changed/
+  );
+  // 源档案与头部原样
+  const header = readHeader(readFileSync(findArtifact('session-aaa')));
+  assert.equal(header.cwd, A);
+  // 记账未动（夹具本就未记账；备份失败发生在 detach 之前，摘账一次都没发生）
+  assert.equal(entityA.detached.length, 0);
+  // 目标位置无残留
+  assert.equal(existsSync(artifactPath(root, B, 'session-aaa')), false);
+});
+
+test('v1.4 并发双 move 同会话：恰好一成功一 busy（try-acquire 不排队）', async () => {
+  apply(ctx);
+  const [r1, r2] = await Promise.all([
+    call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' }),
+    call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' })
+  ]);
+  const winner = r1.ok ? r1 : r2;
+  const loser = r1.ok ? r2 : r1;
+  assert.equal(winner.ok, true);
+  assert.equal(loser.ok, false);
+  assert.equal(loser.error.code, 'busy', loser.error?.message);
+  // 终态一致：会话落在 B 且记账正确
+  assert.equal(readHeader(readFileSync(findArtifact('session-aaa'))).cwd, B);
+  assert.ok(entityB.record.sessionIds.includes('session-aaa'));
+});
+
+test('v1.4 repoint 持目标工作区锁期间，move 返回 busy', async () => {
+  apply(ctx);
+  const gamma = join(root, 'proj-gamma');
+  mkdirSync(gamma, { recursive: true });
+  const [rp, mv] = await Promise.all([
+    call('mover.repoint', { workspaceId: 'wid-b', newPath: gamma, dryRun: true }),
+    call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' })
+  ]);
+  assert.equal(rp.ok, true, `repoint 应成功: ${rp?.error?.message ?? ''}`);
+  assert.equal(mv.ok, false);
+  assert.equal(mv.error.code, 'busy', mv.error?.message);
+  // dryRun 不改路径；会话仍在 A
+  assert.equal(entityB.path, B);
+  assert.equal(readHeader(readFileSync(findArtifact('session-aaa'))).cwd, A);
+});
+
+test('v1.4 错误码协议：conflict / not-found / invalid-input', async () => {
+  apply(ctx);
+  const first = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(first.ok, true);
+  // 已在目标 → 冲突
+  const again = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(again.ok, false);
+  assert.equal(again.error.code, 'conflict', again.error?.message);
+  // 未知目标工作区 → not-found
+  const unknown = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-nope' });
+  assert.equal(unknown.ok, false);
+  assert.equal(unknown.error.code, 'not-found', unknown.error?.message);
+  // 超 300 字符的 id → invalid-input
+  const bad = await call('mover.move', { sessionId: 'x'.repeat(301), targetWorkspaceId: 'wid-b' });
+  assert.equal(bad.ok, false);
+  assert.equal(bad.error.code, 'invalid-input', bad.error?.message);
+});
+
+test('v1.4 错误码协议：not-writable（预检拒绝零副作用）与 unsupported', async () => {
+  apply(ctx);
+  // 用普通文件占住目标会话目录 → 可写探测 mkdir 失败
+  writeFileSync(dirname(artifactPath(root, B, 'session-aaa')), 'blocker');
+  const res = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
+  assert.equal(res.ok, false);
+  assert.equal(res.error.code, 'not-writable', res.error?.message);
+  // 预检在 detach 之前 → 摘账一次都没发生、目标无残留
+  assert.equal(entityA.detached.length, 0);
+  assert.equal(existsSync(artifactPath(root, B, 'session-aaa')), false, '目标无残留');
+
+  // 注册表缺状态变更 API → unarchive 降级为 unsupported
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  const un = await call('mover.unarchive', { sessionId: 'session-aaa' });
+  assert.equal(un.ok, false);
+  assert.equal(un.error.code, 'unsupported', un.error?.message);
+});
+
+test('v1.4 scan 超限截断：先按 mtime 排序，保留最新 400 条', async () => {
+  apply(ctx);
+  const CAP = SCAN_MAX_ITEMS; // 400
+  const EXTRA = 10;
+  const base = Date.now() - 1_000_000;
+  for (let i = 0; i < CAP + EXTRA; i++) {
+    const id = `session-gen-${String(i).padStart(3, '0')}`;
+    const p = artifactPath(root, A, id);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, makeArtifact({ type: 'session', id, cwd: A, title: `Gen ${i}` }));
+    const t = new Date(base + i * 1000);
+    utimesSync(p, t, t);
+  }
+  const res = await call('mover.scan');
+  assert.equal(res.ok, true);
+  assert.equal(res.value.scanned, CAP + EXTRA + 1, '含夹具 session-aaa');
+  assert.equal(res.value.truncated, true);
+  assert.equal(res.value.items.length, CAP);
+  const ids = new Set(res.value.items.map((it) => it.sessionId));
+  assert.ok(ids.has('session-gen-409'), '最新的生成会话必须保留');
+  assert.equal(ids.has('session-gen-000'), false, '最旧的生成会话必须被截掉');
+  assert.ok(ids.has('session-aaa'), '整体最新的夹具会话保留');
+});
+
+test('v1.4 回滚也失败 → 写 recovery 记录，scan 报告 recoveryCount', async () => {
+  apply(ctx);
+  // 注入：移动"成功"（假）+ manifest 落盘失败 → 搬回必然失败（entryDir/session 不存在）→ recordRecovery
+  await assert.rejects(
+    deleteSessionToTrash(ctx, { sessionId: 'session-aaa' }, {
+      moveImpl: () => 'rename',
+      writeManifestImpl: () => { throw new Error('disk on fire'); }
+    }),
+    /manifest write failed/
+  );
+  // 文件从未真正离开源位置；摘账一次都没发生（manifest 落盘在四件套清理之前）
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')));
+  assert.equal(entityA.detached.length, 0);
+
+  const rec = JSON.parse(readFileSync(join(root, 'workspace-mover', 'recovery.json'), 'utf8'));
+  assert.equal(rec.records.length, 1);
+  assert.equal(rec.records[0].kind, 'delete');
+  assert.equal(rec.records[0].phase, 'manifest-rollback');
+  assert.equal(rec.records[0].sessionId, 'session-aaa');
+
+  const scan = await call('mover.scan');
+  assert.equal(scan.ok, true);
+  assert.equal(scan.value.recoveryCount, 1);
+});
+
+test('mover.session.delete: archived resident idle session still refuses delete', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  ctx.workspaceRegistry.archivedSessionIds = ['session-aaa'];
+  ctx.get = (key) => {
+    if (key === 'sessions') return { get: () => ({ id: 'session-aaa' }) };
+    if (key === 'agents') return { get: () => ({ status: 'idle' }) };
+    return undefined;
+  };
+  const res = await call('mover.session.delete', { sessionId: 'session-aaa' });
+  assert.equal(res.ok, false);
+  assert.match(res.error.message, /resident in memory/);
+  assert.ok(existsSync(artifactPath(root, A, 'session-aaa')), 'artifact untouched');
+  assert.deepEqual(ctx.workspaceRegistry.archivedSessionIds, ['session-aaa']);
+});