@camstack/server 0.1.7 → 0.2.0

package/src/core/addon/addon-registry.service.ts

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access -- pre-existing lint debt across this 2200-line orchestration class. The flagged sites (StorageService.setLocationManager / setSettingsBackend, LoggingService.addDestination, RouteRegistry, etc.) are typed as `unknown` by their owning services to break circular construction-order dependencies; runtime contracts are validated structurally. Tracked separately; do not amend in unrelated edits. */
-import * as os from "node:os";
-import { ConfigService } from "../config/config.service";
-import { LoggingService } from "../logging/logging.service";
-import { EventBusService } from "../events/event-bus.service";
-import { StorageService } from "../storage/storage.service";
-import { StreamProbeService } from "../streaming/stream-probe.service";
-
-import { CapabilityService } from "../capability/capability.service";
+import * as os from 'node:os'
+import { ConfigService } from '../config/config.service'
+import { overlayDeclaration } from './addon-row-manifest'
+import { LoggingService } from '../logging/logging.service'
+import { EventBusService } from '../events/event-bus.service'
+import { StorageService } from '../storage/storage.service'
+import { StreamProbeService } from '../streaming/stream-probe.service'
+
+import { CapabilityService } from '../capability/capability.service'
 import {
   EventCategory,
   createDeviceProxy,
@@ -15,7 +16,7 @@ import {
   isAgentOnlyPlacement,
   resolveRunnerId,
   resolveAddonPlacement,
-} from "@camstack/types";
+} from '@camstack/types'
 import type {
   AddonDeclaration,
   CapabilityDeclaration,
@@ -23,20 +24,15 @@ import type {
   InferProvider,
   RunnerPlan,
   RunnerAddonPlacement,
-} from "@camstack/types";
-import type {
-  ICamstackAddon,
-  AddonContext,
-  InternalAddonContext,
-} from "@camstack/types";
-import type { IScopedLogger } from "@camstack/types";
+} from '@camstack/types'
+import type { ICamstackAddon, AddonContext, InternalAddonContext } from '@camstack/types'
+import type { IScopedLogger } from '@camstack/types'
 import {
   CapabilityRegistry,
   CustomActionRegistry,
   INFRA_CAPABILITIES,
   AddonLoader,
   AddonHealthMonitor,
-
   DeviceRegistry,
   adaptBrokerToCluster,
   createAddonService,
@@ -49,35 +45,36 @@ import {
   type ISettingsStore,
   type AddonSettingsView,
   type AddonHealthSnapshot,
-} from "@camstack/kernel";
-import { localProviderLink, brokerTransportLink } from "@camstack/kernel";
-import { createTRPCClient } from "@trpc/client";
-import { MoleculerService } from "../moleculer/moleculer.service";
-import { AddonDepsManager } from "@camstack/kernel";
-import type { SavedDevice, ReadinessScope } from "@camstack/types";
-import { IntegrationRegistry } from "@camstack/core";
-import type {
-  IStorageProvider as INewStorageProvider,
-  ISettingsBackend,
-} from "@camstack/types";
-import { AddonRouteRegistry } from "@camstack/core";
-import { randomUUID } from "node:crypto";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { pathToFileURL } from "node:url";
-import { createAddonSettingsProvider } from "./addon-settings-provider.js";
-import { AddonCallGateway } from "./addon-call-gateway.js";
-import { addonSettingsCapability } from "@camstack/types";
-import { DisposerChain } from "@camstack/types";
-
-type AddonSource = "core" | "installed";
+} from '@camstack/kernel'
+import { localProviderLink, brokerTransportLink } from '@camstack/kernel'
+import { createTRPCClient } from '@trpc/client'
+import { MoleculerService } from '../moleculer/moleculer.service'
+import { AddonDepsManager } from '@camstack/kernel'
+import type { SavedDevice, ReadinessScope } from '@camstack/types'
+import { IntegrationRegistry } from '@camstack/core'
+import type { IStorageProvider as INewStorageProvider, ISettingsBackend } from '@camstack/types'
+import { AddonRouteRegistry, DataPlaneRegistry } from '@camstack/core'
+import { randomUUID } from 'node:crypto'
+import * as path from 'node:path'
+import * as fs from 'node:fs'
+import { pathToFileURL } from 'node:url'
+import { createAddonSettingsProvider } from './addon-settings-provider.js'
+import { AddonCallGateway } from './addon-call-gateway.js'
+import { addonSettingsCapability } from '@camstack/types'
+import { DisposerChain } from '@camstack/types'
+
+type AddonSource = 'core' | 'installed'
 
 /**
  * Local narrowing of the Moleculer ServiceBroker surface we actually use.
  * See the `broker` getter docstring below for why this is necessary.
  */
 interface BrokerLike {
-  call<T = unknown>(action: string, params?: unknown, opts?: { nodeID?: string; timeout?: number }): Promise<T>
+  call<T = unknown>(
+    action: string,
+    params?: unknown,
+    opts?: { nodeID?: string; timeout?: number },
+  ): Promise<T>
   nodeID: string
   createService(schema: unknown): unknown
 }
@@ -89,27 +86,25 @@ interface BrokerLike {
  * `@camstack/core` implements both surfaces; forked addon backends may
  * not, in which case we skip the ConfigService wiring.
  */
-function isSettingsStore(
-  backend: ISettingsBackend,
-): backend is ISettingsBackend & ISettingsStore {
+function isSettingsStore(backend: ISettingsBackend): backend is ISettingsBackend & ISettingsStore {
   const required: readonly (keyof ISettingsStore)[] = [
-    "getSystem",
-    "setSystem",
-    "getAllSystem",
-    "getAllAddon",
-    "setAllAddon",
-    "getAllProvider",
-    "setProvider",
-    "getAllDevice",
-    "setDevice",
-    "getAddonDevice",
-    "setAddonDevice",
-    "clearAddonDevice",
-  ];
+    'getSystem',
+    'setSystem',
+    'getAllSystem',
+    'getAllAddon',
+    'setAllAddon',
+    'getAllProvider',
+    'setProvider',
+    'getAllDevice',
+    'setDevice',
+    'getAddonDevice',
+    'setAddonDevice',
+    'clearAddonDevice',
+  ]
   for (const key of required) {
-    if (typeof Reflect.get(backend, key) !== "function") return false;
+    if (typeof Reflect.get(backend, key) !== 'function') return false
   }
-  return true;
+  return true
 }
 
 /**
@@ -120,41 +115,39 @@ function isSettingsStore(
  */
 interface AddonRoutesInvoker {
   invoke(
-    input: import("@camstack/types").AddonRouteInvokeRequest,
-  ): Promise<import("@camstack/types").AddonRouteReplyEnvelope>;
+    input: import('@camstack/types').AddonRouteInvokeRequest,
+  ): Promise<import('@camstack/types').AddonRouteReplyEnvelope>
 }
 
 /** Structural guard: true when an `addon-routes` provider also exposes `invoke`. */
-function isAddonRoutesInvoker<T extends object>(
-  provider: T,
-): provider is T & AddonRoutesInvoker {
-  return typeof Reflect.get(provider, "invoke") === "function";
+function isAddonRoutesInvoker<T extends object>(provider: T): provider is T & AddonRoutesInvoker {
+  return typeof Reflect.get(provider, 'invoke') === 'function'
 }
 
-const ROUTE_METHODS: readonly import("@camstack/types").IAddonHttpRoute["method"][] = [
-  "GET",
-  "POST",
-  "PUT",
-  "DELETE",
-];
-const ROUTE_ACCESS: readonly import("@camstack/types").RouteAccess[] = [
-  "public",
-  "authenticated",
-  "admin",
-];
-
-function asRouteMethod(value: string): import("@camstack/types").IAddonHttpRoute["method"] {
-  const upper = value.toUpperCase();
-  for (const m of ROUTE_METHODS) if (m === upper) return m;
-  throw new Error(`addon-routes: unsupported HTTP method "${value}"`);
+const ROUTE_METHODS: readonly import('@camstack/types').IAddonHttpRoute['method'][] = [
+  'GET',
+  'POST',
+  'PUT',
+  'DELETE',
+]
+const ROUTE_ACCESS: readonly import('@camstack/types').RouteAccess[] = [
+  'public',
+  'authenticated',
+  'admin',
+]
+
+function asRouteMethod(value: string): import('@camstack/types').IAddonHttpRoute['method'] {
+  const upper = value.toUpperCase()
+  for (const m of ROUTE_METHODS) if (m === upper) return m
+  throw new Error(`addon-routes: unsupported HTTP method "${value}"`)
 }
 
-function asRouteAccess(value: unknown): import("@camstack/types").RouteAccess {
-  if (typeof value === "string") {
-    for (const a of ROUTE_ACCESS) if (a === value) return a;
+function asRouteAccess(value: unknown): import('@camstack/types').RouteAccess {
+  if (typeof value === 'string') {
+    for (const a of ROUTE_ACCESS) if (a === value) return a
   }
   // Default to the most restrictive sensible default the original mount used.
-  return "public";
+  return 'public'
 }
 
 /**
@@ -164,53 +157,78 @@ function asRouteAccess(value: unknown): import("@camstack/types").RouteAccess {
  * `method`/`path`/`access`/`description` are present.
  */
 interface ParsedRouteDescriptor {
-  readonly method: import("@camstack/types").IAddonHttpRoute["method"];
-  readonly path: string;
-  readonly access: import("@camstack/types").RouteAccess;
-  readonly description?: string;
+  readonly method: import('@camstack/types').IAddonHttpRoute['method']
+  readonly path: string
+  readonly access: import('@camstack/types').RouteAccess
+  readonly description?: string
 }
 
 function parseSerializableRouteDescriptors(raw: unknown): readonly ParsedRouteDescriptor[] {
   if (!Array.isArray(raw)) {
-    throw new Error("addon-routes: child returned a non-array route descriptor set");
+    throw new Error('addon-routes: child returned a non-array route descriptor set')
   }
   return raw.map((entry: unknown): ParsedRouteDescriptor => {
-    if (entry === null || typeof entry !== "object") {
-      throw new Error("addon-routes: route descriptor is not an object");
+    if (entry === null || typeof entry !== 'object') {
+      throw new Error('addon-routes: route descriptor is not an object')
     }
-    const method = Reflect.get(entry, "method");
-    const path = Reflect.get(entry, "path");
-    if (typeof method !== "string" || typeof path !== "string") {
-      throw new Error("addon-routes: route descriptor missing method/path");
+    const method = Reflect.get(entry, 'method')
+    const path = Reflect.get(entry, 'path')
+    if (typeof method !== 'string' || typeof path !== 'string') {
+      throw new Error('addon-routes: route descriptor missing method/path')
     }
-    const description = Reflect.get(entry, "description");
+    const description = Reflect.get(entry, 'description')
     return {
       method: asRouteMethod(method),
       path,
-      access: asRouteAccess(Reflect.get(entry, "access")),
-      ...(typeof description === "string" ? { description } : {}),
-    };
-  });
+      access: asRouteAccess(Reflect.get(entry, 'access')),
+      ...(typeof description === 'string' ? { description } : {}),
+    }
+  })
+}
+
+/**
+ * Parse the wire-boundary `unknown` from `callForked(..., {target:'data-planes'})`
+ * into typed data-plane endpoint descriptors (`prefix/access/baseUrl/secret`).
+ * Pure data — the addon's `ctx.dataPlane` facility produced them.
+ */
+function parseDataPlaneEndpoints(
+  raw: unknown,
+): readonly import('@camstack/types').AddonDataPlaneEndpoint[] {
+  if (!Array.isArray(raw)) {
+    throw new Error('data-planes: child returned a non-array endpoint set')
+  }
+  return raw.map((entry: unknown): import('@camstack/types').AddonDataPlaneEndpoint => {
+    if (entry === null || typeof entry !== 'object') {
+      throw new Error('data-planes: endpoint descriptor is not an object')
+    }
+    const prefix = Reflect.get(entry, 'prefix')
+    const baseUrl = Reflect.get(entry, 'baseUrl')
+    const secret = Reflect.get(entry, 'secret')
+    if (typeof prefix !== 'string' || typeof baseUrl !== 'string' || typeof secret !== 'string') {
+      throw new Error('data-planes: endpoint descriptor missing prefix/baseUrl/secret')
+    }
+    return { prefix, access: asRouteAccess(Reflect.get(entry, 'access')), baseUrl, secret }
+  })
 }
 
 interface AddonEntry {
-  readonly addon: ICamstackAddon;
-  initialized: boolean;
-  source: AddonSource;
+  readonly addon: ICamstackAddon
+  initialized: boolean
+  source: AddonSource
   /** npm package name from package.json (e.g. '@camstack/addon-detection-pipeline') */
-  packageName: string;
+  packageName: string
   /** npm package version from package.json */
-  packageVersion: string;
+  packageVersion: string
   /** Human-readable package name from camstack.displayName */
-  packageDisplayName?: string;
+  packageDisplayName?: string
   /** Optional bundle metadata when the package ships multiple addon entries. */
-  bundle?: { displayName: string; description?: string; icon?: string };
+  bundle?: { displayName: string; description?: string; icon?: string }
   /** Capabilities declared in package.json camstack.addons (source of truth) */
-  declaredCapabilities: readonly CapabilityDeclaration[];
+  declaredCapabilities: readonly CapabilityDeclaration[]
   /** Addon directory on disk */
-  addonDir?: string;
+  addonDir?: string
   /** Full package.json declaration (AddonDeclaration from @camstack/types) */
-  declaration?: AddonDeclaration;
+  declaration?: AddonDeclaration
 }
 
 // Phase 11 (settings redesign): `stripValue` helper and the legacy
@@ -220,14 +238,14 @@ interface AddonEntry {
 // endpoints on the `addon-settings` singleton capability.
 
 export class AddonRegistryService {
-  private readonly addonEntries = new Map<string, AddonEntry>();
-  private readonly capabilityRegistry: CapabilityRegistry;
+  private readonly addonEntries = new Map<string, AddonEntry>()
+  private readonly capabilityRegistry: CapabilityRegistry
   /** Single router for addon-level calls (routes / custom / settings). */
-  private addonCallGateway!: AddonCallGateway;
+  private addonCallGateway!: AddonCallGateway
   // Task 7.1: hub-wide registry of addon custom actions. Populated on
   // each addon's initialize() (in-process path); Task 7.2 will dispatch
   // through this from the `api.addons.custom` tRPC procedure.
-  private readonly customActionRegistry = new CustomActionRegistry();
+  private readonly customActionRegistry = new CustomActionRegistry()
   /**
    * AddonIds whose group-runner disconnect is operator-initiated (update /
    * restart / uninstall). The Moleculer `$node.disconnected` handler skips
@@ -235,11 +253,12 @@ export class AddonRegistryService {
    * banner during the kill→respawn window. The set is cleared as soon as
    * `restartAddon` completes (success or failure) or by a 90s safety timer.
    */
-  private readonly restartingAddons = new Map<string, NodeJS.Timeout>();
-  private readonly logger: IScopedLogger;
-  private addonLoader!: AddonLoader;
-  private healthMonitor!: AddonHealthMonitor;
-  private addonRouteRegistry: AddonRouteRegistry | null = null;
+  private readonly restartingAddons = new Map<string, NodeJS.Timeout>()
+  private readonly logger: IScopedLogger
+  private addonLoader!: AddonLoader
+  private healthMonitor!: AddonHealthMonitor
+  private addonRouteRegistry: AddonRouteRegistry | null = null
+  private dataPlaneRegistry: DataPlaneRegistry | null = null
 
   // Broker-routed AddonApi proxy — every addon's `ctx.api` resolves
   // to this. Calls go through `broker.call('${addonId}.${capName}.${method}')`
@@ -249,30 +268,25 @@ export class AddonRegistryService {
   // and forked workers — `ctx.api` is uniform across all deployment
   // shapes. Lazily constructed so tests that don't wire the broker
   // still instantiate the service.
-  private brokerApi: import("@camstack/types").AddonApi | null = null;
+  private brokerApi: import('@camstack/types').AddonApi | null = null
   /**
    * In-process tRPC client over the broker — same `AddonApi` shape every
    * addon sees via `ctx.api`. Exposed as public so the REPL service can
    * build a `SystemManager` from it without crossing the network boundary.
    */
-  public getBrokerApi(): import("@camstack/types").AddonApi {
+  public getBrokerApi(): import('@camstack/types').AddonApi {
     if (!this.brokerApi) {
-      const reg = this.capabilityRegistry;
+      const reg = this.capabilityRegistry
       const resolver = {
         getByName: (capName: string): unknown | null =>
-          reg.getSingleton(capName) ??
-          (reg.getAllProviders(capName)[0] as unknown) ??
-          null,
-      };
+          reg.getSingleton(capName) ?? (reg.getAllProviders(capName)[0] as unknown) ?? null,
+      }
       const client: unknown = createTRPCClient({
-        links: [
-          localProviderLink(resolver),
-          brokerTransportLink(this.moleculer.broker),
-        ],
-      });
-      this.brokerApi = client as import("@camstack/types").AddonApi;
-    }
-    return this.brokerApi;
+        links: [localProviderLink(resolver), brokerTransportLink(this.moleculer.broker)],
+      })
+      this.brokerApi = client as import('@camstack/types').AddonApi
+    }
+    return this.brokerApi
   }
 
   // Common settings resolver (3-level: defaults → global → per-device).
@@ -281,15 +295,13 @@ export class AddonRegistryService {
   // without wiring ConfigService into the resolver.
 
   // Active capability providers (set by consumers when capabilities are wired)
-  private activeStorageProvider: INewStorageProvider | null = null;
-  private activeSettingsBackend: ISettingsBackend | null = null;
-  private integrationRegistry:
-    | import("@camstack/core").IntegrationRegistry
-    | null = null;
+  private activeStorageProvider: INewStorageProvider | null = null
+  private activeSettingsBackend: ISettingsBackend | null = null
+  private integrationRegistry: import('@camstack/core').IntegrationRegistry | null = null
 
   // Device architecture — in-memory registry of live IDevice instances.
   // Persistence is owned by the `device-manager` capability addon.
-  private readonly deviceRegistry = new DeviceRegistry();
+  private readonly deviceRegistry = new DeviceRegistry()
 
   /**
    * Typed accessor for the Moleculer broker. The Moleculer `index.d.ts`
@@ -303,7 +315,7 @@ export class AddonRegistryService {
    * `this.broker.call(...)` / `this.broker.nodeID` lint clean.
    */
   private get broker(): BrokerLike {
-    return this.moleculer.broker as unknown as BrokerLike;
+    return this.moleculer.broker as unknown as BrokerLike
   }
 
   constructor(
@@ -315,10 +327,8 @@ export class AddonRegistryService {
     private readonly moleculer: MoleculerService,
     private readonly streamProbe: StreamProbeService,
   ) {
-    this.logger = this.loggingService.createLogger("AddonRegistry");
-    this.addonLoader = new AddonLoader(
-      this.loggingService.createLogger("AddonLoader"),
-    );
+    this.logger = this.loggingService.createLogger('AddonRegistry')
+    this.addonLoader = new AddonLoader(this.loggingService.createLogger('AddonLoader'))
 
     // Kernel-level addon health monitor — drives the 5-min boot grace
     // window + aggressive auto-retry loop (60s/120s/300s, never gives
@@ -328,51 +338,42 @@ export class AddonRegistryService {
     // AddonLoadFailed / AddonLoadRecovered events consumed by
     // AlertCenter (see addon-health-monitor.ts spec).
     this.healthMonitor = new AddonHealthMonitor({
-      eventBus: this.eventBusService as unknown as import("@camstack/types").IEventBus,
-      logger: this.loggingService.createLogger("AddonHealthMonitor"),
+      eventBus: this.eventBusService as unknown as import('@camstack/types').IEventBus,
+      logger: this.loggingService.createLogger('AddonHealthMonitor'),
       retryFn: (packageName) => this.tryReloadPackage(packageName),
-    });
+    })
 
     // Create capability registry with config reader for singleton preferences
     this.capabilityRegistry = new CapabilityRegistry(
-      this.loggingService.createLogger("CapabilityRegistry"),
+      this.loggingService.createLogger('CapabilityRegistry'),
       this.eventBusService,
-    );
-    this.capabilityRegistry.setConfigReader(
-      (capability: string): string | undefined => {
-        try {
-          return (
-            this.configService.get<string>(
-              `capabilities.singleton.${capability}`,
-            ) ?? undefined
-          );
-        } catch (err) {
-          this.logger.debug(
-            'settings-store not wired yet during early boot',
-            { meta: { capability, error: errMsg(err) } },
-          );
-          return undefined;
-        }
-      },
-    );
+    )
+    this.capabilityRegistry.setConfigReader((capability: string): string | undefined => {
+      try {
+        return this.configService.get<string>(`capabilities.singleton.${capability}`) ?? undefined
+      } catch (err) {
+        this.logger.debug('settings-store not wired yet during early boot', {
+          meta: { capability, error: errMsg(err) },
+        })
+        return undefined
+      }
+    })
 
     this.capabilityRegistry.setNodeConfigReader(
       (capability: string, nodeId: string): string | undefined => {
         try {
           return (
-            this.configService.get<string>(
-              `capabilities.singletonNode.${capability}.${nodeId}`,
-            ) ?? undefined
-          );
+            this.configService.get<string>(`capabilities.singletonNode.${capability}.${nodeId}`) ??
+            undefined
+          )
         } catch (err) {
-          this.logger.debug(
-            'settings-store not wired yet during early boot',
-            { meta: { capability, nodeId, error: errMsg(err) } },
-          );
-          return undefined;
+          this.logger.debug('settings-store not wired yet during early boot', {
+            meta: { capability, nodeId, error: errMsg(err) },
+          })
+          return undefined
         }
       },
-    );
+    )
 
     // Collection-provider enable/disable persistence. Reads the same
     // `capabilities.collection.<cap>` ConfigService key the `capabilities`
@@ -381,68 +382,59 @@ export class AddonRegistryService {
     this.capabilityRegistry.setCollectionConfigReader(
       (capability: string): readonly string[] | undefined => {
         try {
-          const raw = this.configService.get<string>(
-            `capabilities.collection.${capability}`,
-          );
-          if (!raw) return undefined;
-          const parsed: unknown = JSON.parse(raw);
+          const raw = this.configService.get<string>(`capabilities.collection.${capability}`)
+          if (!raw) return undefined
+          const parsed: unknown = JSON.parse(raw)
           if (
-            typeof parsed === "object" &&
+            typeof parsed === 'object' &&
             parsed !== null &&
-            "disabled" in parsed &&
+            'disabled' in parsed &&
             Array.isArray((parsed as { disabled: unknown }).disabled)
           ) {
-            const disabled = (parsed as { disabled: unknown[] }).disabled;
-            return disabled.filter(
-              (id): id is string => typeof id === "string",
-            );
+            const disabled = (parsed as { disabled: unknown[] }).disabled
+            return disabled.filter((id): id is string => typeof id === 'string')
           }
-          return undefined;
+          return undefined
         } catch (err) {
-          this.logger.debug(
-            "settings-store not wired yet or malformed collection preference",
-            { meta: { capability, error: errMsg(err) } },
-          );
-          return undefined;
+          this.logger.debug('settings-store not wired yet or malformed collection preference', {
+            meta: { capability, error: errMsg(err) },
+          })
+          return undefined
         }
       },
-    );
+    )
 
     // Wire the registry into the CapabilityService so all server services can use it
-    this.capabilityService.setRegistry(this.capabilityRegistry);
+    this.capabilityService.setRegistry(this.capabilityRegistry)
 
     // Register kernel-provided infrastructure capabilities so addons
     // can resolve them via the capability registry like any other cap.
     // These are kernel pseudo-caps (no tRPC methods, object-reference only),
     // so we declare them with empty method maps before registering providers.
     this.capabilityRegistry.declareCapability({
-      name: "device-registry",
-      scope: "system",
-      mode: "singleton",
+      name: 'device-registry',
+      scope: 'system',
+      mode: 'singleton',
       methods: {},
-    });
+    })
     this.capabilityRegistry.declareCapability({
-      name: "cluster-broker",
-      scope: "system",
-      mode: "singleton",
+      name: 'cluster-broker',
+      scope: 'system',
+      mode: 'singleton',
       methods: {},
-    });
-    this.capabilityRegistry.registerProvider(
-      "device-registry",
-      "$kernel",
-      this.deviceRegistry,
-    );
-    this.capabilityRegistry.registerProvider("cluster-broker", "$kernel", {
+    })
+    this.capabilityRegistry.registerProvider('device-registry', '$kernel', this.deviceRegistry)
+    this.capabilityRegistry.registerProvider('cluster-broker', '$kernel', {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- moleculer types unresolvable; see `broker` getter docstring
       broker: this.moleculer.broker,
-    });
+    })
   }
 
   async onModuleInit(): Promise<void> {
     // Register the addon-settings singleton provider — replaces the
     // former `$addonHost` Moleculer service. The provider resolves
     // addonId → local addon instance (hub) or remote Moleculer call.
-    this.capabilityRegistry.declareCapability(addonSettingsCapability);
+    this.capabilityRegistry.declareCapability(addonSettingsCapability)
     // The SINGLE router for addon-level calls (routes / custom / settings).
     // It classifies in-process | hub-local-child (UDS) | remote-agent
     // (Moleculer) in ONE place — `resolveNode` reports only the BASE node
@@ -455,104 +447,89 @@ export class AddonRegistryService {
     this.addonCallGateway = new AddonCallGateway({
       hubNodeId: this.broker.nodeID,
       resolveNode: (addonId) => {
-        const entry = this.addonEntries.get(addonId);
+        const entry = this.addonEntries.get(addonId)
         // Every addon in `addonEntries` is hub-local — report the hub node;
         // forked-vs-in-process is decided by `isChildKnown` in the gateway.
-        return entry ? this.broker.nodeID : "hub";
+        return entry ? this.broker.nodeID : 'hub'
       },
       getChildRegistry: () => this.moleculer.childRegistry,
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- moleculer types unresolvable; see `broker` getter docstring
       broker: this.moleculer.broker,
-    });
+    })
     const settingsProvider = createAddonSettingsProvider({
       getAddon: (addonId) => {
-        const entry = this.addonEntries.get(addonId);
-        return entry?.addon ?? null;
+        const entry = this.addonEntries.get(addonId)
+        return entry?.addon ?? null
       },
       gateway: this.addonCallGateway,
-    });
-    this.capabilityRegistry.registerProvider(
-      "addon-settings",
-      "$hub",
-      settingsProvider,
-    );
+    })
+    this.capabilityRegistry.registerProvider('addon-settings', '$hub', settingsProvider)
 
     // Wire capability consumer actions via EventBus
-    this.wireCapabilityConsumers();
+    this.wireCapabilityConsumers()
 
     // Subscribe to capability.binding-changed so hub-side capability
     // overrides take effect on the fly. The orchestrator addon emits
     // these when the operator swaps the addon implementing a cap on a
     // node; we only react when the target node is the hub's own nodeID.
-    this.eventBusService.subscribe(
-      { category: "capability.binding-changed" },
-      (event) => {
-        const data = (event.data ?? {}) as {
-          nodeId?: string;
-          capName?: string;
-          addonId?: string | null;
-        };
-        if (!data.capName) return;
-        const localNodeId = this.broker.nodeID;
-        if (data.nodeId && data.nodeId !== localNodeId) return;
-        this.capabilityRegistry.setSingletonActiveAddon(
-          data.capName,
-          data.addonId ?? null,
-        );
-      },
-    );
+    this.eventBusService.subscribe({ category: 'capability.binding-changed' }, (event) => {
+      const data = (event.data ?? {}) as {
+        nodeId?: string
+        capName?: string
+        addonId?: string | null
+      }
+      if (!data.capName) return
+      const localNodeId = this.broker.nodeID
+      if (data.nodeId && data.nodeId !== localNodeId) return
+      this.capabilityRegistry.setSingletonActiveAddon(data.capName, data.addonId ?? null)
+    })
 
     // 2. Load all addons from data/addons/ directory (including core builtins)
-    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? "camstack-data");
-    const addonsDir = path.resolve(dataDir, "addons");
+    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? 'camstack-data')
+    const addonsDir = path.resolve(dataDir, 'addons')
 
-    await this.addonLoader.loadFromDirectory(addonsDir);
+    await this.addonLoader.loadFromDirectory(addonsDir)
 
     // Hand pre-init load failures (broken package.json, missing
     // dist, import-time errors) to the health monitor so its retry
     // loop and post-grace alerting cover them. Failures during the
     // init phase below are recorded separately.
     for (const fail of this.addonLoader.listLoadFailures()) {
-      this.healthMonitor.recordFailure(fail.packageName, fail.error, fail.addonId);
+      this.healthMonitor.recordFailure(fail.packageName, fail.error, fail.addonId)
     }
 
-    const loadedAddons = this.addonLoader.listAddons();
+    const loadedAddons = this.addonLoader.listAddons()
 
     for (const registered of loadedAddons) {
       // Skip agent-only addons — they never run on the hub, only on remote
       // agents that opt in via `execution.placement: 'agent-only'`.
       if (isAgentOnlyPlacement(registered.declaration)) {
-        this.logger.info(
-          'Skipping agent-only addon on hub',
-          { tags: { addonId: registered.declaration.id }, meta: { packageName: registered.packageName } },
-        );
-        continue;
+        this.logger.info('Skipping agent-only addon on hub', {
+          tags: { addonId: registered.declaration.id },
+          meta: { packageName: registered.packageName },
+        })
+        continue
       }
       if (registered.declaration.capabilities) {
         for (const cap of registered.declaration.capabilities) {
-          this.capabilityRegistry.declareFromManifest(
-            cap,
-            registered.declaration.id,
-          );
+          this.capabilityRegistry.declareFromManifest(cap, registered.declaration.id)
         }
       }
       // Create and store addon instance — cast from @camstack/types to server's
       // local ICamstackAddon (structurally compatible at runtime).
       // Wrap in try/catch so a single broken addon doesn't prevent the rest from loading.
       try {
-        const addon = this.addonLoader.createInstance(
-          registered.declaration.id,
-        );
+        const addon = this.addonLoader.createInstance(registered.declaration.id)
         // Capabilities come from package.json declaration (source of truth),
         // merged with any declared in the addon class manifest.
         const declCaps = (registered.declaration.capabilities ?? []).map(
           (c: string | CapabilityDeclaration) =>
-            typeof c === "string" ? { name: c, mode: "singleton" as const } : c,
-        );
+            typeof c === 'string' ? { name: c, mode: 'singleton' as const } : c,
+        )
         this.addonEntries.set(registered.declaration.id, {
           addon,
           initialized: false,
-          source: "installed",
+          source: 'installed',
           packageName: registered.packageName,
           packageVersion: registered.packageVersion,
           packageDisplayName: registered.packageDisplayName,
@@ -560,20 +537,19 @@ export class AddonRegistryService {
           declaredCapabilities: declCaps,
           addonDir: path.join(addonsDir, registered.packageName),
           declaration: registered.declaration,
-        });
+        })
       } catch (err) {
-        const msg = errMsg(err);
-        this.logger.error(
-          'Failed to create instance of addon',
-          { tags: { addonId: registered.declaration.id }, meta: { error: msg } },
-        );
+        const msg = errMsg(err)
+        this.logger.error('Failed to create instance of addon', {
+          tags: { addonId: registered.declaration.id },
+          meta: { error: msg },
+        })
       }
     }
 
-    this.logger.info(
-      'Loaded addons from directory',
-      { meta: { count: loadedAddons.length, addonsDir } },
-    );
+    this.logger.info('Loaded addons from directory', {
+      meta: { count: loadedAddons.length, addonsDir },
+    })
     // Platform probing is no longer orchestrated by the backend. The
     // `platform-probe` capability (shipped as a core builtin under
     // `@camstack/core/dist/builtins/platform-probe/` since Phase B of
@@ -582,14 +558,14 @@ export class AddonRegistryService {
     // inside their own `onInitialize`.
 
     // 4. Initialize all installed addons in correct order (installed = active)
-    const allIds = [...this.addonEntries.keys()];
+    const allIds = [...this.addonEntries.keys()]
 
     // Mark registry as ready BEFORE any addon initializes. Addons' onInitialize
     // may call ctx.api.<cap>.* which routes through localProviderLink; that
     // resolver depends on getAllProviders/getSingleton which gate on `_ready`.
     // Without this, Phase 1 and Phase 2 addons would all fall through to the
     // Moleculer broker transport and fail with "service not registered".
-    this.capabilityRegistry.ready();
+    this.capabilityRegistry.ready()
 
     // Native-cap cross-process bridge: when a hub consumer resolves a native
     // provider for a device whose IDevice lives in a forked worker, we
@@ -613,13 +589,13 @@ export class AddonRegistryService {
     // genuinely has no cross-process provider and the fallback returns null — wrappers
     // cleanly fall through to their own secondary strategy.
     {
-      const { buildNativeCapProxy } = await import("@camstack/kernel");
+      const { buildNativeCapProxy } = await import('@camstack/kernel')
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- moleculer types unresolvable; see `broker` getter docstring
-      const broker = this.moleculer.broker;
+      const broker = this.moleculer.broker
       this.capabilityRegistry.setNativeFallback(
         (capName: string, deviceId: number): unknown | null => {
-          const resolver = this.moleculer.capRouteResolver;
-          const hubNodeId = this.moleculer.nodeId;
+          const resolver = this.moleculer.capRouteResolver
+          const hubNodeId = this.moleculer.nodeId
 
           // 1. Hub-local path: the resolver's hub-local-child authority is the
           //    single source of truth for whether a forked hub-local UDS child
@@ -652,8 +628,11 @@ export class AddonRegistryService {
                         : { deviceId }
                     // Re-resolve at call time so a child that respawned under a
                     // new runner id is still reachable (route is cheap to build).
-                    const r = resolver.resolveHubLocalUdsRoute(capName, deviceId)
-                      ?? { kind: 'hub-local-uds' as const, capName, childId }
+                    const r = resolver.resolveHubLocalUdsRoute(capName, deviceId) ?? {
+                      kind: 'hub-local-uds' as const,
+                      capName,
+                      childId,
+                    }
                     return resolver.dispatch(r, property, mergedInput)
                   }
                 },
@@ -672,21 +651,21 @@ export class AddonRegistryService {
             resolveNativeCapOwnerSync?: (
               capName: string,
               deviceId: number,
-            ) => { addonId: string; nodeId: string } | null;
-          }>("device-manager");
-          const owner = dm?.resolveNativeCapOwnerSync?.(capName, deviceId) ?? null;
-          if (!owner) return null;
+            ) => { addonId: string; nodeId: string } | null
+          }>('device-manager')
+          const owner = dm?.resolveNativeCapOwnerSync?.(capName, deviceId) ?? null
+          if (!owner) return null
 
           // Guard: skip hub-local owners here — they were already handled (or skipped
           // because the resolver was null / not initialised yet). Returning null avoids
           // building a Moleculer proxy that points at a UDS-only child.
-          if (owner.nodeId.startsWith(`${hubNodeId}/`)) return null;
+          if (owner.nodeId.startsWith(`${hubNodeId}/`)) return null
 
           // Remote native cap → Moleculer with native-provider infix.
           // buildNativeCapProxy uses the action `${addonId}.native-provider.${cap}.${method}`.
-          return buildNativeCapProxy(broker, owner.addonId, capName, deviceId);
+          return buildNativeCapProxy(broker, owner.addonId, capName, deviceId)
         },
-      );
+      )
     }
 
     // Runner spawn: every non-core, placement-eligible addon runs in its
@@ -707,25 +686,24 @@ export class AddonRegistryService {
     // would violate one-addon-one-process). Retry policy for a failed
     // spawn is governed by the kernel circuit-breaker.
     {
-      const plan = this.buildAddonGroupPlan(allIds);
+      const plan = this.buildAddonGroupPlan(allIds)
       for (const [runnerId, runnerAddons] of plan) {
         try {
-          await this.initializeAddonGroup(runnerId, runnerAddons);
+          await this.initializeAddonGroup(runnerId, runnerAddons)
           for (const { addonId } of runnerAddons) {
-            this.wireCapabilities(addonId);
+            this.wireCapabilities(addonId)
           }
         } catch (error: unknown) {
-          const msg = errMsg(error);
+          const msg = errMsg(error)
           for (const { addonId } of runnerAddons) {
-            this.emitAddonLifecycleEvent("addon.error", addonId, {
+            this.emitAddonLifecycleEvent('addon.error', addonId, {
               error: msg,
-              phase: "init",
-            });
+              phase: 'init',
+            })
           }
-          this.logger.error(
-            "Runner spawn failed — addons on this runner will be skipped",
-            { meta: { runnerId, addonIds: runnerAddons.map((a) => a.addonId), error: msg } },
-          );
+          this.logger.error('Runner spawn failed — addons on this runner will be skipped', {
+            meta: { runnerId, addonIds: runnerAddons.map((a) => a.addonId), error: msg },
+          })
         }
       }
     }
@@ -744,106 +722,102 @@ export class AddonRegistryService {
     // still declare `execution` (e.g. `platform-probe`); the package
     // boundary is the selection criterion.
     const isCoreBuiltin = (id: string): boolean =>
-      this.addonEntries.get(id)?.packageName === "@camstack/core";
+      this.addonEntries.get(id)?.packageName === '@camstack/core'
 
     // Pass 1 — infrastructure builtins. A failed REQUIRED infra cap
     // aborts boot: nothing downstream can run without storage/settings.
     for (const infra of INFRA_CAPABILITIES) {
-      const addonId = this.findAddonForCapability(infra.name, allIds);
+      const addonId = this.findAddonForCapability(infra.name, allIds)
       if (addonId) {
-        const entry = this.addonEntries.get(addonId);
+        const entry = this.addonEntries.get(addonId)
         // Only core builtins boot in-process here. A non-core addon that
         // happens to provide an infra cap (e.g. an alternate
         // storage-provider) lives in its own runner — never in-process.
-        if (!entry || entry.initialized || !isCoreBuiltin(addonId)) continue;
+        if (!entry || entry.initialized || !isCoreBuiltin(addonId)) continue
         try {
-          await this.initializeAddon(addonId);
-          this.wireCapabilities(addonId);
+          await this.initializeAddon(addonId)
+          this.wireCapabilities(addonId)
         } catch (error: unknown) {
-          const msg = errMsg(error);
-          this.emitAddonLifecycleEvent("addon.error", addonId, {
+          const msg = errMsg(error)
+          this.emitAddonLifecycleEvent('addon.error', addonId, {
             error: msg,
-            phase: "init",
-          });
+            phase: 'init',
+          })
           if (infra.required) {
-            throw new Error(
-              `Required infrastructure addon "${addonId}" failed: ${msg}`,
-              { cause: error },
-            );
+            throw new Error(`Required infrastructure addon "${addonId}" failed: ${msg}`, {
+              cause: error,
+            })
           }
-          this.logger.warn(
-            'Optional infra addon failed -- continuing',
-            { tags: { addonId }, meta: { error: msg } },
-          );
+          this.logger.warn('Optional infra addon failed -- continuing', {
+            tags: { addonId },
+            meta: { error: msg },
+          })
         }
       } else if (infra.required) {
-        throw new Error(
-          `No addon provides required infrastructure capability "${infra.name}"`,
-        );
+        throw new Error(`No addon provides required infrastructure capability "${infra.name}"`)
       }
     }
 
     // Pass 2 — remaining core builtins, in capability-dependency order.
-    const bootOrder = this.capabilityRegistry.getBootOrder();
-    const infraNames = new Set(INFRA_CAPABILITIES.map((c) => c.name));
+    const bootOrder = this.capabilityRegistry.getBootOrder()
+    const infraNames = new Set(INFRA_CAPABILITIES.map((c) => c.name))
 
     for (const capName of bootOrder) {
-      if (infraNames.has(capName)) continue; // Handled in pass 1
+      if (infraNames.has(capName)) continue // Handled in pass 1
 
       for (const id of allIds) {
-        const entry = this.addonEntries.get(id);
-        if (!entry || entry.initialized || !isCoreBuiltin(id)) continue;
+        const entry = this.addonEntries.get(id)
+        if (!entry || entry.initialized || !isCoreBuiltin(id)) continue
 
         // Check if this addon provides this capability
-        const provides = this.getAddonCapabilities(entry.addon);
-        if (!provides.some((c) => c.name === capName)) continue;
+        const provides = this.getAddonCapabilities(entry.addon)
+        if (!provides.some((c) => c.name === capName)) continue
 
         try {
-          await this.initializeAddon(id);
-          this.wireCapabilities(id);
+          await this.initializeAddon(id)
+          this.wireCapabilities(id)
         } catch (error: unknown) {
-          const msg = errMsg(error);
-          this.emitAddonLifecycleEvent("addon.error", id, {
+          const msg = errMsg(error)
+          this.emitAddonLifecycleEvent('addon.error', id, {
             error: msg,
-            phase: "init",
-          });
-          this.logger.error(
-            'Core builtin failed to initialize -- skipping',
-            { tags: { addonId: id }, meta: { error: msg } },
-          );
+            phase: 'init',
+          })
+          this.logger.error('Core builtin failed to initialize -- skipping', {
+            tags: { addonId: id },
+            meta: { error: msg },
+          })
         }
       }
     }
 
     // Pass 3 — core builtins that declare no capabilities at all.
     for (const id of allIds) {
-      const entry = this.addonEntries.get(id);
+      const entry = this.addonEntries.get(id)
       if (entry && !entry.initialized && isCoreBuiltin(id)) {
         try {
-          await this.initializeAddon(id);
-          this.wireCapabilities(id);
+          await this.initializeAddon(id)
+          this.wireCapabilities(id)
         } catch (error: unknown) {
-          const msg = errMsg(error);
-          this.emitAddonLifecycleEvent("addon.error", id, {
+          const msg = errMsg(error)
+          this.emitAddonLifecycleEvent('addon.error', id, {
             error: msg,
-            phase: "init",
-          });
-          this.logger.error(
-            'Core builtin failed to initialize -- skipping',
-            { tags: { addonId: id }, meta: { error: msg } },
-          );
+            phase: 'init',
+          })
+          this.logger.error('Core builtin failed to initialize -- skipping', {
+            tags: { addonId: id },
+            meta: { error: msg },
+          })
         }
       }
     }
 
     const initializedIds = [...this.addonEntries.entries()]
       .filter(([, e]) => e.initialized)
-      .map(([id]) => id);
+      .map(([id]) => id)
 
-    this.logger.info(
-      'Addons initialized',
-      { meta: { initializedCount: initializedIds.length, totalCount: this.addonEntries.size } },
-    );
+    this.logger.info('Addons initialized', {
+      meta: { initializedCount: initializedIds.length, totalCount: this.addonEntries.size },
+    })
 
     // Health snapshot: every addon entry that survived the loader is
     // either initialized (record success) or failed init (record
@@ -851,7 +825,7 @@ export class AddonRegistryService {
     // recorded above from `addonLoader.listLoadFailures()`.
     for (const [id, entry] of this.addonEntries.entries()) {
       if (entry.initialized) {
-        this.healthMonitor.recordSuccess(entry.packageName, id);
+        this.healthMonitor.recordSuccess(entry.packageName, id)
       } else {
         // Init failed (caught by either Phase 1 or Phase 2 catch
         // blocks above). The catch handlers don't carry the error
@@ -862,14 +836,14 @@ export class AddonRegistryService {
           entry.packageName,
           new Error(`Addon "${id}" failed to initialize — see addon logs for details`),
           id,
-        );
+        )
       }
     }
 
     // Start the kernel-level retry tick (30s). Fires immediately
     // on the first interval boundary; the 5-min boot grace window
     // suppresses alerts until the system has had time to stabilize.
-    this.healthMonitor.start();
+    this.healthMonitor.start()
 
     // Group-runner / forked-addon crash detection (point 5 of the
     // operator's spec — "ogni fork/moleculer deve essere considerato").
@@ -909,7 +883,7 @@ export class AddonRegistryService {
             entry.packageName,
             new Error(`Addon runner ${nodeId} disconnected`),
             id,
-          );
+          )
         }
       })
       localBus.on('$node.connected', (payload) => {
@@ -919,7 +893,7 @@ export class AddonRegistryService {
           if (!entry.declaration) continue
           const runnerId = resolveRunnerId(entry.declaration, id)
           if (`${this.broker.nodeID}/${runnerId}` !== nodeId) continue
-          this.healthMonitor.recordSuccess(entry.packageName, id);
+          this.healthMonitor.recordSuccess(entry.packageName, id)
         }
       })
     }
@@ -927,10 +901,10 @@ export class AddonRegistryService {
     this.eventBusService.emit({
       id: randomUUID(),
       timestamp: new Date(),
-      source: { type: "core", id: "addon-registry" },
+      source: { type: 'core', id: 'addon-registry' },
       category: EventCategory.SystemAddonsReady,
       data: { activeAddons: initializedIds },
-    });
+    })
   }
 
   /**
@@ -950,83 +924,120 @@ export class AddonRegistryService {
    * monitor's catch path schedules the next retry.
    */
   async tryReloadPackage(packageName: string): Promise<void> {
-    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? "camstack-data");
-    const addonsDir = path.resolve(dataDir, "addons");
-    const addonDir = path.join(addonsDir, packageName);
+    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? 'camstack-data')
+    const addonsDir = path.resolve(dataDir, 'addons')
+    const addonDir = path.join(addonsDir, packageName)
 
     if (!fs.existsSync(addonDir)) {
-      throw new Error(`Package directory missing: ${addonDir}`);
+      throw new Error(`Package directory missing: ${addonDir}`)
     }
 
     // Branch 1: package known to the registry already → restart each
     // addon entry. `restartAddon` rebuilds AddonContext + runs init
     // again; on success the entry's `initialized` flag flips back to
     // true and the monitor's auto-resolve path records success.
-    const knownAddonIds: string[] = [];
+    const knownAddonIds: string[] = []
     for (const [id, entry] of this.addonEntries.entries()) {
       if (entry.packageName === packageName) {
-        knownAddonIds.push(id);
+        knownAddonIds.push(id)
       }
     }
 
     if (knownAddonIds.length > 0) {
-      const errors: string[] = [];
+      const errors: string[] = []
       for (const id of knownAddonIds) {
         try {
-          await this.restartAddon(id);
-          this.healthMonitor.recordSuccess(packageName, id);
+          await this.restartAddon(id)
+          this.healthMonitor.recordSuccess(packageName, id)
         } catch (err) {
-          errors.push(`${id}: ${errMsg(err)}`);
-          this.healthMonitor.recordFailure(packageName, err, id);
+          errors.push(`${id}: ${errMsg(err)}`)
+          this.healthMonitor.recordFailure(packageName, err, id)
         }
       }
       if (errors.length > 0) {
-        throw new Error(`tryReloadPackage failed for ${packageName}: ${errors.join('; ')}`);
+        throw new Error(`tryReloadPackage failed for ${packageName}: ${errors.join('; ')}`)
       }
-      return;
+      return
     }
 
     // Branch 2: package not yet known → run loadNewAddons which
     // walks disk, instantiates new entries, and initializes them.
     // It records its own loaded/failed in the return; we re-throw
     // when our package is in the failed list so the monitor knows.
-    const result = await this.loadNewAddons();
+    const result = await this.loadNewAddons()
     if (result.failed.length > 0) {
-      const failed = result.failed.join(', ');
-      throw new Error(`loadNewAddons reported failures: ${failed}`);
+      const failed = result.failed.join(', ')
+      throw new Error(`loadNewAddons reported failures: ${failed}`)
     }
     if (result.loaded.length === 0) {
-      throw new Error(`No new addons loaded for ${packageName} — package may still have a broken manifest`);
+      throw new Error(
+        `No new addons loaded for ${packageName} — package may still have a broken manifest`,
+      )
     }
     // Match loaded addons to this package + record success.
     for (const id of result.loaded) {
-      const entry = this.addonEntries.get(id);
+      const entry = this.addonEntries.get(id)
       if (entry?.packageName === packageName) {
-        this.healthMonitor.recordSuccess(packageName, id);
+        this.healthMonitor.recordSuccess(packageName, id)
       }
     }
   }
 
   /** Health snapshot — exposed to the addons.list tRPC procedure. */
   getAddonHealthSnapshot(): readonly AddonHealthSnapshot[] {
-    return this.healthMonitor.getHealthSnapshot();
+    return this.healthMonitor.getHealthSnapshot()
   }
 
   /** Manual user-triggered retry (resets retry counter). */
   async retryAddonLoad(packageName: string): Promise<void> {
-    return this.healthMonitor.retryNow(packageName);
+    return this.healthMonitor.retryNow(packageName)
   }
 
   async onModuleDestroy(): Promise<void> {
-    this.logger.info("Shutting down all addons…");
-    this.healthMonitor.stop();
-    await this.shutdownAll();
-    this.logger.info("All addons shut down");
+    this.logger.info('Shutting down all addons…')
+    this.healthMonitor.stop()
+    await this.shutdownAll()
+    this.logger.info('All addons shut down')
   }
 
   /** Set the AddonRouteRegistry for wiring addon-routes capabilities */
   setAddonRouteRegistry(registry: AddonRouteRegistry): void {
-    this.addonRouteRegistry = registry;
+    this.addonRouteRegistry = registry
+  }
+
+  /** Set the DataPlaneRegistry the hub's `/addon/:id/*` dispatch reverse-proxies
+   *  against (addon HTTP data-planes). */
+  setDataPlaneRegistry(registry: DataPlaneRegistry): void {
+    this.dataPlaneRegistry = registry
+  }
+
+  /**
+   * Pull a forked addon's HTTP data-plane endpoints over UDS and register them so
+   * the hub can reverse-proxy `/addon/<addonId>/<prefix>/*` to the addon's own
+   * listener. Idempotent (replace-all); an addon with no data-plane registers an
+   * empty set (cleared). Called off the capabilities-changed signal — a data-plane
+   * isn't a cap, but the child is UDS-reachable and has served its endpoints by
+   * the time any of its caps register.
+   */
+  private async mountAddonDataPlanes(addonId: string): Promise<void> {
+    const registry = this.dataPlaneRegistry
+    if (!registry) return
+    const entry = this.addonEntries.get(addonId)
+    const childRegistry = this.moleculer.childRegistry
+    // Forked addons only for now — co-located builtins would publish into the
+    // registry directly via a hub-side sink (deferred; no builtin serves a
+    // data-plane yet).
+    if (!entry || !this.isForkedAddonEntry(entry)) return
+    if (childRegistry === null || !childRegistry.isChildKnown(addonId)) return
+
+    const raw = await this.addonCallGateway.callForked(addonId, { target: 'data-planes' })
+    const endpoints = parseDataPlaneEndpoints(raw)
+    registry.registerAddon(addonId, endpoints)
+    if (endpoints.length > 0) {
+      this.logger.info('Addon data-planes mounted (reverse-proxy)', {
+        meta: { phase: 'v2', addonId, prefixes: endpoints.map((e) => e.prefix) },
+      })
+    }
   }
 
   /**
@@ -1037,22 +1048,22 @@ export class AddonRegistryService {
    */
   async setAppRouter(_router: unknown): Promise<void> {
     this.logger.debug(
-      "setAppRouter called — broker-routed addon API in use, no direct caller needed",
-    );
+      'setAppRouter called — broker-routed addon API in use, no direct caller needed',
+    )
   }
 
   /** Get the CapabilityRegistry for external consumers to register */
   getCapabilityRegistry(): CapabilityRegistry {
-    return this.capabilityRegistry;
+    return this.capabilityRegistry
   }
 
   /** Get the CustomActionRegistry — Task 7.2 will use this from the `api.addons.custom` tRPC procedure. */
   getCustomActionRegistry(): CustomActionRegistry {
-    return this.customActionRegistry;
+    return this.customActionRegistry
   }
 
   getDeviceRegistry(): DeviceRegistry {
-    return this.deviceRegistry;
+    return this.deviceRegistry
   }
 
   /** Load persisted collection disabled-lists from settings-store into the registry */
@@ -1065,11 +1076,9 @@ export class AddonRegistryService {
    * (where the addon is not currently installed). Orphaned data stays in DB
    * and reconnects automatically when the addon is reinstalled.
    */
-  getIntegrationRegistry():
-    | import("@camstack/types").IIntegrationRegistry
-    | null {
-    if (!this.integrationRegistry) return null;
-    return this.createFilteredRegistry(this.integrationRegistry);
+  getIntegrationRegistry(): import('@camstack/types').IIntegrationRegistry | null {
+    if (!this.integrationRegistry) return null
+    return this.createFilteredRegistry(this.integrationRegistry)
   }
 
   /**
@@ -1080,91 +1089,86 @@ export class AddonRegistryService {
    * overrides directly.
    */
   getSettingsBackend(): ISettingsBackend | null {
-    return this.activeSettingsBackend;
+    return this.activeSettingsBackend
   }
 
   /** Get the raw (unfiltered) registry — only for internal addon wiring */
-  getRawIntegrationRegistry():
-    | import("@camstack/types").IIntegrationRegistry
-    | null {
-    return this.integrationRegistry;
+  getRawIntegrationRegistry(): import('@camstack/types').IIntegrationRegistry | null {
+    return this.integrationRegistry
   }
 
   private createFilteredRegistry(
-    raw: import("@camstack/types").IIntegrationRegistry,
-  ): import("@camstack/types").IIntegrationRegistry {
-    const installedAddonIds = new Set([...this.addonEntries.keys()]);
+    raw: import('@camstack/types').IIntegrationRegistry,
+  ): import('@camstack/types').IIntegrationRegistry {
+    const installedAddonIds = new Set(this.addonEntries.keys())
 
     // Build set of integration IDs whose addon IS installed
     // Cache per call — lightweight, called infrequently
-    let activeIntegrationIds: Set<string> | null = null;
+    let activeIntegrationIds: Set<string> | null = null
     const ensureActiveIds = async () => {
-      if (activeIntegrationIds) return activeIntegrationIds;
-      const all = await raw.listIntegrations();
+      if (activeIntegrationIds) return activeIntegrationIds
+      const all = await raw.listIntegrations()
       activeIntegrationIds = new Set(
         all.filter((i) => installedAddonIds.has(i.addonId)).map((i) => i.id),
-      );
-      return activeIntegrationIds;
-    };
+      )
+      return activeIntegrationIds
+    }
 
     return {
       // Integrations: filter out orphaned
       createIntegration: (input) => raw.createIntegration(input),
       getIntegration: async (id) => {
-        const i = await raw.getIntegration(id);
-        return i && installedAddonIds.has(i.addonId) ? i : null;
+        const i = await raw.getIntegration(id)
+        return i && installedAddonIds.has(i.addonId) ? i : null
       },
       getIntegrationByAddonId: async (addonId) => {
-        if (!installedAddonIds.has(addonId)) return null;
-        return raw.getIntegrationByAddonId(addonId);
+        if (!installedAddonIds.has(addonId)) return null
+        return raw.getIntegrationByAddonId(addonId)
       },
       listIntegrations: async () => {
-        const all = await raw.listIntegrations();
-        return all.filter((i) => installedAddonIds.has(i.addonId));
+        const all = await raw.listIntegrations()
+        return all.filter((i) => installedAddonIds.has(i.addonId))
       },
       updateIntegration: (id, updates) => raw.updateIntegration(id, updates),
       deleteIntegration: (id) => raw.deleteIntegration(id),
 
       // Integration settings: passthrough (already gated by getIntegration)
       getIntegrationSettings: (id) => raw.getIntegrationSettings(id),
-      setIntegrationSetting: (id, key, value) =>
-        raw.setIntegrationSetting(id, key, value),
-      setIntegrationSettings: (id, settings) =>
-        raw.setIntegrationSettings(id, settings),
+      setIntegrationSetting: (id, key, value) => raw.setIntegrationSetting(id, key, value),
+      setIntegrationSettings: (id, settings) => raw.setIntegrationSettings(id, settings),
 
       // Devices: filter out devices belonging to orphaned integrations
       createDevice: (input) => raw.createDevice(input),
       getDevice: async (id) => {
-        const d = await raw.getDevice(id);
-        if (!d) return null;
-        const ids = await ensureActiveIds();
-        return ids.has(d.integrationId) ? d : null;
+        const d = await raw.getDevice(id)
+        if (!d) return null
+        const ids = await ensureActiveIds()
+        return ids.has(d.integrationId) ? d : null
       },
       getDeviceByStableId: async (stableId) => {
-        const d = await raw.getDeviceByStableId(stableId);
-        if (!d) return null;
-        const ids = await ensureActiveIds();
-        return ids.has(d.integrationId) ? d : null;
+        const d = await raw.getDeviceByStableId(stableId)
+        if (!d) return null
+        const ids = await ensureActiveIds()
+        return ids.has(d.integrationId) ? d : null
       },
       listDevices: async (integrationId) => {
-        const devices = await raw.listDevices(integrationId);
-        const ids = await ensureActiveIds();
-        return devices.filter((d) => ids.has(d.integrationId));
+        const devices = await raw.listDevices(integrationId)
+        const ids = await ensureActiveIds()
+        return devices.filter((d) => ids.has(d.integrationId))
       },
       listCameras: async () => {
-        const cameras = await raw.listCameras();
-        const ids = await ensureActiveIds();
-        return cameras.filter((d) => ids.has(d.integrationId));
+        const cameras = await raw.listCameras()
+        const ids = await ensureActiveIds()
+        return cameras.filter((d) => ids.has(d.integrationId))
       },
       updateDevice: (id, updates) => raw.updateDevice(id, updates),
       deleteDevice: (id) => raw.deleteDevice(id),
 
       // Device settings: passthrough
       getDeviceSettings: (id) => raw.getDeviceSettings(id),
-      setDeviceSetting: (id, key, value) =>
-        raw.setDeviceSetting(id, key, value),
+      setDeviceSetting: (id, key, value) => raw.setDeviceSetting(id, key, value),
       setDeviceSettings: (id, settings) => raw.setDeviceSettings(id, settings),
-    };
+    }
   }
 
   // InferenceCapabilitiesService removed — now lives in pipeline-executor addon.
@@ -1172,21 +1176,24 @@ export class AddonRegistryService {
 
   /** Log a standardized lifecycle line for addon start/restart */
   private logAddonLifecycle(
-    event: "started" | "restarted",
+    event: 'started' | 'restarted',
     id: string,
-    mode: "in-process" | "isolated",
+    mode: 'in-process' | 'isolated',
   ): void {
-    const entry = this.addonEntries.get(id);
-    if (!entry) return;
-    const agentName = process.env.CAMSTACK_AGENT_NAME ?? "hub";
-    const platform = `${os.platform()}/${os.arch()}`;
-    const message = `Addon ${event} — v${entry.packageVersion} (${entry.packageName}), ${mode}, ${platform}, agent: ${agentName}`;
+    const entry = this.addonEntries.get(id)
+    if (!entry) return
+    const agentName = process.env.CAMSTACK_AGENT_NAME ?? 'hub'
+    const platform = `${os.platform()}/${os.arch()}`
+    const message = `Addon ${event} — v${entry.packageVersion} (${entry.packageName}), ${mode}, ${platform}, agent: ${agentName}`
     // Log under AddonRegistry scope
-    this.logger.info(message, { tags: { addonId: id, agentId: agentName }, meta: { phase: 'lifecycle' } });
+    this.logger.info(message, {
+      tags: { addonId: id, agentId: agentName },
+      meta: { phase: 'lifecycle' },
+    })
     // Also log under the addon's own tagged logger so it appears in the per-addon
     // log viewer. No scope — brand bracket shows the addon id.
-    const addonLogger = this.loggingService.createLogger();
-    addonLogger.info(message, { tags: { addonId: id, agentId: agentName } });
+    const addonLogger = this.loggingService.createLogger()
+    addonLogger.info(message, { tags: { addonId: id, agentId: agentName } })
   }
 
   // Platform probing and inference-config resolution have moved into the
@@ -1197,36 +1204,34 @@ export class AddonRegistryService {
 
   registerAddon(
     addon: ICamstackAddon,
-    source: AddonSource = "installed",
+    source: AddonSource = 'installed',
     packageName?: string,
     packageVersion?: string,
   ): void {
-    const manifest = addon.manifest;
+    const manifest = addon.manifest
     if (!manifest) {
       throw new Error(
-        "Cannot register addon without manifest — was it created via AddonLoader.createInstance()?",
-      );
+        'Cannot register addon without manifest — was it created via AddonLoader.createInstance()?',
+      )
     }
     this.addonEntries.set(manifest.id, {
       addon,
       initialized: false,
       source,
       packageName: packageName ?? manifest.name ?? manifest.id,
-      packageVersion: packageVersion ?? manifest.version ?? "0.0.0",
+      packageVersion: packageVersion ?? manifest.version ?? '0.0.0',
       declaredCapabilities: this.getAddonCapabilities(addon),
-    });
+    })
   }
 
   async initializeAddon(id: string): Promise<void> {
-    const entry = this.addonEntries.get(id);
+    const entry = this.addonEntries.get(id)
     if (!entry) {
-      throw new Error(`Addon "${id}" is not registered`);
+      throw new Error(`Addon "${id}" is not registered`)
     }
 
     if (!entry.addon?.manifest?.id) {
-      throw new Error(
-        `Addon "${id}" has no manifest.id — check the addon class default export`,
-      );
+      throw new Error(`Addon "${id}" has no manifest.id — check the addon class default export`)
     }
 
     // Decide whether this addon should boot in its own forked runner
@@ -1246,25 +1251,22 @@ export class AddonRegistryService {
       // silently run on the hub. (Task 7's circuit breaker governs the
       // retry policy on top of this.)
       try {
-        await this.broker.call("$process.spawnRunner", {
+        await this.broker.call('$process.spawnRunner', {
           runnerId: id,
           addons: [{ addonId: id, addonDir: entry.addonDir }],
-        });
+        })
       } catch (err) {
-        const msg = errMsg(err);
-        this.logger.error(
-          'Failed to spawn isolated runner for addon',
-          { tags: { addonId: id }, meta: { error: msg } },
-        );
-        this.emitAddonLifecycleEvent("addon.error", id, {
+        const msg = errMsg(err)
+        this.logger.error('Failed to spawn isolated runner for addon', {
+          tags: { addonId: id },
+          meta: { error: msg },
+        })
+        this.emitAddonLifecycleEvent('addon.error', id, {
           error: msg,
-          action: "initialize",
-        });
-        this.healthMonitor.recordFailure(entry.packageName, err, id);
-        throw new Error(
-          `Failed to spawn runner for addon "${id}": ${msg}`,
-          { cause: err },
-        );
+          action: 'initialize',
+        })
+        this.healthMonitor.recordFailure(entry.packageName, err, id)
+        throw new Error(`Failed to spawn runner for addon "${id}": ${msg}`, { cause: err })
       }
 
       // Provider registration for forkable addons is delegated to the
@@ -1285,24 +1287,22 @@ export class AddonRegistryService {
         id,
         // `isForkedAddonEntry` narrowed `entry.declaration` to non-null.
         resolveRunnerId(entry.declaration, id),
-      );
+      )
 
-      entry.initialized = true;
-      this.logger.info('Addon spawned as isolated process', { tags: { addonId: id } });
-      this.emitAddonLifecycleEvent("addon.started", id);
-      return;
+      entry.initialized = true
+      this.logger.info('Addon spawned as isolated process', { tags: { addonId: id } })
+      this.emitAddonLifecycleEvent('addon.started', id)
+      return
     }
 
     // In-process initialization — capture providers from initialize() return value
-    const context = await this.createAddonContext(entry.addon);
-    const capturedProviders = new Map<string, unknown>();
+    const context = await this.createAddonContext(entry.addon)
+    const capturedProviders = new Map<string, unknown>()
     // Device-manager needs privileged access to CapabilityRegistry — it
     // resolves native addon ids for getBindings, lists registered wrappers,
     // etc. Inject before initialize() runs so the addon's onInitialize can
     // rely on it.
-    const initResult = normalizeAddonInitResult(
-      await entry.addon.initialize(context),
-    );
+    const initResult = normalizeAddonInitResult(await entry.addon.initialize(context))
     // NOTE: `postBrokerStart()` is deliberately NOT called here. It used to
     // fire right after `initialize()` and would emit readiness events whose
     // subscribers (remote workers) immediately called `ctx.api.<addon>.*` —
@@ -1311,9 +1311,9 @@ export class AddonRegistryService {
     // service mount so the advertised service is live before readiness.
 
     for (const reg of initResult?.providers ?? []) {
-      const capName = reg.capability.name;
-      capturedProviders.set(capName, reg.provider);
-      context.registerProvider(capName, reg.provider);
+      const capName = reg.capability.name
+      capturedProviders.set(capName, reg.provider)
+      context.registerProvider(capName, reg.provider)
       // D4: wrapper behaviour is read from the cap DEFINITION. The runtime
       // ProviderRegistration.kind/defaultActive are deprecated hints — if an
       // addon still sets them and they disagree, warn (the cap def wins).
@@ -1322,42 +1322,35 @@ export class AddonRegistryService {
         kind: reg.kind,
         // eslint-disable-next-line @typescript-eslint/no-deprecated -- this IS the drift detector; it reads the deprecated hint on purpose
         defaultActive: reg.defaultActive,
-      });
+      })
       if (kindDrift) {
         this.logger.warn(kindDrift, {
           tags: { addonId: id },
           meta: { capability: capName },
-        });
+        })
       }
-      if (reg.capability.kind === "wrapper") {
+      if (reg.capability.kind === 'wrapper') {
         this.capabilityRegistry.registerWrapper(capName, id, {
           defaultActive: reg.capability.defaultActive === true,
-        });
+        })
       }
     }
 
     // Task 7.1: register system-level custom actions if the addon declares any.
     if (initResult?.customActions && initResult.actionHandlers) {
-      const handlers = initResult.actionHandlers;
+      const handlers = initResult.actionHandlers
       try {
-        this.customActionRegistry.registerAddon(
-          id,
-          initResult.customActions,
-          (action, input) => {
-            const fn = handlers[action];
-            if (!fn)
-              throw new Error(
-                `addon '${id}' has no handler for custom action '${action}'`,
-              );
-            return fn(input);
-          },
-        );
+        this.customActionRegistry.registerAddon(id, initResult.customActions, (action, input) => {
+          const fn = handlers[action]
+          if (!fn) throw new Error(`addon '${id}' has no handler for custom action '${action}'`)
+          return fn(input)
+        })
       } catch (err) {
-        this.logger.error(
-          'Failed to register custom actions for addon',
-          { tags: { addonId: id }, meta: { error: errMsg(err) } },
-        );
-        throw err;
+        this.logger.error('Failed to register custom actions for addon', {
+          tags: { addonId: id },
+          meta: { error: errMsg(err) },
+        })
+        throw err
       }
     }
 
@@ -1369,45 +1362,37 @@ export class AddonRegistryService {
     // without forcing addons into a single return-path pattern.
     if (entry.declaration) {
       for (const cap of entry.declaration.capabilities ?? []) {
-        const capName = typeof cap === "string" ? cap : cap.name;
-        if (capturedProviders.has(capName)) continue;
-        const provider = this.capabilityRegistry.getProviderByAddon(
-          capName,
-          id,
-        );
-        if (provider) capturedProviders.set(capName, provider);
+        const capName = typeof cap === 'string' ? cap : cap.name
+        if (capturedProviders.has(capName)) continue
+        const provider = this.capabilityRegistry.getProviderByAddon(capName, id)
+        if (provider) capturedProviders.set(capName, provider)
       }
-      validateProviderRegistrations(
-        id,
-        entry.declaration,
-        capturedProviders,
-        this.logger,
-      );
+      validateProviderRegistrations(id, entry.declaration, capturedProviders, this.logger)
     }
 
-    await this.restoreAddonDevices(id, entry.addon);
-    entry.initialized = true;
+    await this.restoreAddonDevices(id, entry.addon)
+    entry.initialized = true
 
     // Register as Moleculer service for remote discoverability
     if (entry.declaration) {
       try {
         // Resolve method names from CapabilityDefinitions registered in the registry
         const methodResolver = (capName: string): readonly string[] => {
-          const def = this.capabilityRegistry.getDefinition(capName);
-          if (!def?.methods) return [];
-          return Object.keys(def.methods);
-        };
+          const def = this.capabilityRegistry.getDefinition(capName)
+          if (!def?.methods) return []
+          return Object.keys(def.methods)
+        }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- createAddonService return type unresolvable due to upstream eventemitter2/moleculer type chain
         const schema = createAddonService(entry.addon, entry.declaration!, {
           methodResolver,
           providers: capturedProviders,
-        });
-        this.broker.createService(schema);
+        })
+        this.broker.createService(schema)
       } catch (err) {
-        this.logger.warn(
-          'Failed to register Moleculer service',
-          { tags: { addonId: id }, meta: { error: errMsg(err) } },
-        );
+        this.logger.warn('Failed to register Moleculer service', {
+          tags: { addonId: id },
+          meta: { error: errMsg(err) },
+        })
       }
     }
 
@@ -1416,14 +1401,14 @@ export class AddonRegistryService {
     // immediately call `ctx.api.<addon>.*` without hitting a phantom
     // service window. Hub addons with `autoEmitReadiness=true` emit here;
     // addons that manage their own readiness override `autoEmitReadiness`.
-    entry.addon.postBrokerStart();
-
-    this.logger.info(
-      'Addon initialized in-process',
-      { tags: { addonId: id }, meta: { packageName: entry.packageName } },
-    );
-    this.logAddonLifecycle("started", id, "in-process");
-    this.emitAddonLifecycleEvent("addon.started", id);
+    entry.addon.postBrokerStart()
+
+    this.logger.info('Addon initialized in-process', {
+      tags: { addonId: id },
+      meta: { packageName: entry.packageName },
+    })
+    this.logAddonLifecycle('started', id, 'in-process')
+    this.emitAddonLifecycleEvent('addon.started', id)
   }
 
   /**
@@ -1431,70 +1416,65 @@ export class AddonRegistryService {
    * Calls addon.restoreDevices() with the list of devices saved to the DB.
    * No-op if the addon does not implement restoreDevices() or stores are not available.
    */
-  private async restoreAddonDevices(
-    addonId: string,
-    addon: ICamstackAddon,
-  ): Promise<void> {
-    if (typeof addon.restoreDevices !== "function") return;
+  private async restoreAddonDevices(addonId: string, addon: ICamstackAddon): Promise<void> {
+    if (typeof addon.restoreDevices !== 'function') return
 
     // Route through the device-persistence capability instead of
     // accessing DeviceStore/ConfigStore directly. This keeps
     // AddonRegistryService decoupled from the persistence layer —
     // the capability addon owns the stores.
-    const api = this.getBrokerApi();
+    const api = this.getBrokerApi()
     try {
       const listResult: unknown = await (
-        Reflect.get(
-          Reflect.get(api, "deviceManager") as object,
-          "listPersistedByAddon",
-        ) as { query: (input: unknown) => Promise<unknown> }
-      ).query({ addonId });
+        Reflect.get(Reflect.get(api, 'deviceManager') as object, 'listPersistedByAddon') as {
+          query: (input: unknown) => Promise<unknown>
+        }
+      ).query({ addonId })
 
       const rows = Array.isArray(listResult)
         ? (listResult as Array<{
-            id: number;
-            stableId: string;
-            type: string;
-            name: string;
-            location?: string | null;
-            disabled?: boolean;
-            parentDeviceId: number | null;
+            id: number
+            stableId: string
+            type: string
+            name: string
+            location?: string | null
+            disabled?: boolean
+            parentDeviceId: number | null
           }>)
-        : [];
-      if (rows.length === 0) return;
+        : []
+      if (rows.length === 0) return
 
       const savedDevices: SavedDevice[] = await Promise.all(
         rows.map(async (row) => {
           const configResult: unknown = await (
-            Reflect.get(
-              Reflect.get(api, "deviceManager") as object,
-              "loadConfig",
-            ) as { query: (input: unknown) => Promise<unknown> }
-          ).query({ deviceId: row.id });
+            Reflect.get(Reflect.get(api, 'deviceManager') as object, 'loadConfig') as {
+              query: (input: unknown) => Promise<unknown>
+            }
+          ).query({ deviceId: row.id })
 
           return {
             id: row.id,
             stableId: row.stableId,
-            type: row.type as import("@camstack/types").DeviceType,
+            type: row.type as import('@camstack/types').DeviceType,
             name: row.name,
             location: row.location ?? null,
             disabled: row.disabled ?? false,
             parentDeviceId: row.parentDeviceId,
             config: (configResult ?? {}) as Record<string, unknown>,
-          };
+          }
         }),
-      );
+      )
 
-      await addon.restoreDevices!(savedDevices);
-      this.logger.info(
-        'Restored devices for addon',
-        { tags: { addonId }, meta: { count: savedDevices.length } },
-      );
+      await addon.restoreDevices!(savedDevices)
+      this.logger.info('Restored devices for addon', {
+        tags: { addonId },
+        meta: { count: savedDevices.length },
+      })
     } catch (err) {
-      this.logger.error(
-        'restoreDevices failed for addon',
-        { tags: { addonId }, meta: { error: errMsg(err) } },
-      );
+      this.logger.error('restoreDevices failed for addon', {
+        tags: { addonId },
+        meta: { error: errMsg(err) },
+      })
     }
   }
 
@@ -1505,11 +1485,11 @@ export class AddonRegistryService {
   refreshPackageVersion(packageName: string, newVersion: string): void {
     for (const [, entry] of this.addonEntries) {
       if (entry.packageName === packageName) {
-        entry.packageVersion = newVersion;
-        this.logger.info(
-          'Updated addon packageVersion',
-          { tags: { addonId: entry.addon.manifest!.id }, meta: { newVersion } },
-        );
+        entry.packageVersion = newVersion
+        this.logger.info('Updated addon packageVersion', {
+          tags: { addonId: entry.addon.manifest!.id },
+          meta: { newVersion },
+        })
       }
     }
   }
@@ -1518,29 +1498,25 @@ export class AddonRegistryService {
   emitUninstallEvent(packageName: string): void {
     for (const [id, entry] of this.addonEntries) {
       if (entry.packageName === packageName) {
-        this.emitAddonLifecycleEvent("addon.uninstalled", id);
+        this.emitAddonLifecycleEvent('addon.uninstalled', id)
       }
     }
     // Drop the package from the health monitor so its retry loop
     // doesn't keep trying to reload an addon the operator explicitly
     // removed. Matching `clearLoadFailures` purges any pre-init
     // failures still tracked by the addon-loader.
-    this.healthMonitor.forget(packageName);
-    this.addonLoader.clearLoadFailures(packageName);
+    this.healthMonitor.forget(packageName)
+    this.addonLoader.clearLoadFailures(packageName)
   }
 
   /** Emit addon.updated lifecycle event for all addons belonging to a package */
-  emitUpdateEvent(
-    packageName: string,
-    fromVersion: string,
-    toVersion: string,
-  ): void {
+  emitUpdateEvent(packageName: string, fromVersion: string, toVersion: string): void {
     for (const [id, entry] of this.addonEntries) {
       if (entry.packageName === packageName) {
-        this.emitAddonLifecycleEvent("addon.updated", id, {
+        this.emitAddonLifecycleEvent('addon.updated', id, {
           fromVersion,
           toVersion,
-        });
+        })
       }
     }
   }
@@ -1549,37 +1525,33 @@ export class AddonRegistryService {
    * Restart an addon by ID.
    * Shuts down, unregisters capabilities, re-initializes, and re-wires.
    */
-  async restartAddon(
-    addonId: string,
-  ): Promise<{ success: boolean; error?: string }> {
-    const entry = this.addonEntries.get(addonId);
+  async restartAddon(addonId: string): Promise<{ success: boolean; error?: string }> {
+    const entry = this.addonEntries.get(addonId)
     if (!entry) {
-      return { success: false, error: `Addon "${addonId}" not found` };
+      return { success: false, error: `Addon "${addonId}" not found` }
     }
 
-    this.logger.info('Addon restarting...', { tags: { addonId }, meta: { phase: 'lifecycle' } });
+    this.logger.info('Addon restarting...', { tags: { addonId }, meta: { phase: 'lifecycle' } })
 
     // Suppress the "Failed to load" health banner during operator-initiated
     // restarts. The Moleculer `$node.disconnected` handler skips entries
     // present in `restartingAddons`; a 90s safety timer clears the flag
     // even if the restart path throws before the finally block runs.
-    const existingTimer = this.restartingAddons.get(addonId);
-    if (existingTimer) clearTimeout(existingTimer);
+    const existingTimer = this.restartingAddons.get(addonId)
+    if (existingTimer) clearTimeout(existingTimer)
     const safetyTimer = setTimeout(() => {
-      this.restartingAddons.delete(addonId);
-    }, 90_000);
-    this.restartingAddons.set(addonId, safetyTimer);
+      this.restartingAddons.delete(addonId)
+    }, 90_000)
+    this.restartingAddons.set(addonId, safetyTimer)
 
     try {
       // Group-runner-hosted addon — delegate to $process.restart for the group
       if (this.isForkedAddonEntry(entry)) {
-        const result = (await this.broker.call("$process.restart", {
+        const result = (await this.broker.call('$process.restart', {
           name: addonId,
-        })) as { success: boolean; reason?: string };
+        })) as { success: boolean; reason?: string }
         if (!result.success) {
-          throw new Error(
-            `Process restart failed: ${result.reason ?? "unknown"}`,
-          );
+          throw new Error(`Process restart failed: ${result.reason ?? 'unknown'}`)
         }
 
         // $process.restart resolves as soon as the child is respawned, not when its
@@ -1587,7 +1559,7 @@ export class AddonRegistryService {
         // immediately try to route to the provider and hit a transient null. Block here
         // until every declared capability is back on the registry so the restart is
         // observable-consistent from the caller's perspective.
-        const declared = entry.declaredCapabilities;
+        const declared = entry.declaredCapabilities
         if (declared.length > 0) {
           // Group-runner restarts pay a multi-step cost: child fork
           // (~1s) → addon init (Python pool warmup ~5-10s, or a CLI
@@ -1601,15 +1573,15 @@ export class AddonRegistryService {
           // always click Cancel on the UI mutation.
           const waits = declared.map((cap) =>
             this.capabilityRegistry.waitForProvider(cap.name, addonId, Number.POSITIVE_INFINITY),
-          );
-          const settled = await Promise.all(waits);
+          )
+          const settled = await Promise.all(waits)
           const missing = declared
             .map((cap, i) => (settled[i] == null ? cap.name : null))
-            .filter((name): name is string => name !== null);
+            .filter((name): name is string => name !== null)
           if (missing.length > 0) {
             throw new Error(
-              `Addon "${addonId}" restarted but did not re-register capabilities in time: ${missing.join(", ")}`,
-            );
+              `Addon "${addonId}" restarted but did not re-register capabilities in time: ${missing.join(', ')}`,
+            )
           }
         }
 
@@ -1621,12 +1593,12 @@ export class AddonRegistryService {
         // drops its custom actions (the catalog is only registered once,
         // at boot, in `initializeAddonGroup`). Reads a fresh catalog from
         // the just-updated on-disk bundle.
-        const runnerId = resolveRunnerId(entry.declaration!, addonId);
-        await this.registerForkedAddonCustomActions(addonId, runnerId);
+        const runnerId = resolveRunnerId(entry.declaration!, addonId)
+        await this.registerForkedAddonCustomActions(addonId, runnerId)
 
-        this.logAddonLifecycle("restarted", addonId, "isolated");
-        this.emitAddonLifecycleEvent("addon.restarted", addonId);
-        return { success: true };
+        this.logAddonLifecycle('restarted', addonId, 'isolated')
+        this.emitAddonLifecycleEvent('addon.restarted', addonId)
+        return { success: true }
       }
 
       // D5: a forked addon ALWAYS restarts via `$process.restart` above
@@ -1635,51 +1607,51 @@ export class AddonRegistryService {
       // — they have no runner and legitimately reload in-process:
       // shutdown, unregister, re-initialize, re-wire.
       if (entry.initialized && entry.addon.shutdown) {
-        await entry.addon.shutdown();
+        await entry.addon.shutdown()
       }
       // Drain disposers registered via ctx.addDisposer(...)
-      await this.drainDisposerChain(addonId);
+      await this.drainDisposerChain(addonId)
 
       // Unregister all capabilities provided by this addon
       for (const cap of entry.declaredCapabilities) {
-        this.capabilityRegistry.unregisterProvider(cap.name, addonId);
+        this.capabilityRegistry.unregisterProvider(cap.name, addonId)
       }
-      const manifestCaps = this.getAddonCapabilities(entry.addon);
+      const manifestCaps = this.getAddonCapabilities(entry.addon)
       for (const cap of manifestCaps) {
-        this.capabilityRegistry.unregisterProvider(cap.name, addonId);
+        this.capabilityRegistry.unregisterProvider(cap.name, addonId)
       }
-      this.capabilityRegistry.unregisterAllWrappersForAddon(addonId);
+      this.capabilityRegistry.unregisterAllWrappersForAddon(addonId)
 
       // Task 7.1: drop any registered custom actions so re-initialization re-registers cleanly.
-      this.customActionRegistry.unregisterAddon(addonId);
+      this.customActionRegistry.unregisterAddon(addonId)
 
       // Destroy existing Moleculer service for this addon
       try {
         await (
           this.moleculer.broker as unknown as {
-            destroyService(name: string): Promise<void>;
+            destroyService(name: string): Promise<void>
           }
-        ).destroyService(addonId);
+        ).destroyService(addonId)
       } catch {
         // Service may not exist if it was never registered
       }
 
-      entry.initialized = false;
+      entry.initialized = false
 
       // Re-initialize and re-wire capabilities
-      await this.initializeAddon(addonId);
-      this.wireCapabilities(addonId);
+      await this.initializeAddon(addonId)
+      this.wireCapabilities(addonId)
 
-      this.logAddonLifecycle("restarted", addonId, "in-process");
-      this.emitAddonLifecycleEvent("addon.restarted", addonId);
-      return { success: true };
+      this.logAddonLifecycle('restarted', addonId, 'in-process')
+      this.emitAddonLifecycleEvent('addon.restarted', addonId)
+      return { success: true }
     } catch (err) {
-      const msg = errMsg(err);
-      this.logger.error('Failed to restart addon', { tags: { addonId }, meta: { error: msg } });
-      this.emitAddonLifecycleEvent("addon.error", addonId, {
+      const msg = errMsg(err)
+      this.logger.error('Failed to restart addon', { tags: { addonId }, meta: { error: msg } })
+      this.emitAddonLifecycleEvent('addon.error', addonId, {
         error: msg,
-        action: "restart",
-      });
+        action: 'restart',
+      })
       // Record the failure on the health monitor so the addon shows up
       // `failed` with its `lastError` instead of a stale `healthy`. The
       // in-process branch already unregistered every capability before
@@ -1689,26 +1661,26 @@ export class AddonRegistryService {
       // only holds for a UI-clicked restart; a `camstack deploy` or a
       // `requiresRestart` auto-restart is fire-and-forget — the failure
       // would otherwise vanish. recordFailure also arms the retry loop.
-      this.healthMonitor.recordFailure(entry.packageName, err, addonId);
-      return { success: false, error: msg };
+      this.healthMonitor.recordFailure(entry.packageName, err, addonId)
+      return { success: false, error: msg }
     } finally {
       // Clear the suppression flag regardless of success/failure — if the
       // restart failed, the operator will see the real error via the
       // mutation result rather than a misleading transient health blip.
-      const timer = this.restartingAddons.get(addonId);
-      if (timer) clearTimeout(timer);
-      this.restartingAddons.delete(addonId);
+      const timer = this.restartingAddons.get(addonId)
+      if (timer) clearTimeout(timer)
+      this.restartingAddons.delete(addonId)
     }
   }
 
   getAddon(id: string): ICamstackAddon | null {
-    const entry = this.addonEntries.get(id);
-    return entry?.addon ?? null;
+    const entry = this.addonEntries.get(id)
+    return entry?.addon ?? null
   }
 
   getAddonEntry(id: string): { addon: ICamstackAddon } | null {
-    const entry = this.addonEntries.get(id);
-    return entry ? { addon: entry.addon } : null;
+    const entry = this.addonEntries.get(id)
+    return entry ? { addon: entry.addon } : null
   }
 
   /**
@@ -1722,48 +1694,50 @@ export class AddonRegistryService {
    * sees a broken-image placeholder for any failed addon.
    */
   getAddonPackageDir(id: string): string | null {
-    const entry = this.addonEntries.get(id);
-    if (entry?.addonDir) return entry.addonDir;
-    return this.findAddonDirOnDisk(id);
+    const entry = this.addonEntries.get(id)
+    if (entry?.addonDir) return entry.addonDir
+    return this.findAddonDirOnDisk(id)
   }
 
   private findAddonDirOnDisk(addonId: string): string | null {
-    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? "camstack-data");
-    const addonsDir = path.resolve(dataDir, "addons");
-    if (!fs.existsSync(addonsDir)) return null;
+    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? 'camstack-data')
+    const addonsDir = path.resolve(dataDir, 'addons')
+    if (!fs.existsSync(addonsDir)) return null
 
     const visit = (pkgDir: string): string | null => {
-      const pkgJsonPath = path.join(pkgDir, "package.json");
-      if (!fs.existsSync(pkgJsonPath)) return null;
+      const pkgJsonPath = path.join(pkgDir, 'package.json')
+      if (!fs.existsSync(pkgJsonPath)) return null
       try {
-        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")) as Record<string, unknown>;
-        const camstack = (pkg["camstack"] as { addons?: unknown[] } | undefined) ?? {};
-        const addons = Array.isArray(camstack.addons) ? camstack.addons as Record<string, unknown>[] : [];
-        if (addons.some((a) => a["id"] === addonId)) return pkgDir;
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8')) as Record<string, unknown>
+        const camstack = (pkg['camstack'] as { addons?: unknown[] } | undefined) ?? {}
+        const addons = Array.isArray(camstack.addons)
+          ? (camstack.addons as Record<string, unknown>[])
+          : []
+        if (addons.some((a) => a['id'] === addonId)) return pkgDir
       } catch {
-        return null;
+        return null
       }
-      return null;
-    };
+      return null
+    }
 
-    const entries = fs.readdirSync(addonsDir, { withFileTypes: true });
+    const entries = fs.readdirSync(addonsDir, { withFileTypes: true })
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dirName = entry.name;
-      if (dirName === "node_modules" || dirName.startsWith(".")) continue;
-      const fullPath = path.join(addonsDir, dirName);
-      if (dirName.startsWith("@")) {
+      if (!entry.isDirectory()) continue
+      const dirName = entry.name
+      if (dirName === 'node_modules' || dirName.startsWith('.')) continue
+      const fullPath = path.join(addonsDir, dirName)
+      if (dirName.startsWith('@')) {
         for (const sub of fs.readdirSync(fullPath, { withFileTypes: true })) {
-          if (!sub.isDirectory()) continue;
-          const found = visit(path.join(fullPath, sub.name));
-          if (found) return found;
+          if (!sub.isDirectory()) continue
+          const found = visit(path.join(fullPath, sub.name))
+          if (found) return found
         }
       } else {
-        const found = visit(fullPath);
-        if (found) return found;
+        const found = visit(fullPath)
+        if (found) return found
       }
     }
-    return null;
+    return null
   }
 
   /**
@@ -1781,13 +1755,13 @@ export class AddonRegistryService {
    * has no `entry` field. The returned `distDir` is an absolute path.
    */
   getAddonInstallPath(addonId: string): { addonDir: string; distDir: string } | null {
-    const entry = this.addonEntries.get(addonId);
-    if (!entry?.addonDir || !entry.declaration?.entry) return null;
-    const distSubdir = path.dirname(entry.declaration.entry);
+    const entry = this.addonEntries.get(addonId)
+    if (!entry?.addonDir || !entry.declaration?.entry) return null
+    const distSubdir = path.dirname(entry.declaration.entry)
     return {
       addonDir: entry.addonDir,
       distDir: path.resolve(entry.addonDir, distSubdir),
-    };
+    }
   }
 
   /**
@@ -1795,9 +1769,9 @@ export class AddonRegistryService {
    * Used by the benchmark system to create fresh addon instances with custom config.
    */
   async buildAddonContext(addonId: string): Promise<AddonContext | null> {
-    const entry = this.addonEntries.get(addonId);
-    if (!entry) return null;
-    return this.createAddonContext(entry.addon);
+    const entry = this.addonEntries.get(addonId)
+    if (!entry) return null
+    return this.createAddonContext(entry.addon)
   }
 
   /**
@@ -1810,10 +1784,10 @@ export class AddonRegistryService {
    */
   isPackageProtected(packageName: string): boolean {
     for (const entry of this.addonEntries.values()) {
-      if (entry.packageName !== packageName) continue;
-      if (entry.declaration?.protected === true) return true;
+      if (entry.packageName !== packageName) continue
+      if (entry.declaration?.protected === true) return true
     }
-    return false;
+    return false
   }
 
   /**
@@ -1838,81 +1812,80 @@ export class AddonRegistryService {
     return !!(
       entry.declaration &&
       entry.addonDir &&
-      entry.packageName !== "@camstack/core" &&
+      entry.packageName !== '@camstack/core' &&
       resolveAddonPlacement(entry.declaration) !== 'agent-only'
-    );
+    )
   }
 
   /** Per-entry helper used by `listAddons()` to mark a row removable / not. */
   private isRequiredEntry(entry: AddonEntry): boolean {
-    if (entry.declaration?.protected === true) return true;
+    if (entry.declaration?.protected === true) return true
     // Fall back to a sibling addon in the same package — the
     // protected-by-association rule above. Catches the case where the
     // SAME package ships an aggregator addon (protected: true) plus
     // a source addon (protected: false): both rows should render
     // as non-removable because uninstalling the package would tear
     // out both.
-    return this.isPackageProtected(entry.packageName);
+    return this.isPackageProtected(entry.packageName)
   }
 
   listAddons(): Array<{
     manifest: AddonDeclaration & {
-      packageName: string;
-      packageVersion: string;
-      packageDisplayName?: string;
-      bundle?: { displayName: string; description?: string; icon?: string };
-      protected?: boolean;
-      removable?: boolean;
-    };
-    declaration?: AddonDeclaration;
-    source: AddonSource;
-    installSource?: "npm" | "local" | "upload";
-    process?: { pid?: number; mode: "in-process"; state: string };
+      packageName: string
+      packageVersion: string
+      packageDisplayName?: string
+      bundle?: { displayName: string; description?: string; icon?: string }
+      protected?: boolean
+      removable?: boolean
+    }
+    declaration?: AddonDeclaration
+    source: AddonSource
+    installSource?: 'npm' | 'local' | 'upload'
+    process?: { pid?: number; mode: 'in-process'; state: string }
   }> {
     // Build process info map from in-memory data (sync, no stats)
-    const processMap = new Map<
-      string,
-      { pid?: number; mode: "in-process"; state: string }
-    >();
+    const processMap = new Map<string, { pid?: number; mode: 'in-process'; state: string }>()
     for (const [id, entry] of this.addonEntries) {
       if (entry.initialized) {
         processMap.set(`addon:${id}`, {
           pid: process.pid,
-          mode: "in-process",
-          state: "running",
-        });
+          mode: 'in-process',
+          state: 'running',
+        })
       }
     }
 
     const live = Array.from(this.addonEntries.values())
       .filter((entry) => entry.addon?.manifest?.id)
       .map((entry) => {
-        let installSource: "npm" | "local" | "upload" | undefined;
+        let installSource: 'npm' | 'local' | 'upload' | undefined
         if (entry.addonDir) {
           try {
-            const markerPath = path.join(entry.addonDir, ".install-source");
+            const markerPath = path.join(entry.addonDir, '.install-source')
             if (fs.existsSync(markerPath)) {
-              const raw = fs.readFileSync(markerPath, "utf-8").trim();
+              const raw = fs.readFileSync(markerPath, 'utf-8').trim()
               // Normalize legacy 'workspace' → 'local'
-              const normalized = raw === "workspace" ? "local" : raw;
-              if (
-                normalized === "npm" ||
-                normalized === "local" ||
-                normalized === "upload"
-              ) {
-                installSource = normalized;
+              const normalized = raw === 'workspace' ? 'local' : raw
+              if (normalized === 'npm' || normalized === 'local' || normalized === 'upload') {
+                installSource = normalized
               }
             }
           } catch (err) {
-            this.logger.debug(
-              'Failed to read install-source marker for addon',
-              { meta: { error: errMsg(err) } },
-            );
+            this.logger.debug('Failed to read install-source marker for addon', {
+              meta: { error: errMsg(err) },
+            })
           }
         }
         return {
           manifest: {
-            ...entry.addon.manifest!,
+            // Overlay the fresh on-disk declaration (refreshed by
+            // `loadNewAddons` on every `camstack deploy`) onto the live
+            // instance manifest, so a redeployed addon's new capabilities /
+            // brokerKind surface here without a full backend restart. See
+            // `overlayDeclaration` — this is what keeps Home Assistant
+            // (post broker rework: broker + device-adoption) visible in the
+            // "+ New Integration" picker.
+            ...overlayDeclaration(entry.addon.manifest!, entry.declaration),
             packageName: entry.packageName,
             packageVersion: entry.packageVersion,
             packageDisplayName: entry.packageDisplayName,
@@ -1924,17 +1897,17 @@ export class AddonRegistryService {
           source: entry.source,
           installSource,
           process: processMap.get(`addon:${entry.addon.manifest!.id}`),
-        };
-      });
+        }
+      })
 
     // Surface packages that exist on disk but failed to load — typical
     // causes are dep-version mismatch, missing native binary, or a
     // corrupted dist. Without this, an operator sees "installed" via
     // the package manifest but can't find the row in the addons UI to
     // diagnose or uninstall, leaving the package stranded.
-    const seenPackages = new Set(live.map((row) => row.manifest.packageName));
-    const failed = this.scanFailedToLoadPackages(seenPackages);
-    return [...live, ...failed];
+    const seenPackages = new Set(live.map((row) => row.manifest.packageName))
+    const failed = this.scanFailedToLoadPackages(seenPackages)
+    return [...live, ...failed]
   }
 
   /**
@@ -1944,74 +1917,84 @@ export class AddonRegistryService {
    * carry a `process.state: 'failed'` flag so the AddonCard can render
    * the diagnostic state distinctly from a normal addon.
    */
-  private scanFailedToLoadPackages(
-    seenPackages: ReadonlySet<string>,
-  ): Array<{
+  private scanFailedToLoadPackages(seenPackages: ReadonlySet<string>): Array<{
     manifest: AddonDeclaration & {
-      packageName: string;
-      packageVersion: string;
-      packageDisplayName?: string;
-      protected?: boolean;
-      removable?: boolean;
-    };
-    declaration?: AddonDeclaration;
-    source: AddonSource;
-    installSource?: "npm" | "local" | "upload";
-    process?: { pid?: number; mode: "in-process"; state: string };
+      packageName: string
+      packageVersion: string
+      packageDisplayName?: string
+      protected?: boolean
+      removable?: boolean
+    }
+    declaration?: AddonDeclaration
+    source: AddonSource
+    installSource?: 'npm' | 'local' | 'upload'
+    process?: { pid?: number; mode: 'in-process'; state: string }
   }> {
-    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? "camstack-data");
-    const addonsDir = path.resolve(dataDir, "addons");
-    if (!fs.existsSync(addonsDir)) return [];
-
-    type Row = ReturnType<AddonRegistryService["scanFailedToLoadPackages"]> extends Array<infer R> ? R : never;
-    const out: Row[] = [];
+    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? 'camstack-data')
+    const addonsDir = path.resolve(dataDir, 'addons')
+    if (!fs.existsSync(addonsDir)) return []
+
+    type Row =
+      ReturnType<AddonRegistryService['scanFailedToLoadPackages']> extends Array<infer R>
+        ? R
+        : never
+    const out: Row[] = []
     const visit = (pkgDir: string): void => {
-      const pkgJsonPath = path.join(pkgDir, "package.json");
-      if (!fs.existsSync(pkgJsonPath)) return;
-      let pkg: Record<string, unknown>;
+      const pkgJsonPath = path.join(pkgDir, 'package.json')
+      if (!fs.existsSync(pkgJsonPath)) return
+      let pkg: Record<string, unknown>
       try {
-        pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8")) as Record<string, unknown>;
+        pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8')) as Record<string, unknown>
       } catch {
-        return;
+        return
       }
-      const packageName = typeof pkg["name"] === "string" ? pkg["name"] : "";
-      const packageVersion = typeof pkg["version"] === "string" ? pkg["version"] : "0.0.0";
-      if (!packageName || seenPackages.has(packageName)) return;
-      const camstack = (pkg["camstack"] as { addons?: unknown[] } | undefined) ?? {};
-      const addons = Array.isArray(camstack.addons) ? camstack.addons as Record<string, unknown>[] : [];
-      if (addons.length === 0) return;
-
-      let installSource: "npm" | "local" | "upload" | undefined;
+      const packageName = typeof pkg['name'] === 'string' ? pkg['name'] : ''
+      const packageVersion = typeof pkg['version'] === 'string' ? pkg['version'] : '0.0.0'
+      if (!packageName || seenPackages.has(packageName)) return
+      const camstack = (pkg['camstack'] as { addons?: unknown[] } | undefined) ?? {}
+      const addons = Array.isArray(camstack.addons)
+        ? (camstack.addons as Record<string, unknown>[])
+        : []
+      if (addons.length === 0) return
+
+      let installSource: 'npm' | 'local' | 'upload' | undefined
       try {
-        const markerPath = path.join(pkgDir, ".install-source");
+        const markerPath = path.join(pkgDir, '.install-source')
         if (fs.existsSync(markerPath)) {
-          const raw = fs.readFileSync(markerPath, "utf-8").trim();
-          const normalized = raw === "workspace" ? "local" : raw;
-          if (normalized === "npm" || normalized === "local" || normalized === "upload") {
-            installSource = normalized;
+          const raw = fs.readFileSync(markerPath, 'utf-8').trim()
+          const normalized = raw === 'workspace' ? 'local' : raw
+          if (normalized === 'npm' || normalized === 'local' || normalized === 'upload') {
+            installSource = normalized
           }
         }
-      } catch { /* non-critical */ }
+      } catch {
+        /* non-critical */
+      }
 
       // Manifest-driven protection — agree with the live-rows path.
-      const isProtected = addons.some((a) => a["protected"] === true);
-      const packageDisplayName = (camstack as { displayName?: string }).displayName;
+      const isProtected = addons.some((a) => a['protected'] === true)
+      const packageDisplayName = (camstack as { displayName?: string }).displayName
       // Bundle metadata — present when the package ships multiple addon
       // entries that should render as collapsible children in the UI.
-      const bundleRaw = (camstack as { bundle?: { displayName?: string; description?: string; icon?: string } }).bundle;
-      const bundle = bundleRaw && typeof bundleRaw.displayName === 'string'
-        ? {
-            displayName: bundleRaw.displayName,
-            ...(bundleRaw.description !== undefined ? { description: bundleRaw.description } : {}),
-            ...(bundleRaw.icon !== undefined ? { icon: bundleRaw.icon } : {}),
-          }
-        : undefined;
+      const bundleRaw = (
+        camstack as { bundle?: { displayName?: string; description?: string; icon?: string } }
+      ).bundle
+      const bundle =
+        bundleRaw && typeof bundleRaw.displayName === 'string'
+          ? {
+              displayName: bundleRaw.displayName,
+              ...(bundleRaw.description !== undefined
+                ? { description: bundleRaw.description }
+                : {}),
+              ...(bundleRaw.icon !== undefined ? { icon: bundleRaw.icon } : {}),
+            }
+          : undefined
 
       for (const decl of addons) {
-        const id = typeof decl["id"] === "string" ? decl["id"] : "";
-        const name = typeof decl["name"] === "string" ? decl["name"] : id;
-        if (!id) continue;
-        const manifest: Row["manifest"] = {
+        const id = typeof decl['id'] === 'string' ? decl['id'] : ''
+        const name = typeof decl['name'] === 'string' ? decl['name'] : id
+        if (!id) continue
+        const manifest: Row['manifest'] = {
           ...(decl as unknown as AddonDeclaration),
           id,
           name,
@@ -2021,34 +2004,34 @@ export class AddonRegistryService {
           ...(bundle !== undefined ? { bundle } : {}),
           protected: isProtected || undefined,
           removable: !isProtected,
-        };
+        }
         out.push({
           manifest,
           declaration: decl as unknown as AddonDeclaration,
-          source: "installed" as AddonSource,
+          source: 'installed' as AddonSource,
           ...(installSource ? { installSource } : {}),
-          process: { mode: "in-process" as const, state: "failed" },
-        });
+          process: { mode: 'in-process' as const, state: 'failed' },
+        })
       }
-    };
+    }
 
-    const entries = fs.readdirSync(addonsDir, { withFileTypes: true });
+    const entries = fs.readdirSync(addonsDir, { withFileTypes: true })
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dirName = entry.name;
-      if (dirName === "node_modules" || dirName.startsWith(".")) continue;
-      const fullPath = path.join(addonsDir, dirName);
+      if (!entry.isDirectory()) continue
+      const dirName = entry.name
+      if (dirName === 'node_modules' || dirName.startsWith('.')) continue
+      const fullPath = path.join(addonsDir, dirName)
       // Scoped: walk one level deeper.
-      if (dirName.startsWith("@")) {
-        const scopedEntries = fs.readdirSync(fullPath, { withFileTypes: true });
+      if (dirName.startsWith('@')) {
+        const scopedEntries = fs.readdirSync(fullPath, { withFileTypes: true })
         for (const sub of scopedEntries) {
-          if (sub.isDirectory()) visit(path.join(fullPath, sub.name));
+          if (sub.isDirectory()) visit(path.join(fullPath, sub.name))
         }
       } else {
-        visit(fullPath);
+        visit(fullPath)
       }
     }
-    return out;
+    return out
   }
 
   /**
@@ -2057,7 +2040,7 @@ export class AddonRegistryService {
    * so the frontend can group by package automatically.
    */
   listAllAddons() {
-    return this.listAddons();
+    return this.listAddons()
   }
 
   /**
@@ -2066,49 +2049,49 @@ export class AddonRegistryService {
    */
   async listAddonProcesses(): Promise<
     ReadonlyArray<{
-      id: string;
-      label: string;
-      state: "running" | "stopped" | "crashed" | "starting";
-      pid?: number;
+      id: string
+      label: string
+      state: 'running' | 'stopped' | 'crashed' | 'starting'
+      pid?: number
       stats?: {
-        pid: number;
-        cpu: number;
-        memory: number;
-        uptime: number;
-        restartCount: number;
-      };
-      restartCount: number;
-      mode: "in-process";
+        pid: number
+        cpu: number
+        memory: number
+        uptime: number
+        restartCount: number
+      }
+      restartCount: number
+      mode: 'in-process'
     }>
   > {
     const result: Array<{
-      id: string;
-      label: string;
-      state: "running" | "stopped" | "crashed" | "starting";
-      pid?: number;
+      id: string
+      label: string
+      state: 'running' | 'stopped' | 'crashed' | 'starting'
+      pid?: number
       stats?: {
-        pid: number;
-        cpu: number;
-        memory: number;
-        uptime: number;
-        restartCount: number;
-      };
-      restartCount: number;
-      mode: "in-process";
-    }> = [];
+        pid: number
+        cpu: number
+        memory: number
+        uptime: number
+        restartCount: number
+      }
+      restartCount: number
+      mode: 'in-process'
+    }> = []
 
     // Collect hub PID and fetch stats
-    const { getPidStats } = await import("@camstack/core");
-    const pidStats = await getPidStats([process.pid]);
+    const { getPidStats } = await import('@camstack/core')
+    const pidStats = await getPidStats([process.pid])
 
     // In-process addons
-    const hubStats = pidStats.get(process.pid);
+    const hubStats = pidStats.get(process.pid)
     for (const [id, entry] of this.addonEntries) {
       if (entry.initialized) {
         result.push({
           id: `addon:${id}`,
           label: `Addon: ${id} (in-process)`,
-          state: "running",
+          state: 'running',
           pid: process.pid,
           stats: {
             pid: process.pid,
@@ -2118,12 +2101,12 @@ export class AddonRegistryService {
             restartCount: 0,
           },
           restartCount: 0,
-          mode: "in-process",
-        });
+          mode: 'in-process',
+        })
       }
     }
 
-    return result;
+    return result
   }
 
   /**
@@ -2142,17 +2125,15 @@ export class AddonRegistryService {
    * Called after install/uninstall to hot-load new addons without server restart.
    */
   async loadNewAddons(): Promise<{ loaded: string[]; failed: string[] }> {
-    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? "camstack-data");
-    const addonsDir = path.resolve(dataDir, "addons");
+    const dataDir = path.resolve(process.env.CAMSTACK_DATA ?? 'camstack-data')
+    const addonsDir = path.resolve(dataDir, 'addons')
 
     // Create a fresh loader to discover what's on disk (for diffing against existing)
-    const freshLoader = new AddonLoader(
-      this.loggingService.createLogger("AddonLoader"),
-    );
-    await freshLoader.loadFromDirectory(addonsDir);
+    const freshLoader = new AddonLoader(this.loggingService.createLogger('AddonLoader'))
+    await freshLoader.loadFromDirectory(addonsDir)
 
-    const loaded: string[] = [];
-    const failed: string[] = [];
+    const loaded: string[] = []
+    const failed: string[] = []
 
     for (const registered of freshLoader.listAddons()) {
       // Already-registered addon: refresh the in-memory metadata (the
@@ -2164,20 +2145,20 @@ export class AddonRegistryService {
       // showing the OLD version. We deliberately keep `entry.addon`
       // (the running instance) and `entry.initialized` untouched so
       // `restartAddon` still shuts the live instance down cleanly.
-      const existing = this.addonEntries.get(registered.declaration.id);
+      const existing = this.addonEntries.get(registered.declaration.id)
       if (existing) {
-        existing.packageVersion = registered.packageVersion;
-        existing.packageName = registered.packageName;
-        existing.packageDisplayName = registered.packageDisplayName;
+        existing.packageVersion = registered.packageVersion
+        existing.packageName = registered.packageName
+        existing.packageDisplayName = registered.packageDisplayName
         if (registered.bundle !== undefined) {
-          existing.bundle = registered.bundle;
+          existing.bundle = registered.bundle
         }
-        existing.declaration = registered.declaration;
+        existing.declaration = registered.declaration
         existing.declaredCapabilities = (registered.declaration.capabilities ?? []).map(
           (c: string | CapabilityDeclaration) =>
-            typeof c === "string" ? { name: c, mode: "singleton" as const } : c,
-        );
-        continue;
+            typeof c === 'string' ? { name: c, mode: 'singleton' as const } : c,
+        )
+        continue
       }
 
       // Skip agent-only addons on the hub. Same rule as the boot loader
@@ -2186,33 +2167,29 @@ export class AddonRegistryService {
       // and a hub-resident `hub-forwarder` creates a write→ingest→
       // write feedback loop because the hub IS the log-receiver.
       if (isAgentOnlyPlacement(registered.declaration)) {
-        this.logger.debug(
-          'loadNewAddons: skipping agent-only addon on hub',
-          { tags: { addonId: registered.declaration.id } },
-        );
-        continue;
+        this.logger.debug('loadNewAddons: skipping agent-only addon on hub', {
+          tags: { addonId: registered.declaration.id },
+        })
+        continue
       }
 
       if (registered.declaration.capabilities) {
         for (const cap of registered.declaration.capabilities) {
-          this.capabilityRegistry.declareFromManifest(
-            cap,
-            registered.declaration.id,
-          );
+          this.capabilityRegistry.declareFromManifest(cap, registered.declaration.id)
         }
       }
 
       try {
-        const addon = freshLoader.createInstance(registered.declaration.id);
+        const addon = freshLoader.createInstance(registered.declaration.id)
         const declCaps = (registered.declaration.capabilities ?? []).map(
           (c: string | CapabilityDeclaration) =>
-            typeof c === "string" ? { name: c, mode: "singleton" as const } : c,
-        );
+            typeof c === 'string' ? { name: c, mode: 'singleton' as const } : c,
+        )
 
         this.addonEntries.set(registered.declaration.id, {
           addon,
           initialized: false,
-          source: "installed",
+          source: 'installed',
           packageName: registered.packageName,
           packageVersion: registered.packageVersion,
           packageDisplayName: registered.packageDisplayName,
@@ -2220,36 +2197,26 @@ export class AddonRegistryService {
           declaredCapabilities: declCaps,
           addonDir: path.join(addonsDir, registered.packageName),
           declaration: registered.declaration,
-        });
+        })
 
         // Initialize the new addon
-        await this.initializeAddon(registered.declaration.id);
-        this.wireCapabilities(registered.declaration.id);
-        loaded.push(registered.declaration.id);
-        this.logger.info(
-          'Hot-loaded addon',
-          { tags: { addonId: registered.declaration.id }, meta: { packageName: registered.packageName } },
-        );
-        this.emitAddonLifecycleEvent(
-          "addon.installed",
-          registered.declaration.id,
-        );
+        await this.initializeAddon(registered.declaration.id)
+        this.wireCapabilities(registered.declaration.id)
+        loaded.push(registered.declaration.id)
+        this.logger.info('Hot-loaded addon', {
+          tags: { addonId: registered.declaration.id },
+          meta: { packageName: registered.packageName },
+        })
+        this.emitAddonLifecycleEvent('addon.installed', registered.declaration.id)
       } catch (err) {
-        const msg = errMsg(err);
-        const stack = err instanceof Error ? err.stack : undefined;
-        this.logger.error(
-          'Failed to hot-load addon',
-          {
-            tags: { addonId: registered.declaration.id },
-            meta: stack ? { error: msg, stack } : { error: msg },
-          },
-        );
-        this.emitAddonLifecycleEvent(
-          "addon.crashed",
-          registered.declaration.id,
-          { error: msg },
-        );
-        failed.push(registered.declaration.id);
+        const msg = errMsg(err)
+        const stack = err instanceof Error ? err.stack : undefined
+        this.logger.error('Failed to hot-load addon', {
+          tags: { addonId: registered.declaration.id },
+          meta: stack ? { error: msg, stack } : { error: msg },
+        })
+        this.emitAddonLifecycleEvent('addon.crashed', registered.declaration.id, { error: msg })
+        failed.push(registered.declaration.id)
       }
     }
 
@@ -2260,23 +2227,21 @@ export class AddonRegistryService {
     // Only `@camstack/core` builtins — which have no runner — take the
     // in-process `shutdown()` + disposer-drain path.
     const onDiskIds = new Set(
-      freshLoader
-        .listAddons()
-        .map((a: { declaration: { id: string } }) => a.declaration.id),
-    );
+      freshLoader.listAddons().map((a: { declaration: { id: string } }) => a.declaration.id),
+    )
     for (const [id, entry] of this.addonEntries) {
-      if (entry.source === "installed" && !onDiskIds.has(id)) {
+      if (entry.source === 'installed' && !onDiskIds.has(id)) {
         // Unregister capabilities before stopping the addon.
         for (const cap of entry.declaredCapabilities) {
-          this.capabilityRegistry.unregisterProvider(cap.name, id);
+          this.capabilityRegistry.unregisterProvider(cap.name, id)
         }
-        const manifestCaps = this.getAddonCapabilities(entry.addon);
+        const manifestCaps = this.getAddonCapabilities(entry.addon)
         for (const cap of manifestCaps) {
-          this.capabilityRegistry.unregisterProvider(cap.name, id);
+          this.capabilityRegistry.unregisterProvider(cap.name, id)
         }
-        this.capabilityRegistry.unregisterAllWrappersForAddon(id);
+        this.capabilityRegistry.unregisterAllWrappersForAddon(id)
         // Task 7.1: drop custom actions for removed addons.
-        this.customActionRegistry.unregisterAddon(id);
+        this.customActionRegistry.unregisterAddon(id)
 
         if (this.isForkedAddonEntry(entry) && entry.initialized) {
           // Forked addon — stop the runner subprocess. `$process.stop`
@@ -2284,46 +2249,46 @@ export class AddonRegistryService {
           // hub's cap registry drops the gone provider with no per-
           // operation hub bookkeeping.
           try {
-            await this.broker.call("$process.stop", { name: id });
+            await this.broker.call('$process.stop', { name: id })
           } catch (err) {
-            this.logger.warn(
-              'Non-fatal: failed to stop runner for removed addon',
-              { tags: { addonId: id }, meta: { error: errMsg(err) } },
-            );
+            this.logger.warn('Non-fatal: failed to stop runner for removed addon', {
+              tags: { addonId: id },
+              meta: { error: errMsg(err) },
+            })
           }
         } else if (entry.initialized) {
           // `@camstack/core` builtin — reload model is in-process.
           try {
-            await entry.addon.shutdown();
+            await entry.addon.shutdown()
           } catch (err) {
-            this.logger.debug(
-              'Non-fatal: shutdown error for removed addon',
-              { tags: { addonId: id }, meta: { error: errMsg(err) } },
-            );
+            this.logger.debug('Non-fatal: shutdown error for removed addon', {
+              tags: { addonId: id },
+              meta: { error: errMsg(err) },
+            })
           }
-          await this.drainDisposerChain(id);
+          await this.drainDisposerChain(id)
         }
-        this.addonEntries.delete(id);
-        this.logger.info('Removed addon (no longer on disk)', { tags: { addonId: id } });
+        this.addonEntries.delete(id)
+        this.logger.info('Removed addon (no longer on disk)', { tags: { addonId: id } })
       }
     }
 
-    return { loaded, failed };
+    return { loaded, failed }
   }
 
   async shutdownAll(): Promise<void> {
     for (const [id, entry] of this.addonEntries) {
       if (entry.initialized) {
-        const capabilities = this.getAddonCapabilities(entry.addon);
+        const capabilities = this.getAddonCapabilities(entry.addon)
         for (const cap of capabilities) {
-          this.capabilityRegistry.unregisterProvider(cap.name, id);
+          this.capabilityRegistry.unregisterProvider(cap.name, id)
         }
-        this.capabilityRegistry.unregisterAllWrappersForAddon(id);
+        this.capabilityRegistry.unregisterAllWrappersForAddon(id)
         // Task 7.1: drop custom actions on full shutdown.
-        this.customActionRegistry.unregisterAddon(id);
-        await entry.addon.shutdown();
-        await this.drainDisposerChain(id);
-        entry.initialized = false;
+        this.customActionRegistry.unregisterAddon(id)
+        await entry.addon.shutdown()
+        await this.drainDisposerChain(id)
+        entry.initialized = false
       }
     }
   }
@@ -2340,120 +2305,120 @@ export class AddonRegistryService {
    * Replaces the 11 registerConsumer callbacks from v1.
    */
   private wireCapabilityConsumers(): void {
-    if (!this.capabilityRegistry) return;
-
-    this.eventBusService.subscribe(
-      { category: "capability:provider-registered" },
-      (event) => {
-        const rawCapability = event.data["capability"];
-        const rawAddonId = event.data["addonId"];
-        if (typeof rawCapability !== "string" || typeof rawAddonId !== "string")
-          return;
-        const capability = rawCapability;
-        const addonId = rawAddonId;
-
-        // Broadcast readiness on the hub-node scope so subprocess
-        // brokers waiting on this cap (e.g. provider-rtsp's
-        // `system.ready-state` listener for stream-broker, or
-        // `runWorkerDeviceRestoreWithRetry` waiting on
-        // device-manager) wake up. We emit ONLY `{ type: 'node',
-        // nodeId: 'hub' }` — most consumer filters are scope-agnostic
-        // (they match on capName + state), so emitting both `node` and
-        // `global` causes duplicate fan-out (e.g. provider-rtsp's
-        // `republishAll` running twice → repeated `dispatchCamera`
-        // loops). The node-scoped emit is sufficient: the hydrate
-        // path on subprocess brokers replays whichever records the
-        // hub's `$readiness.getSnapshot` returns, scope and all.
-        try {
-          this.moleculer.readinessRegistry.emitReady(capability, { type: 'node', nodeId: 'hub' });
-        } catch (err) {
-          this.logger.warn('emitReady failed', {
-            meta: { capability, addonId, error: errMsg(err) },
-          });
-        }
+    if (!this.capabilityRegistry) return
+
+    this.eventBusService.subscribe({ category: 'capability:provider-registered' }, (event) => {
+      const rawCapability = event.data['capability']
+      const rawAddonId = event.data['addonId']
+      if (typeof rawCapability !== 'string' || typeof rawAddonId !== 'string') return
+      const capability = rawCapability
+      const addonId = rawAddonId
+
+      // Broadcast readiness on the hub-node scope so subprocess
+      // brokers waiting on this cap (e.g. provider-rtsp's
+      // `system.ready-state` listener for stream-broker, or
+      // `runWorkerDeviceRestoreWithRetry` waiting on
+      // device-manager) wake up. We emit ONLY `{ type: 'node',
+      // nodeId: 'hub' }` — most consumer filters are scope-agnostic
+      // (they match on capName + state), so emitting both `node` and
+      // `global` causes duplicate fan-out (e.g. provider-rtsp's
+      // `republishAll` running twice → repeated `dispatchCamera`
+      // loops). The node-scoped emit is sufficient: the hydrate
+      // path on subprocess brokers replays whichever records the
+      // hub's `$readiness.getSnapshot` returns, scope and all.
+      try {
+        this.moleculer.readinessRegistry.emitReady(capability, { type: 'node', nodeId: 'hub' })
+      } catch (err) {
+        this.logger.warn('emitReady failed', {
+          meta: { capability, addonId, error: errMsg(err) },
+        })
+      }
 
-        switch (capability) {
-          case "storage": {
-            // Storage-unification refactor (Task 8) — the consumer-
-            // facing `storage` cap is now a singleton owned by the
-            // `storage-orchestrator` builtin, exposing the codegen'd
-            // async `IStorageCapProvider` surface. The legacy
-            // synchronous `INewStorageProvider` (filesystem-only) used
-            // by `StorageService.setNewStorageProvider` and the
-            // `addons-data` dataDir resolution at boot is no longer
-            // wired here — filesystem-storage now registers under
-            // `storage-provider` (the upstream collection cap), and
-            // legacy callers fall back to the deterministic
-            // `camstack-data/addons-data/<addonId>` path. Task 17 will
-            // migrate those callers off `INewStorageProvider`
-            // entirely.
-            break;
-          }
+      switch (capability) {
+        case 'storage': {
+          // Storage-unification refactor (Task 8) — the consumer-
+          // facing `storage` cap is now a singleton owned by the
+          // `storage-orchestrator` builtin, exposing the codegen'd
+          // async `IStorageCapProvider` surface. The legacy
+          // synchronous `INewStorageProvider` (filesystem-only) used
+          // by `StorageService.setNewStorageProvider` and the
+          // `addons-data` dataDir resolution at boot is no longer
+          // wired here — filesystem-storage now registers under
+          // `storage-provider` (the upstream collection cap), and
+          // legacy callers fall back to the deterministic
+          // `camstack-data/addons-data/<addonId>` path. Task 17 will
+          // migrate those callers off `INewStorageProvider`
+          // entirely.
+          break
+        }
 
-          case "settings-store": {
-            const provider = this.capabilityRegistry.getProviderByAddon(
-              "settings-store",
-              addonId,
-            );
-            if (!provider) return;
-            this.activeSettingsBackend = provider;
-            if (isSettingsStore(provider)) {
-              this.configService.setSettingsStore(provider);
-            }
-            this.storageService.setSettingsBackend(provider);
-            this.integrationRegistry = new IntegrationRegistry(provider);
-            void this.integrationRegistry.initialize().then(() => {
-              this.logger.info("IntegrationRegistry initialized", { meta: { phase: 'v2' } });
-            });
-            this.loadCollectionPreferences();
-            // DeviceStore/ConfigStore are owned by the `device-persistence`
-            // capability addon — no longer created here. The addon boots
-            // after `sqlite-settings` and extracts the DB handle via the
-            // capability registry.
-            this.logger.info("Settings backend wired", { meta: { phase: 'v2' } });
-            break;
+        case 'settings-store': {
+          const provider = this.capabilityRegistry.getProviderByAddon('settings-store', addonId)
+          if (!provider) return
+          this.activeSettingsBackend = provider
+          if (isSettingsStore(provider)) {
+            this.configService.setSettingsStore(provider)
           }
+          this.storageService.setSettingsBackend(provider)
+          this.integrationRegistry = new IntegrationRegistry(provider)
+          void this.integrationRegistry.initialize().then(() => {
+            this.logger.info('IntegrationRegistry initialized', { meta: { phase: 'v2' } })
+          })
+          this.loadCollectionPreferences()
+          // DeviceStore/ConfigStore are owned by the `device-persistence`
+          // capability addon — no longer created here. The addon boots
+          // after `sqlite-settings` and extracts the DB handle via the
+          // capability registry.
+          this.logger.info('Settings backend wired', { meta: { phase: 'v2' } })
+          break
+        }
 
-          case "log-destination": {
-            const provider = this.capabilityRegistry.getProviderByAddon(
-              "log-destination",
-              addonId,
-            );
-            if (!provider) return;
-            this.loggingService.addDestination(provider);
-            this.logger.info("Log destination added", { meta: { phase: 'v2' } });
-            break;
-          }
+        case 'log-destination': {
+          const provider = this.capabilityRegistry.getProviderByAddon('log-destination', addonId)
+          if (!provider) return
+          this.loggingService.addDestination(provider)
+          this.logger.info('Log destination added', { meta: { phase: 'v2' } })
+          break
+        }
 
-          case "restreamer":
-          case "webrtc":
-          case "decoder":
-          case "stream-broker":
-            // No wiring needed — consumers read from capabilityRegistry on demand.
-            break;
-
-          case "addon-routes": {
-            // Route mounting is async for forked/group addons — the
-            // provider is a Moleculer proxy whose `getRoutes()` returns
-            // a Promise (the wire round-trips through the worker). The
-            // EventBus subscriber callback is synchronous, so delegate
-            // to an async helper and surface any failure via the
-            // logger instead of letting a rejected promise (or a
-            // `liveRoutes.some is not a function` TypeError) escape the
-            // subscriber unobserved.
-            void this.mountAddonRoutes(addonId).catch((err: unknown) => {
-              this.logger.error('Failed to mount addon routes', {
-                meta: { phase: 'v2', addonId, error: errMsg(err) },
-              })
+        case 'restreamer':
+        case 'webrtc':
+        case 'decoder':
+        case 'stream-broker':
+          // No wiring needed — consumers read from capabilityRegistry on demand.
+          break
+
+        case 'addon-routes': {
+          // Route mounting is async for forked/group addons — the
+          // provider is a Moleculer proxy whose `getRoutes()` returns
+          // a Promise (the wire round-trips through the worker). The
+          // EventBus subscriber callback is synchronous, so delegate
+          // to an async helper and surface any failure via the
+          // logger instead of letting a rejected promise (or a
+          // `liveRoutes.some is not a function` TypeError) escape the
+          // subscriber unobserved.
+          void this.mountAddonRoutes(addonId).catch((err: unknown) => {
+            this.logger.error('Failed to mount addon routes', {
+              meta: { phase: 'v2', addonId, error: errMsg(err) },
             })
-            break;
-          }
-
-          default:
-            break;
+          })
+          break
         }
-      },
-    );
+
+        default:
+          break
+      }
+
+      // HTTP data-planes aren't capabilities, so no `case` fires for them —
+      // pull them off ANY cap-changed signal for this (forked) addon. Cheap +
+      // idempotent (replace-all), and re-pulls the fresh baseUrl/secret after a
+      // restart (the child re-handshakes → caps re-register → this re-fires).
+      void this.mountAddonDataPlanes(addonId).catch((err: unknown) => {
+        this.logger.error('Failed to mount addon data-planes', {
+          meta: { phase: 'v2', addonId, error: errMsg(err) },
+        })
+      })
+    })
   }
 
   /**
@@ -2475,13 +2440,10 @@ export class AddonRegistryService {
    *   directly.
    */
   private async mountAddonRoutes(addonId: string): Promise<void> {
-    if (!this.capabilityRegistry || !this.addonRouteRegistry) return;
-    const addonRouteRegistry = this.addonRouteRegistry;
-    const routeProvider = this.capabilityRegistry.getProviderByAddon(
-      "addon-routes",
-      addonId,
-    );
-    if (!routeProvider) return;
+    if (!this.capabilityRegistry || !this.addonRouteRegistry) return
+    const addonRouteRegistry = this.addonRouteRegistry
+    const routeProvider = this.capabilityRegistry.getProviderByAddon('addon-routes', addonId)
+    if (!routeProvider) return
 
     // ── Forked addon: fetch handler-stripped routes over UDS (F3) ──────
     // EVERY non-`@camstack/core` addon forks (the fork authority is
@@ -2503,29 +2465,29 @@ export class AddonRegistryService {
     // long as the child is connected, and the child is added to the UDS
     // registry BEFORE its manifest fires the cap-changed event that triggers
     // this mount, so the gate is satisfied on the happy path.
-    const entry = this.addonEntries.get(addonId);
-    const childRegistry = this.moleculer.childRegistry;
+    const entry = this.addonEntries.get(addonId)
+    const childRegistry = this.moleculer.childRegistry
     if (entry && this.isForkedAddonEntry(entry)) {
       if (childRegistry !== null && childRegistry.isChildKnown(addonId)) {
-        await this.mountForkedAddonRoutes(addonId, routeProvider, addonRouteRegistry);
-        return;
+        await this.mountForkedAddonRoutes(addonId, routeProvider, addonRouteRegistry)
+        return
       }
       // Child not yet connected over UDS: defer rather than register the async
       // proxy directly (which would crash on `.map`). The `addon-routes`
       // cap-changed event re-fires once the child finishes its handshake.
       this.logger.warn('Deferring forked addon route mount — child not yet UDS-reachable', {
         meta: { phase: 'v2', addonId },
-      });
-      return;
+      })
+      return
     }
 
     // ── Co-located addon (`@camstack/core` builtin): live handlers, register
     // the provider directly. The route handlers run in-process against the
     // real Fastify reply, so no wire bridge is needed.
-    addonRouteRegistry.registerRoutes(routeProvider.id, routeProvider);
+    addonRouteRegistry.registerRoutes(routeProvider.id, routeProvider)
     this.logger.info('Addon routes mounted', {
       meta: { phase: 'v2', routeProviderId: routeProvider.id },
-    });
+    })
   }
 
   /**
@@ -2554,51 +2516,49 @@ export class AddonRegistryService {
       this.logger.warn(
         'Forked addon-routes provider missing `invoke` method — routes will not dispatch. Use `buildAddonRouteProvider()` from @camstack/types.',
         { meta: { phase: 'v2', routeProviderId: routeProvider.id } },
-      );
-      return;
+      )
+      return
     }
-    const invoker = routeProvider;
+    const invoker = routeProvider
 
     const rawRoutes = await this.addonCallGateway.callForked(addonId, {
       target: 'routes',
-    });
-    const descriptors = parseSerializableRouteDescriptors(rawRoutes);
-    const bridgeRoutes: import('@camstack/types').IAddonHttpRoute[] = descriptors.map(
-      (route) => ({
-        method: route.method,
-        path: route.path,
-        access: route.access,
-        ...(route.description !== undefined ? { description: route.description } : {}),
-        handler: async (req, reply) => {
-          const envelope = await invoker.invoke({
-            method: route.method,
-            path: route.path,
-            params: req.params,
-            query: req.query,
-            body: req.body,
-            headers: req.headers,
-            ...(req.user ? { user: req.user } : {}),
-            ...(req.scopedToken !== undefined ? { scopedToken: req.scopedToken } : {}),
-          });
-          reply.code(envelope.status);
-          if (envelope.contentType) reply.type(envelope.contentType);
-          for (const [k, v] of Object.entries(envelope.headers)) reply.header(k, v);
-          if (envelope.redirectUrl !== null) {
-            reply.header('Location', envelope.redirectUrl);
-            reply.send('');
-          } else {
-            reply.send(envelope.body);
-          }
-        },
-      }),
-    );
+    })
+    const descriptors = parseSerializableRouteDescriptors(rawRoutes)
+    const bridgeRoutes: import('@camstack/types').IAddonHttpRoute[] = descriptors.map((route) => ({
+      method: route.method,
+      path: route.path,
+      access: route.access,
+      ...(route.description !== undefined ? { description: route.description } : {}),
+      handler: async (req, reply) => {
+        const envelope = await invoker.invoke({
+          method: route.method,
+          path: route.path,
+          params: req.params,
+          query: req.query,
+          body: req.body,
+          headers: req.headers,
+          ...(req.user ? { user: req.user } : {}),
+          ...(req.scopedToken !== undefined ? { scopedToken: req.scopedToken } : {}),
+        })
+        reply.code(envelope.status)
+        if (envelope.contentType) reply.type(envelope.contentType)
+        for (const [k, v] of Object.entries(envelope.headers)) reply.header(k, v)
+        if (envelope.redirectUrl !== null) {
+          reply.header('Location', envelope.redirectUrl)
+          reply.send('')
+        } else {
+          reply.send(envelope.body)
+        }
+      },
+    }))
     addonRouteRegistry.registerRoutes(routeProvider.id, {
       id: routeProvider.id,
       getRoutes: () => bridgeRoutes,
-    });
+    })
     this.logger.info('Addon routes mounted (forked-bridge over UDS)', {
       meta: { phase: 'v2', routeProviderId: routeProvider.id, routes: bridgeRoutes.length },
-    });
+    })
   }
 
   // Cleanup: `addonHasConfigFields` deleted. It was the last reader of
@@ -2610,23 +2570,23 @@ export class AddonRegistryService {
 
   private emitAddonLifecycleEvent(
     eventType:
-      | "addon.started"
-      | "addon.stopped"
-      | "addon.restarted"
-      | "addon.updated"
-      | "addon.installed"
-      | "addon.uninstalled"
-      | "addon.crashed"
-      | "addon.error",
+      | 'addon.started'
+      | 'addon.stopped'
+      | 'addon.restarted'
+      | 'addon.updated'
+      | 'addon.installed'
+      | 'addon.uninstalled'
+      | 'addon.crashed'
+      | 'addon.error',
     addonId: string,
     data?: Record<string, unknown>,
   ): void {
-    const entry = this.addonEntries.get(addonId);
+    const entry = this.addonEntries.get(addonId)
     this.eventBusService.emit({
       id: randomUUID(),
       timestamp: new Date(),
       source: {
-        type: "addon",
+        type: 'addon',
         id: addonId,
         nodeId: this.broker.nodeID,
       },
@@ -2635,10 +2595,10 @@ export class AddonRegistryService {
         addonId,
         packageName: entry?.packageName,
         packageVersion: entry?.packageVersion,
-        agent: process.env.CAMSTACK_AGENT_NAME ?? "hub",
+        agent: process.env.CAMSTACK_AGENT_NAME ?? 'hub',
         ...data,
       },
-    });
+    })
   }
 
   /**
@@ -2646,60 +2606,54 @@ export class AddonRegistryService {
    * Provider registration now happens in initialize() via context.registerProvider().
    */
   private wireCapabilities(addonId: string): void {
-    const entry = this.addonEntries.get(addonId);
-    if (!entry?.initialized) return;
+    const entry = this.addonEntries.get(addonId)
+    if (!entry?.initialized) return
 
     // Emit addon-pages event for UI notification. Cap name is
     // `addon-pages-source` after the consolidation split — collection
     // providers register on the source cap; the singleton aggregator
     // owns `addon-pages` cluster-wide.
-    const declaredCaps = entry.declaredCapabilities.map((c) => c.name);
-    if (declaredCaps.includes("addon-pages-source")) {
+    const declaredCaps = entry.declaredCapabilities.map((c) => c.name)
+    if (declaredCaps.includes('addon-pages-source')) {
       this.eventBusService.emit({
         id: randomUUID(),
         timestamp: new Date(),
-        source: { type: "addon", id: addonId },
+        source: { type: 'addon', id: addonId },
         category: EventCategory.AddonPageReady,
         data: { addonId, packageName: entry.packageName },
-      });
+      })
     }
     // Symmetric for `addon-widgets-source` — addons that contribute
     // widget bundles emit `AddonWidgetReady` so the
     // <WidgetRegistryProvider> in admin-ui invalidates its aggregator
     // query and the new bundle becomes available without a page
     // reload.
-    if (declaredCaps.includes("addon-widgets-source")) {
+    if (declaredCaps.includes('addon-widgets-source')) {
       this.eventBusService.emit({
         id: randomUUID(),
         timestamp: new Date(),
-        source: { type: "addon", id: addonId },
+        source: { type: 'addon', id: addonId },
         category: EventCategory.AddonWidgetReady,
         data: { addonId, packageName: entry.packageName },
-      });
+      })
     }
   }
 
   private getAddonCapabilities(addon: ICamstackAddon): CapabilityDeclaration[] {
-    const caps = addon?.manifest?.capabilities;
-    if (!caps) return [];
+    const caps = addon?.manifest?.capabilities
+    if (!caps) return []
 
-    return caps.map(
-      (cap): CapabilityDeclaration =>
-        typeof cap === "string" ? { name: cap } : cap,
-    );
+    return caps.map((cap): CapabilityDeclaration => (typeof cap === 'string' ? { name: cap } : cap))
   }
 
-  private findAddonForCapability(
-    capName: string,
-    addonIds: string[],
-  ): string | null {
+  private findAddonForCapability(capName: string, addonIds: string[]): string | null {
     for (const id of addonIds) {
-      const entry = this.addonEntries.get(id);
-      if (!entry) continue;
+      const entry = this.addonEntries.get(id)
+      if (!entry) continue
       // Use declaredCapabilities (from package.json) as source of truth
-      if (entry.declaredCapabilities.some((c) => c.name === capName)) return id;
+      if (entry.declaredCapabilities.some((c) => c.name === capName)) return id
     }
-    return null;
+    return null
   }
 
   /**
@@ -2721,14 +2675,14 @@ export class AddonRegistryService {
    */
   private buildAddonConfig(addonId: string): Record<string, unknown> {
     // Start with per-addon SQL settings (may be empty for most addons)
-    let addonSpecific: Record<string, unknown> = {};
+    let addonSpecific: Record<string, unknown> = {}
     try {
-      addonSpecific = this.configService.getAddonConfig(addonId);
+      addonSpecific = this.configService.getAddonConfig(addonId)
     } catch (err) {
-      this.logger.debug(
-        'ConfigManager not ready for addon',
-        { tags: { addonId }, meta: { error: errMsg(err) } },
-      );
+      this.logger.debug('ConfigManager not ready for addon', {
+        tags: { addonId },
+        meta: { error: errMsg(err) },
+      })
     }
 
     // No addon id special-casing here anymore. Bootstrap-level
@@ -2736,51 +2690,39 @@ export class AddonRegistryService {
     // owned by the addon itself — sqlite-settings imports the
     // constant directly from `@camstack/types` instead of relying on
     // a kernel-injected bootstrap field.
-    return addonSpecific;
+    return addonSpecific
   }
 
-  private async createAddonContext(
-    addon: ICamstackAddon,
-  ): Promise<InternalAddonContext> {
-    const addonId = addon.manifest!.id;
-    const brokerNodeId = this.broker.nodeID;
-    const agentId = brokerNodeId.includes("/")
-      ? brokerNodeId.split("/")[0]!
-      : brokerNodeId;
+  private async createAddonContext(addon: ICamstackAddon): Promise<InternalAddonContext> {
+    const addonId = addon.manifest!.id
+    const brokerNodeId = this.broker.nodeID
+    const agentId = brokerNodeId.includes('/') ? brokerNodeId.split('/')[0]! : brokerNodeId
     // No scope on the addon root logger — the brand bracket already shows
     // `[agent/addonId]`, so `(addon:<addonId>)` was pure duplication.
     // Sub-components add their own scope via `.child('<name>')`.
     const logger = this.loggingService
       .createLogger()
-      .withTags({ addonId, nodeId: brokerNodeId, agentId });
-    const bootstrapConfig = this.buildAddonConfig(addonId);
+      .withTags({ addonId, nodeId: brokerNodeId, agentId })
+    const bootstrapConfig = this.buildAddonConfig(addonId)
 
     // Per-addon private data directory — resolved from active storage
     // provider if available, otherwise falls back to a deterministic
     // hardcoded path. Addons that need the full storage provider now
     // resolve it via the capability registry.
-    const storageProvider = this.activeStorageProvider;
+    const storageProvider = this.activeStorageProvider
     const dataDir = storageProvider
       ? await storageProvider.resolve({
-          location: "addons-data",
+          location: 'addons-data',
           relativePath: addonId,
         })
-      : `camstack-data/addons-data/${addonId}`;
-
-    const registerProvider = (
-      capabilityName: string,
-      provider: unknown,
-    ): void => {
-      this.capabilityRegistry.registerProvider(
-        capabilityName,
-        addonId,
-        provider,
-      );
-      logger.info(
-        'Registered provider via context.registerProvider()',
-        { meta: { capabilityName } },
-      );
-    };
+      : `camstack-data/addons-data/${addonId}`
+
+    const registerProvider = (capabilityName: string, provider: unknown): void => {
+      this.capabilityRegistry.registerProvider(capabilityName, addonId, provider)
+      logger.info('Registered provider via context.registerProvider()', {
+        meta: { capabilityName },
+      })
+    }
 
     // Raw three-level settings store API. The resolver service is a
     // thin wrapper over `ConfigManager` that exposes raw reads/writes
@@ -2789,8 +2731,7 @@ export class AddonRegistryService {
     // combines these raw reads with its own schema via
     // `hydrateSchema()` inside `getAddonSettings / getGlobalSettings
     // / getDeviceSettings`.
-    const settingsView: AddonSettingsView =
-      this.configService.createSettingsView(addonId);
+    const settingsView: AddonSettingsView = this.configService.createSettingsView(addonId)
 
     // Device management — unified path for hub and worker addons.
     // Persistence routes through the `device-manager` capability
@@ -2799,11 +2740,11 @@ export class AddonRegistryService {
     // `device-manager` Moleculer service in-process — no network
     // hop. On a forked worker, the same proxy routes through the TCP
     // transport to the hub's service. Zero custom $hub.* actions needed.
-    const kernelStreamProbe: import("@camstack/types").IKernelStreamProbe = {
+    const kernelStreamProbe: import('@camstack/types').IKernelStreamProbe = {
       probe: (url, options) => this.streamProbe.probe(url, options),
       probeField: (key, value) => this.streamProbe.probeField(key, value),
-    };
-    const deviceManagerApi: import("@camstack/types").DeviceManagerApi =
+    }
+    const deviceManagerApi: import('@camstack/types').DeviceManagerApi =
       createBrokerDeviceManagerApi({
         api: this.getBrokerApi(),
         addonId,
@@ -2813,22 +2754,26 @@ export class AddonRegistryService {
         registry: this.deviceRegistry,
         capabilityRegistry: this.capabilityRegistry,
         streamProbe: kernelStreamProbe,
-      });
-
-    const registry = this;
-    const rr = this.moleculer.readinessRegistry;
-    const capHandleCache = new Map<string, CapabilityHandle<unknown>>();
-    function getOrCreateHandle<T>(capName: string, scope: ReadinessScope, timeoutMs: number): CapabilityHandle<T> {
-      const key = `${capName}::${scopeKey(scope)}`;
-      const existing = capHandleCache.get(key);
-      if (existing) return existing as CapabilityHandle<T>;
-      const handle = new CapabilityHandle<T>(capName, scope, rr, timeoutMs);
-      capHandleCache.set(key, handle as CapabilityHandle<unknown>);
-      return handle;
+      })
+
+    const registry = this
+    const rr = this.moleculer.readinessRegistry
+    const capHandleCache = new Map<string, CapabilityHandle<unknown>>()
+    function getOrCreateHandle<T>(
+      capName: string,
+      scope: ReadinessScope,
+      timeoutMs: number,
+    ): CapabilityHandle<T> {
+      const key = `${capName}::${scopeKey(scope)}`
+      const existing = capHandleCache.get(key)
+      if (existing) return existing as CapabilityHandle<T>
+      const handle = new CapabilityHandle<T>(capName, scope, rr, timeoutMs)
+      capHandleCache.set(key, handle as CapabilityHandle<unknown>)
+      return handle
     }
     const ctx: InternalAddonContext & {
-      integrationRegistry?: unknown;
-      capabilities: import("@camstack/types").CapabilitiesAccess;
+      integrationRegistry?: unknown
+      capabilities: import('@camstack/types').CapabilitiesAccess
     } = {
       id: `addon:${addonId}`,
       logger,
@@ -2836,7 +2781,7 @@ export class AddonRegistryService {
       addonConfig: bootstrapConfig,
       dataDir,
       get api() {
-        return registry.getBrokerApi();
+        return registry.getBrokerApi()
       },
       integrationRegistry: this.integrationRegistry ?? undefined,
       // Live capability-collection accessor used by addons like stream-broker
@@ -2846,20 +2791,18 @@ export class AddonRegistryService {
       // Without this, those addons silently saw 0 providers and quietly
       // skipped the fan-out — no errors, just missing streams/wiring.
       capabilities: {
-        getCollection: <T = unknown>(
-          capName: string,
-        ): readonly T[] | undefined => {
-          const items = registry.capabilityRegistry.getCollection<T>(capName);
-          return items ?? undefined;
+        getCollection: <T = unknown>(capName: string): readonly T[] | undefined => {
+          const items = registry.capabilityRegistry.getCollection<T>(capName)
+          return items ?? undefined
         },
         getCollectionEntries: <T = unknown>(
           capName: string,
         ): readonly (readonly [string, T])[] | undefined => {
-          const items = registry.capabilityRegistry.getCollectionEntries<T>(capName);
-          return items ?? undefined;
+          const items = registry.capabilityRegistry.getCollectionEntries<T>(capName)
+          return items ?? undefined
         },
         get: <T = unknown>(capName: string): T | undefined => {
-          return registry.capabilityRegistry.getSingleton<T>(capName) ?? undefined;
+          return registry.capabilityRegistry.getSingleton<T>(capName) ?? undefined
         },
       },
       deps: new AddonDepsManager(dataDir, logger),
@@ -2872,19 +2815,25 @@ export class AddonRegistryService {
         streamProbe: kernelStreamProbe,
         hwaccel: createKernelHwAccel(),
         capabilityRegistry: this.capabilityRegistry,
+        // Per-addon storage-location declarations across every installed
+        // addon — surfaced from the kernel's AddonLoader so the
+        // storage-orchestrator builtin can aggregate them and seed defaults.
+        listStorageLocationDeclarations: () => this.addonLoader.listStorageLocationDeclarations(),
         readinessRegistry: this.moleculer.readinessRegistry,
         // D3: handshake-fed native-cap view of the whole cluster. Backed by
         // `HubNodeRegistry.listNativeCapEntries()` populated by every
         // `$hub.registerNode` re-handshake. Used by device-manager as the
         // reliable fallback when push events were lost mid-transport.
         listClusterNativeCaps: () => this.moleculer.listClusterNativeCaps(),
+        // Per-device slice of the above — O(caps-for-device) via the registry's
+        // deviceId index. The per-device `getBindings` resolver prefers this
+        // over filtering the whole-cluster flat view.
+        listClusterNativeCapsForDevice: (deviceId: number) =>
+          this.moleculer.listClusterNativeCapsForDevice(deviceId),
       },
       registerProvider,
       resolveProvider: <T = unknown>(capName: string): T | null => {
-        return (
-          (registry.capabilityRegistry.getSingleton<T>(capName) as T | null) ??
-          null
-        );
+        return (registry.capabilityRegistry.getSingleton<T>(capName) as T | null) ?? null
       },
       getNativeProvider: <TCap extends CapabilityDefinition>(
         cap: TCap,
@@ -2892,33 +2841,32 @@ export class AddonRegistryService {
       ): InferProvider<TCap> => {
         // Hub-side addons live on the same process as the CapabilityRegistry;
         // native providers are always resolvable locally.
-        const local = registry.capabilityRegistry.getNativeProvider<
-          InferProvider<TCap>
-        >(cap.name, deviceId);
+        const local = registry.capabilityRegistry.getNativeProvider<InferProvider<TCap>>(
+          cap.name,
+          deviceId,
+        )
         if (!local) {
-          throw new Error(
-            `no native provider for capability '${cap.name}' on device '${deviceId}'`,
-          );
+          throw new Error(`no native provider for capability '${cap.name}' on device '${deviceId}'`)
         }
-        return local;
+        return local
       },
       fetchDevice: async (deviceId: number) => {
-        const api = registry.getBrokerApi();
-        const binding = await api.deviceManager.getBindings.query({ deviceId });
-        return createDeviceProxy(api, binding);
+        const api = registry.getBrokerApi()
+        const binding = await api.deviceManager.getBindings.query({ deviceId })
+        return createDeviceProxy(api, binding)
       },
       settings: settingsView,
       useCapability<T = unknown>(capName: string, scope: ReadinessScope = { type: 'global' }) {
-        return getOrCreateHandle<T>(capName, scope, 15_000);
+        return getOrCreateHandle<T>(capName, scope, 15_000)
       },
       async acquireCapability<T = unknown>(
         capName: string,
         scope: ReadinessScope = { type: 'global' },
         opts: { timeoutMs?: number } = {},
       ) {
-        const timeoutMs = opts.timeoutMs ?? 15_000;
-        const handle = getOrCreateHandle<T>(capName, scope, timeoutMs);
-        return handle;
+        const timeoutMs = opts.timeoutMs ?? 15_000
+        const handle = getOrCreateHandle<T>(capName, scope, timeoutMs)
+        return handle
       },
       onCapabilityStateChange(
         capName: string,
@@ -2926,15 +2874,15 @@ export class AddonRegistryService {
         handler: (state: 'ready' | 'down') => void,
       ) {
         return rr.onReadyState(capName, scope, (t) => {
-          handler(t.state === 'ready' ? 'ready' : 'down');
-        });
+          handler(t.state === 'ready' ? 'ready' : 'down')
+        })
       },
       addDisposer(fn: () => void | Promise<void>) {
-        return registry.getOrCreateDisposerChain(addonId).add(fn);
+        return registry.getOrCreateDisposerChain(addonId).add(fn)
       },
-    };
+    }
 
-    return ctx;
+    return ctx
   }
 
   /**
@@ -2943,22 +2891,22 @@ export class AddonRegistryService {
    * `unregisterAddon()` so cleanup callbacks run before the new addon
    * instance comes up.
    */
-  private readonly disposerChains = new Map<string, DisposerChain>();
+  private readonly disposerChains = new Map<string, DisposerChain>()
 
   private getOrCreateDisposerChain(addonId: string): DisposerChain {
-    let chain = this.disposerChains.get(addonId);
+    let chain = this.disposerChains.get(addonId)
     if (chain == null) {
-      const log = this.loggingService.createLogger().withTags({ addonId });
+      const log = this.loggingService.createLogger().withTags({ addonId })
       chain = new DisposerChain({
         onError: (err, index) => {
           log.error(`Disposer #${index} threw during teardown`, {
             meta: { error: errMsg(err) },
-          });
+          })
         },
-      });
-      this.disposerChains.set(addonId, chain);
+      })
+      this.disposerChains.set(addonId, chain)
     }
-    return chain;
+    return chain
   }
 
   /**
@@ -2967,10 +2915,10 @@ export class AddonRegistryService {
    * `ctx.addDisposer(...)` clean up before the next instance boots.
    */
   private async drainDisposerChain(addonId: string): Promise<void> {
-    const chain = this.disposerChains.get(addonId);
-    if (chain == null) return;
-    this.disposerChains.delete(addonId);
-    await chain.dispose();
+    const chain = this.disposerChains.get(addonId)
+    if (chain == null) return
+    this.disposerChains.delete(addonId)
+    await chain.dispose()
   }
 
   // ── Group orchestration (Phase G3 — opt-in, not yet wired into boot) ──
@@ -3000,19 +2948,19 @@ export class AddonRegistryService {
    * diagnostics that want to render the current topology.
    */
   buildAddonGroupPlan(addonIds: readonly string[]): RunnerPlan {
-    const plan = new Map<string, RunnerAddonPlacement[]>();
+    const plan = new Map<string, RunnerAddonPlacement[]>()
     for (const id of addonIds) {
-      const entry = this.addonEntries.get(id);
-      if (!entry?.declaration || !entry.addonDir) continue;
-      if (entry.packageName === "@camstack/core") continue;
-      const placement = resolveAddonPlacement(entry.declaration);
-      if (placement === "agent-only") continue;
-      const runnerId = resolveRunnerId(entry.declaration, id);
-      const bucket = plan.get(runnerId) ?? [];
-      bucket.push({ addonId: id, addonDir: entry.addonDir });
-      plan.set(runnerId, bucket);
-    }
-    return plan;
+      const entry = this.addonEntries.get(id)
+      if (!entry?.declaration || !entry.addonDir) continue
+      if (entry.packageName === '@camstack/core') continue
+      const placement = resolveAddonPlacement(entry.declaration)
+      if (placement === 'agent-only') continue
+      const runnerId = resolveRunnerId(entry.declaration, id)
+      const bucket = plan.get(runnerId) ?? []
+      bucket.push({ addonId: id, addonDir: entry.addonDir })
+      plan.set(runnerId, bucket)
+    }
+    return plan
   }
 
   /**
@@ -3036,18 +2984,18 @@ export class AddonRegistryService {
     addons: readonly RunnerAddonPlacement[],
   ): Promise<void> {
     if (addons.length === 0) {
-      throw new Error(`initializeAddonGroup("${runnerId}") requires at least one addon`);
+      throw new Error(`initializeAddonGroup("${runnerId}") requires at least one addon`)
     }
     try {
-      await this.broker.call("$process.spawnRunner", {
+      await this.broker.call('$process.spawnRunner', {
         runnerId,
         addons,
-      });
+      })
     } catch (err: unknown) {
       throw new Error(
         `Failed to spawn runner "${runnerId}" (${addons.length} addons): ${errMsg(err)}`,
         { cause: err },
-      );
+      )
     }
 
     // Register custom actions for each addon on the runner. Provider
@@ -3055,19 +3003,19 @@ export class AddonRegistryService {
     // `CapabilityBridge.onProviderConnected` once the runner's
     // INFO heartbeat lands.
     for (const { addonId } of addons) {
-      await this.registerForkedAddonCustomActions(addonId, runnerId);
+      await this.registerForkedAddonCustomActions(addonId, runnerId)
       // Mark the entry initialized so the in-process core-builtin boot
       // passes skip it (those passes only touch `@camstack/core`).
-      const entry = this.addonEntries.get(addonId);
+      const entry = this.addonEntries.get(addonId)
       if (entry) {
-        entry.initialized = true;
-        this.emitAddonLifecycleEvent("addon.started", addonId);
+        entry.initialized = true
+        this.emitAddonLifecycleEvent('addon.started', addonId)
       }
     }
 
-    this.logger.info("Addon runner spawned", {
+    this.logger.info('Addon runner spawned', {
       meta: { runnerId, addonCount: addons.length, addonIds: addons.map((a) => a.addonId) },
-    });
+    })
   }
 
   /**
@@ -3093,76 +3041,73 @@ export class AddonRegistryService {
    * Idempotent: drops any prior registration first. No-op (with a debug
    * log) when the addon exports no `customActions` — most addons don't.
    */
-  private async registerForkedAddonCustomActions(
-    addonId: string,
-    runnerId: string,
-  ): Promise<void> {
+  private async registerForkedAddonCustomActions(addonId: string, runnerId: string): Promise<void> {
     // Always clear first so a restart that REMOVES custom actions (or an
     // addon whose entry no longer exports them) doesn't leave stale
     // entries resolvable.
-    this.customActionRegistry.unregisterAddon(addonId);
+    this.customActionRegistry.unregisterAddon(addonId)
 
-    const entry = this.addonEntries.get(addonId);
-    const addonDir = entry?.addonDir;
-    const declarationEntry = entry?.declaration?.entry;
-    if (!addonDir || !declarationEntry) return;
+    const entry = this.addonEntries.get(addonId)
+    const addonDir = entry?.addonDir
+    const declarationEntry = entry?.declaration?.entry
+    if (!addonDir || !declarationEntry) return
 
     // Resolve the built entry the same way `AddonLoader.loadDeclaration`
     // does: `./src/x.ts` → `dist/x.js`, with index.js fallbacks.
     const entryFile = declarationEntry
-      .replace(/^\.\//, "")
-      .replace(/^src\//, "dist/")
-      .replace(/\.ts$/, ".js");
-    let entryPath = path.resolve(addonDir, entryFile);
+      .replace(/^\.\//, '')
+      .replace(/^src\//, 'dist/')
+      .replace(/\.ts$/, '.js')
+    let entryPath = path.resolve(addonDir, entryFile)
     if (!fs.existsSync(entryPath)) {
-      const base = entryPath.replace(/\.(js|cjs|mjs)$/, "");
+      const base = entryPath.replace(/\.(js|cjs|mjs)$/, '')
       const alternatives = [
         `${base}.cjs`,
         `${base}.mjs`,
-        path.resolve(addonDir, "dist", "index.js"),
-        path.resolve(addonDir, "dist", "index.cjs"),
-        path.resolve(addonDir, "dist", "index.mjs"),
+        path.resolve(addonDir, 'dist', 'index.js'),
+        path.resolve(addonDir, 'dist', 'index.cjs'),
+        path.resolve(addonDir, 'dist', 'index.mjs'),
         path.resolve(addonDir, declarationEntry),
-      ];
-      entryPath = alternatives.find((p) => fs.existsSync(p)) ?? entryPath;
+      ]
+      entryPath = alternatives.find((p) => fs.existsSync(p)) ?? entryPath
     }
-    if (!fs.existsSync(entryPath)) return;
+    if (!fs.existsSync(entryPath)) return
 
-    let catalog: unknown;
+    let catalog: unknown
     try {
       // Cache-bust so a hot-updated bundle is re-read instead of served
       // from Node's ESM module cache.
-      const cacheBustedUrl = `${pathToFileURL(entryPath).href}?t=${Date.now()}`;
-      const modUnknown: unknown = await import(cacheBustedUrl);
+      const cacheBustedUrl = `${pathToFileURL(entryPath).href}?t=${Date.now()}`
+      const modUnknown: unknown = await import(cacheBustedUrl)
       catalog =
-        modUnknown && typeof modUnknown === "object"
-          ? (modUnknown as Record<string, unknown>)["customActions"]
-          : undefined;
+        modUnknown && typeof modUnknown === 'object'
+          ? (modUnknown as Record<string, unknown>)['customActions']
+          : undefined
     } catch (err) {
-      this.logger.warn(
-        "Failed to load custom-action catalog for forked addon",
-        { tags: { addonId }, meta: { error: errMsg(err) } },
-      );
-      return;
+      this.logger.warn('Failed to load custom-action catalog for forked addon', {
+        tags: { addonId },
+        meta: { error: errMsg(err) },
+      })
+      return
     }
 
-    if (!catalog || typeof catalog !== "object") {
-      this.logger.debug("Forked addon exports no custom actions", {
+    if (!catalog || typeof catalog !== 'object') {
+      this.logger.debug('Forked addon exports no custom actions', {
         tags: { addonId },
         meta: { runnerId },
-      });
-      return;
+      })
+      return
     }
 
     this.customActionRegistry.registerAddon(
       addonId,
-      catalog as import("@camstack/types").CustomActionsSpec,
+      catalog as import('@camstack/types').CustomActionsSpec,
       (action, input) => this.dispatchForkedCustomAction(addonId, action, input),
-    );
-    this.logger.info("Runner addon custom actions registered", {
+    )
+    this.logger.info('Runner addon custom actions registered', {
       tags: { addonId },
       meta: { runnerId },
-    });
+    })
   }
 
   /**
@@ -3177,9 +3122,9 @@ export class AddonRegistryService {
     input: unknown,
   ): Promise<unknown> {
     return this.addonCallGateway.callForked(addonId, {
-      target: "custom",
+      target: 'custom',
       action,
       args: input,
-    });
+    })
   }
 }