@memtensor/memos-local-openclaw-plugin 1.0.4-beta.1 → 1.0.4-beta.11

package/src/hub/user-manager.ts

@@ -1,16 +1,27 @@
 import { randomUUID, createHash } from "crypto";
-import { issueUserToken } from "./auth";
+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 };
+type ManagedHubUser = UserInfo & {
+  tokenHash: string;
+  createdAt: number;
+  approvedAt: number | null;
+  lastIp: string;
+  lastActiveAt: number | null;
+  identityKey?: string;
+  leftAt?: number | null;
+  removedAt?: number | null;
+  rejectedAt?: number | null;
+  rejoinRequestedAt?: number | null;
+};
 
 export class HubUserManager {
   constructor(private store: SqliteStore, private log: Logger) {}
 
-  createPendingUser(input: { username: string; deviceName?: string }): ManagedHubUser {
-    const user = {
+  createPendingUser(input: { username: string; deviceName?: string; identityKey?: string }): ManagedHubUser {
+    const user: ManagedHubUser = {
       id: randomUUID(),
       username: input.username,
       deviceName: input.deviceName,
@@ -20,11 +31,38 @@ export class HubUserManager {
       tokenHash: "",
       createdAt: Date.now(),
       approvedAt: null,
+      lastIp: "",
+      lastActiveAt: null,
+      identityKey: input.identityKey || "",
     };
     this.store.upsertHubUser(user);
     return user;
   }
 
+  findByIdentityKey(identityKey: string): ManagedHubUser | null {
+    if (!identityKey) return null;
+    return this.store.findHubUserByIdentityKey(identityKey);
+  }
+
+  markUserLeft(userId: string): boolean {
+    this.log.info(`Hub: user "${userId}" marked as left`);
+    return this.store.markHubUserLeft(userId);
+  }
+
+  rejoinUser(userId: string): ManagedHubUser | null {
+    const user = this.store.getHubUser(userId);
+    if (!user) return null;
+    const updated: ManagedHubUser = {
+      ...user,
+      status: "pending" as const,
+      tokenHash: "",
+      rejoinRequestedAt: Date.now(),
+    };
+    this.store.upsertHubUser(updated);
+    this.log.info(`Hub: user "${userId}" (${user.username}) requested rejoin, previous status: ${user.status}`);
+    return updated;
+  }
+
   listPendingUsers(): ManagedHubUser[] {
     return this.store.listHubUsers("pending");
   }
@@ -46,7 +84,7 @@ export class HubUserManager {
     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")) {
+        if (bootstrapToken && bootstrapUser.tokenHash === createHash("sha256").update(bootstrapToken).digest("hex") && verifyUserToken(bootstrapToken, secret)) {
           return { user: bootstrapUser, token: bootstrapToken };
         }
         const refreshedToken = issueUserToken(
@@ -88,6 +126,8 @@ export class HubUserManager {
       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 },
@@ -101,7 +141,7 @@ export class HubUserManager {
 
   isUsernameTaken(username: string, excludeUserId?: string): boolean {
     const users = this.store.listHubUsers();
-    return users.some(u => u.username === username && u.id !== excludeUserId);
+    return users.some(u => u.username === username && u.id !== excludeUserId && u.status !== "left" && u.status !== "removed");
   }
 
   updateUsername(userId: string, newUsername: string): ManagedHubUser | null {
@@ -115,10 +155,10 @@ export class HubUserManager {
   rejectUser(userId: string): ManagedHubUser | null {
     const user = this.store.getHubUser(userId);
     if (!user) return null;
-    const updated = {
+    const updated: ManagedHubUser = {
       ...user,
       status: "rejected" as const,
-      approvedAt: Date.now(),
+      rejectedAt: Date.now(),
     };
     this.store.upsertHubUser(updated);
     return updated;

package/src/index.ts

@@ -1,5 +1,6 @@
 import { v4 as uuid } from "uuid";
 import { buildContext } from "./config";
+import { ensureSqliteBinding } from "./storage/ensure-binding";
 import { SqliteStore } from "./storage/sqlite";
 import { Embedder } from "./embedding";
 import { IngestWorker } from "./ingest/worker";
@@ -56,13 +57,17 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
 
   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, 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, store, ctx),
+    createMemorySearchTool(engine, store, ctx, sharedState),
     createMemoryTimelineTool(store),
     createMemoryGetTool(store),
     createNetworkMemoryDetailTool(store, ctx),
@@ -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,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, OpenClawAPI } from "../../types";
+import type { SummarizerConfig, SummaryProvider, 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";
@@ -8,6 +8,40 @@ import { summarizeAnthropic, summarizeTaskAnthropic, generateTaskTitleAnthropic,
 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.
@@ -15,7 +49,8 @@ import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judge
 function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
   try {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    const ocHome = process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw");
+    const cfgPath = path.join(ocHome, "openclaw.json");
     if (!fs.existsSync(cfgPath)) return undefined;
 
     const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
@@ -36,13 +71,12 @@ function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = normalizeEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,

package/src/recall/engine.ts

@@ -74,10 +74,60 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
+    // Step 1c: Hub memories search (when sharing is enabled and hub_memories exist)
+    let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
+    let hubMemVecRanked: Array<{ id: string; score: number }> = [];
+    let hubMemPatternRanked: Array<{ id: string; score: number }> = [];
+    if (query && this.ctx.config.sharing?.enabled) {
+      try {
+        const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
+        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({
+          id: `hubmem:${hit.id}`, score: 1 / (i + 1),
+        }));
+      } catch { /* hub_memories table may not exist */ }
+      if (shortTerms.length > 0) {
+        try {
+          const hubPatternHits = this.store.hubMemoryPatternSearch(shortTerms, { limit: candidatePool });
+          hubMemPatternRanked = hubPatternHits.map((h, i) => ({
+            id: `hubmem:${h.memoryId}`, score: 1 / (i + 1),
+          }));
+        } catch { /* best-effort */ }
+      }
+      try {
+        const hubMemEmbs = this.store.getVisibleHubMemoryEmbeddings("");
+        if (hubMemEmbs.length > 0) {
+          const qv = await this.embedder.embedQuery(query).catch(() => null);
+          if (qv) {
+            const scored: Array<{ id: string; score: number }> = [];
+            for (const e of hubMemEmbs) {
+              let dot = 0, nA = 0, nB = 0;
+              for (let i = 0; i < qv.length && i < e.vector.length; i++) {
+                dot += qv[i] * e.vector[i]; nA += qv[i] * qv[i]; nB += e.vector[i] * e.vector[i];
+              }
+              const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
+              if (sim > 0.3) {
+                scored.push({ id: `hubmem:${e.memoryId}`, score: sim });
+              }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            hubMemVecRanked = scored.slice(0, candidatePool);
+          }
+        }
+      } catch { /* best-effort */ }
+      const hubTotal = hubMemFtsRanked.length + hubMemVecRanked.length + hubMemPatternRanked.length;
+      if (hubTotal > 0) {
+        this.ctx.log.debug(`recall: hub_memories candidates: fts=${hubMemFtsRanked.length}, vec=${hubMemVecRanked.length}, pattern=${hubMemPatternRanked.length}`);
+      }
+    }
+
     // Step 2: RRF fusion
     const ftsRanked = ftsCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
     const vecRanked = vecCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
-    const rrfScores = rrfFuse([ftsRanked, vecRanked, patternRanked], recallCfg.rrfK);
+    const allRankedLists = [ftsRanked, vecRanked, patternRanked];
+    if (hubMemFtsRanked.length > 0) allRankedLists.push(hubMemFtsRanked);
+    if (hubMemVecRanked.length > 0) allRankedLists.push(hubMemVecRanked);
+    if (hubMemPatternRanked.length > 0) allRankedLists.push(hubMemPatternRanked);
+    const rrfScores = rrfFuse(allRankedLists, recallCfg.rrfK);
 
     if (rrfScores.size === 0) {
       this.recordQuery(query, maxResults, minScore, 0);
@@ -101,6 +151,11 @@ export class RecallEngine {
 
     // Step 4: Time decay
     const withTs = mmrResults.map((r) => {
+      if (r.id.startsWith("hubmem:")) {
+        const memId = r.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        return { ...r, createdAt: mem?.createdAt ?? 0 };
+      }
       const chunk = this.store.getChunk(r.id);
       return { ...r, createdAt: chunk?.createdAt ?? 0 };
     });
@@ -128,6 +183,35 @@ export class RecallEngine {
     const hits: SearchHit[] = [];
     for (const candidate of normalized) {
       if (hits.length >= maxResults) break;
+
+      if (candidate.id.startsWith("hubmem:")) {
+        const memId = candidate.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        if (!mem) continue;
+        if (roleFilter && mem.role !== roleFilter) continue;
+        hits.push({
+          summary: mem.summary || mem.content.slice(0, 200),
+          original_excerpt: mem.content,
+          ref: {
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+            chunkId: mem.id,
+            turnId: "",
+            seq: 0,
+          },
+          score: Math.round(candidate.score * 1000) / 1000,
+          taskId: null,
+          skillId: null,
+          owner: `hub-user:${mem.sourceUserId}`,
+          origin: "hub-memory",
+          source: {
+            ts: mem.createdAt,
+            role: (mem.role || "assistant") as any,
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+          },
+        });
+        continue;
+      }
+
       const chunk = this.store.getChunk(candidate.id);
       if (!chunk) continue;
       if (roleFilter && chunk.role !== roleFilter) continue;
@@ -145,6 +229,7 @@ export class RecallEngine {
         score: Math.round(candidate.score * 1000) / 1000,
         taskId: chunk.taskId,
         skillId: chunk.skillId,
+        origin: chunk.owner === "public" ? "local-shared" : "local",
         source: {
           ts: chunk.createdAt,
           role: chunk.role,

package/src/shared/llm-call.ts

@@ -1,6 +1,34 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../types";
+import type { SummarizerConfig, SummaryProvider, Logger, PluginContext, OpenClawAPI } from "../types";
+
+/**
+ * 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 default endpoint for a given provider.
+ */
+function defaultEndpointForProvider(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).
@@ -30,13 +58,12 @@ export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | unde
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = defaultEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,
@@ -70,23 +97,34 @@ export interface LLMCallOptions {
   openclawAPI?: OpenClawAPI;
 }
 
-function normalizeEndpoint(url: string): string {
+function normalizeOpenAIEndpoint(url: string): string {
   const stripped = url.replace(/\/+$/, "");
   if (stripped.endsWith("/chat/completions")) return stripped;
   if (stripped.endsWith("/completions")) return stripped;
   return `${stripped}/chat/completions`;
 }
 
+function normalizeAnthropicEndpoint(url: string): string {
+  const stripped = url.replace(/\/+$/, "");
+  if (stripped.endsWith("/v1/messages")) return stripped;
+  if (stripped.endsWith("/messages")) return stripped;
+  return `${stripped}/v1/messages`;
+}
+
+function isAnthropicProvider(cfg: SummarizerConfig): boolean {
+  return cfg.provider === "anthropic";
+}
+
 /**
  * Make a single LLM call with the given config. Throws on failure.
  * When cfg.provider === "openclaw", delegates to the OpenClaw host completion API.
+ * Dispatches to Anthropic or OpenAI-compatible format based on provider.
  */
 export async function callLLMOnce(
   cfg: SummarizerConfig,
   prompt: string,
   opts: LLMCallOptions = {},
 ): Promise<string> {
-  // Handle openclaw provider via host completion API
   if (cfg.provider === "openclaw") {
     const api = opts.openclawAPI;
     if (!api) {
@@ -101,7 +139,57 @@ export async function callLLMOnce(
     return response.text.trim();
   }
 
-  const endpoint = normalizeEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
+  if (isAnthropicProvider(cfg)) {
+    return callLLMOnceAnthropic(cfg, prompt, opts);
+  }
+  return callLLMOnceOpenAI(cfg, prompt, opts);
+}
+
+async function callLLMOnceAnthropic(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeAnthropicEndpoint(
+    cfg.endpoint ?? "https://api.anthropic.com/v1/messages",
+  );
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      temperature: opts.temperature ?? 0.1,
+      max_tokens: opts.maxTokens ?? 1024,
+      messages: [{ role: "user", content: prompt }],
+    }),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? 30_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`LLM call failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  return json.content.find((c) => c.type === "text")?.text?.trim() ?? "";
+}
+
+async function callLLMOnceOpenAI(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeOpenAIEndpoint(
+    cfg.endpoint ?? "https://api.openai.com/v1/chat/completions",
+  );
   const model = cfg.model ?? "gpt-4o-mini";
   const headers: Record<string, string> = {
     "Content-Type": "application/json",

package/src/sharing/types.ts

@@ -12,7 +12,7 @@ import type {
 export type HubScope = "local" | "group" | "all";
 export type SharedVisibility = "group" | "public";
 export type UserRole = "admin" | "member";
-export type UserStatus = "pending" | "active" | "blocked" | "rejected";
+export type UserStatus = "pending" | "active" | "blocked" | "rejected" | "removed" | "left";
 
 export type { ClientModeConfig, HubModeConfig, SharingCapabilities, SharingConfig, SharingRole };
 

package/src/skill/evolver.ts

@@ -9,9 +9,11 @@ import { DEFAULTS } from "../types";
 import { SkillEvaluator } from "./evaluator";
 import { SkillGenerator } from "./generator";
 import { SkillUpgrader } from "./upgrader";
-import { SkillInstaller } from "./installer";
+import { SkillInstaller, type SkillInstallMode } from "./installer";
 import { buildSkillConfigChain, callLLMWithFallback } from "../shared/llm-call";
 
+export type SkillEvolvedCallback = (skillName: string, upgradeType: "created" | "upgraded") => void;
+
 export class SkillEvolver {
   private evaluator: SkillEvaluator;
   private generator: SkillGenerator;
@@ -19,6 +21,7 @@ export class SkillEvolver {
   private installer: SkillInstaller;
   private processing = false;
   private queue: Task[] = [];
+  onSkillEvolved: SkillEvolvedCallback | null = null;
 
   constructor(
     private store: SqliteStore,
@@ -93,10 +96,19 @@ export class SkillEvolver {
       return;
     }
 
+    const preferUpgrade = this.ctx.config.skillEvolution?.preferUpgradeExisting ?? DEFAULTS.skillPreferUpgrade;
     const relatedSkill = await this.findRelatedSkill(task);
 
     if (relatedSkill) {
       await this.handleExistingSkill(task, chunks, relatedSkill);
+    } else if (preferUpgrade) {
+      const nameCandidate = await this.findSkillByNameSimilarity(task);
+      if (nameCandidate) {
+        this.ctx.log.info(`SkillEvolver: preferUpgrade found name-similar skill "${nameCandidate.name}" for task "${task.title}"`);
+        await this.handleExistingSkill(task, chunks, nameCandidate);
+      } else {
+        await this.handleNewSkill(task, chunks);
+      }
     } else {
       await this.handleNewSkill(task, chunks);
     }
@@ -278,7 +290,12 @@ Use selectedIndex 0 when none is highly relevant.`;
 
       if (upgraded) {
         this.store.linkTaskSkill(task.id, freshSkill.id, "evolved_from", freshSkill.version + 1);
-        this.installer.syncIfInstalled(freshSkill.name);
+        if (freshSkill.installed) {
+          this.installer.syncIfInstalled(freshSkill.name);
+        } else {
+          this.autoInstallIfNeeded(freshSkill);
+        }
+        this.onSkillEvolved?.(freshSkill.name, "upgraded");
       } else {
         this.store.linkTaskSkill(task.id, freshSkill.id, "applied_to", freshSkill.version);
       }
@@ -300,6 +317,13 @@ Use selectedIndex 0 when none is highly relevant.`;
     const evalResult = await this.evaluator.evaluateCreate(task);
 
     if (evalResult.shouldGenerate && evalResult.confidence >= minConfidence) {
+      const existingByName = this.store.getSkillByName(evalResult.suggestedName);
+      if (existingByName && (existingByName.status === "active" || existingByName.status === "draft")) {
+        this.ctx.log.info(`SkillEvolver: skill "${evalResult.suggestedName}" already exists, redirecting to upgrade instead of create`);
+        await this.handleExistingSkill(task, chunks, existingByName);
+        return;
+      }
+
       this.ctx.log.info(`SkillEvolver: generating new skill "${evalResult.suggestedName}" — ${evalResult.reason}`);
       this.store.setTaskSkillMeta(task.id, { skillStatus: "generating", skillReason: evalResult.reason });
 
@@ -307,11 +331,9 @@ Use selectedIndex 0 when none is highly relevant.`;
       this.markChunksWithSkill(chunks, skill.id);
       this.store.linkTaskSkill(task.id, skill.id, "generated_from", 1);
       this.store.setTaskSkillMeta(task.id, { skillStatus: "generated", skillReason: evalResult.reason });
+      this.onSkillEvolved?.(skill.name, "created");
 
-      const autoInstall = this.ctx.config.skillEvolution?.autoInstall ?? DEFAULTS.skillAutoInstall;
-      if (autoInstall && skill.status === "active") {
-        this.installer.install(skill.id);
-      }
+      this.autoInstallIfNeeded(skill);
     } else {
       const reason = evalResult.reason || `confidence不足 (${evalResult.confidence} < ${minConfidence})`;
       this.ctx.log.debug(`SkillEvolver: task "${task.title}" not worth generating skill — ${reason}`);
@@ -326,6 +348,41 @@ Use selectedIndex 0 when none is highly relevant.`;
     this.ctx.log.debug(`SkillEvolver: marked ${chunks.length} chunks with skill_id=${skillId}`);
   }
 
+  private async findSkillByNameSimilarity(task: Task): Promise<Skill | null> {
+    const query = task.title.slice(0, 200);
+    const owner = task.owner ?? "agent:main";
+
+    try {
+      const ftsHits = this.store.skillFtsSearch(query, 5, "mix", owner);
+      for (const hit of ftsHits) {
+        if (hit.score < 0.5) continue;
+        const skill = this.store.getSkill(hit.skillId);
+        if (skill && (skill.status === "active" || skill.status === "draft")) {
+          return skill;
+        }
+      }
+    } catch { /* best-effort */ }
+
+    return null;
+  }
+
+  private autoInstallIfNeeded(skill: Skill): void {
+    if (skill.status !== "active") return;
+
+    const explicitAutoInstall = this.ctx.config.skillEvolution?.autoInstall ?? DEFAULTS.skillAutoInstall;
+    if (explicitAutoInstall) {
+      this.installer.install(skill.id);
+      this.ctx.log.info(`SkillEvolver: auto-installed "${skill.name}" (explicit autoInstall=true)`);
+      return;
+    }
+
+    const manifest = SkillInstaller.buildManifest(skill.dirPath, !!skill.installed, skill.name);
+    if (manifest.installMode === "install_recommended") {
+      this.installer.install(skill.id);
+      this.ctx.log.info(`SkillEvolver: auto-installed "${skill.name}" (install_recommended: ${manifest.scriptsCount} scripts, ${Math.round(manifest.totalSize / 1024)}KB)`);
+    }
+  }
+
   private readSkillContent(skill: Skill): string | null {
     const filePath = path.join(skill.dirPath, "SKILL.md");
     try {