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.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
test: exercise orchestrator through local daemon tmux and live viewers
Dee0f361bceca8e
diff --git a/cli/scripts/orchestrator-e2e-peer.ts b/cli/scripts/orchestrator-e2e-peer.tsnew file mode 100644index 000000000..cedb2cdfa--- /dev/null+++ b/cli/scripts/orchestrator-e2e-peer.ts@@ -0,0 +1,115 @@+/** Isolated daemon adapter + real tmux + real viewers. No live Harness state. */+import { execFile } from 'node:child_process'+import { createServer } from 'node:http'+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises'+import { tmpdir } from 'node:os'+import { join, dirname, resolve } from 'node:path'+import { fileURLToPath } from 'node:url'+import { randomBytes } from 'node:crypto'+import { promisify } from 'node:util'++if (process.env.HARNESS_ORCHESTRATOR_E2E !== '1') throw new Error('Opt in with HARNESS_ORCHESTRATOR_E2E=1')+const exec = promisify(execFile)+const root = await mkdtemp(join(tmpdir(), 'orchestrator-e2e-'))+const cliRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')+const socket = join(root, 'tmux.sock')+const machineId = randomBytes(16).toString('hex')+const loader = fileURLToPath(import.meta.resolve('tsx'))+Object.assign(process.env, {+ ADAPTER_DATA_DIR: join(root, 'data'), ADAPTER_RUNTIME_DIR: join(root, 'runtime'),+ HARNESS_AUTH_DIR: join(root, 'auth'), DSH_DIR: join(root, 'dsh'),+ ADAPTER_COMPUTER_ID_FILE: join(root, 'computer-id'),+ DISABLE_HOOK_INSTALL: 'true', DISABLE_GRID_INSTALL: 'true',+})+const [{ BackendSocket }, { attachLocalWsServer }, { registry }, { createAndRegisterPane },+ { installedDsh, upsertInstalledRecord }, { materializeWorkspace }, { DshViewerManager }, { shellQuote }] = await Promise.all([+ import('../src/backendSocket.js'), import('../src/localWsServer.js'), import('../src/lib/registry.js'), import('../src/lib/createAgentPane.js'),+ import('../src/dsh/installed.js'), import('../src/dsh/materialize.js'), import('../src/dsh/viewer.js'), import('../src/orchestrator/prompts.js'),+])+const backend = new BackendSocket(machineId)+const urls = new Map<string, string | null>()+const viewers = new DshViewerManager({ onUrl: (id, url) => urls.set(id, url), log: line => console.error(line) })+let created = 0, stopped = false+const inputs: string[] = []+const pending = new Set<Promise<unknown>>()+const track = (work: Promise<unknown>) => { pending.add(work); void work.catch(e => console.error(e)).finally(() => pending.delete(work)) }+const server = createServer(async (req, res) => {+ if (req.url === '/fixture-stats') { res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ created, inputs })); return }+ if (req.url !== '/fixture-event' || req.method !== 'POST') { res.writeHead(404); res.end(); return }+ let body = ''+ for await (const chunk of req) { body += chunk; if (body.length > 32_000) { res.writeHead(413); res.end(); return } }+ try {+ const event = JSON.parse(body)+ const agent = registry.list().find(a => a.cwd === event.cwd)+ if (!agent || !['text_delta', 'turn_started', 'turn_ended'].includes(event.type)) { res.writeHead(400); res.end(); return }+ backend.send({ type: event.type, agentId: agent.agentId, payload: { content: event.content } })+ res.end('ok')+ } catch { res.writeHead(400); res.end() }+})+const local = attachLocalWsServer(server, { machineId, backend })+await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve))+const port = (server.address() as { port: number }).port+backend.orchestratorCommand = `${[process.execPath, '--import', loader, join(cliRoot, 'src/cli.ts')].map(shellQuote).join(' ')} orchestrator --port ${port} --machine ${machineId}`+backend.engineProbeProvider = async (engines = ['claude']) => engines.map(engine => ({ engine, installed: true, command: process.execPath, installable: false }))+backend.dshFrameProvider = agent => ({ id: agent.dsh ?? null, name: agent.dsh ?? null, viewerUrl: urls.get(agent.agentId) ?? null, viewerName: 'Fixture viewer', verdict: null })+for (const name of ['shape', 'research', 'scene', 'film']) {+ const dir = join(root, 'dsh', 'fixture', name)+ await mkdir(dir, { recursive: true, mode: 0o700 })+ await writeFile(join(dir, 'AGENTS.md'), `This is the ${name} integration-test harness. Produce deliverable.txt and verify its inputs.\n`)+ await writeFile(join(dir, 'harness.json'), JSON.stringify({ spec: 1, id: `fixture/${name}`, name, engine: 'claude',+ description: `${name} deterministic integration fixture`, agent: { instructions: 'AGENTS.md' },+ ...(name === 'research' ? {} : { viewer: { command: `${shellQuote(process.execPath)} ${shellQuote(join(cliRoot, 'scripts/orchestrator-fixture-viewer.mjs'))}`, url: 'http://127.0.0.1:${port}/', artifactExtensions: ['.txt'] } }),+ }))+ upsertInstalledRecord({ id: `fixture/${name}`, dir, source: dir, ref: null, commit: null, linked: true, installedAt: Date.now() })+}+await mkdir(join(root, 'workspace'), { mode: 0o700 })+await exec('tmux', ['-S', socket, '-f', '/dev/null', 'new-session', '-d', '-s', 'fixture-keeper', '/bin/sleep', '3600'])+backend.onCreateAgent = async input => {+ const dsh = input.dsh ? installedDsh(input.dsh) : undefined+ if (dsh) await materializeWorkspace(dsh, input.cwd)+ const result = await createAndRegisterPane({+ tmuxBackend: {+ create: async request => {+ const result = await exec('tmux', ['-S', socket, 'new-session', '-d', '-P', '-F', '#{pane_id}', '-s', request.label!, '-c', input.cwd, ...request.command!])+ return { state: 'succeeded', dispatch: 'executed', runtime: { backend: 'tmux', paneId: result.stdout.trim() } }+ },+ kill: async runtime => {+ await exec('tmux', ['-S', socket, 'kill-pane', '-t', runtime.paneId])+ return { state: 'succeeded', dispatch: 'executed' }+ },+ },+ registry, engine: input.engine, cwd: input.cwd, dsh: input.dsh, defaultName: input.name,+ sessionLabel: `harness-fixture-${++created}`,+ argv: [process.execPath, '--import', loader, join(cliRoot, 'scripts/orchestrator-fixture-engine.ts'), input.cwd, dsh ? 'worker' : 'director', String(port), machineId, join(cliRoot, 'src/cli.ts'), loader],+ })+ if (!result.ok) return result+ if (dsh?.manifest.viewer) track(viewers.start(result.pending.agentId, dsh, input.cwd))+ return { ok: true, session: result.pending }+}+backend.onMessage = (id, text) => {+ const agent = registry.resolve(id)+ if (!agent?.tmuxPane) throw new Error('Fixture director unavailable')+ inputs.push(text)+ track(exec('tmux', ['-S', socket, 'send-keys', '-t', agent.tmuxPane, '-l', Buffer.from(text).toString('base64')])+ .then(() => exec('tmux', ['-S', socket, 'send-keys', '-t', agent.tmuxPane!, 'Enter'])))+}+backend.onCancel = id => {+ const pane = registry.resolve(id)?.tmuxPane+ if (pane) track(exec('tmux', ['-S', socket, 'send-keys', '-t', pane, 'C-c']))+}+async function cleanup(code: number) {+ if (stopped) return+ stopped = true+ await local.close(); await backend.stop(); await viewers.stopAll()+ await Promise.allSettled([...pending])+ await exec('tmux', ['-S', socket, 'kill-server']).catch(() => {})+ server.close()+ if (code === 0 && process.env.HARNESS_ORCHESTRATOR_KEEP !== '1') await rm(root, { recursive: true, force: true })+ else console.error(`Fixture files retained at ${root}`)+ process.exit(code)+}+process.stdin.resume(); process.stdin.on('end', () => { void cleanup(0) })+process.on('SIGTERM', () => { void cleanup(0) }); process.on('SIGINT', () => { void cleanup(0) })+process.on('uncaughtException', e => { console.error(e); void cleanup(1) })+process.on('unhandledRejection', e => { console.error(e); void cleanup(1) })+console.log(JSON.stringify({ port, machineId, workspace: join(root, 'workspace'), root }))diff --git a/cli/scripts/orchestrator-fixture-engine.ts b/cli/scripts/orchestrator-fixture-engine.tsnew file mode 100644index 000000000..007913d8f--- /dev/null+++ b/cli/scripts/orchestrator-fixture-engine.ts@@ -0,0 +1,63 @@+/** Deterministic model substitute. Real tmux, real CLI tools, no model billing. */+import { execFile } from 'node:child_process'+import { readFile, writeFile } from 'node:fs/promises'+import { join } from 'node:path'+import { createInterface } from 'node:readline'+import { promisify } from 'node:util'++const exec = promisify(execFile)+const [cwd, role, port, machine, cli, loader] = process.argv.slice(2)+process.chdir(cwd)+const brief = await readFile(join(cwd, role === 'director' ? 'ORCHESTRATOR.md' : 'ORCHESTRATOR_TASK.md'), 'utf8')+const projectId = role === 'director' ? /Project id: ([a-f0-9]{32})/.exec(brief)![1] : /project ([a-f0-9]{32}), task/.exec(brief)![1]+const tool = async (action: string, ...args: string[]) => {+ const result = await exec(process.execPath, ['--import', loader, cli, 'orchestrator', '--port', port, '--machine', machine, action, projectId, ...args], { env: process.env, timeout: 30_000, maxBuffer: 8 * 1024 * 1024 })+ const reply = JSON.parse(result.stdout)+ if (reply.error) throw new Error(reply.detail ?? reply.error)+ return reply+}+const event = async (type: string, content = '') => {+ await fetch(`http://127.0.0.1:${port}/fixture-event`, { method: 'POST', body: JSON.stringify({ cwd, type, content }) })+}+let stopped = false+process.on('SIGINT', () => { stopped = true; console.log('FIXTURE_TURN_CANCELLED') })+setInterval(() => {}, 1000)+if (role === 'director') {+ // This is the only substitute: a known plan stands in for model inference.+ await new Promise(resolve => setTimeout(resolve, 300))+ await event('turn_started')+ await event('text_delta', 'I’m combining shape, research, scene, and film specialists.')+ const tasks = [+ { id: 'shape', title: 'Shape', harness: 'fixture/shape', prompt: 'Build a verified shape fixture', dependsOn: [] },+ { id: 'research', title: 'Research', harness: 'fixture/research', prompt: 'Write product context', dependsOn: [] },+ { id: 'scene', title: 'Scene', harness: 'fixture/scene', prompt: 'Combine geometry and product context', dependsOn: ['shape', 'research'] },+ { id: 'film', title: 'Film', harness: 'fixture/film', prompt: 'Make a launch sequence from the scene', dependsOn: ['scene'] },+ ]+ await tool('plan', JSON.stringify(tasks))+ await event('turn_ended')+ let chain = Promise.resolve()+ createInterface({ input: process.stdin }).on('line', line => {+ chain = chain.then(async () => {+ if (stopped) return+ const text = Buffer.from(line.trim(), 'base64').toString('utf8')+ await event('turn_started')+ const reply = await tool('status')+ if (reply.project.tasks.every((t: { state: string }) => t.state === 'succeeded') && reply.project.state === 'active') {+ await tool('complete', 'All four fixture specialists finished and their exact artifact versions were handed off.')+ }+ await event('text_delta', text.startsWith('[Orchestrator result]') ? 'A specialist result arrived and I checked project status.' : `Received your direction: ${text}`)+ await event('turn_ended')+ }).catch(error => console.error(error))+ })+} else {+ const match = /task ([a-z0-9-]+), attempt (\d+)/.exec(brief)!+ const [, taskId, attempt] = match+ await new Promise(resolve => setTimeout(resolve, 1200))+ if (!stopped) {+ const inputs = taskId === 'scene' ? ['shape', 'research'] : taskId === 'film' ? ['scene'] : []+ const consumed = await Promise.all(inputs.map(id => readFile(join(cwd, 'inputs', id, 'deliverable.txt'), 'utf8')))+ const result = `Verified ${taskId} fixture\n${consumed.join('\n')}`+ await writeFile(join(cwd, 'deliverable.txt'), result)+ await tool('finish', taskId, attempt, `${taskId} checks passed; consumed ${inputs.join(', ') || 'no upstream files'}`, 'deliverable.txt')+ }+}diff --git a/cli/scripts/orchestrator-fixture-viewer.mjs b/cli/scripts/orchestrator-fixture-viewer.mjsnew file mode 100644index 000000000..756cb1e5a--- /dev/null+++ b/cli/scripts/orchestrator-fixture-viewer.mjs@@ -0,0 +1,10 @@+// A real loopback viewer process, with deliberately non-CAD fixture output.+import { createServer } from 'node:http'+import { readFile } from 'node:fs/promises'+import { join } from 'node:path'+const escape = text => text.replace(/[&<>"']/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' })[c])+createServer(async (_req, res) => {+ const text = await readFile(join(process.env.HARNESS_WORKSPACE, 'deliverable.txt'), 'utf8').catch(() => 'Waiting for the fixture specialist…')+ res.setHeader('Content-Type', 'text/html; charset=utf-8')+ res.end(`<html><body style="font:18px system-ui;padding:24px"><h1>Orchestrator fixture viewer</h1><pre style="white-space:pre-wrap">${escape(text)}</pre></body></html>`)+}).listen(Number(process.env.HARNESS_VIEWER_PORT), '127.0.0.1')diff --git a/cli/src/backendSocket.ts b/cli/src/backendSocket.tsindex 7b09d8626..1a6542855 100644--- a/cli/src/backendSocket.ts+++ b/cli/src/backendSocket.ts@@ -385,12 +385,14 @@ export class BackendSocket {private readonly agentCreations = new AgentCreationReceipts(join(env.ADAPTER_DATA_DIR, 'agent-creations'))/** Injectable for queue-isolation tests; production uses the machine-local probe. */engineProbeProvider: typeof probeEngines = probeEngines+ /** Entrypoint override for isolated integration fixtures; never a wire option. */+ orchestratorCommand: string | null = nullprivate orchestratorService: OrchestratorService | null = nullprivate orchestration(): OrchestratorService {return this.orchestratorService ??= new OrchestratorService({stateDir: join(env.ADAPTER_DATA_DIR, 'orchestrator'),workspaceDir: join(homedir(), 'harnesses', 'orchestrated'),- command: `${shellQuote(process.execPath)} ${shellQuote(process.argv[1])} orchestrator --port ${env.PORT} --machine ${shellQuote(this.machineId)}`,+ command: this.orchestratorCommand ?? `${[process.execPath, ...process.execArgv, process.argv[1]].map(shellQuote).join(' ')} orchestrator --port ${env.PORT} --machine ${shellQuote(this.machineId)}`,catalog: () => listInstalledDsh().filter(d => d.manifest.kind !== 'viewer' && !!d.manifest.engine && supportsFirstPrompt(d.manifest.engine)).map(d => ({id: d.id, name: d.manifest.name, description: d.manifest.description ?? '', engine: d.manifest.engine!, viewer: !!d.manifest.viewer,})),diff --git a/desktop/test/orchestrator_local_e2e_test.dart b/desktop/test/orchestrator_local_e2e_test.dartnew file mode 100644index 000000000..1919f5364--- /dev/null+++ b/desktop/test/orchestrator_local_e2e_test.dart@@ -0,0 +1,201 @@+import 'dart:async';+import 'dart:convert';+import 'dart:io';++import 'package:flutter_test/flutter_test.dart';+import 'package:harness/ws/ws_conn.dart';++void main() {+ final cli = Platform.environment['HARNESS_ORCHESTRATOR_CLI_ROOT'];+ test(+ 'real local socket, background tmux specialists, live viewers, handoffs and reconnect',+ () async {+ if (cli == null) return;+ final fixture = await Process.start(+ 'node',+ ['--import', 'tsx', 'scripts/orchestrator-e2e-peer.ts'],+ workingDirectory: cli,+ environment: {'HARNESS_ORCHESTRATOR_E2E': '1'},+ );+ final errors = StringBuffer();+ fixture.stderr.transform(utf8.decoder).listen(errors.write);+ final ready = Completer<Map<String, dynamic>>();+ fixture.stdout+ .transform(utf8.decoder)+ .transform(const LineSplitter())+ .listen(+ (line) {+ try {+ final value = jsonDecode(line);+ if (value is Map<String, dynamic> &&+ value.containsKey('port') &&+ !ready.isCompleted)+ ready.complete(value);+ } catch (_) {+ /* daemon diagnostics */+ }+ },+ onDone: () {+ if (!ready.isCompleted)+ ready.completeError(StateError('Fixture exited: $errors'));+ },+ );+ addTearDown(() async {+ await fixture.stdin.close();+ await fixture.exitCode.timeout(+ const Duration(seconds: 30),+ onTimeout: () {+ fixture.kill();+ return -1;+ },+ );+ });+ final config = await ready.future.timeout(const Duration(seconds: 40));+ WsConn? connection;+ Future<void> connect() async {+ connection = WsConn(+ wsBaseUrl: 'ws://unused.invalid',+ autonomousEnv: 'prod',+ machineId: config['machineId'] as String,+ transportKind: WsTransportKind.localPlaintext,+ localWsUri: Uri.parse(+ 'ws://127.0.0.1:${config['port']}/api/local-ws',+ ),+ accessTokenProvider: (_, _) async => 'unused',+ onAuthFailure: (_) {},+ onEvent: (_) {},+ onStatus: (_) {},+ );+ await connection!.connect();+ await connection!.waitUntilReady(timeout: const Duration(seconds: 10));+ }++ addTearDown(() async => connection?.close());+ Future<Map<String, dynamic>> ask(Map<String, dynamic> payload) =>+ connection!.request(+ 'orchestrator',+ payload: payload,+ timeout: const Duration(seconds: 30),+ );+ Future<Map<String, dynamic>> until(+ String id,+ bool Function(Map<String, dynamic>) matches,+ ) async {+ final deadline = DateTime.now().add(const Duration(seconds: 90));+ Map<String, dynamic> last = {};+ while (DateTime.now().isBefore(deadline)) {+ last =+ (await ask({'action': 'status', 'id': id}))['project']+ as Map<String, dynamic>;+ if (matches(last)) return last;+ await Future<void>.delayed(const Duration(milliseconds: 200));+ }+ fail('Project timed out: ${jsonEncode(last)}\n$errors');+ }++ await connect();+ const id = 'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';+ final start = {+ 'action': 'start',+ 'id': id,+ 'prompt': 'Make a shape, research its story, build a scene, and create a film',+ 'engine': 'claude',+ 'cwd': config['workspace'],+ 'parallelism': 2,+ };+ await ask(start);+ await ask(start);+ final working = await until(+ id,+ (p) =>+ (p['tasks'] as List).where((t) => t['state'] == 'running').length >=+ 2,+ );+ expect(working['directorId'], isNotNull);+ await ask({+ 'action': 'message',+ 'id': id,+ 'messageId': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',+ 'text': 'Keep the lighting warm',+ });+ await connection!.close();+ await connect();+ final done = await until(id, (p) => p['state'] == 'completed');+ expect(+ (done['tasks'] as List).map((t) => t['state']),+ everyElement('succeeded'),+ );+ final film = (done['tasks'] as List).singleWhere(+ (t) => t['id'] == 'film',+ );+ expect(+ await File('${film['cwd']}/deliverable.txt').readAsString(),+ allOf(+ contains('shape fixture'),+ contains('research fixture'),+ contains('scene fixture'),+ ),+ );+ expect(film['inputs'], {'scene': 1});+ expect(+ (done['messages'] as List).any(+ (m) => (m['text'] as String).contains(+ 'Received your direction: Keep the lighting warm',+ ),+ ),+ isTrue,+ );+ final http = HttpClient();+ addTearDown(http.close);+ final withViews = await until(+ id,+ (p) =>+ (p['tasks'] as List)+ .where((t) => t['runtime']?['viewerUrl'] != null)+ .length ==+ 3,+ );+ for (final task in (withViews['tasks'] as List).where(+ (t) => t['runtime']?['viewerUrl'] != null,+ )) {+ final response = await (await http.getUrl(+ Uri.parse(task['runtime']['viewerUrl'] as String),+ )).close();+ expect(+ await response.transform(utf8.decoder).join(),+ contains('Verified ${task['id']} fixture'),+ );+ }+ final stats = jsonDecode(+ await (await (await http.getUrl(+ Uri.parse('http://127.0.0.1:${config['port']}/fixture-stats'),+ )).close()).transform(utf8.decoder).join(),+ ) as Map;+ expect(+ stats['created'],+ 5,+ reason: 'One director and four specialists, despite duplicate start and reconnect.',+ );+ const cancelled = 'dddddddddddddddddddddddddddddddd';+ await ask({...start, 'id': cancelled});+ await until(+ cancelled,+ (p) => (p['tasks'] as List).any((t) => t['state'] == 'running'),+ );+ await ask({'action': 'cancel', 'id': cancelled});+ final stopped = await until(cancelled, (p) => p['state'] == 'cancelled');+ expect(+ (stopped['tasks'] as List).every((t) => t['state'] != 'running'),+ isTrue,+ );+ expect(+ (await ask({'action': 'status', 'id': id}))['project']['state'],+ 'completed',+ );+ },+ skip: cli == null+ ? 'Set HARNESS_ORCHESTRATOR_CLI_ROOT to the isolated CLI checkout.'+ : false,+ timeout: const Timeout(Duration(minutes: 4)),+ );+}diff --git a/desktop/test/shortcuts_test.dart b/desktop/test/shortcuts_test.dartindex 9153cdae2..5c6653f5d 100644--- a/desktop/test/shortcuts_test.dart+++ b/desktop/test/shortcuts_test.dart@@ -263,10 +263,8 @@ void main() {expect(chordsFor(ShortcutAction.lastPane), contains('⌘;'));expect(chordsFor(ShortcutAction.newSwarm), ['⌘T']);expect(chordsFor(ShortcutAction.showLayout), ['⌘S']);- expect(- appShortcuts().where((s) => describeShortcut(s.activator) == '⌘P'),- isEmpty,- );+ expect(chordsFor(ShortcutAction.orchestrate), ['⌘P']);+ expect(chordsFor(ShortcutAction.routeTask), ['⌘B']);expect(chordsFor(ShortcutAction.addAgent), ['⌘O']);expect(chordsFor(ShortcutAction.newAgent), ['⌘N']);expect(chordsFor(ShortcutAction.showAttention), ['⇧⌘I']);@@ -320,7 +318,9 @@ void main() {test('the digits are one row, at the end of their own group', () {final rows = shortcutRows();- final digits = rows.indexWhere((row) => row.label == 'Select harnesses 1–9');+ final digits = rows.indexWhere(+ (row) => row.label == 'Select harnesses 1–9',+ );expect(digits, isNot(-1));expect(rows[digits].chords, [['⌘', '1 – 9'],diff --git a/desktop/test/swarm_switcher_test.dart b/desktop/test/swarm_switcher_test.dartindex ea4809cec..996f0d301 100644--- a/desktop/test/swarm_switcher_test.dart+++ b/desktop/test/swarm_switcher_test.dart@@ -4,6 +4,7 @@ import 'package:flutter_test/flutter_test.dart';import 'package:harness/shortcuts/keymap_commands.dart';import 'package:harness/terminal/terminal_binary.dart';import 'package:harness/widgets/swarm_switcher.dart';+import 'package:harness/orchestrator/orchestrator_launcher.dart';import 'keymap_runtime_test.dart' show native;import 'swarm_interactions_test.dart' show chord;@@ -42,8 +43,12 @@ void main() {isFalse,);await chord(tester, LogicalKeyboardKey.keyP);+ expect(find.byType(OrchestratorLauncher), findsOneWidget);expect(jumpField, findsNothing);expect(app.swarms, [original]);+ await tester.sendKeyEvent(LogicalKeyboardKey.escape);+ await tester.pumpAndSettle();+ expect(find.byType(OrchestratorLauncher), findsNothing);if (nativeTabs) {await native(tester, 'jump');expect(jumpField, findsNothing);