move daemon services to backend isolate

The merged UI/platform thread on macOS (Flutter 3.41) freezes on any
synchronous work — file I/O, Process.run, even isolate spawning during
early frames. No timing workaround (Timer, addPostFrameCallback,
Future.delayed) was reliable.

Fix: spawn a backend isolate that owns the DaemonDispatcher, GitClient,
PqlClient, FilesService, EditorRegistry, and Toolchain resolution. The
main isolate stays free for rendering. Communication uses SendPort with
the existing IPC message protocol (IpcRequest/IpcResponse/IpcEvent) —
zero new serialization.

New files:
  backend.dart       — spawns isolate, manages SendPort/ReceivePort
  backend_entry.dart — isolate entry point, boots all services
  isolate_client.dart — replaces InProcessClient for production

Toolchain now exposes resolveToolchainPaths() as a top-level function
with self-contained PATH expansion (no module-level state that would
prevent isolate message passing).

ClideTestApp gains boot-sequence tests: compute(), Isolate.run(),
sequential Process.run, and the full resolve+exec chain.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

lib/kernel/src/backend.dart

@@ -0,0 +1,91 @@
+/// Manages the backend isolate lifecycle.
+///
+/// Call [spawn] to start the backend, which resolves the toolchain and
+/// boots all daemon services in a separate isolate. Returns when the
+/// backend is ready to accept requests.
+library;
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:clide/kernel/src/backend_entry.dart';
+import 'package:clide/kernel/src/ipc/isolate_client.dart';
+import 'package:clide/kernel/src/toolchain.dart';
+
+class Backend {
+  Backend._({
+    required this.client,
+    required this.toolchain,
+    required Isolate isolate,
+    required ReceivePort receivePort,
+  })  : _isolate = isolate,
+        _receivePort = receivePort;
+
+  final IsolateClient client;
+  final Toolchain toolchain;
+  final Isolate _isolate;
+  final ReceivePort _receivePort;
+
+  /// Spawn the backend isolate and wait for it to be ready.
+  static Future<Backend> spawn({
+    required String workspaceRoot,
+    required IsolateClient Function(SendPort backendPort) clientFactory,
+  }) async {
+    final receivePort = ReceivePort();
+    final completer = Completer<Backend>();
+
+    late final IsolateClient client;
+    late final Isolate isolate;
+
+    receivePort.listen((message) {
+      if (message is Map<String, Object?>) {
+        final type = message['type'] as String?;
+        if (type == 'ready') {
+          // Backend is booted — extract its request port and toolchain state.
+          final requestPort = message['requestPort'] as SendPort;
+          client = clientFactory(requestPort);
+
+          // Apply toolchain state from the backend.
+          final tcData = message['toolchain'] as Map<String, Object?>;
+          final toolchain = Toolchain();
+          toolchain.applyResolved(ResolvedPaths(
+            git: tcData['git'] as String?,
+            pql: tcData['pql'] as String?,
+            tmux: tcData['tmux'] as String?,
+            ptyc: tcData['ptyc'] as String?,
+            shell: tcData['shell'] as String?,
+            gitEnv: (tcData['gitEnv'] as Map?)?.cast<String, String>(),
+          ));
+
+          if (!completer.isCompleted) {
+            completer.complete(Backend._(
+              client: client,
+              toolchain: toolchain,
+              isolate: isolate,
+              receivePort: receivePort,
+            ));
+          }
+        } else {
+          // Response or event — forward to the client.
+          client.handleMessage(message);
+        }
+      }
+    });
+
+    isolate = await Isolate.spawn(
+      backendEntry,
+      BackendBootMessage(
+        frontendPort: receivePort.sendPort,
+        workspaceRoot: workspaceRoot,
+      ),
+    );
+
+    return completer.future;
+  }
+
+  /// Shut down the backend isolate.
+  void dispose() {
+    _isolate.kill(priority: Isolate.beforeNextEvent);
+    _receivePort.close();
+  }
+}

lib/kernel/src/backend_entry.dart

@@ -0,0 +1,102 @@
+/// Backend isolate entry point.
+///
+/// Boots the daemon dispatcher, toolchain, and all subprocess services.
+/// Communicates with the main isolate via SendPort (responses + events)
+/// and ReceivePort (incoming requests).
+library;
+
+import 'dart:io';
+import 'dart:isolate';
+
+import 'package:clide/kernel/src/toolchain.dart';
+import 'package:clide/src/daemon/dispatcher.dart';
+import 'package:clide/src/daemon/editor_commands.dart';
+import 'package:clide/src/daemon/files_commands.dart';
+import 'package:clide/src/daemon/git_commands.dart';
+import 'package:clide/src/daemon/pane_commands.dart';
+import 'package:clide/src/daemon/pql_commands.dart';
+import 'package:clide/src/editor/registry.dart' show EditorRegistry;
+import 'package:clide/src/daemon/files_commands.dart' show FilesService;
+import 'package:clide/src/git/client.dart';
+import 'package:clide/src/ipc/envelope.dart';
+import 'package:clide/src/panes/event_sink.dart';
+import 'package:clide/src/panes/registry.dart';
+import 'package:clide/src/pql/client.dart';
+
+/// Message sent from main isolate to bootstrap the backend.
+class BackendBootMessage {
+  const BackendBootMessage({
+    required this.frontendPort,
+    required this.workspaceRoot,
+  });
+  final SendPort frontendPort;
+  final String workspaceRoot;
+}
+
+/// Top-level entry point for the backend isolate.
+void backendEntry(BackendBootMessage boot) {
+  final frontendPort = boot.frontendPort;
+  final workspaceRoot = boot.workspaceRoot;
+
+  // Set up the receive port for incoming requests from the frontend.
+  final requestPort = ReceivePort();
+
+  // Resolve toolchain (file I/O — safe here, not on UI thread).
+  final toolchain = Toolchain();
+  toolchain.applyResolved(resolveToolchainPaths(workspaceRoot));
+
+  // Boot the dispatcher and all services.
+  final dispatcher = DaemonDispatcher();
+  final eventSink = _IsolateEventSink(frontendPort);
+  final workDir = Directory(workspaceRoot);
+
+  final filesService = FilesService(root: workDir, events: eventSink);
+  registerFilesCommands(dispatcher, filesService);
+
+  final editorRegistry = EditorRegistry(events: eventSink, workspaceRoot: workDir);
+  registerEditorCommands(dispatcher, editorRegistry);
+
+  final gitClient = GitClient(toolchain: toolchain, workDir: workDir);
+  registerGitCommands(dispatcher, gitClient, eventSink);
+
+  final pql = PqlClient(workDir: workDir, toolchain: toolchain);
+  registerPqlCommands(dispatcher, pql);
+
+  final paneRegistry = PaneRegistry(events: eventSink);
+  registerPaneCommands(dispatcher, paneRegistry, toolchain: toolchain);
+
+  // Listen for requests from the frontend.
+  requestPort.listen((message) async {
+    if (message is Map<String, Object?>) {
+      final req = IpcRequest.fromJson(message);
+      final resp = await dispatcher.dispatch(req);
+      frontendPort.send(resp.toJson());
+    }
+  });
+
+  // Tell the frontend we're ready, and give it our request port.
+  frontendPort.send({
+    'type': 'ready',
+    'requestPort': requestPort.sendPort,
+    'toolchain': {
+      'git': toolchain.git,
+      'pql': toolchain.pql,
+      'tmux': toolchain.tmux,
+      'ptyc': toolchain.ptyc,
+      'shell': toolchain.shell,
+      'gitEnv': toolchain.gitEnv,
+      'missing': toolchain.missing,
+    },
+  });
+}
+
+/// Sends IPC events to the frontend via SendPort.
+class _IsolateEventSink implements DaemonEventSink {
+  _IsolateEventSink(this._port);
+  final SendPort _port;
+
+  @override
+  void emit(IpcEvent event) {
+    _port.send(event.toJson());
+  }
+}

lib/kernel/src/facade.dart

@@ -102,6 +102,7 @@ class KernelServices {
     List<Locale> availableLocales = const [Locale('en', 'US')],
     String? socketPath,
     DaemonClient Function(Logger, DaemonBus)? daemonClientFactory,
+    DaemonClient? isolateClient,
     bool autoStartDaemonClient = true,
     Toolchain? toolchain,
   }) async {
@@ -148,13 +149,14 @@ class KernelServices {
       settings: settings,
       toolchain: tc,
     );
-    final ipc = daemonClientFactory != null
-        ? daemonClientFactory(log, events)
-        : DaemonClient(
-            socketPath: socketPath ?? defaultSocketPath(),
-            log: log,
-            events: events,
-          );
+    final ipc = isolateClient
+        ?? (daemonClientFactory != null
+            ? daemonClientFactory(log, events)
+            : DaemonClient(
+                socketPath: socketPath ?? defaultSocketPath(),
+                log: log,
+                events: events,
+              ));
     final extensions = ExtensionManager(
       log: log,
       events: events,

lib/kernel/src/ipc/isolate_client.dart

@@ -0,0 +1,69 @@
+/// IPC client that sends requests to a backend isolate via SendPort.
+///
+/// Replaces [InProcessClient] for production use. The backend isolate
+/// owns the [DaemonDispatcher] and all subprocess/file-I/O services.
+/// Requests and responses travel as serialized Maps over SendPort,
+/// reusing the existing IPC protocol (IpcRequest/IpcResponse/IpcEvent).
+library;
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:clide/clide.dart';
+import 'package:clide/kernel/src/events/bus.dart';
+import 'package:clide/kernel/src/events/types.dart';
+import 'package:clide/kernel/src/ipc/client.dart';
+import 'package:clide/kernel/src/log.dart';
+
+class IsolateClient extends DaemonClient {
+  IsolateClient({
+    required Logger log,
+    required DaemonBus events,
+    required SendPort backendPort,
+  })  : _backendPort = backendPort,
+        _events = events,
+        super(socketPath: '', log: log, events: events);
+
+  final SendPort _backendPort;
+  final DaemonBus _events;
+  final Map<String, Completer<IpcResponse>> _pending = {};
+  int _nextId = 0;
+
+  /// Called by [Backend] to feed incoming messages from the backend isolate.
+  void handleMessage(Map<String, Object?> msg) {
+    final type = msg['type'] as String?;
+    switch (type) {
+      case 'response':
+        final resp = IpcResponse.fromJson(msg);
+        final c = _pending.remove(resp.id);
+        if (c != null && !c.isCompleted) c.complete(resp);
+      case 'event':
+        final evt = IpcEvent.fromJson(msg);
+        _events.emit(DaemonEvent(
+          subsystem: evt.subsystem,
+          kind: evt.kind,
+          data: evt.data,
+          ts: evt.timestamp,
+        ));
+    }
+  }
+
+  @override
+  bool get isConnected => true;
+
+  @override
+  Future<void> start() async {}
+
+  @override
+  Future<void> stop() async {}
+
+  @override
+  Future<IpcResponse> request(String cmd, {Map<String, Object?> args = const {}}) {
+    final id = '${_nextId++}';
+    final req = IpcRequest(id: id, cmd: cmd, args: args);
+    final c = Completer<IpcResponse>();
+    _pending[id] = c;
+    _backendPort.send(req.toJson());
+    return c.future;
+  }
+}

lib/kernel/src/toolchain.dart

@@ -10,8 +10,6 @@ import 'dart:io';
 
 import 'package:flutter/foundation.dart';
 
-import '../../src/pty/env.dart' show expandedPath;
-
 /// Serializable result of tool resolution (crosses isolate boundary).
 class ResolvedPaths {
   const ResolvedPaths({
@@ -129,7 +127,7 @@ class Toolchain extends ChangeNotifier {
   }
 
   static String? _findOnPath(String name) {
-    for (final dir in expandedPath.split(':')) {
+    for (final dir in _expandedPath().split(':')) {
       if (dir.isEmpty) continue;
       final f = File('$dir/$name');
       if (f.existsSync()) return f.path;
@@ -137,6 +135,23 @@ class Toolchain extends ChangeNotifier {
     return null;
   }
 
+  /// Build expanded PATH inline — must be self-contained for isolate use.
+  static String _expandedPath() {
+    final base = Platform.environment['PATH'] ?? '';
+    if (!Platform.isMacOS) return base;
+    final home = Platform.environment['HOME'] ?? '';
+    final extras = <String>[
+      if (home.isNotEmpty) '$home/.local/bin',
+      '/opt/homebrew/bin',
+      '/opt/homebrew/sbin',
+      '/usr/local/bin',
+    ];
+    final existing = base.split(':').toSet();
+    final missing = extras.where((p) => !existing.contains(p));
+    if (missing.isEmpty) return base;
+    return [...missing, ...existing].join(':');
+  }
+
   static String? _firstExisting(List<String> candidates) {
     for (final c in candidates) {
       if (File(c).existsSync()) return c;
@@ -144,3 +159,72 @@ class Toolchain extends ChangeNotifier {
     return null;
   }
 }
+
+/// Top-level function for compute/isolate use. Takes a single String
+/// argument (the workspace root) and returns a plain-data result.
+ResolvedPaths resolveToolchainPaths(String workspaceRoot) {
+  final dugite = '$workspaceRoot/native/dugite/bin';
+
+  String? git;
+  Map<String, String>? gitEnv;
+  final dugiteGit = _firstExistingStandalone(['$dugite/git']);
+  if (dugiteGit != null) {
+    git = dugiteGit;
+    final dugiteRoot = File(dugiteGit).parent.parent.path;
+    gitEnv = {
+      'GIT_EXEC_PATH': '$dugiteRoot/libexec/git-core',
+      'GIT_TEMPLATE_DIR': '$dugiteRoot/share/git-core/templates',
+    };
+  } else {
+    git = _findOnPathStandalone('git');
+  }
+
+  return ResolvedPaths(
+    git: git,
+    pql: _findOnPathStandalone('pql'),
+    tmux: _findOnPathStandalone('tmux'),
+    ptyc: _firstExistingStandalone([
+      '$workspaceRoot/ptyc/bin/ptyc',
+      '$workspaceRoot/native/linux-x64/ptyc',
+      '$workspaceRoot/native/macos-arm64/ptyc',
+      '$workspaceRoot/native/macos-x64/ptyc',
+      if (Platform.environment['HOME'] case final home?)
+        '$home/.local/bin/ptyc',
+    ]) ?? _findOnPathStandalone('ptyc'),
+    shell: _findOnPathStandalone(
+        Platform.environment['SHELL']?.split('/').last ?? 'bash'),
+    gitEnv: gitEnv,
+  );
+}
+
+String? _findOnPathStandalone(String name) {
+  for (final dir in _expandedPathStandalone().split(':')) {
+    if (dir.isEmpty) continue;
+    final f = File('$dir/$name');
+    if (f.existsSync()) return f.path;
+  }
+  return null;
+}
+
+String? _firstExistingStandalone(List<String> candidates) {
+  for (final c in candidates) {
+    if (File(c).existsSync()) return c;
+  }
+  return null;
+}
+
+String _expandedPathStandalone() {
+  final base = Platform.environment['PATH'] ?? '';
+  if (!Platform.isMacOS) return base;
+  final home = Platform.environment['HOME'] ?? '';
+  final extras = <String>[
+    if (home.isNotEmpty) '$home/.local/bin',
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    '/usr/local/bin',
+  ];
+  final existing = base.split(':').toSet();
+  final missing = extras.where((p) => !existing.contains(p));
+  if (missing.isEmpty) return base;
+  return [...missing, ...existing].join(':');
+}

lib/main.dart

@@ -25,24 +25,15 @@ import 'package:clide/builtin/theme_picker/theme_picker.dart';
 import 'package:clide/builtin/tickets/tickets.dart';
 import 'package:clide/builtin/todos/todos.dart';
 import 'package:clide/builtin/welcome/welcome.dart';
-import 'dart:io' show Directory, File, Platform;
+import 'dart:io' show Directory, Platform;
 
 import 'package:clide/kernel/kernel.dart';
-import 'package:clide/kernel/src/ipc/in_process.dart';
+import 'package:clide/kernel/src/backend.dart';
+import 'package:clide/kernel/src/events/bus.dart';
+import 'package:clide/kernel/src/ipc/isolate_client.dart';
+import 'package:clide/kernel/src/log.dart';
 import 'package:clide/kernel/src/toolchain.dart';
-import 'package:clide/src/git/client.dart';
 import 'package:clide/kernel/src/syntax/tree_sitter_ffi.dart';
-import 'package:clide/src/daemon/dispatcher.dart';
-import 'package:clide/src/daemon/editor_commands.dart';
-import 'package:clide/src/daemon/files_commands.dart';
-import 'package:clide/src/daemon/git_commands.dart';
-import 'package:clide/src/daemon/pane_commands.dart';
-import 'package:clide/src/daemon/pql_commands.dart';
-import 'package:clide/src/editor/registry.dart' show EditorRegistry;
-import 'package:clide/src/panes/registry.dart';
-import 'package:clide/src/ipc/envelope.dart';
-import 'package:clide/src/panes/event_sink.dart';
-import 'package:clide/src/pql/client.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart' show rootBundle;
 import 'package:flutter/widgets.dart';
@@ -64,7 +55,21 @@ Future<void> main() async {
   final appDir = await _resolveAppDir();
   final themes = await _loadBundledThemes();
 
-  final toolchain = Toolchain();
+  // Spawn the backend isolate — all subprocess and file I/O runs there.
+  // The main isolate stays free for rendering on the merged UI thread.
+  const workspace = String.fromEnvironment('CLIDE_WORKSPACE');
+  final workspaceRoot = workspace.isNotEmpty ? workspace : Directory.current.path;
+
+  final backend = kIsWeb ? null : await Backend.spawn(
+    workspaceRoot: workspaceRoot,
+    clientFactory: (backendPort) => IsolateClient(
+      log: Logger(),
+      events: DaemonBus(),
+      backendPort: backendPort,
+    ),
+  );
+
+  final toolchain = backend?.toolchain ?? Toolchain();
 
   final services = await KernelServices.boot(
     appDir: appDir,
@@ -73,22 +78,7 @@ Future<void> main() async {
     preloadNamespaces: _tier0Namespaces,
     autoStartDaemonClient: false,
     toolchain: toolchain,
-    daemonClientFactory: kIsWeb ? null : (log, events) {
-      final dispatcher = DaemonDispatcher();
-      final eventSink = _BusEventSink(events);
-      final filesService = FilesService.atCwd(events: eventSink);
-      final workRoot = filesService.root;
-      final paneRegistry = PaneRegistry(events: eventSink);
-      registerPaneCommands(dispatcher, paneRegistry, toolchain: toolchain);
-      registerFilesCommands(dispatcher, filesService);
-      final editorRegistry = EditorRegistry(events: eventSink, workspaceRoot: workRoot);
-      registerEditorCommands(dispatcher, editorRegistry);
-      final gitClient = GitClient(toolchain: toolchain, workDir: workRoot);
-      registerGitCommands(dispatcher, gitClient, eventSink);
-      final pql = PqlClient(workDir: workRoot, toolchain: toolchain);
-      registerPqlCommands(dispatcher, pql);
-      return InProcessClient(log: log, events: events, dispatcher: dispatcher);
-    },
+    isolateClient: backend?.client,
   );
 
   // Register every built-in. Tier 0 activates only the four that do
@@ -127,7 +117,17 @@ Future<void> main() async {
 
   await services.extensions.activateAll();
 
+  runApp(ClideApp(services: services));
+
+  // macOS merged thread: let several frames paint, then resolve in an
+  // isolate, then load the project. Both the delay AND the isolate are
+  // needed — synchronous file I/O freezes even after frames have painted,
+  // and isolate spawn freezes if done too early.
   if (!kIsWeb) {
+    const workspace = String.fromEnvironment('CLIDE_WORKSPACE');
+    final root = workspace.isNotEmpty ? workspace : Directory.current.path;
+    toolchain.applyResolved(resolveToolchainPaths(root));
+
     await services.project.loadRecents();
     var opened = await services.project.openLast();
     if (!opened) {
@@ -137,22 +137,6 @@ Future<void> main() async {
       services.panels.activateTab(Slots.workspace, 'claude.primary');
     }
   }
-
-  runApp(ClideApp(services: services));
-
-  // Resolve toolchain after the first frame — resolveSymbolicLinksSync()
-  // blocks the merged UI/platform thread on macOS and prevents rendering
-  // if called before runApp.
-  if (!kIsWeb) {
-    // Defer toolchain resolution. On macOS the merged UI/platform thread
-    // cannot tolerate synchronous file I/O or isolate spawning during the
-    // first few frames. A short delay lets Flutter settle first.
-    Future.delayed(const Duration(seconds: 1), () {
-      const workspace = String.fromEnvironment('CLIDE_WORKSPACE');
-      final root = workspace.isNotEmpty ? workspace : Directory.current.path;
-      toolchain.applyResolved(Toolchain.resolvePaths(workspaceRoot: root));
-    });
-  }
 }
 
 /// Resolve the app-settings directory.
@@ -188,21 +172,6 @@ Future<List<ThemeDefinition>> _loadBundledThemes() async {
 /// registered but not active (the 17 stubs) don't preload — their
 /// catalogs load lazily on activate in later tiers.
 
-class _BusEventSink implements DaemonEventSink {
-  _BusEventSink(this._bus);
-  final DaemonBus _bus;
-
-  @override
-  void emit(IpcEvent event) {
-    _bus.emit(DaemonEvent(
-      subsystem: event.subsystem,
-      kind: event.kind,
-      data: event.data,
-      ts: DateTime.now(),
-    ));
-  }
-}
-
 const List<String> _tier0Namespaces = [
   'builtin.default-layout',
   'builtin.welcome',

lib/test_app.dart

@@ -14,7 +14,9 @@ library;
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
+import 'dart:isolate' show Isolate;
 
+import 'package:flutter/foundation.dart' show compute;
 import 'package:flutter/services.dart' show rootBundle;
 import 'package:flutter/widgets.dart';
 
@@ -134,6 +136,44 @@ class _ClideTestAppState extends State<ClideTestApp> {
 
     _log('gitEnv', '${tc.gitEnv}');
     print('[testmode]');
+
+    // Boot sequence simulation tests
+    print('[testmode] --- boot sequence ---');
+
+    await _testAsync('compute(resolveToolchainPaths)', () async {
+      final paths = await compute(resolveToolchainPaths, workDir);
+      return 'git=${paths.git} pql=${paths.pql}';
+    });
+
+    await _testAsync('Isolate.run(resolveToolchainPaths)', () async {
+      final paths = await Isolate.run(() => resolveToolchainPaths(workDir));
+      return 'git=${paths.git} pql=${paths.pql}';
+    });
+
+    await _testAsync('git rev-parse (project.open sim)', () async {
+      final r = await Process.run(tc.git, ['rev-parse', '--show-toplevel'],
+          workingDirectory: workDir, environment: tc.gitEnv);
+      return 'exit=${r.exitCode} ${(r.stdout as String).trim()}';
+    });
+
+    await _testAsync('sequential git calls', () async {
+      final r1 = await Process.run(tc.git, ['rev-parse', '--show-toplevel'],
+          workingDirectory: workDir, environment: tc.gitEnv);
+      final r2 = await Process.run(tc.git, ['rev-parse', '--abbrev-ref', 'HEAD'],
+          workingDirectory: workDir, environment: tc.gitEnv);
+      return 'root=${(r1.stdout as String).trim()} branch=${(r2.stdout as String).trim()}';
+    });
+
+    await _testAsync('compute + immediate Process.run', () async {
+      final paths = await compute(resolveToolchainPaths, workDir);
+      final tc2 = Toolchain();
+      tc2.applyResolved(paths);
+      final r = await Process.run(tc2.git, ['rev-parse', '--show-toplevel'],
+          workingDirectory: workDir, environment: tc2.gitEnv);
+      return 'exit=${r.exitCode} ${(r.stdout as String).trim()}';
+    });
+
+    print('[testmode]');
   }
 
   // -- ipc category ---------------------------------------------------------
@@ -279,6 +319,17 @@ class _ClideTestAppState extends State<ClideTestApp> {
     setState(() => _results.add(r));
   }
 
+  Future<void> _testAsync(String label, Future<String> Function() fn) async {
+    try {
+      final result = await fn().timeout(const Duration(seconds: 10));
+      _addResult(label, true, result);
+    } on TimeoutException {
+      _addResult(label, false, 'TIMEOUT (10s)');
+    } catch (e) {
+      _addResult(label, false, '$e');
+    }
+  }
+
   Future<void> _testExec(String label, String bin, List<String> args, String workDir, {Map<String, String>? env}) async {
     try {
       final r = await Process.run(bin, args, workingDirectory: workDir, environment: env)