add app test suite — unit, widget, golden, a11y (168 tests)

Four layers under app/test/:

  * kernel/, extension/ — unit tests for every kernel service and
    the extension contract. i18n fallback chain gets the full
    matrix (exact/lang/default/placeholder, namespace isolation,
    unknown namespace, interpolation). Theme resolver and
    extension-manager topo sort covered.
  * widgets/, builtin/ — widget tests for every primitive and each
    Tier 0 built-in. Assertions reach into the Semantics node so
    a missing label fails structurally, not visually.
  * goldens/ — Alchemist + Ahem font for cross-platform pixel
    stability; primitives only (button, tab bar, icon set). No
    goldens for compositions — they'd churn through every tier.
  * a11y/ — contract-level gate: semantic coverage walks the
    built-in catalogue, contrast walks every token pair in every
    bundled theme against WCAG-AA thresholds (catches real
    regressions: the first run caught `tab.inactive_text` at 2.81
    in summer-night), i18n coverage asserts every referenced key
    exists in its catalog (exists-in-map, not "key == value" — too
    ambiguous for keys that happen to equal their translation).

Helpers under helpers/: `KernelFixture.create()` boots a
KernelServices with in-memory stores + a FakeDaemonClient (no
socket, drivable connected-state), `widget_harness` wraps a
widget in the minimum tree that resolves theme + i18n.

Co-Authored-By: Claude <noreply@anthropic.com>

app/test/kernel/src/commands/keybindings_test.dart

@@ -0,0 +1,45 @@
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('Keybinding.parse + equality', () {
+    test('parses single-key bindings', () {
+      final k = Keybinding.parse('g');
+      expect(k.key, 'g');
+      expect(k.modifiers, isEmpty);
+    });
+
+    test('parses modifier chains case-insensitively', () {
+      final a = Keybinding.parse('Ctrl+Shift+G');
+      final b = Keybinding.parse('shift+ctrl+g');
+      expect(a, equals(b));
+      expect(a.canonical, 'ctrl+shift+g');
+    });
+
+    test('rejects empty string', () {
+      expect(() => Keybinding.parse(''), throwsA(isA<ArgumentError>()));
+    });
+
+    test('canonical modifier order is deterministic', () {
+      final k = Keybinding.parse('alt+ctrl+shift+x');
+      expect(k.modifiers, ['alt', 'ctrl', 'shift']);
+    });
+  });
+
+  group('KeybindingResolver', () {
+    test('bind + lookup round-trips', () {
+      final r = KeybindingResolver();
+      r.bind(Keybinding.parse('ctrl+shift+g'), 'git.commit');
+      expect(r.commandFor(Keybinding.parse('ctrl+shift+g')), 'git.commit');
+      expect(r.commandFor(Keybinding.parse('ctrl+g')), isNull);
+    });
+
+    test('unbind removes the mapping', () {
+      final r = KeybindingResolver();
+      final k = Keybinding.parse('ctrl+p');
+      r.bind(k, 'palette.open');
+      r.unbind(k);
+      expect(r.commandFor(k), isNull);
+    });
+  });
+}

app/test/kernel/src/commands/palette_test.dart

@@ -0,0 +1,61 @@
+import 'package:clide/clide.dart';
+import 'package:clide_app/extension/extension.dart';
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+CommandContribution _cmd(String id, {String? title}) => CommandContribution(
+      id: id,
+      command: id,
+      title: title,
+      run: (_) async => IpcResponse.ok(id: '', data: const {}),
+    );
+
+void main() {
+  group('PaletteController', () {
+    late CommandRegistry registry;
+    late PaletteController palette;
+
+    setUp(() {
+      registry = CommandRegistry();
+      registry.register(_cmd('git.commit', title: 'Git: Commit'));
+      registry.register(_cmd('git.push', title: 'Git: Push'));
+      registry.register(_cmd('theme.pick', title: 'Theme: Pick…'));
+      palette = PaletteController(registry);
+    });
+
+    test('open/close toggles isOpen and clears filter', () {
+      palette.open();
+      palette.setFilter('git');
+      expect(palette.isOpen, true);
+      expect(palette.filter, 'git');
+      palette.close();
+      expect(palette.isOpen, false);
+      expect(palette.filter, '');
+    });
+
+    test('filtered empty filter returns all commands', () {
+      expect(palette.filtered().length, 3);
+    });
+
+    test('filter is case-insensitive against title or command', () {
+      palette.setFilter('git');
+      expect(
+        palette.filtered().map((c) => c.command).toSet(),
+        {'git.commit', 'git.push'},
+      );
+      palette.setFilter('PICK');
+      expect(
+        palette.filtered().map((c) => c.command).toSet(),
+        {'theme.pick'},
+      );
+    });
+
+    test('invoke closes the palette + runs the command', () async {
+      palette.open();
+      palette.setFilter('git');
+      await palette.invoke('git.commit');
+      expect(palette.isOpen, false);
+      expect(palette.filter, '');
+    });
+  });
+}

app/test/kernel/src/commands/registry_test.dart

@@ -0,0 +1,51 @@
+import 'package:clide/clide.dart';
+import 'package:clide_app/extension/extension.dart';
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+CommandContribution _cmd(String name, Future<IpcResponse> Function() run) =>
+    CommandContribution(
+      id: name,
+      command: name,
+      title: 'cmd $name',
+      run: (_) => run(),
+    );
+
+void main() {
+  group('CommandRegistry', () {
+    test('register exposes the command; all enumerates', () {
+      final r = CommandRegistry();
+      r.register(_cmd('a', () async => IpcResponse.ok(id: '', data: const {})));
+      r.register(_cmd('b', () async => IpcResponse.ok(id: '', data: const {})));
+      expect(r.all.map((c) => c.command).toList(), ['a', 'b']);
+      expect(r.get('a'), isNotNull);
+    });
+
+    test('execute returns the handler response', () async {
+      final r = CommandRegistry();
+      r.register(
+        _cmd(
+          'ping',
+          () async => IpcResponse.ok(id: '', data: const {'pong': true}),
+        ),
+      );
+      final resp = await r.execute('ping');
+      expect(resp.ok, true);
+      expect(resp.data['pong'], true);
+    });
+
+    test('execute on unknown returns NotFound error', () async {
+      final r = CommandRegistry();
+      final resp = await r.execute('missing');
+      expect(resp.ok, false);
+      expect(resp.error!.code, IpcExitCode.notFound);
+    });
+
+    test('unregister removes the command', () {
+      final r = CommandRegistry();
+      r.register(_cmd('x', () async => IpcResponse.ok(id: '', data: const {})));
+      r.unregister('x');
+      expect(r.get('x'), isNull);
+    });
+  });
+}

app/test/kernel/src/events/bus_test.dart

@@ -0,0 +1,69 @@
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('EventBus', () {
+    late EventBus bus;
+
+    setUp(() => bus = EventBus());
+    tearDown(() => bus.dispose());
+
+    test('emit delivers to stream subscribers', () async {
+      final events = <ClideEventEnvelope>[];
+      final sub = bus.stream.listen(events.add);
+      bus.emit(const ThemeChanged(themeName: 'summer-night'));
+      await Future<void>.delayed(Duration.zero);
+      expect(events, hasLength(1));
+      expect(events.first.event, isA<ThemeChanged>());
+      await sub.cancel();
+    });
+
+    test('on<T>() filters by runtime type', () async {
+      final themes = <ThemeChanged>[];
+      final extensions = <ExtensionActivated>[];
+      final s1 = bus.on<ThemeChanged>().listen(themes.add);
+      final s2 = bus.on<ExtensionActivated>().listen(extensions.add);
+      bus.emit(const ThemeChanged(themeName: 'a'));
+      bus.emit(const ExtensionActivated(id: 'builtin.git'));
+      bus.emit(const ThemeChanged(themeName: 'b'));
+      await Future<void>.delayed(Duration.zero);
+      expect(themes.map((e) => e.themeName), ['a', 'b']);
+      expect(extensions.map((e) => e.id), ['builtin.git']);
+      await s1.cancel();
+      await s2.cancel();
+    });
+
+    test('broadcasts to multiple listeners independently', () async {
+      final a = <ClideEvent>[];
+      final b = <ClideEvent>[];
+      final s1 = bus.stream.listen((e) => a.add(e.event));
+      final s2 = bus.stream.listen((e) => b.add(e.event));
+      bus.emit(const ThemeChanged(themeName: 'x'));
+      await Future<void>.delayed(Duration.zero);
+      expect(a, hasLength(1));
+      expect(b, hasLength(1));
+      await s1.cancel();
+      await s2.cancel();
+    });
+
+    test('emit after dispose is a silent no-op', () async {
+      await bus.dispose();
+      // must not throw
+      bus.emit(const ThemeChanged(themeName: 'nope'));
+    });
+
+    test('envelope stamps a timestamp', () async {
+      final capture = <ClideEventEnvelope>[];
+      final sub = bus.stream.listen(capture.add);
+      final before = DateTime.now().toUtc();
+      bus.emit(const ThemeChanged(themeName: 'n'));
+      await Future<void>.delayed(Duration.zero);
+      final after = DateTime.now().toUtc();
+      expect(capture, hasLength(1));
+      final ts = capture.first.timestamp;
+      expect(ts.isAfter(before) || ts.isAtSameMomentAs(before), isTrue);
+      expect(ts.isBefore(after) || ts.isAtSameMomentAs(after), isTrue);
+      await sub.cancel();
+    });
+  });
+}

app/test/kernel/src/extensions_manager_test.dart

@@ -0,0 +1,192 @@
+import 'package:clide/clide.dart';
+import 'package:clide_app/extension/extension.dart';
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../../helpers/kernel_fixture.dart';
+
+/// Minimal no-op extension used as a test actor.
+class _Ext extends ClideExtension {
+  _Ext({
+    required this.id,
+    this.dependsOn = const [],
+    this.contributions = const [],
+    this.onActivate,
+    this.onDeactivate,
+  });
+
+  @override
+  final String id;
+  @override
+  String get title => id;
+  @override
+  String get version => '0.0.0-test';
+  @override
+  final List<String> dependsOn;
+  @override
+  final List<ContributionPoint> contributions;
+
+  final Future<void> Function(ClideExtensionContext ctx)? onActivate;
+  final Future<void> Function()? onDeactivate;
+
+  @override
+  Future<void> activate(ClideExtensionContext ctx) async {
+    if (onActivate != null) await onActivate!(ctx);
+  }
+
+  @override
+  Future<void> deactivate() async {
+    if (onDeactivate != null) await onDeactivate!();
+  }
+}
+
+void main() {
+  group('ExtensionManager', () {
+    late KernelFixture f;
+
+    setUp(() async {
+      f = await KernelFixture.create();
+    });
+
+    tearDown(() async {
+      await f.dispose();
+    });
+
+    test('register + activateAll runs extensions in dep order', () async {
+      final order = <String>[];
+      f.services.extensions
+        ..register(_Ext(
+          id: 'a',
+          onActivate: (_) async => order.add('a'),
+        ))
+        ..register(_Ext(
+          id: 'b',
+          dependsOn: const ['a'],
+          onActivate: (_) async => order.add('b'),
+        ))
+        ..register(_Ext(
+          id: 'c',
+          dependsOn: const ['b'],
+          onActivate: (_) async => order.add('c'),
+        ));
+      await f.services.extensions.activateAll();
+      expect(order, ['a', 'b', 'c']);
+    });
+
+    test('missing dep skips the dependent with a warning', () async {
+      final order = <String>[];
+      f.services.extensions.register(_Ext(
+        id: 'needs-missing',
+        dependsOn: const ['does.not.exist'],
+        onActivate: (_) async => order.add('needs-missing'),
+      ));
+      await f.services.extensions.activateAll();
+      expect(order, isEmpty);
+      expect(f.services.extensions.isActivated('needs-missing'), false);
+    });
+
+    test('contribution points wire into panel registry on activate', () async {
+      f.services.extensions.register(_Ext(
+        id: 'with-tab',
+        contributions: [
+          TabContribution(
+            id: 'with-tab.view',
+            slot: Slots.workspace,
+            title: 'T',
+            build: (_) => const SizedBox.shrink(),
+          ),
+        ],
+      ));
+      await f.services.extensions.activateAll();
+      expect(
+        f.services.panels.tabsFor(Slots.workspace).map((t) => t.id),
+        ['with-tab.view'],
+      );
+    });
+
+    test('deactivate removes contributions from the registry', () async {
+      f.services.extensions.register(_Ext(
+        id: 'ephemeral',
+        contributions: [
+          TabContribution(
+            id: 'ephemeral.view',
+            slot: Slots.workspace,
+            title: 'T',
+            build: (_) => const SizedBox.shrink(),
+          ),
+        ],
+      ));
+      await f.services.extensions.activateAll();
+      expect(f.services.panels.tabsFor(Slots.workspace), hasLength(1));
+      await f.services.extensions.deactivate('ephemeral');
+      expect(f.services.panels.tabsFor(Slots.workspace), isEmpty);
+    });
+
+    test('CommandContribution registers + default binding is bound', () async {
+      f.services.extensions.register(_Ext(
+        id: 'has-cmd',
+        contributions: [
+          CommandContribution(
+            id: 'c',
+            command: 'test.cmd',
+            defaultBinding: 'ctrl+alt+k',
+            run: (_) async => IpcResponse.ok(id: '', data: const {}),
+          ),
+        ],
+      ));
+      await f.services.extensions.activateAll();
+      expect(f.services.commands.get('test.cmd'), isNotNull);
+      expect(
+        f.services.keybindings.commandFor(Keybinding.parse('ctrl+alt+k')),
+        'test.cmd',
+      );
+    });
+
+    test('setEnabled=false deactivates; =true reactivates', () async {
+      final order = <String>[];
+      f.services.extensions.register(_Ext(
+        id: 'toggle',
+        onActivate: (_) async => order.add('on'),
+        onDeactivate: () async => order.add('off'),
+      ));
+      await f.services.extensions.activateAll();
+      expect(order, ['on']);
+      await f.services.extensions.setEnabled('toggle', false);
+      expect(order, ['on', 'off']);
+      await f.services.extensions.setEnabled('toggle', true);
+      expect(order, ['on', 'off', 'on']);
+    });
+
+    test('dependency cycle warns, does not infinite-loop', () async {
+      f.services.extensions
+        ..register(_Ext(id: 'x', dependsOn: const ['y']))
+        ..register(_Ext(id: 'y', dependsOn: const ['x']));
+      // Should not throw; both should fail to activate because of
+      // unsatisfied deps.
+      await f.services.extensions.activateAll();
+      expect(f.services.extensions.isActivated('x'), false);
+      expect(f.services.extensions.isActivated('y'), false);
+    });
+
+    test('emits ExtensionActivated / ExtensionDeactivated events', () async {
+      final activated = <String>[];
+      final deactivated = <String>[];
+      final s1 = f.services.events
+          .on<ExtensionActivated>()
+          .listen((e) => activated.add(e.id));
+      final s2 = f.services.events
+          .on<ExtensionDeactivated>()
+          .listen((e) => deactivated.add(e.id));
+      f.services.extensions.register(_Ext(id: 'e'));
+      await f.services.extensions.activateAll();
+      await Future<void>.delayed(Duration.zero);
+      await f.services.extensions.deactivate('e');
+      await Future<void>.delayed(Duration.zero);
+      expect(activated, ['e']);
+      expect(deactivated, ['e']);
+      await s1.cancel();
+      await s2.cancel();
+    });
+  });
+}

app/test/kernel/src/facade_test.dart

@@ -0,0 +1,63 @@
+import 'dart:ui';
+
+import 'package:flutter_test/flutter_test.dart';
+
+import '../../helpers/kernel_fixture.dart';
+
+void main() {
+  group('KernelServices facade', () {
+    test('boot wires every service and they are non-null', () async {
+      final f = await KernelFixture.create();
+      addTearDown(f.dispose);
+      final s = f.services;
+      expect(s.log, isNotNull);
+      expect(s.events, isNotNull);
+      expect(s.settings, isNotNull);
+      expect(s.ipc, isNotNull);
+      expect(s.theme, isNotNull);
+      expect(s.i18n, isNotNull);
+      expect(s.panels, isNotNull);
+      expect(s.arrangement, isNotNull);
+      expect(s.commands, isNotNull);
+      expect(s.palette, isNotNull);
+      expect(s.keybindings, isNotNull);
+      expect(s.clipboard, isNotNull);
+      expect(s.files, isNotNull);
+      expect(s.notify, isNotNull);
+      expect(s.dialog, isNotNull);
+      expect(s.tray, isNotNull);
+      expect(s.secrets, isNotNull);
+      expect(s.os, isNotNull);
+      expect(s.net, isNotNull);
+      expect(s.focus, isNotNull);
+      expect(s.project, isNotNull);
+      expect(s.extensions, isNotNull);
+    });
+
+    test('i18n is preloaded for the namespaces passed to boot', () async {
+      final f = await KernelFixture.create(
+        i18nCatalogs: {
+          'builtin.welcome': {
+            const Locale('en', 'US'): {
+              'title': const {'translation': 'clide'},
+            },
+          },
+        },
+      );
+      addTearDown(f.dispose);
+      expect(
+        f.services.i18n.string(
+          'title',
+          namespace: 'builtin.welcome',
+          placeholder: '-',
+        ),
+        'clide',
+      );
+    });
+
+    test('dispose shuts down IPC + notifiers without throwing', () async {
+      final f = await KernelFixture.create();
+      await f.dispose();
+    });
+  });
+}

app/test/kernel/src/i18n/i18n_test.dart

@@ -0,0 +1,228 @@
+import 'dart:ui';
+
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+/// Fills fframe's test gap — every path through the lookup matrix is
+/// exercised here.
+void main() {
+  group('I18n lookup & fallback', () {
+    late Logger log;
+
+    setUp(() {
+      log = Logger(minLevel: LogLevel.error); // silence warnings in tests
+    });
+
+    I18n build({
+      required Map<String, Map<Locale, Map<String, Object?>>> catalogs,
+      Locale initial = const Locale('en', 'US'),
+      Locale defaultLocale = const Locale('en', 'US'),
+    }) {
+      final loader = InMemoryCatalogLoader(catalogs);
+      final i = I18n(
+        loader: loader,
+        log: log,
+        defaultLocale: defaultLocale,
+        initialLocale: initial,
+        availableLocales: const [Locale('en', 'US'), Locale('nl', 'NL')],
+      );
+      return i;
+    }
+
+    test('missing key with placeholder returns placeholder', () async {
+      final i = build(catalogs: const {});
+      await i.ensureNamespaceLoaded('builtin.x');
+      expect(
+        i.string('missing', namespace: 'builtin.x', placeholder: 'fallback'),
+        'fallback',
+      );
+    });
+
+    test('missing key with null placeholder returns the key', () async {
+      final i = build(catalogs: const {});
+      await i.ensureNamespaceLoaded('builtin.x');
+      expect(i.string('foo.bar', namespace: 'builtin.x'), 'foo.bar');
+    });
+
+    test('unknown namespace still returns placeholder (no crash)', () {
+      final i = build(catalogs: const {});
+      expect(
+        i.string('k', namespace: 'not.registered', placeholder: 'fb'),
+        'fb',
+      );
+    });
+
+    test('exact locale hit beats fallback', () async {
+      final i = build(catalogs: {
+        'builtin.x': {
+          const Locale('en', 'US'): {
+            'greet': {'translation': 'Hello'},
+          },
+          const Locale('en'): {
+            'greet': {'translation': 'Hi'},
+          },
+        },
+      });
+      await i.ensureNamespaceLoaded('builtin.x');
+      expect(
+        i.string('greet', namespace: 'builtin.x', placeholder: 'fb'),
+        'Hello',
+      );
+    });
+
+    test('language-only locale hit falls through from exact', () async {
+      final i = build(catalogs: {
+        'builtin.x': {
+          const Locale('nl'): {
+            'greet': {'translation': 'Hoi'},
+          },
+        },
+      }, initial: const Locale('nl', 'NL'));
+      await i.ensureNamespaceLoaded('builtin.x');
+      expect(
+        i.string('greet', namespace: 'builtin.x', placeholder: 'fb'),
+        'Hoi',
+      );
+    });
+
+    test('falls through to default-locale when current locale is empty',
+        () async {
+      final i = build(catalogs: {
+        'builtin.x': {
+          const Locale('en', 'US'): {
+            'greet': {'translation': 'Hello'},
+          },
+        },
+      }, initial: const Locale('nl', 'NL'));
+      await i.ensureNamespaceLoaded('builtin.x');
+      expect(
+        i.string('greet', namespace: 'builtin.x', placeholder: 'fb'),
+        'Hello',
+      );
+    });
+
+    test('interpolation replaces all replacers; missing ones silent', () async {
+      final i = build(catalogs: {
+        'builtin.x': {
+          const Locale('en', 'US'): {
+            'welcome': {'translation': 'Hi {name} at {path}'},
+          },
+        },
+      });
+      await i.ensureNamespaceLoaded('builtin.x');
+      expect(
+        i.interpolated(
+          'welcome',
+          namespace: 'builtin.x',
+          placeholder: 'Hi {name} at {path}',
+          replacers: const [
+            I18nReplacer(from: '{name}', replace: 'Claude'),
+            // {path} deliberately absent
+          ],
+        ),
+        'Hi Claude at {path}',
+      );
+    });
+
+    test('namespace isolation — same key, different values', () async {
+      final i = build(catalogs: {
+        'a': {
+          const Locale('en', 'US'): {
+            'k': {'translation': 'A'},
+          },
+        },
+        'b': {
+          const Locale('en', 'US'): {
+            'k': {'translation': 'B'},
+          },
+        },
+      });
+      await i.ensureNamespaceLoaded('a');
+      await i.ensureNamespaceLoaded('b');
+      expect(i.string('k', namespace: 'a', placeholder: '-'), 'A');
+      expect(i.string('k', namespace: 'b', placeholder: '-'), 'B');
+    });
+
+    test('setLocale refreshes cached namespaces and notifies listeners',
+        () async {
+      final i = build(catalogs: {
+        'x': {
+          const Locale('en', 'US'): {
+            'k': {'translation': 'Hello'},
+          },
+          const Locale('nl'): {
+            'k': {'translation': 'Hallo'},
+          },
+        },
+      });
+      await i.ensureNamespaceLoaded('x');
+      var notified = 0;
+      i.addListener(() => notified++);
+      await i.setLocale(const Locale('nl'));
+      expect(notified, greaterThanOrEqualTo(1));
+      expect(i.string('k', namespace: 'x', placeholder: '-'), 'Hallo');
+    });
+
+    test('registerCatalog merges third-party catalog', () async {
+      final i = build(catalogs: const {});
+      i.registerCatalog('ext.linear', const Locale('en', 'US'), const {
+        'issue.title': {'translation': 'Issues'},
+      });
+      expect(
+        i.string('issue.title', namespace: 'ext.linear', placeholder: '-'),
+        'Issues',
+      );
+    });
+
+    test('unregisterCatalog forgets a namespace', () async {
+      final i = build(catalogs: const {});
+      i.registerCatalog('ext.x', const Locale('en', 'US'), const {
+        'k': {'translation': 'v'},
+      });
+      expect(i.string('k', namespace: 'ext.x', placeholder: '-'), 'v');
+      i.unregisterCatalog('ext.x');
+      expect(i.string('k', namespace: 'ext.x', placeholder: '-'), '-');
+    });
+
+    test('plain-string shape (no nested translation) is accepted', () async {
+      // Forward-compat: if a catalog later switches to `"k": "v"`
+      // instead of `"k": {"translation": "v"}`, lookup still works.
+      final i = build(catalogs: {
+        'x': {
+          const Locale('en', 'US'): {'k': 'direct'},
+        },
+      });
+      await i.ensureNamespaceLoaded('x');
+      expect(i.string('k', namespace: 'x', placeholder: '-'), 'direct');
+    });
+  });
+
+  group('FallbackChain.resolve', () {
+    test('ordering: exact, lang, default, default-lang', () {
+      final chain = const FallbackChain(
+        current: Locale('nl', 'NL'),
+        defaultLocale: Locale('en', 'US'),
+      ).resolve();
+      expect(chain.map((l) => l.toString()).toList(), [
+        'nl_NL',
+        'nl',
+        'en_US',
+        'en',
+      ]);
+    });
+
+    test('deduplicates when current == default', () {
+      final chain = const FallbackChain(
+        current: Locale('en', 'US'),
+        defaultLocale: Locale('en', 'US'),
+      ).resolve();
+      expect(chain, ['en_US', 'en'].map((_) => isA<Locale>()));
+      expect(chain.length, 2);
+    });
+
+    test('filenameSuffix lowercases + omits empty country', () {
+      expect(FallbackChain.filenameSuffix(const Locale('en', 'US')), 'en_us');
+      expect(FallbackChain.filenameSuffix(const Locale('en')), 'en');
+    });
+  });
+}

app/test/kernel/src/log_test.dart

@@ -0,0 +1,71 @@
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('Logger', () {
+    test('respects minLevel — lower-level messages drop silently', () {
+      final out = <LogRecord>[];
+      final log = Logger(
+        minLevel: LogLevel.warn,
+        sinks: [out.add],
+      );
+      log.debug('s', 'dropped');
+      log.info('s', 'dropped');
+      log.warn('s', 'kept');
+      log.error('s', 'kept');
+      expect(out.map((r) => r.message), ['kept', 'kept']);
+    });
+
+    test('minLevel is mutable post-construction', () {
+      final out = <LogRecord>[];
+      final log = Logger(minLevel: LogLevel.error, sinks: [out.add]);
+      log.info('s', 'dropped');
+      log.minLevel = LogLevel.info;
+      log.info('s', 'kept');
+      expect(out.map((r) => r.message), ['kept']);
+    });
+
+    test('error + stack trace propagate to sinks', () {
+      final out = <LogRecord>[];
+      final log = Logger(minLevel: LogLevel.debug, sinks: [out.add]);
+      final st = StackTrace.current;
+      log.error('s', 'boom', error: 'e', stackTrace: st);
+      expect(out, hasLength(1));
+      expect(out.first.level, LogLevel.error);
+      expect(out.first.error, 'e');
+      expect(out.first.stackTrace, st);
+    });
+
+    test('broken sink does not kill the logger', () {
+      final good = <LogRecord>[];
+      final log = Logger(minLevel: LogLevel.info, sinks: [
+        (_) => throw StateError('bad sink'),
+        good.add,
+      ]);
+      log.info('s', 'still delivered');
+      expect(good, hasLength(1));
+    });
+
+    test('records stream for subscribers', () async {
+      final log = Logger(minLevel: LogLevel.info);
+      final out = <LogRecord>[];
+      final sub = log.records.listen(out.add);
+      log.info('s', 'm1');
+      log.info('s', 'm2');
+      await Future<void>.delayed(Duration.zero);
+      expect(out.map((r) => r.message), ['m1', 'm2']);
+      await sub.cancel();
+      await log.dispose();
+    });
+
+    test('addSink appends without replacing', () {
+      final a = <LogRecord>[];
+      final b = <LogRecord>[];
+      final log = Logger(minLevel: LogLevel.info, sinks: [a.add]);
+      log.addSink(b.add);
+      log.info('s', 'hello');
+      expect(a, hasLength(1));
+      expect(b, hasLength(1));
+    });
+  });
+}

app/test/kernel/src/panels/arrangement_test.dart

@@ -0,0 +1,50 @@
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('LayoutArrangement', () {
+    test('applyPreset sets position + size + visibility per slot', () {
+      final a = LayoutArrangement();
+      a.applyPreset(classicPreset());
+      expect(a.positionOf(Slots.sidebar), SlotPosition.left);
+      expect(a.sizeOf(Slots.sidebar), 240);
+      expect(a.minSizeOf(Slots.sidebar), 180);
+      expect(a.maxSizeOf(Slots.sidebar), 400);
+      expect(a.isVisible(Slots.workspace), true);
+    });
+
+    test('setSize clamps to min/max', () {
+      final a = LayoutArrangement()..applyPreset(classicPreset());
+      a.setSize(Slots.sidebar, 50); // below min 180
+      expect(a.sizeOf(Slots.sidebar), 180);
+      a.setSize(Slots.sidebar, 10000); // above max 400
+      expect(a.sizeOf(Slots.sidebar), 400);
+    });
+
+    test('setSize notifies listeners only when changing', () {
+      final a = LayoutArrangement()..applyPreset(classicPreset());
+      var count = 0;
+      a.addListener(() => count++);
+      a.setSize(Slots.sidebar, 240); // already 240, no change
+      expect(count, 0);
+      a.setSize(Slots.sidebar, 260);
+      expect(count, 1);
+    });
+
+    test('setVisible flips the flag', () {
+      final a = LayoutArrangement()..applyPreset(classicPreset());
+      expect(a.isVisible(Slots.sidebar), true);
+      a.setVisible(Slots.sidebar, false);
+      expect(a.isVisible(Slots.sidebar), false);
+    });
+
+    test('registerSlotsInto populates a PanelRegistry', () {
+      final a = LayoutArrangement();
+      final r = PanelRegistry();
+      final preset = classicPreset();
+      a.registerSlotsInto(r, preset);
+      expect(r.definitionFor(Slots.sidebar), isNotNull);
+      expect(r.definitionFor(Slots.statusbar), isNotNull);
+    });
+  });
+}

app/test/kernel/src/panels/registry_test.dart

@@ -0,0 +1,76 @@
+import 'package:clide_app/extension/extension.dart';
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+TabContribution _tab({
+  required String id,
+  required SlotId slot,
+  int priority = 0,
+}) =>
+    TabContribution(
+      id: id,
+      slot: slot,
+      title: id,
+      priority: priority,
+      build: (_) => const SizedBox.shrink(),
+    );
+
+void main() {
+  group('PanelRegistry', () {
+    late PanelRegistry r;
+
+    setUp(() => r = PanelRegistry());
+
+    test('registerSlot creates an empty mount list', () {
+      r.registerSlot(const SlotDefinition(
+        id: Slots.sidebar,
+        position: SlotPosition.left,
+      ));
+      expect(r.definitionFor(Slots.sidebar)!.position, SlotPosition.left);
+      expect(r.contributionsFor(Slots.sidebar), isEmpty);
+    });
+
+    test('contribute appends to the slot and orders by priority', () {
+      r.contribute(_tab(id: 'a', slot: Slots.sidebar, priority: 10));
+      r.contribute(_tab(id: 'b', slot: Slots.sidebar, priority: -5));
+      r.contribute(_tab(id: 'c', slot: Slots.sidebar, priority: 0));
+      expect(r.tabsFor(Slots.sidebar).map((t) => t.id), ['b', 'c', 'a']);
+    });
+
+    test('first tab contribution becomes the active tab', () {
+      r.contribute(_tab(id: 'a', slot: Slots.sidebar));
+      expect(r.activeTabIn(Slots.sidebar), 'a');
+      r.contribute(_tab(id: 'b', slot: Slots.sidebar));
+      expect(r.activeTabIn(Slots.sidebar), 'a');
+    });
+
+    test('uncontribute removes by id and reassigns active tab', () {
+      r.contribute(_tab(id: 'a', slot: Slots.sidebar));
+      r.contribute(_tab(id: 'b', slot: Slots.sidebar));
+      expect(r.activeTabIn(Slots.sidebar), 'a');
+      r.uncontribute('a');
+      expect(r.tabsFor(Slots.sidebar).map((t) => t.id), ['b']);
+      expect(r.activeTabIn(Slots.sidebar), 'b');
+    });
+
+    test('activateTab notifies listeners', () {
+      r.contribute(_tab(id: 'a', slot: Slots.sidebar));
+      r.contribute(_tab(id: 'b', slot: Slots.sidebar));
+      var count = 0;
+      r.addListener(() => count++);
+      r.activateTab(Slots.sidebar, 'b');
+      expect(r.activeTabIn(Slots.sidebar), 'b');
+      expect(count, 1);
+    });
+
+    test('contributing a non-slot contribution is a no-op for slots', () {
+      r.contribute(CommandContribution(
+        id: 'c',
+        command: 'c',
+        run: (_) async => throw UnimplementedError(),
+      ));
+      expect(r.tabsFor(Slots.sidebar), isEmpty);
+    });
+  });
+}

app/test/kernel/src/settings_test.dart

@@ -0,0 +1,94 @@
+import 'dart:io';
+
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('SettingsStore', () {
+    late Directory tmp;
+    late SettingsStore store;
+
+    setUp(() async {
+      tmp = await Directory.systemTemp.createTemp('clide_settings_');
+      store = SettingsStore(appDir: tmp);
+      await store.load();
+    });
+
+    tearDown(() async {
+      store.dispose();
+      if (await tmp.exists()) {
+        try {
+          await tmp.delete(recursive: true);
+        } catch (_) {}
+      }
+    });
+
+    test('scope key validation — rejects non-standard prefixes', () async {
+      expect(
+        () => store.get<String>('nothing.here'),
+        throwsA(isA<ArgumentError>()),
+      );
+      expect(
+        () => store.set('notascope.key', 'v'),
+        throwsA(isA<ArgumentError>()),
+      );
+    });
+
+    test('app.* scope round-trips via YAML on disk', () async {
+      await store.set<String>('app.theme.current', 'summer-night');
+      expect(store.get<String>('app.theme.current'), 'summer-night');
+      final loaded = SettingsStore(appDir: tmp);
+      await loaded.load();
+      expect(loaded.get<String>('app.theme.current'), 'summer-night');
+      loaded.dispose();
+    });
+
+    test('app.* scope supports bool + int + list', () async {
+      await store.set<bool>('app.extensions.git.enabled', false);
+      await store.set<int>('app.layout.width', 240);
+      await store.set<List<String>>('app.recent', const ['/a', '/b']);
+      final loaded = SettingsStore(appDir: tmp);
+      await loaded.load();
+      expect(loaded.get<bool>('app.extensions.git.enabled'), false);
+      expect(loaded.get<int>('app.layout.width'), 240);
+      expect(loaded.get<List<dynamic>>('app.recent'), ['/a', '/b']);
+      loaded.dispose();
+    });
+
+    test('setting a project.* key without an open project throws', () async {
+      expect(
+        () => store.set('project.thing', 'x'),
+        throwsA(isA<StateError>()),
+      );
+    });
+
+    test('project scope is isolated from app scope', () async {
+      final projectDir = await Directory.systemTemp.createTemp('clide_proj_');
+      try {
+        await store.setProjectDir(projectDir);
+        await store.set<String>('app.global', 'A');
+        await store.set<String>('project.scoped', 'P');
+        expect(store.get<String>('app.global'), 'A');
+        expect(store.get<String>('project.scoped'), 'P');
+        // Reload project dir (simulate reopening) and confirm app values
+        // don't leak into project store.
+        await store.setProjectDir(null);
+        expect(store.get<String>('app.global'), 'A');
+        expect(store.get<String>('project.scoped'), isNull);
+        await store.setProjectDir(projectDir);
+        expect(store.get<String>('project.scoped'), 'P');
+      } finally {
+        try {
+          await projectDir.delete(recursive: true);
+        } catch (_) {}
+      }
+    });
+
+    test('notifyListeners fires on set and load', () async {
+      var count = 0;
+      store.addListener(() => count++);
+      await store.set<String>('app.k', 'v');
+      expect(count, greaterThanOrEqualTo(1));
+    });
+  });
+}

app/test/kernel/src/theme/controller_test.dart

@@ -0,0 +1,89 @@
+import 'dart:ui';
+
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+ThemeDefinition _def(String name, Color primary) => ThemeDefinition(
+      name: name,
+      displayName: name,
+      dark: true,
+      palette: Palette({
+        'primary': primary,
+        'accent': primary,
+        'background': const Color(0xFF000000),
+        'surface': const Color(0xFF111111),
+        'panel': const Color(0xFF222222),
+        'foreground': const Color(0xFFFFFFFF),
+        'success': const Color(0xFF00FF00),
+        'warning': const Color(0xFFFFFF00),
+        'error': const Color(0xFFFF0000),
+      }),
+    );
+
+void main() {
+  group('ThemeController', () {
+    test('starts on first bundled theme', () {
+      final c = ThemeController(bundled: [
+        _def('a', const Color(0xFF111111)),
+        _def('b', const Color(0xFF222222)),
+      ]);
+      expect(c.currentName, 'a');
+    });
+
+    test('honors initialName when present', () {
+      final c = ThemeController(
+        bundled: [
+          _def('a', const Color(0xFF000000)),
+          _def('b', const Color(0xFF999999))
+        ],
+        initialName: 'b',
+      );
+      expect(c.currentName, 'b');
+    });
+
+    test('silently falls back to first when initialName is unknown', () {
+      final c = ThemeController(
+        bundled: [_def('a', const Color(0xFF000000))],
+        initialName: 'missing',
+      );
+      expect(c.currentName, 'a');
+    });
+
+    test('select changes current + notifies listeners', () {
+      final c = ThemeController(bundled: [
+        _def('a', const Color(0xFF000000)),
+        _def('b', const Color(0xFF333333)),
+      ]);
+      var count = 0;
+      c.addListener(() => count++);
+      c.select('b');
+      expect(c.currentName, 'b');
+      expect(count, 1);
+    });
+
+    test('select on same theme is a no-op', () {
+      final c = ThemeController(bundled: [_def('a', const Color(0xFF000000))]);
+      var count = 0;
+      c.addListener(() => count++);
+      c.select('a');
+      expect(count, 0);
+    });
+
+    test('select throws on unknown name', () {
+      final c = ThemeController(bundled: [_def('a', const Color(0xFF000000))]);
+      expect(() => c.select('nope'), throwsA(isA<ArgumentError>()));
+    });
+
+    test('registerTheme adds a new theme and rebuilds current if matching', () {
+      final c = ThemeController(bundled: [_def('a', const Color(0xFFAAAAAA))]);
+      expect(c.available.length, 1);
+      c.registerTheme(_def('b', const Color(0xFFBBBBBB)));
+      expect(c.available.length, 2);
+      // re-register 'a' with a different palette — current rebuilds
+      var count = 0;
+      c.addListener(() => count++);
+      c.registerTheme(_def('a', const Color(0xFF123456)));
+      expect(count, 1);
+    });
+  });
+}

app/test/kernel/src/theme/loader_test.dart

@@ -0,0 +1,80 @@
+import 'dart:ui';
+
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  const loader = ThemeLoader();
+
+  group('ThemeLoader.fromYamlString', () {
+    test('parses palette-only theme', () {
+      final def = loader.fromYamlString('''
+name: summer-night
+display_name: Summer Night
+dark: true
+palette:
+  primary: "#00a3d2"
+  background: "#21262F"
+  foreground: "#E2E8F5"
+''');
+      expect(def.name, 'summer-night');
+      expect(def.displayName, 'Summer Night');
+      expect(def.dark, true);
+      expect(def.palette.lookup('primary'), const Color(0xFF00A3D2));
+      expect(def.semanticOverride, isNull);
+      expect(def.surfaceOverride, isNull);
+    });
+
+    test('captures semantic overrides as palette-resolved colors', () {
+      final def = loader.fromYamlString('''
+name: t
+palette:
+  red: "#FF0000"
+  blue: "#0000FF"
+semantic:
+  mainchrome: red
+  focus: "#123456"
+''');
+      expect(
+          def.semanticOverride!.lookup('mainchrome'), const Color(0xFFFF0000));
+      expect(def.semanticOverride!.lookup('focus'), const Color(0xFF123456));
+    });
+
+    test('captures surface overrides as ref strings', () {
+      final def = loader.fromYamlString('''
+name: t
+palette:
+  red: "#FF0000"
+surface:
+  panel.background: "semantic.mainchrome"
+  panel.border: red
+''');
+      expect(def.surfaceOverride, {
+        'panel.background': 'semantic.mainchrome',
+        'panel.border': 'red',
+      });
+    });
+
+    test('throws when name is missing and no fallback', () {
+      expect(
+        () => loader.fromYamlString('palette: { fg: "#fff" }'),
+        throwsA(isA<FormatException>()),
+      );
+    });
+
+    test('throws when palette is missing', () {
+      expect(
+        () => loader.fromYamlString('name: t'),
+        throwsA(isA<FormatException>()),
+      );
+    });
+
+    test('fallback name is used when name is absent', () {
+      final def = loader.fromYamlString(
+        'palette: { fg: "#fff" }',
+        fallbackName: 'inferred',
+      );
+      expect(def.name, 'inferred');
+    });
+  });
+}

app/test/kernel/src/theme/resolver_test.dart

@@ -0,0 +1,128 @@
+import 'dart:ui';
+
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  const resolver = ThemeResolver();
+
+  Palette paletteOf(Map<String, Color> colors) => Palette(colors);
+
+  group('ThemeResolver default fallbacks', () {
+    test('palette-only summer-night shape resolves every token', () {
+      final tokens = resolver.resolve(
+        palette: paletteOf(const {
+          'primary': Color(0xFF00A3D2),
+          'accent': Color(0xFFFA5F8B),
+          'background': Color(0xFF21262F),
+          'surface': Color(0xFF393E48),
+          'panel': Color(0xFF292E38),
+          'foreground': Color(0xFFE2E8F5),
+          'muted': Color(0xFF6A7280),
+          'success': Color(0xFF00AB9A),
+          'warning': Color(0xFFD08447),
+          'error': Color(0xFFF06C6F),
+          'info': Color(0xFF00A3D2),
+        }),
+      );
+      expect(tokens.globalBackground, const Color(0xFF21262F));
+      expect(tokens.globalForeground, const Color(0xFFE2E8F5));
+      expect(tokens.panelBackground, const Color(0xFF292E38));
+      expect(tokens.sidebarItemSelected, const Color(0xFF00A3D2));
+      expect(tokens.statusSuccess, const Color(0xFF00AB9A));
+      expect(tokens.statusError, const Color(0xFFF06C6F));
+      expect(tokens.globalTextMuted, const Color(0xFF6A7280));
+    });
+
+    test('missing "muted" falls back to foreground', () {
+      final tokens = resolver.resolve(
+        palette: paletteOf(const {
+          'primary': Color(0xFF111111),
+          'accent': Color(0xFF222222),
+          'background': Color(0xFF333333),
+          'surface': Color(0xFF444444),
+          'panel': Color(0xFF555555),
+          'foreground': Color(0xFFEEEEEE),
+          'success': Color(0xFF008800),
+          'warning': Color(0xFFFF8800),
+          'error': Color(0xFFFF0000),
+        }),
+      );
+      expect(tokens.globalTextMuted, const Color(0xFFEEEEEE));
+    });
+  });
+
+  group('ThemeResolver overrides', () {
+    test('surface override wins over default', () {
+      final tokens = resolver.resolve(
+        palette: paletteOf(const {
+          'primary': Color(0xFF111111),
+          'accent': Color(0xFF222222),
+          'background': Color(0xFF333333),
+          'surface': Color(0xFF444444),
+          'panel': Color(0xFF555555),
+          'foreground': Color(0xFFFFFFFF),
+          'success': Color(0xFF008800),
+          'warning': Color(0xFFFF8800),
+          'error': Color(0xFFFF0000),
+        }),
+        surfaceOverride: const {
+          'panel.background': '#00FF00',
+        },
+      );
+      expect(tokens.panelBackground, const Color(0xFF00FF00));
+    });
+
+    test('semantic override propagates to surface tokens using it', () {
+      final tokens = resolver.resolve(
+        palette: paletteOf(const {
+          'primary': Color(0xFF111111),
+          'accent': Color(0xFF222222),
+          'background': Color(0xFF333333),
+          'surface': Color(0xFF444444),
+          'panel': Color(0xFF555555),
+          'foreground': Color(0xFFFFFFFF),
+          'success': Color(0xFF008800),
+          'warning': Color(0xFFFF8800),
+          'error': Color(0xFFFF0000),
+          'teal': Color(0xFF007777),
+        }),
+        semanticOverride: const SemanticRoles({
+          'focus': Color(0xFF007777),
+        }),
+      );
+      // sidebarItemSelected defaults to semantic.focus — expect override.
+      expect(tokens.sidebarItemSelected, const Color(0xFF007777));
+    });
+
+    test('extensionOverride populates extensionTokens map', () {
+      final tokens = resolver.resolve(
+        palette: paletteOf(const {
+          'primary': Color(0xFF111111),
+          'background': Color(0xFF333333),
+          'surface': Color(0xFF444444),
+          'panel': Color(0xFF555555),
+          'foreground': Color(0xFFFFFFFF),
+        }),
+        extensionOverride: const {
+          'ext.sqlite.table.background': '#ABCDEF',
+        },
+      );
+      expect(tokens.extensionTokens['ext.sqlite.table.background'],
+          const Color(0xFFABCDEF));
+    });
+  });
+
+  group('Palette.parseHex', () {
+    test('parses 6-digit hex as opaque', () {
+      expect(Palette.parseHex('#112233'), const Color(0xFF112233));
+    });
+    test('parses 8-digit hex with alpha', () {
+      expect(Palette.parseHex('#80112233'), const Color(0x80112233));
+    });
+    test('returns null on invalid', () {
+      expect(Palette.parseHex('nope'), isNull);
+      expect(Palette.parseHex('#12'), isNull);
+    });
+  });
+}