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.

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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.mjs
new file mode 100644
index 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 => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[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.ts
index 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 = null
private orchestratorService: OrchestratorService | null = null
private 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.dart
new file mode 100644
index 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.dart
index 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.dart
index 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);