fix: scope runtime plugin preload to effective plugins

src/plugins/runtime/runtime-registry-loader.test.ts

@@ -13,6 +13,8 @@ const mocks = vi.hoisted(() => ({
     vi.fn<typeof import("../channel-plugin-ids.js").resolveDiscoverableScopedChannelPluginIds>(),
   resolveChannelPluginIds:
     vi.fn<typeof import("../channel-plugin-ids.js").resolveChannelPluginIds>(),
+  resolveEffectivePluginIds:
+    vi.fn<typeof import("../effective-plugin-ids.js").resolveEffectivePluginIds>(),
   applyPluginAutoEnable:
     vi.fn<typeof import("../../config/plugin-auto-enable.js").applyPluginAutoEnable>(),
   resolveAgentWorkspaceDir: vi.fn<
@@ -55,6 +57,11 @@ vi.mock("../channel-plugin-ids.js", () => ({
     mocks.resolveChannelPluginIds(...args),
 }));
 
+vi.mock("../effective-plugin-ids.js", () => ({
+  resolveEffectivePluginIds: (...args: Parameters<typeof mocks.resolveEffectivePluginIds>) =>
+    mocks.resolveEffectivePluginIds(...args),
+}));
+
 vi.mock("../../config/plugin-auto-enable.js", () => ({
   applyPluginAutoEnable: (...args: Parameters<typeof mocks.applyPluginAutoEnable>) =>
     mocks.applyPluginAutoEnable(...args),
@@ -82,6 +89,7 @@ describe("ensurePluginRegistryLoaded", () => {
     mocks.resolveConfiguredChannelPluginIds.mockReset();
     mocks.resolveDiscoverableScopedChannelPluginIds.mockReset();
     mocks.resolveChannelPluginIds.mockReset();
+    mocks.resolveEffectivePluginIds.mockReset();
     mocks.applyPluginAutoEnable.mockReset();
     mocks.resolveAgentWorkspaceDir.mockClear();
     mocks.resolveDefaultAgentId.mockClear();
@@ -111,6 +119,7 @@ describe("ensurePluginRegistryLoaded", () => {
       },
     }));
     mocks.resolveDiscoverableScopedChannelPluginIds.mockReturnValue([]);
+    mocks.resolveEffectivePluginIds.mockReturnValue(["demo"]);
   });
 
   it("uses the shared runtime load context for configured-channel loads", () => {
@@ -328,8 +337,63 @@ describe("ensurePluginRegistryLoaded", () => {
     ).toBeUndefined();
   });
 
+  it("derives all-scope runtime loads from effective plugin ids", () => {
+    const config = {
+      plugins: { enabled: true },
+      channels: { "demo-channel-a": { enabled: true } },
+    };
+    const env = { HOME: "/tmp/openclaw-home" } as NodeJS.ProcessEnv;
+
+    mocks.resolveEffectivePluginIds.mockReturnValue(["demo-effective", "demo-hook"]);
+
+    ensurePluginRegistryLoaded({ scope: "all", config: config as never, env });
+
+    expect(mocks.resolveEffectivePluginIds).toHaveBeenCalledWith({
+      config,
+      env,
+      workspaceDir: "/resolved-workspace",
+    });
+    expect(mocks.loadOpenClawPlugins).toHaveBeenCalledWith(
+      expect.objectContaining({
+        config: expect.objectContaining({
+          ...config,
+          plugins: expect.objectContaining({
+            entries: expect.objectContaining({
+              demo: { enabled: true },
+            }),
+          }),
+        }),
+        onlyPluginIds: ["demo-effective", "demo-hook"],
+        throwOnLoadError: true,
+        workspaceDir: "/resolved-workspace",
+      }),
+    );
+  });
+
+  it("preserves empty all-scope loads instead of widening to all discovered plugins", () => {
+    mocks.resolveEffectivePluginIds.mockReturnValue([]);
+
+    ensurePluginRegistryLoaded({
+      scope: "all",
+      config: { plugins: { enabled: true } } as never,
+    });
+
+    expect(mocks.loadOpenClawPlugins).toHaveBeenCalledWith(
+      expect.objectContaining({
+        onlyPluginIds: [],
+      }),
+    );
+  });
+
   it("reuses a compatible active registry instead of forcing a broad reload", () => {
     const activeRegistry = createEmptyPluginRegistry();
+    activeRegistry.plugins.push({
+      id: "demo",
+      source: "/tmp/demo.js",
+      origin: "workspace",
+      enabled: true,
+      status: "loaded",
+    } as never);
     mocks.getActivePluginRegistry.mockReturnValue(activeRegistry);
     mocks.resolveCompatibleRuntimePluginRegistry.mockReturnValue(activeRegistry);
 

src/plugins/runtime/runtime-registry-loader.ts

@@ -6,6 +6,7 @@ import {
   resolveConfiguredChannelPluginIds,
   resolveDiscoverableScopedChannelPluginIds,
 } from "../channel-plugin-ids.js";
+import { resolveEffectivePluginIds } from "../effective-plugin-ids.js";
 import { loadOpenClawPlugins } from "../loader.js";
 import {
   hasExplicitPluginIdScope,
@@ -75,6 +76,35 @@ function shouldForwardChannelScope(params: {
   return !params.scopedLoad && params.scope === "configured-channels";
 }
 
+function resolveScopePluginIds(params: {
+  scope: PluginRegistryScope;
+  context: ReturnType<typeof resolvePluginRuntimeLoadContext>;
+}): string[] {
+  switch (params.scope) {
+    case "configured-channels":
+      return resolveConfiguredChannelPluginIds({
+        config: params.context.config,
+        activationSourceConfig: params.context.activationSourceConfig,
+        workspaceDir: params.context.workspaceDir,
+        env: params.context.env,
+      });
+    case "channels":
+      return resolveChannelPluginIds({
+        config: params.context.config,
+        workspaceDir: params.context.workspaceDir,
+        env: params.context.env,
+      });
+    case "all":
+      return resolveEffectivePluginIds({
+        config: params.context.rawConfig,
+        workspaceDir: params.context.workspaceDir,
+        env: params.context.env,
+      });
+  }
+  const unreachableScope: never = params.scope;
+  return unreachableScope;
+}
+
 function resolveOrLoadRuntimePluginRegistry(
   loadOptions: NonNullable<Parameters<typeof loadOpenClawPlugins>[0]>,
 ): void {
@@ -121,33 +151,21 @@ export function ensurePluginRegistryLoaded(options?: {
           ...requestedChannelOwnerPluginIds,
         ]);
   const scopedLoad = hasExplicitPluginIdScope(requestedPluginIds);
-  const expectedChannelPluginIds = scopedLoad
+  const expectedPluginIds = scopedLoad
     ? (requestedPluginIds ?? [])
-    : scope === "configured-channels"
-      ? resolveConfiguredChannelPluginIds({
-          config: context.config,
-          activationSourceConfig: context.activationSourceConfig,
-          workspaceDir: context.workspaceDir,
-          env: context.env,
-        })
-      : scope === "channels"
-        ? resolveChannelPluginIds({
-            config: context.config,
-            workspaceDir: context.workspaceDir,
-            env: context.env,
-          })
-        : [];
+    : resolveScopePluginIds({ scope, context });
   const active = getActivePluginRegistry();
+  const requestedPluginIdsForScope = scope === "all" ? expectedPluginIds : undefined;
   if (
     !scopedLoad &&
     scopeRank(pluginRegistryLoaded) >= scopeRank(scope) &&
-    activeRegistrySatisfiesScope(scope, active, expectedChannelPluginIds, undefined)
+    activeRegistrySatisfiesScope(scope, active, expectedPluginIds, requestedPluginIdsForScope)
   ) {
     return;
   }
   if (
     (pluginRegistryLoaded === "none" || scopedLoad) &&
-    activeRegistrySatisfiesScope(scope, active, expectedChannelPluginIds, requestedPluginIds)
+    activeRegistrySatisfiesScope(scope, active, expectedPluginIds, requestedPluginIds)
   ) {
     if (!scopedLoad) {
       pluginRegistryLoaded = scope;
@@ -156,20 +174,20 @@ export function ensurePluginRegistryLoaded(options?: {
   }
   const scopedConfig =
     scope === "configured-channels" &&
-    expectedChannelPluginIds.length > 0 &&
+    expectedPluginIds.length > 0 &&
     (!scopedLoad || requestedChannelOwnerPluginIds !== undefined)
       ? (withActivatedPluginIds({
           config: context.config,
-          pluginIds: expectedChannelPluginIds,
+          pluginIds: expectedPluginIds,
         }) ?? context.config)
       : context.config;
   const scopedActivationSourceConfig =
     scope === "configured-channels" &&
-    expectedChannelPluginIds.length > 0 &&
+    expectedPluginIds.length > 0 &&
     (!scopedLoad || requestedChannelOwnerPluginIds !== undefined)
       ? (withActivatedPluginIds({
           config: context.activationSourceConfig,
-          pluginIds: expectedChannelPluginIds,
+          pluginIds: expectedPluginIds,
         }) ?? context.activationSourceConfig)
       : context.activationSourceConfig;
   const loadOptions = buildPluginRuntimeLoadOptionsFromValues(
@@ -182,8 +200,9 @@ export function ensurePluginRegistryLoaded(options?: {
       throwOnLoadError: true,
       ...(hasExplicitPluginIdScope(requestedPluginIds) ||
       shouldForwardChannelScope({ scope, scopedLoad }) ||
-      hasNonEmptyPluginIdScope(expectedChannelPluginIds)
-        ? { onlyPluginIds: expectedChannelPluginIds }
+      hasNonEmptyPluginIdScope(expectedPluginIds) ||
+      scope === "all"
+        ? { onlyPluginIds: expectedPluginIds }
         : {}),
     },
   );