Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

35.7 KB
Raw Blame
// Other accounts' panes on the desk (1c, R1 and R2) and the desktop seams
// 2–5 of step 0: a foreign pane is placed once through the desk, renders as
// shared at once, restores as "Alice · waiting", never routes a stop, and
// names its owner in the status bar.
import 'dart:async';
import 'dart:convert';

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/agent_messages/shared_tabs.dart' show SharedTabsState;
import 'package:harness/agent_messages/shared_tabs_model.dart' show memberDeskTabId;
import 'package:harness/api/api_client.dart';
import 'package:harness/auth/auth_session.dart';
import 'package:harness/core/config.dart';
import 'package:harness/core/models.dart';
import 'package:harness/shared/theme/app_theme.dart' as grid;
import 'package:harness/sharing/shared_harness_panel.dart';
import 'package:harness/state/app_state.dart';
import 'package:harness/state/desk_sync.dart';
import 'package:harness/state/pane_layout_store.dart';
import 'package:harness/state/terminal_pane.dart';
import 'package:harness/state/workspace_status.dart';
import 'package:harness/terminal/terminal_session.dart';
import 'package:harness/widgets/pane_grid.dart';
import 'package:harness/ws/local_cli_discovery.dart';
import 'package:harness/ws/ws_conn.dart';

import 'swarm_state_test.dart' show MemoryStore;

/// A shared tab id, as the daemon mints them (`roster.ts`: 24 hex).
const _tab = 'aaaaaaaaaaaaaaaaaaaaaaaa';

/// Its desk tab on Bob's (a member's) desk: derived from the shared tab id (R1).
final _deskTab = memberDeskTabId(_tab);
const _computer = 'abcdef0123456789';
const _placedKey = 'shared_tabs.placed.bob';

/// What the backend's desk schema refuses (`desk.ts`: a trimmed name of 1–80
/// UTF-16 units); the fake refuses the whole batch for it, as the route does.
bool _badName(Object? name) =>
    name is! String ||
    name.trim().isEmpty ||
    name.trim().length > 80 ||
    RegExp(r'[\p{Cc}\p{Cf}]', unicode: true).hasMatch(name);

String _key(String machineId, String agentId) => '$machineId\u0000$agentId';

/// The account's desk, one document every window writes to (the backend's
/// rules: `tab.create` and `pane.add` are idempotent).
class _Desk {
  DeskDoc doc = const DeskDoc(revision: 0, tabs: []);
  final batches = <List<Map<String, dynamic>>>[];
  int refused = 0;

  Map<String, dynamic> json() => {
    'revision': doc.revision,
    'tabs': [for (final t in doc.tabs) t.toJson()],
  };

  DeskTab? tab(String id) => doc.tabs.where((t) => t.id == id).firstOrNull;
}

/// The daemon's REST proxy: the desk, Agent Messages' presence, and a
/// scripted machine list.
class _Api extends ApiClient {
  _Api(this.board)
    : super(config: AppConfig.dev, session: AuthSession(storage: MemoryStore()));

  final _Desk board;
  List<Machine> list = const [];
  int machineReads = 0;
  int sharesTold = 0;

  @override
  void sharesChanged() => sharesTold++;

  @override
  Future<Map<String, dynamic>?> desk() async => board.json();

  @override
  Future<Map<String, dynamic>?> deskOps(List<Map<String, dynamic>> ops) async {
    for (final op in ops) {
      final names = [
        if (op['op'] == 'tab.create' || op['op'] == 'tab.rename') op['name'],
        if (op['op'] == 'seed')
          for (final t in op['tabs'] as List) (t as Map)['name'],
      ];
      if (names.any(_badName)) {
        board.refused++;
        throw StateError('400: desk op refused');
      }
    }
    board.batches.add(ops);
    var tabs = board.doc.tabs;
    for (final op in ops) {
      // The backend holds 9 harnesses a tab (`DESK_MAX_PANES`).
      if (op['op'] == 'pane.add' &&
          (tabs.where((t) => t.id == op['tabId']).firstOrNull?.panes.length ??
                  0) >=
              9) {
        continue;
      }
      tabs = applyDeskOps(tabs, [op]);
    }
    board.doc = DeskDoc(revision: board.doc.revision + 1, tabs: tabs);
    return board.json();
  }

  @override
  Future<Map<String, dynamic>?> readAgentMessageTabs() async => {
    'revision': board.doc.revision,
    'machines': const [],
    'tabs': const [],
  };

  @override
  Future<Map<String, dynamic>?> me() async => null;

  @override
  Future<Map<String, dynamic>?> daemonDevices() async => null;

  @override
  Future<List<Machine>> machines() async {
    machineReads++;
    return list;
  }
}

class _Discovery extends LocalCliDiscovery {
  _Discovery() : super(config: AppConfig.dev);
  @override
  Future<String?> computerId() async => _computer;
  @override
  Future<LocalCliEndpoint?> discover({String? expectedComputerId}) async =>
      null;
}

/// This computer's daemon (and, through `connectionForTest`, every machine's
/// connection): answers `shares` and records every request and frame type.
class _Daemon extends WsConn {
  _Daemon(this.shares)
    : super(
        wsBaseUrl: 'ws://fixture.invalid',
        autonomousEnv: 'test',
        machineId: 'm',
        accessTokenProvider: (_, _) async => '',
        onAuthFailure: (_) {},
        onEvent: (_) {},
        onStatus: (_) {},
      );

  Map<String, dynamic> shares;
  Completer<void>? gate;
  final sent = <String>[];

  /// Every other `agent_messages` request, as asked.
  final asked = <Map<String, dynamic>>[];

  @override
  Future<Map<String, dynamic>> request(
    String type, {
    Map<String, dynamic> payload = const {},
    Duration timeout = const Duration(seconds: 20),
  }) async {
    if (type == 'agent_messages' && payload['action'] == 'shares') {
      final answer = jsonDecode(jsonEncode(shares)) as Map<String, dynamic>;
      if (gate case final g?) await g.future;
      return answer;
    }
    if (type == 'agent_messages') {
      asked.add(Map<String, dynamic>.from(payload));
      if (payload['action'] == 'history') {
        final tabId = payload['tabId'];
        return {
          'messages': [
            {
              'id': 'msg-$tabId',
              'tabId': tabId,
              'text': 'hi',
              'at': 1792144800000,
              'from': {'machineId': 'm', 'agentId': 'a0', 'name': 'Own 0'},
              'to': [
                {'machineId': 'ma', 'agentId': 'a1', 'name': 'Harness a1'},
              ],
            },
          ],
        };
      }
    }
    sent.add(type);
    return const {};
  }

  @override
  void sendRaw(String type, Map<String, dynamic> payload) => sent.add(type);

  @override
  Future<bool> sendTerminalFrame(
    String type,
    Map<String, dynamic> payload,
  ) async {
    sent.add(type);
    return true;
  }

  @override
  Future<void> sendFrame(Map<String, dynamic> frame) async {
    sent.add('${frame['type']}');
  }

  /// Nothing to close: no socket was ever opened.
  @override
  Future<void> close() async {}
}

Map<String, dynamic> _shares({
  List<String> foreign = const ['ma/a1'],
  List<Map<String, dynamic>> members = const [],
  String me = 'bob',
  String foreignAccount = 'alice',
  String name = 'app',
  String? tabId,
}) => {
  'api': 2,
  'me': {'accountId': me, 'email': '$me@example.com', 'machineId': 'm'},
  'rosters': [
    {
      'sharedTabId': _tab,
      'tabId': tabId,
      'version': 3,
      'name': name,
      'owner': {
        'accountId': 'alice',
        'email': '[email protected]',
        'machineId': 'ma',
        'machinePublicKey': 'k',
      },
      'leader': null,
      'members': members,
      'invites': [],
      'harnesses': [
        for (final key in foreign)
          {
            'accountId': foreignAccount,
            'machineId': key.split('/').first,
            'agentId': key.split('/').last,
            'name': 'Harness ${key.split('/').last}',
            'engine': 'claude',
          },
      ],
    },
  ],
  'invites': [],
  'alerts': [],
  'pending': [],
  'notices': [],
  'untrusted': [],
  'activity': [],
};

const _own = Machine(
  machineId: 'm',
  computerId: _computer,
  authMode: MachineAuthMode.remote,
  name: 'This Mac',
);

/// Alice's machine as the inventory shows it to Bob: shared, with a grant for
/// each of [agents].
Machine _aliceMachine({List<String> agents = const ['a1']}) => Machine(
  machineId: 'ma',
  authMode: MachineAuthMode.remote,
  name: 'alice-mbp',
  isShared: true,
  ownerName: 'Alice',
  status: 'running',
  sharedHarnesses: [
    for (final a in agents)
      SharedHarness(
        id: 'grant-$a',
        agentId: a,
        name: 'Harness $a',
        engine: 'claude',
        expiresAt: DateTime.utc(2030),
      ),
  ],
);

/// Put Alice's shared machine in [app]'s inventory, as the merge does.
void _addAliceMachine(AppNotifier app, {List<Agent>? agents}) {
  final machine = _aliceMachine();
  app.machines = [...app.machines, machine];
  app.machineStates['ma'] = MachineState(machine)
    ..agentLoadStatus = AgentLoadStatus.loaded
    ..nodeOnline = true
    ..agents =
        agents ??
        [
          Agent(
            id: 'a1',
            name: 'Harness a1',
            engine: 'claude',
            terminalAvailable: true,
          ),
        ];
}

AppNotifier _app(_Api api, _Daemon daemon, {MemoryStore? store}) {
  final app = AppNotifier(
    config: AppConfig.dev,
    authSession: AuthSession(storage: MemoryStore()),
    configStore: null,
    connectionForTest: (_) => daemon,
    localCliDiscovery: _Discovery(),
    paneLayoutStore: PaneLayoutStore(storage: store ?? MemoryStore()),
  )..hasNavigationRail = false;
  app.machines = [_own];
  app.machineStates['m'] = MachineState(_own)
    ..localOnly = true
    ..nodeOnline = true
    ..connectionStatus = ConnectionStatus.connected
    ..agentLoadStatus = AgentLoadStatus.loaded
    ..agents = [
      for (var i = 0; i < 4; i++)
        Agent(
          id: 'a$i',
          name: 'Own $i',
          engine: 'codex',
          terminalAvailable: true,
        ),
    ];
  app
    ..api = api
    ..status = AppStatus.authenticated;
  return app;
}

/// Let every chained future (reads, placement, desk writes) land.
Future<void> _settle() async {
  for (var i = 0; i < 40; i++) {
    await Future<void>.delayed(Duration.zero);
  }
}

Future<void> _pumpGrid(WidgetTester tester, AppNotifier app) async {
  await tester.pumpWidget(
    MaterialApp(
      theme: grid.buildAppTheme(brightness: Brightness.dark),
      home: Scaffold(
        body: ListenableBuilder(
          listenable: app,
          builder: (_, _) => PaneGrid(notifier: app, swarmMode: true),
        ),
      ),
    ),
  );
  await tester.pump();
}

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  group('placement (R1, R2)', () {
    test('a member\'s desk gets one tab and one pane, even from two windows at once (Review Focus 2)', () async {
      final desk = _Desk();
      final gate = Completer<void>();
      final apps = <AppNotifier>[];
      for (var i = 0; i < 2; i++) {
        final daemon = _Daemon(_shares())..gate = gate;
        final app = _app(_Api(desk), daemon);
        addTearDown(app.dispose);
        _addAliceMachine(app);
        apps.add(app);
      }
      // Both join before either has read the roster, so both place at once.
      for (final app in apps) {
        await app.deskStartForTest();
      }
      gate.complete();
      await _settle();
      for (final app in apps) {
        await app.deskFetchForTest();
      }
      await _settle();

      final shared = desk.doc.tabs.where((t) => t.id == _deskTab).toList();
      expect(shared, hasLength(1));
      expect(shared.single.name, 'app');
      expect(shared.single.panes.map((p) => p.key), [_key('ma', 'a1')]);
      for (final app in apps) {
        final tabs = app.swarms.where((s) => s.id == _deskTab).toList();
        expect(tabs, hasLength(1));
        expect(tabs.single.panes.map((p) => (p.machineId, p.agentId)), [
          ('ma', 'a1'),
        ]);
        // Not selected: placement is not the person's gesture.
        expect(app.activeSwarmId, isNot(_deskTab));
      }
    });

    test('placement waits for the grant: an unknown machine re-reads the machines, and places after', () async {
      final desk = _Desk();
      final store = MemoryStore();
      final api = _Api(desk)..list = [_own, _aliceMachine()];
      final daemon = _Daemon(_shares());
      final app = _app(api, daemon, store: store);
      addTearDown(app.dispose);
      // Alice's machine is not in this window's inventory yet.
      await app.deskStartForTest();
      await _settle();

      expect(api.machineReads, greaterThanOrEqualTo(1));
      // The grant is a harness share: the read reads the shares, which it otherwise does every few minutes.
      expect(api.sharesTold, 1);
      expect(app.machineStates['ma']?.machine.isShared, isTrue);
      expect(desk.tab(_deskTab)?.panes.map((p) => p.key), [_key('ma', 'a1')]);
      final placed = jsonDecode(store.values[_placedKey]!) as Map;
      expect(placed[_tab], [_key('ma', 'a1')]);
      // Placed as a shared pane at once (seam 2).
      final pane = app.allPanes.singleWhere((p) => p.machineId == 'ma');
      expect(pane.sharedHarness?.agentId, 'a1');
      expect(daemon.sent, isNot(contains('share_add')));
    });

    test('a shared tab the member closed does not come back when a harness joins (Review Focus 1)', () async {
      final desk = _Desk();
      final daemon = _Daemon(_shares());
      final app = _app(_Api(desk), daemon);
      addTearDown(app.dispose);
      _addAliceMachine(
        app,
        agents: [
          for (final id in ['a1', 'a2'])
            Agent(
              id: id,
              name: 'Harness $id',
              engine: 'claude',
              terminalAvailable: true,
            ),
        ],
      );
      await app.deskStartForTest();
      await _settle();
      expect(desk.tab(_deskTab), isNotNull);

      await app.closeSwarm(_deskTab);
      await _settle();
      expect(desk.tab(_deskTab), isNull);

      daemon.shares = _shares(foreign: ['ma/a1', 'ma/a2']);
      await app.sharedTabs.refresh();
      await _settle();
      expect(desk.tab(_deskTab), isNull);
      expect(app.swarms.where((s) => s.id == _deskTab), isEmpty);
    });

    test('a pane the member closed is not placed again; a harness that joins later is', () async {
      final desk = _Desk();
      final daemon = _Daemon(_shares());
      final app = _app(_Api(desk), daemon);
      addTearDown(app.dispose);
      _addAliceMachine(
        app,
        agents: [
          for (final id in ['a1', 'a2'])
            Agent(
              id: id,
              name: 'Harness $id',
              engine: 'claude',
              terminalAvailable: true,
            ),
        ],
      );
      await app.deskStartForTest();
      await _settle();
      // Keep the tab: one of Bob's own harnesses in it.
      await app.assignAgentToPane(
        null,
        'm',
        'a0',
        swarmId: _deskTab,
        focus: false,
      );
      final foreign = app.swarms
          .singleWhere((s) => s.id == _deskTab)
          .panes
          .singleWhere((p) => p.machineId == 'ma');
      await app.closePane(foreign.id, swarmId: _deskTab);
      await _settle();
      expect(desk.tab(_deskTab)?.panes.map((p) => p.key), [_key('m', 'a0')]);

      daemon.shares = _shares(foreign: ['ma/a1', 'ma/a2']);
      await app.sharedTabs.refresh();
      await _settle();
      expect(desk.tab(_deskTab)?.panes.map((p) => p.key), [
        _key('m', 'a0'),
        _key('ma', 'a2'),
      ]);
    });

    test('a relaunch keeps the member\'s tab under its derived desk id, and _deskJoin gives it no new one (R1)', () async {
      final desk = _Desk();
      final store = MemoryStore();
      final first = _app(_Api(desk), _Daemon(_shares()), store: store);
      _addAliceMachine(first);
      await first.deskStartForTest();
      await _settle();
      await first.flushPaneLayout();
      first.dispose();
      expect(desk.tab(_deskTab), isNotNull);

      final again = _app(_Api(desk), _Daemon(_shares()), store: store);
      addTearDown(again.dispose);
      _addAliceMachine(again);
      await again.restorePaneLayoutForTest();
      await again.deskStartForTest();
      await _settle();

      expect(desk.doc.tabs.where((t) => t.id == _deskTab), hasLength(1));
      expect(
        desk.doc.tabs.where(
          (t) => t.panes.any((p) => p.key == _key('ma', 'a1')),
        ),
        hasLength(1),
      );
      expect(again.swarms.where((s) => s.id == _deskTab), hasLength(1));
      // A desk id in shape, so a released desktop leaves it alone too.
      expect(isDeskId(_deskTab), isTrue);
      // The member's tab has its Agent Messages log, like any desk tab.
      expect(again.agentMessagesOffered(_deskTab), isTrue);
    });

    test('Show Agent Messages on a member\'s desk tab reads the shared tab id\'s log, and its own (R1)', () async {
      final desk = _Desk();
      final daemon = _Daemon(_shares());
      final app = _app(_Api(desk), daemon);
      addTearDown(app.dispose);
      _addAliceMachine(app);
      await app.deskStartForTest();
      await _settle();
      final log = await app.readAgentMessages(_deskTab);
      final asked = [
        for (final p in daemon.asked)
          if (p['action'] == 'history') p['tabId'],
      ];
      // What crosses accounts is filed under the shared tab id; the member's
      // own harnesses' messages to each other under the desk tab.
      expect(asked, unorderedEquals([_tab, _deskTab]));
      expect(log.messages.map((m) => m.id), unorderedEquals(['msg-$_tab', 'msg-$_deskTab']));
      expect(log.reached, isTrue);
    });

    test('messages_changed for the shared tab id counts as traffic in the member\'s desk tab (R1)', () async {
      final desk = _Desk();
      final app = _app(_Api(desk), _Daemon(_shares()));
      addTearDown(app.dispose);
      _addAliceMachine(app);
      await app.deskStartForTest();
      await _settle();
      expect(app.agentMessages.trafficFor(_deskTab), 0);
      await app.handleEventForTest('m', {
        'type': 'messages_changed',
        'payload': {
          'tabId': _tab,
          'messageId': 'm1',
          'from': {'machineId': 'ma', 'agentId': 'a1'},
          'to': [
            {'machineId': 'm', 'agentId': 'a0'},
          ],
        },
      });
      expect(app.agentMessages.trafficFor(_deskTab), 1);
      expect(app.agentMessages.trafficFor(_tab), 0);
      // The recipient's pane is marked, as for any tab.
      expect(app.agentMessages.markFor('m', 'a0'), isNotNull);
      // A desk tab's own id names itself.
      await app.handleEventForTest('m', {
        'type': 'messages_changed',
        'payload': {'tabId': _deskTab, 'messageId': 'm2'},
      });
      expect(app.agentMessages.trafficFor(_deskTab), 2);
    });

    test('openSharedDeskTab makes a desk tab with that id, not selected', () async {
      final desk = _Desk();
      final app = _app(_Api(desk), _Daemon(_shares(foreign: const [])));
      addTearDown(app.dispose);
      await app.deskStartForTest();
      await _settle();
      final before = app.activeSwarmId;
      app.openSharedDeskTab('bbbbbbbbbbbbbbbbbbbbbbbb', 'web');
      app.openSharedDeskTab('bbbbbbbbbbbbbbbbbbbbbbbb', 'web');
      await _settle();
      expect(app.activeSwarmId, before);
      expect(
        app.swarms.where((s) => s.id == 'bbbbbbbbbbbbbbbbbbbbbbbb'),
        hasLength(1),
      );
      expect(desk.tab('bbbbbbbbbbbbbbbbbbbbbbbb')?.name, 'web');
    });
  });

  group('fix round 1', () {
    test('a hostile roster name reaches the desk as an accepted tab name, and later writes still flush', () async {
      final desk = _Desk();
      final hostile =
          '\u202Eevil\u0007${'x' * 120}\n${'y' * 80}\u200B';
      final daemon = _Daemon(_shares(name: hostile));
      final app = _app(_Api(desk), daemon);
      addTearDown(app.dispose);
      _addAliceMachine(app);
      await app.deskStartForTest();
      await _settle();

      expect(desk.refused, 0);
      final tab = desk.tab(_deskTab);
      expect(tab, isNotNull);
      expect(_badName(tab!.name), isFalse);
      expect(tab.name, startsWith('evil x'));
      expect(tab.name.length, lessThanOrEqualTo(80));
      expect(tab.panes.map((p) => p.key), [_key('ma', 'a1')]);

      // Nothing is wedged behind it: the next edit reaches the desk.
      await app.assignAgentToPane(null, 'm', 'a0', swarmId: _deskTab, focus: false);
      await _settle();
      expect(desk.tab(_deskTab)!.panes.map((p) => p.key), [
        _key('ma', 'a1'),
        _key('m', 'a0'),
      ]);
      expect(desk.refused, 0);
    });

    test('a name with nothing printable becomes a new tab', () async {
      final desk = _Desk();
      final app = _app(
        _Api(desk),
        _Daemon(_shares(name: '\u202E\u0007 \u200B')),
      );
      addTearDown(app.dispose);
      _addAliceMachine(app);
      await app.deskStartForTest();
      await _settle();
      expect(desk.refused, 0);
      expect(desk.tab(_deskTab)?.name, 'New Tab');
    });

    test('placements are kept per account: Alice\'s record never closes Bob\'s member tab on the same computer', () async {
      final store = MemoryStore();
      // Alice owns the shared tab: her desk tab holds her own harness, and
      // Bob's harness, which her window does not know yet, is recorded.
      final aliceDesk = _Desk()
        ..doc = DeskDoc(
          revision: 1,
          tabs: [
            DeskTab(
              id: 'd' * 32,
              name: 'app',
              nameIsCustom: true,
              panes: const [DeskPaneRef(machineId: 'm', agentId: 'a0')],
            ),
          ],
        );
      final alice = _app(
        _Api(aliceDesk),
        _Daemon(
          _shares(
            me: 'alice',
            foreign: ['mb/b1'],
            foreignAccount: 'bob',
            tabId: 'd' * 32,
          ),
        ),
        store: store,
      );
      await alice.deskStartForTest();
      await _settle();
      expect(store.values['shared_tabs.placed.alice'], isNotNull);
      alice.dispose();

      // Bob signs in on the same computer (same store), his own desk.
      final bobDesk = _Desk();
      final bob = _app(_Api(bobDesk), _Daemon(_shares()), store: store);
      addTearDown(bob.dispose);
      _addAliceMachine(bob);
      await bob.deskStartForTest();
      await _settle();
      expect(bobDesk.tab(_deskTab)?.panes.map((p) => p.key), [_key('ma', 'a1')]);
      expect(jsonDecode(store.values['shared_tabs.placed.bob']!)[_tab], [
        _key('ma', 'a1'),
      ]);
      // Alice's record is left as it was.
      expect(store.values['shared_tabs.placed.alice'], isNotNull);
    });

    test('a member tab takes the desk\'s 9; the 10th waits, unrecorded, and is placed when room frees', () async {
      final desk = _Desk();
      final store = MemoryStore();
      final ten = [for (var i = 1; i <= 10; i++) 'ma/a$i'];
      final daemon = _Daemon(_shares(foreign: ten));
      final app = _app(_Api(desk), daemon, store: store);
      addTearDown(app.dispose);
      _addAliceMachine(
        app,
        agents: [
          for (var i = 1; i <= 10; i++)
            Agent(
              id: 'a$i',
              name: 'Harness a$i',
              engine: 'claude',
              terminalAvailable: true,
            ),
        ],
      );
      await app.deskStartForTest();
      await _settle();
      expect(desk.tab(_deskTab)!.panes, hasLength(9));
      expect(
        desk.tab(_deskTab)!.panes.map((p) => p.key),
        isNot(contains(_key('ma', 'a10'))),
      );
      final placed = jsonDecode(store.values[_placedKey]!)[_tab] as List;
      expect(placed, hasLength(9));
      expect(placed, isNot(contains(_key('ma', 'a10'))));

      // a1 leaves the roster and its pane leaves the desk (another window).
      daemon.shares = _shares(foreign: ten.skip(1).toList());
      desk.doc = DeskDoc(
        revision: desk.doc.revision + 1,
        tabs: [
          for (final t in desk.doc.tabs)
            t.id == _deskTab
                ? DeskTab(
                    id: t.id,
                    name: t.name,
                    nameIsCustom: t.nameIsCustom,
                    panes: t.panes
                        .where((p) => p.key != _key('ma', 'a1'))
                        .toList(),
                  )
                : t,
        ],
      );
      await app.sharedTabs.refresh();
      await app.deskFetchForTest();
      await _settle();
      expect(desk.tab(_deskTab)!.panes, hasLength(9));
      expect(
        desk.tab(_deskTab)!.panes.map((p) => p.key),
        contains(_key('ma', 'a10')),
      );
      expect(
        jsonDecode(store.values[_placedKey]!)[_tab] as List,
        contains(_key('ma', 'a10')),
      );
    });

    test('the tab this account shares keeps its desk id when its only agent hands over to its shell', () async {
      final shared = 'd' * 32, plain = 'e' * 32;
      final desk = _Desk()
        ..doc = DeskDoc(
          revision: 1,
          tabs: [
            DeskTab(
              id: shared,
              name: 'app',
              nameIsCustom: true,
              panes: const [DeskPaneRef(machineId: 'm', agentId: 'a0')],
            ),
            DeskTab(
              id: plain,
              name: 'other',
              nameIsCustom: true,
              panes: const [DeskPaneRef(machineId: 'm', agentId: 'a1')],
            ),
          ],
        );
      final app = _app(
        _Api(desk),
        _Daemon(
          _shares(
            me: 'alice',
            foreign: const [],
            foreignAccount: 'bob',
            tabId: shared,
          ),
        ),
      );
      addTearDown(app.dispose);
      await app.deskStartForTest();
      await _settle();
      expect(app.sharedTabs.isShared(shared), isTrue);

      for (final agent in ['a0', 'a1']) {
        await app.handleEventForTest('m', {
          'type': 'agent_deleted',
          'payload': {
            'agentId': agent,
            'retained': true,
            'successor': 'shell-$agent',
          },
        });
      }
      await _settle();
      final sharedTab = app.swarms.where((s) => s.id == shared).toList();
      expect(sharedTab, hasLength(1));
      expect(sharedTab.single.panes.single.agentId, 'shell-a0');
      // An unshared tab is re-minted as before.
      expect(app.swarms.where((s) => s.id == plain), isEmpty);
      expect(
        app.swarms.where(
          (s) => s.panes.any((p) => p.agentId == 'shell-a1'),
        ),
        hasLength(1),
      );
    });

    test('before the first shares answer after a launch, no tab is re-minted when its only agent hands over (final review of 1c, B3)', () async {
      final shared = 'd' * 32;
      final desk = _Desk()
        ..doc = DeskDoc(
          revision: 1,
          tabs: [
            DeskTab(
              id: shared,
              name: 'app',
              nameIsCustom: true,
              panes: const [DeskPaneRef(machineId: 'm', agentId: 'a0')],
            ),
          ],
        );
      final daemon = _Daemon(
        _shares(me: 'alice', foreign: const [], foreignAccount: 'bob', tabId: shared),
      )..gate = Completer<void>();
      final app = _app(_Api(desk), daemon);
      addTearDown(app.dispose);
      await app.deskStartForTest();
      await _settle();
      // The shares are not read yet: whether this tab is shared is not known.
      expect(app.sharedTabs.state, SharedTabsState.unknown);
      await app.handleEventForTest('m', {
        'type': 'agent_deleted',
        'payload': {'agentId': 'a0', 'retained': true, 'successor': 'shell-a0'},
      });
      await _settle();
      final tab = app.swarms.where((s) => s.id == shared).toList();
      expect(tab, hasLength(1));
      expect(tab.single.panes.single.agentId, 'shell-a0');
      daemon.gate!.complete();
      await _settle();
      expect(app.sharedTabs.isShared(shared), isTrue);
    });

    test('a pane the desk restored before the roster was read asks for its machine once the roster says whose it is (seam 2)', () async {
      final desk = _Desk()
        ..doc = DeskDoc(
          revision: 1,
          tabs: [
            DeskTab(
              id: _deskTab,
              name: 'app',
              nameIsCustom: true,
              panes: const [DeskPaneRef(machineId: 'ma', agentId: 'a1')],
            ),
          ],
        );
      final api = _Api(desk)..list = [_own, _aliceMachine()];
      final gate = Completer<void>();
      final app = _app(api, _Daemon(_shares())..gate = gate);
      addTearDown(app.dispose);
      await app.deskStartForTest();
      await _settle();
      expect(api.machineReads, 0);
      final pane = app.allPanes.singleWhere((p) => p.machineId == 'ma');
      expect(pane.sharedHarness, isNull);

      gate.complete();
      await _settle();
      expect(api.machineReads, greaterThanOrEqualTo(1));
      expect(api.sharesTold, 1, reason: 'the machine is a harness share: the read reads the shares');
      expect(pane.sharedHarness?.agentId, 'a1');
      expect(pane.sharedOwnerName, 'Alice');
    });
  });

  group('seams', () {
    testWidgets('a desk-carried foreign pane is shared at once, never "Open here" (seam 2)', (tester) async {
      final desk = _Desk()
        ..doc = DeskDoc(
          revision: 1,
          tabs: [
            DeskTab(
              id: 'c' * 32,
              name: 'Work',
              nameIsCustom: true,
              panes: const [DeskPaneRef(machineId: 'ma', agentId: 'a1')],
            ),
          ],
        );
      // No roster: a desk another computer wrote, the inventory already in.
      final app = _app(_Api(desk), _Daemon(_shares(foreign: const [])));
      _addAliceMachine(app);
      await tester.runAsync(app.deskStartForTest);
      final pane = app.allPanes.singleWhere((p) => p.machineId == 'ma');
      expect(pane.sharedHarness?.agentId, 'a1');
      expect(pane.sharedOwnerName, 'Alice');

      app.selectSwarm('c' * 32);
      await _pumpGrid(tester, app);
      // Drawn from its grant (the observer channel), never the takeover offer.
      expect(find.byType(SharedHarnessPanel), findsOneWidget);
      expect(find.text('Open here'), findsNothing);
      // The panel's observer socket (refused under the test's HTTP mock)
      // closes with the tree.
      await tester.pumpWidget(const SizedBox());
      await tester.pump(const Duration(seconds: 3));
      app.dispose();
    });

    for (final named in [false, true]) {
      testWidgets('restored before the inventory, a foreign pane says "${named ? 'Alice Liddell' : '[email protected]'} · waiting" (seam 3)', (tester) async {
        final daemon = _Daemon(
          _shares(
            members: [
              if (named)
                {
                  'accountId': 'alice',
                  'email': '[email protected]',
                  'name': 'Alice Liddell',
                },
            ],
          ),
        );
        final app = _app(_Api(_Desk()), daemon);
        await tester.runAsync(app.sharedTabs.refresh);
        app.panes.add(TerminalPane(id: 900, machineId: 'ma', agentId: 'a1'));
        await _pumpGrid(tester, app);
        final name = named ? 'Alice Liddell' : '[email protected]';
        expect(find.text('$name · waiting'), findsOneWidget);
        expect(find.textContaining('This machine isn’t available'), findsNothing);
        expect(find.textContaining('Waiting for this machine'), findsNothing);
        expect(app.sharedWaitingName('ma', 'a1'), name);
        // A harness no roster lists keeps the ordinary wording.
        expect(app.sharedWaitingName('ma', 'other'), isNull);
        app.dispose();
      });
    }

    testWidgets('a foreign pane with retained output whose machine this window lacks says who it waits for (seam 3)', (tester) async {
      final app = _app(_Api(_Desk()), _Daemon(_shares()));
      await tester.runAsync(app.sharedTabs.refresh);
      app.panes.add(
        TerminalPane(id: 901, machineId: 'ma', agentId: 'a1')
          ..session = (TerminalSession(
            machineId: 'ma',
            agentId: 'a1',
            agentName: 'Harness a1',
            engineId: 'claude',
            readOnly: true,
            send: (_, _) async => true,
            sendBinary: (_) async => true,
          )
            ..status = TerminalSessionStatus.controlling
            ..streamId = 'stream-a1'),
      );
      await _pumpGrid(tester, app);
      // The compact pane header carries the notice as its status: label and
      // detail, as text where there is room and as its tooltip.
      bool says(Widget w, String text) =>
          (w is Text && (w.data ?? '').contains(text)) ||
          (w is Tooltip && (w.message ?? '').contains(text));
      expect(
        find.byWidgetPredicate((w) => says(w, '[email protected] · waiting')),
        findsWidgets,
      );
      expect(
        find.byWidgetPredicate((w) => says(w, 'isn’t available')),
        findsNothing,
      );
      expect(find.textContaining('Waiting for this machine'), findsNothing);
      await tester.pumpWidget(const SizedBox());
      app.dispose();
    });

    testWidgets('another account\'s hostile name waits on one plain line (seam 3)', (tester) async {
      final hostile = '\u202EAlice\n${'L' * 200}\u0007';
      final app = _app(
        _Api(_Desk()),
        _Daemon(
          _shares(
            members: [
              {'accountId': 'alice', 'email': '[email protected]', 'name': hostile},
            ],
          ),
        ),
      );
      await tester.runAsync(app.sharedTabs.refresh);
      app.panes.add(TerminalPane(id: 902, machineId: 'ma', agentId: 'a1'));
      await _pumpGrid(tester, app);
      final text = tester.widget<Text>(find.textContaining('· waiting'));
      expect(text.data, 'Alice ${'L' * 200} · waiting');
      expect(text.maxLines, 1);
      expect(text.overflow, TextOverflow.ellipsis);
      expect(tester.takeException(), isNull);
      app.dispose();
    });

    test('closing a foreign pane or its tab sends no stop (seam 4)', () async {
      final daemon = _Daemon(_shares(foreign: const []));
      final app = _app(_Api(_Desk()), daemon);
      addTearDown(app.dispose);
      _addAliceMachine(
        app,
        agents: [
          Agent(
            id: 'a1',
            name: 'Harness a1',
            engine: 'claude',
            terminalAvailable: true,
            closeSupported: true,
            sessionId: 's-a1',
            createdAt: DateTime.utc(2026, 10, 16),
          ),
        ],
      );
      app.stateOf('m')!.agents = [
        Agent(
          id: 'a0',
          name: 'Own 0',
          engine: 'codex',
          terminalAvailable: true,
          closeSupported: true,
          sessionId: 's-a0',
          createdAt: DateTime.utc(2026, 10, 16),
        ),
      ];
      final reviewed = <List<(String, Agent)>>[];
      app.reviewSessionClose = (targets, {tabName, canStop}) async {
        reviewed.add(targets);
        return true;
      };

      await app.assignAgentToPane(null, 'ma', 'a1', focus: false);
      final foreign = app.panes.singleWhere((p) => p.machineId == 'ma');
      await app.requestClosePane(foreign.id);
      await _settle();
      expect(reviewed, isEmpty);
      expect(app.allPanes.where((p) => p.machineId == 'ma'), isEmpty);

      await app.assignAgentToPane(null, 'ma', 'a1', focus: false);
      await app.assignAgentToPane(null, 'm', 'a0', focus: false);
      await app.requestCloseSwarm(app.activeSwarmId);
      await _settle();
      expect(reviewed, hasLength(1));
      expect(reviewed.single.map((t) => t.$1), ['m']);
      expect(daemon.sent, isNot(contains('agent_close')));
      expect(daemon.sent, isNot(contains('stop_agent')));
    });

    test('the status bar names the owner for a focused foreign pane (seam 5)', () async {
      final app = _app(_Api(_Desk()), _Daemon(_shares()));
      addTearDown(app.dispose);
      _addAliceMachine(app);
      await app.assignAgentToPane(null, 'ma', 'a1');
      final context = WorkspacePaneContext.focused(app)!;
      expect(context.machineName, 'Alice');
      app.panes.single.sharedOwnerName = '\u202EAl\u0007ice\n';
      expect(WorkspacePaneContext.focused(app)!.machineName, 'Al ice');
      app.panes.single.sharedOwnerName = 'Alice';
      expect(context.shared, isTrue);
      expect(context.location, startsWith('Alice'));

      await app.assignAgentToPane(null, 'm', 'a0');
      final own = WorkspacePaneContext.focused(app)!;
      expect(own.machineName, 'This Mac');
      expect(own.shared, isFalse);
    });
  });
}