@martian-engineering/lossless-claw 0.6.3 → 0.7.0

package/src/lcm-log.ts

@@ -0,0 +1,37 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { LcmDependencies } from "./types.js";
+
+export type LcmLogger = LcmDependencies["log"];
+
+/** Silent logger used when a caller does not provide an explicit sink. */
+export const NOOP_LCM_LOGGER: LcmLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  debug: () => {},
+};
+
+/** Format unknown failures into stable one-line log text. */
+export function describeLogError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Create the LCM logger, preferring OpenClaw's file-backed runtime logger. */
+export function createLcmLogger(api: OpenClawPluginApi): LcmLogger {
+  const runtimeLogger = api.runtime.logging?.getChildLogger?.({ plugin: "lossless-claw" });
+  if (runtimeLogger) {
+    return {
+      info: (message) => runtimeLogger.info(message),
+      warn: (message) => runtimeLogger.warn(message),
+      error: (message) => runtimeLogger.error(message),
+      debug: (message) => runtimeLogger.debug?.(message),
+    };
+  }
+
+  return {
+    info: (message) => api.logger.info(message),
+    warn: (message) => api.logger.warn(message),
+    error: (message) => api.logger.error(message),
+    debug: (message) => api.logger.debug?.(message),
+  };
+}

package/src/plugin/index.ts

@@ -6,11 +6,15 @@
  */
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import type { DatabaseSync } from "node:sqlite";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { resolveLcmConfig } from "../db/config.js";
-import { createLcmDatabaseConnection } from "../db/connection.js";
+import { closeLcmConnection, createLcmDatabaseConnection, normalizePath } from "../db/connection.js";
 import { LcmContextEngine } from "../engine.js";
+import { createLcmLogger, describeLogError } from "../lcm-log.js";
 import { logStartupBannerOnce } from "../startup-banner-log.js";
+import { getSharedInit, setSharedInit, removeSharedInit } from "./shared-init.js";
+import type { SharedLcmInit } from "./shared-init.js";
 import { createLcmDescribeTool } from "../tools/lcm-describe-tool.js";
 import { createLcmExpandQueryTool } from "../tools/lcm-expand-query-tool.js";
 import { createLcmExpandTool } from "../tools/lcm-expand-tool.js";
@@ -64,6 +68,29 @@ type CompleteSimpleOptions = {
 
 type RuntimeModelAuthResult = {
   apiKey?: string;
+  baseUrl?: string;
+  request?: RuntimeModelRequestTransportOverrides;
+  expiresAt?: number;
+};
+
+type RuntimeModelRequestAuthOverride =
+  | {
+      mode: "provider-default";
+    }
+  | {
+      mode: "authorization-bearer";
+      token: string;
+    }
+  | {
+      mode: "header";
+      headerName: string;
+      value: string;
+      prefix?: string;
+    };
+
+type RuntimeModelRequestTransportOverrides = {
+  headers?: Record<string, string>;
+  auth?: RuntimeModelRequestAuthOverride;
 };
 
 type SessionEndLifecycleEvent = {
@@ -104,6 +131,13 @@ type RuntimeModelAuth = {
     profileId?: string;
     preferredProfile?: string;
   }) => Promise<RuntimeModelAuthResult | undefined>;
+  getRuntimeAuthForModel?: (params: {
+    model: RuntimeModelAuthModel;
+    cfg?: OpenClawPluginApi["config"];
+    profileId?: string;
+    preferredProfile?: string;
+    workspaceDir?: string;
+  }) => Promise<RuntimeModelAuthResult | undefined>;
 };
 
 const MODEL_AUTH_PR_URL = "https://github.com/openclaw/openclaw/pull/41090";
@@ -136,12 +170,20 @@ const LOSSLESS_RECALL_POLICY_PROMPT = [
   "Recall order for compacted conversation history:",
   "1. `lcm_grep` — search by regex or full-text across messages and summaries",
   "2. `lcm_describe` — inspect a specific summary (cheap, no sub-agent)",
-  "3. `lcm_expand_query` — deep recall: spawns bounded sub-agent, expands DAG, returns answer with cited summary IDs (~120s, don't ration it)",
+  "3. `lcm_expand_query` — deep recall: spawns bounded sub-agent, expands DAG, and returns answer plus cited summary IDs in tool output for follow-up (~120s, don't ration it)",
+  "",
+  "**`lcm_grep` routing guidance:**",
+  '- Prefer `mode: "full_text"` for keyword or topical recall; keep `mode: "regex"` for literal patterns.',
+  '- Wrap exact multi-word phrases in quotes, for example `"error handling"`.',
+  '- Keep the default `sort: "recency"` for "what just happened?" lookups.',
+  '- Use `sort: "relevance"` when hunting for the best older match on a topic.',
+  '- Use `sort: "hybrid"` when relevance matters but newer context should still get a boost.',
   "",
   "**`lcm_expand_query` usage** — two patterns (always requires `prompt`):",
   "- With IDs: `lcm_expand_query(summaryIds: [\"sum_xxx\"], prompt: \"What config changes were discussed?\")`",
   "- With search: `lcm_expand_query(query: \"database migration\", prompt: \"What strategy was decided?\")`",
   "- Optional: `maxTokens` (default 2000), `conversationId`, `allConversations: true`",
+  "- Keep raw summary IDs out of normal user-facing prose unless the user explicitly asks for sources or IDs.",
   "",
   "These precedence rules apply only to compacted conversation history. Lossless-claw does not supersede memory tools globally.",
   "",
@@ -587,6 +629,78 @@ function resolveApiKeyFromAuthResult(auth: RuntimeModelAuthResult | undefined):
   return apiKey ? apiKey : undefined;
 }
 
+/** Normalize a runtime auth override base URL when present. */
+function resolveBaseUrlFromAuthResult(auth: RuntimeModelAuthResult | undefined): string | undefined {
+  const baseUrl = auth?.baseUrl?.trim();
+  return baseUrl ? baseUrl : undefined;
+}
+
+/** Normalize raw runtime auth headers into plain string headers. */
+function resolveRuntimeAuthHeaders(
+  request: RuntimeModelRequestTransportOverrides | undefined,
+): Record<string, string> | undefined {
+  if (!request) {
+    return undefined;
+  }
+
+  const headers: Record<string, string> = {};
+  if (isRecord(request.headers)) {
+    for (const [key, value] of Object.entries(request.headers)) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      const headerName = key.trim();
+      const headerValue = value.trim();
+      if (headerName && headerValue) {
+        headers[headerName] = headerValue;
+      }
+    }
+  }
+
+  const auth = request.auth;
+  if (auth?.mode === "authorization-bearer") {
+    const token = auth.token.trim();
+    if (token) {
+      for (const key of Object.keys(headers)) {
+        if (key.toLowerCase() === "authorization") {
+          delete headers[key];
+        }
+      }
+      headers.Authorization = `Bearer ${token}`;
+    }
+  } else if (auth?.mode === "header") {
+    const headerName = auth.headerName.trim();
+    const value = auth.value.trim();
+    if (headerName && value) {
+      const normalizedHeader = headerName.toLowerCase();
+      for (const key of Object.keys(headers)) {
+        if (
+          key.toLowerCase() === normalizedHeader ||
+          (normalizedHeader !== "authorization" && key.toLowerCase() === "authorization")
+        ) {
+          delete headers[key];
+        }
+      }
+      headers[headerName] = `${auth.prefix?.trim() ?? ""}${value}`;
+    }
+  }
+
+  return Object.keys(headers).length > 0 ? headers : undefined;
+}
+
+/** Attach OpenClaw transport overrides to a model for runtimes that inspect the shared symbol. */
+function attachRuntimeAuthRequestTransport<TModel extends object>(
+  model: TModel,
+  request: RuntimeModelRequestTransportOverrides | undefined,
+): TModel {
+  if (!request) {
+    return model;
+  }
+  const next = { ...model } as TModel & Record<symbol, unknown>;
+  next[Symbol.for("openclaw.modelProviderRequestTransport")] = request;
+  return next;
+}
+
 function buildLegacyAuthFallbackWarning(): string {
   return [
     "[lcm] OpenClaw runtime.modelAuth is unavailable; using legacy auth-profiles fallback.",
@@ -1102,6 +1216,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
       ? api.pluginConfig
       : undefined;
   const config = resolveLcmConfig(process.env, pluginConfig);
+  const log = createLcmLogger(api);
 
   // Read model overrides from plugin config
   if (pluginConfig) {
@@ -1116,7 +1231,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
   }
 
   if (!modelAuth) {
-    api.logger.warn(buildLegacyAuthFallbackWarning());
+    log.warn(buildLegacyAuthFallbackWarning());
   }
 
   /** Resolve the best config object to hand to runtime.modelAuth for this lookup. */
@@ -1194,6 +1309,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
       authProfileId,
       agentDir,
       runtimeConfig,
+      skipModelAuth,
       messages,
       system,
       maxTokens,
@@ -1213,6 +1329,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
         if (!providerId || !modelId) {
           return { content: [] };
         }
+        const workspaceDir = agentDir?.trim() || api.resolvePath(".");
 
         // When runtimeConfig is undefined (e.g. resolveLargeFileTextSummarizer
         // passes legacyParams without config), fall back to the plugin API so
@@ -1243,6 +1360,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
             return first.api.trim();
           })() ||
           inferApiFromProvider(providerId);
+        const modelAuthConfig = resolveModelAuthConfig(effectiveRuntimeConfig);
 
         // Resolve provider-level config (baseUrl, headers, etc.) from runtime config.
         // Custom/proxy providers (e.g. bailian, local proxies) store their baseUrl and
@@ -1259,7 +1377,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
           return isRecord(cfg) ? cfg : {};
         })();
 
-        const resolvedModel =
+        let resolvedModel =
           isRecord(knownModel) &&
           typeof knownModel.api === "string" &&
           typeof knownModel.provider === "string" &&
@@ -1307,8 +1425,50 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
                   : {}),
               };
 
+        let runtimeAuth: RuntimeModelAuthResult | undefined;
+        if (modelAuth && skipModelAuth !== true && typeof modelAuth.getRuntimeAuthForModel === "function") {
+          try {
+            runtimeAuth = await modelAuth.getRuntimeAuthForModel({
+              model: buildModelAuthLookupModel({
+                provider: providerId,
+                model: modelId,
+                api: resolvedModel.api,
+              }),
+              cfg: modelAuthConfig,
+              ...(authProfileId ? { profileId: authProfileId } : {}),
+              workspaceDir,
+            });
+          } catch (err) {
+            console.error(
+              `[lcm] modelAuth.getRuntimeAuthForModel FAILED:`,
+              err instanceof Error ? err.message : err,
+            );
+          }
+        }
+
+        const runtimeAuthBaseUrl = resolveBaseUrlFromAuthResult(runtimeAuth);
+        const runtimeAuthHeaders = resolveRuntimeAuthHeaders(runtimeAuth?.request);
+        resolvedModel = attachRuntimeAuthRequestTransport(
+          {
+            ...resolvedModel,
+            ...(runtimeAuthBaseUrl ? { baseUrl: runtimeAuthBaseUrl } : {}),
+            ...(runtimeAuthHeaders
+              ? {
+                  headers: {
+                    ...(isRecord(resolvedModel.headers) ? resolvedModel.headers : {}),
+                    ...runtimeAuthHeaders,
+                  },
+                }
+              : {}),
+          },
+          runtimeAuth?.request,
+        );
+
         let resolvedApiKey = apiKey?.trim();
-        if (!resolvedApiKey && modelAuth) {
+        if (!resolvedApiKey) {
+          resolvedApiKey = resolveApiKeyFromAuthResult(runtimeAuth);
+        }
+        if (!resolvedApiKey && modelAuth && skipModelAuth !== true) {
           try {
             resolvedApiKey = resolveApiKeyFromAuthResult(
               await modelAuth.getApiKeyForModel({
@@ -1317,31 +1477,25 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
                   model: modelId,
                   api: resolvedModel.api,
                 }),
-                cfg: api.config,
+                cfg: modelAuthConfig,
                 ...(authProfileId ? { profileId: authProfileId } : {}),
               }),
             );
           } catch (err) {
-            console.error(
-              `[lcm] modelAuth.getApiKeyForModel FAILED:`,
-              err instanceof Error ? err.message : err,
-            );
+            log.warn(`[lcm] modelAuth.getApiKeyForModel FAILED: ${describeLogError(err)}`);
           }
         }
-        if (!resolvedApiKey && modelAuth) {
+        if (!resolvedApiKey && modelAuth && skipModelAuth !== true) {
           try {
             resolvedApiKey = resolveApiKeyFromAuthResult(
               await modelAuth.resolveApiKeyForProvider({
                 provider: providerId,
-                cfg: api.config,
+                cfg: modelAuthConfig,
                 ...(authProfileId ? { profileId: authProfileId } : {}),
               }),
             );
           } catch (err) {
-            console.error(
-              `[lcm] modelAuth.resolveApiKeyForProvider FAILED:`,
-              err instanceof Error ? err.message : err,
-            );
+            log.warn(`[lcm] modelAuth.resolveApiKeyForProvider FAILED: ${describeLogError(err)}`);
           }
         }
         if (!resolvedApiKey) {
@@ -1426,7 +1580,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
           ...requestMetadata,
         };
       } catch (err) {
-        console.error(`[lcm] completeSimple error:`, err instanceof Error ? err.message : err);
+        log.error(`[lcm] completeSimple error: ${describeLogError(err)}`);
         const authError = detectProviderAuthError(err);
         return {
           content: [],
@@ -1536,15 +1690,66 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
       }
     },
     agentLaneSubagent: "subagent",
-    log: {
-      info: (msg) => console.error(msg),
-      warn: (msg) => console.error(msg),
-      error: (msg) => console.error(msg),
-      debug: (msg) => api.logger.debug?.(msg),
-    },
+    log,
   };
 }
 
+/**
+ * Wire event handlers, context engines, tools, and commands to the
+ * OpenClaw plugin API using shared init closures.
+ */
+function wirePluginHandlers(
+  api: OpenClawPluginApi,
+  deps: LcmDependencies,
+  shared: SharedLcmInit,
+): void {
+  api.on("before_reset", async (event, ctx) => {
+    await (await shared.waitForEngine()).handleBeforeReset({
+      reason: event.reason,
+      sessionId: ctx.sessionId,
+      sessionKey: ctx.sessionKey,
+    });
+  });
+  api.on("before_prompt_build", () => ({
+    prependSystemContext: LOSSLESS_RECALL_POLICY_PROMPT,
+  }));
+  api.on("session_end", async (event) => {
+    const lifecycleEvent = event as SessionEndLifecycleEvent;
+    await (await shared.waitForEngine()).handleSessionEnd({
+      reason: lifecycleEvent.reason,
+      sessionId: lifecycleEvent.sessionId,
+      sessionKey: lifecycleEvent.sessionKey,
+      nextSessionId: lifecycleEvent.nextSessionId,
+      nextSessionKey: lifecycleEvent.nextSessionKey,
+    });
+  });
+
+  api.registerContextEngine("lossless-claw", () => shared.getCachedEngine() ?? shared.waitForEngine());
+  api.registerContextEngine("default", () => shared.getCachedEngine() ?? shared.waitForEngine());
+
+  api.registerTool((ctx) =>
+    createLcmGrepTool({ deps, getLcm: shared.waitForEngine, sessionKey: ctx.sessionKey }),
+  );
+  api.registerTool((ctx) =>
+    createLcmDescribeTool({ deps, getLcm: shared.waitForEngine, sessionKey: ctx.sessionKey }),
+  );
+  api.registerTool((ctx) =>
+    createLcmExpandTool({ deps, getLcm: shared.waitForEngine, sessionKey: ctx.sessionKey }),
+  );
+  api.registerTool((ctx) =>
+    createLcmExpandQueryTool({
+      deps,
+      getLcm: shared.waitForEngine,
+      sessionKey: ctx.sessionKey,
+      requesterSessionKey: ctx.sessionKey,
+    }),
+  );
+
+  api.registerCommand(
+    createLcmCommand({ db: shared.waitForDatabase, config: deps.config, deps }),
+  );
+}
+
 const lcmPlugin = {
   id: "lossless-claw",
   name: "Lossless Context Management",
@@ -1563,82 +1768,192 @@ const lcmPlugin = {
 
   register(api: OpenClawPluginApi) {
     const deps = createLcmDependencies(api);
-    const database = createLcmDatabaseConnection(deps.config.databasePath);
-    const lcm = new LcmContextEngine(deps, database);
-
-    api.on("before_reset", async (event, ctx) => {
-      await lcm.handleBeforeReset({
-        reason: event.reason,
-        sessionId: ctx.sessionId,
-        sessionKey: ctx.sessionKey,
+    const dbPath = deps.config.databasePath;
+    const normalizedDbPath = normalizePath(dbPath);
+
+    // ── Singleton check ─────────────────────────────────────────────
+    // OpenClaw v2026.4.5+ calls register() per-agent-context (main,
+    // subagents, cron lanes). Reuse the existing connection and engine
+    // when the same DB path is already initialized.
+    const existingInit = getSharedInit(normalizedDbPath);
+    if (existingInit && !existingInit.stopped) {
+      wirePluginHandlers(api, deps, existingInit);
+      return;
+    }
+
+    // ── Eager-first DB init with deferred fallback on lock ──────────
+    let database: DatabaseSync | null = null;
+    let lcm: LcmContextEngine | null = null;
+    let initPromise: Promise<LcmContextEngine> | null = null;
+    let initError: Error | null = null;
+    let resolveDeferredInit: ((engine: LcmContextEngine) => void) | null = null;
+    let rejectDeferredInit: ((error: Error) => void) | null = null;
+    let stopped = false;
+
+    /** Normalize unknown failures into stable Error instances. */
+    function toInitError(error: unknown): Error {
+      return error instanceof Error ? error : new Error(String(error));
+    }
+
+    /** Build a live DB+engine pair and roll back the DB handle if engine init fails. */
+    function initializeEngine(): LcmContextEngine {
+      const nextDatabase = createLcmDatabaseConnection(dbPath);
+      try {
+        const nextEngine = new LcmContextEngine(deps, nextDatabase);
+        database = nextDatabase;
+        lcm = nextEngine;
+        initError = null;
+        return nextEngine;
+      } catch (error) {
+        closeLcmConnection(nextDatabase);
+        throw error;
+      }
+    }
+
+    /** Keep one shared deferred init promise so early callers all await the same retry. */
+    function ensureDeferredInitPromise(): Promise<LcmContextEngine> {
+      if (initPromise) {
+        return initPromise;
+      }
+
+      initPromise = new Promise<LcmContextEngine>((resolve, reject) => {
+        resolveDeferredInit = resolve;
+        rejectDeferredInit = reject;
       });
-    });
-    api.on("before_prompt_build", () => ({
-      prependSystemContext: LOSSLESS_RECALL_POLICY_PROMPT,
-    }));
-    api.on("session_end", async (event) => {
-      const lifecycleEvent = event as SessionEndLifecycleEvent;
-      await lcm.handleSessionEnd({
-        reason: lifecycleEvent.reason,
-        sessionId: lifecycleEvent.sessionId,
-        sessionKey: lifecycleEvent.sessionKey,
-        nextSessionId: lifecycleEvent.nextSessionId,
-        nextSessionKey: lifecycleEvent.nextSessionKey,
+      initPromise.catch(() => {});
+      return initPromise;
+    }
+
+    /** Resolve the shared deferred init promise exactly once. */
+    function resolveDeferredEngine(nextEngine: LcmContextEngine): void {
+      const resolve = resolveDeferredInit;
+      resolveDeferredInit = null;
+      rejectDeferredInit = null;
+      resolve?.(nextEngine);
+    }
+
+    /** Reject the shared deferred init promise exactly once and retain the root cause. */
+    function rejectDeferredEngine(error: Error): void {
+      initError = error;
+      const reject = rejectDeferredInit;
+      resolveDeferredInit = null;
+      rejectDeferredInit = null;
+      reject?.(error);
+    }
+
+    /** Return the initialized engine, waiting for deferred startup when the DB is lock-contended. */
+    async function waitForEngine(): Promise<LcmContextEngine> {
+      if (stopped) {
+        throw new Error("[lcm] Database connection closed after gateway_stop");
+      }
+      if (initError) {
+        throw initError;
+      }
+      if (lcm) {
+        return lcm;
+      }
+      if (initPromise) {
+        return initPromise;
+      }
+
+      try {
+        const nextEngine = initializeEngine();
+        initPromise = Promise.resolve(nextEngine);
+        return nextEngine;
+      } catch (error) {
+        const normalized = toInitError(error);
+        if (!/database is locked/i.test(normalized.message)) {
+          initError = normalized;
+          throw normalized;
+        }
+
+        deps.log.warn("[lcm] DB locked during eager init, deferring to gateway_start");
+        return ensureDeferredInitPromise();
+      }
+    }
+
+    /** Return the initialized DB handle, sharing the same wait/error semantics as the engine. */
+    async function waitForDatabase(): Promise<DatabaseSync> {
+      await waitForEngine();
+      if (!database) {
+        throw initError ?? new Error("[lcm] Database initialization finished without a handle");
+      }
+      return database;
+    }
+
+    try {
+      const nextEngine = initializeEngine();
+      initPromise = Promise.resolve(nextEngine);
+    } catch (error) {
+      const normalized = toInitError(error);
+      if (!/database is locked/i.test(normalized.message)) {
+        initError = normalized;
+        throw normalized;
+      }
+
+      deps.log.warn("[lcm] DB locked during eager init, deferring to gateway_start");
+      ensureDeferredInitPromise();
+      api.on("gateway_start", async () => {
+        if (stopped || lcm || initError) {
+          return;
+        }
+        try {
+          const nextEngine = initializeEngine();
+          initPromise = Promise.resolve(nextEngine);
+          resolveDeferredEngine(nextEngine);
+        } catch (retryError) {
+          const normalizedRetryError = toInitError(retryError);
+          rejectDeferredEngine(normalizedRetryError);
+          deps.log.error(`[lcm] Deferred DB init failed: ${normalizedRetryError.message}`);
+        }
       });
+    }
+
+    const shared: SharedLcmInit = {
+      stopped: false,
+      getCachedEngine: () => lcm,
+      waitForEngine,
+      waitForDatabase,
+    };
+    setSharedInit(normalizedDbPath, shared);
+
+    api.on("gateway_stop", async () => {
+      stopped = true;
+      shared.stopped = true;
+      if (!lcm && !database) {
+        rejectDeferredEngine(new Error("[lcm] Database connection closed after gateway_stop"));
+      }
+      if (database) {
+        closeLcmConnection(database);
+        database = null;
+      }
+      lcm = null;
+      removeSharedInit(normalizedDbPath);
     });
-    api.registerContextEngine("lossless-claw", () => lcm);
-    api.registerContextEngine("default", () => lcm);
-    api.registerTool((ctx) =>
-      createLcmGrepTool({
-        deps,
-        lcm,
-        sessionKey: ctx.sessionKey,
-      }),
-    );
-    api.registerTool((ctx) =>
-      createLcmDescribeTool({
-        deps,
-        lcm,
-        sessionKey: ctx.sessionKey,
-      }),
-    );
-    api.registerTool((ctx) =>
-      createLcmExpandTool({
-        deps,
-        lcm,
-        sessionKey: ctx.sessionKey,
-      }),
-    );
-    api.registerTool((ctx) =>
-      createLcmExpandQueryTool({
-        deps,
-        lcm,
-        sessionKey: ctx.sessionKey,
-        requesterSessionKey: ctx.sessionKey,
-      }),
-    );
-    api.registerCommand(
-      createLcmCommand({
-        db: database,
-        config: deps.config,
-        deps,
-      }),
-    );
+
+    wirePluginHandlers(api, deps, shared);
 
     logStartupBannerOnce({
       key: "plugin-loaded",
-      log: (message) => console.error(message),
+      log: (message) => deps.log.info(message),
       message: `[lcm] Plugin loaded (enabled=${deps.config.enabled}, db=${deps.config.databasePath}, threshold=${deps.config.contextThreshold})`,
     });
     logStartupBannerOnce({
       key: "compaction-model",
-      log: (message) => console.error(message),
+      log: (message) => deps.log.info(message),
       message: buildCompactionModelLog({
         config: deps.config,
         openClawConfig: api.config,
         defaultProvider: process.env.OPENCLAW_PROVIDER?.trim() ?? "",
       }),
     });
+    if (deps.config.fallbackProviders.length > 0) {
+      logStartupBannerOnce({
+        key: "fallback-providers",
+        log: (message) => deps.log.info(message),
+        message: `[lcm] Fallback providers: ${deps.config.fallbackProviders.map((fp) => `${fp.provider}/${fp.model}`).join(", ")}`,
+      });
+    }
   },
 };