@memtensor/memos-local-openclaw-plugin 1.0.4-beta.6 → 1.0.4-beta.7

package/src/hub/user-manager.ts

@@ -0,0 +1,143 @@
+import { randomUUID, createHash } from "crypto";
+import { issueUserToken, verifyUserToken } from "./auth";
+import type { Logger } from "../types";
+import type { UserInfo } from "../sharing/types";
+import type { SqliteStore } from "../storage/sqlite";
+
+type ManagedHubUser = UserInfo & { tokenHash: string; createdAt: number; approvedAt: number | null; lastIp: string; lastActiveAt: number | null };
+
+export class HubUserManager {
+  constructor(private store: SqliteStore, private log: Logger) {}
+
+  createPendingUser(input: { username: string; deviceName?: string }): ManagedHubUser {
+    const user = {
+      id: randomUUID(),
+      username: input.username,
+      deviceName: input.deviceName,
+      role: "member" as const,
+      status: "pending" as const,
+      groups: [],
+      tokenHash: "",
+      createdAt: Date.now(),
+      approvedAt: null,
+      lastIp: "",
+      lastActiveAt: null,
+    };
+    this.store.upsertHubUser(user);
+    return user;
+  }
+
+  listPendingUsers(): ManagedHubUser[] {
+    return this.store.listHubUsers("pending");
+  }
+
+  approveUser(userId: string, token: string): ManagedHubUser | null {
+    const user = this.store.getHubUser(userId);
+    if (!user) return null;
+    const updated = {
+      ...user,
+      status: "active" as const,
+      tokenHash: createHash("sha256").update(token).digest("hex"),
+      approvedAt: Date.now(),
+    };
+    this.store.upsertHubUser(updated);
+    return updated;
+  }
+
+  ensureBootstrapAdmin(secret: string, username = "admin", bootstrapUserId?: string, bootstrapToken?: string): { user: ManagedHubUser; token: string } {
+    if (bootstrapUserId) {
+      const bootstrapUser = this.store.getHubUser(bootstrapUserId);
+      if (bootstrapUser && bootstrapUser.role === "admin" && bootstrapUser.status === "active") {
+        if (bootstrapToken && bootstrapUser.tokenHash === createHash("sha256").update(bootstrapToken).digest("hex") && verifyUserToken(bootstrapToken, secret)) {
+          return { user: bootstrapUser, token: bootstrapToken };
+        }
+        const refreshedToken = issueUserToken(
+          { userId: bootstrapUser.id, username: bootstrapUser.username, role: bootstrapUser.role, status: bootstrapUser.status },
+          secret,
+          3650 * 24 * 60 * 60 * 1000,
+        );
+        const refreshedUser: ManagedHubUser = {
+          ...bootstrapUser,
+          tokenHash: createHash("sha256").update(refreshedToken).digest("hex"),
+        };
+        this.store.upsertHubUser(refreshedUser);
+        return { user: refreshedUser, token: refreshedToken };
+      }
+    }
+
+    const existing = this.store.listHubUsers().find((user) => user.role === "admin" && user.status === "active");
+    if (existing) {
+      const refreshedToken = issueUserToken(
+        { userId: existing.id, username: existing.username, role: existing.role, status: existing.status },
+        secret,
+        3650 * 24 * 60 * 60 * 1000,
+      );
+      const refreshedUser: ManagedHubUser = {
+        ...existing,
+        tokenHash: createHash("sha256").update(refreshedToken).digest("hex"),
+      };
+      this.store.upsertHubUser(refreshedUser);
+      return { user: refreshedUser, token: refreshedToken };
+    }
+
+    const user: ManagedHubUser = {
+      id: randomUUID(),
+      username,
+      deviceName: "hub",
+      role: "admin",
+      status: "active",
+      groups: [],
+      tokenHash: "",
+      createdAt: Date.now(),
+      approvedAt: Date.now(),
+      lastIp: "",
+      lastActiveAt: null,
+    };
+    const token = issueUserToken(
+      { userId: user.id, username: user.username, role: user.role, status: user.status },
+      secret,
+      3650 * 24 * 60 * 60 * 1000,
+    );
+    user.tokenHash = createHash("sha256").update(token).digest("hex");
+    this.store.upsertHubUser(user);
+    return { user, token };
+  }
+
+  isUsernameTaken(username: string, excludeUserId?: string): boolean {
+    const users = this.store.listHubUsers();
+    return users.some(u => u.username === username && u.id !== excludeUserId);
+  }
+
+  updateUsername(userId: string, newUsername: string): ManagedHubUser | null {
+    const user = this.store.getHubUser(userId);
+    if (!user) return null;
+    const updated = { ...user, username: newUsername };
+    this.store.upsertHubUser(updated);
+    return updated;
+  }
+
+  rejectUser(userId: string): ManagedHubUser | null {
+    const user = this.store.getHubUser(userId);
+    if (!user) return null;
+    const updated = {
+      ...user,
+      status: "rejected" as const,
+      approvedAt: Date.now(),
+    };
+    this.store.upsertHubUser(updated);
+    return updated;
+  }
+
+  resetToPending(userId: string): ManagedHubUser | null {
+    const user = this.store.getHubUser(userId);
+    if (!user) return null;
+    const updated = {
+      ...user,
+      status: "pending" as const,
+      tokenHash: "",
+      approvedAt: null,
+    };
+    this.store.upsertHubUser(updated);
+    return updated;
+  }
+}

package/src/index.ts

@@ -6,8 +6,9 @@ import { Embedder } from "./embedding";
 import { IngestWorker } from "./ingest/worker";
 import { RecallEngine } from "./recall/engine";
 import { captureMessages } from "./capture";
-import { createMemorySearchTool, createMemoryTimelineTool, createMemoryGetTool } from "./tools";
+import { createMemorySearchTool, createMemoryTimelineTool, createMemoryGetTool, createNetworkMemoryDetailTool } from "./tools";
 import type { MemosLocalConfig, ToolDefinition, Logger } from "./types";
+import type { HostModelsConfig } from "./openclaw-api";
 
 export interface MemosLocalPlugin {
   id: string;
@@ -23,6 +24,7 @@ export interface PluginInitOptions {
   workspaceDir?: string;
   config?: Partial<MemosLocalConfig>;
   log?: Logger;
+  hostModels?: HostModelsConfig;
 }
 
 /**
@@ -51,21 +53,24 @@ export interface PluginInitOptions {
 export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
   const stateDir = opts.stateDir ?? defaultStateDir();
   const workspaceDir = opts.workspaceDir ?? process.cwd();
-  const ctx = buildContext(stateDir, workspaceDir, opts.config, opts.log);
+  const ctx = buildContext(stateDir, workspaceDir, opts.config, opts.log, opts.hostModels);
 
   ctx.log.info("Initializing memos-local plugin...");
 
   ensureSqliteBinding(ctx.log);
 
   const store = new SqliteStore(ctx.config.storage!.dbPath!, ctx.log);
-  const embedder = new Embedder(ctx.config.embedding, ctx.log);
+  const embedder = new Embedder(ctx.config.embedding, ctx.log, ctx.openclawAPI);
   const worker = new IngestWorker(store, embedder, ctx);
   const engine = new RecallEngine(store, embedder, ctx);
 
+  const sharedState = { lastSearchTime: 0 };
+
   const tools: ToolDefinition[] = [
-    createMemorySearchTool(engine),
+    createMemorySearchTool(engine, store, ctx, sharedState),
     createMemoryTimelineTool(store),
     createMemoryGetTool(store),
+    createNetworkMemoryDetailTool(store, ctx),
   ];
 
   ctx.log.info(`Plugin ready. DB: ${ctx.config.storage!.dbPath}, Embedding: ${embedder.provider}`);
@@ -84,7 +89,10 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
       const turnId = uuid();
       const tag = ctx.config.capture?.evidenceWrapperTag ?? "STORED_MEMORY";
 
-      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner);
+      const userSearchTime = sharedState.lastSearchTime || 0;
+      sharedState.lastSearchTime = 0;
+
+      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner, userSearchTime);
       if (captured.length > 0) {
         worker.enqueue(captured);
       }

package/src/ingest/providers/index.ts

@@ -1,47 +1,13 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, SummaryProvider, Logger } from "../../types";
-import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI } from "./openai";
+import type { SummarizerConfig, Logger, OpenClawAPI } from "../../types";
+import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI, parseFilterResult, parseDedupResult } from "./openai";
 import type { FilterResult, DedupResult } from "./openai";
 export type { FilterResult, DedupResult } from "./openai";
 import { summarizeAnthropic, summarizeTaskAnthropic, generateTaskTitleAnthropic, judgeNewTopicAnthropic, filterRelevantAnthropic, judgeDedupAnthropic } from "./anthropic";
 import { summarizeGemini, summarizeTaskGemini, generateTaskTitleGemini, judgeNewTopicGemini, filterRelevantGemini, judgeDedupGemini } from "./gemini";
 import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judgeNewTopicBedrock, filterRelevantBedrock, judgeDedupBedrock } from "./bedrock";
 
-/**
- * Detect provider type from provider key name or base URL.
- */
-function detectProvider(
-  providerKey: string | undefined,
-  baseUrl: string,
-): SummaryProvider {
-  const key = providerKey?.toLowerCase() ?? "";
-  const url = baseUrl.toLowerCase();
-  if (key.includes("anthropic") || url.includes("anthropic")) return "anthropic";
-  if (key.includes("gemini") || url.includes("generativelanguage.googleapis.com")) {
-    return "gemini";
-  }
-  if (key.includes("bedrock") || url.includes("bedrock")) return "bedrock";
-  return "openai_compatible";
-}
-
-/**
- * Return the correct endpoint for a given provider and base URL.
- */
-function normalizeEndpointForProvider(
-  provider: SummaryProvider,
-  baseUrl: string,
-): string {
-  const stripped = baseUrl.replace(/\/+$/, "");
-  if (provider === "anthropic") {
-    if (stripped.endsWith("/v1/messages")) return stripped;
-    return `${stripped}/v1/messages`;
-  }
-  if (stripped.endsWith("/chat/completions")) return stripped;
-  if (stripped.endsWith("/completions")) return stripped;
-  return `${stripped}/chat/completions`;
-}
-
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
  * This serves as the final fallback when both strongCfg and plugin summarizer fail or are absent.
@@ -49,8 +15,7 @@ function normalizeEndpointForProvider(
 function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
   try {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const ocHome = process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw");
-    const cfgPath = path.join(ocHome, "openclaw.json");
+    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
     if (!fs.existsSync(cfgPath)) return undefined;
 
     const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
@@ -71,12 +36,13 @@ function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const provider = detectProvider(providerKey, baseUrl);
-    const endpoint = normalizeEndpointForProvider(provider, baseUrl);
+    const endpoint = baseUrl.endsWith("/chat/completions")
+      ? baseUrl
+      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
     return {
-      provider,
+      provider: "openai_compatible",
       endpoint,
       apiKey,
       model: modelId,
@@ -154,6 +120,7 @@ export class Summarizer {
   constructor(
     private cfg: SummarizerConfig | undefined,
     private log: Logger,
+    private openclawAPI?: OpenClawAPI,
     strongCfg?: SummarizerConfig,
   ) {
     this.strongCfg = strongCfg;
@@ -163,11 +130,20 @@ export class Summarizer {
   /**
    * Ordered config chain: strongCfg → cfg → fallbackCfg (OpenClaw native model).
    * Returns configs that are defined, in priority order.
+   * Openclaw configs without hostCompletion capability or without openclawAPI are excluded.
    */
   private getConfigChain(): SummarizerConfig[] {
     const chain: SummarizerConfig[] = [];
     if (this.strongCfg) chain.push(this.strongCfg);
-    if (this.cfg) chain.push(this.cfg);
+    if (this.cfg) {
+      if (this.cfg.provider === "openclaw") {
+        if (this.cfg.capabilities?.hostCompletion === true && this.openclawAPI) {
+          chain.push(this.cfg);
+        }
+      } else {
+        chain.push(this.cfg);
+      }
+    }
     if (this.fallbackCfg) chain.push(this.fallbackCfg);
     return chain;
   }
@@ -251,7 +227,9 @@ export class Summarizer {
       return taskFallback(text);
     }
 
-    const result = await this.tryChain("summarizeTask", (cfg) => callSummarizeTask(cfg, text, this.log));
+    const result = await this.tryChain("summarizeTask", (cfg) =>
+      cfg.provider === "openclaw" ? this.summarizeTaskOpenClaw(text) : callSummarizeTask(cfg, text, this.log),
+    );
     return result ?? taskFallback(text);
   }
 
@@ -290,7 +268,11 @@ export class Summarizer {
     if (!this.cfg && !this.fallbackCfg) return null;
     if (candidates.length === 0) return { relevant: [], sufficient: true };
 
-    const result = await this.tryChain("filterRelevant", (cfg) => callFilterRelevant(cfg, query, candidates, this.log));
+    const result = await this.tryChain("filterRelevant", (cfg) =>
+      cfg.provider === "openclaw"
+        ? this.filterRelevantOpenClaw(query, candidates)
+        : callFilterRelevant(cfg, query, candidates, this.log),
+    );
     return result ?? null;
   }
 
@@ -301,13 +283,144 @@ export class Summarizer {
     if (!this.cfg && !this.fallbackCfg) return null;
     if (candidates.length === 0) return null;
 
-    const result = await this.tryChain("judgeDedup", (cfg) => callJudgeDedup(cfg, newSummary, candidates, this.log));
+    const result = await this.tryChain("judgeDedup", (cfg) =>
+      cfg.provider === "openclaw"
+        ? this.judgeDedupOpenClaw(newSummary, candidates)
+        : callJudgeDedup(cfg, newSummary, candidates, this.log),
+    );
     return result ?? { action: "NEW", reason: "all_models_failed" };
   }
 
   getStrongConfig(): SummarizerConfig | undefined {
     return this.strongCfg;
   }
+
+  // ─── OpenClaw API Implementation ───
+
+  private requireOpenClawAPI(): void {
+    if (!this.openclawAPI) {
+      throw new Error(
+        "OpenClaw API not available. Ensure sharing.capabilities.hostCompletion is enabled in config."
+      );
+    }
+  }
+
+  private async summarizeOpenClaw(text: string): Promise<string> {
+    this.requireOpenClawAPI();
+    const prompt = [
+      `Summarize the text in ONE concise sentence (max 120 characters). IMPORTANT: Use the SAME language as the input text — if the input is Chinese, write Chinese; if English, write English. Preserve exact names, commands, error codes. No bullet points, no preamble — output only the sentence.`,
+      ``,
+      text.slice(0, 2000),
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 100,
+      temperature: 0,
+      model: this.cfg?.model,
+    });
+
+    return response.text.trim().slice(0, 200);
+  }
+
+  private async summarizeTaskOpenClaw(text: string): Promise<string> {
+    this.requireOpenClawAPI();
+    const prompt = [
+      OPENCLAW_TASK_SUMMARY_PROMPT,
+      ``,
+      text,
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 4096,
+      temperature: 0.1,
+      model: this.cfg?.model,
+    });
+
+    return response.text.trim();
+  }
+
+  private async judgeNewTopicOpenClaw(currentContext: string, newMessage: string): Promise<boolean> {
+    this.requireOpenClawAPI();
+    const prompt = [
+      OPENCLAW_TOPIC_JUDGE_PROMPT,
+      ``,
+      `CURRENT CONVERSATION SUMMARY:`,
+      currentContext,
+      ``,
+      `NEW USER MESSAGE:`,
+      newMessage,
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 10,
+      temperature: 0,
+      model: this.cfg?.model,
+    });
+
+    const answer = response.text.trim().toUpperCase();
+    this.log.debug(`Topic judge result: "${answer}"`);
+    return answer.startsWith("NEW");
+  }
+
+  private async filterRelevantOpenClaw(
+    query: string,
+    candidates: Array<{ index: number; role: string; content: string; time?: string }>,
+  ): Promise<FilterResult> {
+    this.requireOpenClawAPI();
+    const candidateText = candidates
+      .map((c) => `${c.index}. [${c.role}] ${c.content}`)
+      .join("\n");
+
+    const prompt = [
+      OPENCLAW_FILTER_RELEVANT_PROMPT,
+      ``,
+      `QUERY: ${query}`,
+      ``,
+      `CANDIDATES:`,
+      candidateText,
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 200,
+      temperature: 0,
+      model: this.cfg?.model,
+    });
+
+    return parseFilterResult(response.text.trim(), this.log);
+  }
+
+  private async judgeDedupOpenClaw(
+    newSummary: string,
+    candidates: Array<{ index: number; summary: string; chunkId: string }>,
+  ): Promise<DedupResult> {
+    this.requireOpenClawAPI();
+    const candidateText = candidates
+      .map((c) => `${c.index}. ${c.summary}`)
+      .join("\n");
+
+    const prompt = [
+      OPENCLAW_DEDUP_JUDGE_PROMPT,
+      ``,
+      `NEW MEMORY:`,
+      newSummary,
+      ``,
+      `EXISTING MEMORIES:`,
+      candidateText,
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 300,
+      temperature: 0,
+      model: this.cfg?.model,
+    });
+
+    return parseDedupResult(response.text.trim(), this.log);
+  }
 }
 
 // ─── Dispatch helpers ───
@@ -483,3 +596,90 @@ function wordCount(text: string): number {
   return count;
 }
 
+// ─── OpenClaw Prompt Templates ───
+
+const OPENCLAW_TASK_SUMMARY_PROMPT = `You create a DETAILED task summary from a multi-turn conversation. This summary will be the ONLY record of this conversation, so it must preserve ALL important information.
+
+CRITICAL LANGUAGE RULE: You MUST write in the SAME language as the user's messages. Chinese input → Chinese output. English input → English output. NEVER mix languages.
+
+Output EXACTLY this structure:
+
+📌 Title
+A short, descriptive title (10-30 characters). Like a chat group name.
+
+🎯 Goal
+One sentence: what the user wanted to accomplish.
+
+📋 Key Steps
+- Describe each meaningful step in detail
+- Include the ACTUAL content produced: code snippets, commands, config blocks, formulas, key paragraphs
+- For code: include the function signature and core logic (up to ~30 lines per block), use fenced code blocks
+- For configs: include the actual config values and structure
+- For lists/instructions: include the actual items, not just "provided a list"
+- Merge only truly trivial back-and-forth (like "ok" / "sure")
+- Do NOT over-summarize: "provided a function" is BAD; show the actual function
+
+✅ Result
+What was the final outcome? Include the final version of any code/config/content produced.
+
+💡 Key Details
+- Decisions made, trade-offs discussed, caveats noted, alternative approaches mentioned
+- Specific values: numbers, versions, thresholds, URLs, file paths, model names
+- Omit this section only if there truly are no noteworthy details
+
+RULES:
+- This summary is a KNOWLEDGE BASE ENTRY, not a brief note. Be thorough.
+- PRESERVE verbatim: code, commands, URLs, file paths, error messages, config values, version numbers, names, amounts
+- DISCARD only: greetings, filler, the assistant explaining what it will do before doing it
+- Replace secrets (API keys, tokens, passwords) with [REDACTED]
+- Target length: 30-50% of the original conversation length. Longer conversations need longer summaries.
+- Output summary only, no preamble.`;
+
+const OPENCLAW_TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given a summary of the CURRENT conversation and a NEW user message, determine if the new message starts a DIFFERENT topic/task.
+
+Answer ONLY "NEW" or "SAME".
+
+Rules:
+- "NEW" = the new message is about a completely different subject, project, or task
+- "SAME" = the new message continues, follows up on, or is closely related to the current topic
+- Follow-up questions, clarifications, refinements, bug fixes, or next steps on the same task = SAME
+- Greetings or meta-questions like "你好" or "谢谢" without new substance = SAME
+- A clearly unrelated request (e.g., current topic is deployment, new message asks about cooking) = NEW
+
+Output exactly one word: NEW or SAME`;
+
+const OPENCLAW_FILTER_RELEVANT_PROMPT = `You are a memory relevance judge. Given a user's QUERY and a list of CANDIDATE memory summaries, do two things:
+
+1. Select ALL candidates that could be useful for answering the query. When in doubt, INCLUDE the candidate.
+   - For questions about lists, history, or "what/where/who" across multiple items, include ALL matching items.
+   - For factual lookups, a single direct answer is enough.
+2. Judge whether the selected memories are SUFFICIENT to fully answer the query WITHOUT fetching additional context.
+
+IMPORTANT for "sufficient" judgment:
+- sufficient=true ONLY when the memories contain a concrete ANSWER, fact, decision, or actionable information that directly addresses the query.
+- sufficient=false when the memories only repeat the question, show related topics but lack the specific detail, or contain partial information.
+
+Output a JSON object with exactly two fields:
+{"relevant":[1,3,5],"sufficient":true}
+
+- "relevant": array of candidate numbers that are useful. Empty array [] if none are relevant.
+- "sufficient": true ONLY if the memories contain a direct answer; false otherwise.
+
+Output ONLY the JSON object, nothing else.`;
+
+const OPENCLAW_DEDUP_JUDGE_PROMPT = `You are a memory deduplication system. Given a NEW memory summary and several EXISTING memory summaries, determine the relationship.
+
+For each EXISTING memory, the NEW memory is either:
+- "DUPLICATE": NEW is fully covered by an EXISTING memory — no new information at all
+- "UPDATE": NEW contains information that supplements or updates an EXISTING memory (new data, status change, additional detail)
+- "NEW": NEW is a different topic/event despite surface similarity
+
+Pick the BEST match among all candidates. If none match well, choose "NEW".
+
+Output a single JSON object:
+- If DUPLICATE: {"action":"DUPLICATE","targetIndex":2,"reason":"..."}
+- If UPDATE: {"action":"UPDATE","targetIndex":3,"reason":"...","mergedSummary":"a combined summary preserving all info from both old and new, same language as input"}
+- If NEW: {"action":"NEW","reason":"..."}
+
+CRITICAL: mergedSummary must use the SAME language as the input. Output ONLY the JSON object.`;
+

package/src/ingest/providers/openai.ts

@@ -316,7 +316,7 @@ export async function filterRelevantOpenAI(
   return parseFilterResult(raw, log);
 }
 
-function parseFilterResult(raw: string, log: Logger): FilterResult {
+export function parseFilterResult(raw: string, log: Logger): FilterResult {
   try {
     const match = raw.match(/\{[\s\S]*\}/);
     if (match) {

package/src/ingest/task-processor.ts

@@ -39,7 +39,7 @@ export class TaskProcessor {
     private ctx: PluginContext,
   ) {
     const strongCfg = ctx.config.skillEvolution?.summarizer;
-    this.summarizer = new Summarizer(ctx.config.summarizer, ctx.log, strongCfg);
+    this.summarizer = new Summarizer(ctx.config.summarizer, ctx.log, ctx.openclawAPI, strongCfg);
   }
 
   onTaskCompleted(cb: (task: Task) => void): void {