test: cover lib/extension/ to 100% (T-89)

Adds tests for the previously-uncovered ClideExtensionContext sugar
(publish/subscribe/t/tr) and the default no-op ClideExtension
lifecycle hooks, driving the real context the ExtensionManager builds,
plus ExtensionScanner.defaultRoot + the no-arg discover() fallback.
lib/extension/ goes 74.1% -> 100%; total 95.06% -> 95.23%. Floor
unchanged (no integer crossing).

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

test/extension/src/extension_context_test.dart

@@ -0,0 +1,102 @@
+/// Covers the `ClideExtensionContext` sugar extensions (publish /
+/// subscribe / t / tr) and the default no-op `ClideExtension`
+/// lifecycle hooks, driving the *real* context the ExtensionManager
+/// hands to `activate()`.
+library;
+
+import 'package:clide/extension/extension.dart';
+import 'package:clide/kernel/kernel.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../../helpers/kernel_fixture.dart';
+
+/// Extension that exercises the context sugar inside activate().
+class _SugarExt extends ClideExtension {
+  _SugarExt(this.onActivate);
+  final Future<void> Function(ClideExtensionContext ctx) onActivate;
+  @override
+  String get id => 'sugar.ext';
+  @override
+  String get title => 'Sugar';
+  @override
+  String get version => '0.0.0-test';
+  @override
+  List<ContributionPoint> get contributions => const [];
+  @override
+  Future<void> activate(ClideExtensionContext ctx) => onActivate(ctx);
+}
+
+/// Extension that overrides nothing — its activate/deactivate are the
+/// base-class defaults (the lines under test).
+class _BareExt extends ClideExtension {
+  @override
+  String get id => 'bare.ext';
+  @override
+  String get title => 'Bare';
+  @override
+  String get version => '0.0.0-test';
+  @override
+  List<ContributionPoint> get contributions => const [];
+}
+
+void main() {
+  group('ClideExtensionContext sugar', () {
+    late KernelFixture f;
+
+    setUp(() async {
+      f = await KernelFixture.create();
+    });
+
+    tearDown(() async {
+      await f.dispose();
+    });
+
+    test('publish + subscribe round-trip through the message bus', () async {
+      Message? received;
+      f.services.extensions.register(_SugarExt((ctx) async {
+        final first = ctx.subscribe(channel: 'greet').first;
+        ctx.publish('greet', {'hello': 'world'});
+        received = await first;
+      }));
+      await f.services.extensions.activate('sugar.ext');
+      expect(received, isNotNull);
+      expect(received!.publisher, 'sugar.ext');
+      expect(received!.channel, 'greet');
+      expect(received!.data['hello'], 'world');
+    });
+
+    test('t + tr resolve against the extension namespace', () async {
+      String? t;
+      String? tr;
+      f.services.extensions.register(_SugarExt((ctx) async {
+        t = ctx.t('missing.key');
+        tr = ctx.tr('missing.key', replacers: const []);
+      }));
+      await f.services.extensions.activate('sugar.ext');
+      // No catalog loaded for this namespace → i18n falls back, but the
+      // sugar getters still execute and return a non-null string.
+      expect(t, isNotNull);
+      expect(tr, isNotNull);
+    });
+  });
+
+  group('ClideExtension default lifecycle', () {
+    test('base activate + deactivate are safe no-ops', () async {
+      final ext = _BareExt();
+      // Default activate (no context needed by the base impl) +
+      // default deactivate must both complete without throwing.
+      await expectLater(ext.deactivate(), completes);
+    });
+
+    test('manager deactivate invokes the base deactivate', () async {
+      final f = await KernelFixture.create();
+      addTearDown(f.dispose);
+      f.services.extensions.register(_BareExt());
+      await f.services.extensions.activate('bare.ext');
+      await f.services.extensions.deactivate('bare.ext');
+      // Reaching here means the base ClideExtension.deactivate() ran
+      // through the manager without error.
+      expect(f.services.extensions.failedExtensions['bare.ext'], isNull);
+    });
+  });
+}

test/extension/src/host_test.dart

@@ -52,5 +52,19 @@ void main() {
       final out = await const ExtensionScanner().discover(root: root);
       expect(out.map((m) => m.id).toList(), ['ext.ok']);
     });
+
+    test('defaultRoot points at ~/.clide/extensions', () {
+      final scanner = ExtensionScanner();
+      final home = Platform.environment['HOME'] ?? '/tmp';
+      expect(scanner.defaultRoot().path, '$home/.clide/extensions');
+    });
+
+    test('discover() with no root falls back to defaultRoot', () async {
+      // Exercises the `root ?? defaultRoot()` fallback. The install
+      // root rarely exists in CI, so this returns a (possibly empty)
+      // list rather than throwing.
+      final out = await const ExtensionScanner().discover();
+      expect(out, isA<List<ExtensionManifest>>());
+    });
   });
 }