assistme 0.2.9 → 0.3.1

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 {
@@ -3156,17 +3408,17 @@ ${content}`;
           response += `**Your task:** Analyze this job description and decompose it into 4-10 automatable skills.
 
 `;
-          response += `**IMPORTANT \u2014 You MUST use request_user_confirmation before creating skills:**
+          response += `**IMPORTANT \u2014 You MUST use ask_user before creating skills:**
 `;
           response += `1. Analyze the job and draft a list of proposed skills (name, emoji, one-line description for each).
 `;
-          response += `2. Call \`request_user_confirmation\` with the formatted skill list as "message" and these options:
+          response += `2. Call \`ask_user\` with the formatted skill list as "question" and these options:
 `;
           response += `   - options: [{label: "Approve All", action_key: "approve_all", description: "Create all proposed skills"}, {label: "Cancel", action_key: "cancel", description: "Do not create any skills"}]
 `;
           response += `3. WAIT for the response. If action_key is "approve_all", create all skills using \`skill_create\`. If "cancel", stop.
 `;
-          response += `4. Do NOT ask for confirmation in text. Do NOT create skills without calling request_user_confirmation first.
+          response += `4. Do NOT ask for confirmation in text. Do NOT create skills without calling ask_user first.
 
 `;
           response += `For each skill, call \`skill_create\` with:
@@ -3333,56 +3585,60 @@ ${content}`;
           };
         }
       ),
-      // ── User Confirmation Tool ─────────────────────────────────
+      // ── User Interaction Tool ───────────────────────────────────
       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.",
+        "ask_user",
+        "Ask the user a question via the web UI and wait for their response. Shows a message with optional predefined option buttons PLUS a free-text input field \u2014 the user can either click a suggested option or type a custom answer. ALWAYS provide options when you can suggest likely answers. Do NOT use this for information you can discover yourself (git remote, file contents, etc.).",
         {
-          message: z.string().describe("What to show the user (supports markdown)"),
+          question: z.string().describe("The question to ask (supports markdown). Be specific about what you need and why."),
           options: z.array(z.object({
             label: z.string().describe("Button label shown to user"),
             action_key: z.string().describe("Machine-readable key returned when selected"),
             description: z.string().optional().describe("Tooltip/description for this option")
-          })).describe("Buttons/options to show the user"),
+          })).optional().describe("Suggested options shown as buttons. The user can always type a custom answer instead."),
+          placeholder: z.string().optional().describe("Placeholder text for the free-text input field"),
           timeout_seconds: z.number().optional().describe("How long to wait for response (default: 300)")
         },
         async (args) => {
-          const actionId = `action_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const actionId = `ask_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
           const timeout = (args.timeout_seconds || 300) * 1e3;
           const actionData = {
             id: actionId,
-            type: "confirmation",
-            message: args.message,
-            options: args.options,
+            type: "ask_user",
+            message: args.question,
+            options: args.options || [],
+            placeholder: args.placeholder || "",
             created_at: (/* @__PURE__ */ new Date()).toISOString()
           };
           try {
             await setActionRequest(taskId, actionData);
-            log.info(`Action request ${actionId} stored in metadata, waiting for user response...`);
+            log.info(`Ask user ${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) {
-                const actionKey = response.action_key || response.action || "";
-                const label = response.label || actionKey;
-                log.info(`User responded: ${label} (${actionKey})`);
+              if (response && (!response.action_id || response.action_id === actionId)) {
+                const actionKey = response.action_key || "";
+                const text = response.text || "";
+                const label = response.label || actionKey || text;
+                log.info(`User responded: "${label}"`);
                 return {
                   content: [{
                     type: "text",
                     text: JSON.stringify({
                       status: "responded",
-                      action_key: actionKey,
-                      label
+                      action_key: actionKey || "custom_input",
+                      label,
+                      text: text || label
                     })
                   }]
                 };
               }
               await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
             }
-            log.warn(`Action request ${actionId} timed out after ${args.timeout_seconds || 300}s`);
+            log.warn(`Ask user ${actionId} timed out after ${args.timeout_seconds || 300}s`);
             return {
               content: [{
                 type: "text",
@@ -3393,11 +3649,11 @@ ${content}`;
               }]
             };
           } catch (err) {
-            log.error(`request_user_confirmation failed: ${err}`);
+            log.error(`ask_user failed: ${err}`);
             return {
               content: [{
                 type: "text",
-                text: `Failed to request user confirmation: ${err instanceof Error ? err.message : err}`
+                text: `Failed to ask user: ${err instanceof Error ? err.message : err}`
               }]
             };
           }
@@ -3687,17 +3943,29 @@ 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
-   - ALWAYS use request_user_confirmation to get user approval before creating skills \u2014 never create skills without approval
+   - ALWAYS use ask_user to get user approval before creating skills \u2014 never create skills without approval
    - Use job_run to start a job \u2014 it gives you the job's goal and available skills as capabilities
    - When running a job, be AGENTIC: decide dynamically what to do based on what you discover
    - Do NOT follow a fixed sequence \u2014 if checking Slack reveals a task that needs GitHub, go do GitHub immediately
@@ -3730,6 +3998,15 @@ 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 ask_user 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 ask_user. Do NOT guess, assume defaults, or proceed with incomplete information.
+- When asking, provide suggested options as buttons whenever possible \u2014 the user can always type a custom answer instead.
+- 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 +4031,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 +4052,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 +4066,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,8 +4122,8 @@ var TaskProcessor = class {
         "mcp__assistme-agent__skill_browse",
         "mcp__assistme-agent__skill_add",
         "mcp__assistme-agent__skill_publish",
-        // User confirmation
-        "mcp__assistme-agent__request_user_confirmation",
+        // User interaction
+        "mcp__assistme-agent__ask_user",
         // Job automation tools
         "mcp__assistme-agent__job_run",
         "mcp__assistme-agent__job_schedule",
@@ -3864,7 +4154,7 @@ var TaskProcessor = class {
           "assistme-agent": agentToolsServer
         },
         hooks: eventHooks,
-        persistSession: false,
+        persistSession: true,
         abortController
       };
       const taskStartTime = Date.now();
@@ -3872,7 +4162,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 +4214,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 +4237,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 +4619,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 +4697,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}]`);