assistme 0.2.8 → 0.3.0

package/dist/index.js

@@ -1,35 +1,18 @@
 #!/usr/bin/env node
 import {
   JobRunner,
-  claimTask,
-  clearConfig,
-  completeTask,
-  createSession,
-  createTask,
-  emitEvent,
-  endSession,
-  failTask,
-  getConfig,
-  getConfigPath,
-  getConversationHistory,
-  getCurrentUserId,
-  getOrCreateCliConversation,
-  getSupabase,
+  callMcpHandler,
   log,
-  loginWithToken,
-  logout,
   newCorrelationId,
-  pollActionResponse,
-  pollAndClaimJobRun,
-  pollAndClaimTask,
-  resetEventSequence,
-  setActionRequest,
-  setConfig,
   setCorrelationId,
-  setLogLevel,
-  setSessionBusy,
-  updateHeartbeat
-} from "./chunk-XY3LGAOY.js";
+  setLogLevel
+} from "./chunk-UWE5WVQI.js";
+import {
+  clearConfig,
+  getConfig,
+  getConfigPath,
+  setConfig
+} from "./chunk-TTEGHE2E.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -40,6 +23,217 @@ import { createRequire } from "module";
 import chalk from "chalk";
 import ora from "ora";
 import { createInterface } from "readline";
+
+// src/db/supabase.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var AUTH_DIR = join(homedir(), ".config", "assistme");
+var AUTH_FILE = join(AUTH_DIR, "auth.json");
+function ensureAuthDir() {
+  if (!existsSync(AUTH_DIR)) {
+    mkdirSync(AUTH_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readAuthStore() {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function writeAuthStore(data) {
+  ensureAuthDir();
+  writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+async function loginWithToken(mcpToken) {
+  if (!mcpToken.startsWith("am_")) {
+    throw new Error(
+      "Invalid token format. Use an am_ token from the web page."
+    );
+  }
+  const result = await callMcpHandler(
+    "auth.validate_token",
+    {},
+    mcpToken
+  );
+  const store = readAuthStore();
+  store["mcp_token"] = mcpToken;
+  writeAuthStore(store);
+  return result.user_id;
+}
+async function getCurrentUserId() {
+  const result = await callMcpHandler(
+    "auth.validate_token"
+  );
+  return result.user_id;
+}
+async function logout() {
+  try {
+    writeAuthStore({});
+  } catch {
+  }
+}
+async function createSession(_userId, sessionName, workspacePath, version2) {
+  const { getConfig: getConfig2 } = await import("./config-PUIS2TQL.js");
+  const data = await callMcpHandler("session.create", {
+    session_name: sessionName,
+    workspace_path: workspacePath,
+    version: version2,
+    model: getConfig2().model || null
+  });
+  return data;
+}
+async function updateHeartbeat(sessionId) {
+  try {
+    await callMcpHandler("session.heartbeat", { session_id: sessionId });
+  } catch (err) {
+    log.warn(`Heartbeat update failed: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function endSession(sessionId) {
+  try {
+    await callMcpHandler("session.end", { session_id: sessionId });
+  } catch (err) {
+    log.error(`Failed to end session: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function setSessionBusy(sessionId, busy) {
+  await callMcpHandler("session.set_busy", {
+    session_id: sessionId,
+    busy
+  });
+}
+async function cleanupStaleSessions(currentSessionId, thresholdMs = 12e4) {
+  try {
+    const result = await callMcpHandler(
+      "session.cleanup_stale",
+      { current_session_id: currentSessionId, threshold_ms: thresholdMs }
+    );
+    return result.cleaned;
+  } catch {
+    return 0;
+  }
+}
+async function getActiveSessions(limit = 5) {
+  return callMcpHandler("session.get_active", { limit });
+}
+async function getOrCreateCliConversation(_userId, _sessionId) {
+  const data = await callMcpHandler("conversation.get_or_create");
+  return data;
+}
+async function createTask(conversationId, _userId, sessionId, prompt) {
+  const data = await callMcpHandler("task.create", {
+    conversation_id: conversationId,
+    session_id: sessionId,
+    prompt
+  });
+  return { ...data, prompt };
+}
+async function pollAndClaimTask(sessionId) {
+  try {
+    const data = await callMcpHandler(
+      "task.poll_and_claim",
+      { session_id: sessionId }
+    );
+    if (!data) return null;
+    return {
+      ...data,
+      prompt: data.metadata?.prompt || data.content || ""
+    };
+  } catch (err) {
+    log.warn(`Poll-and-claim failed: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}
+async function claimTask(messageId) {
+  const data = await callMcpHandler("task.claim", {
+    message_id: messageId
+  });
+  return data;
+}
+async function completeTask(messageId, resultSummary, tokenUsage) {
+  await callMcpHandler("task.complete", {
+    message_id: messageId,
+    result: resultSummary,
+    token_usage: tokenUsage || null
+  });
+}
+async function failTask(messageId, errorMessage) {
+  try {
+    await callMcpHandler("task.fail", {
+      message_id: messageId,
+      error: errorMessage
+    });
+  } catch (err) {
+    log.error(`Failed to update task status: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function pollAndClaimJobRun(_userId) {
+  try {
+    const data = await callMcpHandler(
+      "job.claim_pending_run"
+    );
+    return data;
+  } catch (err) {
+    log.debug(`Job run poll failed: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}
+async function getConversationHistory(conversationId, excludeMessageId, limit = 20) {
+  try {
+    const rows = await callMcpHandler(
+      "conversation.get_history",
+      {
+        conversation_id: conversationId,
+        exclude_message_id: excludeMessageId,
+        limit
+      }
+    );
+    return (rows || []).reverse().map((row) => {
+      const prompt = row.metadata?.prompt || "";
+      const content = row.content || "";
+      const response = row.status === "failed" ? `[Task failed] ${content}` : content;
+      return { prompt, response };
+    }).filter((entry) => entry.prompt && entry.response);
+  } catch (err) {
+    log.debug(`Failed to fetch conversation history: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+var eventSequence = 0;
+function resetEventSequence() {
+  eventSequence = 0;
+}
+async function emitEvent(messageId, eventType, eventData) {
+  eventSequence++;
+  try {
+    await callMcpHandler("event.emit", {
+      message_id: messageId,
+      event_type: eventType,
+      event_data: eventData,
+      seq: eventSequence
+    });
+  } catch (err) {
+    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function setActionRequest(messageId, actionData) {
+  await callMcpHandler("action.set_request", {
+    message_id: messageId,
+    action_data: actionData
+  });
+}
+async function pollActionResponse(messageId) {
+  return callMcpHandler(
+    "action.poll_response",
+    { message_id: messageId }
+  );
+}
+
+// src/commands/auth.ts
 function registerAuthCommands(program2) {
   program2.command("login").description("Authenticate with your AssistMe account via browser token").action(async () => {
     const tokenPageUrl = process.env.ASSISTME_WEB_URL || "https://assistme.co.nz/agent/token";
@@ -164,9 +358,9 @@ import ora2 from "ora";
 // src/tools/browser.ts
 import { WebSocket } from "ws";
 import { execSync, spawn } from "child_process";
-import { platform, homedir } from "os";
-import { existsSync, unlinkSync, mkdirSync, cpSync } from "fs";
-import { join } from "path";
+import { platform, homedir as homedir2 } from "os";
+import { existsSync as existsSync2, unlinkSync, mkdirSync as mkdirSync2, cpSync } from "fs";
+import { join as join2 } from "path";
 var BrowserController = class {
   ws = null;
   debugPort;
@@ -701,7 +895,7 @@ function findChromePath() {
       "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
       "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
     ];
-    return paths.find((p) => existsSync(p)) ?? null;
+    return paths.find((p) => existsSync2(p)) ?? null;
   }
   if (os === "linux") {
     const names = [
@@ -738,7 +932,7 @@ function findChromePath() {
     for (const prefix of prefixes) {
       for (const sub of subPaths) {
         const p = `${prefix}\\${sub}`;
-        if (existsSync(p)) return p;
+        if (existsSync2(p)) return p;
       }
     }
     return null;
@@ -746,39 +940,39 @@ function findChromePath() {
   return null;
 }
 function getDefaultProfileDir(chromePath) {
-  const home = homedir();
+  const home = homedir2();
   const os = platform();
   if (os === "darwin") {
     if (chromePath.includes("Brave Browser"))
-      return join(home, "Library", "Application Support", "BraveSoftware", "Brave-Browser");
+      return join2(home, "Library", "Application Support", "BraveSoftware", "Brave-Browser");
     if (chromePath.includes("Microsoft Edge"))
-      return join(home, "Library", "Application Support", "Microsoft Edge");
+      return join2(home, "Library", "Application Support", "Microsoft Edge");
     if (chromePath.includes("Chromium"))
-      return join(home, "Library", "Application Support", "Chromium");
+      return join2(home, "Library", "Application Support", "Chromium");
     if (chromePath.includes("Canary"))
-      return join(home, "Library", "Application Support", "Google", "Chrome Canary");
-    return join(home, "Library", "Application Support", "Google", "Chrome");
+      return join2(home, "Library", "Application Support", "Google", "Chrome Canary");
+    return join2(home, "Library", "Application Support", "Google", "Chrome");
   }
   if (os === "win32") {
-    const appData = process.env.LOCALAPPDATA || join(home, "AppData", "Local");
+    const appData = process.env.LOCALAPPDATA || join2(home, "AppData", "Local");
     if (chromePath.includes("brave"))
-      return join(appData, "BraveSoftware", "Brave-Browser", "User Data");
-    if (chromePath.includes("msedge")) return join(appData, "Microsoft", "Edge", "User Data");
-    return join(appData, "Google", "Chrome", "User Data");
-  }
-  if (chromePath.includes("brave")) return join(home, ".config", "BraveSoftware", "Brave-Browser");
-  if (chromePath.includes("microsoft-edge")) return join(home, ".config", "microsoft-edge");
-  if (chromePath.includes("chromium")) return join(home, ".config", "chromium");
-  return join(home, ".config", "google-chrome");
+      return join2(appData, "BraveSoftware", "Brave-Browser", "User Data");
+    if (chromePath.includes("msedge")) return join2(appData, "Microsoft", "Edge", "User Data");
+    return join2(appData, "Google", "Chrome", "User Data");
+  }
+  if (chromePath.includes("brave")) return join2(home, ".config", "BraveSoftware", "Brave-Browser");
+  if (chromePath.includes("microsoft-edge")) return join2(home, ".config", "microsoft-edge");
+  if (chromePath.includes("chromium")) return join2(home, ".config", "chromium");
+  return join2(home, ".config", "google-chrome");
 }
 function getDebugProfileDir(chromePath) {
-  const home = homedir();
-  const debugDir = join(home, ".assistme", "browser-profile");
-  if (!existsSync(debugDir)) {
-    mkdirSync(debugDir, { recursive: true });
+  const home = homedir2();
+  const debugDir = join2(home, ".assistme", "browser-profile");
+  if (!existsSync2(debugDir)) {
+    mkdirSync2(debugDir, { recursive: true });
     log.debug(`Created debug profile directory: ${debugDir}`);
     const realDir = getDefaultProfileDir(chromePath);
-    if (existsSync(realDir)) {
+    if (existsSync2(realDir)) {
       seedDebugProfile(realDir, debugDir);
     }
   }
@@ -788,35 +982,35 @@ function seedDebugProfile(realDir, debugDir) {
   const rootFiles = ["Local State"];
   const profileFiles = ["Bookmarks", "Preferences", "Favicons", "Top Sites", "Shortcuts"];
   for (const file of rootFiles) {
-    const src = join(realDir, file);
-    const dest = join(debugDir, file);
+    const src = join2(realDir, file);
+    const dest = join2(debugDir, file);
     try {
-      if (existsSync(src)) {
+      if (existsSync2(src)) {
         cpSync(src, dest, { force: true });
         log.debug(`Seeded: ${file}`);
       }
     } catch {
     }
   }
-  const srcProfile = join(realDir, "Default");
-  const destProfile = join(debugDir, "Default");
-  if (existsSync(srcProfile)) {
-    mkdirSync(destProfile, { recursive: true });
+  const srcProfile = join2(realDir, "Default");
+  const destProfile = join2(debugDir, "Default");
+  if (existsSync2(srcProfile)) {
+    mkdirSync2(destProfile, { recursive: true });
     for (const file of profileFiles) {
-      const src = join(srcProfile, file);
-      const dest = join(destProfile, file);
+      const src = join2(srcProfile, file);
+      const dest = join2(destProfile, file);
       try {
-        if (existsSync(src)) {
+        if (existsSync2(src)) {
           cpSync(src, dest, { force: true });
           log.debug(`Seeded: Default/${file}`);
         }
       } catch {
       }
     }
-    const srcExt = join(srcProfile, "Extensions");
-    const destExt = join(destProfile, "Extensions");
+    const srcExt = join2(srcProfile, "Extensions");
+    const destExt = join2(destProfile, "Extensions");
     try {
-      if (existsSync(srcExt)) {
+      if (existsSync2(srcExt)) {
         cpSync(srcExt, destExt, { recursive: true, force: true });
         log.debug("Seeded: Default/Extensions");
       }
@@ -907,14 +1101,14 @@ async function ensureBrowserAvailable(port = 9222) {
     return { success: true, action: "launched", chromePath };
   }
   const debugDir = getDebugProfileDir(chromePath);
-  const lockPath = join(debugDir, "SingletonLock");
-  if (existsSync(lockPath)) {
+  const lockPath = join2(debugDir, "SingletonLock");
+  if (existsSync2(lockPath)) {
     log.debug("Found stale SingletonLock in debug profile \u2014 removing and retrying");
     try {
       unlinkSync(lockPath);
       for (const f of ["SingletonSocket", "SingletonCookie"]) {
         try {
-          unlinkSync(join(debugDir, f));
+          unlinkSync(join2(debugDir, f));
         } catch {
         }
       }
@@ -1124,13 +1318,14 @@ var Scheduler = class {
   }
   async initializeNextRuns() {
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-      const { data } = await sb.from("agent_scheduled_tasks").select("*").eq("user_id", userId).eq("enabled", true).is("next_run_at", null);
+      const data = await callMcpHandler("schedule.get_uninitialized");
       if (data) {
         for (const task of data) {
           const nextRun = getNextRunTime(task.cron_expression, task.timezone);
-          await sb.from("agent_scheduled_tasks").update({ next_run_at: nextRun.toISOString() }).eq("id", task.id);
+          await callMcpHandler("schedule.update", {
+            task_id: task.id,
+            next_run_at: nextRun.toISOString()
+          });
         }
       }
     } catch (err) {
@@ -1140,24 +1335,29 @@ var Scheduler = class {
   async checkDueTasks() {
     if (!this.running || !this.onScheduledTask) return;
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-      const { data: dueTasks } = await sb.from("agent_scheduled_tasks").select("*").eq("user_id", userId).eq("enabled", true).lte("next_run_at", (/* @__PURE__ */ new Date()).toISOString()).order("next_run_at", { ascending: true }).limit(1);
+      const dueTasks = await callMcpHandler("schedule.check_due");
       if (!dueTasks || dueTasks.length === 0) return;
       const task = dueTasks[0];
       log.info(`Scheduled task due: "${task.name}"`);
       const nextRun = getNextRunTime(task.cron_expression, task.timezone);
-      await sb.from("agent_scheduled_tasks").update({
+      await callMcpHandler("schedule.update", {
+        task_id: task.id,
         last_run_at: (/* @__PURE__ */ new Date()).toISOString(),
         next_run_at: nextRun.toISOString(),
         run_count: task.run_count + 1
-      }).eq("id", task.id);
+      });
       try {
         await this.onScheduledTask(task);
-        await sb.from("agent_scheduled_tasks").update({ last_error: null }).eq("id", task.id);
+        await callMcpHandler("schedule.update", {
+          task_id: task.id,
+          last_error: null
+        });
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        await sb.from("agent_scheduled_tasks").update({ last_error: errMsg }).eq("id", task.id);
+        await callMcpHandler("schedule.update", {
+          task_id: task.id,
+          last_error: errMsg
+        });
         log.error(`Scheduled task "${task.name}" failed: ${errMsg}`);
       }
     } catch (err) {
@@ -1165,50 +1365,41 @@ var Scheduler = class {
     }
   }
 };
-async function createScheduledTask(userId, name, prompt, cronExpression, timezone = "UTC") {
-  const sb = getSupabase();
+async function createScheduledTask(_userId, name, prompt, cronExpression, timezone = "UTC") {
   const nextRun = getNextRunTime(cronExpression, timezone);
-  const { data, error } = await sb.from("agent_scheduled_tasks").insert({
-    user_id: userId,
+  return callMcpHandler("schedule.create", {
     name,
     prompt,
     cron_expression: cronExpression,
     timezone,
     next_run_at: nextRun.toISOString()
-  }).select().single();
-  if (error) throw new Error(`Failed to create schedule: ${error.message}`);
-  return data;
+  });
 }
-async function listScheduledTasks(userId) {
-  const sb = getSupabase();
-  const { data, error } = await sb.from("agent_scheduled_tasks").select("*").eq("user_id", userId).order("created_at", { ascending: false });
-  if (error) throw new Error(`Failed to list schedules: ${error.message}`);
-  return data || [];
+async function listScheduledTasks(_userId) {
+  return callMcpHandler("schedule.list");
 }
 async function toggleScheduledTask(taskId, enabled) {
-  const sb = getSupabase();
-  const update = { enabled };
+  const params = { task_id: taskId, enabled };
   if (enabled) {
-    const { data } = await sb.from("agent_scheduled_tasks").select("cron_expression, timezone").eq("id", taskId).single();
-    if (data) {
-      const nextRun = getNextRunTime(data.cron_expression, data.timezone);
-      update.next_run_at = nextRun.toISOString();
+    const taskData = await callMcpHandler(
+      "schedule.get_task",
+      { task_id: taskId }
+    );
+    if (taskData) {
+      const nextRun = getNextRunTime(taskData.cron_expression, taskData.timezone);
+      params.next_run_at = nextRun.toISOString();
     }
   }
-  const { error } = await sb.from("agent_scheduled_tasks").update(update).eq("id", taskId);
-  if (error) throw new Error(`Failed to toggle schedule: ${error.message}`);
+  await callMcpHandler("schedule.toggle", params);
 }
 async function deleteScheduledTask(taskId) {
-  const sb = getSupabase();
-  const { error } = await sb.from("agent_scheduled_tasks").delete().eq("id", taskId);
-  if (error) throw new Error(`Failed to delete schedule: ${error.message}`);
+  await callMcpHandler("schedule.delete", { task_id: taskId });
 }
 
 // src/agent/session.ts
 var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
 var DEFAULT_POLL_INTERVAL = 2e3;
 var MAX_POLL_INTERVAL = 3e4;
-var STALE_SESSION_THRESHOLD = 12e4;
 var SessionManager = class {
   session = null;
   heartbeatTimer = null;
@@ -1261,9 +1452,6 @@ var SessionManager = class {
     });
     return this.session;
   }
-  /**
-   * Schedule the next poll with exponential backoff on failures.
-   */
   schedulePoll() {
     if (!this.running) return;
     const delay = this.consecutivePollFailures === 0 ? this.basePollInterval : Math.min(
@@ -1283,10 +1471,6 @@ var SessionManager = class {
       log.error(`Scheduled task error: ${err}`);
     }
   }
-  /**
-   * Execute a pending job run triggered from the web UI.
-   * Loads the job, builds the agentic prompt, and processes it as a chat task.
-   */
   async executeJobRun(jobRun) {
     if (!this.session || !this.userId || !this.conversationId || !this.onTask)
       return;
@@ -1312,8 +1496,10 @@ var SessionManager = class {
       return;
     }
     try {
-      const sb = getSupabase();
-      await sb.from("agent_job_runs").update({ session_id: this.session.id }).eq("id", jobRun.id);
+      await callMcpHandler("job.link_run_session", {
+        run_id: jobRun.id,
+        session_id: this.session.id
+      });
     } catch (linkErr) {
       log.debug(`Failed to link session to job run: ${linkErr}`);
     }
@@ -1389,37 +1575,17 @@ var SessionManager = class {
     }
     this.schedulePoll();
   }
-  /**
-   * Mark sessions as offline if they haven't sent a heartbeat recently.
-   * Runs once on startup to clean up orphaned sessions from crashed processes.
-   */
   async cleanupStaleSessions() {
-    if (!this.userId) return;
+    if (!this.userId || !this.session) return;
     try {
-      const sb = getSupabase();
-      const threshold = new Date(
-        Date.now() - STALE_SESSION_THRESHOLD
-      ).toISOString();
-      const { data: stale } = await sb.from("agent_sessions").select("id").eq("user_id", this.userId).in("status", ["online", "busy"]).lt("last_heartbeat_at", threshold).neq("id", this.session?.id || "");
-      if (stale && stale.length > 0) {
-        for (const s of stale) {
-          await sb.from("agent_sessions").update({
-            status: "offline",
-            ended_at: (/* @__PURE__ */ new Date()).toISOString(),
-            metadata: { ended_reason: "stale_session_cleanup" }
-          }).eq("id", s.id);
-        }
-        log.info(`Cleaned up ${stale.length} stale session(s)`);
+      const cleaned = await cleanupStaleSessions(this.session.id);
+      if (cleaned > 0) {
+        log.info(`Cleaned up ${cleaned} stale session(s)`);
       }
     } catch (err) {
       log.debug(`Stale session cleanup error: ${err}`);
     }
   }
-  /**
-   * Submit a task from the interactive prompt or scheduled job.
-   * Sets processing=true BEFORE creating the task so the poll loop
-   * never races to pick it up.
-   */
   async submitTask(prompt) {
     if (!this.session || !this.userId || !this.conversationId || !this.onTask) {
       throw new Error("Session not started");
@@ -1445,9 +1611,6 @@ var SessionManager = class {
       }
     }
   }
-  /**
-   * Stop the session with a safety timeout to prevent hanging on shutdown.
-   */
   async stop(timeoutMs = 5e3) {
     this.running = false;
     this.scheduler.stop();
@@ -1488,62 +1651,45 @@ var SessionManager = class {
 
 // src/agent/processor.ts
 import {
-  query
+  query as query2
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/agent/memory.ts
 var MemoryManager = class {
-  userId;
-  constructor(userId) {
-    this.userId = userId;
+  constructor(_userId) {
   }
   /**
    * Store a new memory. Called by the agent after completing tasks
    * to remember important facts about the user.
    */
   async remember(content, category = "general", options) {
-    const sb = getSupabase();
     const expiresAt = options?.expiresInDays ? new Date(
       Date.now() + options.expiresInDays * 864e5
     ).toISOString() : null;
-    const { data, error } = await sb.from("agent_memories").insert({
-      user_id: this.userId,
+    const data = await callMcpHandler("memory.store", {
       category,
       content,
       importance: options?.importance ?? 5,
       tags: options?.tags ?? [],
       source_message_id: options?.sourceMessageId ?? null,
       expires_at: expiresAt
-    }).select().single();
-    if (error) throw new Error(`Failed to store memory: ${error.message}`);
+    });
     log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
     return data;
   }
   /**
    * Search memories by query text. Uses ILIKE + tag containment.
    */
-  async search(query2, limit = 10) {
-    const sb = getSupabase();
-    const sanitized = query2.replace(/[%_]/g, "\\$&");
-    const { data, error } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).or(
-      `content.ilike.%${sanitized}%,tags.cs.{${sanitized}}`
-    ).order("importance", { ascending: false }).limit(limit);
-    if (error) {
-      log.warn(`Memory search failed: ${error.message}`);
+  async search(query3, limit = 10) {
+    try {
+      return await callMcpHandler("memory.search", {
+        query: query3,
+        limit
+      });
+    } catch (err) {
+      log.warn(`Memory search failed: ${err instanceof Error ? err.message : err}`);
       return [];
     }
-    if (data && data.length > 0) {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      await Promise.all(
-        data.map(
-          (m) => sb.from("agent_memories").update({
-            access_count: m.access_count + 1,
-            last_accessed_at: now
-          }).eq("id", m.id)
-        )
-      );
-    }
-    return data || [];
   }
   /**
    * Get the most important/recent memories to include in context.
@@ -1551,18 +1697,11 @@ var MemoryManager = class {
    * Automatically filters out expired memories.
    */
   async getContext(maxItems = 20) {
-    const sb = getSupabase();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const { data: instructions } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).eq("category", "instruction").or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).limit(5);
-    const { data: preferences } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).eq("category", "preference").or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).limit(5);
-    const { data: general } = await sb.from("agent_memories").select("*").eq("user_id", this.userId).not("category", "in", '("instruction","preference")').or(`expires_at.is.null,expires_at.gt.${now}`).order("importance", { ascending: false }).order("updated_at", { ascending: false }).limit(maxItems - 10);
-    const all = [
-      ...instructions || [],
-      ...preferences || [],
-      ...general || []
-    ];
+    const all = await callMcpHandler("memory.get_context", {
+      max_items: maxItems
+    });
     const seen = /* @__PURE__ */ new Set();
-    return all.filter((m) => {
+    return (all || []).filter((m) => {
       if (seen.has(m.id)) return false;
       seen.add(m.id);
       return true;
@@ -1599,32 +1738,23 @@ var MemoryManager = class {
   }
   // ── CRUD for CLI ────────────────────────────────────────────
   async list(category, limit = 20) {
-    const sb = getSupabase();
-    let query2 = sb.from("agent_memories").select("*").eq("user_id", this.userId).order("importance", { ascending: false }).order("created_at", { ascending: false }).limit(limit);
-    if (category) {
-      query2 = query2.eq("category", category);
-    }
-    const { data, error } = await query2;
-    if (error) throw new Error(`Failed to list memories: ${error.message}`);
+    const data = await callMcpHandler("memory.list", {
+      category: category || null,
+      limit
+    });
     return data || [];
   }
   async add(content, category = "general", importance = 5, tags = []) {
     return this.remember(content, category, { importance, tags });
   }
   async remove(memoryId) {
-    const sb = getSupabase();
-    const { error } = await sb.from("agent_memories").delete().eq("id", memoryId).eq("user_id", this.userId);
-    if (error) throw new Error(`Failed to delete memory: ${error.message}`);
+    await callMcpHandler("memory.remove", { memory_id: memoryId });
   }
   async clear(category) {
-    const sb = getSupabase();
-    let query2 = sb.from("agent_memories").delete().eq("user_id", this.userId);
-    if (category) {
-      query2 = query2.eq("category", category);
-    }
-    const { error, count } = await query2.select("id");
-    if (error) throw new Error(`Failed to clear memories: ${error.message}`);
-    return count || 0;
+    const result = await callMcpHandler("memory.clear", {
+      category: category || null
+    });
+    return result.count;
   }
 };
 
@@ -1772,31 +1902,18 @@ var SkillManager = class {
   skills = /* @__PURE__ */ new Map();
   idfCache = /* @__PURE__ */ new Map();
   userId = null;
-  /** Budget for skill descriptions in system prompt (characters). */
+  /** Cache for findRelevant() — keyed by prompt, invalidated on skill changes */
+  relevanceCache = /* @__PURE__ */ new Map();
   DESCRIPTION_BUDGET_CHARS = 16e3;
-  /**
-   * Set the user ID for DB operations.
-   * Called after authentication; enables DB-backed skill storage.
-   */
   setUserId(userId) {
     this.userId = userId;
   }
-  /**
-   * Load skills from DB (user's agent_skills collection).
-   * This is the only loading mechanism — no file-based loading.
-   */
   async loadFromDb() {
     if (!this.userId) return;
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.from("agent_skills").select("*").eq("user_id", this.userId).eq("is_active", true);
-      if (error) {
-        log.debug(`DB skill load failed: ${error.message}`);
-        return;
-      }
+      const data = await callMcpHandler("skill.load");
       this.skills.clear();
-      const dbRows = data || [];
-      for (const row of dbRows) {
+      for (const row of data || []) {
         const skill = this.rowToSkill(row);
         this.skills.set(skill.name, skill);
       }
@@ -1808,15 +1925,7 @@ var SkillManager = class {
       log.debug(`DB skill load error: ${err}`);
     }
   }
-  /**
-   * Convert a DB row to a Skill object.
-   */
   rowToSkill(row) {
-    const meta = row.metadata || {};
-    const rawVars = row.variables || meta.variables;
-    const variables = Array.isArray(rawVars) ? rawVars : void 0;
-    const rawConfig = row.config;
-    const config = rawConfig && typeof rawConfig === "object" ? rawConfig : void 0;
     return {
       name: row.name,
       description: row.description || "",
@@ -1833,14 +1942,14 @@ var SkillManager = class {
       source: row.source || "manual",
       dbId: row.id,
       sourceSkillId: row.source_skill_id || void 0,
-      variables,
-      config
+      invocationCount: row.invocation_count || 0
     };
   }
-  /**
-   * Pre-compute IDF (Inverse Document Frequency) for all tokens across skills.
-   * Called once after loadFromDb(), avoids recomputing on every findRelevant() call.
-   */
+  /** Invalidate caches when skills change (create, add, update, remove). */
+  invalidateCaches() {
+    this.relevanceCache.clear();
+    this.buildIdfCache();
+  }
   buildIdfCache() {
     this.idfCache.clear();
     const docFreq = /* @__PURE__ */ new Map();
@@ -1856,24 +1965,19 @@ var SkillManager = class {
       this.idfCache.set(word, Math.log(totalSkills / df) + 1);
     }
   }
-  /**
-   * Get all loaded skills (from user's agent_skills collection).
-   */
   getAll() {
     return Array.from(this.skills.values());
   }
-  /**
-   * Get a skill by name.
-   */
   get(name) {
     return this.skills.get(name);
   }
-  /**
-   * Find skills relevant to a given task prompt.
-   * Uses a TF-IDF-inspired scoring approach with pre-computed IDF cache.
-   */
   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;
@@ -1883,47 +1987,56 @@ var SkillManager = class {
       let score = 0;
       if (lower.includes(skill.name.toLowerCase())) score += 10;
       for (const kw of skill.keywords) {
-        if (lower.includes(kw.toLowerCase())) {
-          score += 8;
-        }
+        if (lower.includes(kw.toLowerCase())) score += 8;
       }
       const descTokens = tokenize(skill.description.toLowerCase());
       for (const word of descTokens) {
-        if (promptTokenSet.has(word)) {
-          score += 3 * idf(word);
-        }
+        if (promptTokenSet.has(word)) score += 3 * idf(word);
       }
       const contentTokens = tokenize(skill.content.toLowerCase());
       for (const word of contentTokens) {
-        if (promptTokenSet.has(word)) {
-          score += 0.5 * idf(word);
-        }
+        if (promptTokenSet.has(word)) score += 0.5 * idf(word);
       }
       const promptBigrams = bigrams(promptTokens);
       const descBigrams = bigrams(descTokens);
       for (const bg of descBigrams) {
         if (promptBigrams.has(bg)) score += 5;
       }
-      if (score > 0) {
-        scored.push({ skill, score });
-      }
+      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;
   }
   /**
-   * Build a lightweight prompt section with skill descriptions only.
-   * Full skill content is loaded on-demand via the skill_invoke tool.
+   * 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() {
-    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;
+  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 || "";
@@ -1937,14 +2050,12 @@ 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;
   }
-  /**
-   * @deprecated Use buildSkillDescriptions() + skill_invoke tool instead.
-   */
+  /** @deprecated Use buildSkillDescriptions() + skill_invoke tool instead. */
   buildSkillPrompt(taskPrompt) {
     const relevant = this.findRelevant(taskPrompt);
     if (relevant.length === 0) return "";
@@ -1961,40 +2072,23 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     }
     return prompt;
   }
-  /**
-   * Create a new skill. Saves to `skills` table only (as private draft).
-   * The skill is NOT added to user's active collection (agent_skills) until
-   * the user approves it via addSkill().
-   *
-   * Returns { id, name } of the created skill, or null on failure.
-   */
   async create(name, description, content, options) {
     if (!this.userId) return null;
     try {
-      const sb = getSupabase();
-      const source = options?.source || "manual";
-      const metadata = {};
-      if (options?.emoji) {
-        metadata.openclaw = { emoji: options.emoji };
-      }
-      if (options?.variables && options.variables.length > 0) {
-        metadata.variables = options.variables;
-      }
-      const { data, error } = await sb.rpc("create_skill", {
-        p_user_id: this.userId,
-        p_name: name,
-        p_description: description,
-        p_content: content,
-        p_version: "1.0.0",
-        p_source: source,
-        p_emoji: options?.emoji || null,
-        p_keywords: options?.keywords || [],
-        p_metadata: metadata
-      });
-      if (error) {
-        log.debug(`Skill create failed for "${name}": ${error.message}`);
-        return null;
-      }
+      const metadata = options?.emoji ? { openclaw: { emoji: options.emoji } } : {};
+      const data = await callMcpHandler(
+        "skill.create",
+        {
+          name,
+          description,
+          content,
+          version: "1.0.0",
+          source: options?.source || "manual",
+          emoji: options?.emoji || null,
+          keywords: options?.keywords || [],
+          metadata
+        }
+      );
       const row = Array.isArray(data) ? data[0] : data;
       if (!row) {
         log.debug(`Skill create returned no data for "${name}"`);
@@ -2002,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) {
@@ -2009,45 +2121,15 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       return null;
     }
   }
-  /**
-   * Add a skill to the user's active collection (agent_skills).
-   * Copies content from the skills table.
-   * This is the "approval" step — after this, the skill is usable.
-   */
   async addSkill(skillId) {
     if (!this.userId) return null;
     try {
-      const sb = getSupabase();
-      const { data: pub, error: fetchErr } = await sb.from("skills").select("*").eq("id", skillId).eq("is_active", true).single();
-      if (fetchErr || !pub) {
-        log.debug(`Skill not found: ${skillId}`);
-        return null;
-      }
-      const row = pub;
-      const { data, error } = await sb.rpc("upsert_agent_skill", {
-        p_user_id: this.userId,
-        p_name: row.name,
-        p_description: row.description || "",
-        p_content: row.content,
-        p_version: row.version || "1.0.0",
-        p_source: row.source || "manual",
-        p_emoji: row.emoji || null,
-        p_keywords: row.keywords || [],
-        p_source_skill_id: skillId
-      });
-      if (error) {
-        log.debug(`addSkill failed: ${error.message}`);
-        return null;
-      }
-      try {
-        await sb.rpc("increment_install_count", { p_skill_id: skillId });
-      } catch {
-        try {
-          await sb.from("skills").update({ install_count: (row.install_count || 0) + 1 }).eq("id", skillId);
-        } catch {
-        }
-      }
-      const agentSkillRow = data && typeof data === "object" ? data : row;
+      const result = await callMcpHandler(
+        "skill.fetch_and_add",
+        { skill_id: skillId }
+      );
+      const row = result.skill;
+      const agentSkillRow = result.agent_skill && typeof result.agent_skill === "object" ? result.agent_skill : row;
       const skill = this.rowToSkill({
         ...agentSkillRow,
         name: row.name,
@@ -2056,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) {
@@ -2064,34 +2146,24 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       return null;
     }
   }
-  /**
-   * Remove a skill from user's collection (soft-delete in agent_skills).
-   */
   remove(name) {
     const skill = this.skills.get(name);
     if (!skill) return false;
     this.skills.delete(name);
+    this.invalidateCaches();
     this.removeFromDb(name).catch(() => {
     });
     return true;
   }
-  /**
-   * List skills with summary info.
-   */
   listFormatted() {
     const skills = this.getAll();
-    if (skills.length === 0) {
-      return "No skills in your collection.";
-    }
+    if (skills.length === 0) return "No skills in your collection.";
     return skills.map((s) => {
       const emoji = s.metadata.emoji || "";
       return `  ${emoji ? emoji + " " : ""}${s.name} (${s.version}) [${s.source}]
     ${s.description}`;
     }).join("\n\n");
   }
-  /**
-   * Check if a skill with a similar name already exists in user's collection.
-   */
   findSimilar(name) {
     if (this.skills.has(name)) return this.skills.get(name);
     const normalizedName = name.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -2112,10 +2184,6 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     }
     return null;
   }
-  /**
-   * Update an existing skill in user's collection.
-   * Bumps the patch version automatically. Also updates skills table if user is author.
-   */
   update(name, newContent, description) {
     const skill = this.skills.get(name);
     if (!skill) return false;
@@ -2126,68 +2194,47 @@ _(${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(() => {
     });
     if (skill.sourceSkillId && this.userId) {
-      const sb = getSupabase();
-      void (async () => {
-        try {
-          await sb.from("skills").update({ content: newContent, description: newDescription, version: newVersion }).eq("id", skill.sourceSkillId).eq("author_id", this.userId);
-        } catch {
-        }
-      })();
+      callMcpHandler("skill.update_source", {
+        source_skill_id: skill.sourceSkillId,
+        content: newContent,
+        description: newDescription,
+        version: newVersion
+      }).catch(() => {
+      });
     }
     log.info(`Skill "${name}" updated to v${newVersion}`);
     return true;
   }
   // ── DB Integration ─────────────────────────────────────────────────
-  /**
-   * Persist a skill to agent_skills via upsert_agent_skill().
-   * Fire-and-forget: failures are logged but don't block.
-   */
   async syncToAgentSkills(name, description, content, version2, options) {
     if (!this.userId) return;
     try {
-      const sb = getSupabase();
-      const metadata = {};
-      if (options?.variables && options.variables.length > 0) {
-        metadata.variables = options.variables;
-      }
-      const { data, error } = await sb.rpc("upsert_agent_skill", {
-        p_user_id: this.userId,
-        p_name: name,
-        p_description: description,
-        p_content: content,
-        p_version: version2,
-        p_source: options?.source || "manual",
-        p_emoji: options?.emoji || null,
-        p_keywords: options?.keywords || [],
-        p_change_summary: options?.changeSummary || null,
-        p_source_skill_id: options?.sourceSkillId || null,
-        p_metadata: Object.keys(metadata).length > 0 ? metadata : null
+      const data = await callMcpHandler("skill.upsert", {
+        name,
+        description,
+        content,
+        version: version2,
+        source: options?.source || "manual",
+        emoji: options?.emoji || null,
+        keywords: options?.keywords || [],
+        change_summary: options?.changeSummary || null,
+        source_skill_id: options?.sourceSkillId || null
       });
-      if (error) {
-        log.debug(`DB skill sync failed for "${name}": ${error.message}`);
-        return;
-      }
       const skill = this.skills.get(name);
       if (skill && data && typeof data === "object" && "id" in data) {
         skill.dbId = data.id;
       }
-      if (skill && options?.variables) {
-        skill.variables = options.variables;
-      }
       log.debug(`Skill "${name}" synced to agent_skills`);
     } catch (err) {
       log.debug(`DB skill sync error for "${name}": ${err}`);
     }
   }
-  /**
-   * Log a skill invocation to agent_skill_invocations.
-   * Fire-and-forget: failures don't block task execution.
-   */
   async logInvocation(skillName, options) {
     if (!this.userId) return;
     const skill = this.skills.get(skillName);
@@ -2197,39 +2244,24 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       return;
     }
     try {
-      const sb = getSupabase();
-      const { error } = await sb.from("agent_skill_invocations").insert({
+      await callMcpHandler("skill.log_invocation", {
         skill_id: skillDbId,
-        user_id: this.userId,
         message_id: options?.messageId || null,
         session_id: options?.sessionId || null,
         task_prompt: options?.taskPrompt?.slice(0, 500) || null,
         arguments: options?.arguments || null,
         success: options?.success ?? null
       });
-      if (error) {
-        log.debug(`Invocation log failed: ${error.message}`);
-      }
     } catch (err) {
       log.debug(`Invocation log error: ${err}`);
     }
   }
-  /**
-   * Search user's skills in DB using full-text search.
-   * Falls back to in-memory findRelevant() if DB is unavailable.
-   */
-  async searchDb(query2, limit = 10) {
+  async searchDb(query3, limit = 10) {
     if (this.userId) {
       try {
-        const sb = getSupabase();
-        const { data, error } = await sb.rpc("search_agent_skills", {
-          p_user_id: this.userId,
-          p_query: query2,
-          p_limit: limit
-        });
-        if (!error && data) {
-          const rows = data;
-          return rows.map((row) => ({
+        const data = await callMcpHandler("skill.search", { query: query3, limit });
+        if (data) {
+          return data.map((row) => ({
             name: row.name,
             description: row.description || "",
             emoji: row.emoji || "",
@@ -2240,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,
@@ -2249,21 +2281,14 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       invocationCount: 0
     }));
   }
-  /**
-   * Remove a skill from DB (soft-delete).
-   */
   async removeFromDb(name) {
     if (!this.userId) return;
     try {
-      const sb = getSupabase();
-      await sb.from("agent_skills").update({ is_active: false }).eq("user_id", this.userId).eq("name", name);
+      await callMcpHandler("skill.remove", { name });
     } catch {
     }
   }
   // ── Marketplace ────────────────────────────────────────────────────
-  /**
-   * Publish a skill to the marketplace (sets is_public = true in skills table).
-   */
   async publish(name, options) {
     if (!this.userId) return null;
     const skill = this.skills.get(name);
@@ -2273,31 +2298,21 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       return null;
     }
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.from("skills").upsert(
-        {
-          name: skill.name,
-          description: skill.description,
-          version: skill.version,
-          emoji: skill.metadata.emoji || null,
-          content: skill.content,
-          argument_hint: skill.argumentHint || null,
-          keywords: skill.keywords,
-          allowed_tools: skill.allowedTools,
-          author_id: this.userId,
-          author_name: options?.authorName || null,
-          metadata: skill.metadata,
-          homepage: skill.homepage || null,
-          category: options?.category || null,
-          source: skill.source,
-          is_public: true
-        },
-        { onConflict: "author_id,name" }
-      ).select("id").single();
-      if (error) {
-        log.debug(`Publish failed for "${name}": ${error.message}`);
-        return null;
-      }
+      const data = await callMcpHandler("skill.publish", {
+        name: skill.name,
+        description: skill.description,
+        version: skill.version,
+        emoji: skill.metadata.emoji || null,
+        content: skill.content,
+        argument_hint: skill.argumentHint || null,
+        keywords: skill.keywords,
+        allowed_tools: skill.allowedTools,
+        author_name: options?.authorName || null,
+        metadata: skill.metadata,
+        homepage: skill.homepage || null,
+        category: options?.category || null,
+        source: skill.source
+      });
       log.info(`Skill "${name}" published to marketplace`);
       return data;
     } catch (err) {
@@ -2305,21 +2320,16 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       return null;
     }
   }
-  /**
-   * Browse marketplace skills (public + active).
-   */
   async browse(options) {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("browse_skills", {
-        p_query: options?.query || null,
-        p_category: options?.category || null,
-        p_sort: options?.sort || "popular",
-        p_limit: options?.limit || 20,
-        p_offset: options?.offset || 0
+      const data = await callMcpHandler("skill.browse", {
+        query: options?.query || null,
+        category: options?.category || null,
+        sort: options?.sort || "popular",
+        limit: options?.limit || 20,
+        offset: options?.offset || 0
       });
-      if (error || !data) return [];
-      return data.map((r) => ({
+      return (data || []).map((r) => ({
         id: r.id,
         name: r.name,
         description: r.description || "",
@@ -2335,53 +2345,17 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
       return [];
     }
   }
-  // ── Variable Configuration ──────────────────────────────────────────
-  /**
-   * Update user-specific variable values (config) for a skill.
-   * Persists to agent_skills.config in DB and updates in-memory.
-   */
-  async updateConfig(skillName, config) {
-    const skill = this.skills.get(skillName);
-    if (!skill) return false;
-    const merged = { ...skill.config || {}, ...config };
-    skill.config = merged;
-    if (this.userId && skill.dbId) {
-      try {
-        const sb = getSupabase();
-        await sb.from("agent_skills").update({ config: merged }).eq("id", skill.dbId).eq("user_id", this.userId);
-        log.debug(`Config updated for skill "${skillName}"`);
-      } catch (err) {
-        log.debug(`Config update failed for "${skillName}": ${err}`);
-      }
-    }
-    return true;
-  }
-  /**
-   * Get the unresolved (unconfigured) variables for a skill.
-   * Returns variables that are required but have no value in config.
-   */
-  getUnconfiguredVariables(skillName) {
-    const skill = this.skills.get(skillName);
-    if (!skill?.variables) return [];
-    return skill.variables.filter((v) => {
-      if (!v.required) return false;
-      const value = skill.config?.[v.name];
-      return value === void 0 || value === null || value === "";
-    });
-  }
 };
-function substituteVariables(content, config, variables) {
-  if (!content.includes("{{")) return content;
-  return content.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
-    const value = config?.[varName];
-    if (value !== void 0 && value !== null) {
-      if (Array.isArray(value)) return value.join(", ");
-      return String(value);
-    }
-    const varDef = variables?.find((v) => v.name === varName);
-    if (varDef?.default !== void 0) return varDef.default;
-    return `{{${varName}: [NOT CONFIGURED]}}`;
-  });
+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+/);
@@ -2400,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 {
@@ -2443,7 +2595,7 @@ import { z } from "zod/v4";
 
 // src/tools/filesystem.ts
 import { readFile, writeFile, readdir, stat, mkdir } from "fs/promises";
-import { resolve, relative, join as join2 } from "path";
+import { resolve, relative, join as join3 } from "path";
 import { glob } from "glob";
 function assertWithinWorkspace(filePath) {
   const config = getConfig();
@@ -2480,7 +2632,7 @@ async function searchFiles(pattern, directory) {
     ignore: ["node_modules/**", ".git/**", "dist/**", ".next/**"]
   });
   if (matches.length === 0) return "No files found matching the pattern.";
-  return matches.slice(0, 50).map((m) => relative(config.workspacePath, join2(cwd, m))).join("\n");
+  return matches.slice(0, 50).map((m) => relative(config.workspacePath, join3(cwd, m))).join("\n");
 }
 async function listDirectory(path) {
   const config = getConfig();
@@ -2490,7 +2642,7 @@ async function listDirectory(path) {
   for (const entry of entries) {
     if (entry.name.startsWith(".") && entry.name !== ".env.example") continue;
     const icon = entry.isDirectory() ? "\u{1F4C1}" : "\u{1F4C4}";
-    const info = entry.isFile() ? await stat(join2(resolved, entry.name)).then(
+    const info = entry.isFile() ? await stat(join3(resolved, entry.name)).then(
       (s) => ` (${formatSize(s.size)})`
     ) : "";
     results.push(`${icon} ${entry.name}${info}`);
@@ -2514,11 +2666,11 @@ async function searchContent(pattern, fileGlob, directory) {
   const results = [];
   for (const file of files.slice(0, 200)) {
     try {
-      const content = await readFile(join2(cwd, file), "utf-8");
+      const content = await readFile(join3(cwd, file), "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (regex.test(lines[i])) {
-          const relPath = relative(config.workspacePath, join2(cwd, file));
+          const relPath = relative(config.workspacePath, join3(cwd, file));
           results.push(`${relPath}:${i + 1}: ${lines[i].trim()}`);
           regex.lastIndex = 0;
           if (results.length >= 30) break;
@@ -3044,26 +3196,23 @@ function createAgentToolsServer(deps) {
       ),
       tool(
         "skill_create",
-        "Create a new skill and add it to the user's collection. Returns the skill ID on success. Use {{variable_name}} syntax in instructions for user-specific data (e.g. {{github_repos}}, {{slack_channel}}).",
+        "Create a new skill and add it to the user's collection. Returns the skill ID on success.",
         {
           name: z.string().describe("Skill name in kebab-case, e.g. 'flight-booking'"),
           description: z.string().describe("One-line description of what this skill does"),
-          instructions: z.string().describe(
-            "Markdown step-by-step instructions. Use {{variable_name}} placeholders for user-specific data (e.g. {{github_repos}}, {{trello_board}}, {{slack_channel}}). These will be resolved with user's config at invoke time."
-          ),
-          emoji: z.string().optional().describe("Single emoji representing this skill"),
-          variables: z.array(z.object({
-            name: z.string().describe("Variable name matching {{name}} in instructions"),
-            description: z.string().describe("Human-readable description of what this variable is for"),
-            type: z.enum(["string", "string[]", "number", "boolean"]).describe("Data type"),
-            required: z.boolean().describe("Whether the skill needs this to function"),
-            default: z.string().optional().describe("Default value if user doesn't configure"),
-            example: z.string().optional().describe("Example value to guide the user")
-          })).optional().describe(
-            "Variables that need user-specific configuration. Define one for each {{variable}} used in instructions."
-          )
+          instructions: z.string().describe("Markdown step-by-step instructions"),
+          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 {
@@ -3079,11 +3228,7 @@ function createAgentToolsServer(deps) {
             args.name,
             args.description,
             args.instructions,
-            {
-              source: "manual",
-              emoji: args.emoji,
-              variables: args.variables
-            }
+            { source: "manual", emoji: args.emoji }
           );
           if (!result) {
             return {
@@ -3098,30 +3243,17 @@ function createAgentToolsServer(deps) {
             {
               source: "manual",
               emoji: args.emoji,
-              sourceSkillId: result.id,
-              variables: args.variables
+              sourceSkillId: result.id
             }
           );
-          let responseText = `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`;
-          if (args.variables && args.variables.length > 0) {
-            const requiredVars = args.variables.filter((v) => v.required);
-            if (requiredVars.length > 0) {
-              responseText += `
-
-**Variables that need configuration:**
-`;
-              for (const v of requiredVars) {
-                const example = v.example ? ` (e.g. ${v.example})` : "";
-                responseText += `- \`{{${v.name}}}\`: ${v.description}${example}
-`;
-              }
-              responseText += `
-Use \`skill_configure\` to set these values for the user, or ask the user to provide them.`;
-            }
-          }
           log.success(`Skill "${args.name}" created and added to collection`);
           return {
-            content: [{ type: "text", text: responseText }]
+            content: [
+              {
+                type: "text",
+                text: `Skill "${args.name}" created and added to your collection (ID: ${result.id}).`
+              }
+            ]
           };
         }
       ),
@@ -3193,7 +3325,6 @@ Use \`skill_configure\` to set these values for the user, or ask the user to pro
             };
           }
           let content = skill.content;
-          content = substituteVariables(content, skill.config, skill.variables);
           if (args.arguments) {
             content = substituteArguments(content, args.arguments);
           }
@@ -3212,18 +3343,6 @@ ${content}`;
 **Allowed tools for this skill:** ${skill.allowedTools.join(", ")}
 `;
           }
-          const unconfigured = skillManager.getUnconfiguredVariables(args.name);
-          if (unconfigured.length > 0) {
-            response += `
-
-**\u26A0 Unconfigured variables \u2014 use \`skill_configure\` to set these:**
-`;
-            for (const v of unconfigured) {
-              const example = v.example ? ` (e.g. ${v.example})` : "";
-              response += `- \`{{${v.name}}}\`: ${v.description}${example}
-`;
-            }
-          }
           log.info(`Skill invoked: "${args.name}"`);
           skillManager.logInvocation(args.name, {
             messageId: taskId,
@@ -3263,53 +3382,6 @@ ${content}`;
           return { content: [{ type: "text", text: response }] };
         }
       ),
-      tool(
-        "skill_configure",
-        "Set user-specific variable values for a skill. Variables are defined in the skill template (e.g. {{github_repos}}) and need to be configured with the user's actual data before the skill can work properly.",
-        {
-          name: z.string().describe("Name of the skill to configure"),
-          config: z.record(z.unknown()).describe(
-            'Key-value pairs of variable values. Keys must match variable names defined in the skill. Example: {"github_repos": ["octocat/hello-world", "myorg/myrepo"], "github_username": "octocat"}'
-          )
-        },
-        async (args) => {
-          const skill = skillManager.get(args.name);
-          if (!skill) {
-            const available = skillManager.getAll().map((s) => s.name).join(", ");
-            return {
-              content: [{
-                type: "text",
-                text: `Skill "${args.name}" not found. Available: ${available}`
-              }]
-            };
-          }
-          const updated = await skillManager.updateConfig(args.name, args.config);
-          if (!updated) {
-            return {
-              content: [{ type: "text", text: `Failed to update config for "${args.name}".` }]
-            };
-          }
-          const unconfigured = skillManager.getUnconfiguredVariables(args.name);
-          let responseText = `Configuration updated for skill "${args.name}".`;
-          if (unconfigured.length > 0) {
-            responseText += `
-
-**Still needs configuration:**
-`;
-            for (const v of unconfigured) {
-              const example = v.example ? ` (e.g. ${v.example})` : "";
-              responseText += `- \`{{${v.name}}}\`: ${v.description}${example}
-`;
-            }
-          } else {
-            responseText += ` All required variables are configured.`;
-          }
-          log.info(`Config updated for skill "${args.name}": ${Object.keys(args.config).join(", ")}`);
-          return {
-            content: [{ type: "text", text: responseText }]
-          };
-        }
-      ),
       tool(
         "skill_generate",
         "Prepare context for generating skills from a job description. Returns existing skills and job info so you can analyze the job and create skills using skill_create (which auto-adds to user's collection). After creating all skills, call skill_link_job to link them to the job and mark it as analyzed.",
@@ -3358,8 +3430,6 @@ ${content}`;
           response += `- instructions: detailed step-by-step markdown instructions the agent can follow
 `;
           response += `- emoji: a single emoji representing the skill
-`;
-          response += `- variables: define user-specific data needed by the skill (see below)
 
 `;
           response += `skill_create automatically adds the skill to the user's collection \u2014 no need to call skill_add.
@@ -3376,59 +3446,9 @@ ${content}`;
 `;
           response += `- Include error handling steps
 `;
-          response += `- Each skill should be a single, well-defined workflow (10-25 steps)
-
-`;
-          response += `**IMPORTANT \u2014 Use {{variables}} for user-specific data:**
-`;
-          response += `Skills often need user-specific information (accounts, repos, boards, channels, etc.).
-`;
-          response += `Instead of hardcoding or asking at runtime, use \`{{variable_name}}\` placeholders in instructions.
-
-`;
-          response += `Example: A GitHub PR review skill should use \`{{github_repos}}\` in its instructions:
-`;
-          response += `  "Navigate to each repository in {{github_repos}} and check for open PRs..."
-
-`;
-          response += `For each \`{{variable}}\` used in instructions, add a matching entry in the \`variables\` array:
-`;
-          response += `\`\`\`json
-`;
-          response += `{
-`;
-          response += `  "name": "github_repos",
-`;
-          response += `  "description": "GitHub repositories to monitor (owner/repo format)",
-`;
-          response += `  "type": "string[]",
-`;
-          response += `  "required": true,
+          response += `- Use placeholders like {query}, {date} for variable inputs
 `;
-          response += `  "example": "octocat/hello-world, myorg/myrepo"
-`;
-          response += `}
-`;
-          response += `\`\`\`
-
-`;
-          response += `Common variables by platform:
-`;
-          response += `- GitHub: github_repos, github_username, github_org
-`;
-          response += `- Trello: trello_board_url, trello_list_names
-`;
-          response += `- Slack: slack_channels, slack_workspace_url
-`;
-          response += `- Email: email_labels, email_filters
-`;
-          response += `- E-commerce: store_url, competitor_urls, product_categories
-`;
-          response += `- General: timezone, language, notification_channel
-
-`;
-          response += `After creating skills, if any have required variables, call \`skill_configure\` to set initial values `;
-          response += `(ask the user for the values first).
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)
 `;
           return { content: [{ type: "text", text: response }] };
         }
@@ -3565,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.",
@@ -3597,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})`);
@@ -3721,8 +3801,10 @@ ${content}`;
           const tz = args.timezone || "UTC";
           try {
             const task = await createScheduledTask(userId, name, prompt, args.cron, tz);
-            const sb = getSupabase();
-            await sb.from("agent_scheduled_tasks").update({ job_id: job.jobId }).eq("id", task.id);
+            await callMcpHandler("schedule.link_job", {
+              task_id: task.id,
+              job_id: job.jobId
+            });
             const nextRun = task.next_run_at ? new Date(task.next_run_at).toLocaleString() : "calculating...";
             let response = `## Job Scheduled: ${args.job_name}
 
@@ -3825,20 +3907,14 @@ ${content}`;
     ]
   });
 }
-async function saveJobToDb(userId, jobName, jobDescription, createdSkillNames) {
+async function saveJobToDb(_userId, jobName, jobDescription, createdSkillNames) {
   try {
-    const sb = getSupabase();
-    const { data, error } = await sb.rpc("save_job_with_skills", {
-      p_user_id: userId,
-      p_job_name: jobName,
-      p_job_description: jobDescription,
-      p_skill_names: createdSkillNames
+    const data = await callMcpHandler("job.save_with_skills", {
+      job_name: jobName,
+      job_description: jobDescription,
+      skill_names: createdSkillNames
     });
-    if (error) {
-      log.debug(`Failed to save job "${jobName}" via RPC: ${error.message}`);
-      return;
-    }
-    log.debug(`Job "${jobName}" saved via RPC (id: ${data}), ${createdSkillNames.length} skill(s) linked`);
+    log.debug(`Job "${jobName}" saved via edge function (id: ${data}), ${createdSkillNames.length} skill(s) linked`);
   } catch (err) {
     log.debug(`saveJobToDb error: ${err}`);
   }
@@ -3923,15 +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
-   - Skills use {{variable_name}} placeholders for user-specific data (repos, channels, boards, etc.)
-   - Use skill_configure to set variable values after creating skills or when the user provides their data
+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
@@ -3968,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;
@@ -3992,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();
@@ -4001,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);
@@ -4014,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;
       }
@@ -4065,13 +4172,13 @@ var TaskProcessor = class {
         "mcp__assistme-agent__skill_improve",
         "mcp__assistme-agent__skill_invoke",
         "mcp__assistme-agent__skill_search",
-        "mcp__assistme-agent__skill_configure",
         "mcp__assistme-agent__skill_generate",
         "mcp__assistme-agent__skill_link_job",
         "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",
@@ -4103,7 +4210,7 @@ var TaskProcessor = class {
           "assistme-agent": agentToolsServer
         },
         hooks: eventHooks,
-        persistSession: false,
+        persistSession: true,
         abortController
       };
       const taskStartTime = Date.now();
@@ -4111,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
         })) {
@@ -4163,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;
           }
@@ -4183,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}`);
@@ -4362,9 +4475,8 @@ import chalk5 from "chalk";
 function registerStatusCommand(program2) {
   program2.command("status").description("Check the status of the current agent session").action(async () => {
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-      const { data: sessions } = await sb.from("agent_sessions").select("*").eq("user_id", userId).in("status", ["online", "busy"]).order("started_at", { ascending: false }).limit(5);
+      await getCurrentUserId();
+      const sessions = await getActiveSessions(5);
       if (!sessions || sessions.length === 0) {
         console.log(chalk5.yellow("No active sessions found."));
         console.log('Run "assistme" to begin a new session.');
@@ -4563,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}`);
       }
@@ -4641,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}]`);
@@ -4745,7 +4857,7 @@ function registerJobCommands(program2) {
   jobCmd.command("list").description("List your defined jobs").action(async () => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-XTGLMPZ3.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-N4XAAWLJ.js");
       const runner = new JobRunner2(userId);
       const jobs = await runner.listJobs();
       if (jobs.length === 0) {
@@ -4773,7 +4885,7 @@ function registerJobCommands(program2) {
   jobCmd.command("status [name]").description("Show run history for a job (or all jobs)").option("-l, --limit <number>", "Max runs to show (default: 5)").action(async (name, opts) => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-XTGLMPZ3.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-N4XAAWLJ.js");
       const runner = new JobRunner2(userId);
       const runs = await runner.getRunHistory(
         name,
@@ -4827,7 +4939,7 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`
         process.exit(1);
       }
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-XTGLMPZ3.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-N4XAAWLJ.js");
       const runner = new JobRunner2(userId);
       const job = await runner.loadJob(name);
       if (!job) {
@@ -4849,8 +4961,10 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`
         opts.cron,
         tz
       );
-      const sb = getSupabase();
-      await sb.from("agent_scheduled_tasks").update({ job_id: job.jobId }).eq("id", task.id);
+      await callMcpHandler("schedule.link_job", {
+        task_id: task.id,
+        job_id: job.jobId
+      });
       log.success(`Job "${name}" scheduled: ${opts.cron} (${tz})`);
       console.log(`  Skills: ${job.skills.length}`);
       console.log(