assistme 0.2.9 → 0.3.0

package/dist/index.js

@@ -1651,7 +1651,7 @@ var SessionManager = class {
 
 // src/agent/processor.ts
 import {
-  query
+  query as query2
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/agent/memory.ts
@@ -1680,10 +1680,10 @@ var MemoryManager = class {
   /**
    * Search memories by query text. Uses ILIKE + tag containment.
    */
-  async search(query2, limit = 10) {
+  async search(query3, limit = 10) {
     try {
       return await callMcpHandler("memory.search", {
-        query: query2,
+        query: query3,
         limit
       });
     } catch (err) {
@@ -1902,6 +1902,8 @@ var SkillManager = class {
   skills = /* @__PURE__ */ new Map();
   idfCache = /* @__PURE__ */ new Map();
   userId = null;
+  /** Cache for findRelevant() — keyed by prompt, invalidated on skill changes */
+  relevanceCache = /* @__PURE__ */ new Map();
   DESCRIPTION_BUDGET_CHARS = 16e3;
   setUserId(userId) {
     this.userId = userId;
@@ -1939,9 +1941,15 @@ var SkillManager = class {
       filePath: "",
       source: row.source || "manual",
       dbId: row.id,
-      sourceSkillId: row.source_skill_id || void 0
+      sourceSkillId: row.source_skill_id || void 0,
+      invocationCount: row.invocation_count || 0
     };
   }
+  /** Invalidate caches when skills change (create, add, update, remove). */
+  invalidateCaches() {
+    this.relevanceCache.clear();
+    this.buildIdfCache();
+  }
   buildIdfCache() {
     this.idfCache.clear();
     const docFreq = /* @__PURE__ */ new Map();
@@ -1964,7 +1972,12 @@ var SkillManager = class {
     return this.skills.get(name);
   }
   findRelevant(prompt, maxResults = 3) {
-    const lower = prompt.toLowerCase();
+    const cacheKey = prompt.toLowerCase();
+    const cached = this.relevanceCache.get(cacheKey);
+    if (cached && cached.maxResults >= maxResults) {
+      return cached.results.slice(0, maxResults);
+    }
+    const lower = cacheKey;
     const promptTokens = tokenize(lower);
     const promptTokenSet = new Set(promptTokens);
     const idf = (word) => this.idfCache.get(word) || 1;
@@ -1991,18 +2004,39 @@ var SkillManager = class {
       }
       if (score > 0) scored.push({ skill, score });
     }
-    return scored.sort((a, b) => b.score - a.score).slice(0, maxResults).map((s) => s.skill);
+    const results = scored.sort((a, b) => b.score - a.score).slice(0, maxResults).map((s) => s.skill);
+    this.relevanceCache.set(cacheKey, { results, maxResults });
+    return results;
   }
-  buildSkillDescriptions() {
-    const skills = this.getAll().filter((s) => !s.disableModelInvocation).sort((a, b) => {
-      if (a.metadata.always && !b.metadata.always) return -1;
-      if (!a.metadata.always && b.metadata.always) return 1;
-      return a.description.length - b.description.length;
+  /**
+   * Build lightweight skill descriptions for the system prompt.
+   * When a taskPrompt is provided, relevant skills are prioritized to the top;
+   * remaining skills are sorted by usage frequency (invocationCount).
+   */
+  buildSkillDescriptions(taskPrompt) {
+    const all = this.getAll().filter((s) => !s.disableModelInvocation);
+    if (all.length === 0) return "";
+    const alwaysSkills = all.filter((s) => s.metadata.always);
+    const rest = all.filter((s) => !s.metadata.always);
+    let relevantNames = null;
+    if (taskPrompt) {
+      const relevant = this.findRelevant(taskPrompt, 10);
+      relevantNames = new Set(relevant.map((s) => s.name));
+    }
+    const sorted = rest.sort((a, b) => {
+      if (relevantNames) {
+        const aRelevant = relevantNames.has(a.name);
+        const bRelevant = relevantNames.has(b.name);
+        if (aRelevant && !bRelevant) return -1;
+        if (!aRelevant && bRelevant) return 1;
+      }
+      return (b.invocationCount || 0) - (a.invocationCount || 0);
     });
-    if (skills.length === 0) return "";
+    const skills = [...alwaysSkills, ...sorted];
     let budget = this.DESCRIPTION_BUDGET_CHARS;
     let prompt = "\n\n## Your Skills\n";
-    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n\n";
+    prompt += "These are your approved skills. Use skill_invoke to load full instructions when a task matches.\n";
+    prompt += "If no skill matches but the task is a reusable pattern, consider creating one with skill_create.\n\n";
     let included = 0;
     for (const skill of skills) {
       const emoji = skill.metadata.emoji || "";
@@ -2016,7 +2050,7 @@ var SkillManager = class {
     }
     if (included < skills.length) {
       prompt += `
-_(${skills.length - included} additional skills available \u2014 use skill_invoke to explore)_
+_(${skills.length - included} additional skills available \u2014 use skill_search to find more)_
 `;
     }
     return prompt;
@@ -2062,6 +2096,24 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       }
       const id = row.out_id || row.id;
       const skillName = row.out_name || row.name;
+      this.skills.set(skillName, {
+        name: skillName,
+        description,
+        version: "1.0.0",
+        userInvocable: true,
+        disableModelInvocation: false,
+        keywords: options?.keywords || [],
+        allowedTools: [],
+        argumentHint: "",
+        metadata: options?.emoji ? { emoji: options.emoji } : {},
+        homepage: "",
+        content,
+        filePath: "",
+        source: options?.source || "manual",
+        dbId: id,
+        invocationCount: 0
+      });
+      this.invalidateCaches();
       log.info(`Skill "${skillName}" created in skills table (pending approval)`);
       return { id, name: skillName };
     } catch (err) {
@@ -2086,7 +2138,7 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
         source_skill_id: skillId
       });
       this.skills.set(skill.name, skill);
-      this.buildIdfCache();
+      this.invalidateCaches();
       log.info(`Skill "${row.name}" added to user's collection`);
       return skill;
     } catch (err) {
@@ -2098,6 +2150,7 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     const skill = this.skills.get(name);
     if (!skill) return false;
     this.skills.delete(name);
+    this.invalidateCaches();
     this.removeFromDb(name).catch(() => {
     });
     return true;
@@ -2141,6 +2194,7 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     skill.content = newContent;
     skill.description = newDescription;
     skill.version = newVersion;
+    this.invalidateCaches();
     this.syncToAgentSkills(name, newDescription, newContent, newVersion, {
       source: "auto_improved"
     }).catch(() => {
@@ -2202,10 +2256,10 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       log.debug(`Invocation log error: ${err}`);
     }
   }
-  async searchDb(query2, limit = 10) {
+  async searchDb(query3, limit = 10) {
     if (this.userId) {
       try {
-        const data = await callMcpHandler("skill.search", { query: query2, limit });
+        const data = await callMcpHandler("skill.search", { query: query3, limit });
         if (data) {
           return data.map((row) => ({
             name: row.name,
@@ -2218,7 +2272,7 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       } catch {
       }
     }
-    const results = this.findRelevant(query2, limit);
+    const results = this.findRelevant(query3, limit);
     return results.map((s) => ({
       name: s.name,
       description: s.description,
@@ -2292,6 +2346,17 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     }
   }
 };
+function validateSkillName(name) {
+  if (!name || name.length === 0) return "name is empty";
+  if (name.length > 64) return `name too long (${name.length}/64 chars)`;
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    return `name must be lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens. Got: "${name}"`;
+  }
+  return null;
+}
+function normalizeSkillName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 64);
+}
 function substituteArguments(content, args) {
   const parts = args.split(/\s+/);
   content = content.replace(/\$ARGUMENTS/g, args);
@@ -2309,6 +2374,184 @@ function preprocessDynamicContext(content, cwd) {
   });
 }
 
+// src/agent/skill-evaluator.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+var SKILL_EVALUATION_PROMPT = `You just completed a task. Now evaluate whether it should be saved as a reusable Agent Skill.
+
+## Agent Skills Format (agentskills.io)
+
+A skill follows the SKILL.md format:
+- name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
+- description: 1-1024 chars, describe WHAT it does AND WHEN to use it, include searchable keywords
+- body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines, <5000 tokens.
+- Use generic placeholders (e.g. {url}, {query}, {product_name}) instead of specific values
+- Instructions should be a REUSABLE workflow, not a transcript of what just happened
+- Include error handling steps and tool references (browser_navigate, browser_read_page, Bash, Read, etc.)
+
+## Your Decision
+
+Respond with ONLY a JSON object (no markdown, no explanation outside the JSON). Choose one action:
+
+1. **"create"** \u2014 The task is a reusable workflow worth saving.
+   Include: name, description, instructions (full SKILL.md body), emoji, keywords (3-5, include Chinese if task was in Chinese)
+
+2. **"update"** \u2014 An existing skill should be improved based on what you just learned.
+   Include: existing_skill_name, improved_instructions (full updated body), improved_description (if changed)
+
+3. **"skip"** \u2014 Not worth capturing (simple Q&A, one-off, too vague, already fully covered by existing skill).
+
+Always include "reason" explaining your decision.
+
+Use your judgment \u2014 no rigid rules. Consider: Is this repeatable? Can it be generalized? Would it save time next time?`;
+async function evaluateAndMaybeCreateSkill(opts) {
+  const { sessionId, skillManager, model } = opts;
+  if (!sessionId) {
+    log.debug("Skill evaluation skipped: no session ID to resume");
+    return;
+  }
+  const existingSkills = skillManager.getAll();
+  const existingList = existingSkills.length > 0 ? existingSkills.map((s) => `- ${s.name}: ${s.description}`).join("\n") : "(no existing skills)";
+  const prompt = `${SKILL_EVALUATION_PROMPT}
+
+## Existing Skills (do NOT duplicate these)
+${existingList}
+
+Respond with a JSON object now.`;
+  try {
+    let responseText = "";
+    for await (const message of query({
+      prompt,
+      options: {
+        resume: sessionId,
+        model,
+        maxTurns: 1,
+        allowedTools: []
+      }
+    })) {
+      if (message.type === "assistant") {
+        const assistantMsg = message;
+        for (const block of assistantMsg.message.content) {
+          if (block.type === "text") {
+            responseText += block.text;
+          }
+        }
+      } else if (message.type === "result") {
+        const resultMsg = message;
+        if (resultMsg.subtype === "success" && "total_cost_usd" in resultMsg) {
+          log.debug(`Skill evaluation cost: $${resultMsg.total_cost_usd.toFixed(4)}`);
+        }
+      }
+    }
+    const decision = parseJsonResponse(responseText);
+    if (!decision) {
+      log.debug("Skill evaluation: no valid JSON in response");
+      return;
+    }
+    if (!["create", "update", "skip"].includes(decision.action)) {
+      log.debug("Skill evaluation: invalid action");
+      return;
+    }
+    await executeSkillDecision(decision, skillManager);
+  } catch (err) {
+    log.debug(`Skill evaluation error: ${err}`);
+  }
+}
+async function executeSkillDecision(decision, skillManager) {
+  switch (decision.action) {
+    case "create": {
+      if (!decision.name || !decision.instructions) {
+        log.debug("Skill create skipped: missing name or instructions");
+        return;
+      }
+      let skillName = decision.name;
+      if (validateSkillName(skillName)) {
+        skillName = normalizeSkillName(skillName);
+        if (!skillName || validateSkillName(skillName)) {
+          log.debug(`Skill create skipped: name "${decision.name}" cannot be normalized`);
+          return;
+        }
+        log.debug(`Normalized skill name: "${decision.name}" \u2192 "${skillName}"`);
+      }
+      const existing = skillManager.findSimilar(skillName);
+      if (existing) {
+        log.debug(`Skill create skipped: similar skill "${existing.name}" exists`);
+        return;
+      }
+      const result = await skillManager.create(
+        skillName,
+        decision.description || "",
+        decision.instructions,
+        {
+          source: "auto_extracted",
+          emoji: decision.emoji,
+          keywords: decision.keywords
+        }
+      );
+      if (result) {
+        await skillManager.syncToAgentSkills(
+          skillName,
+          decision.description || "",
+          decision.instructions,
+          "1.0.0",
+          {
+            source: "auto_extracted",
+            emoji: decision.emoji,
+            keywords: decision.keywords,
+            sourceSkillId: result.id
+          }
+        );
+        log.info(`Auto-created skill "${skillName}": ${decision.reason}`);
+      }
+      break;
+    }
+    case "update": {
+      if (!decision.existing_skill_name || !decision.improved_instructions) {
+        log.debug("Skill update skipped: missing skill name or instructions");
+        return;
+      }
+      const updated = skillManager.update(
+        decision.existing_skill_name,
+        decision.improved_instructions,
+        decision.improved_description
+      );
+      if (updated) {
+        log.info(`Auto-improved skill "${decision.existing_skill_name}": ${decision.reason}`);
+      } else {
+        log.debug(`Skill update failed: "${decision.existing_skill_name}" not found`);
+      }
+      break;
+    }
+    case "skip":
+      log.debug(`Skill evaluation: skip \u2014 ${decision.reason}`);
+      break;
+  }
+}
+function parseJsonResponse(text) {
+  const trimmed = text.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed.action) return parsed;
+  } catch {
+  }
+  const start = trimmed.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  for (let i = start; i < trimmed.length; i++) {
+    if (trimmed[i] === "{") depth++;
+    else if (trimmed[i] === "}") depth--;
+    if (depth === 0) {
+      try {
+        return JSON.parse(trimmed.slice(start, i + 1));
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
 // src/utils/retry.ts
 async function withRetry(fn, opts = {}) {
   const {
@@ -2961,6 +3204,15 @@ function createAgentToolsServer(deps) {
           emoji: z.string().optional().describe("Single emoji representing this skill")
         },
         async (args) => {
+          const nameError = validateSkillName(args.name);
+          if (nameError) {
+            return {
+              content: [{
+                type: "text",
+                text: `Invalid skill name: ${nameError}. Use lowercase kebab-case like "flight-booking".`
+              }]
+            };
+          }
           const existing = skillManager.findSimilar(args.name);
           if (existing) {
             return {
@@ -3333,7 +3585,67 @@ ${content}`;
           };
         }
       ),
-      // ── User Confirmation Tool ─────────────────────────────────
+      // ── User Interaction Tools ──────────────────────────────────
+      tool(
+        "request_user_input",
+        "Ask the user a clarifying question and wait for their free-text response. Use this when you need information that cannot be inferred from context, memory, or the workspace \u2014 e.g. which account to use, specific preferences, ambiguous instructions, or missing parameters for a skill. Do NOT use this for information you can discover yourself (git remote, file contents, etc.).",
+        {
+          question: z.string().describe("The question to ask the user (supports markdown). Be specific about what you need and why."),
+          placeholder: z.string().optional().describe("Placeholder text for the input field (e.g. 'https://github.com/owner/repo')"),
+          timeout_seconds: z.number().optional().describe("How long to wait for response (default: 300)")
+        },
+        async (args) => {
+          const actionId = `input_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const timeout = (args.timeout_seconds || 300) * 1e3;
+          const actionData = {
+            id: actionId,
+            type: "input",
+            message: args.question,
+            placeholder: args.placeholder || "",
+            created_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          try {
+            await setActionRequest(taskId, actionData);
+            log.info(`Input request ${actionId}: "${args.question.slice(0, 80)}..."`);
+            emitEvent(taskId, "user_action_request", actionData).catch(() => {
+            });
+            const startTime = Date.now();
+            const pollInterval = 2e3;
+            while (Date.now() - startTime < timeout) {
+              const response = await pollActionResponse(taskId);
+              if (response && (!response.action_id || response.action_id === actionId)) {
+                const text = response.text || response.value || "";
+                log.info(`User input received: "${text.slice(0, 80)}"`);
+                return {
+                  content: [{
+                    type: "text",
+                    text: JSON.stringify({ status: "responded", text })
+                  }]
+                };
+              }
+              await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+            }
+            log.warn(`Input request ${actionId} timed out`);
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  status: "timeout",
+                  message: "User did not respond within the timeout period."
+                })
+              }]
+            };
+          } catch (err) {
+            log.error(`request_user_input failed: ${err}`);
+            return {
+              content: [{
+                type: "text",
+                text: `Failed to request user input: ${err instanceof Error ? err.message : err}`
+              }]
+            };
+          }
+        }
+      ),
       tool(
         "request_user_confirmation",
         "Pause and ask the user for approval or input via the web UI. Returns the user's chosen action_key. Use this BEFORE creating skills, making irreversible changes, etc. The agent will block until the user responds or the timeout expires.",
@@ -3365,7 +3677,7 @@ ${content}`;
             const pollInterval = 2e3;
             while (Date.now() - startTime < timeout) {
               const response = await pollActionResponse(taskId);
-              if (response) {
+              if (response && (!response.action_id || response.action_id === actionId)) {
                 const actionKey = response.action_key || response.action || "";
                 const label = response.label || actionKey;
                 log.info(`User responded: ${label} (${actionKey})`);
@@ -3687,13 +3999,25 @@ Available capabilities:
    - PROACTIVELY use memory_store during tasks when you discover user preferences, habits, or important context
    - Before completing a task, consider if anything learned should be remembered for future conversations
 
-4. SKILL PLANNING (pre-task):
-   - Before executing a complex task, analyze if it matches an existing skill (use skill_invoke)
-   - If no matching skill exists, consider whether this task represents a reusable workflow
-   - To create a new skill: use skill_create to save a draft, then ASK the user if they want to add it
-   - If the user approves, use skill_add to add it to their collection, then proceed with the task
-   - If a skill's instructions could be improved based on your experience, use skill_improve
-   - Use skill_search to find relevant skills when the task doesn't obviously match the listed skills
+4. SKILL-AWARE EXECUTION (CRITICAL \u2014 follow this for EVERY task):
+   Step A \u2014 Search: Before executing ANY task, check if an existing skill matches (use skill_invoke or skill_search).
+   Step B \u2014 If skill found: load it with skill_invoke and follow its instructions precisely. If the instructions are incomplete or wrong, adapt and improve as you go \u2014 note what changed.
+   Step C \u2014 If NO skill found: BEFORE executing, draft a skill plan following the Agent Skills format:
+     Skill Draft: [kebab-case-name]
+     Description: [what this skill does and when to use it]
+     Steps:
+     1. [first step]
+     2. [second step]
+     ...
+     The draft should be a reusable workflow, not specific to this one request. Use generic placeholders where the user provided specific values.
+   Step D \u2014 Execute: Follow the skill draft (or loaded skill) step by step. Refine the draft as you discover better approaches, edge cases, or missing steps.
+   Step E \u2014 After execution: The system will automatically evaluate whether to save the skill. You do NOT need to call skill_create manually.
+
+   Agent Skills format reference (agentskills.io):
+   - name: 1-64 chars, lowercase kebab-case (a-z, 0-9, hyphens), no leading/trailing/consecutive hyphens
+   - description: 1-1024 chars, describe what the skill does AND when to use it, include keywords for discoverability
+   - body: markdown step-by-step instructions, examples, edge cases. Keep under 500 lines.
+   - Progressive disclosure: metadata (~100 tokens) \u2192 instructions (<5000 tokens) \u2192 references (on demand)
 
 5. JOB AUTOMATION:
    - When the user describes their job/role/daily work, use skill_generate to decompose it into automatable skills
@@ -3730,6 +4054,14 @@ Guidelines:
 - Summarize results clearly at the end
 - When you learn something about the user (preferences, habits), use memory_store to remember it
 
+CRITICAL \u2014 Ask before you guess:
+- Before executing a task, verify you have all required information. If anything is ambiguous or missing, use request_user_input to ask.
+- First try to resolve unknowns yourself: check memories, read workspace files (e.g. git remote, config files), or infer from conversation history.
+- If you still lack a critical piece of information after self-resolution, ASK the user via request_user_input. Do NOT guess, assume defaults, or proceed with incomplete information.
+- Examples of when to ask: which account/repo/project to target, what format the user wants, which of multiple options to choose, credentials or URLs that cannot be inferred.
+- Keep questions specific and actionable. Explain what you already know and what exactly you need.
+- After receiving the answer, store it with memory_store if it is likely to be useful in future conversations.
+
 Workspace path: {workspace_path}`;
 var MAX_HISTORY_ENTRIES = 10;
 var MAX_RESPONSE_LENGTH = 1500;
@@ -3754,6 +4086,18 @@ var TaskProcessor = class {
   setSessionId(sessionId) {
     this.sessionId = sessionId;
   }
+  /**
+   * Post-task: resume the same Agent SDK session to evaluate whether
+   * to create/update a skill. The agent already has full context from
+   * the task it just completed — no need to re-describe anything.
+   */
+  async evaluateSkillPostTask(agentSessionId, model) {
+    await evaluateAndMaybeCreateSkill({
+      sessionId: agentSessionId,
+      skillManager: this.skillManager,
+      model
+    });
+  }
   async processTask(task) {
     const config = getConfig();
     resetEventSequence();
@@ -3763,6 +4107,7 @@ var TaskProcessor = class {
     let finalResponse = "";
     const toolCallRecords = [];
     let tokenUsage;
+    let agentSessionId;
     try {
       await emitEvent(task.id, "status_change", { status: "running" });
       let systemPrompt = BASE_SYSTEM_PROMPT.replace("{workspace_path}", config.workspacePath);
@@ -3776,7 +4121,7 @@ var TaskProcessor = class {
           log.debug(`Memory load failed: ${err}`);
         }
       }
-      const skillPrompt = this.skillManager.buildSkillDescriptions();
+      const skillPrompt = this.skillManager.buildSkillDescriptions(task.prompt);
       if (skillPrompt) {
         systemPrompt += skillPrompt;
       }
@@ -3832,7 +4177,8 @@ var TaskProcessor = class {
         "mcp__assistme-agent__skill_browse",
         "mcp__assistme-agent__skill_add",
         "mcp__assistme-agent__skill_publish",
-        // User confirmation
+        // User interaction
+        "mcp__assistme-agent__request_user_input",
         "mcp__assistme-agent__request_user_confirmation",
         // Job automation tools
         "mcp__assistme-agent__job_run",
@@ -3864,7 +4210,7 @@ var TaskProcessor = class {
           "assistme-agent": agentToolsServer
         },
         hooks: eventHooks,
-        persistSession: false,
+        persistSession: true,
         abortController
       };
       const taskStartTime = Date.now();
@@ -3872,7 +4218,7 @@ var TaskProcessor = class {
         abortController.abort();
       }, taskTimeoutMs);
       try {
-        for await (const message of query({
+        for await (const message of query2({
           prompt: promptMessages(),
           options
         })) {
@@ -3924,6 +4270,9 @@ var TaskProcessor = class {
               break;
             }
             default:
+              if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+                agentSessionId = message.session_id;
+              }
               log.debug(`SDK message type: ${message.type}`);
               break;
           }
@@ -3944,6 +4293,9 @@ var TaskProcessor = class {
         convHistory.splice(0, convHistory.length - MAX_HISTORY_ENTRIES * 2);
       }
       this.historyCache.set(task.conversation_id, convHistory);
+      if (agentSessionId) {
+        this.evaluateSkillPostTask(agentSessionId, config.model).catch((err) => log.debug(`Post-task skill evaluation skipped: ${err}`));
+      }
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : String(err);
       log.error(`Task failed: ${errorMsg}`);
@@ -4323,17 +4675,17 @@ Memories (${memories.length}):`));
       process.exit(1);
     }
   });
-  memoryCmd.command("search <query>").description("Search memories").action(async (query2) => {
+  memoryCmd.command("search <query>").description("Search memories").action(async (query3) => {
     try {
       const userId = await getCurrentUserId();
       const mm = new MemoryManager(userId);
-      const results = await mm.search(query2);
+      const results = await mm.search(query3);
       if (results.length === 0) {
-        console.log(chalk7.yellow(`No memories matching "${query2}"`));
+        console.log(chalk7.yellow(`No memories matching "${query3}"`));
         return;
       }
       console.log(chalk7.bold(`
-Search results for "${query2}":`));
+Search results for "${query3}":`));
       for (const m of results) {
         console.log(`  [${m.category}] ${m.content}`);
       }
@@ -4401,18 +4753,18 @@ function registerSkillCommands(program2) {
     );
     console.log();
   });
-  skillCmd.command("search <query>").description("Search skills in your collection and marketplace").action(async (query2) => {
+  skillCmd.command("search <query>").description("Search skills in your collection and marketplace").action(async (query3) => {
     const spinner = ora4("Searching skills...").start();
     const sm = await getAuthenticatedSkillManager();
     try {
-      const results = await sm.searchDb(query2);
+      const results = await sm.searchDb(query3);
       spinner.stop();
       if (results.length === 0) {
-        console.log(chalk8.yellow(`No skills found for "${query2}"`));
+        console.log(chalk8.yellow(`No skills found for "${query3}"`));
         return;
       }
       console.log(chalk8.bold(`
-Skills matching "${query2}":`));
+Skills matching "${query3}":`));
       for (const r of results) {
         const emoji = r.emoji ? `${r.emoji} ` : "";
         console.log(`  ${emoji}${chalk8.cyan(r.name)} [${r.source}]`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",