Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

23.0 KB
Raw Blame
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
import { beforeAll, describe, expect, it, vi } from 'vitest';
import { i18n } from '@/i18n';
import {
  buildSessionActionMenu,
  createLatestWriteGuard,
  createPendingWriteTracker,
  createSessionWriteQueue,
  createSwipeRowRegistry,
  pickWriteFields,
  pinToggleAction,
  retryPatchWhileLatest,
  swipeActionPatch,
  writeGuardFields,
} from '@/session/swipeRowRegistry';

// 文案已 i18n 化;固定 zh-CN 让字面量断言与语言环境解耦(全局 mock 默认 en-US)。
beforeAll(async () => {
  await i18n.changeLanguage('zh-CN');
});

describe('createSwipeRowRegistry', () => {
  it('打开新行时自动关掉上一行', () => {
    const registry = createSwipeRowRegistry();
    let closedA = 0;
    registry.onRowOpen('a', () => { closedA += 1; });
    registry.onRowOpen('b', () => undefined);
    expect(closedA).toBe(1);
  });

  it('同一行重复上报不会自己关自己', () => {
    const registry = createSwipeRowRegistry();
    let closedA = 0;
    registry.onRowOpen('a', () => { closedA += 1; });
    registry.onRowOpen('a', () => { closedA += 1; });
    expect(closedA).toBe(0);
  });

  it('迟到的 onRowClose 不抹掉新行记录', () => {
    const registry = createSwipeRowRegistry();
    let closedB = 0;
    registry.onRowOpen('a', () => undefined);
    registry.onRowOpen('b', () => { closedB += 1; });
    // A 的关闭动画回调此刻才到:不应清掉 B 的记录。
    registry.onRowClose('a');
    expect(registry.closeOpenRow()).toBe(true);
    expect(closedB).toBe(1);
  });

  it('closeOpenRow 空注册表返回 false,关闭后再关也是 false', () => {
    const registry = createSwipeRowRegistry();
    expect(registry.closeOpenRow()).toBe(false);
    let closed = 0;
    registry.onRowOpen('a', () => { closed += 1; });
    expect(registry.closeOpenRow()).toBe(true);
    expect(closed).toBe(1);
    expect(registry.closeOpenRow()).toBe(false);
  });

  it('onRowClose 之后 closeOpenRow 不再触发旧 close', () => {
    const registry = createSwipeRowRegistry();
    let closed = 0;
    registry.onRowOpen('a', () => { closed += 1; });
    registry.onRowClose('a');
    expect(registry.closeOpenRow()).toBe(false);
    expect(closed).toBe(0);
  });
});

describe('createLatestWriteGuard', () => {
  it('同 key 同字段后发的写使先发的写过期(置顶在途时取消置顶)', () => {
    const guard = createLatestWriteGuard();
    const pin = guard.begin('s1', ['pinnedAt']);
    const unpin = guard.begin('s1', ['pinnedAt']);
    expect(pin.isLatest()).toBe(false);
    expect(unpin.isLatest()).toBe(true);
  });

  it('同 key 无交集字段的写互不取代(review P1:重命名退避中用户置顶,重命名不得被丢弃)', () => {
    const guard = createLatestWriteGuard();
    const rename = guard.begin('s1', ['title']);
    const pin = guard.begin('s1', ['pinnedAt']);
    expect(rename.isLatest()).toBe(true);
    expect(pin.isLatest()).toBe(true);
  });

  it('部分交集即取代:归档(status+pinnedAt)使在途置顶(pinnedAt)过期,但不动重命名(title)', () => {
    const guard = createLatestWriteGuard();
    const rename = guard.begin('s1', ['title']);
    const pin = guard.begin('s1', ['pinnedAt']);
    const archive = guard.begin('s1', ['status', 'pinnedAt']);
    expect(pin.isLatest()).toBe(false);
    expect(rename.isLatest()).toBe(true);
    expect(archive.isLatest()).toBe(true);
  });

  it('不同 key 互不影响', () => {
    const guard = createLatestWriteGuard();
    const a = guard.begin('a', ['title']);
    const b = guard.begin('b', ['title']);
    expect(a.isLatest()).toBe(true);
    expect(b.isLatest()).toBe(true);
  });

  it('序号单调不回收:新笔终结后再开一笔,不与仍在途的旧笔撞号(review P2 场景)', () => {
    const guard = createLatestWriteGuard();
    // slow pin(seq 1)在途 → unpin(seq 2)成功终结 → archive 开始:
    // archive 必须是最新,pin 绝不能因序号重用被误判为最新(否则迟到回滚复活旧置顶态)。
    const pin = guard.begin('s1', ['pinnedAt']);
    guard.begin('s1', ['pinnedAt']); // unpin,成功并终结(不存在显式清理,登记常驻)
    const archive = guard.begin('s1', ['status', 'pinnedAt']);
    expect(archive.isLatest()).toBe(true);
    expect(pin.isLatest()).toBe(false);
  });
});

describe('pickWriteFields', () => {
  it('只挑本笔字段 + updatedAt,不整对象覆盖', () => {
    const updated = { id: 's1', title: '新名字', pinnedAt: '2026-01-01T00:00:00Z', status: 'active', updatedAt: 'ts' };
    expect(pickWriteFields(updated, ['title'])).toEqual({ title: '新名字', updatedAt: 'ts' });
  });

  it('source 缺字段时跳过,不产出 undefined 键', () => {
    expect(pickWriteFields({ title: 'x' } as { title: string }, ['pinnedAt'])).toEqual({});
  });

  it('updatedAt 单调不回退:旧回包时间戳不高于 floor 时不带 updatedAt(review P2 场景)', () => {
    const staleReply = { title: '新名字', updatedAt: '2026-07-14T00:00:01Z' };
    expect(pickWriteFields(staleReply, ['title'], '2026-07-14T00:00:02Z'))
      .toEqual({ title: '新名字' });
    expect(pickWriteFields(staleReply, ['title'], '2026-07-14T00:00:01Z'))
      .toEqual({ title: '新名字' });
  });

  it('updatedAt 比 floor 新(或无 floor)时正常带上', () => {
    const reply = { title: 'x', updatedAt: '2026-07-14T00:00:03Z' };
    expect(pickWriteFields(reply, ['title'], '2026-07-14T00:00:02Z'))
      .toEqual({ title: 'x', updatedAt: '2026-07-14T00:00:03Z' });
    expect(pickWriteFields(reply, ['title'], null))
      .toEqual({ title: 'x', updatedAt: '2026-07-14T00:00:03Z' });
  });
});

describe('createSessionWriteQueue', () => {
  it('同 key 同字段严格串行:下一笔等上一笔 settle 后才执行', async () => {
    const queue = createSessionWriteQueue();
    const order: string[] = [];
    let releaseA!: () => void;
    const blockedA = new Promise<void>((resolve) => { releaseA = resolve; });
    const p1 = queue.enqueue('s1', ['pinnedAt'], async () => {
      order.push('a-start');
      await blockedA;
      order.push('a-end');
      return 'a';
    });
    const p2 = queue.enqueue('s1', ['pinnedAt'], async () => {
      order.push('b');
      return 'b';
    });
    await vi.waitFor(() => expect(order).toEqual(['a-start']));
    releaseA();
    await expect(p1).resolves.toBe('a');
    await expect(p2).resolves.toBe('b');
    expect(order).toEqual(['a-start', 'a-end', 'b']);
  });

  it('上一笔失败不阻断下一笔,失败原样抛给自己的调用方', async () => {
    const queue = createSessionWriteQueue();
    const p1 = queue.enqueue('s1', ['pinnedAt'], () => Promise.reject(new Error('boom')));
    const p2 = queue.enqueue('s1', ['pinnedAt'], () => Promise.resolve('ok'));
    await expect(p1).rejects.toThrow('boom');
    await expect(p2).resolves.toBe('ok');
  });

  it('不同 key 互不排队', async () => {
    const queue = createSessionWriteQueue();
    let releaseA!: () => void;
    const blockedA = new Promise<void>((resolve) => { releaseA = resolve; });
    const order: string[] = [];
    const p1 = queue.enqueue('s1', ['title'], async () => { await blockedA; order.push('s1'); });
    const p2 = queue.enqueue('s2', ['title'], async () => { order.push('s2'); });
    await p2;
    expect(order).toEqual(['s2']);
    releaseA();
    await p1;
  });

  it('同 key 无交集字段并行出网:归档不被在途重命名拖住(review P2 场景)', async () => {
    const queue = createSessionWriteQueue();
    let releaseRename!: () => void;
    const blocked = new Promise<void>((resolve) => { releaseRename = resolve; });
    const order: string[] = [];
    const pRename = queue.enqueue('s1', ['title'], async () => { await blocked; order.push('rename'); });
    const pArchive = queue.enqueue('s1', ['status', 'pinnedAt'], async () => { order.push('archive'); });
    // 归档(status+pinnedAt)与重命名(title)无交集:不等重命名,立即执行
    await pArchive;
    expect(order).toEqual(['archive']);
    releaseRename();
    await pRename;
  });

  it('部分交集仍排队:置顶在途时归档(共享 pinnedAt 道)等它 settle', async () => {
    const queue = createSessionWriteQueue();
    let releasePin!: () => void;
    const blocked = new Promise<void>((resolve) => { releasePin = resolve; });
    const order: string[] = [];
    const pPin = queue.enqueue('s1', ['pinnedAt'], async () => { await blocked; order.push('pin'); });
    const pArchive = queue.enqueue('s1', ['status', 'pinnedAt'], async () => { order.push('archive'); });
    await Promise.resolve();
    expect(order).toEqual([]);
    releasePin();
    await pPin;
    await pArchive;
    expect(order).toEqual(['pin', 'archive']);
  });

  it('组合场景(review P1):同字段旧笔退避中被取代 → 让位,新笔随后出网,发出序 = 操作序', async () => {
    const guard = createLatestWriteGuard();
    const queue = createSessionWriteQueue();
    const sent: string[] = [];
    // 置顶 A:首发失败进退避
    const pin = guard.begin('s1', ['pinnedAt']);
    const sendPin = vi.fn().mockImplementation(() => {
      sent.push('pin');
      return Promise.reject(Object.assign(new Error('not connected'), { code: 'NOT_CONNECTED' }));
    });
    const pA = queue.enqueue('s1', ['pinnedAt'], () => retryPatchWhileLatest(pin.isLatest, sendPin));
    // 等 A 的首发真实出网(用户点击当刻队列为空,首发立即发生)
    await vi.waitFor(() => expect(sendPin).toHaveBeenCalledTimes(1));
    // 用户随即取消置顶 B:同字段新写登记(A 过期),排到 A 之后
    const unpin = guard.begin('s1', ['pinnedAt']);
    const sendUnpin = vi.fn().mockImplementation(() => {
      sent.push('unpin');
      return Promise.resolve('ok');
    });
    const pB = queue.enqueue('s1', ['pinnedAt'], () => retryPatchWhileLatest(unpin.isLatest, sendUnpin));
    // A 在下一次重发前因 isLatest 屏障让位;B 等 A settle 后出网并成功
    await expect(pA).resolves.toBeNull();
    await expect(pB).resolves.toBe('ok');
    expect(sent).toEqual(['pin', 'unpin']);
    expect(sendPin).toHaveBeenCalledTimes(1);
  });

  it('组合场景(review P1 二连):无交集字段互不取代——重命名退避中置顶,两笔都落地', async () => {
    const guard = createLatestWriteGuard();
    const queue = createSessionWriteQueue();
    const sent: string[] = [];
    // 重命名 A:首发失败进退避,随后重试成功
    const rename = guard.begin('s1', ['title']);
    const sendRename = vi.fn()
      .mockImplementationOnce(() => {
        sent.push('rename-1');
        return Promise.reject(Object.assign(new Error('not connected'), { code: 'NOT_CONNECTED' }));
      })
      .mockImplementationOnce(() => {
        sent.push('rename-2');
        return Promise.resolve('renamed');
      });
    const pA = queue.enqueue('s1', ['title'], () => retryPatchWhileLatest(rename.isLatest, sendRename));
    await vi.waitFor(() => expect(sendRename).toHaveBeenCalledTimes(1));
    // 用户在重命名退避期间置顶:字段无交集,重命名不得被丢弃;置顶并行出网不等重命名
    const pin = guard.begin('s1', ['pinnedAt']);
    const sendPin = vi.fn().mockImplementation(() => {
      sent.push('pin');
      return Promise.resolve('pinned');
    });
    const pB = queue.enqueue('s1', ['pinnedAt'], () => retryPatchWhileLatest(pin.isLatest, sendPin));
    await expect(pB).resolves.toBe('pinned');
    await expect(pA).resolves.toBe('renamed');
    // 分道后置顶不等重命名的退避,先出网;重命名随后重试成功,两笔都落地
    expect(sent).toEqual(['rename-1', 'pin', 'rename-2']);
  });

  it('组合场景(review P2):删除取代全字段写序——退避中的重命名让位,删除并行出网', async () => {
    const guard = createLatestWriteGuard();
    const queue = createSessionWriteQueue();
    const sent: string[] = [];
    // 重命名 A:首发失败进退避
    const rename = guard.begin('s1', writeGuardFields({ title: '新名' }));
    const sendRename = vi.fn().mockImplementation(() => {
      sent.push('rename');
      return Promise.reject(Object.assign(new Error('not connected'), { code: 'NOT_CONNECTED' }));
    });
    const pA = queue.enqueue('s1', ['title'], () => retryPatchWhileLatest(rename.isLatest, sendRename));
    await vi.waitFor(() => expect(sendRename).toHaveBeenCalledTimes(1));
    // 用户删除该会话:终态取代全字段,重命名立即过期;删除走 status 道并行出网
    const del = guard.begin('s1', writeGuardFields({ status: 'deleted' }));
    const sendDelete = vi.fn().mockImplementation(() => {
      sent.push('delete');
      return Promise.resolve('deleted');
    });
    const pB = queue.enqueue('s1', ['status'], () => retryPatchWhileLatest(del.isLatest, sendDelete));
    await expect(pB).resolves.toBe('deleted');
    // 重命名在下一次重发前发现已被终态取代,让位返回 null,不再重发、不弹「重命名失败」
    await expect(pA).resolves.toBeNull();
    expect(sendRename).toHaveBeenCalledTimes(1);
    expect(sent).toEqual(['rename', 'delete']);
  });
});

describe('createPendingWriteTracker', () => {
  it('在途字段的 push 回流被遮蔽,release 后恢复透传(review P2:pin 在途时 unpin,旧 push 不滚回)', () => {
    const tracker = createPendingWriteTracker();
    const release = tracker.track('s1', ['pinnedAt']);
    // 旧写(pin)的 push 回流:pinnedAt 在途 → 被遮;无关字段照常透传
    expect(tracker.filterPatch('s1', { pinnedAt: '2026-01-01T00:00:00Z', title: 'x' }))
      .toEqual({ title: 'x' });
    // 全部字段都在途 → 空对象(调用方跳过应用)
    expect(tracker.filterPatch('s1', { pinnedAt: null })).toEqual({});
    release();
    expect(tracker.filterPatch('s1', { pinnedAt: null })).toEqual({ pinnedAt: null });
  });

  it('被遮蔽的外部 push 留痕:失败回滚方可 consume 判定 reseed(review P1 场景)', () => {
    const tracker = createPendingWriteTracker();
    const release = tracker.track('s1', ['title']);
    // 手机重命名在途,桌面端并发改名的 push 被遮
    expect(tracker.filterPatch('s1', { title: 'B' })).toEqual({});
    // 本机写失败回滚:consume 命中 → 调用方 reseed;读后即清,不重复触发
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(true);
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(false);
    release();
  });

  it('echo push(值与本机乐观值相同)遮蔽但不留痕:成功写不误触发 reseed(review P2)', () => {
    const tracker = createPendingWriteTracker();
    const release = tracker.track('s1', ['title']);
    // 本笔自己的 echo push 先于回包到达:值 = 本机乐观值 → 遮蔽但零信息
    expect(tracker.filterPatch('s1', { title: '新名' }, { title: '新名' })).toEqual({});
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(false);
    // 外部并发写(不同值)→ 留痕
    expect(tracker.filterPatch('s1', { title: '外部改名' }, { title: '新名' })).toEqual({});
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(true);
    release();
  });

  it('noteMaskedValue(全量对账 overlay 留痕):同值不记,异值记', () => {
    const tracker = createPendingWriteTracker();
    const release = tracker.track('s1', ['title']);
    tracker.noteMaskedValue('s1', 'title', '新名', '新名');
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(false);
    tracker.noteMaskedValue('s1', 'title', '外部改名', '新名');
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(true);
    release();
  });

  it('遮蔽标记随计数归零清除,不污染下一笔写;无遮蔽时 consume 为 false', () => {
    const tracker = createPendingWriteTracker();
    const r1 = tracker.track('s1', ['title']);
    tracker.filterPatch('s1', { title: 'B' });
    r1(); // 成功分支不 consume,release 归零清残留
    const r2 = tracker.track('s1', ['title']);
    expect(tracker.consumeMaskedPush('s1', ['title'])).toBe(false);
    r2();
  });

  it('同字段多笔在途按计数释放;release 幂等;不同 key 互不影响', () => {
    const tracker = createPendingWriteTracker();
    const r1 = tracker.track('s1', ['pinnedAt']);
    const r2 = tracker.track('s1', ['pinnedAt']);
    r1();
    r1(); // 幂等:重复调用不把 r2 的登记也放掉
    expect(tracker.filterPatch('s1', { pinnedAt: null })).toEqual({});
    expect(tracker.filterPatch('s2', { pinnedAt: null })).toEqual({ pinnedAt: null });
    r2();
    expect(tracker.filterPatch('s1', { pinnedAt: null })).toEqual({ pinnedAt: null });
  });
});

describe('writeGuardFields', () => {
  it('delete / archive(移行写)取代全部元数据字段(review P2:归档后在途重命名让位)', () => {
    expect(writeGuardFields({ status: 'deleted' }).sort()).toEqual(['pinnedAt', 'status', 'title']);
    expect(writeGuardFields({ status: 'archived', pinnedAt: null } as { status: string }).sort())
      .toEqual(['pinnedAt', 'status', 'title']);
  });

  it('restore / 置顶 / 重命名(不移行)按 patch 自身字段', () => {
    expect(writeGuardFields({ status: 'active' })).toEqual(['status']);
    expect(writeGuardFields({ pinnedAt: null })).toEqual(['pinnedAt']);
    expect(writeGuardFields({ title: 'x' })).toEqual(['title']);
  });
});

describe('retryPatchWhileLatest', () => {
  it('始终最新:瞬时失败后重试直到成功,返回结果', async () => {
    const send = vi.fn()
      .mockRejectedValueOnce(Object.assign(new Error('not online within 1500ms'), { code: 'NOT_CONNECTED' }))
      .mockResolvedValueOnce('ok');
    await expect(retryPatchWhileLatest(() => true, send)).resolves.toBe('ok');
    expect(send).toHaveBeenCalledTimes(2);
  });

  it('退避期间被同字段后续写取代:不再重发旧 patch,返回 null 让位(review P1 场景)', async () => {
    const guard = createLatestWriteGuard();
    const pin = guard.begin('s1', ['pinnedAt']);
    const send = vi.fn().mockImplementation(() => {
      // 首发失败;失败后用户在同会话执行了取消置顶(同字段新写登记,旧笔过期)
      guard.begin('s1', ['pinnedAt']);
      return Promise.reject(Object.assign(new Error('not connected'), { code: 'NOT_CONNECTED' }));
    });
    await expect(retryPatchWhileLatest(pin.isLatest, send)).resolves.toBeNull();
    expect(send).toHaveBeenCalledTimes(1);
  });

  it('发起前就已过期:一次都不发,返回 null', async () => {
    const send = vi.fn();
    await expect(retryPatchWhileLatest(() => false, send)).resolves.toBeNull();
    expect(send).not.toHaveBeenCalled();
  });

  it('非瞬时错误照常抛出,不吞', async () => {
    const send = vi.fn().mockRejectedValue(new Error('[REMOTE_DISABLED] disabled'));
    await expect(retryPatchWhileLatest(() => true, send)).rejects.toThrow('disabled');
    expect(send).toHaveBeenCalledTimes(1);
  });

  it('发送点断言(preSend 语义):重连等待期间被取代 → 等待后就地让位,不真正出网(review P2 场景)', async () => {
    const guard = createLatestWriteGuard();
    const pin = guard.begin('s1', ['pinnedAt']);
    let reallySent = 0;
    // 模拟 sendInvoke:先经历重连等待(此期间同字段新写登记),再到发送点调用断言
    const send = vi.fn().mockImplementation(async (assertStillLatest: () => void) => {
      await new Promise((resolve) => setTimeout(resolve, 10)); // ensureOnlineForRequest 等待
      guard.begin('s1', ['pinnedAt']); // 等待期间用户取消置顶
      assertStillLatest(); // preSend:应在此抛让位哨兵
      reallySent += 1;
      return 'ok';
    });
    await expect(retryPatchWhileLatest(pin.isLatest, send)).resolves.toBeNull();
    expect(send).toHaveBeenCalledTimes(1);
    expect(reallySent).toBe(0);
  });
});

describe('pinToggleAction', () => {
  it('未置顶 → 置顶', () => {
    expect(pinToggleAction(null)).toEqual({ action: 'pin', label: '置顶' });
    expect(pinToggleAction(undefined)).toEqual({ action: 'pin', label: '置顶' });
  });

  it('已置顶 → 取消置顶', () => {
    expect(pinToggleAction('2026-07-07T00:00:00.000Z')).toEqual({ action: 'unpin', label: '取消置顶' });
  });
});

describe('buildSessionActionMenu', () => {
  it('菜单顺序固定:重命名 → 置顶切换 → 归档 → 删除,删除标 destructive', () => {
    const menu = buildSessionActionMenu(null);
    expect(menu.map((item) => item.action)).toEqual(['rename', 'pin', 'archive', 'delete']);
    expect(menu[3]).toMatchObject({ label: '删除任务', destructive: true });
    expect(menu.filter((item) => item.destructive)).toHaveLength(1);
  });

  it('已置顶会话的第二项是取消置顶', () => {
    const menu = buildSessionActionMenu('2026-07-07T00:00:00.000Z');
    expect(menu[1]).toEqual({ action: 'unpin', label: '取消置顶' });
  });
});

describe('swipeActionPatch', () => {
  it('pin 产出 ISO pinnedAt', () => {
    const now = Date.UTC(2026, 6, 7, 12, 0, 0);
    expect(swipeActionPatch('pin', now)).toEqual({ pinnedAt: new Date(now).toISOString() });
  });

  it('unpin 清空 pinnedAt', () => {
    expect(swipeActionPatch('unpin')).toEqual({ pinnedAt: null });
  });

  it('archive 同时清置顶(归档置顶会话不得遗留置顶态)', () => {
    expect(swipeActionPatch('archive')).toEqual({ status: 'archived', pinnedAt: null });
  });

  it('delete 是软删标记', () => {
    expect(swipeActionPatch('delete')).toEqual({ status: 'deleted' });
  });
});

describe('会话元数据写的设备解析(首页与会话页同口径)', () => {
  const read = (path: string) => readFileSync(resolve(process.cwd(), path), 'utf8').replace(/\r\n/g, '\n');

  it('会话页乐观 patch / 对账 / 回滚落物理 shard,出网沿用路由设备', () => {
    const source = read('app/sessions/[sessionId].tsx');
    const start = source.indexOf('const patchSessionMeta = useCallback((');
    const block = source.slice(start, source.indexOf('const previewRewindAtMessage', start));
    expect(block).toContain('resolveSessionWriteDevices(sessionId, session, deviceId)');
    expect(block).toContain('remoteSessionStore.applySessionPatch(shardId, sessionId, patch as Partial<RemoteSession>);');
    expect(block).toContain('remoteSessionStore.upsertDeviceSession(shardId, shardName, session);');
    expect(block).toContain('remoteSessionStore.requestReseed(shardId);');
    expect(block).toMatch(/invoke<RemoteSession>\(\s*rpcDeviceId,/);
    // 路由 id 不再直接当 shard 用。
    expect(block).not.toMatch(/applySessionPatch\(\s*deviceId,/);
    expect(block).not.toContain('upsertDeviceSession(deviceId,');
    // 整行回滚前先释放本笔在途登记,否则会被 upsertDeviceSession 的在途保护挡掉。
    expect(block.indexOf('releasePending();')).toBeLessThan(block.indexOf('upsertDeviceSession(shardId'));
  });

  it('首页 / 设备页写路径共用同一解析,回滚同样先释放在途登记', () => {
    const source = read('src/session/useSessionListActions.ts');
    // PR #6863:详情归档也复用此入口,必须保留路由 RPC 设备覆盖,
    // 乐观写与回滚仍使用解析出的物理 shard(跨文件设备路由 guard)。
    expect(source).toContain('resolveSessionWriteDevices(session.id, session, preferredRpcDeviceId)');
    expect(source.indexOf('releasePending();')).toBeLessThan(source.indexOf('upsertDeviceSession(shardId'));
  });
});