assistme 0.2.8 → 0.2.9

package/dist/job-runner-N4XAAWLJ.js

@@ -0,0 +1,7 @@
+import {
+  JobRunner
+} from "./chunk-UWE5WVQI.js";
+import "./chunk-TTEGHE2E.js";
+export {
+  JobRunner
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,6 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.63",
-    "@supabase/supabase-js": "^2.76.0",
     "zod": "^4.0.0",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",

package/src/agent/job-runner.ts

@@ -1,4 +1,4 @@
-import { getSupabase } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 
 // ── Interfaces ─────────────────────────────────────────────────────
@@ -31,10 +31,8 @@ export interface JobRunInfo {
 // ── JobRunner ──────────────────────────────────────────────────────
 
 export class JobRunner {
-  private userId: string;
-
-  constructor(userId: string) {
-    this.userId = userId;
+  constructor(_userId: string) {
+    // userId is no longer needed — auth is handled by the MCP token in callMcpHandler
   }
 
   /**
@@ -43,13 +41,12 @@ export class JobRunner {
    */
   async loadJob(jobName: string): Promise<JobInfo | null> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("get_job_with_skills", {
-        p_user_id: this.userId,
-        p_job_name: jobName,
-      });
+      const data = await callMcpHandler<Array<Record<string, unknown>> | null>(
+        "job.get_with_skills",
+        { job_name: jobName },
+      );
 
-      if (error || !data || (data as unknown[]).length === 0) {
+      if (!data || (data as unknown[]).length === 0) {
         return null;
       }
 
@@ -79,33 +76,16 @@ export class JobRunner {
    */
   async listJobs(): Promise<Array<{ id: string; name: string; description: string; skillCount: number }>> {
     try {
-      const sb = getSupabase();
-
-      const { data: jobs, error } = await sb
-        .from("agent_jobs")
-        .select("id, name, description")
-        .eq("user_id", this.userId)
-        .eq("is_active", true)
-        .order("name");
-
-      if (error || !jobs) return [];
-
-      const result: Array<{ id: string; name: string; description: string; skillCount: number }> = [];
-      for (const job of jobs) {
-        const { count } = await sb
-          .from("agent_job_skills")
-          .select("id", { count: "exact", head: true })
-          .eq("job_id", job.id);
-
-        result.push({
-          id: job.id,
-          name: job.name,
-          description: job.description,
-          skillCount: count || 0,
-        });
-      }
-
-      return result;
+      const data = await callMcpHandler<Array<Record<string, unknown>>>(
+        "job.list",
+      );
+
+      return (data || []).map((row) => ({
+        id: row.id as string,
+        name: row.name as string,
+        description: row.description as string,
+        skillCount: (row.skill_count as number) || 0,
+      }));
     } catch (err) {
       log.debug(`Failed to list jobs: ${err}`);
       return [];
@@ -122,21 +102,13 @@ export class JobRunner {
     options?: { sessionId?: string; messageId?: string; triggerType?: string }
   ): Promise<string | null> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("create_job_run", {
-        p_user_id: this.userId,
-        p_job_id: jobId,
-        p_session_id: options?.sessionId || null,
-        p_message_id: options?.messageId || null,
-        p_trigger_type: options?.triggerType || "manual",
+      const data = await callMcpHandler<string>("job.create_run", {
+        job_id: jobId,
+        session_id: options?.sessionId || null,
+        message_id: options?.messageId || null,
+        trigger_type: options?.triggerType || "manual",
       });
-
-      if (error) {
-        log.debug(`Failed to create job run: ${error.message}`);
-        return null;
-      }
-
-      return data as string;
+      return data;
     } catch (err) {
       log.debug(`Job run creation error: ${err}`);
       return null;
@@ -152,17 +124,11 @@ export class JobRunner {
     status: "completed" | "failed" | "cancelled" = "completed",
     summary?: string
   ): Promise<void> {
-    const sb = getSupabase();
-    const { error } = await sb.rpc("complete_job_run", {
-      p_run_id: runId,
-      p_status: status,
-      p_summary: summary?.slice(0, 10000) || null,
-      p_user_id: this.userId,
+    await callMcpHandler("job.complete_run", {
+      run_id: runId,
+      status,
+      summary: summary?.slice(0, 10000) || null,
     });
-    if (error) {
-      log.error(`Failed to mark run ${runId} as ${status}: ${error.message}`);
-      throw new Error(`Run completion failed: ${error.message}`);
-    }
   }
 
   /**
@@ -170,16 +136,12 @@ export class JobRunner {
    */
   async getRunHistory(jobName?: string, limit = 10): Promise<JobRunInfo[]> {
     try {
-      const sb = getSupabase();
-      const { data, error } = await sb.rpc("get_job_runs", {
-        p_user_id: this.userId,
-        p_job_name: jobName || null,
-        p_limit: limit,
-      });
-
-      if (error || !data) return [];
+      const data = await callMcpHandler<Array<Record<string, unknown>>>(
+        "job.get_runs",
+        { job_name: jobName || null, limit },
+      );
 
-      return (data as Array<Record<string, unknown>>).map((row) => ({
+      return (data || []).map((row) => ({
         runId: row.run_id as string,
         jobName: row.job_name as string,
         status: row.status as string,

package/src/agent/mcp-servers.ts

@@ -8,9 +8,10 @@ import { executeTool } from "../tools/index.js";
 import { getLimiterForTool } from "../utils/rate-limiter.js";
 import { log } from "../utils/logger.js";
 import type { MemoryManager, MemoryCategory } from "./memory.js";
-import type { SkillManager, SkillVariable } from "./skills.js";
-import { substituteArguments, substituteVariables, preprocessDynamicContext } from "./skills.js";
-import { getSupabase, emitEvent, setActionRequest, pollActionResponse } from "../db/supabase.js";
+import type { SkillManager } from "./skills.js";
+import { substituteArguments, preprocessDynamicContext } from "./skills.js";
+import { emitEvent, setActionRequest, pollActionResponse } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { JobRunner } from "./job-runner.js";
 import {
   createScheduledTask,
@@ -214,26 +215,12 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
       ),
       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."
-          ),
+          instructions: z.string().describe("Markdown step-by-step instructions"),
           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."
-          ),
         },
         async (args) => {
           // Check for duplicates in user's collection
@@ -254,11 +241,7 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             args.name,
             args.description,
             args.instructions,
-            {
-              source: "manual",
-              emoji: args.emoji,
-              variables: args.variables as SkillVariable[] | undefined,
-            }
+            { source: "manual", emoji: args.emoji }
           );
 
           if (!result) {
@@ -277,27 +260,17 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
               source: "manual",
               emoji: args.emoji,
               sourceSkillId: result.id,
-              variables: args.variables as SkillVariable[] | undefined,
             }
           );
 
-          // Build response with variable info
-          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 += `\n\n**Variables that need configuration:**\n`;
-              for (const v of requiredVars) {
-                const example = v.example ? ` (e.g. ${v.example})` : "";
-                responseText += `- \`{{${v.name}}}\`: ${v.description}${example}\n`;
-              }
-              responseText += `\nUse \`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}).`,
+              },
+            ],
           };
         }
       ),
@@ -382,9 +355,6 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
 
           let content = skill.content;
 
-          // Substitute {{variable}} placeholders with user config values
-          content = substituteVariables(content, skill.config, skill.variables);
-
           // Substitute $ARGUMENTS placeholders
           if (args.arguments) {
             content = substituteArguments(content, args.arguments);
@@ -405,16 +375,6 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             response += `\n\n**Allowed tools for this skill:** ${skill.allowedTools.join(", ")}\n`;
           }
 
-          // Warn about unconfigured required variables
-          const unconfigured = skillManager.getUnconfiguredVariables(args.name);
-          if (unconfigured.length > 0) {
-            response += `\n\n**⚠ Unconfigured variables — use \`skill_configure\` to set these:**\n`;
-            for (const v of unconfigured) {
-              const example = v.example ? ` (e.g. ${v.example})` : "";
-              response += `- \`{{${v.name}}}\`: ${v.description}${example}\n`;
-            }
-          }
-
           log.info(`Skill invoked: "${args.name}"`);
 
           // Log invocation to DB (fire-and-forget)
@@ -457,56 +417,6 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
           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}".` }],
-            };
-          }
-
-          // Check if there are still unconfigured required variables
-          const unconfigured = skillManager.getUnconfiguredVariables(args.name);
-          let responseText = `Configuration updated for skill "${args.name}".`;
-
-          if (unconfigured.length > 0) {
-            responseText += `\n\n**Still needs configuration:**\n`;
-            for (const v of unconfigured) {
-              const example = v.example ? ` (e.g. ${v.example})` : "";
-              responseText += `- \`{{${v.name}}}\`: ${v.description}${example}\n`;
-            }
-          } 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 " +
@@ -542,39 +452,15 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
           response += `- name: kebab-case name (e.g. "slack-message-check")\n`;
           response += `- description: one-line description\n`;
           response += `- instructions: detailed step-by-step markdown instructions the agent can follow\n`;
-          response += `- emoji: a single emoji representing the skill\n`;
-          response += `- variables: define user-specific data needed by the skill (see below)\n\n`;
+          response += `- emoji: a single emoji representing the skill\n\n`;
           response += `skill_create automatically adds the skill to the user's collection — no need to call skill_add.\n\n`;
           response += `After ALL skills are created, call \`skill_link_job\` with job_name="${args.job_name}" and the list of created skill names to link them and mark the job as analyzed.\n\n`;
           response += `**Guidelines for skill instructions:**\n`;
           response += `- Write clear, actionable markdown steps\n`;
           response += `- Reference browser tools (browser_navigate, browser_click, browser_read_page, etc.) for web tasks\n`;
           response += `- Include error handling steps\n`;
-          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n\n`;
-          response += `**IMPORTANT — Use {{variables}} for user-specific data:**\n`;
-          response += `Skills often need user-specific information (accounts, repos, boards, channels, etc.).\n`;
-          response += `Instead of hardcoding or asking at runtime, use \`{{variable_name}}\` placeholders in instructions.\n\n`;
-          response += `Example: A GitHub PR review skill should use \`{{github_repos}}\` in its instructions:\n`;
-          response += `  "Navigate to each repository in {{github_repos}} and check for open PRs..."\n\n`;
-          response += `For each \`{{variable}}\` used in instructions, add a matching entry in the \`variables\` array:\n`;
-          response += `\`\`\`json\n`;
-          response += `{\n`;
-          response += `  "name": "github_repos",\n`;
-          response += `  "description": "GitHub repositories to monitor (owner/repo format)",\n`;
-          response += `  "type": "string[]",\n`;
-          response += `  "required": true,\n`;
-          response += `  "example": "octocat/hello-world, myorg/myrepo"\n`;
-          response += `}\n`;
-          response += `\`\`\`\n\n`;
-          response += `Common variables by platform:\n`;
-          response += `- GitHub: github_repos, github_username, github_org\n`;
-          response += `- Trello: trello_board_url, trello_list_names\n`;
-          response += `- Slack: slack_channels, slack_workspace_url\n`;
-          response += `- Email: email_labels, email_filters\n`;
-          response += `- E-commerce: store_url, competitor_urls, product_categories\n`;
-          response += `- General: timezone, language, notification_channel\n\n`;
-          response += `After creating skills, if any have required variables, call \`skill_configure\` to set initial values `;
-          response += `(ask the user for the values first).\n`;
+          response += `- Use placeholders like {query}, {date} for variable inputs\n`;
+          response += `- Each skill should be a single, well-defined workflow (10-25 steps)\n`;
 
           return { content: [{ type: "text", text: response }] };
         }
@@ -916,11 +802,10 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
             const task = await createScheduledTask(userId, name, prompt, args.cron, tz);
 
             // Link the job_id to the scheduled task
-            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()
@@ -1034,27 +919,19 @@ export function createAgentToolsServer(deps: AgentToolsDeps): McpSdkServerConfig
 // ── Helper: persist job and link skills ────────────────────────────
 
 async function saveJobToDb(
-  userId: string,
+  _userId: string,
   jobName: string,
   jobDescription: string,
   createdSkillNames: string[]
 ): Promise<void> {
   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}`);
   }

package/src/agent/memory.test.ts

@@ -1,45 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
-// Build a fluent mock that mimics the Supabase query builder chain
-function createSupabaseMock() {
-  let finalResult: Record<string, unknown> = { data: [], error: null };
-
-  const chain: Record<string, unknown> = {};
-  const methods = [
-    "select", "insert", "update", "delete", "eq", "neq", "not",
-    "or", "in", "order", "limit", "single", "from",
-  ];
-  for (const method of methods) {
-    chain[method] = vi.fn().mockReturnValue(chain);
-  }
-
-  // Make the chain thenable (for await)
-  chain.then = (resolve: (value: unknown) => void) => resolve(finalResult);
-  chain.single = vi.fn().mockImplementation(() => {
-    const singleChain = { ...chain, then: (resolve: (value: unknown) => void) => resolve(finalResult) };
-    return singleChain;
-  });
+const mockCallMcpHandler = vi.fn();
 
-  const mockSupabase = {
-    from: vi.fn().mockReturnValue(chain),
-    _chain: chain,
-    _setResult(result: Record<string, unknown>) {
-      finalResult = result;
-      chain.then = (resolve: (value: unknown) => void) => resolve(result);
-      chain.single = vi.fn().mockImplementation(() => ({
-        ...chain,
-        then: (resolve: (value: unknown) => void) => resolve(result),
-      }));
-    },
-  };
-
-  return mockSupabase;
-}
-
-let mockSb: ReturnType<typeof createSupabaseMock>;
-
-vi.mock("../db/supabase.js", () => ({
-  getSupabase: () => mockSb,
+vi.mock("../db/api-client.js", () => ({
+  callMcpHandler: (...args: unknown[]) => mockCallMcpHandler(...args),
 }));
 
 vi.mock("../utils/logger.js", () => ({
@@ -58,12 +22,11 @@ describe("MemoryManager", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockSb = createSupabaseMock();
     manager = new MemoryManager("user-123");
   });
 
   describe("remember()", () => {
-    it("inserts a memory with default values", async () => {
+    it("stores a memory with default values", async () => {
       const mockData = {
         id: "mem-1",
         user_id: "user-123",
@@ -77,16 +40,23 @@ describe("MemoryManager", () => {
         last_accessed_at: null,
         created_at: "2026-01-01",
       };
-      mockSb._setResult({ data: mockData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(mockData);
 
       const result = await manager.remember("User prefers dark mode");
 
-      expect(mockSb.from).toHaveBeenCalledWith("agent_memories");
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("memory.store", {
+        category: "general",
+        content: "User prefers dark mode",
+        importance: 5,
+        tags: [],
+        source_message_id: null,
+        expires_at: null,
+      });
       expect(result.content).toBe("User prefers dark mode");
       expect(result.category).toBe("general");
     });
 
-    it("inserts with custom category and importance", async () => {
+    it("stores with custom category and importance", async () => {
       const mockData = {
         id: "mem-2",
         user_id: "user-123",
@@ -100,7 +70,7 @@ describe("MemoryManager", () => {
         last_accessed_at: null,
         created_at: "2026-01-01",
       };
-      mockSb._setResult({ data: mockData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(mockData);
 
       const result = await manager.remember("Likes TypeScript", "preference", {
         importance: 8,
@@ -112,12 +82,10 @@ describe("MemoryManager", () => {
       expect(result.importance).toBe(8);
     });
 
-    it("throws on DB error", async () => {
-      mockSb._setResult({ data: null, error: { message: "DB down" } });
+    it("throws on edge function error", async () => {
+      mockCallMcpHandler.mockRejectedValueOnce(new Error("Edge function error"));
 
-      await expect(manager.remember("test")).rejects.toThrow(
-        "Failed to store memory"
-      );
+      await expect(manager.remember("test")).rejects.toThrow();
     });
 
     it("computes expiry from expiresInDays", async () => {
@@ -134,46 +102,54 @@ describe("MemoryManager", () => {
         last_accessed_at: null,
         created_at: "2026-01-01",
       };
-      mockSb._setResult({ data: mockData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(mockData);
 
       const result = await manager.remember("temp context", "context", {
         expiresInDays: 7,
       });
 
       expect(result.expires_at).not.toBeNull();
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "memory.store",
+        expect.objectContaining({
+          expires_at: expect.any(String),
+        })
+      );
     });
   });
 
   describe("buildMemoryPrompt()", () => {
     it("returns empty string when no memories", async () => {
-      mockSb._setResult({ data: [], error: null });
+      mockCallMcpHandler.mockResolvedValueOnce([]);
       const result = await manager.buildMemoryPrompt();
       expect(result).toBe("");
     });
   });
 
   describe("list()", () => {
-    it("queries agent_memories with user_id filter", async () => {
-      mockSb._setResult({ data: [], error: null });
+    it("calls memory.list action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce([]);
       await manager.list();
-      expect(mockSb.from).toHaveBeenCalledWith("agent_memories");
-      expect(mockSb._chain.eq).toHaveBeenCalledWith("user_id", "user-123");
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("memory.list", {
+        category: null,
+        limit: 20,
+      });
     });
 
-    it("throws on DB error", async () => {
-      mockSb._setResult({ data: null, error: { message: "fail" } });
-      await expect(manager.list()).rejects.toThrow("Failed to list memories");
+    it("returns empty array on null response", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(null);
+      const result = await manager.list();
+      expect(result).toEqual([]);
     });
   });
 
   describe("remove()", () => {
-    it("calls delete on agent_memories", async () => {
-      mockSb._setResult({ error: null });
+    it("calls memory.remove action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await manager.remove("mem-1");
-      expect(mockSb.from).toHaveBeenCalledWith("agent_memories");
-      expect(mockSb._chain.delete).toHaveBeenCalled();
-      expect(mockSb._chain.eq).toHaveBeenCalledWith("id", "mem-1");
-      expect(mockSb._chain.eq).toHaveBeenCalledWith("user_id", "user-123");
+      expect(mockCallMcpHandler).toHaveBeenCalledWith("memory.remove", {
+        memory_id: "mem-1",
+      });
     });
   });
 });