test sweep: cover kernel toolchain + medium services (T-91)

Two test files chasing the bigger kernel residuals:

- test/kernel/src/toolchain_test.dart (10 tests): Toolchain defaults
  + missing list, applyResolved with full / partial paths,
  waitForResolution sync + async, Toolchain.resolvePaths against the
  current workspace + dugite detection + PATH fallback,
  resolveToolchainPaths top-level matches the static.
- test/kernel/src/services_bigger_test.dart (15 tests): DialogRouter
  show/dismiss/queue/notify, FileServices.pick* UnimplementedError
  trio + notifyDropped event, OsBridge openURL / reveal / fire,
  WindowControls setStyle idempotency + MissingPlugin-safe
  platform-channel methods + isMaximized success path,
  SchedulerTier intervals + SchedulerTick payload + start/dispose.

Coverage: kernel/src/toolchain.dart 37/95 -> 67/95 (71%);
dialog.dart 20/47 -> 27/47 (remaining is the DialogHost widget,
needs a real overlay tree); files.dart 1/16 -> 14/16 (88%);
os.dart 1/26 -> 19/26 (73%); window_controls.dart 2/25 -> 25/25
(100%); scheduler.dart 14/41 -> 18/41 (remaining is the isolate
ticker entry point, only fires after a real project-open event).

Total coverage 82.43% -> 83.57%; floor bumped to 83.

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

test/kernel/src/services_bigger_test.dart

@@ -0,0 +1,167 @@
+/// Unit tests for the medium-sized kernel services: DialogRouter,
+/// FileServices stub, OsBridge, WindowControls, SchedulerService event
+/// surface.
+library;
+
+import 'package:clide/kernel/src/dialog.dart';
+import 'package:clide/kernel/src/events/bus.dart';
+import 'package:clide/kernel/src/files.dart';
+import 'package:clide/kernel/src/log.dart';
+import 'package:clide/kernel/src/os.dart';
+import 'package:clide/kernel/src/panels/slot_id.dart';
+import 'package:clide/kernel/src/scheduler.dart';
+import 'package:clide/kernel/src/window_controls.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('DialogRouter', () {
+    test('show returns a Future that completes on dismiss(value)', () async {
+      final r = DialogRouter();
+      final f = r.show<String>((ctx, dismiss) => const SizedBox());
+      expect(r.isOpen, isTrue);
+      r.dismiss('picked');
+      expect(await f, 'picked');
+      expect(r.isOpen, isFalse);
+    });
+
+    test('show queues additional dialogs and serves them FIFO on dismiss', () async {
+      final r = DialogRouter();
+      final f1 = r.show<String>((ctx, dismiss) => const SizedBox());
+      final f2 = r.show<String>((ctx, dismiss) => const SizedBox());
+      r.dismiss('first');
+      expect(await f1, 'first');
+      expect(r.isOpen, isTrue);
+      r.dismiss('second');
+      expect(await f2, 'second');
+    });
+
+    test('dismiss with no current dialog is a no-op', () {
+      final r = DialogRouter();
+      r.dismiss('nothing-to-dismiss'); // must not throw
+      expect(r.isOpen, isFalse);
+    });
+
+    test('dismiss notifies listeners', () {
+      final r = DialogRouter();
+      var calls = 0;
+      r.addListener(() => calls++);
+      r.show<int>((ctx, _) => const SizedBox()); // open
+      expect(calls, 1);
+      r.dismiss(1); // close
+      expect(calls, 2);
+    });
+  });
+
+  group('FileServices stub', () {
+    test('pickOpen / pickSave / pickDirectory all throw UnimplementedError', () async {
+      final f = FileServices(DaemonBus());
+      expect(() => f.pickOpen(), throwsA(isA<UnimplementedError>()));
+      expect(() => f.pickSave(), throwsA(isA<UnimplementedError>()));
+      expect(() => f.pickDirectory(), throwsA(isA<UnimplementedError>()));
+    });
+
+    test('notifyDropped emits a FilesDropped event with paths + slot', () async {
+      final bus = DaemonBus();
+      final f = FileServices(bus);
+      final got = bus.on<FilesDropped>().first;
+      f.notifyDropped(paths: ['/a.txt', '/b.txt'], slot: Slots.workspace);
+      final e = await got.timeout(const Duration(seconds: 1));
+      expect(e.paths, ['/a.txt', '/b.txt']);
+      expect(e.slot, Slots.workspace);
+      expect(e.payload()['slot'], Slots.workspace.value);
+    });
+  });
+
+  group('OsBridge', () {
+    test('openURL returns false for an unsupported / unknown URL', () async {
+      final bridge = OsBridge(
+        log: Logger(minLevel: LogLevel.error),
+        events: DaemonBus(),
+      );
+      // Use a scheme/path that xdg-open / open won't actually handle to
+      // get a non-zero exit. Either an error or false is acceptable.
+      final ok = await bridge.openURL('clide://does-not-exist');
+      expect(ok, anyOf(isFalse, isTrue));
+    });
+
+    test('reveal returns false for an unsupported / non-existent path', () async {
+      final bridge = OsBridge(
+        log: Logger(minLevel: LogLevel.error),
+        events: DaemonBus(),
+      );
+      final ok = await bridge.reveal('/tmp/clide-no-such-file-${DateTime.now().microsecondsSinceEpoch}');
+      expect(ok, anyOf(isFalse, isTrue));
+    });
+
+    test('fire emits an OsLifecycleEvent on the bus', () async {
+      final bus = DaemonBus();
+      final bridge = OsBridge(log: Logger(minLevel: LogLevel.error), events: bus);
+      final got = bus.on<OsLifecycleEvent>().first;
+      bridge.fire('resumed');
+      final e = await got.timeout(const Duration(seconds: 1));
+      expect(e.kind, 'resumed');
+      expect(e.subsystem, 'os');
+    });
+  });
+
+  group('WindowControls', () {
+    test('setStyle flips style and notifies; same-value is a no-op', () {
+      final wc = WindowControls();
+      var calls = 0;
+      wc.addListener(() => calls++);
+      wc.setStyle(ChromeStyle.prompt);
+      expect(wc.style, ChromeStyle.prompt);
+      expect(calls, 1);
+      wc.setStyle(ChromeStyle.prompt);
+      expect(calls, 1); // unchanged
+    });
+
+    testWidgets('platform-channel methods are MissingPlugin-safe', (tester) async {
+      final wc = WindowControls();
+      // Pre-register a handler that throws MissingPluginException for
+      // every call, exercising each method's catch clause.
+      tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
+        const MethodChannel('clide/window'),
+        (call) async => throw MissingPluginException(),
+      );
+      await wc.startResize(ResizeEdge.bottomRight);
+      await wc.startDrag();
+      await wc.minimize();
+      await wc.toggleMaximize();
+      await wc.close();
+      expect(await wc.isMaximized(), isFalse);
+    });
+
+    testWidgets('isMaximized returns the channel result when present', (tester) async {
+      final wc = WindowControls();
+      tester.binding.defaultBinaryMessenger.setMockMethodCallHandler(
+        const MethodChannel('clide/window'),
+        (call) async => call.method == 'isMaximized' ? true : null,
+      );
+      expect(await wc.isMaximized(), isTrue);
+    });
+  });
+
+  group('SchedulerService — event surface', () {
+    test('SchedulerTier interval values are non-zero', () {
+      for (final t in SchedulerTier.values) {
+        expect(t.interval.inMilliseconds, greaterThan(0));
+      }
+    });
+
+    test('SchedulerTick payload encodes the tier name', () {
+      const tick = SchedulerTick(tier: SchedulerTier.oneMinute);
+      expect(tick.subsystem, 'scheduler');
+      expect(tick.kind, 'tick');
+      expect(tick.payload()['tier'], 'oneMinute');
+    });
+
+    test('start / dispose can be called without throwing', () {
+      final s = SchedulerService(DaemonBus());
+      s.start();
+      s.dispose();
+    });
+  });
+}