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。

64.9 KB
Raw Blame
/**
 * remoteProjectsStore — vitest 单测(push 驱动纯镜像)
 *
 * 覆盖 device-link 控制端内存层的核心不变量:
 *  - setDeviceSessions:打 device-link origin 标记 + 合并扁平列表 + sessionId→deviceId 注册 + 引用稳定
 *  - active/archived 分桶快照互不覆盖,applyPatch 在状态桶间迁移 / deleted 移出分片
 *  - epoch:旧 snapshot 不覆盖新 snapshot(乱序保护)
 *  - markDeviceDisconnected:断线保留快照 + 在线索引清理;removeDevice / clear:明确移除时清理
 */

import { beforeEach, describe, expect, it, vi } from 'vitest';

import {
  remoteProjectsStore,
  getSessionDeviceId,
  retryRemoteSessionBootstrap,
  retryRemoteSessionStatus,
  requestRemoteSessionStatus,
  setRemoteReseedImpl,
  setRemoteSessionBootstrapRetryImpl,
  subscribeRemoteSessionRemoval,
} from '@/features/device-link/remoteProjectsStore';
import type { Session } from '@/lib/ccAgent.types';

/** 造一个最小可用 Session(store 只存/透传,不校验字段)。 */
function mk(id: string, partial: Partial<Session> = {}): Session {
  return {
    id,
    userId: 'u',
    source: partial.source,
    title: partial.title ?? id,
    workingDir: partial.workingDir ?? `/proj/${id}`,
    workspaceKind: 'project',
    model: partial.model ?? 'gpt-5.4',
    effort: (partial.effort ?? 'medium') as Session['effort'],
    permissionMode: (partial.permissionMode ?? 'default') as Session['permissionMode'],
    sdkSessionId: null,
    totalTokenUsage: 0,
    totalCostUsd: 0,
    contextTokens: 0,
    contextWindow: 0,
    fastMode: partial.fastMode ?? false,
    clearedAt: null,
    pinnedAt: partial.pinnedAt ?? null,
    userSendAt: '2026-01-01T00:00:00.000Z',
    status: partial.status ?? 'active',
    agentKind: partial.agentKind ?? 'cc',
    // fork 占位判据要看它(与被控端 getOverwritableAutoTitle 同一条规则)。
    parentSessionId: partial.parentSessionId ?? null,
    extraDirs: [],
    createdAt: '2026-01-01T00:00:00.000Z',
    updatedAt: '2026-01-01T00:00:00.000Z',
  };
}

describe('remoteProjectsStore', () => {
  // Unit, #7469: a two-row snapshot changing one task must not invalidate the
  // other sidebar row's memo. Existing tests cover whole-snapshot no-ops, not
  // per-row UI identity or its separation from in-flight detail-read fences.
  it('reuses unchanged visible rows without reusing authoritative snapshot identities', () => {
    remoteProjectsStore.setDeviceSessions('host', 'Host', [mk('same'), mk('changed')]);
    remoteProjectsStore.setDeviceSessions('other', 'Other', [mk('same')]);
    const before = remoteProjectsStore.getVisibleMergedRemoteSessions();
    const rawBefore = remoteProjectsStore.getDeviceSessions('host');
    const read = remoteProjectsStore.captureSessionRead('host', 'same');

    remoteProjectsStore.setDeviceSessions('host', 'Host', [
      mk('changed', { title: 'Updated title' }), mk('same'),
    ]);

    const visible = remoteProjectsStore.getVisibleMergedRemoteSessions();
    expect(visible.map(row => [row.deviceLinkDeviceId, row.id, row.title])).toEqual([
      ['host', 'changed', 'Updated title'], ['host', 'same', 'same'], ['other', 'same', 'same'],
    ]);
    expect(visible[0]).not.toBe(before[1]);
    expect(visible[1]).toBe(before[0]);
    expect(visible[2]).toBe(before[2]);
    expect(remoteProjectsStore.getDeviceSessions('host')[1]).not.toBe(rawBefore[0]);
    expect(read()).toBe(false);
    const freshRead = remoteProjectsStore.captureSessionRead('host', 'same');
    expect(freshRead()).toBe(true);
    remoteProjectsStore.applyPatch('host', 'same', { lastActivityAt: '2026-01-02T00:00:00.000Z' });
    expect(freshRead()).toBe(true);
    expect(freshRead.mergeActivity(mk('same')).lastActivityAt).toBe('2026-01-02T00:00:00.000Z');
  });

  // Unit, #7469: structural sharing must compare nested payloads too, and must
  // not resurrect removed rows or hide connection changes behind a UI cache.
  it('updates nested visible data and retires rows on disconnect, deletion and clear', () => {
    const row = { ...mk('a'), extraDirs: ['/first'] };
    remoteProjectsStore.setDeviceSessions('host', 'Host', [row, mk('b')]);
    const before = remoteProjectsStore.getVisibleMergedRemoteSessions();
    remoteProjectsStore.setDeviceSessions('host', 'Host', [
      { ...row, extraDirs: ['/second'] }, mk('b'),
    ]);
    const changed = remoteProjectsStore.getVisibleMergedRemoteSessions();
    expect(changed[0]?.extraDirs).toEqual(['/second']);
    expect(changed[0]).not.toBe(before[0]);
    expect(changed[1]).toBe(before[1]);
    remoteProjectsStore.markDeviceDisconnected('host');
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions().map(s => s.deviceLinkConnectionStatus))
      .toEqual(['disconnected', 'disconnected']);
    remoteProjectsStore.setDeviceSessions('host', 'Renamed host', [row]);
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()).toMatchObject([
      { id: 'a', deviceLinkDeviceName: 'Renamed host', deviceLinkConnectionStatus: 'connected' },
    ]);
    remoteProjectsStore.applyPatch('host', 'a', { status: 'deleted' });
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()).toEqual([]);
    remoteProjectsStore.setDeviceSessions('host', 'Host', [row]);
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()[0]).not.toBe(before[0]);
    remoteProjectsStore.clear();
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()).toEqual([]);
  });

  it('preserves an activity push while accepting an in-flight detail read', () => {
    const session = mk('handoff');
    remoteProjectsStore.setDeviceSessions('host', 'Host', [session]);
    const read = remoteProjectsStore.captureSessionRead('host', session.id);
    const lastActivityAt = '2026-01-02T00:00:00.000Z';
    remoteProjectsStore.applyPatch('host', session.id, { lastActivityAt });
    expect(read()).toBe(true);
    expect(read.mergeActivity(session)).toMatchObject({
      lastActivityAt,
      userSendAt: session.userSendAt,
    });
  });
  // Unit, #6529: ordinary lists deliberately omit side chats; a list refresh
  // must not erase detail loaded for an opened full-page follow-up.
  it('retains a hidden side chat across ordinary snapshots until an explicit deletion', () => {
    remoteProjectsStore.mergeDeviceSessions('host', 'Host', [mk('parent'), mk('child', { source: 'side-chat', parentSessionId: 'parent' })]);
    remoteProjectsStore.setDeviceSessions('host', 'Host', [mk('parent')]);
    expect(remoteProjectsStore.getDeviceSessions('host').map(row => row.id)).toEqual(['parent', 'child']);
    remoteProjectsStore.applyPatch('host', 'child', { model: 'new-model' });
    expect(remoteProjectsStore.getDeviceSessions('host').find(row => row.id === 'child')?.model).toBe('new-model');
    remoteProjectsStore.applyPatch('host', 'child', { status: 'deleted' });
    expect(remoteProjectsStore.getDeviceSessions('host').map(row => row.id)).toEqual(['parent']);
  });
  it('hides Make tasks from visible snapshots while preserving raw mirrors and origins', () => {
    remoteProjectsStore.clear();
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
      mk('make', { source: 'cindy-make' }),
      mk('merge', { source: 'cindy-make-merge' }),
      mk('ordinary', { source: 'desktop' }),
    ]);
    expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(3);
    expect(getSessionDeviceId('make')).toBe('dev-B');
    const visible = remoteProjectsStore.getVisibleMergedRemoteSessions();
    expect(visible.map(session => session.id)).toEqual(['ordinary']);
    remoteProjectsStore.applyPatch('dev-B', 'make', { title: 'Hidden update' });
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()).toBe(visible);
    remoteProjectsStore.applyPatch('dev-B', 'ordinary', { source: 'cindy-make' });
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()).toEqual([]);
    remoteProjectsStore.clear();
    expect(remoteProjectsStore.getVisibleMergedRemoteSessions()).toEqual([]);
  });
  beforeEach(() => {
    setRemoteReseedImpl(null);
    setRemoteSessionBootstrapRetryImpl(null);
    remoteProjectsStore.clear();
    remoteProjectsStore.__resetPendingTitlePreviewForTest();
    // 钉子刻意不随 clear() 消失(见 pinnedOrigins),所以测试间必须显式清,否则会串用例。
    remoteProjectsStore.__resetPinnedOriginsForTest();
  });

  it('invalidates and reloads the first snapshot when a tag catalog push arrives first', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    const epoch = remoteProjectsStore.nextSnapshotEpoch('dev-A');
    const otherEpoch = remoteProjectsStore.nextSnapshotEpoch('dev-B');
    remoteProjectsStore.applyTagCatalog('dev-A', []);
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', epoch)).toBe(false);
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-B', otherEpoch)).toBe(true);
    expect(reseed.mock.calls).toEqual([['dev-A', 'active']]);
    const replacementEpoch = remoteProjectsStore.nextSnapshotEpoch('dev-A');
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', replacementEpoch)).toBe(true);
  });

  it('reloads an in-flight first archived snapshot without loading untouched history', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    remoteProjectsStore.applyTagCatalog('dev-A', []);
    expect(reseed.mock.calls).toEqual([['dev-A', 'active']]);
    reseed.mockClear();
    remoteProjectsStore.markSessionStatusLoading('dev-A', 'archived');
    const epoch = remoteProjectsStore.nextSnapshotEpoch('dev-A', 'archived');
    remoteProjectsStore.applyTagCatalog('dev-A', []);
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', epoch, 'archived')).toBe(false);
    expect(reseed.mock.calls).toEqual([['dev-A', 'active'], ['dev-A', 'archived']]);
  });

  it('requeues both loaded buckets after invalidating a refresh that may contain new tasks', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('archived', { status: 'archived' })], 'archived');
    const activeEpoch = remoteProjectsStore.nextSnapshotEpoch('dev-A');
    const archivedEpoch = remoteProjectsStore.nextSnapshotEpoch('dev-A', 'archived');
    remoteProjectsStore.applyTagCatalog('dev-A', []);
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', activeEpoch)).toBe(false);
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', archivedEpoch, 'archived')).toBe(false);
    expect(reseed.mock.calls).toEqual([['dev-A', 'active'], ['dev-A', 'archived']]);
  });

  it('把用户的任务重试动作交给 listing tier 注册的 bootstrap 实现', () => {
    const retry = vi.fn();
    setRemoteSessionBootstrapRetryImpl(retry);

    retryRemoteSessionBootstrap('dev-B');

    expect(retry).toHaveBeenCalledWith('dev-B');
    expect(retry).toHaveBeenCalledTimes(1);
  });

  describe('origin 钉子(pinSessionOrigin)', () => {
    // #7115: a copied task can exist on multiple computers with the same id.
    // A link's explicit origin must survive both existing and later snapshots.
    it('keeps an explicit origin ahead of same-id snapshots from another computer', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('same', { title: 'B task' })]);
      remoteProjectsStore.setDeviceSessions('dev-C', 'C', [mk('same', { title: 'C task' })]);
      remoteProjectsStore.pinSessionOrigin('dev-B', 'same');
      expect(getSessionDeviceId('same')).toBe('dev-B');
      expect(remoteProjectsStore.getSessionTitle('same')).toBe('B task');
      remoteProjectsStore.setDeviceSessions('dev-C', 'C', [mk('same', { title: 'C changed' })]);
      expect(getSessionDeviceId('same')).toBe('dev-B');
      expect(remoteProjectsStore.getSessionTitle('same')).toBe('B task');
      remoteProjectsStore.pinSessionOrigin('dev-C', 'same');
      expect(getSessionDeviceId('same')).toBe('dev-C');
      expect(remoteProjectsStore.getSessionTitle('same')).toBe('C changed');
    });

    it('does not borrow another computer\'s title while the pinned snapshot is unavailable', () => {
      remoteProjectsStore.setDeviceSessions('dev-C', 'C', [mk('same', { title: 'C task' })]);
      remoteProjectsStore.pinSessionOrigin('dev-B', 'same');
      expect(getSessionDeviceId('same')).toBe('dev-B');
      expect(remoteProjectsStore.getSessionTitle('same')).toBeNull();
    });

    it('远程新建会话后 origin 立刻可判定,即使权威快照还没到', () => {
      remoteProjectsStore.pinSessionOrigin('dev-B', 'new-1');
      // 传输层据此走隧道 —— 没有钉子时它返回 undefined,首条消息就发给本机 maker。
      expect(getSessionDeviceId('new-1')).toBe('dev-B');
    });

    it('钉子只影响 origin 判定,不伪造会话行', () => {
      remoteProjectsStore.pinSessionOrigin('dev-B', 'new-1');
      // 会话进列表仍等权威快照:侧边栏不该出现一条字段全靠猜的行。
      expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(0);
      expect(remoteProjectsStore.getDeviceSessions('dev-B')).toHaveLength(0);
    });

    it('权威快照到达后归属不变,且该会话正常进入列表', () => {
      remoteProjectsStore.pinSessionOrigin('dev-B', 'new-1');
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('new-1'), mk('s2')]);
      expect(getSessionDeviceId('new-1')).toBe('dev-B');
      expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(2);
    });

    it('钉子跨 clear() 存活:relay 瞬时重连不该让远程会话看起来像本机会话', () => {
      remoteProjectsStore.pinSessionOrigin('dev-B', 'new-1');
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('new-1')]);
      remoteProjectsStore.clear();
      // 分片没了(镜像随链路重建),但归属仍然成立 —— 否则重建窗口里的操作会落到本机执行。
      expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(0);
      expect(getSessionDeviceId('new-1')).toBe('dev-B');
    });

    it('重复钉同一条是幂等的', () => {
      remoteProjectsStore.pinSessionOrigin('dev-B', 'new-1');
      const before = remoteProjectsStore.getMergedRemoteSessions();
      remoteProjectsStore.pinSessionOrigin('dev-B', 'new-1');
      expect(remoteProjectsStore.getMergedRemoteSessions()).toBe(before);
      expect(getSessionDeviceId('new-1')).toBe('dev-B');
    });
  });

  it('stamps device-link origin, merges sessions, and registers sessionId→deviceId', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'Bob Mac', [mk('s1'), mk('s2')]);
    const merged = remoteProjectsStore.getMergedRemoteSessions();
    expect(merged).toHaveLength(2);
    for (const s of merged) {
      expect(s.deviceLinkDeviceId).toBe('dev-B');
      expect(s.deviceLinkDeviceName).toBe('Bob Mac');
      expect(s.deviceLinkConnectionStatus).toBe('connected');
    }
    expect(getSessionDeviceId('s1')).toBe('dev-B');
    expect(getSessionDeviceId('unknown')).toBeUndefined();
  });

  it('merges multiple devices and keeps origin per device', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);
    remoteProjectsStore.setDeviceSessions('dev-C', 'C', [mk('s2')]);
    expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(2);
    expect(getSessionDeviceId('s1')).toBe('dev-B');
    expect(getSessionDeviceId('s2')).toBe('dev-C');
  });

  it('active / archived 权威快照只替换自己的状态桶', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('active-1')], 'active');
    remoteProjectsStore.setDeviceSessions(
      'dev-B',
      'B',
      [mk('archived-1', { status: 'archived' })],
      'archived',
    );

    expect(remoteProjectsStore.hasLoadedSessionStatus('dev-B', 'active')).toBe(true);
    expect(remoteProjectsStore.hasLoadedSessionStatus('dev-B', 'archived')).toBe(true);
    expect([...remoteProjectsStore.getArchivedLoadedDeviceIds()]).toEqual(['dev-B']);
    expect(remoteProjectsStore.getDeviceSessions('dev-B', 'active').map((s) => s.id)).toEqual([
      'active-1',
    ]);
    expect(remoteProjectsStore.getDeviceSessions('dev-B', 'archived').map((s) => s.id)).toEqual([
      'archived-1',
    ]);

    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('active-2')], 'active');
    expect(remoteProjectsStore.getMergedRemoteSessions().map((s) => s.id)).toEqual([
      'active-2',
      'archived-1',
    ]);
  });

  it('归档桶按设备+状态去重,active 在途不拦请求且成功只清 archived loading', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('active-1')]);
    remoteProjectsStore.markBootstrapLoading('dev-B');

    requestRemoteSessionStatus('dev-B', 'archived');
    requestRemoteSessionStatus('dev-B', 'archived');
    expect(reseed).toHaveBeenCalledTimes(1);
    expect(reseed).toHaveBeenCalledWith('dev-B', 'archived');
    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'active')).toBe(true);
    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'archived')).toBe(true);
    expect([...remoteProjectsStore.getBootstrapLoadingDeviceIds()]).toEqual(['dev-B']);

    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [], 'archived');
    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'active')).toBe(true);
    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'archived')).toBe(false);
    expect([...remoteProjectsStore.getBootstrapLoadingDeviceIds()]).toEqual(['dev-B']);
    requestRemoteSessionStatus('dev-B', 'archived');
    expect(reseed).toHaveBeenCalledTimes(1);
  });

  it('归档桶失败后显示失败态,并允许下一次按需请求自动重试', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('active-1')]);

    requestRemoteSessionStatus('dev-B', 'archived');
    remoteProjectsStore.markSessionStatusFailed('dev-B', 'archived');

    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'archived')).toBe(false);
    expect(remoteProjectsStore.getBootstrapFailedDeviceIds().size).toBe(0);
    expect([...remoteProjectsStore.getArchivedFailedDeviceIds()]).toEqual(['dev-B']);

    requestRemoteSessionStatus('dev-B', 'archived');

    expect(reseed).toHaveBeenCalledTimes(2);
    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'archived')).toBe(true);
    expect(remoteProjectsStore.getArchivedFailedDeviceIds().size).toBe(0);
  });

  it('已加载过 archived 桶后,失败恢复仍会强制重新拉取', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [], 'archived');
    remoteProjectsStore.markSessionStatusFailed('dev-B', 'archived');

    retryRemoteSessionStatus('dev-B', 'archived');

    expect(reseed).toHaveBeenCalledWith('dev-B', 'archived');
    expect(remoteProjectsStore.isSessionStatusLoading('dev-B', 'archived')).toBe(true);
    expect(remoteProjectsStore.getArchivedFailedDeviceIds().size).toBe(0);
  });

  it('snapshot reference is stable across no-op (useSyncExternalStore safety)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);
    const a = remoteProjectsStore.getMergedRemoteSessions();
    const b = remoteProjectsStore.getMergedRemoteSessions();
    expect(a).toBe(b);
  });

  describe('applyPatch(push 驱动镜像)', () => {
    it('就地幂等合并字段(title / pinnedAt / model)', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { model: 'gpt-5.4' })]);
      remoteProjectsStore.applyPatch('dev-B', 's1', { title: 'New', model: 'opus-4-8' });
      const s = remoteProjectsStore.getMergedRemoteSessions().find((x) => x.id === 's1')!;
      expect(s.title).toBe('New');
      expect(s.model).toBe('opus-4-8');
      expect(getSessionDeviceId('s1')).toBe('dev-B'); // origin 标记不丢
    });

    it('合并被控端运行时模型投影并同步有效设置轴', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);
      remoteProjectsStore.applyPatch('dev-B', 's1', {
        model: 'gpt-runtime',
        providerId: 'openai',
        effort: 'xhigh',
        fastMode: true,
        runtimeGeneration: 3,
        runtimeBaseline: {
          agentKind: 'codex',
          model: 'gpt-baseline',
          providerId: 'xd',
          effort: 'high',
          fastMode: false,
        },
        runtimeEffective: {
          agentKind: 'codex',
          model: 'gpt-runtime',
          providerId: 'openai',
          effort: 'xhigh',
          fastMode: true,
        },
        runtimePending: null,
      });

      expect(remoteProjectsStore.getMergedRemoteSessions()[0]).toMatchObject({
        model: 'gpt-runtime',
        providerId: 'openai',
        effort: 'xhigh',
        fastMode: true,
        runtimeGeneration: 3,
        runtimeEffective: { model: 'gpt-runtime', providerId: 'openai' },
      });
    });

    it('固定强度运行时模型显式清除旧 effort', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { effort: 'high' })]);
      remoteProjectsStore.applyPatch('dev-B', 's1', {
        model: 'fixed-strength-model',
        providerId: 'openai',
        effort: '',
        runtimeEffective: {
          agentKind: 'codex',
          model: 'fixed-strength-model',
          providerId: 'openai',
          effort: null,
          fastMode: false,
        },
      });

      expect(remoteProjectsStore.getMergedRemoteSessions()[0]).toMatchObject({
        model: 'fixed-strength-model',
        effort: '',
        runtimeEffective: { effort: null },
      });
    });

    it('status=deleted 移出分片,archived 保留完整行供归档筛选展示', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1'), mk('s2')]);
      remoteProjectsStore.applyPatch('dev-B', 's1', { status: 'deleted' });
      expect(remoteProjectsStore.getMergedRemoteSessions().map((x) => x.id)).toEqual(['s2']);
      remoteProjectsStore.applyPatch('dev-B', 's2', { status: 'archived' });
      expect(remoteProjectsStore.getDeviceSessions('dev-B', 'active')).toHaveLength(0);
      expect(remoteProjectsStore.getDeviceSessions('dev-B', 'archived')).toEqual([
        expect.objectContaining({ id: 's2', status: 'archived' }),
      ]);
      expect(getSessionDeviceId('s1')).toBeUndefined();
      expect(getSessionDeviceId('s2')).toBe('dev-B');
    });

    it('通知只在意 sessionId 的旁路状态,包含不在任何分片里的会话', () => {
      const removed: string[] = [];
      const off = subscribeRemoteSessionRemoval((id) => removed.push(id));
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);

      remoteProjectsStore.applyPatch('dev-B', 's1', { status: 'deleted' });
      // 不在任何分片里的会话(分片有界/设备早已移除)也得报:窗口里可能还挂着它的路由。
      remoteProjectsStore.applyPatch('dev-gone', 's9', { status: 'deleted' });
      // 非删除的 patch 不是消失。
      remoteProjectsStore.applyPatch('dev-B', 's2', { status: 'archived' });

      off();
      remoteProjectsStore.applyPatch('dev-B', 's3', { status: 'deleted' });
      expect(removed).toEqual(['s1', 's9']);
    });

    it('unpin 后触发 reseed,让仅因 includePinned 补入的旧会话被后续 snapshot 剔除', () => {
      const reseed = vi.fn();
      setRemoteReseedImpl(reseed);
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
        mk('old-pinned', { pinnedAt: '2026-01-02T00:00:00.000Z' }),
      ]);

      remoteProjectsStore.applyPatch('dev-B', 'old-pinned', { pinnedAt: null });

      expect(remoteProjectsStore.getMergedRemoteSessions()[0].pinnedAt).toBeNull();
      expect(reseed).toHaveBeenCalledWith('dev-B', 'active');
      expect(reseed).toHaveBeenCalledTimes(1);
    });

    it('落到未知 session 丢弃(不造壳)', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);
      remoteProjectsStore.applyPatch('dev-B', 'ghost', { title: 'X' });
      expect(remoteProjectsStore.getMergedRemoteSessions().map((x) => x.id)).toEqual(['s1']);
    });

    it('未知设备 no-op', () => {
      remoteProjectsStore.applyPatch('dev-Z', 's1', { title: 'X' });
      expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(0);
    });
  });

  describe('snapshot epoch(乱序保护)', () => {
    it('旧 snapshot 不覆盖新 snapshot', () => {
      remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { model: 'old' })]);
      // 模拟两次重拉:先发起 e1(旧),再发起 e2(新);e2 先 set,e1 后到应被丢弃。
      const e1 = remoteProjectsStore.nextSnapshotEpoch('dev-B');
      const e2 = remoteProjectsStore.nextSnapshotEpoch('dev-B');
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-B', e2)).toBe(true);
      // e2 的结果落地
      if (remoteProjectsStore.isLatestSnapshotEpoch('dev-B', e2)) {
        remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { model: 'new' })]);
      }
      // e1(旧)回来:已非最新 → 调用方据 isLatestSnapshotEpoch 丢弃,不 set
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-B', e1)).toBe(false);
      const s = remoteProjectsStore.getMergedRemoteSessions().find((x) => x.id === 's1')!;
      expect(s.model).toBe('new');
    });

    it('removeDevice 即使无 shard 也失效 epoch:在途 refresh 不会把已移除设备会话加回', () => {
      // 设备首次 bootstrap 还没建 shard 就被移除(下线/关被控),此刻在途 refresh 已取 epoch。
      const e = remoteProjectsStore.nextSnapshotEpoch('dev-X'); // 无 shard
      remoteProjectsStore.removeDevice('dev-X');
      // 在途 refresh await 回来:epoch 已失效 → isLatestSnapshotEpoch=false → 调用方丢弃结果。
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-X', e)).toBe(false);
    });

    it('clear() 即使无 shard 也清 epoch:断连时在途首拉不会把会话加回', () => {
      // relay 断连(connecting/stopped)调 clear();某设备首拉还在途、shard 未建,此刻已取 epoch。
      const e = remoteProjectsStore.nextSnapshotEpoch('dev-Y'); // 无 shard
      remoteProjectsStore.clear();
      // 在途首拉 await 回来:epoch 已被 clear 失效 → 调用方据 isLatestSnapshotEpoch 丢弃,不 set。
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-Y', e)).toBe(false);
    });

    it('[ABA] removeDevice 后重新 bootstrap 的 epoch 不复用旧值,断连前的在途响应永久失效', () => {
      const e1 = remoteProjectsStore.nextSnapshotEpoch('dev-A'); // 断连前在途
      remoteProjectsStore.removeDevice('dev-A'); // 移除 → 自增(非归零)
      const e2 = remoteProjectsStore.nextSnapshotEpoch('dev-A'); // reconnect 后新一轮
      expect(e2).not.toBe(e1); // 关键:不复用 → 无 ABA
      expect(e2).toBeGreaterThan(e1);
      // 断连前在途响应(e1)即使在新一轮发起后回来,也已永久失效,不会盖回新 snapshot。
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', e1)).toBe(false);
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', e2)).toBe(true);
    });

    it('[ABA] clear() 后重新 bootstrap 的 epoch 不复用旧值', () => {
      const e1 = remoteProjectsStore.nextSnapshotEpoch('dev-A');
      remoteProjectsStore.clear(); // 断连 → 全部自增(非 clear-to-0)
      const e2 = remoteProjectsStore.nextSnapshotEpoch('dev-A');
      expect(e2).not.toBe(e1);
      expect(e2).toBeGreaterThan(e1);
      expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', e1)).toBe(false);
    });
  });

  it('removeDevice clears shard + registry', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);
    remoteProjectsStore.removeDevice('dev-B');
    expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(0);
    expect(getSessionDeviceId('s1')).toBeUndefined();
    expect(remoteProjectsStore.getDeviceIds()).toHaveLength(0);
  });

  it('markDeviceDisconnected keeps sessions visible but removes the device from the online index', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1'), mk('s2')]);
    remoteProjectsStore.setDeviceSessions(
      'dev-B',
      'B',
      [mk('archived-1', { status: 'archived' })],
      'archived',
    );
    remoteProjectsStore.markDeviceDisconnected('dev-B');

    const merged = remoteProjectsStore.getMergedRemoteSessions();
    expect(merged.map((s) => s.id)).toEqual(['s1', 's2', 'archived-1']);
    expect(merged.every((s) => s.deviceLinkConnectionStatus === 'disconnected')).toBe(true);
    // 旧 archived 行作缓存保留,但权威标记失效,重连后侧栏会重新校准断线期间变化。
    expect(remoteProjectsStore.getArchivedLoadedDeviceIds().size).toBe(0);
    // origin 保留:打开会话仍知道要走哪个 device-link 隧道,连接状态由 banner / invoke 错误处理。
    expect(getSessionDeviceId('s1')).toBe('dev-B');
    // 在线索引清掉:useRemoteSessionConnection 会显示 host-offline。
    expect(remoteProjectsStore.getDeviceIds()).toEqual([]);
    expect(remoteProjectsStore.getDeviceList()).toEqual([
      { deviceId: 'dev-B', deviceName: 'B', sessionCount: 3, connected: false },
    ]);
  });

  it('markAllDisconnected invalidates archived authority for every cached device', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [], 'archived');
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [], 'archived');
    expect([...remoteProjectsStore.getArchivedLoadedDeviceIds()]).toEqual(['dev-A', 'dev-B']);

    remoteProjectsStore.markAllDisconnected();

    expect(remoteProjectsStore.getArchivedLoadedDeviceIds().size).toBe(0);
  });

  it('setDeviceSessions reconnects a disconnected cached shard', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);
    remoteProjectsStore.markDeviceDisconnected('dev-B');
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1')]);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0].deviceLinkConnectionStatus).toBe(
      'connected',
    );
    expect(remoteProjectsStore.getDeviceIds()).toEqual(['dev-B']);
    expect(remoteProjectsStore.getDeviceList()).toEqual([
      { deviceId: 'dev-B', deviceName: 'B', sessionCount: 1, connected: true },
    ]);
  });

  it('tracks loading/error independently from an existing shard and clears both after a successful snapshot', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('old')]);
    remoteProjectsStore.markBootstrapLoading('dev-B');
    expect([...remoteProjectsStore.getBootstrapLoadingDeviceIds()]).toEqual(['dev-B']);
    expect(remoteProjectsStore.getDeviceSessions('dev-B').map((session) => session.id)).toEqual([
      'old',
    ]);

    const before = remoteProjectsStore.getBootstrapFailedDeviceIds();
    remoteProjectsStore.markBootstrapFailed('dev-B');
    expect(remoteProjectsStore.getBootstrapLoadingDeviceIds().size).toBe(0);
    const failed = remoteProjectsStore.getBootstrapFailedDeviceIds();
    expect(failed).not.toBe(before);
    expect([...failed]).toEqual(['dev-B']);

    remoteProjectsStore.markBootstrapFailed('dev-B');
    expect(remoteProjectsStore.getBootstrapFailedDeviceIds()).toBe(failed);

    remoteProjectsStore.setDeviceSessions('dev-B', 'B', []);
    expect(remoteProjectsStore.getBootstrapLoadingDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getBootstrapFailedDeviceIds().size).toBe(0);
  });

  it('disconnect, removeDevice and clear discard active / archived activity before a shard exists', () => {
    remoteProjectsStore.markBootstrapLoading('dev-loading');
    remoteProjectsStore.markSessionStatusLoading('dev-loading', 'archived');
    remoteProjectsStore.markDeviceDisconnected('dev-loading');
    expect(remoteProjectsStore.getBootstrapLoadingDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getArchivedLoadingDeviceIds().size).toBe(0);

    remoteProjectsStore.markBootstrapFailed('dev-A');
    remoteProjectsStore.markSessionStatusFailed('dev-A', 'archived');
    remoteProjectsStore.removeDevice('dev-A');
    expect(remoteProjectsStore.getBootstrapFailedDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getArchivedFailedDeviceIds().size).toBe(0);

    remoteProjectsStore.setDeviceSessions('dev-loaded', 'Loaded', [], 'archived');
    remoteProjectsStore.removeDevice('dev-loaded');
    expect(remoteProjectsStore.getArchivedLoadedDeviceIds().size).toBe(0);

    remoteProjectsStore.markBootstrapLoading('dev-A');
    remoteProjectsStore.markBootstrapFailed('dev-B');
    remoteProjectsStore.markSessionStatusLoading('dev-C', 'archived');
    remoteProjectsStore.markSessionStatusFailed('dev-D', 'archived');
    remoteProjectsStore.clear();
    expect(remoteProjectsStore.getBootstrapLoadingDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getBootstrapFailedDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getArchivedLoadingDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getArchivedFailedDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getArchivedLoadedDeviceIds().size).toBe(0);
  });

  it('clears only a superseded bootstrap loading state', () => {
    remoteProjectsStore.markBootstrapLoading('dev-loading');
    remoteProjectsStore.clearBootstrapLoading('dev-loading');
    expect(remoteProjectsStore.getBootstrapLoadingDeviceIds().size).toBe(0);
    expect(remoteProjectsStore.getBootstrapFailedDeviceIds().size).toBe(0);

    remoteProjectsStore.markBootstrapFailed('dev-failed');
    remoteProjectsStore.clearBootstrapLoading('dev-failed');
    expect([...remoteProjectsStore.getBootstrapFailedDeviceIds()]).toEqual(['dev-failed']);
  });

  it('clear resets everything', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1'), mk('s2')]);
    remoteProjectsStore.clear();
    expect(remoteProjectsStore.getMergedRemoteSessions()).toHaveLength(0);
    expect(getSessionDeviceId('s1')).toBeUndefined();
    expect(remoteProjectsStore.getDeviceIds()).toHaveLength(0);
  });

  it('applyPatch 只换被 patch 设备的会话对象引用,其它设备会话引用稳定(防级联重渲染)', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a1'), mk('a2')]);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('b1')]);
    const before = remoteProjectsStore.getMergedRemoteSessions();
    const a1Before = before.find((x) => x.id === 'a1')!;
    const a2Before = before.find((x) => x.id === 'a2')!;

    remoteProjectsStore.applyPatch('dev-B', 'b1', { title: 'B1!' });

    const after = remoteProjectsStore.getMergedRemoteSessions();
    expect(after).not.toBe(before); // 扁平快照 recompute 换新数组
    // dev-A 的会话对象引用未变(只有 dev-B 分片被 .map);否则 React 会无谓重渲所有设备项。
    expect(after.find((x) => x.id === 'a1')).toBe(a1Before);
    expect(after.find((x) => x.id === 'a2')).toBe(a2Before);
    // 被 patch 的 dev-B 会话是新对象 + 新值。
    expect(after.find((x) => x.id === 'b1')!.title).toBe('B1!');
  });

  it('renameDevice:重打 deviceLinkDeviceName + 通知 subscribeRename;同名时不重算(引用稳定)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'Old', [mk('s1')]);
    const seen: Array<[string, string]> = [];
    const off = remoteProjectsStore.subscribeRename((id, name) => seen.push([id, name]));

    remoteProjectsStore.renameDevice('dev-B', 'New');
    expect(
      remoteProjectsStore.getMergedRemoteSessions().find((x) => x.id === 's1')!
        .deviceLinkDeviceName,
    ).toBe('New');
    expect(seen).toEqual([['dev-B', 'New']]);

    // 同名:分片名未变 → 不 recompute(扁平快照引用不变),避免无谓重渲。
    const beforeSameName = remoteProjectsStore.getMergedRemoteSessions();
    remoteProjectsStore.renameDevice('dev-B', 'New');
    expect(remoteProjectsStore.getMergedRemoteSessions()).toBe(beforeSameName);
    off();
  });
});

/**
 * 标题预览叠加层:控制端发送瞬间即时显示占位,不等被控端那一次隧道往返;
 * 分片数据仍是纯镜像(不被本地改写),被控端权威标题一到自动让位。
 */
describe('remoteProjectsStore pending title preview', () => {
  beforeEach(() => {
    setRemoteReseedImpl(null);
    remoteProjectsStore.clear();
    remoteProjectsStore.__resetPendingTitlePreviewForTest();
  });

  it('shows the preview while the authoritative title is still the default placeholder', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);

    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('帮我排查登录失败');
    // 分片本身没有被改写 —— 纯镜像不变量。
    expect(remoteProjectsStore.getDeviceSessions('dev-B')[0]?.title).toBe('New Maker');
  });

  it('yields to the authoritative title as soon as the controlled device writes one', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    // 被控端回流占位 → 权威值胜出。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '帮我排查登录失败' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('帮我排查登录失败');

    // 再回流智能标题 → 预览已回收,不会把它顶回去。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '登录失败排查' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('登录失败排查');
  });

  it('previews over a synthesized placeholder the controller itself registered', () => {
    // 纯附件首条消息:被控端把标题写成文件名。用户随后打下第一句话时,控制端同样
    // 要即时顶上 —— 只认默认占位的话,即时性恰好在这条恢复路径上缺席(review P1)。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '设计稿-v3.png', false);
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '设计稿-v3.png' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('设计稿-v3.png');

    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修');

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('这个报错怎么修');
    // 分片仍是纯镜像。
    expect(remoteProjectsStore.getDeviceSessions('dev-B')[0]?.title).toBe('设计稿-v3.png');

    // 智能标题落地 → 归属作废,后续预览不再生效。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '报错排查' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('报错排查');
    remoteProjectsStore.setPendingTitlePreview('s1', '又一条消息');
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('报错排查');
  });

  it('previews over a fork placeholder (system-owned, parentSessionId present)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
      mk('s1', { title: '[Fork] 源会话标题', parentSessionId: 'src-1' }),
    ]);

    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修');

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('这个报错怎么修');
  });

  it('treats a user-named "[Fork] ..." session without parentSessionId as manual', () => {
    // 与被控端 getOverwritableAutoTitle 同一条判据:没有 parentSessionId 就不是
    // fork 占位,是用户自己起的名。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
      mk('s1', { title: '[Fork] 我自己起的名' }),
    ]);

    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修');

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('[Fork] 我自己起的名');
  });

  it('drops synthesized-title provenance together with the session (archive / device removal)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '设计稿-v3.png', false);
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '设计稿-v3.png' });
    remoteProjectsStore.applyPatch('dev-B', 's1', { status: 'archived' });

    // unarchive 回来:归属已随会话回收,旧的合成标题不再被当成系统占位。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: '设计稿-v3.png' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修');

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('设计稿-v3.png');
  });

  it('does not claim provenance for a prose title that the host settles on', () => {
    // 首句是用户文字、标题模型无结果时,被控端就地定稿 —— 那是终态标题,不是占位。
    // 靠"预览与权威值相等"推断归属会把它记成系统占位,之后每条消息的预览都能盖着
    // 它不放,而权威侧再也不会发新 patch 纠正(review P1)。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败', true);
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '帮我排查登录失败' });

    remoteProjectsStore.setPendingTitlePreview('s1', '第二条消息', true);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('帮我排查登录失败');
  });

  it('keeps the newer prose preview when an older synthesized patch lands late', () => {
    // 用户在附件占位回流之前就打了字:旧占位 A 随后才到,它既不等于当前预览 B、
    // 也不在归属表里,会被当成手动改名而把 B 整个丢掉,侧边栏回退到附件名
    // 直到下一跳(review P1)。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '设计稿-v3.png', false);
    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修', true);

    // 迟到的 A 补丁。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '设计稿-v3.png' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('这个报错怎么修');

    // 随后 B 的权威补丁到达 → 叠加层整体作废,后续预览不再生效。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '这个报错怎么修' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('这个报错怎么修');
    remoteProjectsStore.setPendingTitlePreview('s1', '又一条消息', true);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('这个报错怎么修');
  });

  it('never treats a manual rename arriving mid-preview as a synthesized confirmation', () => {
    // 用户在合成预览在途时手动改了名 —— 那是权威的、他自己起的名字。若把"下一个
    // 非默认标题"一律当成合成占位登记,之后的预览就能长期顶掉它,而被控端正确地
    // 拒绝给手动命名的会话改名、不会有 patch 来纠正(review P1)。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '设计稿-v3.png', false);

    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '我自己起的名字' });
    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修', true);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('我自己起的名字');
  });

  it('跨语种占位登记不上时只丢失即时预览,不影响权威改名', () => {
    // 已知且刻意接受的降级:两端 UI 语言不同、且首条消息只能回落到 i18n 类别词
    // (粘贴截图)时,两端算出的串不逐字相等,归属登记不上。表现为后续首句话没有
    // 即时预览,仍会经隧道往返正常改名 —— 少一次即时性,好过顶掉用户的名字。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', 'Image', false);
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '图片' });

    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修', true);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('图片');

    // 权威改名照常到达。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '这个报错怎么修' });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('这个报错怎么修');
  });

  it('drops overlays for sessions a full snapshot no longer contains', () => {
    // 权威快照整片替换分片:patch 丢失期间被归档的会话就此离场,叠加层若不在这里
    // 回收,removeDevice 也够不着它,unarchive/reseed 后旧预览会复活(review P1)。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
      mk('s1', { title: 'New Maker' }),
      mk('s2', { title: 'New Maker' }),
    ]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    // s1 没在这次快照里回来 → 离场。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s2', { title: 'New Maker' })]);
    // unarchive/reseed 把它拉回来,权威标题仍是默认占位。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
      mk('s1', { title: 'New Maker' }),
      mk('s2', { title: 'New Maker' }),
    ]);

    expect(remoteProjectsStore.getMergedRemoteSessions().find((s) => s.id === 's1')?.title).toBe(
      'New Maker',
    );
  });

  it('keeps overlays for sessions merged back by a partial anti-entropy window', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [
      mk('s1', { title: 'New Maker' }),
      mk('s2', { title: 'New Maker' }),
    ]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    // 半窗口 anti-entropy:s1 不在本次窗口内,但 mergeDeviceSessions 会把它并回来。
    remoteProjectsStore.mergeDeviceSessions('dev-B', 'B', [mk('s2', { title: 'New Maker' })]);

    expect(remoteProjectsStore.getMergedRemoteSessions().find((s) => s.id === 's1')?.title).toBe(
      '帮我排查登录失败',
    );
  });

  it('clears stale synthesized provenance once a prose preview is confirmed', () => {
    // 合成占位 A 落地后又来了用户文字 B;B 被权威确认时 A 的归属必须一并作废,
    // 否则用户日后手动把标题改回 A,会被误判成系统占位而被预览长期顶替 —— 权威侧
    // 正确地拒绝给手动命名的会话改名,不会有 patch 来纠正(review P1)。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '设计稿-v3.png', false);
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '设计稿-v3.png' });
    remoteProjectsStore.setPendingTitlePreview('s1', '这个报错怎么修', true);
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '这个报错怎么修' });

    // 用户手动改回那个合成串。
    remoteProjectsStore.applyPatch('dev-B', 's1', { title: '设计稿-v3.png' });
    remoteProjectsStore.setPendingTitlePreview('s1', '又一条消息', true);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('设计稿-v3.png');
  });

  it('never overrides a title the user already renamed on the controlled device', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: '我自己起的名字' })]);

    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('我自己起的名字');
  });

  it('can explicitly drop a preview when first-message handoff fails', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');
    remoteProjectsStore.clearPendingTitlePreview('s1');
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('New Maker');
  });

  it('survives a snapshot rebuild while the authoritative title stays default', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    // anti-entropy 重拉:权威标题仍是默认占位 → 预览继续顶着,不闪回 New Maker。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('帮我排查登录失败');
  });

  it('drops previews for a removed device (revoke / stop control)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    remoteProjectsStore.removeDevice('dev-B');
    // 重新接入后权威标题仍是默认占位 —— 边界前的旧预览不得复活。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('New Maker');
  });

  it('drops previews on clear() (logout / device-link stopped)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    remoteProjectsStore.clear();
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('New Maker');
  });

  it('drops the preview when the session leaves the shard (archive / delete)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    // 归档移出分片 —— removeDevice 之后也遍历不到它,预览必须在这里回收。
    remoteProjectsStore.applyPatch('dev-B', 's1', { status: 'archived' });
    // unarchive / reseed 把同一个仍是默认标题的会话拉回来,旧预览不得复活。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);

    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('New Maker');
  });

  it('no-ops when the authoritative title is already set (avoids write/recompute churn)', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: '登录失败排查' })]);
    const before = remoteProjectsStore.getMergedRemoteSessions();

    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');

    // 预览本来就不会生效 —— 不写、不 recompute,快照引用保持不变。
    expect(remoteProjectsStore.getMergedRemoteSessions()).toBe(before);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('登录失败排查');
  });

  it('ignores empty previews and keeps the snapshot reference stable on repeat calls', () => {
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [mk('s1', { title: 'New Maker' })]);
    remoteProjectsStore.setPendingTitlePreview('s1', '   ');
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.title).toBe('New Maker');

    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');
    const first = remoteProjectsStore.getMergedRemoteSessions();
    remoteProjectsStore.setPendingTitlePreview('s1', '帮我排查登录失败');
    expect(remoteProjectsStore.getMergedRemoteSessions()).toBe(first);
  });
});

describe('remote session title index', () => {
  beforeEach(() => remoteProjectsStore.clear());

  it('resolves titles by id and follows renames pushed by the device', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { title: 'Release checklist' })]);
    expect(remoteProjectsStore.getSessionTitle('a')).toBe('Release checklist');
    expect(remoteProjectsStore.getSessionTitle('missing')).toBeNull();

    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { title: 'Renamed' })]);
    expect(remoteProjectsStore.getSessionTitle('a')).toBe('Renamed');

    remoteProjectsStore.removeDevice('dev-A');
    expect(remoteProjectsStore.getSessionTitle('a')).toBeNull();
  });
});

/**
 * 首条发送叠加层:远程建会话后、被控端收下首条前,列表回流里的 userSendAt 仍为空。
 * 叠加层让会话一直留在项目里,不先掉进项目外的草稿区再跳回来。
 */
describe('remoteProjectsStore pending first send', () => {
  const SENT_AT = '2026-10-05T03:41:49.000Z';
  const unsent = (id: string): Session => ({ ...mk(id, { title: 'New Maker' }), userSendAt: null });

  beforeEach(() => {
    setRemoteReseedImpl(null);
    remoteProjectsStore.clear();
    remoteProjectsStore.__resetPendingTitlePreviewForTest();
  });

  it('keeps the send time across a list refresh that still reports the host row as unsent', () => {
    remoteProjectsStore.setPendingFirstSend('s1', SENT_AT);
    remoteProjectsStore.mergeDeviceSessions('dev-B', 'B', [unsent('s1')]);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBe(SENT_AT);

    // 权威快照再来一次(host 仍未收下首条)—— 叠加层继续顶着。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [unsent('s1')]);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBe(SENT_AT);
    // 分片本身没有被改写 —— 纯镜像不变量。
    expect(remoteProjectsStore.getDeviceSessions('dev-B')[0]?.userSendAt).toBeNull();
  });

  it('yields to the host value and retires once the host records the first send', () => {
    remoteProjectsStore.setPendingFirstSend('s1', SENT_AT);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [unsent('s1')]);

    const hostSentAt = '2026-10-05T03:41:50.123Z';
    remoteProjectsStore.applyPatch('dev-B', 's1', { userSendAt: hostSentAt });
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBe(hostSentAt);

    // 已回收:之后即使有一份陈旧快照把它报回空,也不会再被叠加层补上。
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [unsent('s1')]);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBeNull();
  });

  it('lets an undelivered first message fall back to the honest empty state', () => {
    remoteProjectsStore.setPendingFirstSend('s1', SENT_AT);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [unsent('s1')]);

    remoteProjectsStore.clearPendingFirstSend('s1');
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBeNull();
  });

  it('drops the overlay when the session leaves the mirror', () => {
    remoteProjectsStore.setPendingFirstSend('s1', SENT_AT);
    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [unsent('s1')]);
    remoteProjectsStore.applyPatch('dev-B', 's1', { status: 'deleted' });

    remoteProjectsStore.setDeviceSessions('dev-B', 'B', [unsent('s1')]);
    expect(remoteProjectsStore.getMergedRemoteSessions()[0]?.userSendAt).toBeNull();
  });
});

/**
 * 远程归档 / 恢复的状态迁移叠加层:写库往返期间行先换桶,分片保持权威;
 * 写库成功落被控端返回的行,叠加层留到写库之后的新列表确认为止。
 */
describe('remoteProjectsStore pending status (remote archive / unarchive)', () => {
  const PINNED_AT = '2026-01-02T00:00:00.000Z';
  const projected = (id: string) =>
    remoteProjectsStore.getMergedRemoteSessions().find((session) => session.id === id);
  const stored = (id: string) =>
    remoteProjectsStore.getDeviceSessions('dev-A').find((session) => session.id === id);

  beforeEach(() => {
    setRemoteReseedImpl(null);
    remoteProjectsStore.clear();
    remoteProjectsStore.__resetPendingTitlePreviewForTest();
  });

  it('moves an archived row out of the active bucket at once without rewriting the shard', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { pinnedAt: PINNED_AT }), mk('b')]);
    const before = remoteProjectsStore.getMergedRemoteSessions();

    remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');

    expect(remoteProjectsStore.getMergedRemoteSessions()).not.toBe(before);
    expect(projected('a')).toMatchObject({ status: 'archived', pinnedAt: null });
    expect(projected('b')?.status).toBe('active');
    // 分片仍是权威镜像;origin 判定不受影响。
    expect(stored('a')).toMatchObject({ status: 'active', pinnedAt: PINNED_AT });
    expect(getSessionDeviceId('a')).toBe('dev-A');
  });

  it('restores the row on rollback, and only the latest token can settle a session', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    const first = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
    const second = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
    expect(remoteProjectsStore.isPendingStatusCurrent(first)).toBe(false);
    expect(remoteProjectsStore.isPendingStatusCurrent(second)).toBe(true);

    expect(remoteProjectsStore.rollbackPendingStatus(first)).toBe(false);
    expect(remoteProjectsStore.completePendingStatus(first, { status: 'archived' })).toBe(false);
    expect(projected('a')?.status).toBe('archived');
    expect(stored('a')?.status).toBe('active');

    expect(remoteProjectsStore.rollbackPendingStatus(second)).toBe(true);
    expect(projected('a')?.status).toBe('active');
  });

  it('keeps the row hidden while stale snapshots and patches land during the write', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');

    // 写库前就在途的列表 / 乱序 push 仍报 active —— 叠加层顶着,不回弹。
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { title: 'renamed' })]);
    remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'active' });

    expect(projected('a')).toMatchObject({ status: 'archived', title: 'renamed' });
    expect(stored('a')?.status).toBe('active');
  });

  it('applies the persisted row on success and survives a list that started before the write', () => {
    const reseed = vi.fn();
    setRemoteReseedImpl(reseed);
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { pinnedAt: PINNED_AT })]);
    // 10s 周期对账在写库前已发出(拿到了 epoch),响应会在写库成功之后才落地。
    const staleEpoch = remoteProjectsStore.nextSnapshotEpoch('dev-A');
    const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');

    expect(
      remoteProjectsStore.completePendingStatus(token, {
        id: 'a',
        status: 'archived',
        pinnedAt: null,
        updatedAt: '2026-02-01T00:00:00.000Z',
      }),
    ).toBe(true);
    // 不等 sessions:patched 回流,权威行已就地落下。
    expect(stored('a')).toMatchObject({
      status: 'archived',
      pinnedAt: null,
      updatedAt: '2026-02-01T00:00:00.000Z',
    });
    // 完成不让在途列表 superseded(不打断 bootstrap / 按需读取的收尾)。
    expect(remoteProjectsStore.isLatestSnapshotEpoch('dev-A', staleEpoch)).toBe(true);

    // 陈旧列表落地,把权威行改回 active —— 叠加层继续顶着,行不复活。
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    expect(stored('a')?.status).toBe('active');
    expect(projected('a')?.status).toBe('archived');

    // 同状态的 push 回流不撤叠加层(它可能早于那份陈旧列表到达)。
    remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'archived' });
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    expect(projected('a')?.status).toBe('archived');

    // 写库之后才发出的列表不含该行 → 权威确认,叠加层让位。
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
    expect(projected('a')).toBeUndefined();
    // 叠加层已回收:之后的权威 active 快照照实显示(例如别处又恢复了它)。
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    expect(projected('a')?.status).toBe('active');
  });

  it('settles on a confirming snapshot even when the shard is already byte-identical', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
    remoteProjectsStore.completePendingStatus(token, { status: 'archived', pinnedAt: null });

    // 写库后的 active 新列表不含 a:分片内容与此前逐字节相同(a 已是 archived),走 no-op
    // 分支 —— 叠加层仍要在这里确认回收。
    const listener = vi.fn();
    const unsubscribe = remoteProjectsStore.subscribe(listener);
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
    unsubscribe();
    expect(listener).toHaveBeenCalled();
    expect(projected('a')?.status).toBe('archived');

    // 已回收:之后的权威 active 行(例如别处又恢复了它)照实显示。
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    expect(projected('a')?.status).toBe('active');
  });

  it('brings an unarchived row back into the active bucket immediately', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
    remoteProjectsStore.setDeviceSessions(
      'dev-A',
      'A',
      [mk('a', { status: 'archived' })],
      'archived',
    );
    const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'active');
    expect(projected('a')?.status).toBe('active');
    expect(stored('a')?.status).toBe('archived');

    remoteProjectsStore.completePendingStatus(token, { id: 'a', status: 'active' });
    expect(stored('a')?.status).toBe('active');
    expect(projected('a')?.status).toBe('active');
  });

  it('ignores late status pushes after the write and a post-write list that still carries old data', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
    remoteProjectsStore.completePendingStatus(token, {
      id: 'a',
      status: 'archived',
      updatedAt: '2026-02-01T00:00:00.000Z',
    });

    // 写库前产生的 active 推送晚于回包到达:不带 updatedAt,分不清新旧 —— 不撤叠加层。
    remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'active' });
    expect(projected('a')?.status).toBe('archived');

    // 写库后才发出的列表被被控端并进写库前的查询,仍带旧 active 行 —— 第一份容忍一次。
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    expect(projected('a')?.status).toBe('archived');

    // 真正写库后的列表不含它 → 确认让位。
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
    remoteProjectsStore.nextSnapshotEpoch('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a')]);
    expect(projected('a')?.status).toBe('active');
  });

  it('yields to a later change by another controller on the second post-write list', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', []);
    remoteProjectsStore.setDeviceSessions(
      'dev-A',
      'A',
      [mk('a', { status: 'archived' })],
      'archived',
    );
    const token = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'active');
    remoteProjectsStore.completePendingStatus(token, { id: 'a', status: 'active' });

    // 另一控制端随后又把它归档了。状态写不推进 updatedAt,推送和第一份对不上的写库后列表
    // 都分不清它与旧结果 —— 叠加层顶住;第二份写库后列表无论内容一律让位,不会永远顶住。
    remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'archived' });
    expect(projected('a')?.status).toBe('active');
    const archivedList = () => {
      remoteProjectsStore.nextSnapshotEpoch('dev-A', 'archived');
      remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a', { status: 'archived' })], 'archived');
    };
    archivedList();
    expect(projected('a')?.status).toBe('active');
    archivedList();
    expect(projected('a')?.status).toBe('archived');
  });

  it('drops the overlay on deletion, device removal and clear', () => {
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('a'), mk('b'), mk('c')]);
    const deleted = remoteProjectsStore.beginPendingStatus('dev-A', 'a', 'archived');
    remoteProjectsStore.applyPatch('dev-A', 'a', { status: 'deleted' });
    expect(projected('a')).toBeUndefined();
    expect(remoteProjectsStore.completePendingStatus(deleted, { status: 'archived' })).toBe(false);

    const removed = remoteProjectsStore.beginPendingStatus('dev-A', 'b', 'archived');
    remoteProjectsStore.removeDevice('dev-A');
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('b')]);
    expect(projected('b')?.status).toBe('active');
    expect(remoteProjectsStore.rollbackPendingStatus(removed)).toBe(false);

    remoteProjectsStore.beginPendingStatus('dev-A', 'b', 'archived');
    remoteProjectsStore.clear();
    remoteProjectsStore.setDeviceSessions('dev-A', 'A', [mk('b')]);
    expect(projected('b')?.status).toBe('active');
  });
});