@memtensor/memos-local-openclaw-plugin 0.3.19 → 1.0.0

package/src/shared/llm-call.ts

@@ -0,0 +1,144 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { SummarizerConfig, Logger, PluginContext } from "../types";
+
+/**
+ * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
+ * Final fallback when both strongCfg and plugin summarizer fail or are absent.
+ */
+export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
+  try {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    if (!fs.existsSync(cfgPath)) return undefined;
+
+    const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+
+    const agentModel: string | undefined = raw?.agents?.defaults?.model?.primary;
+    if (!agentModel) return undefined;
+
+    const [providerKey, modelId] = agentModel.includes("/")
+      ? agentModel.split("/", 2)
+      : [undefined, agentModel];
+
+    const providerCfg = providerKey
+      ? raw?.models?.providers?.[providerKey]
+      : Object.values(raw?.models?.providers ?? {})[0] as any;
+    if (!providerCfg) return undefined;
+
+    const baseUrl: string | undefined = providerCfg.baseUrl;
+    const apiKey: string | undefined = providerCfg.apiKey;
+    if (!baseUrl || !apiKey) return undefined;
+
+    const endpoint = baseUrl.endsWith("/chat/completions")
+      ? baseUrl
+      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    return {
+      provider: "openai_compatible",
+      endpoint,
+      apiKey,
+      model: modelId,
+    };
+  } catch (err) {
+    log.debug(`Failed to load OpenClaw fallback config: ${err}`);
+    return undefined;
+  }
+}
+
+/**
+ * Build the ordered fallback chain for skill-related LLM calls:
+ *   skillEvolution.summarizer → plugin summarizer → OpenClaw native model
+ */
+export function buildSkillConfigChain(ctx: PluginContext): SummarizerConfig[] {
+  const chain: SummarizerConfig[] = [];
+  const skillCfg = ctx.config.skillEvolution?.summarizer;
+  const pluginCfg = ctx.config.summarizer;
+  const fallbackCfg = loadOpenClawFallbackConfig(ctx.log);
+  if (skillCfg) chain.push(skillCfg);
+  if (pluginCfg && pluginCfg !== skillCfg) chain.push(pluginCfg);
+  if (fallbackCfg) chain.push(fallbackCfg);
+  return chain;
+}
+
+export interface LLMCallOptions {
+  maxTokens?: number;
+  temperature?: number;
+  timeoutMs?: number;
+}
+
+function normalizeEndpoint(url: string): string {
+  const stripped = url.replace(/\/+$/, "");
+  if (stripped.endsWith("/chat/completions")) return stripped;
+  if (stripped.endsWith("/completions")) return stripped;
+  return `${stripped}/chat/completions`;
+}
+
+/**
+ * Make a single LLM call with the given config. Throws on failure.
+ */
+export async function callLLMOnce(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeEndpoint(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",
+    Authorization: `Bearer ${cfg.apiKey}`,
+    ...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 { choices: Array<{ message: { content: string } }> };
+  return json.choices[0]?.message?.content?.trim() ?? "";
+}
+
+/**
+ * Call LLM with fallback chain: tries each config in order until one succeeds.
+ * Returns the result string, or throws if ALL configs fail.
+ */
+export async function callLLMWithFallback(
+  chain: SummarizerConfig[],
+  prompt: string,
+  log: Logger,
+  label: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  if (chain.length === 0) {
+    throw new Error(`${label}: no LLM config available`);
+  }
+
+  for (let i = 0; i < chain.length; i++) {
+    try {
+      return await callLLMOnce(chain[i], prompt, opts);
+    } catch (err) {
+      const modelInfo = `${chain[i].provider ?? "?"}/${chain[i].model ?? "?"}`;
+      if (i < chain.length - 1) {
+        log.warn(`${label} failed (${modelInfo}), trying next fallback: ${err}`);
+      } else {
+        log.error(`${label} failed (${modelInfo}), no more fallbacks: ${err}`);
+        throw err;
+      }
+    }
+  }
+  throw new Error(`${label}: all models failed`);
+}

package/src/skill/evaluator.ts

@@ -1,5 +1,6 @@
-import type { Chunk, Task, Skill, PluginContext, SummarizerConfig } from "../types";
+import type { Chunk, Task, Skill, PluginContext } from "../types";
 import { DEFAULTS } from "../types";
+import { buildSkillConfigChain, callLLMWithFallback } from "../shared/llm-call";
 
 export interface CreateEvalResult {
   shouldGenerate: boolean;
@@ -18,34 +19,45 @@ export interface UpgradeEvalResult {
   confidence: number;
 }
 
-const CREATE_EVAL_PROMPT = `You are an experience evaluation expert. Based on the completed task record below, decide whether this task contains reusable experience worth distilling into a "skill".
+const CREATE_EVAL_PROMPT = `You are a strict experience evaluation expert. Based on the completed task record below, decide whether this task contains **reusable, transferable** experience worth distilling into a "skill".
 
-A skill is a reusable guide that helps an AI agent handle similar tasks better in the future.
+A skill is a reusable guide that helps an AI agent handle **the same type of task** better in the future. The key question is: "Will someone likely need to do this exact type of thing again?"
 
-Worth distilling (any ONE qualifies):
-- Contains concrete steps, commands, code, or configuration
-- Solves a recurring problem with a specific approach/workflow
-- Went through trial-and-error (wrong approach then corrected)
+STRICT criteria — must meet ALL of:
+1. **Repeatable**: The task type is likely to recur (not a one-off personal conversation)
+2. **Transferable**: The approach/solution would help others facing the same problem
+3. **Technical depth**: Contains non-trivial steps, commands, code, configs, or diagnostic reasoning
+
+Worth distilling (must meet criteria above AND at least ONE below):
+- Solves a recurring technical problem with a specific approach/workflow
+- Went through trial-and-error (wrong approach then corrected) — the learning is valuable
 - Involves non-obvious usage of specific tools, APIs, or frameworks
 - Contains debugging/troubleshooting with diagnostic reasoning
-- Demonstrates a multi-step workflow using external tools (browser, search, file system, etc.)
-- Reveals user preferences or style requirements that should be remembered
-- Shows how to combine multiple tools/services to accomplish a goal
-- Contains a process that required specific parameter tuning or configuration
+- Shows how to combine multiple tools/services to accomplish a technical goal
+- Contains deployment, configuration, or infrastructure setup steps
+- Demonstrates a reusable data processing or automation pipeline
 
-NOT worth distilling:
+NOT worth distilling (if ANY matches, return shouldGenerate=false):
 - Pure factual Q&A with no process ("what is TCP", "what's the capital of France")
 - Single-turn simple answers with no workflow
 - Conversation too fragmented or incoherent to extract a clear process
+- One-off personal tasks: identity confirmation, preference setting, self-introduction
+- Casual chat, opinion discussion, news commentary, brainstorming without actionable output
+- Simple information lookup or summarization (e.g. "summarize this article", "explain X concept")
+- Organizing/listing personal information (work history, resume, contacts)
+- Generic product/system overviews without specific operational steps
+- Tasks where the "steps" are just the AI answering questions (no real workflow)
 
 Task title: {TITLE}
 Task summary:
 {SUMMARY}
 
+LANGUAGE RULE: The "reason" field MUST use the SAME language as the task title/summary. Chinese input → Chinese reason. English input → English reason. "suggestedName" stays in English kebab-case.
+
 Reply in JSON only, no extra text:
 {
   "shouldGenerate": boolean,
-  "reason": "brief explanation",
+  "reason": "brief explanation (same language as input)",
   "suggestedName": "kebab-case-name",
   "suggestedTags": ["tag1", "tag2"],
   "confidence": 0.0-1.0
@@ -80,13 +92,15 @@ NOT worth upgrading:
 - New task's approach is worse than existing skill
 - Differences are trivial
 
+LANGUAGE RULE: "reason" and "mergeStrategy" MUST use the SAME language as the task title/summary. Chinese input → Chinese output. English input → English output.
+
 Reply in JSON only, no extra text:
 {
   "shouldUpgrade": boolean,
   "upgradeType": "refine" | "extend" | "fix",
   "dimensions": ["faster", "more_elegant", "more_convenient", "fewer_tokens", "more_accurate", "more_robust", "new_scenario", "fix_outdated"],
-  "reason": "what new value the task brings",
-  "mergeStrategy": "which specific parts need updating",
+  "reason": "what new value the task brings (same language as input)",
+  "mergeStrategy": "which specific parts need updating (same language as input)",
   "confidence": 0.0-1.0
 }`;
 
@@ -121,8 +135,8 @@ export class SkillEvaluator {
   }
 
   async evaluateCreate(task: Task): Promise<CreateEvalResult> {
-    const cfg = this.getProviderConfig();
-    if (!cfg) {
+    const chain = buildSkillConfigChain(this.ctx);
+    if (chain.length === 0) {
       return { shouldGenerate: false, reason: "no LLM configured", suggestedName: "", suggestedTags: [], confidence: 0 };
     }
 
@@ -131,7 +145,7 @@ export class SkillEvaluator {
       .replace("{SUMMARY}", task.summary.slice(0, 3000));
 
     try {
-      const raw = await this.callLLM(cfg, prompt);
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvaluator.create");
       return this.parseJSON<CreateEvalResult>(raw, {
         shouldGenerate: false, reason: "parse failed", suggestedName: "", suggestedTags: [], confidence: 0,
       });
@@ -142,8 +156,8 @@ export class SkillEvaluator {
   }
 
   async evaluateUpgrade(task: Task, skill: Skill, skillContent: string): Promise<UpgradeEvalResult> {
-    const cfg = this.getProviderConfig();
-    if (!cfg) {
+    const chain = buildSkillConfigChain(this.ctx);
+    if (chain.length === 0) {
       return { shouldUpgrade: false, upgradeType: "refine", dimensions: [], reason: "no LLM configured", mergeStrategy: "", confidence: 0 };
     }
 
@@ -155,7 +169,7 @@ export class SkillEvaluator {
       .replace("{SUMMARY}", task.summary.slice(0, 3000));
 
     try {
-      const raw = await this.callLLM(cfg, prompt);
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvaluator.upgrade");
       return this.parseJSON<UpgradeEvalResult>(raw, {
         shouldUpgrade: false, upgradeType: "refine", dimensions: [], reason: "parse failed", mergeStrategy: "", confidence: 0,
       });
@@ -165,42 +179,6 @@ export class SkillEvaluator {
     }
   }
 
-  private getProviderConfig(): SummarizerConfig | undefined {
-    return this.ctx.config.summarizer;
-  }
-
-  private async callLLM(cfg: SummarizerConfig, userContent: string): Promise<string> {
-    const endpoint = this.normalizeEndpoint(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",
-      Authorization: `Bearer ${cfg.apiKey}`,
-      ...cfg.headers,
-    };
-
-    const resp = await fetch(endpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        model,
-        temperature: cfg.temperature ?? 0.1,
-        max_tokens: 1024,
-        messages: [
-          { role: "user", content: userContent },
-        ],
-      }),
-      signal: AbortSignal.timeout(cfg.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 { choices: Array<{ message: { content: string } }> };
-    return json.choices[0]?.message?.content?.trim() ?? "";
-  }
-
   private parseJSON<T>(raw: string, fallback: T): T {
     const jsonMatch = raw.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return fallback;
@@ -210,11 +188,4 @@ export class SkillEvaluator {
       return fallback;
     }
   }
-
-  private normalizeEndpoint(url: string): string {
-    const stripped = url.replace(/\/+$/, "");
-    if (stripped.endsWith("/chat/completions")) return stripped;
-    if (stripped.endsWith("/completions")) return stripped;
-    return `${stripped}/chat/completions`;
-  }
 }

package/src/skill/evolver.ts

@@ -3,12 +3,14 @@ import * as path from "path";
 import type { SqliteStore } from "../storage/sqlite";
 import type { RecallEngine } from "../recall/engine";
 import type { Embedder } from "../embedding";
+import { cosineSimilarity } from "../storage/vector";
 import type { Task, Skill, Chunk, PluginContext } from "../types";
 import { DEFAULTS } from "../types";
 import { SkillEvaluator } from "./evaluator";
 import { SkillGenerator } from "./generator";
 import { SkillUpgrader } from "./upgrader";
 import { SkillInstaller } from "./installer";
+import { buildSkillConfigChain, callLLMWithFallback } from "../shared/llm-call";
 
 export class SkillEvolver {
   private evaluator: SkillEvaluator;
@@ -16,12 +18,13 @@ export class SkillEvolver {
   private upgrader: SkillUpgrader;
   private installer: SkillInstaller;
   private processing = false;
+  private queue: Task[] = [];
 
   constructor(
     private store: SqliteStore,
     private engine: RecallEngine,
     private ctx: PluginContext,
-    embedder?: Embedder,
+    private embedder?: Embedder,
   ) {
     this.evaluator = new SkillEvaluator(ctx);
     this.generator = new SkillGenerator(store, engine, ctx, embedder);
@@ -29,25 +32,57 @@ export class SkillEvolver {
     this.installer = new SkillInstaller(store, ctx);
   }
 
+  async recoverOrphanedTasks(): Promise<number> {
+    const orphaned = this.store.getTasksBySkillStatus(["queued", "generating"]);
+    if (orphaned.length === 0) return 0;
+
+    this.ctx.log.info(`SkillEvolver: recovering ${orphaned.length} orphaned tasks (queued/generating from previous run)`);
+    for (const task of orphaned) {
+      try {
+        await this.processOne(task);
+      } catch (err) {
+        this.ctx.log.error(`SkillEvolver: recovery failed for task ${task.id}: ${err}`);
+      }
+    }
+    return orphaned.length;
+  }
+
   async onTaskCompleted(task: Task): Promise<void> {
     const enabled = this.ctx.config.skillEvolution?.enabled ?? DEFAULTS.skillEvolutionEnabled;
     const autoEval = this.ctx.config.skillEvolution?.autoEvaluate ?? DEFAULTS.skillAutoEvaluate;
     if (!enabled || !autoEval) return;
 
     if (this.processing) {
-      this.ctx.log.debug("SkillEvolver: already processing, skipping");
+      this.ctx.log.debug(`SkillEvolver: busy, queuing task ${task.id} (queue=${this.queue.length})`);
+      this.store.setTaskSkillMeta(task.id, { skillStatus: "queued", skillReason: `排队中，前方还有 ${this.queue.length + 1} 个任务` });
+      this.queue.push(task);
       return;
     }
+    await this.drain(task);
+  }
+
+  private async drain(task: Task): Promise<void> {
     this.processing = true;
     try {
-      await this.process(task);
-    } catch (err) {
-      this.ctx.log.error(`SkillEvolver error: ${err}`);
+      await this.processOne(task);
+      while (this.queue.length > 0) {
+        const next = this.queue.shift()!;
+        await this.processOne(next);
+      }
     } finally {
       this.processing = false;
     }
   }
 
+  private async processOne(task: Task): Promise<void> {
+    try {
+      await this.process(task);
+    } catch (err) {
+      this.ctx.log.error(`SkillEvolver error for task ${task.id}: ${err}`);
+      this.store.setTaskSkillMeta(task.id, { skillStatus: "skipped", skillReason: `Error: ${err}` });
+    }
+  }
+
   private async process(task: Task): Promise<void> {
     const chunks = this.store.getChunksByTask(task.id);
 
@@ -67,63 +102,196 @@ export class SkillEvolver {
     }
   }
 
+  /** Max candidates to send to LLM for relevance judgment. */
+  private static readonly RELATED_SKILL_CANDIDATE_TOP = 10;
+
+  /**
+   * Search for an existing skill that is HIGHLY related to the given task.
+   *
+   * 1. Collect top 50 skill candidates by FTS + vector similarity (relaxed thresholds).
+   * 2. Call LLM with task title/summary and each skill's name/description; strict rule:
+   *    only output ONE skill index if the task clearly belongs to that skill's domain;
+   *    otherwise output 0 (do not force a match).
+   */
   private async findRelatedSkill(task: Task): Promise<Skill | null> {
+    const query = task.summary.slice(0, 600);
+    const owner = task.owner ?? "agent:main";
+    // Relaxed thresholds to gather a larger candidate pool; LLM will do strict filtering
+    const VEC_FLOOR = 0.35;
+    const TOP_N = SkillEvolver.RELATED_SKILL_CANDIDATE_TOP;
+
+    type Candidate = { skill: Skill; vecScore: number; ftsScore: number; combined: number };
+    const candidateMap = new Map<string, Candidate>();
+
+    // 1. FTS on skill name + description (take more candidates)
     try {
-      const result = await this.engine.search({
-        query: task.summary.slice(0, 500),
-        maxResults: 10,
-        minScore: 0.5,
-      });
-
-      for (const hit of result.hits) {
-        if (hit.skillId) {
-          const skill = this.store.getSkill(hit.skillId);
-          if (skill && (skill.status === "active" || skill.status === "draft")) {
-            this.ctx.log.debug(`SkillEvolver: found related skill "${skill.name}" via memory search`);
-            return skill;
+      const ftsHits = this.store.skillFtsSearch(query, TOP_N, "mix", owner);
+      for (const hit of ftsHits) {
+        const skill = this.store.getSkill(hit.skillId);
+        if (skill && (skill.status === "active" || skill.status === "draft")) {
+          candidateMap.set(skill.id, { skill, vecScore: 0, ftsScore: hit.score, combined: 0 });
+        }
+      }
+    } catch (err) {
+      this.ctx.log.warn(`SkillEvolver: skill FTS search failed: ${err}`);
+    }
+
+    // 2. Vector similarity: include all skills above a low floor to rank them
+    if (this.embedder) {
+      try {
+        const queryVec = await this.embedder.embedQuery(query);
+        const allSkillEmb = this.store.getSkillEmbeddings("mix", owner);
+        for (const row of allSkillEmb) {
+          const sim = cosineSimilarity(queryVec, row.vector);
+          if (sim >= VEC_FLOOR) {
+            const existing = candidateMap.get(row.skillId);
+            if (existing) {
+              existing.vecScore = sim;
+            } else {
+              const skill = this.store.getSkill(row.skillId);
+              if (skill && (skill.status === "active" || skill.status === "draft")) {
+                candidateMap.set(skill.id, { skill, vecScore: sim, ftsScore: 0, combined: 0 });
+              }
+            }
           }
         }
+      } catch (err) {
+        this.ctx.log.warn(`SkillEvolver: skill vector search failed: ${err}`);
       }
+    }
+
+    if (candidateMap.size === 0) return null;
+
+    for (const c of candidateMap.values()) {
+      c.combined = c.vecScore * 0.7 + c.ftsScore * 0.3;
+    }
+
+    const sorted = [...candidateMap.values()]
+      .sort((a, b) => b.combined - a.combined)
+      .slice(0, TOP_N);
+
+    if (sorted.length === 0) return null;
+
+    // 3. LLM strict relevance judgment: only one skill if HIGHLY related, else none
+    const selectedSkill = await this.judgeSkillRelatedToTask(task, sorted);
+    if (selectedSkill) {
+      this.ctx.log.debug(`SkillEvolver: LLM selected related skill "${selectedSkill.name}" for task "${task.title}"`);
+    } else {
+      this.ctx.log.debug(`SkillEvolver: LLM found no highly related skill for task "${task.title}" (${sorted.length} candidates)`);
+    }
+    return selectedSkill;
+  }
+
+  /**
+   * Ask LLM to pick at most ONE skill that is HIGHLY relevant to the task.
+   * Strict rule: only return a skill if the task clearly belongs to that skill's domain; otherwise return null.
+   */
+  private async judgeSkillRelatedToTask(
+    task: Task,
+    candidates: Array<{ skill: Skill; vecScore: number; ftsScore: number; combined: number }>,
+  ): Promise<Skill | null> {
+    const chain = buildSkillConfigChain(this.ctx);
+    if (chain.length === 0) {
+      this.ctx.log.warn("SkillEvolver: no LLM config available, skipping skill relevance judgment");
+      return null;
+    }
+
+    const taskTitle = task.title || "(no title)";
+    const taskSummary = task.summary.slice(0, 800);
+    const skillList = candidates
+      .map((c, i) => `${i + 1}. [${c.skill.name}]\n   ${(c.skill.description || "").slice(0, 300)}`)
+      .join("\n\n");
+
+    const prompt = `You are a strict judge: decide whether a completed TASK should be merged into an EXISTING SKILL. The task and the skill must be in the SAME domain/topic — e.g. same type of problem, same tool, same workflow. Loose or tangential relevance is NOT enough.
+
+TASK TITLE: ${taskTitle}
+
+TASK SUMMARY:
+${taskSummary}
+
+CANDIDATE SKILLS (index, name, description):
+${skillList}
+
+RULES:
+- Output exactly ONE skill index (1 to ${candidates.length}) ONLY if the task's experience clearly belongs to that skill's domain. Same topic, same kind of work.
+- If no skill is clearly relevant (different domain, or only loosely related), output 0. When in doubt, output 0.
+- Do not force a match. "Movie recommendation" task must not match "Weather query" or "Legal discussion" skill even if both exist in the list.
+
+LANGUAGE RULE: "reason" MUST use the SAME language as the task title/summary. Chinese input → Chinese reason.
+
+Reply with JSON only, no other text:
+{"selectedIndex": 0, "reason": "brief explanation (same language as input)"}
+Use selectedIndex 0 when none is highly relevant.`;
+
+    try {
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvolver.judgeRelated", { temperature: 0, maxTokens: 256 });
+      const parsed = this.parseJudgeSkillResult(raw, candidates.length);
+      if (parsed.selectedIndex >= 1 && parsed.selectedIndex <= candidates.length) {
+        return candidates[parsed.selectedIndex - 1].skill;
+      }
+      return null;
     } catch (err) {
-      this.ctx.log.warn(`SkillEvolver: memory search for related skill failed: ${err}`);
+      this.ctx.log.warn(`SkillEvolver: LLM skill relevance judgment failed: ${err}`);
+      return null;
+    }
+  }
+
+  private parseJudgeSkillResult(raw: string, maxIndex: number): { selectedIndex: number; reason: string } {
+    const fallback = { selectedIndex: 0, reason: "parse failed" };
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match) return fallback;
+    try {
+      const obj = JSON.parse(match[0]) as { selectedIndex?: number; reason?: string };
+      const idx = typeof obj.selectedIndex === "number" ? obj.selectedIndex : 0;
+      const reason = typeof obj.reason === "string" ? obj.reason : "";
+      if (idx < 0 || idx > maxIndex) return { selectedIndex: 0, reason: reason || "out of range" };
+      return { selectedIndex: idx, reason };
+    } catch {
+      return fallback;
     }
-    return null;
   }
 
   private async handleExistingSkill(task: Task, chunks: Chunk[], skill: Skill): Promise<void> {
-    const skillContent = this.readSkillContent(skill);
+    // Verify skill still exists in DB (may have been manually deleted)
+    const freshSkill = this.store.getSkill(skill.id);
+    if (!freshSkill) {
+      this.ctx.log.warn(`SkillEvolver: skill "${skill.name}" (${skill.id}) no longer exists, treating as new`);
+      await this.handleNewSkill(task, chunks);
+      return;
+    }
+
+    const skillContent = this.readSkillContent(freshSkill);
     if (!skillContent) {
-      this.ctx.log.warn(`SkillEvolver: cannot read skill "${skill.name}" content, treating as new`);
+      this.ctx.log.warn(`SkillEvolver: cannot read skill "${freshSkill.name}" content, treating as new`);
       await this.handleNewSkill(task, chunks);
       return;
     }
 
     const minConfidence = this.ctx.config.skillEvolution?.minConfidence ?? DEFAULTS.skillMinConfidence;
-    const evalResult = await this.evaluator.evaluateUpgrade(task, skill, skillContent);
+    const evalResult = await this.evaluator.evaluateUpgrade(task, freshSkill, skillContent);
 
     if (evalResult.shouldUpgrade && evalResult.confidence >= minConfidence) {
-      this.ctx.log.info(`SkillEvolver: upgrading skill "${skill.name}" — ${evalResult.reason}`);
-      const { upgraded } = await this.upgrader.upgrade(task, skill, evalResult);
+      this.ctx.log.info(`SkillEvolver: upgrading skill "${freshSkill.name}" — ${evalResult.reason}`);
+      const { upgraded } = await this.upgrader.upgrade(task, freshSkill, evalResult);
 
-      this.markChunksWithSkill(chunks, skill.id);
+      this.markChunksWithSkill(chunks, freshSkill.id);
 
       if (upgraded) {
-        this.store.linkTaskSkill(task.id, skill.id, "evolved_from", skill.version + 1);
-        this.installer.syncIfInstalled(skill.name);
+        this.store.linkTaskSkill(task.id, freshSkill.id, "evolved_from", freshSkill.version + 1);
+        this.installer.syncIfInstalled(freshSkill.name);
       } else {
-        this.store.linkTaskSkill(task.id, skill.id, "applied_to", skill.version);
+        this.store.linkTaskSkill(task.id, freshSkill.id, "applied_to", freshSkill.version);
       }
     } else if (evalResult.confidence < 0.3) {
-      // Low confidence means the matched skill is likely unrelated — try creating a new one
       this.ctx.log.info(
-        `SkillEvolver: skill "${skill.name}" has low relevance (confidence=${evalResult.confidence}), ` +
+        `SkillEvolver: skill "${freshSkill.name}" has low relevance (confidence=${evalResult.confidence}), ` +
         `falling back to new skill evaluation for task "${task.title}"`,
       );
       await this.handleNewSkill(task, chunks);
     } else {
-      this.ctx.log.debug(`SkillEvolver: skill "${skill.name}" not worth upgrading (confidence=${evalResult.confidence})`);
-      this.markChunksWithSkill(chunks, skill.id);
-      this.store.linkTaskSkill(task.id, skill.id, "applied_to", skill.version);
+      this.ctx.log.debug(`SkillEvolver: skill "${freshSkill.name}" not worth upgrading (confidence=${evalResult.confidence})`);
+      this.markChunksWithSkill(chunks, freshSkill.id);
+      this.store.linkTaskSkill(task.id, freshSkill.id, "applied_to", freshSkill.version);
     }
   }