[fix] fix startup summary model banner resolution (#305)

* fix startup summary model banner resolution

* fix: use runtime config for startup model resolution

Keep registration-time plugin overrides from api.pluginConfig, but always source the OpenClaw config surface from the best validated runtime config available. This fixes the startup ordering where pluginConfig is ready before api.config, so the compaction banner and summarizer fallback both see the configured default model. Also add a regression test for that ordering, relax the provider-config loadConfig call-count assertion to match the earlier registration lookup, and add a patch changeset for the user-visible startup behavior fix.

Regeneration-Prompt: |
  Address the PR review finding that registration-time config resolution still broke when
  OpenClaw populated api.pluginConfig before api.config. Preserve the intended behavior of
  preferring api.pluginConfig for lossless-claw-specific overrides, but stop coupling that to
  the top-level OpenClaw config used for default and compaction model discovery.

  Update the registration tests to cover the startup order where runtime.config.loadConfig()
  contains the default model while api.config is still empty, and verify both the startup
  banner and resolveModel() pick up that default. Because registration now consults runtime
  config earlier, adjust any overly strict tests that asserted an exact loadConfig call count.
  Since the startup banner output changes for users, include a patch changeset.

* test: align rebased startup-banner assertions

Current main logs startup banner messages through the plugin logger info path instead of console.error. Update the rebased PR 305 registration-order tests to assert the current logging surface so the branch reflects the intended startup-model fix and the targeted test run stays green.

Regeneration-Prompt: |
  Rebase the old PR 305 startup-model fix onto current origin/main and resolve conflicts without losing main's newer registration diagnostics and logger plumbing. After the rebase, re-run the targeted registration/provider-config tests and account for any drift caused by current main no longer emitting startup banner lines through console.error. Preserve the actual runtime-config fallback behavior being tested; only update the assertions to match the current info-log surface used by registration startup banners.

---------

Co-authored-by: Josh Lehman <josh@martian.engineering>

Author: stilrmy

.changeset/late-cups-rhyme.md

@@ -0,0 +1,5 @@
+---
+"@martian-engineering/lossless-claw": patch
+---
+
+Fix startup-time summary model resolution when OpenClaw populates plugin config before the top-level runtime config surface.

src/plugin/index.ts

@@ -344,6 +344,72 @@ function readDefaultModelFromConfig(config: unknown): string {
   return typeof primary === "string" ? primary.trim() : "";
 }
 
+/** Load the best available validated OpenClaw config during plugin registration. */
+function loadEffectiveOpenClawConfig(api: OpenClawPluginApi): unknown {
+  try {
+    const runtimeConfig = api.runtime.config.loadConfig();
+    if (runtimeConfig !== undefined) {
+      if (isRecord(runtimeConfig) && Object.keys(runtimeConfig).length > 0) {
+        return runtimeConfig;
+      }
+      if (!isRecord(api.config) || Object.keys(api.config).length === 0) {
+        return runtimeConfig;
+      }
+    }
+  } catch {
+    // Older runtimes or early startup can leave loadConfig unavailable.
+  }
+  return api.config;
+}
+
+/** Read this plugin's config from the validated OpenClaw runtime config. */
+function readPluginConfigFromOpenClawConfig(
+  openClawConfig: unknown,
+  pluginId: string,
+): Record<string, unknown> | undefined {
+  if (!isRecord(openClawConfig)) {
+    return undefined;
+  }
+
+  const plugins = openClawConfig.plugins;
+  if (!isRecord(plugins)) {
+    return undefined;
+  }
+
+  const entries = plugins.entries;
+  if (!isRecord(entries)) {
+    return undefined;
+  }
+
+  const entry = entries[pluginId];
+  if (!isRecord(entry) || !isRecord(entry.config)) {
+    return undefined;
+  }
+
+  return entry.config;
+}
+
+/** Resolve the config surfaces that should drive registration-time behavior. */
+function resolveRegistrationConfig(api: OpenClawPluginApi): {
+  openClawConfig: unknown;
+  pluginConfig?: Record<string, unknown>;
+} {
+  const openClawConfig = loadEffectiveOpenClawConfig(api);
+  const apiPluginConfig =
+    api.pluginConfig && typeof api.pluginConfig === "object" && !Array.isArray(api.pluginConfig)
+      ? api.pluginConfig
+      : undefined;
+
+  if (apiPluginConfig && Object.keys(apiPluginConfig).length > 0) {
+    return { openClawConfig, pluginConfig: apiPluginConfig };
+  }
+
+  return {
+    openClawConfig,
+    pluginConfig: readPluginConfigFromOpenClawConfig(openClawConfig, api.id),
+  };
+}
+
 /** Read OpenClaw's configured compaction model from the validated runtime config. */
 function readCompactionModelFromConfig(config: unknown): string {
   if (!config || typeof config !== "object") {
@@ -1278,12 +1344,15 @@ function readLatestAssistantReply(messages: unknown[]): string | undefined {
 }
 
 /** Construct LCM dependencies from plugin API/runtime surfaces. */
-function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
+function createLcmDependencies(
+  api: OpenClawPluginApi,
+  registrationConfig = resolveRegistrationConfig(api),
+): LcmDependencies {
   const envSnapshot = snapshotPluginEnv();
-  envSnapshot.openclawDefaultModel = readDefaultModelFromConfig(api.config);
+  envSnapshot.openclawDefaultModel = readDefaultModelFromConfig(registrationConfig.openClawConfig);
   const modelAuth = getRuntimeModelAuth(api);
   const readEnv: ReadEnvFn = (key) => process.env[key];
-  const pluginConfig = resolvePluginConfig(api);
+  const pluginConfig = registrationConfig.pluginConfig;
   const log = createLcmLogger(api);
   const { config, diagnostics } = resolveLcmConfigWithDiagnostics(process.env, pluginConfig);
 
@@ -1943,7 +2012,8 @@ const lcmPlugin = {
   },
 
   register(api: OpenClawPluginApi) {
-    const deps = createLcmDependencies(api);
+    const registrationConfig = resolveRegistrationConfig(api);
+    const deps = createLcmDependencies(api, registrationConfig);
     const dbPath = deps.config.databasePath;
     const normalizedDbPath = normalizePath(dbPath);
 
@@ -2132,7 +2202,7 @@ const lcmPlugin = {
       log: (message) => deps.log.info(message),
       message: buildCompactionModelLog({
         config: deps.config,
-        openClawConfig: api.config,
+        openClawConfig: registrationConfig.openClawConfig,
         defaultProvider: process.env.OPENCLAW_PROVIDER?.trim() ?? "",
       }),
     });

test/index-complete-provider-config.test.ts

@@ -157,7 +157,7 @@ describe("createLcmDependencies.complete provider config resolution", () => {
       model: "unit-model",
     });
 
-    expect(loadConfig).toHaveBeenCalledTimes(1);
+    expect(loadConfig).toHaveBeenCalled();
     expect(piAiMock.completeSimple).toHaveBeenCalledTimes(1);
     expect(piAiMock.completeSimple).toHaveBeenCalledWith(
       expect.objectContaining({

test/plugin-config-registration.test.ts

@@ -14,7 +14,11 @@ type HookHandler = (event: unknown, context: unknown) => unknown;
 
 function buildApi(
   pluginConfig: unknown,
-  options?: { includeModelAuth?: boolean; agentDir?: string },
+  options?: {
+    includeModelAuth?: boolean;
+    agentDir?: string;
+    runtimeConfig?: Record<string, unknown>;
+  },
 ): {
   api: OpenClawPluginApi;
   getFactory: () => RegisteredEngineFactory;
@@ -58,7 +62,7 @@ function buildApi(
             },
           }),
       config: {
-        loadConfig: vi.fn(() => ({})),
+        loadConfig: vi.fn(() => options?.runtimeConfig ?? {}),
       },
       logging: {
         getChildLogger: vi.fn(() => ({
@@ -519,6 +523,66 @@ describe("lcm plugin registration", () => {
     expect(sessionInfoLog).not.toHaveBeenCalled();
   });
 
+  it("falls back to runtime plugin config for the startup banner when register runs before api.pluginConfig is populated", () => {
+    const { api, infoLog } = buildApi(
+      {},
+      {
+        runtimeConfig: {
+          plugins: {
+            entries: {
+              "lossless-claw": {
+                enabled: true,
+                config: {
+                  summaryModel: "openai-codex/gpt-5.4",
+                },
+              },
+            },
+          },
+        },
+      },
+    );
+    api.config = {} as OpenClawPluginApi["config"];
+
+    lcmPlugin.register(api);
+
+    expect(infoLog).toHaveBeenCalledWith(
+      "[lcm] Compaction summarization model: openai-codex/gpt-5.4 (override)",
+    );
+  });
+
+  it("uses runtime OpenClaw defaults when api.pluginConfig is ready before api.config", () => {
+    const { api, getFactory, infoLog } = buildApi(
+      {
+        enabled: true,
+      },
+      {
+        runtimeConfig: compactionAndDefaultModelConfig({
+          defaultModel: "anthropic/claude-sonnet-4-6",
+        }),
+      },
+    );
+    api.config = {} as OpenClawPluginApi["config"];
+
+    lcmPlugin.register(api);
+
+    expect(infoLog).toHaveBeenCalledWith(
+      "[lcm] Compaction summarization model: anthropic/claude-sonnet-4-6 (default)",
+    );
+
+    const factory = getFactory();
+    expect(factory).toBeTypeOf("function");
+
+    const engine = factory!() as { deps?: { resolveModel: (modelRef?: string, providerHint?: string) => unknown } };
+    const resolved = engine.deps?.resolveModel(undefined, undefined) as
+      | { provider: string; model: string }
+      | undefined;
+
+    expect(resolved).toEqual({
+      provider: "anthropic",
+      model: "claude-sonnet-4-6",
+    });
+  });
+
   it("logs the OpenClaw compaction model at startup when no plugin override is set", () => {
     const { api, infoLog } = buildApi({
       enabled: true,