dsh-workspace-mover 2.4.1 → 2.4.3

package/test/client-dom.test.mjs

@@ -493,6 +493,104 @@ test('模块导出 apply / inject，且 apply 不抛错', () => {
   assert.deepEqual(mod.inject, ['connection', 'slots']);
 });
 
+test('locale service wins over browser language, switches live and releases registrations', async () => {
+  resetDom();
+  let language = 'en';
+  let dicts;
+  let unregisters = 0;
+  const listeners = new Set();
+  const locale = {
+    register(ns, values) {
+      assert.equal(ns, 'workspace-mover'); dicts = values;
+      return () => { unregisters++; };
+    },
+    bind() { return (key) => dicts[language][key] ?? key; },
+    subscribe(fn) { listeners.add(fn); return () => listeners.delete(fn); }
+  };
+  ctx = makeCtx();
+  ctx.get = (key) => key === 'locale' ? locale : undefined;
+  mod.apply(ctx);
+  const row = sessionRow('Locale test', 'session-aaa');
+  const beta = header('proj-beta');
+  fixture({ rows: [row] }); attach(beta);
+  await dragDrop(row, beta, 'session-aaa', { confirm: false });
+  assert.equal(doc._body.querySelector('.wsm-title').textContent, 'Move session across workspaces');
+  dispatch({ type: 'click', target: doc._body.querySelector('.wsm-cancel') });
+  language = 'zh'; for (const fn of listeners) fn();
+  await dragDrop(row, beta, 'session-aaa', { confirm: false });
+  assert.equal(doc._body.querySelector('.wsm-title').textContent, '跨工作区移动会话');
+  dispatch({ type: 'click', target: doc._body.querySelector('.wsm-cancel') });
+  unmount();
+  assert.equal(unregisters, 1);
+  assert.equal(listeners.size, 0);
+});
+
+test('late locale service is disposed even when unavailable at initial mount', () => {
+  resetDom();
+  ctx = makeCtx();
+  let arrive;
+  ctx.inject = (keys, callback) => { assert.deepEqual(keys, ['locale']); arrive = callback; };
+  mod.apply(ctx);
+  let disposed = 0;
+  const locale = { register: () => () => disposed++, bind: () => () => 'translated' };
+  arrive({ get: () => locale, effect(fn) { effects.push(fn()); } });
+  unmount();
+  assert.equal(disposed, 1);
+});
+
+test('deleting selected conversation clears its view without reopening; later selection is preserved', async () => {
+  for (const navigate of [false, true]) {
+    resetDom();
+    ctx = makeCtx();
+    let selected = 'session-delete';
+    let cleared = 0;
+    let rpc;
+    const ui = {
+      selection: { getSnapshot: () => ({ sessionId: selected }) },
+      clearMain() { selected = null; cleared++; },
+      openSession() { assert.fail('must not reload deleted conversation'); }
+    };
+    ctx.get = (key) => key === 'uiWorkspace' ? ui : undefined;
+    ctx.slots = {
+      inject(_name, fn) { fn(); },
+      register(options) { rpc = options.inject().rpcCall; }
+    };
+    ctx.connection.rpc.call = async () => {
+      if (navigate) selected = 'session-other';
+      return { ok: true, value: { deleted: true } };
+    };
+    mod.apply(ctx);
+    await rpc('mover.session.delete', { sessionId: 'session-delete' });
+    assert.equal(cleared, navigate ? 0 : 1);
+    assert.equal(selected, navigate ? 'session-other' : null);
+  }
+});
+
+test('restore refreshes the real session baseline once; refresh failure never repeats file restoration', async () => {
+  for (const endpoint of ['mover.trash.restore', 'mover.backups.restore', 'mover.unarchive']) {
+    for (const brokenRefresh of [false, true]) {
+      resetDom();
+      ctx = makeCtx();
+      let rpc;
+      const actions = [];
+      ctx.slots = { inject(_name, fn) { fn(); }, register(options) { rpc = options.inject().rpcCall; } };
+      ctx.get = (key) => key === 'sessions' ? {
+        async refresh() { actions.push('refresh'); if (brokenRefresh) throw new Error('list unavailable'); }
+      } : undefined;
+      ctx.connection.rpc.call = async (_channel, method) => {
+        actions.push(method);
+        return { ok: true, value: { restored: true } };
+      };
+      mod.apply(ctx);
+      actions.length = 0; // discard the initial status probe
+      const result = await rpc(endpoint, { sessionId: 'session-restored' });
+      assert.equal(result.ok, true, 'do not label completed restore as failed');
+      assert.deepEqual(actions, [endpoint, 'refresh']);
+      if (brokenRefresh) assert.match(doc._body.querySelector('.wsm-toast')?.textContent, /无需重复还原/);
+    }
+  }
+});
+
 test('热重载：卸载再装载不得让 document 监听器净增长（teardown 回归）', () => {
   resetDom();
   mount();
@@ -566,7 +664,7 @@ test('拖拽跨组移动：经权威 fiber 通道解析出正确 sessionId', asy
   assert.equal(calls[0].payload.targetWorkspaceId, 'wid-b');
 });
 
-test('迁移标题使用权威预览，不包含侧边栏时间；驻留队列提示可能需重启', async () => {
+test('即时迁移使用权威标题，不包含侧边栏时间，不启用排队', async () => {
   resetDom();
   mount();
   const row = sessionRow('测试刚刚', 'session-aaa');
@@ -575,22 +673,114 @@ test('迁移标题使用权威预览，不包含侧边栏时间；驻留队列
   const prior = rpcResponder;
   setResponder((endpoint, payload) => endpoint === 'mover.preview' ? {
     ok: true, value: {
-      title: '测试', status: 'queued', source: { cwd: 'C:/proj-alpha' },
+      title: '测试', status: 'safe', liveMigration: true, source: { cwd: 'C:/proj-alpha' },
       target: { path: 'C:/proj-beta' }, estimatedBackupBytes: 0,
-      warnings: ['resident writer; restart required']
+      warnings: []
     }
   } : prior(endpoint, payload));
   attach(beta);
   await dragDrop(row, beta, 'session-aaa', { confirm: false });
   const overlay = doc._body.querySelector('.wsm-overlay');
   assert.equal(overlay.querySelector('.wsm-session').textContent, '测试');
-  assert.match(overlay.querySelector('.wsm-preview').textContent, /可能需重启/);
+  assert.doesNotMatch(overlay.querySelector('.wsm-preview').textContent, /可能需重启/);
   assert.doesNotMatch(overlay.querySelector('.wsm-preview').textContent, /进入空闲队列/);
   dispatch({ type: 'click', target: overlay.querySelector('.wsm-ok') });
   await new Promise((resolve) => setTimeout(resolve, 0));
   assert.equal(moveCalls()[0].payload.sessionTitle, '测试');
+  assert.equal(moveCalls()[0].payload.allowQueue, false);
 });
 
+for (const outcome of ['success', 'render-release', 'navigation-during-release', 'rollback', 'transport-error', 'navigated', 'healthy', 'unloaded']) {
+  test(`migration reconnects the removed current conversation via host navigation: ${outcome}`, async () => {
+    resetDom(); mount();
+    const row = sessionRow('标题保留测试', 'session-aaa');
+    const beta = header('proj-beta');
+    fixture({ rows: [row] });
+    attach(beta);
+    let selected = 'session-aaa';
+    let removed = false;
+    const releaseListeners = new Set();
+    let binding;
+    const navigation = [];
+    const ui = {
+      selection: { getSnapshot: () => ({ sessionId: selected }) },
+      clearMain() {
+        navigation.push('release'); selected = undefined;
+        const release = () => {
+          binding = undefined;
+          if (outcome === 'navigation-during-release') selected = 'session-other';
+          for (const listener of releaseListeners) listener();
+        };
+        if (outcome === 'render-release' || outcome === 'navigation-during-release') setTimeout(release, 0);
+        else release();
+      },
+      openSession(id) {
+        assert.equal(binding, undefined, 'must wait for Provider reference release before retaining again');
+        navigation.push(id); selected = id; removed = false; binding = { session };
+      }
+    };
+    const session = {
+      getSnapshot: () => ({ removed }),
+      async open() { navigation.push('ready'); }
+    };
+    binding = { session };
+    const sessions = { binding: () => binding, retainInfo: () => ({
+      subscribe(listener) { releaseListeners.add(listener); return () => releaseListeners.delete(listener); }
+    }) };
+    ctx.get = (key) => ({ uiWorkspace: ui, sessions })[key];
+    const prior = rpcResponder;
+    setResponder((endpoint, payload) => {
+      if (endpoint !== 'mover.move') return prior(endpoint, payload);
+      removed = outcome !== 'healthy';
+      if (outcome === 'navigated') selected = 'session-other';
+      if (outcome === 'unloaded') unmount();
+      if (outcome === 'transport-error') throw new Error('Connection lost after release');
+      if (outcome === 'rollback') return { ok: false, error: { code: 'move-failed', message: 'rolled back cleanly' } };
+      return prior(endpoint, payload);
+    });
+    await dragDrop(row, beta, 'session-aaa');
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.equal(moveCalls().length, 1, 'never repeats the physical migration');
+    if (['navigated', 'healthy', 'unloaded'].includes(outcome)) {
+      assert.deepEqual(navigation, []);
+    } else if (outcome === 'navigation-during-release') {
+      assert.deepEqual(navigation, ['release']);
+      assert.equal(selected, 'session-other');
+    } else {
+      assert.deepEqual(navigation, ['release', 'session-aaa', 'ready']);
+      assert.equal(removed, false, 'new view can accept messages without manually switching');
+    }
+    assert.equal(releaseListeners.size, 0, 'retention observer is released');
+    if (outcome === 'success') {
+      const text = doc._body.querySelector('.wsm-toast')?.textContent;
+      assert.match(text, /重启应用/);
+      assert.doesNotMatch(text, /刷新页面/);
+    }
+    if (outcome === 'rollback') assert.match(doc._body.querySelector('.wsm-toast')?.textContent, /rolled back cleanly/);
+  });
+}
+
+for (const approve of [false, true]) {
+  test(`运行中拖动会话：${approve ? '明确停止后迁移' : '取消不执行'}`, async () => {
+    resetDom(); mount();
+    const row = sessionRow('运行中', 'session-aaa');
+    const beta = header('proj-beta');
+    fixture({ rows: [row] });
+    const prior = rpcResponder;
+    setResponder((endpoint, payload) => endpoint === 'mover.preview' ? { ok: true, value: {
+      status: 'warning', running: true, liveMigration: true, warnings: ['session is running; moving requires explicit stop confirmation']
+    } } : prior(endpoint, payload));
+    attach(beta);
+    await dragDrop(row, beta, 'session-aaa', { confirm: false });
+    const overlay = doc._body.querySelector('.wsm-overlay');
+    assert.equal(overlay.querySelector('.wsm-ok').textContent, '停止任务并迁移');
+    dispatch({ type: 'click', target: overlay.querySelector(approve ? '.wsm-ok' : '.wsm-cancel') });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.equal(moveCalls().length, approve ? 1 : 0);
+    if (approve) assert.equal(moveCalls()[0].payload.stopRunning, true);
+  });
+}
+
 test('兜底映射错配时不得把错配 id 当成真实会话移动（P2 回归）', async () => {
   resetDom();
   mount();

package/test/core.test.mjs

@@ -1,55 +1,55 @@
-// 核心纯函数单元测试：帧扫描 / 头部读写 / 存储路径编码。
-// 运行：npm test（或 node --test test/）
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { zstdCompressSync, constants } from 'node:zlib';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { scanFrames, readHeader, rewriteHeaderCwd, generationLogFilename, parseGenerationLogFilename, findHighestArtifact, artifactPath, sessionDir } from '../lib/index.js';
-
-const OPTS = { params: { [constants.ZSTD_c_checksumFlag]: 1 } };
-
-/** 构造一个「头 + N 个事件帧」的合成档案。 */
-function makeArtifact(header, events) {
-  const head = zstdCompressSync(Buffer.from(JSON.stringify(header) + '\n', 'utf8'), OPTS);
-  const rest = events.map((e) => zstdCompressSync(Buffer.from(JSON.stringify(e) + '\n', 'utf8'), OPTS));
-  return Buffer.concat([head, ...rest]);
-}
-
-test('scanFrames 定位全部帧边界', () => {
-  const buf = makeArtifact({ type: 'session', id: 's1', cwd: 'E:\\a' }, [{ seq: 1 }, { seq: 2 }]);
-  const frames = scanFrames(buf);
-  assert.equal(frames.length, 3);
-  for (const [s, e] of frames) assert.ok(e > s && e <= buf.length);
-});
-
-test('readHeader 解出首行会话头', () => {
-  const buf = makeArtifact({ type: 'session', id: 'session-x', cwd: 'C:\\work' }, [{ seq: 1 }]);
-  const header = readHeader(buf);
-  assert.equal(header.type, 'session');
-  assert.equal(header.id, 'session-x');
-  assert.equal(header.cwd, 'C:\\work');
-});
-
-test('rewriteHeaderCwd 只改头部，其余帧字节不变', () => {
-  const ev = [{ seq: 1, text: 'hello 世界' }, { seq: 2 }];
-  const original = makeArtifact({ type: 'session', id: 'session-y', cwd: 'E:\\old\\path' }, ev);
-  const rewritten = rewriteHeaderCwd(original, 'E:\\new\\home');
-  // 头部已更新
-  const header = readHeader(rewritten);
-  assert.equal(header.cwd, 'E:\\new\\home');
-  assert.equal(header.id, 'session-y');
-  // 其余事件帧逐字节保留
-  const of = scanFrames(original), nf = scanFrames(rewritten);
-  assert.equal(nf.length, of.length);
-  assert.ok(of.slice(1).every(([, e], i) => original.subarray(of[i + 1][0], e).equals(rewritten.subarray(nf[i + 1][0], nf[i + 1][1]))));
-});
-
+// 核心纯函数单元测试：帧扫描 / 头部读写 / 存储路径编码。
+// 运行：npm test（或 node --test test/）
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { zstdCompressSync, constants } from 'node:zlib';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { scanFrames, readHeader, rewriteHeaderCwd, generationLogFilename, parseGenerationLogFilename, findHighestArtifact, artifactPath, sessionDir } from '../lib/index.js';
+
+const OPTS = { params: { [constants.ZSTD_c_checksumFlag]: 1 } };
+
+/** 构造一个「头 + N 个事件帧」的合成档案。 */
+function makeArtifact(header, events) {
+  const head = zstdCompressSync(Buffer.from(JSON.stringify(header) + '\n', 'utf8'), OPTS);
+  const rest = events.map((e) => zstdCompressSync(Buffer.from(JSON.stringify(e) + '\n', 'utf8'), OPTS));
+  return Buffer.concat([head, ...rest]);
+}
+
+test('scanFrames 定位全部帧边界', () => {
+  const buf = makeArtifact({ type: 'session', id: 's1', cwd: 'E:\\a' }, [{ seq: 1 }, { seq: 2 }]);
+  const frames = scanFrames(buf);
+  assert.equal(frames.length, 3);
+  for (const [s, e] of frames) assert.ok(e > s && e <= buf.length);
+});
+
+test('readHeader 解出首行会话头', () => {
+  const buf = makeArtifact({ type: 'session', id: 'session-x', cwd: 'C:\\work' }, [{ seq: 1 }]);
+  const header = readHeader(buf);
+  assert.equal(header.type, 'session');
+  assert.equal(header.id, 'session-x');
+  assert.equal(header.cwd, 'C:\\work');
+});
+
+test('rewriteHeaderCwd 只改头部，其余帧字节不变', () => {
+  const ev = [{ seq: 1, text: 'hello 世界' }, { seq: 2 }];
+  const original = makeArtifact({ type: 'session', id: 'session-y', cwd: 'E:\\old\\path' }, ev);
+  const rewritten = rewriteHeaderCwd(original, 'E:\\new\\home');
+  // 头部已更新
+  const header = readHeader(rewritten);
+  assert.equal(header.cwd, 'E:\\new\\home');
+  assert.equal(header.id, 'session-y');
+  // 其余事件帧逐字节保留
+  const of = scanFrames(original), nf = scanFrames(rewritten);
+  assert.equal(nf.length, of.length);
+  assert.ok(of.slice(1).every(([, e], i) => original.subarray(of[i + 1][0], e).equals(rewritten.subarray(nf[i + 1][0], nf[i + 1][1]))));
+});
+
 test('损坏档案被拒绝而不是静默通过', () => {
-  const buf = makeArtifact({ type: 'session', id: 's', cwd: 'x' }, []);
-  buf.writeUInt32LE(0x12345678, 8); // 破坏第一帧内部
-  assert.throws(() => readHeader(buf));
+  const buf = makeArtifact({ type: 'session', id: 's', cwd: 'x' }, []);
+  buf.writeUInt32LE(0x12345678, 8); // 破坏第一帧内部
+  assert.throws(() => readHeader(buf));
 });
 
 test('readHeader and rewriteHeaderCwd support uncompressed JSONL', () => {
@@ -67,29 +67,29 @@ test('readHeader and rewriteHeaderCwd support uncompressed JSONL', () => {
 
 
 test('generationLogFilename prefers v3 zstd names', () => {
-  assert.equal(generationLogFilename(0, 'zstd'), 'session.jsonl.zstd');
-  assert.equal(generationLogFilename(3, 'zstd'), 'session.v3.jsonl.zstd');
-  assert.equal(parseGenerationLogFilename('session.jsonl.zstd')?.version, 0);
-  assert.equal(parseGenerationLogFilename('session.v3.jsonl.zstd')?.version, 3);
-  assert.equal(parseGenerationLogFilename('session.migration.tmp.jsonl.zstd'), null);
-});
-
+  assert.equal(generationLogFilename(0, 'zstd'), 'session.jsonl.zstd');
+  assert.equal(generationLogFilename(3, 'zstd'), 'session.v3.jsonl.zstd');
+  assert.equal(parseGenerationLogFilename('session.jsonl.zstd')?.version, 0);
+  assert.equal(parseGenerationLogFilename('session.v3.jsonl.zstd')?.version, 3);
+  assert.equal(parseGenerationLogFilename('session.migration.tmp.jsonl.zstd'), null);
+});
+
 test('findHighestArtifact picks the newest canonical generation', () => {
-  const root = mkdtempSync(join(tmpdir(), 'wsm-gen-'));
-  try {
-    const dir = join(root, 'sess');
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'session.jsonl.zstd'), Buffer.from('old'));
-    writeFileSync(join(dir, 'session.v2.jsonl.zstd'), Buffer.from('mid'));
-    writeFileSync(join(dir, 'session.v3.jsonl.zstd'), Buffer.from('new'));
-    writeFileSync(join(dir, 'session.migration.abc.jsonl.zstd'), Buffer.from('tmp'));
-    const found = findHighestArtifact(dir);
-    assert.equal(found?.version, 3);
-    assert.equal(found?.name, 'session.v3.jsonl.zstd');
-    assert.equal(artifactPath(root, 'E:\\proj', 'session-x'), join(sessionDir(root, 'E:\\proj', 'session-x'), 'session.v3.jsonl.zstd'));
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
+  const root = mkdtempSync(join(tmpdir(), 'wsm-gen-'));
+  try {
+    const dir = join(root, 'sess');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'session.jsonl.zstd'), Buffer.from('old'));
+    writeFileSync(join(dir, 'session.v2.jsonl.zstd'), Buffer.from('mid'));
+    writeFileSync(join(dir, 'session.v3.jsonl.zstd'), Buffer.from('new'));
+    writeFileSync(join(dir, 'session.migration.abc.jsonl.zstd'), Buffer.from('tmp'));
+    const found = findHighestArtifact(dir);
+    assert.equal(found?.version, 3);
+    assert.equal(found?.name, 'session.v3.jsonl.zstd');
+    assert.equal(artifactPath(root, 'E:\\proj', 'session-x'), join(sessionDir(root, 'E:\\proj', 'session-x'), 'session.v3.jsonl.zstd'));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
 });
 
 test('findHighestArtifact supports the official uncompressed encoding', () => {

package/test/e2e-sandbox.test.mjs

@@ -62,13 +62,18 @@ for (const compression of ['none', 'zstd']) {
     writeFileSync(src, original);
     const projections = { identity: { cwd: A }, rows: { workingDirectory: { val: A }, title: { val: 'Keep title' } } };
     let updated;
-    ctx.get = (key) => key === 'sessionProjectionCache' ? { table: { async update(id, fn) { updated = fn(projections); } } } : undefined;
+    let cached = projections;
+    ctx.get = (key) => key === 'sessionProjectionCache' ? { table: {
+      get() { return cached; }, async put(id, value) { cached = updated = value; }
+    } } : undefined;
     entityA.record.sessionIds.push('session-aaa');
     entityB.failAttach = true;
     const failure = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
     assert.equal(failure.ok, false);
     assert.match(failure.error.message, /rolled back cleanly/);
     assert.deepEqual(readFileSync(src), original);
+    assert.equal(cached.identity.cwd, A, 'failed attach restores the title identity');
+    assert.deepEqual(cached.rows, projections.rows, 'rollback restores every original projection row');
     entityB.failAttach = false;
     const moved = await call('mover.move', { sessionId: 'session-aaa', targetWorkspaceId: 'wid-b' });
     assert.equal(moved.ok, true, JSON.stringify(moved));
@@ -926,7 +931,7 @@ test('mover.scan 分类 orphaned / unregistered / ok，并检出幽灵记账', a
   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.deepEqual(res.value.ghosts, [{ workspaceId: 'wid-b', sessionId: 'session-ghost', locations: [], status: 'location-unknown', archived: false }]);
   assert.equal(res.value.scanned, 3);
 });
 
@@ -1437,6 +1442,46 @@ test('mover.archived 列出归档会话：归属取自原始记账，cwd 挂错
   assert.equal(bbb.suggestedTitle, 'wid-b');
 });
 
+test('current per-record and live titles override legacy titles across repair, archive, preview and backups', async () => {
+  apply(ctx);
+  const id = 'session-aaa';
+  writeFileSync(artifactPath(root, A, id), makeArtifact({ type: 'session', id, cwd: A }));
+  const storage = join(root, 'storages');
+  const checkpoint = join(storage, 'session_projcache', 'sessions', `${id}.json`);
+  mkdirSync(dirname(checkpoint), { recursive: true });
+  writeFileSync(join(storage, 'session_projcache.json'), JSON.stringify({ tables: {
+    sessions: { [id]: { rows: { title: { val: 'Outdated title' } } } }
+  } }), 'utf8');
+  writeFileSync(checkpoint, JSON.stringify({ version: 7, record: {
+    identity: { cwd: A }, rows: { title: { val: '标题保留测试' } }
+  } }), 'utf8');
+  entityA.record.sessionIds.push(id);
+  sharedIndex.sessionPaths.set(id, A);
+  ctx.workspaceRegistry.archivedSessionIds = [id];
+  stashBackup(id, readFileSync(artifactPath(root, A, id)));
+  const titles = async () => {
+    const scan = await call('mover.scan');
+    const archived = await call('mover.archived');
+    const preview = await call('mover.preview', { sessionId: id, targetWorkspaceId: 'wid-b' });
+    const backups = await call('mover.backups.list');
+    for (const result of [scan, archived, preview, backups]) assert.equal(result.ok, true, JSON.stringify(result));
+    return [scan.value.items.find((item) => item.sessionId === id).title,
+      archived.value.items.find((item) => item.sessionId === id).title,
+      preview.value.title, backups.value.items.find((item) => item.sessionId === id).title];
+  };
+  assert.deepEqual(await titles(), Array(4).fill('标题保留测试'));
+  ctx.get = (key) => key === 'sessionProjectionCache' ? { table: {
+    get: () => ({ rows: { title: { val: 'Latest live title' } } })
+  } } : undefined;
+  assert.deepEqual(await titles(), Array(4).fill('Latest live title'));
+  ctx.get = () => undefined;
+  writeFileSync(checkpoint, '{broken', 'utf8');
+  assert.deepEqual(await titles(), Array(4).fill('Outdated title'));
+  rmSync(join(storage, 'session_projcache.json'));
+  const scan = await call('mover.scan');
+  assert.equal(scan.value.items.find((item) => item.sessionId === id).title, '未命名会话');
+});
+
 test('mover.unarchive 取消归档：归档集移除、账本不动、无迁移', async () => {
   apply(ctx);
   entityA.record.sessionIds.push('session-aaa');
@@ -1890,6 +1935,40 @@ test('mover.session.delete：manifest 写失败时原样搬回，状态零变化
   assert.ok(!existsSync(recycle) || readdirSync(recycle).length === 0, 'no invisible recycle entries');
 });
 
+test('delete failed rollback preserves relocated archive for recovery instead of removing it', async () => {
+  apply(ctx);
+  entityA.record.sessionIds.push('session-aaa');
+  const source = artifactPath(root, A, 'session-aaa');
+  const bytes = readFileSync(source);
+  // A successful relocation followed by a new destination file blocks move-back.
+  await assert.rejects(deleteSessionToTrash(ctx, { sessionId: 'session-aaa' }, {
+    writeManifestImpl() {
+      mkdirSync(dirname(source), { recursive: true });
+      writeFileSync(source, 'concurrent destination');
+      throw new Error('manifest disk failure');
+    }
+  }), /rollback failed; session files preserved/);
+  const recycle = join(root, 'workspace-mover', 'recycle');
+  const entry = readdirSync(recycle)[0];
+  assert.deepEqual(readFileSync(join(recycle, entry, 'session', source.split(/[\\/]/).at(-1))), bytes);
+  assert.deepEqual(entityA.record.sessionIds, ['session-aaa']);
+});
+
+test('scan distinguishes misplaced membership from unknown archive location without detaching', async () => {
+  apply(ctx);
+  entityB.record.sessionIds.push('session-aaa', 'session-missing');
+  ctx.workspaceRegistry.archivedSessionIds = ['session-missing'];
+  const res = await call('mover.scan');
+  assert.equal(res.ok, true);
+  const found = res.value.ghosts.find((g) => g.sessionId === 'session-aaa');
+  assert.equal(found.status, 'found-elsewhere');
+  assert.deepEqual(found.locations, [artifactPath(root, A, 'session-aaa')]);
+  const unknown = res.value.ghosts.find((g) => g.sessionId === 'session-missing');
+  assert.equal(unknown.status, 'location-unknown');
+  assert.equal(unknown.archived, true);
+  assert.deepEqual(entityB.record.sessionIds, ['session-aaa', 'session-missing']);
+});
+
 test('mover.session.delete：归档会话删除时同步移出归档集', async () => {
   apply(ctx);
   sharedIndex.sessionPaths.set('session-aaa', A);
@@ -1917,6 +1996,7 @@ test('mover.trash.restore：还原到原路径并回写记账、投影标题、
   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.equal(res.value.archived, true, 'recycle restore explicitly reports preserved archived visibility');
   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');