feat(studio): trust pass — friendly errors + store clarity + MCP i18n

Second half of the May-2026 trust pass. Drops the wall of
gRPC trailers from every error surface and makes the Store
honest about what is and isn't installable.

Friendly errors:

- New `friendlyError(Object, AppLocalizations)` mapper turns
  GrpcError + arbitrary throwables into a localised headline,
  optional recovery hint, and a verbatim detail string kept
  behind a "Show details" expander. Duck-typed on `.code` /
  `.message` so Studio doesn't have to depend on package:grpc
  directly.
- `FaiErrorBox` gains an `error:` constructor that runs the
  mapper. Every call site that used to render
  `snap.error.toString()` (flows, welcome, store) switches to
  it.
- 9 .arb entries per locale cover the gRPC codes we actually
  emit (INVALID_ARGUMENT, NOT_FOUND, ALREADY_EXISTS,
  PERMISSION_DENIED, FAILED_PRECONDITION, INTERNAL,
  UNAVAILABLE, UNAUTHENTICATED) plus copy/details affordances.
- `test/friendly_error_test.dart` — 6 unit tests for the
  mapper. Covers the mapping table, locale-switching, and the
  non-gRPC fallback so future regressions show up in CI.

Capability discovery:

- New `HubService.allCapabilities()` reads the kind-aware
  capability list (wasm + builtin + federated) and returns a
  Dart-side `CapabilityInfo` value type. The flow page's
  missing-dependency check uses it so `system.approval` and
  federated MCP/n8n tools count as "available" — fixes the
  Run button staying disabled forever.
- `HubService.listModules()` filters to kind=wasm so the
  Modules page doesn't sprout synthetic "system" entries that
  the operator can't uninstall.

Store clarity:

- New "Installable only" filter, on by default. Roughly 2/3
  of seed entries currently carry `status: planned`; the
  default view stops being noise.
- Featured-strip cards for planned modules now show a
  "Coming soon" pill instead of an empty action area.
- Main-grid cards for non-installable modules dim to 60%
  opacity so the eye lands on actionable cards first.
- Detail-sheet "Nicht installierbar" tooltip → inline hint
  box. The reason is visible without hovering.

MCP localisation:

- `_kMcpSuggestions` no longer holds 11 hardcoded English
  description strings. The `description` field is replaced
  with a `resolveDescription(AppLocalizations)` lookup that
  switches on the suggestion `name` to read the matching
  `mcpSuggestion*Desc` .arb key. EN + DE shipped.
- New `FaiEnBadge` widget renders a small `[EN]` pill when
  the active locale isn't English. Used next to MCP /
  federated store entries' tagline + description because
  the server supplies them in English and we can't translate
  on the fly yet — the badge is the honest signal until the
  planned `studio.translate` plugin lands.

Plus housekeeping: removed the unused `_keepImport` lint
escape in the test and the dangling library doc-comment in
`format.dart`.

Signed-off-by: flemming-it <sf@flemming.it>
Signed-off-by: flemming-it <stefan.a.flemming@googlemail.com>

lib/data/hub.dart

@@ -93,13 +93,18 @@ class HubService {
 
   Future<bool> healthy() => _client.healthy();
 
+  /// List of installed WASM modules, grouped by `module_name`.
+  /// Built-in and federated capabilities are excluded — they
+  /// don't correspond to a bundle on disk and would confuse the
+  /// Modules page (a "system" or "via:filesystem" pseudo-module
+  /// has nothing to uninstall). Callers that need every callable
+  /// capability — e.g. the flow's missing-dependencies check —
+  /// use [allCapabilities] instead.
   Future<List<ModuleSummary>> listModules() async {
     final caps = await _client.listCapabilities();
-
-    // Group capabilities by module so Studio's UI maps a card
-    // to a module rather than a capability.
+    final wasm = caps.where((c) => c.kind.isEmpty || c.kind == 'wasm');
     final byModule = <String, List<CapabilityEntry>>{};
-    for (final c in caps) {
+    for (final c in wasm) {
       byModule.putIfAbsent(c.moduleName, () => []).add(c);
     }
     return byModule.entries.map((e) {
@@ -115,6 +120,25 @@ class HubService {
       ..sort((a, b) => a.name.compareTo(b.name));
   }
 
+  /// Every capability the hub can execute, with the `kind` tag
+  /// telling apart wasm / builtin / federated. The flow page
+  /// uses this to decide which capabilities are "already
+  /// available" — including built-ins like `system.approval`
+  /// and federated MCP / n8n tools — so the Run button enables
+  /// when the dependency is reachable, not only when a bundle
+  /// happens to be installed.
+  Future<List<CapabilityInfo>> allCapabilities() async {
+    final caps = await _client.listCapabilities();
+    return caps
+        .map((c) => CapabilityInfo(
+              capability: c.capability,
+              version: c.version,
+              moduleName: c.moduleName,
+              kind: c.kind.isEmpty ? 'wasm' : c.kind,
+            ))
+        .toList();
+  }
+
   /// Fully-detailed manifest for one installed module.
   Future<ModuleDetail> moduleInfo(String name) async {
     final r = await _client.moduleInfo(name);
@@ -126,6 +150,7 @@ class HubService {
           .toList(),
       permissions: r.permissions,
       directory: r.directory,
+      acceptsMime: r.acceptsMime,
     );
   }
 
@@ -834,6 +859,26 @@ enum ThemeModeValue {
   }
 }
 
+/// Single capability with its provenance. `kind` is one of
+/// `wasm` (installed module), `builtin` (hub-internal, e.g.
+/// `system.approval`), or `federated` (MCP / n8n tool reachable
+/// through the bridge). UI uses `kind` to decide what actions
+/// to offer — only `wasm` capabilities have an install /
+/// uninstall affordance.
+class CapabilityInfo {
+  final String capability;
+  final String version;
+  final String moduleName;
+  final String kind;
+
+  const CapabilityInfo({
+    required this.capability,
+    required this.version,
+    required this.moduleName,
+    required this.kind,
+  });
+}
+
 /// UI-side type, decoupled from the proto wire type so pages
 /// don't import protobuf packages.
 class ModuleSummary {
@@ -872,6 +917,10 @@ class ModuleDetail {
   final List<String> capabilities;
   final List<String> permissions;
   final String directory;
+  /// MIME allow-list declared in the module's `module.yaml`.
+  /// Empty when the module didn't declare any — caller falls
+  /// back to its built-in extension heuristic.
+  final List<String> acceptsMime;
 
   const ModuleDetail({
     required this.name,
@@ -879,6 +928,7 @@ class ModuleDetail {
     required this.capabilities,
     required this.permissions,
     required this.directory,
+    this.acceptsMime = const [],
   });
 }