assistme 0.2.8 → 0.2.9

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();
@@ -1493,29 +1656,24 @@ import {
 
 // 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;
   }
@@ -1523,27 +1681,15 @@ var MemoryManager = class {
    * 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}`);
+    try {
+      return await callMcpHandler("memory.search", {
+        query: query2,
+        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,16 @@ var SkillManager = class {
   skills = /* @__PURE__ */ new Map();
   idfCache = /* @__PURE__ */ new Map();
   userId = null;
-  /** Budget for skill descriptions in system prompt (characters). */
   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 +1923,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 || "",
@@ -1832,15 +1939,9 @@ var SkillManager = class {
       filePath: "",
       source: row.source || "manual",
       dbId: row.id,
-      sourceSkillId: row.source_skill_id || void 0,
-      variables,
-      config
+      sourceSkillId: row.source_skill_id || void 0
     };
   }
-  /**
-   * Pre-compute IDF (Inverse Document Frequency) for all tokens across skills.
-   * Called once after loadFromDb(), avoids recomputing on every findRelevant() call.
-   */
   buildIdfCache() {
     this.idfCache.clear();
     const docFreq = /* @__PURE__ */ new Map();
@@ -1856,22 +1957,12 @@ 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 promptTokens = tokenize(lower);
@@ -1883,37 +1974,25 @@ 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);
   }
-  /**
-   * Build a lightweight prompt section with skill descriptions only.
-   * Full skill content is loaded on-demand via the skill_invoke tool.
-   */
   buildSkillDescriptions() {
     const skills = this.getAll().filter((s) => !s.disableModelInvocation).sort((a, b) => {
       if (a.metadata.always && !b.metadata.always) return -1;
@@ -1942,9 +2021,7 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     }
     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 +2038,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}"`);
@@ -2009,45 +2069,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,
@@ -2064,9 +2094,6 @@ _(${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;
@@ -2075,23 +2102,15 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     });
     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 +2131,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;
@@ -2131,63 +2146,41 @@ _(${skills.length - included} additional skills available \u2014 use skill_invok
     }).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 +2190,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) {
     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: query2, limit });
+        if (data) {
+          return data.map((row) => ({
             name: row.name,
             description: row.description || "",
             emoji: row.emoji || "",
@@ -2249,21 +2227,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 +2244,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 +2266,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,54 +2291,7 @@ _(${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 substituteArguments(content, args) {
   const parts = args.split(/\s+/);
   content = content.replace(/\$ARGUMENTS/g, args);
@@ -2443,7 +2352,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 +2389,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 +2399,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 +2423,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,24 +2953,12 @@ 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 existing = skillManager.findSimilar(args.name);
@@ -3079,11 +2976,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 +2991,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 +3073,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 +3091,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 +3130,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 +3178,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 +3194,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 += `- Use placeholders like {query}, {date} for variable inputs
 `;
-          response += `  "type": "string[]",
-`;
-          response += `  "required": true,
-`;
-          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 }] };
         }
@@ -3721,8 +3489,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 +3595,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}`);
   }
@@ -3930,8 +3694,6 @@ Available capabilities:
    - 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
 
 5. JOB AUTOMATION:
    - When the user describes their job/role/daily work, use skill_generate to decompose it into automatable skills
@@ -4065,7 +3827,6 @@ 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",
@@ -4362,9 +4123,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.');
@@ -4745,7 +4505,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 +4533,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 +4587,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 +4609,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(