@mgsoftwarebv/mg-dashboard-mcp 2.6.3 → 2.7.0

package/dist/index.js

@@ -376,339 +376,13 @@ ${rawJson.substring(0, 500)}`
 }
 
 // src/agent-tools.ts
-var VALID_FINDING_TYPES = /* @__PURE__ */ new Set([
-  "missing_docs",
-  "inaccurate",
-  "incomplete",
-  "outdated",
-  "improvement",
-  "n_plus_1_query",
-  "bundle_size",
-  "unnecessary_rerender",
-  "slow_endpoint",
-  "memory_leak",
-  "missing_memoization",
-  "large_dependency",
-  "dead_code",
-  "unused_dependency",
-  "env_leak",
-  "i18n_missing_key",
-  "i18n_unused_key"
-]);
-var VALID_SEVERITIES = /* @__PURE__ */ new Set(["info", "warning", "critical"]);
-var VALID_SCOPES = /* @__PURE__ */ new Set([
-  "architecture",
-  "module",
-  "component",
-  "api",
-  "package",
-  "security",
-  "server_audit",
-  "changelog",
-  "api-reference"
-]);
-var VALID_REVIEW_STATUSES = /* @__PURE__ */ new Set([
-  "pending",
-  "agent_approved",
-  "agent_flagged",
-  "human_approved"
-]);
-function normalizeCompanyName(name) {
-  return name.toLowerCase().replace(/\b(b\.?v\.?|n\.?v\.?|v\.?o\.?f\.?|c\.?v\.?|holding|groep|group|nederland|netherlands)\b/gi, "").replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, " ").trim();
+function clamp(val, min, max) {
+  return Math.max(min, Math.min(max, val));
+}
+function sanitizeString(val, maxLen) {
+  return String(val ?? "").slice(0, maxLen);
 }
 var AGENT_TOOLS = [
-  {
-    name: "agent-report-coverage",
-    description: "Report documentation coverage data for a repository. Upserts records into doc_coverage. Call once per logical unit (package, module, theme, plugin directory). Provide all entries in a single call for efficiency.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo_slug: {
-          type: "string",
-          description: 'Repository slug (e.g. "mg-dashboard", "bna-wordpress")'
-        },
-        refront_project_id: {
-          type: "string",
-          description: "Refront project UUID linked to this repository"
-        },
-        entries: {
-          type: "array",
-          description: "Array of coverage entries, one per logical unit",
-          items: {
-            type: "object",
-            properties: {
-              path: { type: "string", description: 'Logical unit path (e.g. "packages/ui", "wp-content/themes/bna")' },
-              total_functions: { type: "number", description: "Total public functions/methods" },
-              documented_functions: { type: "number", description: "Functions with doc comments" },
-              total_types: { type: "number", description: "Total classes/interfaces/types" },
-              documented_types: { type: "number", description: "Types with doc comments" },
-              total_endpoints: { type: "number", description: "Total API/REST/hook endpoints" },
-              documented_endpoints: { type: "number", description: "Endpoints with documentation" }
-            },
-            required: ["path", "total_functions", "documented_functions"]
-          }
-        }
-      },
-      required: ["repo_slug", "entries"]
-    }
-  },
-  {
-    name: "agent-report-finding",
-    description: "Report documentation or performance findings for a repository. Inserts records into doc_suggestion. Auto-creates a parent documentation record if one does not exist yet. Batch multiple findings in one call.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo_slug: {
-          type: "string",
-          description: "Repository slug"
-        },
-        refront_project_id: {
-          type: "string",
-          description: "Refront project UUID linked to this repository"
-        },
-        category: {
-          type: "string",
-          enum: ["scan_findings", "perf_audit"],
-          description: 'Finding category: "scan_findings" for doc issues, "perf_audit" for performance issues'
-        },
-        findings: {
-          type: "array",
-          description: "Array of findings to report",
-          items: {
-            type: "object",
-            properties: {
-              type: {
-                type: "string",
-                enum: [...VALID_FINDING_TYPES],
-                description: "Finding type"
-              },
-              severity: {
-                type: "string",
-                enum: ["info", "warning", "critical"],
-                description: "Severity level"
-              },
-              description: {
-                type: "string",
-                description: "Clear description of the issue (max 2000 chars)"
-              },
-              file_path: {
-                type: "string",
-                description: "Relative file path where the issue was found"
-              },
-              suggested_fix: {
-                type: "string",
-                description: "Suggested fix with code example (max 5000 chars)"
-              }
-            },
-            required: ["type", "severity", "description"]
-          }
-        }
-      },
-      required: ["repo_slug", "category", "findings"]
-    }
-  },
-  {
-    name: "agent-save-documentation",
-    description: "Save or update a documentation record for a repository. Upserts by repo_slug + scope + path combination.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo_slug: { type: "string", description: "Repository slug" },
-        refront_project_id: { type: "string", description: "Refront project UUID (optional for standalone repos)" },
-        scope: {
-          type: "string",
-          enum: [...VALID_SCOPES],
-          description: "Documentation scope"
-        },
-        path: {
-          type: "string",
-          description: 'Path within the repo (e.g. "packages/ui")'
-        },
-        title: { type: "string", description: "Document title" },
-        content: { type: "string", description: "Documentation content (Typst markup)" },
-        review_status: {
-          type: "string",
-          enum: [...VALID_REVIEW_STATUSES],
-          description: 'Review status (default: "pending")'
-        }
-      },
-      required: ["repo_slug", "scope", "path", "title", "content"]
-    }
-  },
-  {
-    name: "agent-list-findings",
-    description: "List existing findings (doc_suggestion records) for a repository. Use this to check what has already been reported before submitting new findings.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo_slug: { type: "string", description: "Repository slug" },
-        type: {
-          type: "string",
-          enum: [...VALID_FINDING_TYPES],
-          description: "Filter by finding type"
-        },
-        severity: {
-          type: "string",
-          enum: ["info", "warning", "critical"],
-          description: "Filter by severity"
-        },
-        status: {
-          type: "string",
-          enum: ["open", "ticket_created", "resolved", "dismissed"],
-          description: "Filter by status (default: all)"
-        },
-        limit: {
-          type: "number",
-          description: "Max results to return (default: 50, max: 200)"
-        }
-      },
-      required: ["repo_slug"]
-    }
-  },
-  {
-    name: "agent-get-documentation",
-    description: "Retrieve existing documentation records for a repository. Use this to read current docs before generating or reviewing.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo_slug: { type: "string", description: "Repository slug" },
-        scope: {
-          type: "string",
-          enum: [...VALID_SCOPES],
-          description: "Filter by scope"
-        },
-        path: { type: "string", description: "Filter by exact path" },
-        limit: {
-          type: "number",
-          description: "Max results to return (default: 20, max: 100)"
-        }
-      },
-      required: ["repo_slug"]
-    }
-  },
-  {
-    name: "agent-validate-suggestions",
-    description: "Validate existing open suggestions against the actual codebase. For each suggestion, report whether it is resolved (fixed), valid (still open), invalid (should be dismissed), or needs adjustment.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        repo_slug: {
-          type: "string",
-          description: "Repository slug being validated"
-        },
-        results: {
-          type: "array",
-          description: "Validation results per suggestion",
-          items: {
-            type: "object",
-            properties: {
-              suggestion_id: {
-                type: "string",
-                description: "UUID of the doc_suggestion being validated"
-              },
-              verdict: {
-                type: "string",
-                enum: ["valid", "invalid", "adjusted", "resolved"],
-                description: "resolved = fix applied (sets status resolved), valid = still relevant (keep open), invalid = dismiss, adjusted = update fields"
-              },
-              reason: {
-                type: "string",
-                description: "Explanation of why this suggestion is valid/invalid/adjusted (max 2000 chars)"
-              },
-              adjusted_description: {
-                type: "string",
-                description: "Updated description (only for verdict=adjusted, max 2000 chars)"
-              },
-              adjusted_severity: {
-                type: "string",
-                enum: ["info", "warning", "critical"],
-                description: "Updated severity (only for verdict=adjusted)"
-              },
-              adjusted_suggested_fix: {
-                type: "string",
-                description: "Updated suggested fix (only for verdict=adjusted, max 5000 chars)"
-              }
-            },
-            required: ["suggestion_id", "verdict", "reason"]
-          }
-        }
-      },
-      required: ["repo_slug", "results"]
-    }
-  },
-  // -- Lead Generation tools --------------------------------------------------
-  {
-    name: "agent-check-lead-exists",
-    description: "Check if a lead already exists by website URL or company name. Call this BEFORE visiting a website to avoid wasting time on duplicates.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        website_url: {
-          type: "string",
-          description: 'Website URL to check (e.g. "https://example.nl")'
-        },
-        company_name: {
-          type: "string",
-          description: "Company name to fuzzy-match against existing leads"
-        }
-      },
-      required: []
-    }
-  },
-  {
-    name: "agent-save-lead",
-    description: "Save a discovered lead (company) to the database. Handles dedup on website_url + fuzzy match on company name. Returns the lead ID and whether it already existed.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        company_name: { type: "string", description: "Company name" },
-        website_url: { type: "string", description: "Company website URL" },
-        industry: { type: "string", description: "Industry sector" },
-        region: { type: "string", description: 'Geographic region (e.g. "amsterdam", "rotterdam")' },
-        description: { type: "string", description: "AI-generated summary of what the company does (max 2000 chars)" },
-        potential_fit: { type: "string", description: "Why MG Software could help this company (max 2000 chars)" },
-        fit_score: { type: "number", description: "Fit score 1-10 for MG Software partnership" },
-        estimated_company_size: { type: "string", description: 'Estimated employee count range (e.g. "1-10", "10-50", "50-200")' },
-        kvk_number: { type: "string", description: "KvK (Chamber of Commerce) number if found" },
-        contact_name: { type: "string", description: "Primary contact person name" },
-        contact_role: { type: "string", description: "Contact person role/title" },
-        contact_email: { type: "string", description: "Contact person email" },
-        contact_phone: { type: "string", description: "Contact person phone" },
-        contact_linkedin: { type: "string", description: "Contact person LinkedIn URL" },
-        general_email: { type: "string", description: "General company email (info@...)" },
-        general_phone: { type: "string", description: "General company phone number" },
-        source_url: { type: "string", description: "URL where this lead was found (Google result, directory, etc.)" },
-        target_id: { type: "string", description: "UUID of the lead_generation_target this lead was found for" }
-      },
-      required: ["company_name", "website_url"]
-    }
-  },
-  {
-    name: "agent-save-email-draft",
-    description: "Save a cold email draft for a lead. The email will be shown in the backoffice for manual review and copy. Do NOT use em-dashes or en-dashes in the email.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        lead_id: { type: "string", description: "UUID of the lead this email is for" },
-        subject: { type: "string", description: "Email subject line (Dutch, max 200 chars)" },
-        body: { type: "string", description: "Email body text (Dutch, max 5000 chars, NO em-dashes or en-dashes)" },
-        tone: { type: "string", description: "Tone of the email (default: professional)" }
-      },
-      required: ["lead_id", "subject", "body"]
-    }
-  },
-  {
-    name: "agent-complete-target",
-    description: "Mark a lead_generation_target as completed with the number of leads found.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        target_id: { type: "string", description: "UUID of the lead_generation_target" },
-        results_count: { type: "number", description: "Number of new leads saved for this target" }
-      },
-      required: ["target_id", "results_count"]
-    }
-  },
   {
     name: "web-search",
     description: "Search the web using DuckDuckGo. Returns a list of results with title, URL, and snippet. Use this to find companies, websites, directories, etc.",
@@ -758,26 +432,10 @@ var AGENT_TOOLS = [
 ];
 var AGENT_TOOL_NAMES = new Set(AGENT_TOOLS.map((t) => t.name));
 var AGENT_TOOL_MODULE_MAP = {
-  "agent-report-coverage": "agent_reporting",
-  "agent-report-finding": "agent_reporting",
-  "agent-save-documentation": "agent_reporting",
-  "agent-list-findings": "agent_reporting",
-  "agent-get-documentation": "agent_reporting",
-  "agent-validate-suggestions": "agent_reporting",
-  "agent-check-lead-exists": "agent_reporting",
-  "agent-save-lead": "agent_reporting",
-  "agent-save-email-draft": "agent_reporting",
-  "agent-complete-target": "agent_reporting",
   "web-search": "agent_reporting",
   "web-fetch": "agent_reporting",
   "web-find-contacts": "agent_reporting"
 };
-function clamp(val, min, max) {
-  return Math.max(min, Math.min(max, val));
-}
-function sanitizeString(val, maxLen) {
-  return String(val ?? "").slice(0, maxLen);
-}
 var WEB_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
 async function webSearch(query, maxResults) {
   const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
@@ -1088,499 +746,8 @@ async function webFetch(url, extractLinks) {
     clearTimeout(timeout);
   }
 }
-function textSimilarity(a, b) {
-  if (a === b) return 1;
-  const norm = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
-  const na = norm(a);
-  const nb = norm(b);
-  if (na === nb) return 1;
-  if (na.length < 3 || nb.length < 3) return na === nb ? 1 : 0;
-  const trigrams = (s) => {
-    const set = /* @__PURE__ */ new Set();
-    for (let i = 0; i <= s.length - 3; i++) set.add(s.slice(i, i + 3));
-    return set;
-  };
-  const setA = trigrams(na);
-  const setB = trigrams(nb);
-  let intersection = 0;
-  for (const t of setA) if (setB.has(t)) intersection++;
-  const union = setA.size + setB.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-async function handleAgentTool(name, args2, deps) {
-  const { supabase: supabase2 } = deps;
+async function handleAgentTool(name, args2) {
   switch (name) {
-    // -----------------------------------------------------------------
-    case "agent-report-coverage": {
-      const repoSlug = sanitizeString(args2.repo_slug, 200);
-      const refrontProjectId = sanitizeString(args2.refront_project_id, 100);
-      const entries = Array.isArray(args2.entries) ? args2.entries : [];
-      if (!repoSlug) throw new Error("repo_slug is required");
-      if (entries.length === 0) throw new Error("entries array must not be empty");
-      const wsId = deps.workspaceId;
-      const scanCommit = wsId ? `agent-scan-${wsId.slice(0, 8)}` : `agent-scan-${Date.now().toString(36)}`;
-      let upserted = 0;
-      let errors = 0;
-      for (const entry of entries) {
-        const { error } = await supabase2.from("doc_coverage").upsert(
-          {
-            refront_project_id: refrontProjectId,
-            repo_slug: repoSlug,
-            path: sanitizeString(entry.path, 500),
-            total_functions: clamp(Number(entry.total_functions) || 0, 0, 99999),
-            documented_functions: clamp(Number(entry.documented_functions) || 0, 0, 99999),
-            total_types: clamp(Number(entry.total_types) || 0, 0, 99999),
-            documented_types: clamp(Number(entry.documented_types) || 0, 0, 99999),
-            total_endpoints: clamp(Number(entry.total_endpoints) || 0, 0, 99999),
-            documented_endpoints: clamp(Number(entry.documented_endpoints) || 0, 0, 99999),
-            scan_commit: scanCommit,
-            scanned_at: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          { onConflict: "repo_slug,path" }
-        );
-        if (error) errors++;
-        else upserted++;
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `Coverage reported: ${upserted} entries upserted${errors > 0 ? `, ${errors} errors` : ""}`
-        }]
-      };
-    }
-    // -----------------------------------------------------------------
-    case "agent-report-finding": {
-      const repoSlug = sanitizeString(args2.repo_slug, 200);
-      const refrontProjectId = sanitizeString(args2.refront_project_id, 100);
-      const category = args2.category;
-      const findings = Array.isArray(args2.findings) ? args2.findings : [];
-      if (!repoSlug) throw new Error("repo_slug is required");
-      if (!category || !["scan_findings", "perf_audit"].includes(category)) {
-        throw new Error('category must be "scan_findings" or "perf_audit"');
-      }
-      if (findings.length === 0) throw new Error("findings array must not be empty");
-      const SIMILARITY_THRESHOLD = 0.55;
-      const MAX_OPEN_PER_TYPE = 30;
-      const { data: existingFindings } = await supabase2.from("doc_suggestion").select("id, type, description, file_path, severity, category, status").eq("repo_slug", repoSlug).in("status", ["open", "dismissed", "resolved", "ticket_created"]).limit(500);
-      const existing = existingFindings ?? [];
-      const typeCountMap = /* @__PURE__ */ new Map();
-      for (const e of existing) {
-        if (e.status !== "open") continue;
-        const key = `${e.category}:${e.type}`;
-        typeCountMap.set(key, (typeCountMap.get(key) ?? 0) + 1);
-      }
-      let inserted = 0;
-      let deduplicated = 0;
-      let grouped = 0;
-      let errors = 0;
-      const overflowBucket = /* @__PURE__ */ new Map();
-      for (const f of findings) {
-        const findingType = VALID_FINDING_TYPES.has(f.type) ? f.type : "improvement";
-        const severity = VALID_SEVERITIES.has(f.severity) ? f.severity : "info";
-        const description = sanitizeString(f.description, 2e3);
-        const filePath = f.file_path ? sanitizeString(f.file_path, 500) : null;
-        if (!description) continue;
-        const isDuplicate = existing.some((e) => {
-          if (e.type !== findingType) return false;
-          if (filePath && e.file_path === filePath && ["dismissed", "resolved"].includes(e.status)) {
-            return true;
-          }
-          if (filePath && e.file_path === filePath) {
-            return textSimilarity(e.description ?? "", description) > 0.4;
-          }
-          return textSimilarity(e.description ?? "", description) > SIMILARITY_THRESHOLD;
-        });
-        if (isDuplicate) {
-          deduplicated++;
-          continue;
-        }
-        const typeKey = `${category}:${findingType}`;
-        const currentCount = typeCountMap.get(typeKey) ?? 0;
-        if (currentCount >= MAX_OPEN_PER_TYPE) {
-          const bucket = overflowBucket.get(typeKey) ?? [];
-          bucket.push(`${filePath ? `${filePath}: ` : ""}${description.slice(0, 120)}`);
-          overflowBucket.set(typeKey, bucket);
-          grouped++;
-          continue;
-        }
-        const { error } = await supabase2.from("doc_suggestion").insert({
-          repo_slug: repoSlug,
-          refront_project_id: refrontProjectId,
-          category,
-          type: findingType,
-          severity,
-          description,
-          file_path: filePath,
-          suggested_fix: f.suggested_fix ? sanitizeString(f.suggested_fix, 5e3) : null,
-          status: "open"
-        });
-        if (error) {
-          errors++;
-        } else {
-          inserted++;
-          typeCountMap.set(typeKey, currentCount + 1);
-          existing.push({ id: "", type: findingType, description, file_path: filePath, severity, category, status: "open" });
-        }
-      }
-      for (const [typeKey, items] of overflowBucket) {
-        const [cat, type] = typeKey.split(":");
-        const summary = `Gegroepeerd (${items.length} items):
-${items.map((i) => `\u2022 ${i}`).join("\n")}`;
-        await supabase2.from("doc_suggestion").insert({
-          repo_slug: repoSlug,
-          refront_project_id: refrontProjectId,
-          category: cat,
-          type,
-          severity: "info",
-          description: summary.slice(0, 5e3),
-          file_path: null,
-          suggested_fix: null,
-          status: "open"
-        });
-      }
-      const parts = [`${inserted} inserted`];
-      if (deduplicated > 0) parts.push(`${deduplicated} deduplicated`);
-      if (grouped > 0) parts.push(`${grouped} grouped into ${overflowBucket.size} summary row(s)`);
-      if (errors > 0) parts.push(`${errors} errors`);
-      return {
-        content: [{
-          type: "text",
-          text: `Findings reported under ${category}: ${parts.join(", ")}`
-        }]
-      };
-    }
-    // -----------------------------------------------------------------
-    case "agent-save-documentation": {
-      const repoSlug = sanitizeString(args2.repo_slug, 200);
-      const refrontProjectId = sanitizeString(args2.refront_project_id, 100);
-      const scope = VALID_SCOPES.has(args2.scope) ? args2.scope : "module";
-      const path = sanitizeString(args2.path, 500);
-      const title = sanitizeString(args2.title, 500);
-      const content = sanitizeString(args2.content, 1e5);
-      const reviewStatus = VALID_REVIEW_STATUSES.has(args2.review_status) ? args2.review_status : "pending";
-      if (!repoSlug) throw new Error("repo_slug is required");
-      if (!path) throw new Error("path is required");
-      if (!title) throw new Error("title is required");
-      if (!content) throw new Error("content is required");
-      const { data: existing } = await supabase2.from("project_documentation").select("id").eq("repo_slug", repoSlug).eq("scope", scope).eq("path", path).maybeSingle();
-      if (existing) {
-        const { error: error2 } = await supabase2.from("project_documentation").update({
-          title,
-          content,
-          review_status: reviewStatus,
-          pdf_storage_path: null,
-          pdf_compiled_at: null,
-          updated_at: (/* @__PURE__ */ new Date()).toISOString()
-        }).eq("id", existing.id);
-        if (error2) throw new Error(`Failed to update documentation: ${error2.message}`);
-        return { content: [{ type: "text", text: `Documentation updated: ${title} (${scope}/${path}). PDF compilation pending.` }] };
-      }
-      const generatedBy = deps.workspaceId ? `agent-${deps.workspaceId.slice(0, 8)}` : "agent-mcp";
-      const { error } = await supabase2.from("project_documentation").insert({
-        refront_project_id: refrontProjectId,
-        repo_slug: repoSlug,
-        scope,
-        path,
-        title,
-        content,
-        generated_by: generatedBy,
-        review_status: reviewStatus,
-        pdf_storage_path: null,
-        pdf_compiled_at: null
-      });
-      if (error) throw new Error(`Failed to save documentation: ${error.message}`);
-      return { content: [{ type: "text", text: `Documentation saved: ${title} (${scope}/${path}). PDF compilation pending.` }] };
-    }
-    // -----------------------------------------------------------------
-    case "agent-list-findings": {
-      const repoSlug = sanitizeString(args2.repo_slug, 200);
-      if (!repoSlug) throw new Error("repo_slug is required");
-      const limit = clamp(Number(args2.limit) || 50, 1, 200);
-      let query = supabase2.from("doc_suggestion").select("id, type, severity, description, file_path, status, category, created_at").eq("repo_slug", repoSlug).order("created_at", { ascending: false }).limit(limit);
-      if (args2.type && VALID_FINDING_TYPES.has(args2.type)) {
-        query = query.eq("type", args2.type);
-      }
-      if (args2.severity && VALID_SEVERITIES.has(args2.severity)) {
-        query = query.eq("severity", args2.severity);
-      }
-      if (args2.status) {
-        query = query.eq("status", args2.status);
-      }
-      const { data: findings, error } = await query;
-      if (error) throw new Error(`Failed to query findings: ${error.message}`);
-      if (!findings || findings.length === 0) {
-        return { content: [{ type: "text", text: `No findings found for repo "${repoSlug}"` }] };
-      }
-      const summary = findings.map(
-        (f) => `[${f.severity}] ${f.type}: ${String(f.description).slice(0, 120)}${f.file_path ? ` (${f.file_path})` : ""} \u2014 ${f.status}`
-      ).join("\n");
-      return {
-        content: [{
-          type: "text",
-          text: `${findings.length} findings for "${repoSlug}":
-
-${summary}`
-        }]
-      };
-    }
-    // -----------------------------------------------------------------
-    case "agent-get-documentation": {
-      const repoSlug = sanitizeString(args2.repo_slug, 200);
-      if (!repoSlug) throw new Error("repo_slug is required");
-      const limit = clamp(Number(args2.limit) || 20, 1, 100);
-      let query = supabase2.from("project_documentation").select("id, repo_slug, scope, path, title, content, review_status, generated_by, created_at, updated_at").eq("repo_slug", repoSlug).order("updated_at", { ascending: false }).limit(limit);
-      if (args2.scope && VALID_SCOPES.has(args2.scope)) {
-        query = query.eq("scope", args2.scope);
-      }
-      if (args2.path) {
-        query = query.eq("path", sanitizeString(args2.path, 500));
-      }
-      const { data: docs, error } = await query;
-      if (error) throw new Error(`Failed to query documentation: ${error.message}`);
-      if (!docs || docs.length === 0) {
-        return { content: [{ type: "text", text: `No documentation found for repo "${repoSlug}"` }] };
-      }
-      const output = docs.map((d) => {
-        const fullContent = String(d.content || "");
-        const isChangelog = d.scope === "changelog";
-        const maxPreview = isChangelog ? 5e4 : 500;
-        const preview = fullContent.slice(0, maxPreview);
-        return [
-          `## ${d.title} (${d.scope}/${d.path})`,
-          `Status: ${d.review_status} | By: ${d.generated_by || "unknown"}`,
-          `Updated: ${d.updated_at || d.created_at}`,
-          "",
-          preview + (fullContent.length > maxPreview ? "\n...(truncated)" : ""),
-          ""
-        ].join("\n");
-      }).join("\n---\n\n");
-      return {
-        content: [{ type: "text", text: `${docs.length} docs for "${repoSlug}":
-
-${output}` }]
-      };
-    }
-    // -----------------------------------------------------------------
-    case "agent-validate-suggestions": {
-      const repoSlug = sanitizeString(args2.repo_slug, 200);
-      const results = Array.isArray(args2.results) ? args2.results : [];
-      if (!repoSlug) throw new Error("repo_slug is required");
-      if (results.length === 0) throw new Error("results array must not be empty");
-      const validatedBy = deps.workspaceId ? `validator-${deps.workspaceId.slice(0, 8)}` : "validator-mcp";
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      let dismissed = 0;
-      let adjusted = 0;
-      let validated = 0;
-      let errors = 0;
-      let resolved = 0;
-      for (const r of results) {
-        const id = sanitizeString(r.suggestion_id, 100);
-        const verdict = r.verdict;
-        const reason = sanitizeString(r.reason, 2e3);
-        if (!id || !["valid", "invalid", "adjusted", "resolved"].includes(verdict)) {
-          errors++;
-          continue;
-        }
-        if (verdict === "resolved") {
-          const { error } = await supabase2.from("doc_suggestion").update({
-            status: "resolved",
-            validated_at: now,
-            validated_by: validatedBy
-          }).eq("id", id).eq("repo_slug", repoSlug);
-          if (error) errors++;
-          else resolved++;
-        } else if (verdict === "invalid") {
-          const { error } = await supabase2.from("doc_suggestion").update({
-            status: "dismissed",
-            dismissed_reason: reason || "Dismissed by validation agent",
-            validated_at: now,
-            validated_by: validatedBy
-          }).eq("id", id).eq("repo_slug", repoSlug);
-          if (error) errors++;
-          else dismissed++;
-        } else if (verdict === "adjusted") {
-          const updates = {
-            validated_at: now,
-            validated_by: validatedBy
-          };
-          if (r.adjusted_description) {
-            updates.description = sanitizeString(r.adjusted_description, 2e3);
-          }
-          if (r.adjusted_severity && VALID_SEVERITIES.has(r.adjusted_severity)) {
-            updates.severity = r.adjusted_severity;
-          }
-          if (r.adjusted_suggested_fix) {
-            updates.suggested_fix = sanitizeString(r.adjusted_suggested_fix, 5e3);
-          }
-          const { error } = await supabase2.from("doc_suggestion").update(updates).eq("id", id).eq("repo_slug", repoSlug);
-          if (error) errors++;
-          else adjusted++;
-        } else {
-          const { error } = await supabase2.from("doc_suggestion").update({ validated_at: now, validated_by: validatedBy }).eq("id", id).eq("repo_slug", repoSlug);
-          if (error) errors++;
-          else validated++;
-        }
-      }
-      const parts = [];
-      if (resolved > 0) parts.push(`${resolved} resolved`);
-      if (validated > 0) parts.push(`${validated} valid`);
-      if (dismissed > 0) parts.push(`${dismissed} dismissed`);
-      if (adjusted > 0) parts.push(`${adjusted} adjusted`);
-      if (errors > 0) parts.push(`${errors} errors`);
-      return {
-        content: [{
-          type: "text",
-          text: `Validation complete for "${repoSlug}": ${parts.join(", ")}`
-        }]
-      };
-    }
-    // -----------------------------------------------------------------
-    // Lead Generation tools
-    // -----------------------------------------------------------------
-    case "agent-check-lead-exists": {
-      const websiteUrl = sanitizeString(args2.website_url, 500).replace(/\/+$/, "");
-      const companyName = sanitizeString(args2.company_name, 500);
-      if (!websiteUrl && !companyName) {
-        throw new Error("At least one of website_url or company_name is required");
-      }
-      const checks = [];
-      if (websiteUrl) {
-        const { data: urlMatch } = await supabase2.from("lead").select("id, company_name, website_url").eq("website_url", websiteUrl).maybeSingle();
-        if (urlMatch) {
-          return {
-            content: [{
-              type: "text",
-              text: `DUPLICATE: Lead already exists (URL match). ID: ${urlMatch.id}, Company: ${urlMatch.company_name}. SKIP this company.`
-            }]
-          };
-        }
-        checks.push(`URL "${websiteUrl}" not found`);
-      }
-      if (companyName) {
-        const normalized = normalizeCompanyName(companyName);
-        if (normalized.length >= 3) {
-          const { data: nameMatches } = await supabase2.from("lead").select("id, company_name, website_url").ilike("company_name", `%${normalized.split(" ")[0]}%`).limit(20);
-          if (nameMatches) {
-            for (const match of nameMatches) {
-              const matchNorm = normalizeCompanyName(match.company_name);
-              if (textSimilarity(normalized, matchNorm) > 0.6) {
-                return {
-                  content: [{
-                    type: "text",
-                    text: `DUPLICATE: Similar company found. ID: ${match.id}, Name: "${match.company_name}" (${match.website_url}). SKIP this company.`
-                  }]
-                };
-              }
-            }
-          }
-        }
-        checks.push(`Name "${companyName}" has no similar matches`);
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `NOT FOUND: No duplicate detected. ${checks.join(". ")}. Safe to proceed.`
-        }]
-      };
-    }
-    case "agent-save-lead": {
-      const companyName = sanitizeString(args2.company_name, 500);
-      const websiteUrl = sanitizeString(args2.website_url, 500).replace(/\/+$/, "");
-      if (!companyName) throw new Error("company_name is required");
-      if (!websiteUrl) throw new Error("website_url is required");
-      const { data: existing } = await supabase2.from("lead").select("id, company_name").eq("website_url", websiteUrl).maybeSingle();
-      if (existing) {
-        return {
-          content: [{
-            type: "text",
-            text: `Lead already exists (URL match). ID: ${existing.id}, Company: "${existing.company_name}". Skipped.`
-          }]
-        };
-      }
-      const normalized = normalizeCompanyName(companyName);
-      if (normalized.length >= 3) {
-        const { data: nameMatches } = await supabase2.from("lead").select("id, company_name").ilike("company_name", `%${normalized.split(" ")[0]}%`).limit(20);
-        if (nameMatches) {
-          for (const match of nameMatches) {
-            if (textSimilarity(normalized, normalizeCompanyName(match.company_name)) > 0.6) {
-              return {
-                content: [{
-                  type: "text",
-                  text: `Lead already exists (name match). ID: ${match.id}, Name: "${match.company_name}". Skipped.`
-                }]
-              };
-            }
-          }
-        }
-      }
-      const fitScore = args2.fit_score ? clamp(Number(args2.fit_score), 1, 10) : null;
-      const { data: inserted, error } = await supabase2.from("lead").insert({
-        company_name: companyName,
-        website_url: websiteUrl,
-        industry: args2.industry ? sanitizeString(args2.industry, 200) : null,
-        region: args2.region ? sanitizeString(args2.region, 200) : null,
-        description: args2.description ? sanitizeString(args2.description, 2e3) : null,
-        potential_fit: args2.potential_fit ? sanitizeString(args2.potential_fit, 2e3) : null,
-        fit_score: fitScore,
-        estimated_company_size: args2.estimated_company_size ? sanitizeString(args2.estimated_company_size, 50) : null,
-        kvk_number: args2.kvk_number ? sanitizeString(args2.kvk_number, 20) : null,
-        contact_name: args2.contact_name ? sanitizeString(args2.contact_name, 200) : null,
-        contact_role: args2.contact_role ? sanitizeString(args2.contact_role, 200) : null,
-        contact_email: args2.contact_email ? sanitizeString(args2.contact_email, 200) : null,
-        contact_phone: args2.contact_phone ? sanitizeString(args2.contact_phone, 50) : null,
-        contact_linkedin: args2.contact_linkedin ? sanitizeString(args2.contact_linkedin, 500) : null,
-        general_email: args2.general_email ? sanitizeString(args2.general_email, 200) : null,
-        general_phone: args2.general_phone ? sanitizeString(args2.general_phone, 50) : null,
-        source_url: args2.source_url ? sanitizeString(args2.source_url, 500) : null,
-        target_id: args2.target_id ? sanitizeString(args2.target_id, 100) : null,
-        status: "new"
-      }).select("id").single();
-      if (error) throw new Error(`Failed to save lead: ${error.message}`);
-      return {
-        content: [{
-          type: "text",
-          text: `Lead saved: "${companyName}" (${websiteUrl}). ID: ${inserted.id}. Fit score: ${fitScore ?? "N/A"}.`
-        }]
-      };
-    }
-    case "agent-save-email-draft": {
-      const leadId = sanitizeString(args2.lead_id, 100);
-      const subject = sanitizeString(args2.subject, 200);
-      let body = sanitizeString(args2.body, 5e3);
-      const tone = sanitizeString(args2.tone, 50) || "professional";
-      if (!leadId) throw new Error("lead_id is required");
-      if (!subject) throw new Error("subject is required");
-      if (!body) throw new Error("body is required");
-      body = body.replace(/[\u2013\u2014]/g, ",");
-      const { data: inserted, error } = await supabase2.from("lead_email_draft").insert({ lead_id: leadId, subject, body, tone, status: "draft" }).select("id").single();
-      if (error) throw new Error(`Failed to save email draft: ${error.message}`);
-      await supabase2.from("lead").update({ status: "email_drafted", updated_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", leadId).eq("status", "new");
-      return {
-        content: [{
-          type: "text",
-          text: `Email draft saved for lead ${leadId}. Draft ID: ${inserted.id}. Subject: "${subject}".`
-        }]
-      };
-    }
-    case "agent-complete-target": {
-      const targetId = sanitizeString(args2.target_id, 100);
-      const resultsCount = clamp(Number(args2.results_count) || 0, 0, 9999);
-      if (!targetId) throw new Error("target_id is required");
-      const { error } = await supabase2.from("lead_generation_target").update({
-        results_count: resultsCount,
-        assigned_workspace_id: null
-      }).eq("id", targetId);
-      if (error) throw new Error(`Failed to update target: ${error.message}`);
-      return {
-        content: [{
-          type: "text",
-          text: `Target ${targetId} updated: ${resultsCount} leads found. Workspace released.`
-        }]
-      };
-    }
-    // -----------------------------------------------------------------
-    // Web Tools
-    // -----------------------------------------------------------------
     case "web-search": {
       const query = sanitizeString(args2.query, 500);
       if (!query) throw new Error("query is required");
@@ -1635,9 +802,6 @@ LinkedIn: ${pageLinkedIn.join(", ")}`;
       }
       return { content: [{ type: "text", text }] };
     }
-    // -----------------------------------------------------------------
-    // Web Find Contacts — SOTA multi-page crawler + email extraction
-    // -----------------------------------------------------------------
     case "web-find-contacts": {
       const inputUrl = sanitizeString(args2.url, 2e3);
       if (!inputUrl) throw new Error("url is required");
@@ -1782,9 +946,8 @@ LinkedIn: ${pageLinkedIn.join(", ")}`;
       for (const p of failedPages) lines.push(`  [--] ${p}`);
       return { content: [{ type: "text", text: lines.join("\n") }] };
     }
-    // -----------------------------------------------------------------
     default:
-      return { content: [{ type: "text", text: `Unknown agent tool: ${name}` }] };
+      return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
   }
 }
 
@@ -1798,7 +961,6 @@ var supabaseUrl = getArg("supabase-url") || process.env.SUPABASE_URL;
 var supabaseKey = getArg("supabase-key") || process.env.SUPABASE_SERVICE_ROLE_KEY;
 var encryptionKey = getArg("encryption-key") || process.env.ENCRYPTION_KEY;
 var mijnhostApiKey = getArg("mijnhost-api-key") || process.env.MIJNHOST_API_KEY;
-var agentWorkspaceId = getArg("workspace-id") || process.env.AGENT_WORKSPACE_ID || null;
 var httpMode = args.includes("--http");
 var httpPort = Number(getArg("port")) || 3100;
 if (!apiKey) {
@@ -1861,7 +1023,6 @@ var MODULE_KEYS = [
   "supabase",
   "wiki",
   "ci_cd",
-  "source_control",
   "domains",
   "settings",
   "agent_reporting"
@@ -2360,6 +1521,69 @@ function sshExecViaProxy(proxyOpts, targetOpts, command) {
     });
   });
 }
+function connectSshClient(opts, proxy, readyTimeout = 6e4) {
+  if (!proxy) {
+    return new Promise((resolve, reject) => {
+      const ssh = new Client();
+      ssh.on("ready", () => resolve({ client: ssh, cleanup: () => ssh.end() }));
+      ssh.on("error", (e) => reject(e));
+      ssh.connect({
+        host: opts.hostname,
+        port: opts.port,
+        username: opts.username,
+        password: opts.password,
+        privateKey: opts.privateKey,
+        passphrase: opts.passphrase,
+        readyTimeout
+      });
+    });
+  }
+  return new Promise((resolve, reject) => {
+    const proxyClient = new Client();
+    proxyClient.on("ready", () => {
+      proxyClient.forwardOut("127.0.0.1", 0, opts.hostname, opts.port, (err, tunnel) => {
+        if (err) {
+          proxyClient.end();
+          reject(err);
+          return;
+        }
+        const targetClient = new Client();
+        targetClient.on(
+          "ready",
+          () => resolve({
+            client: targetClient,
+            cleanup: () => {
+              targetClient.end();
+              proxyClient.end();
+            }
+          })
+        );
+        targetClient.on("error", (e) => {
+          proxyClient.end();
+          reject(e);
+        });
+        targetClient.connect({
+          sock: tunnel,
+          username: opts.username,
+          password: opts.password,
+          privateKey: opts.privateKey,
+          passphrase: opts.passphrase,
+          readyTimeout
+        });
+      });
+    });
+    proxyClient.on("error", (e) => reject(e));
+    proxyClient.connect({
+      host: proxy.hostname,
+      port: proxy.port,
+      username: proxy.username,
+      password: proxy.password,
+      privateKey: proxy.privateKey,
+      passphrase: proxy.passphrase,
+      readyTimeout: proxy.timeout || 3e4
+    });
+  });
+}
 function sanitizePath(path) {
   let normalized = path.replace(/\\/g, "/").replace(/\0/g, "");
   const parts = normalized.split("/");
@@ -2380,34 +1604,31 @@ function assertWritablePath(path) {
     }
   }
 }
-async function sftpReaddir(opts, dirPath) {
+async function sftpReaddir(opts, dirPath, proxy) {
   const safe = sanitizePath(dirPath);
-  return new Promise((resolve) => {
-    const ssh = new Client();
-    let done = false;
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true;
-        ssh.end();
+  let cleanup;
+  try {
+    const { client, cleanup: c } = await connectSshClient(opts, proxy, 3e4);
+    cleanup = c;
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        cleanup?.();
         resolve("Error: timeout");
-      }
-    }, 3e4);
-    ssh.on("ready", () => {
-      ssh.sftp((err, sftp) => {
+        cleanup = void 0;
+      }, 3e4);
+      client.sftp((err, sftp) => {
         if (err) {
-          if (!done) {
-            done = true;
-            clearTimeout(timer);
-            ssh.end();
-            resolve(`Error: ${err.message}`);
-          }
+          clearTimeout(timer);
+          cleanup?.();
+          cleanup = void 0;
+          resolve(`Error: ${err.message}`);
           return;
         }
         sftp.readdir(safe, (err2, list) => {
-          done = true;
           clearTimeout(timer);
           if (err2) {
-            ssh.end();
+            cleanup?.();
+            cleanup = void 0;
             resolve(`Error: ${err2.message}`);
             return;
           }
@@ -2418,199 +1639,159 @@ async function sftpReaddir(opts, dirPath) {
             const mtime = item.attrs.mtime ? new Date(item.attrs.mtime * 1e3).toISOString() : "";
             return `${isDir ? "d" : "-"} ${String(size).padStart(10)} ${mtime} ${item.filename}`;
           });
-          ssh.end();
+          cleanup?.();
+          cleanup = void 0;
           resolve(entries.join("\n"));
         });
       });
     });
-    ssh.on("error", (e) => {
-      if (!done) {
-        done = true;
-        clearTimeout(timer);
-        resolve(`Error: ${e.message}`);
-      }
-    });
-    ssh.connect({ host: opts.hostname, port: opts.port, username: opts.username, password: opts.password, privateKey: opts.privateKey, passphrase: opts.passphrase, readyTimeout: 3e4 });
-  });
+  } catch (e) {
+    cleanup?.();
+    return `Error: ${e.message}`;
+  }
 }
-async function sftpRead(opts, filePath) {
+async function sftpRead(opts, filePath, proxy) {
   const safe = sanitizePath(filePath);
-  return new Promise((resolve) => {
-    const ssh = new Client();
-    let done = false;
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true;
-        ssh.end();
+  let cleanup;
+  try {
+    const { client, cleanup: c } = await connectSshClient(opts, proxy, 6e4);
+    cleanup = c;
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        cleanup?.();
         resolve("Error: timeout");
-      }
-    }, 6e4);
-    ssh.on("ready", () => {
-      ssh.sftp((err, sftp) => {
+        cleanup = void 0;
+      }, 6e4);
+      client.sftp((err, sftp) => {
         if (err) {
-          if (!done) {
-            done = true;
-            clearTimeout(timer);
-            ssh.end();
-            resolve(`Error: ${err.message}`);
-          }
+          clearTimeout(timer);
+          cleanup?.();
+          cleanup = void 0;
+          resolve(`Error: ${err.message}`);
           return;
         }
         sftp.stat(safe, (err2, stats) => {
           if (err2) {
-            if (!done) {
-              done = true;
-              clearTimeout(timer);
-              ssh.end();
-              resolve(`Error: ${err2.message}`);
-            }
+            clearTimeout(timer);
+            cleanup?.();
+            cleanup = void 0;
+            resolve(`Error: ${err2.message}`);
             return;
           }
           if ((stats.size || 0) > 1048576) {
-            if (!done) {
-              done = true;
-              clearTimeout(timer);
-              ssh.end();
-              resolve(`Error: file too large (${stats.size} bytes, max 1MB)`);
-            }
+            clearTimeout(timer);
+            cleanup?.();
+            cleanup = void 0;
+            resolve(`Error: file too large (${stats.size} bytes, max 1MB)`);
             return;
           }
           const chunks = [];
           const rs = sftp.createReadStream(safe);
-          rs.on("data", (c) => chunks.push(c));
+          rs.on("data", (ch) => chunks.push(ch));
           rs.on("end", () => {
-            if (!done) {
-              done = true;
-              clearTimeout(timer);
-              ssh.end();
-              resolve(Buffer.concat(chunks.map((c) => new Uint8Array(c))).toString("utf-8"));
-            }
+            clearTimeout(timer);
+            cleanup?.();
+            cleanup = void 0;
+            resolve(Buffer.concat(chunks.map((ch) => new Uint8Array(ch))).toString("utf-8"));
           });
           rs.on("error", (e) => {
-            if (!done) {
-              done = true;
-              clearTimeout(timer);
-              ssh.end();
-              resolve(`Error: ${e.message}`);
-            }
+            clearTimeout(timer);
+            cleanup?.();
+            cleanup = void 0;
+            resolve(`Error: ${e.message}`);
           });
         });
       });
     });
-    ssh.on("error", (e) => {
-      if (!done) {
-        done = true;
-        clearTimeout(timer);
-        resolve(`Error: ${e.message}`);
-      }
-    });
-    ssh.connect({ host: opts.hostname, port: opts.port, username: opts.username, password: opts.password, privateKey: opts.privateKey, passphrase: opts.passphrase, readyTimeout: 6e4 });
-  });
+  } catch (e) {
+    cleanup?.();
+    return `Error: ${e.message}`;
+  }
 }
-async function sftpWrite(opts, filePath, content) {
+async function sftpWrite(opts, filePath, content, proxy) {
   const safe = sanitizePath(filePath);
   assertWritablePath(safe);
-  return new Promise((resolve) => {
-    const ssh = new Client();
-    let done = false;
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true;
-        ssh.end();
+  let cleanup;
+  try {
+    const { client, cleanup: c } = await connectSshClient(opts, proxy, 6e4);
+    cleanup = c;
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        cleanup?.();
         resolve("Error: timeout");
-      }
-    }, 6e4);
-    ssh.on("ready", () => {
-      ssh.sftp((err, sftp) => {
+        cleanup = void 0;
+      }, 6e4);
+      client.sftp((err, sftp) => {
         if (err) {
-          if (!done) {
-            done = true;
-            clearTimeout(timer);
-            ssh.end();
-            resolve(`Error: ${err.message}`);
-          }
+          clearTimeout(timer);
+          cleanup?.();
+          cleanup = void 0;
+          resolve(`Error: ${err.message}`);
           return;
         }
         const ws = sftp.createWriteStream(safe, { mode: 420 });
         ws.on("close", () => {
-          if (!done) {
-            done = true;
-            clearTimeout(timer);
-            ssh.end();
-            resolve(`Written ${content.length} bytes to ${safe}`);
-          }
+          clearTimeout(timer);
+          cleanup?.();
+          cleanup = void 0;
+          resolve(`Written ${content.length} bytes to ${safe}`);
         });
         ws.on("error", (e) => {
-          if (!done) {
-            done = true;
-            clearTimeout(timer);
-            ssh.end();
-            resolve(`Error: ${e.message}`);
-          }
+          clearTimeout(timer);
+          cleanup?.();
+          cleanup = void 0;
+          resolve(`Error: ${e.message}`);
         });
         ws.end(Buffer.from(content, "utf-8"));
       });
     });
-    ssh.on("error", (e) => {
-      if (!done) {
-        done = true;
-        clearTimeout(timer);
-        resolve(`Error: ${e.message}`);
-      }
-    });
-    ssh.connect({ host: opts.hostname, port: opts.port, username: opts.username, password: opts.password, privateKey: opts.privateKey, passphrase: opts.passphrase, readyTimeout: 6e4 });
-  });
+  } catch (e) {
+    cleanup?.();
+    return `Error: ${e.message}`;
+  }
 }
-async function sftpDelete(opts, filePath) {
+async function sftpDelete(opts, filePath, proxy) {
   const safe = sanitizePath(filePath);
   assertWritablePath(safe);
-  return new Promise((resolve) => {
-    const ssh = new Client();
-    let done = false;
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true;
-        ssh.end();
+  let cleanup;
+  try {
+    const { client, cleanup: c } = await connectSshClient(opts, proxy, 3e4);
+    cleanup = c;
+    return await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        cleanup?.();
         resolve("Error: timeout");
-      }
-    }, 3e4);
-    ssh.on("ready", () => {
-      ssh.sftp((err, sftp) => {
+        cleanup = void 0;
+      }, 3e4);
+      client.sftp((err, sftp) => {
         if (err) {
-          if (!done) {
-            done = true;
-            clearTimeout(timer);
-            ssh.end();
-            resolve(`Error: ${err.message}`);
-          }
+          clearTimeout(timer);
+          cleanup?.();
+          cleanup = void 0;
+          resolve(`Error: ${err.message}`);
           return;
         }
-        sftp.unlink(safe, (err2) => {
-          if (err2) {
-            sftp.rmdir(safe, (err22) => {
-              done = true;
+        sftp.unlink(safe, (unlinkErr) => {
+          if (unlinkErr) {
+            sftp.rmdir(safe, (rmdirErr) => {
               clearTimeout(timer);
-              ssh.end();
-              resolve(err22 ? `Error: ${err2.message}` : `Deleted directory ${safe}`);
+              cleanup?.();
+              cleanup = void 0;
+              resolve(rmdirErr ? `Error: ${unlinkErr.message}` : `Deleted directory ${safe}`);
             });
           } else {
-            done = true;
             clearTimeout(timer);
-            ssh.end();
+            cleanup?.();
+            cleanup = void 0;
             resolve(`Deleted file ${safe}`);
           }
         });
       });
     });
-    ssh.on("error", (e) => {
-      if (!done) {
-        done = true;
-        clearTimeout(timer);
-        resolve(`Error: ${e.message}`);
-      }
-    });
-    ssh.connect({ host: opts.hostname, port: opts.port, username: opts.username, password: opts.password, privateKey: opts.privateKey, passphrase: opts.passphrase, readyTimeout: 3e4 });
-  });
+  } catch (e) {
+    cleanup?.();
+    return `Error: ${e.message}`;
+  }
 }
 var BLOCKED_COMMANDS = [
   "rm -rf /",
@@ -3128,25 +2309,25 @@ ${result.stdout}`);
 ${result.stderr}`);
         return { content: [{ type: "text", text: output.join("\n") }] };
       }
-      // ----- SFTP (no proxy support yet — direct connection only) -----
+      // ----- SFTP -----
       case "sftp-list": {
-        const { conn } = await getServerConnection(String(a.serverId));
-        const listing = await sftpReaddir(conn, String(a.path || "/"));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const listing = await sftpReaddir(conn, String(a.path || "/"), proxy);
         return { content: [{ type: "text", text: listing }] };
       }
       case "sftp-read": {
-        const { conn } = await getServerConnection(String(a.serverId));
-        const content = await sftpRead(conn, String(a.path));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const content = await sftpRead(conn, String(a.path), proxy);
         return { content: [{ type: "text", text: content }] };
       }
       case "sftp-write": {
-        const { conn } = await getServerConnection(String(a.serverId));
-        const result = await sftpWrite(conn, String(a.path), String(a.content));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const result = await sftpWrite(conn, String(a.path), String(a.content), proxy);
         return { content: [{ type: "text", text: result }] };
       }
       case "sftp-delete": {
-        const { conn } = await getServerConnection(String(a.serverId));
-        const result = await sftpDelete(conn, String(a.path));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const result = await sftpDelete(conn, String(a.path), proxy);
         return { content: [{ type: "text", text: result }] };
       }
       // ----- Docker -----
@@ -3538,7 +2719,7 @@ ${lines.join("\n")}` }] };
           return handleTriggerTool(name, a, { sshExec, getServerConnection });
         }
         if (AGENT_TOOL_NAMES.has(name)) {
-          return handleAgentTool(name, a, { supabase, workspaceId: agentWorkspaceId });
+          return handleAgentTool(name, a);
         }
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }
@@ -3569,16 +2750,6 @@ async function main() {
     console.error(`API key validated. Starting Streamable HTTP transport on port ${httpPort}...`);
     const transports = /* @__PURE__ */ new Map();
     const REST_TOOL_MAP = {
-      "/api/report-coverage": "agent-report-coverage",
-      "/api/report-finding": "agent-report-finding",
-      "/api/save-documentation": "agent-save-documentation",
-      "/api/list-findings": "agent-list-findings",
-      "/api/get-documentation": "agent-get-documentation",
-      "/api/validate-suggestions": "agent-validate-suggestions",
-      "/api/check-lead-exists": "agent-check-lead-exists",
-      "/api/save-lead": "agent-save-lead",
-      "/api/save-email-draft": "agent-save-email-draft",
-      "/api/complete-target": "agent-complete-target",
       "/api/web-search": "web-search",
       "/api/web-fetch": "web-fetch"
     };
@@ -3597,7 +2768,7 @@ async function main() {
           return;
         }
         try {
-          const result = await handleAgentTool(restToolName, toolArgs, { supabase, workspaceId: agentWorkspaceId });
+          const result = await handleAgentTool(restToolName, toolArgs);
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: true, result }));
         } catch (err) {