@socialneuron/mcp-server 1.6.1 → 1.7.0

package/dist/index.js

@@ -14,7 +14,7 @@ var MCP_VERSION;
 var init_version = __esm({
   "src/lib/version.ts"() {
     "use strict";
-    MCP_VERSION = "1.6.0";
+    MCP_VERSION = "1.7.0";
   }
 });
 
@@ -311,7 +311,7 @@ __export(api_keys_exports, {
 async function validateApiKey(apiKey) {
   const supabaseUrl = getSupabaseUrl();
   try {
-    const anonKey = process.env.SUPABASE_ANON_KEY || process.env.SOCIALNEURON_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY || CLOUD_SUPABASE_ANON_KEY;
+    const anonKey = getCloudAnonKey();
     const response = await fetch(
       `${supabaseUrl}/functions/v1/mcp-auth?action=validate-key-public`,
       {
@@ -346,12 +346,12 @@ var init_api_keys = __esm({
 // src/lib/supabase.ts
 var supabase_exports = {};
 __export(supabase_exports, {
-  CLOUD_SUPABASE_ANON_KEY: () => CLOUD_SUPABASE_ANON_KEY,
-  CLOUD_SUPABASE_URL: () => CLOUD_SUPABASE_URL,
+  fetchCloudConfig: () => fetchCloudConfig,
   getAuthMode: () => getAuthMode,
   getAuthenticatedApiKey: () => getAuthenticatedApiKey,
   getAuthenticatedExpiresAt: () => getAuthenticatedExpiresAt,
   getAuthenticatedScopes: () => getAuthenticatedScopes,
+  getCloudAnonKey: () => getCloudAnonKey,
   getDefaultProjectId: () => getDefaultProjectId,
   getDefaultUserId: () => getDefaultUserId,
   getMcpRunId: () => getMcpRunId,
@@ -376,11 +376,47 @@ function getSupabaseClient() {
   }
   return client2;
 }
+async function fetchCloudConfig() {
+  if (_cloudConfig) return _cloudConfig;
+  const envUrl = process.env.SOCIALNEURON_CLOUD_SUPABASE_URL || process.env.SUPABASE_URL;
+  const envAnon = process.env.SUPABASE_ANON_KEY || process.env.SOCIALNEURON_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY;
+  if (envUrl && envAnon) {
+    _cloudConfig = { supabaseUrl: envUrl, anonKey: envAnon };
+    return _cloudConfig;
+  }
+  try {
+    const resp = await fetch(CLOUD_CONFIG_URL, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!resp.ok) {
+      throw new Error(`Config fetch failed: ${resp.status}`);
+    }
+    const config = await resp.json();
+    _cloudConfig = config;
+    return _cloudConfig;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Failed to fetch cloud config from ${CLOUD_CONFIG_URL}: ${msg}. Set SUPABASE_URL and SUPABASE_ANON_KEY environment variables as a fallback.`
+    );
+  }
+}
 function getSupabaseUrl() {
   if (SUPABASE_URL) return SUPABASE_URL;
   const cloudOverride = process.env.SOCIALNEURON_CLOUD_SUPABASE_URL;
   if (cloudOverride) return cloudOverride;
-  return CLOUD_SUPABASE_URL;
+  if (_cloudConfig) return _cloudConfig.supabaseUrl;
+  throw new Error(
+    "Supabase URL not configured. Run: npx @socialneuron/mcp-server setup"
+  );
+}
+function getCloudAnonKey() {
+  const envAnon = process.env.SUPABASE_ANON_KEY || process.env.SOCIALNEURON_ANON_KEY || process.env.VITE_SUPABASE_ANON_KEY;
+  if (envAnon) return envAnon;
+  if (_cloudConfig) return _cloudConfig.anonKey;
+  throw new Error(
+    "Supabase anon key not available. Call fetchCloudConfig() first or set SUPABASE_ANON_KEY."
+  );
 }
 function getServiceKey() {
   if (!SUPABASE_SERVICE_KEY) {
@@ -427,6 +463,12 @@ async function getDefaultProjectId() {
   return null;
 }
 async function initializeAuth() {
+  if (!SUPABASE_URL) {
+    try {
+      await fetchCloudConfig();
+    } catch {
+    }
+  }
   const { loadApiKey: loadApiKey2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
   const apiKey = await loadApiKey2();
   if (apiKey) {
@@ -530,7 +572,7 @@ async function logMcpToolInvocation(args) {
   captureToolEvent(args).catch(() => {
   });
 }
-var SUPABASE_URL, SUPABASE_SERVICE_KEY, client2, _authMode, authenticatedUserId, authenticatedScopes, authenticatedExpiresAt, authenticatedApiKey, MCP_RUN_ID, CLOUD_SUPABASE_URL, CLOUD_SUPABASE_ANON_KEY, projectIdCache;
+var SUPABASE_URL, SUPABASE_SERVICE_KEY, client2, _authMode, authenticatedUserId, authenticatedScopes, authenticatedExpiresAt, authenticatedApiKey, MCP_RUN_ID, CLOUD_CONFIG_URL, _cloudConfig, projectIdCache;
 var init_supabase = __esm({
   "src/lib/supabase.ts"() {
     "use strict";
@@ -545,8 +587,8 @@ var init_supabase = __esm({
     authenticatedExpiresAt = null;
     authenticatedApiKey = null;
     MCP_RUN_ID = randomUUID();
-    CLOUD_SUPABASE_URL = "https://rhukkjscgzauutioyeei.supabase.co";
-    CLOUD_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InJodWtranNjZ3phdXV0aW95ZWVpIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjQ4NjM4ODYsImV4cCI6MjA4MDQzOTg4Nn0.JVtrviGvN0HaSh0JFS5KNl5FAB5ffG5Y1IMZsQFUrNQ";
+    CLOUD_CONFIG_URL = process.env.SOCIALNEURON_CONFIG_URL || "https://mcp.socialneuron.com/config";
+    _cloudConfig = null;
     projectIdCache = /* @__PURE__ */ new Map();
   }
 });
@@ -963,6 +1005,24 @@ var init_tool_catalog = __esm({
         module: "brand",
         scope: "mcp:read"
       },
+      {
+        name: "get_brand_runtime",
+        description: "Get the full 4-layer brand runtime (messaging, voice, visual, constraints)",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      {
+        name: "explain_brand_system",
+        description: "Explain brand completeness, confidence, and recommendations",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
+      {
+        name: "check_brand_consistency",
+        description: "Check content text for brand voice/vocabulary/claim consistency",
+        module: "brandRuntime",
+        scope: "mcp:read"
+      },
       {
         name: "save_brand_profile",
         description: "Save or update brand profile",
@@ -1001,6 +1061,12 @@ var init_tool_catalog = __esm({
         module: "remotion",
         scope: "mcp:read"
       },
+      {
+        name: "render_template_video",
+        description: "Render a template video in the cloud via async job",
+        module: "remotion",
+        scope: "mcp:write"
+      },
       // youtube-analytics
       {
         name: "fetch_youtube_analytics",
@@ -1173,6 +1239,58 @@ var init_tool_catalog = __esm({
         description: "Search and discover available MCP tools",
         module: "discovery",
         scope: "mcp:read"
+      },
+      // pipeline
+      {
+        name: "check_pipeline_readiness",
+        description: "Pre-flight check before running a content pipeline",
+        module: "pipeline",
+        scope: "mcp:read"
+      },
+      {
+        name: "run_content_pipeline",
+        description: "End-to-end content pipeline: plan \u2192 quality \u2192 approve \u2192 schedule",
+        module: "pipeline",
+        scope: "mcp:autopilot"
+      },
+      {
+        name: "get_pipeline_status",
+        description: "Check status of a pipeline run",
+        module: "pipeline",
+        scope: "mcp:read"
+      },
+      {
+        name: "auto_approve_plan",
+        description: "Batch auto-approve posts meeting quality thresholds",
+        module: "pipeline",
+        scope: "mcp:autopilot"
+      },
+      // suggest
+      {
+        name: "suggest_next_content",
+        description: "Suggest next content topics based on performance data",
+        module: "suggest",
+        scope: "mcp:read"
+      },
+      // digest
+      {
+        name: "generate_performance_digest",
+        description: "Generate a performance summary with trends and recommendations",
+        module: "digest",
+        scope: "mcp:analytics"
+      },
+      {
+        name: "detect_anomalies",
+        description: "Detect significant performance changes (spikes, drops, viral)",
+        module: "digest",
+        scope: "mcp:analytics"
+      },
+      // autopilot (addition)
+      {
+        name: "create_autopilot_config",
+        description: "Create a new autopilot configuration",
+        module: "autopilot",
+        scope: "mcp:autopilot"
       }
     ];
   }
@@ -2947,7 +3065,7 @@ __export(setup_exports, {
   runLogout: () => runLogout,
   runSetup: () => runSetup
 });
-import { createHash as createHash4, randomBytes, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash4, randomBytes, randomUUID as randomUUID4 } from "node:crypto";
 import {
   createServer
 } from "node:http";
@@ -2968,7 +3086,11 @@ function getAppBaseUrl() {
   return process.env.SOCIALNEURON_APP_URL || "https://www.socialneuron.com";
 }
 function getDefaultSupabaseUrl() {
-  return process.env.SOCIALNEURON_SUPABASE_URL || process.env.SUPABASE_URL || CLOUD_SUPABASE_URL;
+  try {
+    return getSupabaseUrl();
+  } catch {
+    return "https://mcp.socialneuron.com";
+  }
 }
 function getConfigPaths() {
   const paths = [];
@@ -3074,7 +3196,7 @@ async function runSetup() {
   );
   console.error("");
   const { codeVerifier, codeChallenge } = generatePKCE();
-  const state = randomUUID3();
+  const state = randomUUID4();
   const { server: server2, port } = await new Promise((resolve3, reject) => {
     const srv = createServer();
     srv.listen(0, "127.0.0.1", () => {
@@ -3232,7 +3354,11 @@ function prompt(question) {
   });
 }
 function getDefaultSupabaseUrl2() {
-  return process.env.SOCIALNEURON_SUPABASE_URL || process.env.SUPABASE_URL || CLOUD_SUPABASE_URL;
+  try {
+    return getSupabaseUrl();
+  } catch {
+    return "https://mcp.socialneuron.com";
+  }
 }
 async function runLogin(method) {
   if (method === "browser") {
@@ -3748,6 +3874,9 @@ var TOOL_SCOPES = {
   get_best_posting_times: "mcp:read",
   extract_brand: "mcp:read",
   get_brand_profile: "mcp:read",
+  get_brand_runtime: "mcp:read",
+  explain_brand_system: "mcp:read",
+  check_brand_consistency: "mcp:read",
   get_ideation_context: "mcp:read",
   get_credit_balance: "mcp:read",
   get_budget_status: "mcp:read",
@@ -3763,6 +3892,7 @@ var TOOL_SCOPES = {
   generate_image: "mcp:write",
   check_status: "mcp:read",
   render_demo_video: "mcp:write",
+  render_template_video: "mcp:write",
   save_brand_profile: "mcp:write",
   update_platform_voice: "mcp:write",
   create_storyboard: "mcp:write",
@@ -3801,7 +3931,19 @@ var TOOL_SCOPES = {
   // mcp:read (usage is read-only)
   get_mcp_usage: "mcp:read",
   list_plan_approvals: "mcp:read",
-  search_tools: "mcp:read"
+  search_tools: "mcp:read",
+  // mcp:read (pipeline readiness + status are read-only)
+  check_pipeline_readiness: "mcp:read",
+  get_pipeline_status: "mcp:read",
+  // mcp:autopilot (pipeline orchestration + approval automation)
+  run_content_pipeline: "mcp:autopilot",
+  auto_approve_plan: "mcp:autopilot",
+  create_autopilot_config: "mcp:autopilot",
+  // mcp:read (suggestions are read-only, no credit cost)
+  suggest_next_content: "mcp:read",
+  // mcp:analytics (digest and anomalies are analytics-scoped)
+  generate_performance_digest: "mcp:analytics",
+  detect_anomalies: "mcp:analytics"
 };
 function hasScope(userScopes, required) {
   if (userScopes.includes(required)) return true;
@@ -3812,6 +3954,147 @@ function hasScope(userScopes, required) {
   return false;
 }
 
+// src/lib/tool-annotations.ts
+var ACRONYMS = {
+  youtube: "YouTube",
+  tiktok: "TikTok",
+  mcp: "MCP",
+  url: "URL",
+  ai: "AI",
+  api: "API",
+  dm: "DM",
+  id: "ID"
+};
+function toTitle(name) {
+  return name.split("_").map((w) => ACRONYMS[w] ?? w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+var SCOPE_DEFAULTS = {
+  "mcp:read": {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  "mcp:write": {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  "mcp:distribute": {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  "mcp:analytics": {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  "mcp:comments": {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  "mcp:autopilot": {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+};
+var OVERRIDES = {
+  // Destructive tools
+  delete_comment: { destructiveHint: true },
+  moderate_comment: { destructiveHint: true },
+  // Read-only tools in non-read scopes (must also clear destructiveHint from scope default)
+  list_comments: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  list_autopilot_configs: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  get_autopilot_status: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  check_status: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  get_content_plan: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  list_plan_approvals: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  // Analytics tool that triggers side effects (data refresh)
+  refresh_platform_analytics: { readOnlyHint: false, idempotentHint: true },
+  // Write tools that are idempotent
+  save_brand_profile: { idempotentHint: true },
+  update_platform_voice: { idempotentHint: true },
+  update_autopilot_config: { idempotentHint: true },
+  update_content_plan: { idempotentHint: true },
+  respond_plan_approval: { idempotentHint: true },
+  // Distribution is open-world (publishes to external platforms)
+  schedule_post: { openWorldHint: true },
+  schedule_content_plan: { openWorldHint: true },
+  // Extraction reads external URLs
+  extract_url_content: { openWorldHint: true },
+  extract_brand: { openWorldHint: true },
+  // Pipeline: read-only tools
+  check_pipeline_readiness: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  get_pipeline_status: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  // Pipeline: orchestration tools (non-idempotent, may schedule externally)
+  run_content_pipeline: { openWorldHint: true },
+  auto_approve_plan: { idempotentHint: true },
+  // Suggest: read-only
+  suggest_next_content: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  // Digest/Anomalies: read-only analytics
+  generate_performance_digest: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+  detect_anomalies: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
+};
+function buildAnnotationsMap() {
+  const map = /* @__PURE__ */ new Map();
+  for (const [toolName, scope] of Object.entries(TOOL_SCOPES)) {
+    const defaults = SCOPE_DEFAULTS[scope];
+    if (!defaults) {
+      map.set(toolName, {
+        title: toTitle(toolName),
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      });
+      continue;
+    }
+    const overrides = OVERRIDES[toolName] ?? {};
+    map.set(toolName, {
+      title: toTitle(toolName),
+      readOnlyHint: overrides.readOnlyHint ?? defaults.readOnlyHint,
+      destructiveHint: overrides.destructiveHint ?? defaults.destructiveHint,
+      idempotentHint: overrides.idempotentHint ?? defaults.idempotentHint,
+      openWorldHint: overrides.openWorldHint ?? defaults.openWorldHint
+    });
+  }
+  return map;
+}
+function applyAnnotations(server2) {
+  const annotations = buildAnnotationsMap();
+  const registeredTools = server2._registeredTools;
+  if (!registeredTools || typeof registeredTools !== "object") {
+    console.warn("[annotations] Could not access _registeredTools \u2014 annotations not applied");
+    return;
+  }
+  const entries = Object.entries(registeredTools);
+  let applied = 0;
+  for (const [toolName, tool] of entries) {
+    const ann = annotations.get(toolName);
+    if (ann && typeof tool.update === "function") {
+      tool.update({
+        annotations: {
+          title: ann.title,
+          readOnlyHint: ann.readOnlyHint,
+          destructiveHint: ann.destructiveHint,
+          idempotentHint: ann.idempotentHint,
+          openWorldHint: ann.openWorldHint
+        }
+      });
+      applied++;
+    }
+  }
+  console.log(`[annotations] Applied annotations to ${applied}/${entries.length} tools`);
+}
+
 // src/tools/ideation.ts
 init_edge_function();
 import { z } from "zod";
@@ -8250,6 +8533,7 @@ import { z as z7 } from "zod";
 import { resolve as resolve2 } from "node:path";
 import { mkdir as mkdir2 } from "node:fs/promises";
 init_supabase();
+init_edge_function();
 var COMPOSITIONS = [
   {
     id: "CaptionedClip",
@@ -8354,6 +8638,22 @@ var COMPOSITIONS = [
     durationInFrames: 450,
     fps: 30,
     description: "Product ad - 15s ultra-short"
+  },
+  {
+    id: "DataVizDashboard",
+    width: 1080,
+    height: 1920,
+    durationInFrames: 450,
+    fps: 30,
+    description: "Animated data dashboard - KPIs, bar chart, donut chart, line chart (15s, 9:16)"
+  },
+  {
+    id: "ReviewsTestimonial",
+    width: 1080,
+    height: 1920,
+    durationInFrames: 600,
+    fps: 30,
+    description: "Customer review testimonial with star animations and review carousel (dynamic duration, 9:16)"
   }
 ];
 function registerRemotionTools(server2) {
@@ -8361,13 +8661,6 @@ function registerRemotionTools(server2) {
     "list_compositions",
     "List all available Remotion video compositions defined in Social Neuron. Returns composition IDs, dimensions, duration, and descriptions. Use this to discover what videos can be rendered with render_demo_video.",
     {},
-    {
-      title: "List Compositions",
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
     async () => {
       const lines = [`${COMPOSITIONS.length} Remotion compositions available:`, ""];
       for (const comp of COMPOSITIONS) {
@@ -8396,13 +8689,6 @@ function registerRemotionTools(server2) {
         "JSON string of input props to pass to the composition. Each composition accepts different props. Omit for defaults."
       )
     },
-    {
-      title: "Render Demo Video",
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
     async ({ composition_id, output_format, props }) => {
       const startedAt = Date.now();
       const userId = await getDefaultUserId();
@@ -8534,6 +8820,134 @@ function registerRemotionTools(server2) {
       }
     }
   );
+  server2.tool(
+    "render_template_video",
+    "Render a Remotion template video in the cloud. Creates an async render job that is processed by the production worker, uploaded to R2, and tracked via async_jobs. Returns a job ID that can be polled with check_status. Costs credits based on video duration (3 base + 0.1/sec). Use list_compositions to see available template IDs.",
+    {
+      composition_id: z7.string().describe(
+        'Remotion composition ID. Examples: "DataVizDashboard", "ReviewsTestimonial", "CaptionedClip". Use list_compositions to see all available IDs.'
+      ),
+      input_props: z7.string().describe(
+        "JSON string of input props for the composition. Each composition has different required props. For DataVizDashboard: {title, kpis, barData, donutData, lineData}. For ReviewsTestimonial: {businessName, overallRating, totalReviews, reviews}."
+      ),
+      aspect_ratio: z7.enum(["9:16", "1:1", "16:9"]).optional().describe('Output aspect ratio. Defaults to "9:16" (vertical).')
+    },
+    async ({ composition_id, input_props, aspect_ratio }) => {
+      const startedAt = Date.now();
+      const userId = await getDefaultUserId();
+      const rateLimit = checkRateLimit("generation", `render_template:${userId}`);
+      if (!rateLimit.allowed) {
+        await logMcpToolInvocation({
+          toolName: "render_template_video",
+          status: "rate_limited",
+          durationMs: Date.now() - startedAt,
+          details: { retryAfter: rateLimit.retryAfter }
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Rate limit exceeded. Retry in ~${rateLimit.retryAfter}s.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const comp = COMPOSITIONS.find((c) => c.id === composition_id);
+      if (!comp) {
+        await logMcpToolInvocation({
+          toolName: "render_template_video",
+          status: "error",
+          durationMs: Date.now() - startedAt,
+          details: { error: "Unknown composition", compositionId: composition_id }
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown composition "${composition_id}". Available: ${COMPOSITIONS.map((c) => c.id).join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      let inputProps;
+      try {
+        inputProps = JSON.parse(input_props);
+      } catch {
+        await logMcpToolInvocation({
+          toolName: "render_template_video",
+          status: "error",
+          durationMs: Date.now() - startedAt,
+          details: { error: "Invalid input_props JSON" }
+        });
+        return {
+          content: [{ type: "text", text: `Invalid JSON in input_props.` }],
+          isError: true
+        };
+      }
+      try {
+        const { data, error } = await callEdgeFunction("create-remotion-job", {
+          compositionId: composition_id,
+          inputProps,
+          outputs: [
+            {
+              aspectRatio: aspect_ratio || "9:16",
+              resolution: "1080p",
+              codec: "h264"
+            }
+          ]
+        });
+        if (error || !data?.success) {
+          throw new Error(error || data?.error || "Failed to create render job");
+        }
+        await logMcpToolInvocation({
+          toolName: "render_template_video",
+          status: "success",
+          durationMs: Date.now() - startedAt,
+          details: {
+            compositionId: composition_id,
+            jobId: data.jobId,
+            creditsCharged: data.creditsCharged
+          }
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: [
+                `Render job created successfully.`,
+                `  Composition: ${composition_id}`,
+                `  Job ID: ${data.jobId}`,
+                `  Credits charged: ${data.creditsCharged}`,
+                `  Estimated duration: ${data.estimatedDurationSeconds}s`,
+                `  Content ID: ${data.contentHistoryId}`,
+                ``,
+                `The video is rendering in the cloud. Use check_status with job_id="${data.jobId}" to poll for completion. When done, the result_url will contain the R2 video URL.`
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await logMcpToolInvocation({
+          toolName: "render_template_video",
+          status: "error",
+          durationMs: Date.now() - startedAt,
+          details: { error: message, compositionId: composition_id }
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to create render job: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
 }
 
 // src/tools/insights.ts
@@ -9950,9 +10364,9 @@ ${"=".repeat(40)}
 }
 
 // src/tools/autopilot.ts
-init_supabase();
-import { z as z15 } from "zod";
+init_edge_function();
 init_version();
+import { z as z15 } from "zod";
 function asEnvelope11(data) {
   return {
     _meta: {
@@ -9970,46 +10384,35 @@ function registerAutopilotTools(server2) {
       active_only: z15.boolean().optional().describe("If true, only return active configs. Defaults to false (show all)."),
       response_format: z15.enum(["text", "json"]).optional().describe("Optional response format. Defaults to text.")
     },
-    {
-      title: "List Autopilot Configs",
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
     async ({ active_only, response_format }) => {
       const format = response_format ?? "text";
-      const supabase = getSupabaseClient();
-      const userId = await getDefaultUserId();
-      let query = supabase.from("autopilot_configs").select(
-        "id, recipe_id, is_active, schedule_config, max_credits_per_run, max_credits_per_week, credits_used_this_week, last_run_at, created_at, mode"
-      ).eq("user_id", userId).order("created_at", { ascending: false });
-      if (active_only) {
-        query = query.eq("is_active", true);
-      }
-      const { data: configs, error } = await query;
-      if (error) {
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", {
+        action: "list-autopilot-configs",
+        active_only: active_only ?? false
+      });
+      if (efError) {
         return {
           content: [
             {
               type: "text",
-              text: `Error fetching autopilot configs: ${sanitizeDbError(error)}`
+              text: `Error fetching autopilot configs: ${efError}`
             }
           ],
           isError: true
         };
       }
+      const configs = result?.configs ?? [];
       if (format === "json") {
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify(asEnvelope11(configs || []), null, 2)
+              text: JSON.stringify(asEnvelope11(configs), null, 2)
             }
           ]
         };
       }
-      if (!configs || configs.length === 0) {
+      if (configs.length === 0) {
         return {
           content: [
             {
@@ -10054,18 +10457,11 @@ ${"=".repeat(40)}
     {
       config_id: z15.string().uuid().describe("The autopilot config ID to update."),
       is_active: z15.boolean().optional().describe("Enable or disable this autopilot config."),
-      schedule_days: z15.array(z15.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"]).describe("Three-letter lowercase day abbreviation.")).optional().describe('Days of the week to run (e.g. ["mon", "wed", "fri"]).'),
+      schedule_days: z15.array(z15.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"])).optional().describe('Days of the week to run (e.g., ["mon", "wed", "fri"]).'),
       schedule_time: z15.string().optional().describe('Time to run in HH:MM format (24h, user timezone). E.g., "09:00".'),
       max_credits_per_run: z15.number().optional().describe("Maximum credits per execution."),
       max_credits_per_week: z15.number().optional().describe("Maximum credits per week.")
     },
-    {
-      title: "Update Autopilot Config",
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
     async ({
       config_id,
       is_active,
@@ -10074,22 +10470,7 @@ ${"=".repeat(40)}
       max_credits_per_run,
       max_credits_per_week
     }) => {
-      const supabase = getSupabaseClient();
-      const userId = await getDefaultUserId();
-      const updates = {};
-      if (is_active !== void 0) updates.is_active = is_active;
-      if (max_credits_per_run !== void 0) updates.max_credits_per_run = max_credits_per_run;
-      if (max_credits_per_week !== void 0) updates.max_credits_per_week = max_credits_per_week;
-      if (schedule_days || schedule_time) {
-        const { data: existing } = await supabase.from("autopilot_configs").select("schedule_config").eq("id", config_id).eq("user_id", userId).single();
-        const existingSchedule = existing?.schedule_config || {};
-        updates.schedule_config = {
-          ...existingSchedule,
-          ...schedule_days ? { days: schedule_days } : {},
-          ...schedule_time ? { time: schedule_time } : {}
-        };
-      }
-      if (Object.keys(updates).length === 0) {
+      if (is_active === void 0 && !schedule_days && !schedule_time && max_credits_per_run === void 0 && max_credits_per_week === void 0) {
         return {
           content: [
             {
@@ -10099,18 +10480,37 @@ ${"=".repeat(40)}
           ]
         };
       }
-      const { data: updated, error } = await supabase.from("autopilot_configs").update(updates).eq("id", config_id).eq("user_id", userId).select("id, is_active, schedule_config, max_credits_per_run").single();
-      if (error) {
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", {
+        action: "update-autopilot-config",
+        config_id,
+        is_active,
+        schedule_days,
+        schedule_time,
+        max_credits_per_run,
+        max_credits_per_week
+      });
+      if (efError) {
         return {
           content: [
             {
               type: "text",
-              text: `Error updating config: ${sanitizeDbError(error)}`
+              text: `Error updating config: ${efError}`
             }
           ],
           isError: true
         };
       }
+      const updated = result?.updated;
+      if (!updated) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: result?.message || "No changes applied."
+            }
+          ]
+        };
+      }
       return {
         content: [
           {
@@ -10129,26 +10529,19 @@ Schedule: ${JSON.stringify(updated.schedule_config)}`
     {
       response_format: z15.enum(["text", "json"]).optional().describe("Optional response format. Defaults to text.")
     },
-    {
-      title: "Get Autopilot Status",
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
     async ({ response_format }) => {
       const format = response_format ?? "text";
-      const supabase = getSupabaseClient();
-      const userId = await getDefaultUserId();
-      const { data: configs } = await supabase.from("autopilot_configs").select(
-        "id, recipe_id, is_active, schedule_config, last_run_at, credits_used_this_week, max_credits_per_week"
-      ).eq("user_id", userId).eq("is_active", true);
-      const { data: recentRuns } = await supabase.from("recipe_runs").select("id, status, started_at, completed_at, credits_used").eq("user_id", userId).order("started_at", { ascending: false }).limit(5);
-      const { data: approvals } = await supabase.from("approval_queue").select("id, status, created_at").eq("user_id", userId).eq("status", "pending");
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", { action: "autopilot-status" });
+      if (efError) {
+        return {
+          content: [{ type: "text", text: `Error fetching autopilot status: ${efError}` }],
+          isError: true
+        };
+      }
       const statusData = {
-        activeConfigs: configs?.length || 0,
-        recentRuns: recentRuns || [],
-        pendingApprovals: approvals?.length || 0
+        activeConfigs: result?.activeConfigs ?? 0,
+        recentRuns: [],
+        pendingApprovals: result?.pendingApprovals ?? 0
       };
       if (format === "json") {
         return {
@@ -10169,24 +10562,95 @@ ${"=".repeat(40)}
       text += `Pending Approvals: ${statusData.pendingApprovals}
 
 `;
-      if (statusData.recentRuns.length > 0) {
-        text += `Recent Runs:
-`;
-        for (const run of statusData.recentRuns) {
-          text += `  ${run.id.substring(0, 8)}... \u2014 ${run.status} (${run.started_at})
-`;
-        }
-      } else {
-        text += `No recent runs.
+      text += `No recent runs.
 `;
-      }
       return {
         content: [{ type: "text", text }]
       };
     }
   );
-}
-
+  server2.tool(
+    "create_autopilot_config",
+    "Create a new autopilot configuration for automated content pipeline execution. Defines schedule, credit budgets, and approval mode.",
+    {
+      name: z15.string().min(1).max(100).describe("Name for this autopilot config"),
+      project_id: z15.string().uuid().describe("Project to run autopilot for"),
+      mode: z15.enum(["recipe", "pipeline"]).default("pipeline").describe("Mode: recipe (legacy) or pipeline (new orchestration)"),
+      schedule_days: z15.array(z15.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"])).min(1).describe("Days of the week to run"),
+      schedule_time: z15.string().describe('Time to run in HH:MM format (24h). E.g., "09:00"'),
+      timezone: z15.string().optional().describe('Timezone (e.g., "America/New_York"). Defaults to UTC.'),
+      max_credits_per_run: z15.number().min(0).optional().describe("Maximum credits per execution"),
+      max_credits_per_week: z15.number().min(0).optional().describe("Maximum credits per week"),
+      approval_mode: z15.enum(["auto", "review_all", "review_low_confidence"]).default("review_low_confidence").describe("How to handle post approvals"),
+      is_active: z15.boolean().default(true).describe("Whether to activate immediately"),
+      response_format: z15.enum(["text", "json"]).optional().describe("Response format. Defaults to text.")
+    },
+    async ({
+      name,
+      project_id,
+      mode,
+      schedule_days,
+      schedule_time,
+      timezone,
+      max_credits_per_run,
+      max_credits_per_week,
+      approval_mode,
+      is_active,
+      response_format
+    }) => {
+      const format = response_format ?? "text";
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", {
+        action: "create-autopilot-config",
+        name,
+        projectId: project_id,
+        mode,
+        schedule_days,
+        schedule_time,
+        timezone,
+        max_credits_per_run,
+        max_credits_per_week,
+        approval_mode,
+        is_active
+      });
+      if (efError) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating autopilot config: ${efError}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const created = result?.created;
+      if (!created) {
+        return {
+          content: [{ type: "text", text: "Failed to create config." }],
+          isError: true
+        };
+      }
+      if (format === "json") {
+        return {
+          content: [{ type: "text", text: JSON.stringify(asEnvelope11(created), null, 2) }]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Autopilot config created: ${created.id}
+Name: ${name}
+Mode: ${mode}
+Schedule: ${schedule_days.join(", ")} @ ${schedule_time}
+Active: ${is_active}`
+          }
+        ]
+      };
+    }
+  );
+}
+
 // src/tools/extraction.ts
 init_edge_function();
 init_supabase();
@@ -11867,76 +12331,2293 @@ function registerDiscoveryTools(server2) {
   );
 }
 
-// src/lib/register-tools.ts
-function applyScopeEnforcement(server2, scopeResolver) {
-  const originalTool = server2.tool.bind(server2);
-  server2.tool = function wrappedTool(...args) {
-    const name = args[0];
-    const requiredScope = TOOL_SCOPES[name];
-    const handlerIndex = args.findIndex(
-      (a, i) => i > 0 && typeof a === "function"
-    );
-    if (handlerIndex !== -1) {
-      const originalHandler = args[handlerIndex];
-      args[handlerIndex] = async function scopeEnforcedHandler(...handlerArgs) {
-        if (!requiredScope) {
+// src/tools/pipeline.ts
+init_edge_function();
+init_supabase();
+init_quality();
+init_version();
+import { z as z21 } from "zod";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// src/lib/parse-utils.ts
+function extractJsonArray2(text) {
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) return parsed;
+    for (const key of ["posts", "plan", "content", "items", "results"]) {
+      if (parsed[key] && Array.isArray(parsed[key])) return parsed[key];
+    }
+  } catch {
+  }
+  const match = text.match(/\[[\s\S]*\]/);
+  if (match) {
+    try {
+      return JSON.parse(match[0]);
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/tools/pipeline.ts
+function asEnvelope16(data) {
+  return { _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, data };
+}
+var PLATFORM_ENUM2 = z21.enum([
+  "youtube",
+  "tiktok",
+  "instagram",
+  "twitter",
+  "linkedin",
+  "facebook",
+  "threads",
+  "bluesky"
+]);
+var BASE_PLAN_CREDITS = 15;
+var SOURCE_EXTRACTION_CREDITS = 5;
+function registerPipelineTools(server2) {
+  server2.tool(
+    "check_pipeline_readiness",
+    "Pre-flight check before run_content_pipeline. Verifies: sufficient credits for estimated_posts, active OAuth on target platforms, brand profile exists, no stale insights. Returns pass/fail with specific issues to fix before running the pipeline.",
+    {
+      project_id: z21.string().uuid().optional().describe("Project ID (auto-detected if omitted)"),
+      platforms: z21.array(PLATFORM_ENUM2).min(1).describe("Target platforms to check"),
+      estimated_posts: z21.number().min(1).max(50).default(5).describe("Estimated posts to generate"),
+      response_format: z21.enum(["text", "json"]).optional().describe("Response format")
+    },
+    async ({ project_id, platforms, estimated_posts, response_format }) => {
+      const format = response_format ?? "text";
+      const startedAt = Date.now();
+      try {
+        const resolvedProjectId = project_id ?? await getDefaultProjectId() ?? void 0;
+        const estimatedCost = BASE_PLAN_CREDITS + estimated_posts * 2;
+        const { data: readiness, error: readinessError } = await callEdgeFunction(
+          "mcp-data",
+          {
+            action: "pipeline-readiness",
+            platforms,
+            estimated_posts,
+            ...resolvedProjectId ? { projectId: resolvedProjectId, project_id: resolvedProjectId } : {}
+          },
+          { timeoutMs: 15e3 }
+        );
+        if (readinessError || !readiness) {
+          throw new Error(readinessError ?? "No response from mcp-data");
+        }
+        const credits = readiness.credits;
+        const connectedPlatforms = readiness.connected_platforms;
+        const missingPlatforms = readiness.missing_platforms;
+        const hasBrand = readiness.has_brand;
+        const pendingApprovals = readiness.pending_approvals;
+        const insightAge = readiness.insight_age;
+        const insightsFresh = readiness.insights_fresh;
+        const blockers = [];
+        const warnings = [];
+        if (credits < estimatedCost) {
+          blockers.push(`Insufficient credits: ${credits} available, ~${estimatedCost} needed`);
+        }
+        if (missingPlatforms.length > 0) {
+          blockers.push(`Missing connected accounts: ${missingPlatforms.join(", ")}`);
+        }
+        if (!hasBrand) {
+          warnings.push("No brand profile found. Content will use generic voice.");
+        }
+        if (pendingApprovals > 0) {
+          warnings.push(`${pendingApprovals} pending approval(s) from previous runs.`);
+        }
+        if (!insightsFresh) {
+          warnings.push(
+            insightAge === null ? "No performance insights available. Pipeline will skip optimization." : `Insights are ${insightAge} days old. Consider refreshing analytics.`
+          );
+        }
+        const result = {
+          ready: blockers.length === 0,
+          checks: {
+            credits: {
+              available: credits,
+              estimated_cost: estimatedCost,
+              sufficient: credits >= estimatedCost
+            },
+            connected_accounts: { platforms: connectedPlatforms, missing: missingPlatforms },
+            brand_profile: { exists: hasBrand },
+            pending_approvals: { count: pendingApprovals },
+            insights_available: {
+              count: readiness.latest_insight ? 1 : 0,
+              fresh: insightsFresh,
+              last_generated_at: readiness.latest_insight?.generated_at ?? null
+            }
+          },
+          blockers,
+          warnings
+        };
+        const durationMs = Date.now() - startedAt;
+        logMcpToolInvocation({
+          toolName: "check_pipeline_readiness",
+          status: "success",
+          durationMs,
+          details: { ready: result.ready, blockers: blockers.length, warnings: warnings.length }
+        });
+        if (format === "json") {
+          return {
+            content: [{ type: "text", text: JSON.stringify(asEnvelope16(result), null, 2) }]
+          };
+        }
+        const lines = [];
+        lines.push(`Pipeline Readiness: ${result.ready ? "READY" : "NOT READY"}`);
+        lines.push("=".repeat(40));
+        lines.push(
+          `Credits: ${credits} available, ~${estimatedCost} needed \u2014 ${credits >= estimatedCost ? "OK" : "BLOCKED"}`
+        );
+        lines.push(
+          `Accounts: ${connectedPlatforms.length} connected${missingPlatforms.length > 0 ? ` (missing: ${missingPlatforms.join(", ")})` : " \u2014 OK"}`
+        );
+        lines.push(`Brand: ${hasBrand ? "OK" : "Missing (will use generic voice)"}`);
+        lines.push(`Pending Approvals: ${pendingApprovals}`);
+        lines.push(
+          `Insights: ${insightsFresh ? "Fresh" : insightAge === null ? "None available" : `${insightAge} days old`}`
+        );
+        if (blockers.length > 0) {
+          lines.push("");
+          lines.push("BLOCKERS:");
+          for (const b of blockers) lines.push(`  \u2717 ${b}`);
+        }
+        if (warnings.length > 0) {
+          lines.push("");
+          lines.push("WARNINGS:");
+          for (const w of warnings) lines.push(`  ! ${w}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        logMcpToolInvocation({
+          toolName: "check_pipeline_readiness",
+          status: "error",
+          durationMs,
+          details: { error: message }
+        });
+        return {
+          content: [{ type: "text", text: `Readiness check failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "run_content_pipeline",
+    "Run the full content pipeline: research trends \u2192 generate plan \u2192 quality check \u2192 auto-approve \u2192 schedule posts. Chains all stages in one call for maximum efficiency. Set dry_run=true to preview the plan without publishing. Check check_pipeline_readiness first to verify credits, OAuth, and brand profile are ready.",
+    {
+      project_id: z21.string().uuid().optional().describe("Project ID (auto-detected if omitted)"),
+      topic: z21.string().optional().describe("Content topic (required if no source_url)"),
+      source_url: z21.string().optional().describe("URL to extract content from"),
+      platforms: z21.array(PLATFORM_ENUM2).min(1).describe("Target platforms"),
+      days: z21.number().min(1).max(7).default(5).describe("Days to plan"),
+      posts_per_day: z21.number().min(1).max(3).default(1).describe("Posts per platform per day"),
+      approval_mode: z21.enum(["auto", "review_all", "review_low_confidence"]).default("review_low_confidence").describe(
+        "auto: approve all passing quality. review_all: flag everything. review_low_confidence: auto-approve high scorers."
+      ),
+      auto_approve_threshold: z21.number().min(0).max(35).default(28).describe(
+        "Quality score threshold for auto-approval (used in auto/review_low_confidence modes)"
+      ),
+      max_credits: z21.number().optional().describe("Credit budget cap"),
+      dry_run: z21.boolean().default(false).describe("If true, skip scheduling and return plan only"),
+      skip_stages: z21.array(z21.enum(["research", "quality", "schedule"])).optional().describe("Stages to skip"),
+      response_format: z21.enum(["text", "json"]).default("json")
+    },
+    async ({
+      project_id,
+      topic,
+      source_url,
+      platforms,
+      days,
+      posts_per_day,
+      approval_mode,
+      auto_approve_threshold,
+      max_credits,
+      dry_run,
+      skip_stages,
+      response_format
+    }) => {
+      const startedAt = Date.now();
+      const pipelineId = randomUUID3();
+      const stagesCompleted = [];
+      const stagesSkipped = [];
+      const errors = [];
+      let creditsUsed = 0;
+      if (!topic && !source_url) {
+        return {
+          content: [{ type: "text", text: "Either topic or source_url is required." }],
+          isError: true
+        };
+      }
+      const skipSet = new Set(skip_stages ?? []);
+      try {
+        const resolvedProjectId = project_id ?? await getDefaultProjectId() ?? void 0;
+        const estimatedCost = BASE_PLAN_CREDITS + (source_url ? SOURCE_EXTRACTION_CREDITS : 0);
+        const { data: budgetData } = await callEdgeFunction(
+          "mcp-data",
+          {
+            action: "run-pipeline",
+            plan_status: "budget-check",
+            ...resolvedProjectId ? { projectId: resolvedProjectId, project_id: resolvedProjectId } : {}
+          },
+          { timeoutMs: 1e4 }
+        );
+        const availableCredits = budgetData?.credits ?? 0;
+        const creditLimit = max_credits ?? availableCredits;
+        if (availableCredits < estimatedCost) {
           return {
             content: [
               {
                 type: "text",
-                text: `Permission denied: '${name}' has no scope defined. Contact support.`
+                text: `Insufficient credits: ${availableCredits} available, ~${estimatedCost} needed.`
               }
             ],
             isError: true
           };
         }
-        const userScopes = scopeResolver();
-        if (!hasScope(userScopes, requiredScope)) {
+        stagesCompleted.push("budget_check");
+        await callEdgeFunction(
+          "mcp-data",
+          {
+            action: "run-pipeline",
+            plan_status: "create",
+            pipeline_id: pipelineId,
+            config: {
+              topic,
+              source_url,
+              platforms,
+              days,
+              posts_per_day,
+              approval_mode,
+              auto_approve_threshold,
+              dry_run,
+              skip_stages: skip_stages ?? []
+            },
+            current_stage: "planning",
+            ...resolvedProjectId ? { projectId: resolvedProjectId, project_id: resolvedProjectId } : {}
+          },
+          { timeoutMs: 1e4 }
+        );
+        const resolvedTopic = topic ?? source_url ?? "Content plan";
+        const { data: planData, error: planError } = await callEdgeFunction(
+          "social-neuron-ai",
+          {
+            type: "generation",
+            prompt: buildPlanPrompt(resolvedTopic, platforms, days, posts_per_day, source_url),
+            model: "gemini-2.5-flash",
+            responseFormat: "json",
+            ...resolvedProjectId ? { projectId: resolvedProjectId, project_id: resolvedProjectId } : {}
+          },
+          { timeoutMs: 6e4 }
+        );
+        if (planError || !planData) {
+          errors.push({ stage: "planning", message: planError ?? "No AI response" });
+          await callEdgeFunction(
+            "mcp-data",
+            {
+              action: "run-pipeline",
+              plan_status: "update",
+              pipeline_id: pipelineId,
+              status: "failed",
+              stages_completed: stagesCompleted,
+              errors,
+              current_stage: null,
+              completed_at: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            { timeoutMs: 1e4 }
+          );
           return {
             content: [
-              {
-                type: "text",
-                text: `Permission denied: '${name}' requires scope '${requiredScope}'. Generate a new key with the required scope at https://socialneuron.com/settings/developer`
-              }
+              { type: "text", text: `Planning failed: ${planError ?? "No AI response"}` }
             ],
             isError: true
           };
         }
-        return originalHandler(...handlerArgs);
-      };
-    }
-    return originalTool(...args);
-  };
-}
-function registerAllTools(server2, options) {
-  registerIdeationTools(server2);
-  registerContentTools(server2);
-  registerDistributionTools(server2);
-  registerAnalyticsTools(server2);
-  registerBrandTools(server2);
-  if (!options?.skipScreenshots) {
-    registerScreenshotTools(server2);
-  }
-  registerRemotionTools(server2);
-  registerInsightsTools(server2);
-  registerYouTubeAnalyticsTools(server2);
-  registerCommentsTools(server2);
-  registerIdeationContextTools(server2);
-  registerCreditsTools(server2);
-  registerLoopSummaryTools(server2);
-  registerUsageTools(server2);
-  registerAutopilotTools(server2);
-  registerExtractionTools(server2);
-  registerQualityTools(server2);
-  registerPlanningTools(server2);
-  registerPlanApprovalTools(server2);
-  registerDiscoveryTools(server2);
-}
-
-// src/index.ts
-init_posthog();
-init_supabase();
-init_sn();
+        creditsUsed += BASE_PLAN_CREDITS;
+        if (!dry_run) {
+          try {
+            await callEdgeFunction(
+              "mcp-data",
+              {
+                action: "run-pipeline",
+                plan_status: "deduct-credits",
+                credits_used: BASE_PLAN_CREDITS,
+                reason: `Pipeline ${pipelineId.slice(0, 8)}: content plan generation`
+              },
+              { timeoutMs: 1e4 }
+            );
+          } catch (deductErr) {
+            errors.push({
+              stage: "planning",
+              message: `Credit deduction failed: ${deductErr instanceof Error ? deductErr.message : String(deductErr)}`
+            });
+          }
+        }
+        stagesCompleted.push("planning");
+        const rawText = String(planData.text ?? planData.content ?? "");
+        const postsArray = extractJsonArray2(rawText);
+        const posts = (postsArray ?? []).map((p) => ({
+          id: String(p.id ?? randomUUID3().slice(0, 8)),
+          day: Number(p.day ?? 1),
+          date: String(p.date ?? ""),
+          platform: String(p.platform ?? ""),
+          content_type: p.content_type ?? "caption",
+          caption: String(p.caption ?? ""),
+          title: p.title ? String(p.title) : void 0,
+          hashtags: Array.isArray(p.hashtags) ? p.hashtags.map(String) : void 0,
+          hook: String(p.hook ?? ""),
+          angle: String(p.angle ?? ""),
+          visual_direction: p.visual_direction ? String(p.visual_direction) : void 0,
+          media_type: p.media_type ? String(p.media_type) : void 0
+        }));
+        let postsApproved = 0;
+        let postsFlagged = 0;
+        if (!skipSet.has("quality")) {
+          for (const post of posts) {
+            const quality = evaluateQuality({
+              caption: post.caption,
+              title: post.title,
+              platforms: [post.platform],
+              threshold: auto_approve_threshold
+            });
+            post.quality = {
+              score: quality.total,
+              max_score: quality.maxTotal,
+              passed: quality.passed,
+              blockers: quality.blockers
+            };
+            if (approval_mode === "auto" && quality.passed) {
+              post.status = "approved";
+              postsApproved++;
+            } else if (approval_mode === "review_low_confidence") {
+              if (quality.total >= auto_approve_threshold && quality.blockers.length === 0) {
+                post.status = "approved";
+                postsApproved++;
+              } else {
+                post.status = "needs_edit";
+                postsFlagged++;
+              }
+            } else {
+              post.status = "pending";
+              postsFlagged++;
+            }
+          }
+          stagesCompleted.push("quality_check");
+        } else {
+          stagesSkipped.push("quality_check");
+          for (const post of posts) {
+            post.status = "approved";
+            postsApproved++;
+          }
+        }
+        const planId = randomUUID3();
+        if (resolvedProjectId) {
+          const startDate = /* @__PURE__ */ new Date();
+          startDate.setDate(startDate.getDate() + 1);
+          const endDate = new Date(startDate);
+          endDate.setDate(endDate.getDate() + days - 1);
+          await callEdgeFunction(
+            "mcp-data",
+            {
+              action: "run-pipeline",
+              plan_status: "persist-plan",
+              pipeline_id: pipelineId,
+              plan_id: planId,
+              topic: resolvedTopic,
+              status: postsFlagged > 0 ? "in_review" : "approved",
+              plan_payload: {
+                plan_id: planId,
+                topic: resolvedTopic,
+                platforms,
+                posts,
+                start_date: startDate.toISOString().split("T")[0],
+                end_date: endDate.toISOString().split("T")[0],
+                estimated_credits: estimatedCost,
+                generated_at: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              ...resolvedProjectId ? { projectId: resolvedProjectId, project_id: resolvedProjectId } : {}
+            },
+            { timeoutMs: 1e4 }
+          );
+        }
+        stagesCompleted.push("persist_plan");
+        if (postsFlagged > 0 && resolvedProjectId) {
+          const userId = await getDefaultUserId();
+          const resolvedApprovalRows = posts.filter((p) => p.status !== "approved").map((post) => ({
+            plan_id: planId,
+            post_id: post.id,
+            project_id: resolvedProjectId,
+            user_id: userId,
+            status: "pending",
+            original_post: post,
+            auto_approved: false
+          }));
+          if (resolvedApprovalRows.length > 0) {
+            await callEdgeFunction(
+              "mcp-data",
+              {
+                action: "run-pipeline",
+                plan_status: "upsert-approvals",
+                posts: resolvedApprovalRows
+              },
+              { timeoutMs: 1e4 }
+            );
+          }
+        }
+        if (postsApproved > 0 && resolvedProjectId) {
+          const userId = await getDefaultUserId();
+          const autoApprovedRows = posts.filter((p) => p.status === "approved").map((post) => ({
+            plan_id: planId,
+            post_id: post.id,
+            project_id: resolvedProjectId,
+            user_id: userId,
+            status: "approved",
+            original_post: post,
+            auto_approved: true
+          }));
+          if (autoApprovedRows.length > 0) {
+            await callEdgeFunction(
+              "mcp-data",
+              {
+                action: "run-pipeline",
+                plan_status: "upsert-approvals",
+                posts: autoApprovedRows
+              },
+              { timeoutMs: 1e4 }
+            );
+          }
+        }
+        let postsScheduled = 0;
+        if (!dry_run && !skipSet.has("schedule") && postsApproved > 0) {
+          const approvedPosts = posts.filter((p) => p.status === "approved");
+          for (const post of approvedPosts) {
+            if (creditsUsed >= creditLimit) {
+              errors.push({ stage: "schedule", message: "Credit limit reached" });
+              break;
+            }
+            try {
+              const { error: schedError } = await callEdgeFunction(
+                "schedule-post",
+                {
+                  platform: post.platform,
+                  caption: post.caption,
+                  title: post.title,
+                  hashtags: post.hashtags,
+                  media_url: post.media_url,
+                  scheduled_at: post.schedule_at,
+                  ...resolvedProjectId ? { projectId: resolvedProjectId, project_id: resolvedProjectId } : {}
+                },
+                { timeoutMs: 15e3 }
+              );
+              if (schedError) {
+                errors.push({
+                  stage: "schedule",
+                  message: `Failed to schedule ${post.id}: ${schedError}`
+                });
+              } else {
+                postsScheduled++;
+              }
+            } catch (schedErr) {
+              errors.push({
+                stage: "schedule",
+                message: `Failed to schedule ${post.id}: ${schedErr instanceof Error ? schedErr.message : String(schedErr)}`
+              });
+            }
+          }
+          stagesCompleted.push("schedule");
+        } else if (dry_run) {
+          stagesSkipped.push("schedule");
+        } else if (skipSet.has("schedule")) {
+          stagesSkipped.push("schedule");
+        }
+        const finalStatus = errors.length > 0 && stagesCompleted.length <= 2 ? "failed" : postsFlagged > 0 ? "awaiting_approval" : "completed";
+        await callEdgeFunction(
+          "mcp-data",
+          {
+            action: "run-pipeline",
+            plan_status: "update",
+            pipeline_id: pipelineId,
+            status: finalStatus,
+            plan_id: planId,
+            stages_completed: stagesCompleted,
+            stages_skipped: stagesSkipped,
+            current_stage: null,
+            posts_generated: posts.length,
+            posts_approved: postsApproved,
+            posts_scheduled: postsScheduled,
+            posts_flagged: postsFlagged,
+            credits_used: creditsUsed,
+            errors,
+            completed_at: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          { timeoutMs: 1e4 }
+        );
+        const durationMs = Date.now() - startedAt;
+        logMcpToolInvocation({
+          toolName: "run_content_pipeline",
+          status: "success",
+          durationMs,
+          details: {
+            pipeline_id: pipelineId,
+            posts: posts.length,
+            approved: postsApproved,
+            scheduled: postsScheduled,
+            flagged: postsFlagged
+          }
+        });
+        const resultPayload = {
+          pipeline_id: pipelineId,
+          stages_completed: stagesCompleted,
+          stages_skipped: stagesSkipped,
+          plan_id: planId,
+          posts_generated: posts.length,
+          posts_approved: postsApproved,
+          posts_scheduled: postsScheduled,
+          posts_flagged: postsFlagged,
+          credits_used: creditsUsed,
+          credits_remaining: availableCredits - creditsUsed,
+          dry_run,
+          next_action: postsFlagged > 0 ? `Review ${postsFlagged} flagged post(s) with list_plan_approvals and respond_plan_approval.` : postsScheduled > 0 ? "All posts scheduled. Monitor with get_pipeline_status." : "Pipeline complete.",
+          errors: errors.length > 0 ? errors : void 0
+        };
+        if (response_format === "json") {
+          return {
+            content: [
+              { type: "text", text: JSON.stringify(asEnvelope16(resultPayload), null, 2) }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(`Pipeline ${pipelineId.slice(0, 8)}... ${finalStatus.toUpperCase()}`);
+        lines.push("=".repeat(40));
+        lines.push(`Posts generated: ${posts.length}`);
+        lines.push(`Posts approved: ${postsApproved}`);
+        lines.push(`Posts scheduled: ${postsScheduled}`);
+        lines.push(`Posts flagged for review: ${postsFlagged}`);
+        lines.push(`Credits used: ${creditsUsed}`);
+        lines.push(`Stages: ${stagesCompleted.join(" \u2192 ")}`);
+        if (stagesSkipped.length > 0) {
+          lines.push(`Skipped: ${stagesSkipped.join(", ")}`);
+        }
+        if (errors.length > 0) {
+          lines.push("");
+          lines.push("Errors:");
+          for (const e of errors) lines.push(`  [${e.stage}] ${e.message}`);
+        }
+        lines.push("");
+        lines.push(`Next: ${resultPayload.next_action}`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        logMcpToolInvocation({
+          toolName: "run_content_pipeline",
+          status: "error",
+          durationMs,
+          details: { error: message }
+        });
+        try {
+          await callEdgeFunction(
+            "mcp-data",
+            {
+              action: "run-pipeline",
+              plan_status: "update",
+              pipeline_id: pipelineId,
+              status: "failed",
+              stages_completed: stagesCompleted,
+              errors: [...errors, { stage: "unknown", message }],
+              current_stage: null,
+              completed_at: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            { timeoutMs: 1e4 }
+          );
+        } catch {
+        }
+        return {
+          content: [{ type: "text", text: `Pipeline failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get_pipeline_status",
+    "Check status of a pipeline run, including stages completed, pending approvals, and scheduled posts.",
+    {
+      pipeline_id: z21.string().uuid().optional().describe("Pipeline run ID (omit for latest)"),
+      response_format: z21.enum(["text", "json"]).optional()
+    },
+    async ({ pipeline_id, response_format }) => {
+      const format = response_format ?? "text";
+      const { data: result, error: fetchError } = await callEdgeFunction(
+        "mcp-data",
+        {
+          action: "get-pipeline-status",
+          ...pipeline_id ? { pipeline_id } : {}
+        },
+        { timeoutMs: 1e4 }
+      );
+      if (fetchError) {
+        return {
+          content: [{ type: "text", text: `Error: ${fetchError}` }],
+          isError: true
+        };
+      }
+      const data = result?.pipeline;
+      if (!data) {
+        return {
+          content: [{ type: "text", text: "No pipeline runs found." }]
+        };
+      }
+      if (format === "json") {
+        return {
+          content: [{ type: "text", text: JSON.stringify(asEnvelope16(data), null, 2) }]
+        };
+      }
+      const lines = [];
+      lines.push(
+        `Pipeline ${String(data.id).slice(0, 8)}... \u2014 ${String(data.status).toUpperCase()}`
+      );
+      lines.push("=".repeat(40));
+      lines.push(`Started: ${data.started_at}`);
+      if (data.completed_at) lines.push(`Completed: ${data.completed_at}`);
+      lines.push(
+        `Stages: ${(Array.isArray(data.stages_completed) ? data.stages_completed : []).join(" \u2192 ") || "none"}`
+      );
+      if (Array.isArray(data.stages_skipped) && data.stages_skipped.length > 0) {
+        lines.push(`Skipped: ${data.stages_skipped.join(", ")}`);
+      }
+      lines.push(
+        `Posts: ${data.posts_generated} generated, ${data.posts_approved} approved, ${data.posts_scheduled} scheduled, ${data.posts_flagged} flagged`
+      );
+      lines.push(`Credits used: ${data.credits_used}`);
+      if (data.plan_id) lines.push(`Plan ID: ${data.plan_id}`);
+      const errs = data.errors;
+      if (errs && errs.length > 0) {
+        lines.push("");
+        lines.push("Errors:");
+        for (const e of errs) lines.push(`  [${e.stage}] ${e.message}`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "auto_approve_plan",
+    "Batch auto-approve posts in a content plan that meet quality thresholds. Posts below the threshold are flagged for manual review.",
+    {
+      plan_id: z21.string().uuid().describe("Content plan ID"),
+      quality_threshold: z21.number().min(0).max(35).default(26).describe("Minimum quality score to auto-approve"),
+      response_format: z21.enum(["text", "json"]).default("json")
+    },
+    async ({ plan_id, quality_threshold, response_format }) => {
+      const startedAt = Date.now();
+      try {
+        const { data: loadResult, error: loadError } = await callEdgeFunction("mcp-data", { action: "auto-approve-plan", plan_id }, { timeoutMs: 1e4 });
+        if (loadError) {
+          return {
+            content: [{ type: "text", text: `Failed to load plan: ${loadError}` }],
+            isError: true
+          };
+        }
+        const stored = loadResult?.plan;
+        if (!stored?.plan_payload) {
+          return {
+            content: [
+              { type: "text", text: `No content plan found for plan_id=${plan_id}` }
+            ],
+            isError: true
+          };
+        }
+        const plan = stored.plan_payload;
+        const posts = Array.isArray(plan.posts) ? plan.posts : [];
+        let autoApproved = 0;
+        let flagged = 0;
+        let rejected = 0;
+        const details = [];
+        for (const post of posts) {
+          const quality = evaluateQuality({
+            caption: post.caption,
+            title: post.title,
+            platforms: [post.platform],
+            threshold: quality_threshold
+          });
+          if (quality.total >= quality_threshold && quality.blockers.length === 0) {
+            post.status = "approved";
+            post.quality = {
+              score: quality.total,
+              max_score: quality.maxTotal,
+              passed: true,
+              blockers: []
+            };
+            autoApproved++;
+            details.push({ post_id: post.id, action: "approved", score: quality.total });
+          } else if (quality.total >= quality_threshold - 5) {
+            post.status = "needs_edit";
+            post.quality = {
+              score: quality.total,
+              max_score: quality.maxTotal,
+              passed: false,
+              blockers: quality.blockers
+            };
+            flagged++;
+            details.push({ post_id: post.id, action: "flagged", score: quality.total });
+          } else {
+            post.status = "rejected";
+            post.quality = {
+              score: quality.total,
+              max_score: quality.maxTotal,
+              passed: false,
+              blockers: quality.blockers
+            };
+            rejected++;
+            details.push({ post_id: post.id, action: "rejected", score: quality.total });
+          }
+        }
+        const newStatus = flagged === 0 && rejected === 0 ? "approved" : "in_review";
+        const userId = await getDefaultUserId();
+        const resolvedRows = posts.map((post) => ({
+          plan_id,
+          post_id: post.id,
+          project_id: stored.project_id,
+          user_id: userId,
+          status: post.status === "approved" ? "approved" : post.status === "rejected" ? "rejected" : "pending",
+          original_post: post,
+          auto_approved: post.status === "approved"
+        }));
+        await callEdgeFunction(
+          "mcp-data",
+          {
+            action: "auto-approve-plan",
+            plan_id,
+            plan_status: newStatus,
+            plan_payload: { ...plan, posts },
+            posts: resolvedRows
+          },
+          { timeoutMs: 1e4 }
+        );
+        const durationMs = Date.now() - startedAt;
+        logMcpToolInvocation({
+          toolName: "auto_approve_plan",
+          status: "success",
+          durationMs,
+          details: { plan_id, auto_approved: autoApproved, flagged, rejected }
+        });
+        const resultPayload = {
+          plan_id,
+          auto_approved: autoApproved,
+          flagged_for_review: flagged,
+          rejected,
+          details,
+          plan_status: newStatus
+        };
+        if (response_format === "json") {
+          return {
+            content: [
+              { type: "text", text: JSON.stringify(asEnvelope16(resultPayload), null, 2) }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(`Auto-Approve Results for Plan ${plan_id.slice(0, 8)}...`);
+        lines.push("=".repeat(40));
+        lines.push(`Auto-approved: ${autoApproved}`);
+        lines.push(`Flagged for review: ${flagged}`);
+        lines.push(`Rejected: ${rejected}`);
+        lines.push(`Plan status: ${newStatus}`);
+        if (details.length > 0) {
+          lines.push("");
+          for (const d of details) {
+            lines.push(`  ${d.post_id}: ${d.action} (score: ${d.score}/35)`);
+          }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        logMcpToolInvocation({
+          toolName: "auto_approve_plan",
+          status: "error",
+          durationMs,
+          details: { error: message }
+        });
+        return {
+          content: [{ type: "text", text: `Auto-approve failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function sanitizeTopic(raw) {
+  return raw.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 500);
+}
+function buildPlanPrompt(topic, platforms, days, postsPerDay, sourceUrl) {
+  const safeTopic = sanitizeTopic(topic);
+  const parts = [
+    `Generate a ${days}-day content plan for "${safeTopic}" across platforms: ${platforms.join(", ")}.`,
+    `${postsPerDay} post(s) per platform per day.`,
+    sourceUrl ? `Source material URL: ${sourceUrl}` : "",
+    "",
+    "For each post, return a JSON object with:",
+    "  id, day, date, platform, content_type, caption, title, hashtags, hook, angle, visual_direction, media_type",
+    "",
+    "Return ONLY a JSON array. No surrounding text."
+  ];
+  return parts.filter(Boolean).join("\n");
+}
+
+// src/tools/suggest.ts
+init_edge_function();
+init_supabase();
+init_version();
+import { z as z22 } from "zod";
+function asEnvelope17(data) {
+  return { _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, data };
+}
+function registerSuggestTools(server2) {
+  server2.tool(
+    "suggest_next_content",
+    "Suggest next content topics based on performance insights, past content, and competitor patterns. No AI call, no credit cost \u2014 purely data-driven recommendations.",
+    {
+      project_id: z22.string().uuid().optional().describe("Project ID (auto-detected if omitted)"),
+      count: z22.number().min(1).max(10).default(3).describe("Number of suggestions to return"),
+      response_format: z22.enum(["text", "json"]).optional()
+    },
+    async ({ project_id, count, response_format }) => {
+      const format = response_format ?? "text";
+      const startedAt = Date.now();
+      try {
+        const { data: result, error: efError } = await callEdgeFunction("mcp-data", {
+          action: "suggest-content",
+          projectId: project_id
+        });
+        if (efError) throw new Error(efError);
+        const insights = result?.insights ?? [];
+        const recentContent = result?.recentContent ?? [];
+        const swipeItems = result?.swipeItems ?? [];
+        const hookInsights = insights.filter(
+          (i) => i.insight_type === "top_hooks" || i.insight_type === "winning_hooks"
+        );
+        const recentTopics = new Set(
+          recentContent.map((c) => c.topic?.toLowerCase()).filter(Boolean)
+        );
+        const dataQuality = insights.length >= 10 ? "strong" : insights.length >= 3 ? "moderate" : "weak";
+        const latestInsightDate = insights[0]?.generated_at ?? null;
+        const suggestions = [];
+        for (const insight of hookInsights.slice(0, Math.ceil(count / 2))) {
+          const data = insight.insight_data;
+          const hooks = Array.isArray(data.hooks) ? data.hooks : Array.isArray(data.top_hooks) ? data.top_hooks : [];
+          for (const hook of hooks.slice(0, 2)) {
+            const hookStr = typeof hook === "string" ? hook : String(hook.text ?? hook);
+            if (suggestions.length >= count) break;
+            suggestions.push({
+              topic: `Content inspired by winning hook: "${hookStr.slice(0, 80)}"`,
+              platform: String(data.platform ?? "tiktok"),
+              content_type: "caption",
+              rationale: "This hook pattern performed well in your past content.",
+              confidence: insight.confidence_score ?? 0.7,
+              based_on: ["performance_insights", "hook_analysis"],
+              suggested_hook: hookStr.slice(0, 120),
+              suggested_angle: "Apply this hook style to a fresh topic in your niche."
+            });
+          }
+        }
+        for (const swipe of swipeItems.slice(0, Math.ceil(count / 3))) {
+          if (suggestions.length >= count) break;
+          const title = swipe.title ?? "";
+          if (recentTopics.has(title.toLowerCase())) continue;
+          suggestions.push({
+            topic: `Competitor-inspired: "${title.slice(0, 80)}"`,
+            platform: swipe.platform ?? "instagram",
+            content_type: "caption",
+            rationale: `High-performing competitor content (score: ${swipe.engagement_score ?? "N/A"}).`,
+            confidence: 0.6,
+            based_on: ["niche_swipe_file", "competitor_analysis"],
+            suggested_hook: swipe.hook ?? `Your take on: ${title.slice(0, 60)}`,
+            suggested_angle: "Put your unique spin on this trending topic."
+          });
+        }
+        if (suggestions.length < count) {
+          const recentFormats = recentContent.map((c) => c.content_type).filter(Boolean);
+          const formatCounts = {};
+          for (const f of recentFormats) {
+            formatCounts[f] = (formatCounts[f] ?? 0) + 1;
+          }
+          const allFormats = ["script", "caption", "blog", "hook"];
+          const underusedFormats = allFormats.filter(
+            (f) => (formatCounts[f] ?? 0) < recentFormats.length / allFormats.length * 0.5
+          );
+          for (const fmt of underusedFormats.slice(0, count - suggestions.length)) {
+            suggestions.push({
+              topic: `Try a ${fmt} format \u2014 you haven't used it recently`,
+              platform: "linkedin",
+              content_type: fmt,
+              rationale: `You've posted ${formatCounts[fmt] ?? 0} ${fmt}(s) recently vs ${recentFormats.length} total posts. Diversifying formats can reach new audiences.`,
+              confidence: 0.5,
+              based_on: ["content_history", "format_analysis"],
+              suggested_hook: `Experiment with ${fmt} content for your audience.`,
+              suggested_angle: "Format diversification to increase reach."
+            });
+          }
+        }
+        if (suggestions.length < count) {
+          suggestions.push({
+            topic: "Share a behind-the-scenes look at your process",
+            platform: "instagram",
+            content_type: "caption",
+            rationale: "Behind-the-scenes content consistently drives engagement across platforms.",
+            confidence: 0.4,
+            based_on: ["general_best_practices"],
+            suggested_hook: "Here's what it actually takes to...",
+            suggested_angle: "Authenticity and transparency."
+          });
+        }
+        const durationMs = Date.now() - startedAt;
+        logMcpToolInvocation({
+          toolName: "suggest_next_content",
+          status: "success",
+          durationMs,
+          details: {
+            suggestions: suggestions.length,
+            data_quality: dataQuality,
+            insights_count: insights.length
+          }
+        });
+        const resultPayload = {
+          suggestions: suggestions.slice(0, count),
+          data_quality: dataQuality,
+          last_analysis_at: latestInsightDate
+        };
+        if (format === "json") {
+          return {
+            content: [
+              { type: "text", text: JSON.stringify(asEnvelope17(resultPayload), null, 2) }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(`Content Suggestions (${suggestions.length})`);
+        lines.push(`Data Quality: ${dataQuality} | Last analysis: ${latestInsightDate ?? "never"}`);
+        lines.push("=".repeat(40));
+        for (let i = 0; i < suggestions.length; i++) {
+          const s = suggestions[i];
+          lines.push(`
+${i + 1}. ${s.topic}`);
+          lines.push(`   Platform: ${s.platform} | Type: ${s.content_type}`);
+          lines.push(`   Hook: "${s.suggested_hook}"`);
+          lines.push(`   Angle: ${s.suggested_angle}`);
+          lines.push(`   Rationale: ${s.rationale}`);
+          lines.push(`   Confidence: ${Math.round(s.confidence * 100)}%`);
+          lines.push(`   Based on: ${s.based_on.join(", ")}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        logMcpToolInvocation({
+          toolName: "suggest_next_content",
+          status: "error",
+          durationMs,
+          details: { error: message }
+        });
+        return {
+          content: [{ type: "text", text: `Suggestion failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/digest.ts
+init_edge_function();
+init_supabase();
+import { z as z23 } from "zod";
+
+// src/lib/anomaly-detector.ts
+var SENSITIVITY_THRESHOLDS = {
+  low: 50,
+  medium: 30,
+  high: 15
+};
+var VIRAL_MULTIPLIER = 10;
+function aggregateByPlatform(data) {
+  const map = /* @__PURE__ */ new Map();
+  for (const d of data) {
+    const existing = map.get(d.platform) ?? { views: 0, engagement: 0, posts: 0 };
+    existing.views += d.views;
+    existing.engagement += d.engagement;
+    existing.posts += d.posts;
+    map.set(d.platform, existing);
+  }
+  return map;
+}
+function pctChange(current, previous) {
+  if (previous === 0) return current > 0 ? 100 : 0;
+  return (current - previous) / previous * 100;
+}
+function detectAnomalies(currentData, previousData, sensitivity = "medium", averageViewsPerPost) {
+  const threshold = SENSITIVITY_THRESHOLDS[sensitivity];
+  const anomalies = [];
+  const currentAgg = aggregateByPlatform(currentData);
+  const previousAgg = aggregateByPlatform(previousData);
+  const currentDates = currentData.map((d) => d.date).sort();
+  const period = {
+    current_start: currentDates[0] ?? "",
+    current_end: currentDates[currentDates.length - 1] ?? ""
+  };
+  const allPlatforms = /* @__PURE__ */ new Set([...currentAgg.keys(), ...previousAgg.keys()]);
+  for (const platform3 of allPlatforms) {
+    const current = currentAgg.get(platform3) ?? { views: 0, engagement: 0, posts: 0 };
+    const previous = previousAgg.get(platform3) ?? { views: 0, engagement: 0, posts: 0 };
+    const viewsChange = pctChange(current.views, previous.views);
+    if (Math.abs(viewsChange) >= threshold) {
+      const isSpike = viewsChange > 0;
+      anomalies.push({
+        type: isSpike ? "spike" : "drop",
+        metric: "views",
+        platform: platform3,
+        magnitude: Math.round(viewsChange * 10) / 10,
+        period,
+        affected_posts: [],
+        confidence: Math.min(1, Math.abs(viewsChange) / 100),
+        suggested_action: isSpike ? `Views up ${Math.abs(Math.round(viewsChange))}% on ${platform3}. Analyze what worked and double down.` : `Views down ${Math.abs(Math.round(viewsChange))}% on ${platform3}. Review content strategy and posting frequency.`
+      });
+    }
+    const engagementChange = pctChange(current.engagement, previous.engagement);
+    if (Math.abs(engagementChange) >= threshold) {
+      const isSpike = engagementChange > 0;
+      anomalies.push({
+        type: isSpike ? "spike" : "drop",
+        metric: "engagement",
+        platform: platform3,
+        magnitude: Math.round(engagementChange * 10) / 10,
+        period,
+        affected_posts: [],
+        confidence: Math.min(1, Math.abs(engagementChange) / 100),
+        suggested_action: isSpike ? `Engagement up ${Math.abs(Math.round(engagementChange))}% on ${platform3}. Replicate this content style.` : `Engagement down ${Math.abs(Math.round(engagementChange))}% on ${platform3}. Test different hooks and CTAs.`
+      });
+    }
+    const avgViews = averageViewsPerPost ?? (previous.posts > 0 ? previous.views / previous.posts : 0);
+    if (avgViews > 0 && current.posts > 0) {
+      const currentAvgViews = current.views / current.posts;
+      if (currentAvgViews > avgViews * VIRAL_MULTIPLIER) {
+        anomalies.push({
+          type: "viral",
+          metric: "views",
+          platform: platform3,
+          magnitude: Math.round(currentAvgViews / avgViews * 100) / 100,
+          period,
+          affected_posts: [],
+          confidence: 0.9,
+          suggested_action: `Viral content detected on ${platform3}! Average views per post is ${Math.round(currentAvgViews / avgViews)}x normal. Engage with comments and create follow-up content.`
+        });
+      }
+    }
+    const prevEngRate = previous.views > 0 ? previous.engagement / previous.views : 0;
+    const currEngRate = current.views > 0 ? current.engagement / current.views : 0;
+    const rateChange = pctChange(currEngRate, prevEngRate);
+    if (Math.abs(rateChange) >= threshold && current.posts >= 2 && previous.posts >= 2) {
+      anomalies.push({
+        type: "trend_shift",
+        metric: "engagement_rate",
+        platform: platform3,
+        magnitude: Math.round(rateChange * 10) / 10,
+        period,
+        affected_posts: [],
+        confidence: Math.min(1, Math.min(current.posts, previous.posts) / 5),
+        suggested_action: rateChange > 0 ? `Engagement rate improving on ${platform3}. Current audience is more responsive.` : `Engagement rate declining on ${platform3} despite views. Content may not be resonating \u2014 test new formats.`
+      });
+    }
+  }
+  anomalies.sort((a, b) => Math.abs(b.magnitude) - Math.abs(a.magnitude));
+  return anomalies;
+}
+
+// src/tools/digest.ts
+init_version();
+function asEnvelope18(data) {
+  return { _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, data };
+}
+var PLATFORM_ENUM3 = z23.enum([
+  "youtube",
+  "tiktok",
+  "instagram",
+  "twitter",
+  "linkedin",
+  "facebook",
+  "threads",
+  "bluesky"
+]);
+function registerDigestTools(server2) {
+  server2.tool(
+    "generate_performance_digest",
+    "Generate a performance summary for a time period. Includes metrics, trends vs previous period, top/bottom performers, platform breakdown, and actionable recommendations. No AI call, no credit cost.",
+    {
+      project_id: z23.string().uuid().optional().describe("Project ID (auto-detected if omitted)"),
+      period: z23.enum(["7d", "14d", "30d"]).default("7d").describe("Time period to analyze"),
+      include_recommendations: z23.boolean().default(true),
+      response_format: z23.enum(["text", "json"]).optional()
+    },
+    async ({ project_id, period, include_recommendations, response_format }) => {
+      const format = response_format ?? "text";
+      const startedAt = Date.now();
+      try {
+        const { data: result, error: efError } = await callEdgeFunction("mcp-data", {
+          action: "performance-digest",
+          period,
+          projectId: project_id
+        });
+        if (efError) throw new Error(efError);
+        const currentData = result?.currentData ?? [];
+        const previousData = result?.previousData ?? [];
+        const totalViews = currentData.reduce((sum, d) => sum + (d.views ?? 0), 0);
+        const totalEngagement = currentData.reduce((sum, d) => sum + (d.engagement ?? 0), 0);
+        const postIds = new Set(currentData.map((d) => d.post_id));
+        const totalPosts = postIds.size;
+        const avgEngRate = totalViews > 0 ? totalEngagement / totalViews * 100 : 0;
+        const postMetrics = /* @__PURE__ */ new Map();
+        for (const d of currentData) {
+          const existing = postMetrics.get(d.post_id) ?? {
+            views: 0,
+            engagement: 0,
+            platform: d.platform
+          };
+          existing.views += d.views ?? 0;
+          existing.engagement += d.engagement ?? 0;
+          postMetrics.set(d.post_id, existing);
+        }
+        let best = null;
+        let worst = null;
+        for (const [id, metrics] of postMetrics) {
+          if (!best || metrics.views > best.views) {
+            best = {
+              id,
+              platform: metrics.platform,
+              title: null,
+              views: metrics.views,
+              engagement: metrics.engagement
+            };
+          }
+          if (!worst || metrics.views < worst.views) {
+            worst = {
+              id,
+              platform: metrics.platform,
+              title: null,
+              views: metrics.views,
+              engagement: metrics.engagement
+            };
+          }
+        }
+        const platformMap = /* @__PURE__ */ new Map();
+        for (const d of currentData) {
+          const existing = platformMap.get(d.platform) ?? { posts: 0, views: 0, engagement: 0 };
+          existing.views += d.views ?? 0;
+          existing.engagement += d.engagement ?? 0;
+          platformMap.set(d.platform, existing);
+        }
+        const platformPosts = /* @__PURE__ */ new Map();
+        for (const d of currentData) {
+          if (!platformPosts.has(d.platform)) platformPosts.set(d.platform, /* @__PURE__ */ new Set());
+          platformPosts.get(d.platform).add(d.post_id);
+        }
+        for (const [platform3, postSet] of platformPosts) {
+          const existing = platformMap.get(platform3);
+          if (existing) existing.posts = postSet.size;
+        }
+        const platformBreakdown = [...platformMap.entries()].map(([platform3, m]) => ({
+          platform: platform3,
+          ...m
+        }));
+        const periodMap = { "7d": 7, "14d": 14, "30d": 30 };
+        const periodDays = periodMap[period] ?? 7;
+        const now = /* @__PURE__ */ new Date();
+        const currentStart = new Date(now);
+        currentStart.setDate(currentStart.getDate() - periodDays);
+        const prevViews = previousData.reduce((sum, d) => sum + (d.views ?? 0), 0);
+        const prevEngagement = previousData.reduce((sum, d) => sum + (d.engagement ?? 0), 0);
+        const viewsChangePct = prevViews > 0 ? (totalViews - prevViews) / prevViews * 100 : totalViews > 0 ? 100 : 0;
+        const engChangePct = prevEngagement > 0 ? (totalEngagement - prevEngagement) / prevEngagement * 100 : totalEngagement > 0 ? 100 : 0;
+        const recommendations = [];
+        if (include_recommendations) {
+          if (viewsChangePct < -10) {
+            recommendations.push("Views declining \u2014 experiment with new hooks and posting times.");
+          }
+          if (avgEngRate < 2) {
+            recommendations.push(
+              "Engagement rate below 2% \u2014 try more interactive content (questions, polls, CTAs)."
+            );
+          }
+          if (totalPosts < periodDays / 2) {
+            recommendations.push(
+              `Only ${totalPosts} posts in ${periodDays} days \u2014 increase posting frequency.`
+            );
+          }
+          if (platformBreakdown.length === 1) {
+            recommendations.push(
+              "Only posting on one platform \u2014 diversify to reach new audiences."
+            );
+          }
+          if (viewsChangePct > 20) {
+            recommendations.push(
+              "Views growing well! Analyze top performers and replicate those patterns."
+            );
+          }
+          if (engChangePct > 20 && viewsChangePct > 0) {
+            recommendations.push(
+              "Both views and engagement growing \u2014 current strategy is working."
+            );
+          }
+          if (recommendations.length === 0) {
+            recommendations.push(
+              "Performance is stable. Continue current strategy and monitor weekly."
+            );
+          }
+        }
+        const digest = {
+          period,
+          period_start: currentStart.toISOString().split("T")[0],
+          period_end: now.toISOString().split("T")[0],
+          metrics: {
+            total_posts: totalPosts,
+            total_views: totalViews,
+            total_engagement: totalEngagement,
+            avg_engagement_rate: Math.round(avgEngRate * 100) / 100,
+            best_performing: best,
+            worst_performing: worst,
+            platform_breakdown: platformBreakdown
+          },
+          trends: {
+            views: {
+              direction: viewsChangePct > 5 ? "up" : viewsChangePct < -5 ? "down" : "flat",
+              change_pct: Math.round(viewsChangePct * 10) / 10
+            },
+            engagement: {
+              direction: engChangePct > 5 ? "up" : engChangePct < -5 ? "down" : "flat",
+              change_pct: Math.round(engChangePct * 10) / 10
+            }
+          },
+          recommendations,
+          winning_patterns: {
+            hook_types: [],
+            content_formats: [],
+            posting_times: []
+          }
+        };
+        const durationMs = Date.now() - startedAt;
+        logMcpToolInvocation({
+          toolName: "generate_performance_digest",
+          status: "success",
+          durationMs,
+          details: { period, posts: totalPosts, views: totalViews }
+        });
+        if (format === "json") {
+          return {
+            content: [{ type: "text", text: JSON.stringify(asEnvelope18(digest), null, 2) }]
+          };
+        }
+        const lines = [];
+        lines.push(`Performance Digest (${period})`);
+        lines.push(`Period: ${digest.period_start} to ${digest.period_end}`);
+        lines.push("=".repeat(40));
+        lines.push(`Posts: ${totalPosts}`);
+        lines.push(
+          `Views: ${totalViews.toLocaleString()} (${viewsChangePct >= 0 ? "+" : ""}${Math.round(viewsChangePct)}% vs prev period)`
+        );
+        lines.push(
+          `Engagement: ${totalEngagement.toLocaleString()} (${engChangePct >= 0 ? "+" : ""}${Math.round(engChangePct)}% vs prev period)`
+        );
+        lines.push(`Avg Engagement Rate: ${digest.metrics.avg_engagement_rate}%`);
+        if (best) {
+          lines.push(
+            `
+Best: ${best.id.slice(0, 8)}... (${best.platform}) \u2014 ${best.views.toLocaleString()} views`
+          );
+        }
+        if (worst && totalPosts > 1) {
+          lines.push(
+            `Worst: ${worst.id.slice(0, 8)}... (${worst.platform}) \u2014 ${worst.views.toLocaleString()} views`
+          );
+        }
+        if (platformBreakdown.length > 0) {
+          lines.push("\nPlatform Breakdown:");
+          for (const p of platformBreakdown) {
+            lines.push(
+              `  ${p.platform}: ${p.posts} posts, ${p.views.toLocaleString()} views, ${p.engagement.toLocaleString()} engagement`
+            );
+          }
+        }
+        if (recommendations.length > 0) {
+          lines.push("\nRecommendations:");
+          for (const r of recommendations) lines.push(`  \u2022 ${r}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        logMcpToolInvocation({
+          toolName: "generate_performance_digest",
+          status: "error",
+          durationMs,
+          details: { error: message }
+        });
+        return {
+          content: [{ type: "text", text: `Digest failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "detect_anomalies",
+    "Detect significant performance changes: spikes, drops, viral content, trend shifts. Compares current period against previous equal-length period. No AI call, no credit cost.",
+    {
+      project_id: z23.string().uuid().optional().describe("Project ID (auto-detected if omitted)"),
+      days: z23.number().min(7).max(90).default(14).describe("Days to analyze"),
+      sensitivity: z23.enum(["low", "medium", "high"]).default("medium").describe("Detection sensitivity: low=50%+, medium=30%+, high=15%+ changes"),
+      platforms: z23.array(PLATFORM_ENUM3).optional().describe("Filter to specific platforms"),
+      response_format: z23.enum(["text", "json"]).optional()
+    },
+    async ({ project_id, days, sensitivity, platforms, response_format }) => {
+      const format = response_format ?? "text";
+      const startedAt = Date.now();
+      try {
+        const { data: result, error: efError } = await callEdgeFunction("mcp-data", {
+          action: "detect-anomalies",
+          days,
+          platforms,
+          projectId: project_id
+        });
+        if (efError) throw new Error(efError);
+        const toMetricData = (data) => {
+          const dayMap = /* @__PURE__ */ new Map();
+          for (const d of data) {
+            const date = d.captured_at.split("T")[0];
+            const key = `${date}-${d.platform}`;
+            const existing = dayMap.get(key) ?? {
+              date,
+              platform: d.platform,
+              views: 0,
+              engagement: 0,
+              posts: 0
+            };
+            existing.views += d.views ?? 0;
+            existing.engagement += d.engagement ?? 0;
+            existing.posts += 1;
+            dayMap.set(key, existing);
+          }
+          return [...dayMap.values()];
+        };
+        const currentMetrics = toMetricData(result?.currentData ?? []);
+        const previousMetrics = toMetricData(result?.previousData ?? []);
+        const anomalies = detectAnomalies(
+          currentMetrics,
+          previousMetrics,
+          sensitivity
+        );
+        const durationMs = Date.now() - startedAt;
+        logMcpToolInvocation({
+          toolName: "detect_anomalies",
+          status: "success",
+          durationMs,
+          details: { days, sensitivity, anomalies_found: anomalies.length }
+        });
+        const summary = anomalies.length === 0 ? `No significant anomalies detected in the last ${days} days.` : `Found ${anomalies.length} anomal${anomalies.length === 1 ? "y" : "ies"} in the last ${days} days.`;
+        const resultPayload = { anomalies, summary };
+        if (format === "json") {
+          return {
+            content: [
+              { type: "text", text: JSON.stringify(asEnvelope18(resultPayload), null, 2) }
+            ]
+          };
+        }
+        const lines = [];
+        lines.push(`Anomaly Detection (${days} days, ${sensitivity} sensitivity)`);
+        lines.push("=".repeat(40));
+        lines.push(summary);
+        if (anomalies.length > 0) {
+          lines.push("");
+          for (let i = 0; i < anomalies.length; i++) {
+            const a = anomalies[i];
+            const arrow = a.magnitude > 0 ? "\u2191" : "\u2193";
+            const magnitudeStr = a.type === "viral" ? `${a.magnitude}x average` : `${Math.abs(a.magnitude)}% change`;
+            lines.push(`${i + 1}. [${a.type.toUpperCase()}] ${a.metric} on ${a.platform}`);
+            lines.push(
+              `   ${arrow} ${magnitudeStr} | Confidence: ${Math.round(a.confidence * 100)}%`
+            );
+            lines.push(`   \u2192 ${a.suggested_action}`);
+          }
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const durationMs = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        logMcpToolInvocation({
+          toolName: "detect_anomalies",
+          status: "error",
+          durationMs,
+          details: { error: message }
+        });
+        return {
+          content: [{ type: "text", text: `Anomaly detection failed: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/brandRuntime.ts
+init_edge_function();
+init_supabase();
+init_version();
+import { z as z24 } from "zod";
+function asEnvelope19(data) {
+  return {
+    _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+    data
+  };
+}
+function registerBrandRuntimeTools(server2) {
+  server2.tool(
+    "get_brand_runtime",
+    "Get the full brand runtime for a project. Returns the 4-layer brand system: messaging (value props, pillars, proof points), voice (tone, vocabulary, avoid patterns), visual (palette, typography, composition), and operating constraints (audience, archetype). Also returns extraction confidence metadata.",
+    {
+      project_id: z24.string().optional().describe("Project ID. Defaults to current project.")
+    },
+    async ({ project_id }) => {
+      const projectId = project_id || await getDefaultProjectId();
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", { action: "brand-profile", projectId });
+      if (efError || !result?.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${efError || result?.error || "Failed to fetch brand profile"}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const data = result.profile;
+      if (!data?.profile_data) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No brand profile found for this project. Use extract_brand to create one."
+            }
+          ]
+        };
+      }
+      const profile = data.profile_data;
+      const meta = data.extraction_metadata || {};
+      const runtime = {
+        name: profile.name || "",
+        industry: profile.industryClassification || "",
+        positioning: profile.competitivePositioning || "",
+        messaging: {
+          valuePropositions: profile.valuePropositions || [],
+          messagingPillars: profile.messagingPillars || [],
+          contentPillars: (profile.contentPillars || []).map(
+            (p) => `${p.name} (${Math.round(p.weight * 100)}%)`
+          ),
+          socialProof: profile.socialProof || { testimonials: [], awards: [], pressMentions: [] }
+        },
+        voice: {
+          tone: profile.voiceProfile?.tone || [],
+          style: profile.voiceProfile?.style || [],
+          avoidPatterns: profile.voiceProfile?.avoidPatterns || [],
+          preferredTerms: profile.vocabularyRules?.preferredTerms || [],
+          bannedTerms: profile.vocabularyRules?.bannedTerms || []
+        },
+        visual: {
+          colorPalette: profile.colorPalette || {},
+          logoUrl: profile.logoUrl || null,
+          referenceFrameUrl: data.default_style_ref_url || null
+        },
+        audience: profile.targetAudience || {},
+        confidence: {
+          overall: meta.overallConfidence || 0,
+          provider: meta.scrapingProvider || "unknown",
+          pagesScraped: meta.pagesScraped || 0
+        }
+      };
+      const envelope = asEnvelope19(runtime);
+      return {
+        content: [{ type: "text", text: JSON.stringify(envelope, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "explain_brand_system",
+    "Explains what brand data is available vs missing for a project. Returns a human-readable summary of completeness, confidence levels, and recommendations for improving the brand profile.",
+    {
+      project_id: z24.string().optional().describe("Project ID. Defaults to current project.")
+    },
+    async ({ project_id }) => {
+      const projectId = project_id || await getDefaultProjectId();
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", { action: "brand-profile", projectId });
+      if (efError || !result?.success) {
+        return {
+          content: [
+            { type: "text", text: "No brand profile found. Run extract_brand first." }
+          ]
+        };
+      }
+      const row = result.profile;
+      if (!row?.profile_data) {
+        return {
+          content: [
+            { type: "text", text: "No brand profile found. Run extract_brand first." }
+          ]
+        };
+      }
+      const p = row.profile_data;
+      const meta = row.extraction_metadata || {};
+      const sections = [
+        {
+          name: "Identity",
+          fields: [p.name, p.tagline, p.industryClassification, p.competitivePositioning],
+          total: 4
+        },
+        {
+          name: "Voice",
+          fields: [
+            p.voiceProfile?.tone?.length,
+            p.voiceProfile?.style?.length,
+            p.voiceProfile?.avoidPatterns?.length
+          ],
+          total: 3
+        },
+        {
+          name: "Audience",
+          fields: [
+            p.targetAudience?.demographics?.ageRange,
+            p.targetAudience?.psychographics?.painPoints?.length
+          ],
+          total: 2
+        },
+        {
+          name: "Messaging",
+          fields: [
+            p.valuePropositions?.length,
+            p.messagingPillars?.length,
+            p.contentPillars?.length
+          ],
+          total: 3
+        },
+        {
+          name: "Visual",
+          fields: [
+            p.logoUrl,
+            p.colorPalette?.primary !== "#000000" ? p.colorPalette?.primary : null,
+            p.typography
+          ],
+          total: 3
+        },
+        {
+          name: "Vocabulary",
+          fields: [
+            p.vocabularyRules?.preferredTerms?.length,
+            p.vocabularyRules?.bannedTerms?.length
+          ],
+          total: 2
+        },
+        {
+          name: "Video Rules",
+          fields: [p.videoBrandRules?.pacing, p.videoBrandRules?.colorGrading],
+          total: 2
+        }
+      ];
+      const lines = [`Brand System Report: ${p.name || "Unknown"}`, ""];
+      for (const section of sections) {
+        const filled = section.fields.filter((f) => f != null && f !== "" && f !== 0).length;
+        const pct = Math.round(filled / section.total * 100);
+        const icon = pct >= 80 ? "OK" : pct >= 50 ? "PARTIAL" : "MISSING";
+        lines.push(`[${icon}] ${section.name}: ${filled}/${section.total} (${pct}%)`);
+      }
+      lines.push("");
+      lines.push(`Extraction confidence: ${Math.round((meta.overallConfidence || 0) * 100)}%`);
+      lines.push(
+        `Scraping: ${meta.pagesScraped || 0} pages via ${meta.scrapingProvider || "unknown"}`
+      );
+      const recs = [];
+      if (!p.contentPillars?.length) recs.push("Add content pillars for focused ideation");
+      if (!p.vocabularyRules?.preferredTerms?.length)
+        recs.push("Add preferred terms for vocabulary consistency");
+      if (!p.videoBrandRules?.pacing)
+        recs.push("Add video brand rules (pacing, color grading) for storyboard consistency");
+      if (!p.logoUrl) recs.push("Upload a logo for deterministic brand overlay");
+      if ((meta.overallConfidence || 0) < 0.6)
+        recs.push("Re-extract with premium mode for higher confidence");
+      if (recs.length > 0) {
+        lines.push("");
+        lines.push("Recommendations:");
+        recs.forEach((r) => lines.push(`  - ${r}`));
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server2.tool(
+    "check_brand_consistency",
+    "Check if content text is consistent with the brand voice, vocabulary, messaging, and factual claims. Returns per-dimension scores (0-100) and specific issues found. Use this to validate scripts, captions, or post copy before publishing.",
+    {
+      content: z24.string().describe("The content text to check for brand consistency."),
+      project_id: z24.string().optional().describe("Project ID. Defaults to current project.")
+    },
+    async ({ content, project_id }) => {
+      const projectId = project_id || await getDefaultProjectId();
+      const { data: result, error: efError } = await callEdgeFunction("mcp-data", { action: "brand-profile", projectId });
+      const row = !efError && result?.success ? result.profile : null;
+      if (!row?.profile_data) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No brand profile found. Cannot check consistency without brand data."
+            }
+          ],
+          isError: true
+        };
+      }
+      const profile = row.profile_data;
+      const contentLower = content.toLowerCase();
+      const issues = [];
+      let score = 70;
+      const banned = profile.vocabularyRules?.bannedTerms || [];
+      const bannedFound = banned.filter((t) => contentLower.includes(t.toLowerCase()));
+      if (bannedFound.length > 0) {
+        score -= bannedFound.length * 15;
+        issues.push(`Banned terms found: ${bannedFound.join(", ")}`);
+      }
+      const avoid = profile.voiceProfile?.avoidPatterns || [];
+      const avoidFound = avoid.filter((p) => contentLower.includes(p.toLowerCase()));
+      if (avoidFound.length > 0) {
+        score -= avoidFound.length * 10;
+        issues.push(`Avoid patterns found: ${avoidFound.join(", ")}`);
+      }
+      const preferred = profile.vocabularyRules?.preferredTerms || [];
+      const prefUsed = preferred.filter((t) => contentLower.includes(t.toLowerCase()));
+      score += Math.min(15, prefUsed.length * 5);
+      const fabPatterns = [
+        { regex: /\b\d+[,.]?\d*\s*(%|percent)/gi, label: "unverified percentage" },
+        { regex: /\b(award[- ]?winning|best[- ]selling|#\s*1)\b/gi, label: "unverified ranking" },
+        { regex: /\b(guaranteed|proven to|studies show)\b/gi, label: "unverified claim" }
+      ];
+      for (const { regex, label } of fabPatterns) {
+        regex.lastIndex = 0;
+        if (regex.test(content)) {
+          score -= 10;
+          issues.push(`Potential ${label} detected`);
+        }
+      }
+      score = Math.max(0, Math.min(100, score));
+      const checkResult = {
+        score,
+        passed: score >= 60,
+        issues,
+        preferredTermsUsed: prefUsed,
+        bannedTermsFound: bannedFound
+      };
+      const envelope = asEnvelope19(checkResult);
+      return {
+        content: [{ type: "text", text: JSON.stringify(envelope, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/lib/register-tools.ts
+function applyScopeEnforcement(server2, scopeResolver) {
+  const originalTool = server2.tool.bind(server2);
+  server2.tool = function wrappedTool(...args) {
+    const name = args[0];
+    const requiredScope = TOOL_SCOPES[name];
+    const handlerIndex = args.findIndex(
+      (a, i) => i > 0 && typeof a === "function"
+    );
+    if (handlerIndex !== -1) {
+      const originalHandler = args[handlerIndex];
+      args[handlerIndex] = async function scopeEnforcedHandler(...handlerArgs) {
+        if (!requiredScope) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Permission denied: '${name}' has no scope defined. Contact support.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const userScopes = scopeResolver();
+        if (!hasScope(userScopes, requiredScope)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Permission denied: '${name}' requires scope '${requiredScope}'. Generate a new key with the required scope at https://socialneuron.com/settings/developer`
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = await originalHandler(...handlerArgs);
+        return truncateResponse(result);
+      };
+    }
+    return originalTool(...args);
+  };
+}
+var RESPONSE_CHAR_LIMIT = 1e5;
+function truncateResponse(result) {
+  if (!result?.content || !Array.isArray(result.content)) return result;
+  let totalChars = 0;
+  for (const part of result.content) {
+    if (part.type === "text" && typeof part.text === "string") {
+      totalChars += part.text.length;
+    }
+  }
+  if (totalChars <= RESPONSE_CHAR_LIMIT) return result;
+  let remaining = RESPONSE_CHAR_LIMIT;
+  const truncated = [];
+  for (const part of result.content) {
+    if (part.type === "text" && typeof part.text === "string") {
+      if (remaining <= 0) continue;
+      if (part.text.length <= remaining) {
+        truncated.push(part);
+        remaining -= part.text.length;
+      } else {
+        truncated.push({
+          ...part,
+          text: part.text.slice(0, remaining) + `
+
+[Response truncated: ${totalChars.toLocaleString()} chars exceeded ${RESPONSE_CHAR_LIMIT.toLocaleString()} limit. Use filters to narrow your query.]`
+        });
+        remaining = 0;
+      }
+    } else {
+      truncated.push(part);
+    }
+  }
+  return { ...result, content: truncated };
+}
+function registerAllTools(server2, options) {
+  registerIdeationTools(server2);
+  registerContentTools(server2);
+  registerDistributionTools(server2);
+  registerAnalyticsTools(server2);
+  registerBrandTools(server2);
+  if (!options?.skipScreenshots) {
+    registerScreenshotTools(server2);
+  }
+  registerRemotionTools(server2);
+  registerInsightsTools(server2);
+  registerYouTubeAnalyticsTools(server2);
+  registerCommentsTools(server2);
+  registerIdeationContextTools(server2);
+  registerCreditsTools(server2);
+  registerLoopSummaryTools(server2);
+  registerUsageTools(server2);
+  registerAutopilotTools(server2);
+  registerExtractionTools(server2);
+  registerQualityTools(server2);
+  registerPlanningTools(server2);
+  registerPlanApprovalTools(server2);
+  registerDiscoveryTools(server2);
+  registerPipelineTools(server2);
+  registerSuggestTools(server2);
+  registerDigestTools(server2);
+  registerBrandRuntimeTools(server2);
+  applyAnnotations(server2);
+}
+
+// src/index.ts
+init_posthog();
+init_supabase();
+init_sn();
+
+// src/prompts.ts
+import { z as z25 } from "zod";
+function registerPrompts(server2) {
+  server2.prompt(
+    "create_weekly_content_plan",
+    "Generate a full week of social media content (7 days, multiple platforms). Returns a structured plan with topics, formats, and posting times.",
+    {
+      niche: z25.string().describe('Your content niche or industry (e.g., "fitness coaching", "SaaS marketing")'),
+      platforms: z25.string().optional().describe(
+        'Comma-separated platforms to target (default: "YouTube, Instagram, TikTok, LinkedIn")'
+      ),
+      tone: z25.string().optional().describe('Brand tone of voice (e.g., "professional", "casual", "bold and edgy")')
+    },
+    ({ niche, platforms, tone }) => {
+      const targetPlatforms = platforms || "YouTube, Instagram, TikTok, LinkedIn";
+      const brandTone = tone || "professional yet approachable";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Create a 7-day social media content plan for a ${niche} brand.
+
+Target platforms: ${targetPlatforms}
+Brand tone: ${brandTone}
+
+For each day, provide:
+1. **Topic/Theme** \u2014 what the content is about
+2. **Platform** \u2014 which platform this piece is for
+3. **Format** \u2014 (short video, carousel, story, text post, long-form video, etc.)
+4. **Hook** \u2014 the opening line or thumbnail concept
+5. **Key talking points** \u2014 3-4 bullet points
+6. **Call to action** \u2014 what the audience should do
+7. **Best posting time** \u2014 optimal time based on platform norms
+
+Use Social Neuron tools:
+- Call \`generate_content_ideas\` for fresh topic suggestions
+- Call \`get_brand_profile\` to align with brand guidelines
+- Call \`get_performance_insights\` to learn what's worked before
+- Call \`get_best_posting_times\` for optimal scheduling
+
+After building the plan, use \`create_content_plan\` to save it.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server2.prompt(
+    "analyze_top_content",
+    "Analyze your best-performing posts to identify patterns and replicate success. Returns insights on hooks, formats, timing, and topics that resonate.",
+    {
+      timeframe: z25.string().optional().describe('Analysis period (default: "30 days"). E.g., "7 days", "90 days"'),
+      platform: z25.string().optional().describe('Filter to a specific platform (e.g., "youtube", "instagram")')
+    },
+    ({ timeframe, platform: platform3 }) => {
+      const period = timeframe || "30 days";
+      const platformFilter = platform3 ? `
+Focus specifically on ${platform3} content.` : "";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Analyze my top-performing content from the last ${period}.${platformFilter}
+
+Steps:
+1. Call \`get_analytics_summary\` for overall performance metrics
+2. Call \`get_performance_insights\` for AI-generated patterns
+3. Call \`get_best_posting_times\` for timing insights
+
+Then provide:
+- **Top 5 posts** by engagement with analysis of why they worked
+- **Common patterns** in successful hooks, formats, and topics
+- **Optimal posting times** by platform
+- **Content gaps** \u2014 what topics or formats are underrepresented
+- **Actionable recommendations** \u2014 5 specific things to do next week
+
+Format as a clear, actionable performance report.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server2.prompt(
+    "repurpose_content",
+    "Take one piece of content and transform it into 8-10 pieces across multiple platforms and formats.",
+    {
+      source: z25.string().describe(
+        "The source content to repurpose \u2014 a URL, transcript, or the content text itself"
+      ),
+      target_platforms: z25.string().optional().describe(
+        'Comma-separated target platforms (default: "Twitter, LinkedIn, Instagram, TikTok, YouTube")'
+      )
+    },
+    ({ source, target_platforms }) => {
+      const platforms = target_platforms || "Twitter, LinkedIn, Instagram, TikTok, YouTube";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Repurpose this content into 8-10 pieces across multiple platforms.
+
+Source content:
+${source}
+
+Target platforms: ${platforms}
+
+Generate these variations:
+1. **5 standalone tweets** \u2014 each a different angle or quote from the source
+2. **2 LinkedIn posts** \u2014 one thought-leadership, one story-driven
+3. **1 Instagram caption** \u2014 with relevant hashtags
+4. **1 TikTok script** \u2014 30-60 second hook-driven format
+5. **1 newsletter section** \u2014 key takeaways with a CTA
+
+Use Social Neuron tools:
+- Call \`generate_social_content\` for each platform variation
+- Call \`get_brand_profile\` to maintain brand voice consistency
+- Call \`score_content_quality\` to ensure each piece scores 70+
+
+For each piece, include the platform, format, character count, and suggested posting time.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server2.prompt(
+    "setup_brand_voice",
+    "Define or refine your brand voice profile so all generated content stays on-brand. Walks through tone, audience, values, and style.",
+    {
+      brand_name: z25.string().describe("Your brand or business name"),
+      industry: z25.string().optional().describe('Your industry or niche (e.g., "B2B SaaS", "fitness coaching")'),
+      website: z25.string().optional().describe("Your website URL for context")
+    },
+    ({ brand_name, industry, website }) => {
+      const industryContext = industry ? ` in the ${industry} space` : "";
+      const websiteContext = website ? `
+Website: ${website}` : "";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me set up a comprehensive brand voice profile for ${brand_name}${industryContext}.${websiteContext}
+
+I need to define:
+1. **Brand personality** \u2014 3-5 adjectives that describe our voice
+2. **Target audience** \u2014 who we're speaking to (demographics, psychographics)
+3. **Tone spectrum** \u2014 where we fall on formal\u2194casual, serious\u2194playful, technical\u2194simple
+4. **Key messages** \u2014 3 core messages we always communicate
+5. **Words we use** \u2014 vocabulary that's on-brand
+6. **Words we avoid** \u2014 vocabulary that's off-brand
+7. **Content pillars** \u2014 3-5 recurring content themes
+
+After we define these, use \`update_brand_profile\` to save the profile.
+Then use \`generate_social_content\` to create a sample post to verify the voice sounds right.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server2.prompt(
+    "run_content_audit",
+    "Audit your recent content performance and get a prioritized action plan for improvement.",
+    {},
+    () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Run a comprehensive content audit on my Social Neuron account.
+
+Steps:
+1. Call \`get_credit_balance\` to check account status
+2. Call \`get_analytics_summary\` for performance overview
+3. Call \`get_performance_insights\` for AI-generated analysis
+4. Call \`get_brand_profile\` to check brand alignment
+5. Call \`get_best_posting_times\` for scheduling optimization
+
+Deliver a report covering:
+- **Account health** \u2014 credits remaining, plan tier, usage patterns
+- **Performance summary** \u2014 posts published, total engagement, trends
+- **Top performers** \u2014 what's working and why
+- **Underperformers** \u2014 what's not working and why
+- **Consistency score** \u2014 posting frequency vs. recommended cadence
+- **Brand alignment** \u2014 how well content matches brand profile
+- **Prioritized action items** \u2014 top 5 things to do this week, ranked by impact`
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/resources.ts
+init_edge_function();
+init_version();
+function registerResources(server2) {
+  server2.resource(
+    "brand-profile",
+    "socialneuron://brand/profile",
+    {
+      description: "Your brand voice profile including personality traits, target audience, tone, key messages, and content pillars. Read this before generating any content to stay on-brand.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const { data, error } = await callEdgeFunction("mcp-data", { action: "brand-profile" });
+        if (error || !data?.success) {
+          return {
+            contents: [
+              {
+                uri: "socialneuron://brand/profile",
+                mimeType: "application/json",
+                text: JSON.stringify(
+                  {
+                    _meta: { version: MCP_VERSION, status: "no_profile" },
+                    message: "No brand profile set up yet. Use the setup_brand_voice prompt or update_brand_profile tool to create one."
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        return {
+          contents: [
+            {
+              uri: "socialneuron://brand/profile",
+              mimeType: "application/json",
+              text: JSON.stringify(
+                {
+                  _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+                  ...data.profile
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch {
+        return {
+          contents: [
+            {
+              uri: "socialneuron://brand/profile",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                _meta: { version: MCP_VERSION, status: "error" },
+                message: "Failed to load brand profile. Check your connection and try again."
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.resource(
+    "account-overview",
+    "socialneuron://account/overview",
+    {
+      description: "Current account status including plan tier, credit balance, monthly usage, connected platforms, and feature access. A quick snapshot of your Social Neuron account.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const { data, error } = await callEdgeFunction("mcp-data", { action: "credit-balance" });
+        const overview = {
+          _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          plan: data?.plan || "unknown",
+          credits: {
+            balance: data?.balance ?? 0,
+            monthlyUsed: data?.monthlyUsed ?? 0,
+            monthlyLimit: data?.monthlyLimit ?? 0,
+            percentUsed: data?.monthlyLimit ? Math.round((data?.monthlyUsed ?? 0) / data.monthlyLimit * 100) : 0
+          },
+          status: error ? "error" : "ok",
+          docs: "https://socialneuron.com/for-developers",
+          pricing: "https://socialneuron.com/pricing"
+        };
+        return {
+          contents: [
+            {
+              uri: "socialneuron://account/overview",
+              mimeType: "application/json",
+              text: JSON.stringify(overview, null, 2)
+            }
+          ]
+        };
+      } catch {
+        return {
+          contents: [
+            {
+              uri: "socialneuron://account/overview",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                _meta: { version: MCP_VERSION, status: "error" },
+                message: "Failed to load account overview."
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.resource(
+    "platform-capabilities",
+    "socialneuron://docs/capabilities",
+    {
+      description: "Complete reference of all Social Neuron capabilities: supported platforms, content formats, AI models, credit costs, and feature availability by plan tier.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const capabilities = {
+        _meta: { version: MCP_VERSION, generated: (/* @__PURE__ */ new Date()).toISOString() },
+        platforms: {
+          available: ["YouTube", "Instagram", "TikTok"],
+          coming_soon: ["LinkedIn", "X/Twitter", "Facebook", "Pinterest"]
+        },
+        content_formats: {
+          text: ["Social post", "Thread", "Caption", "Newsletter", "Blog draft", "Script"],
+          image: [
+            "AI-generated image",
+            "Quote graphic",
+            "Carousel slide",
+            "Thumbnail",
+            "Story"
+          ],
+          video: [
+            "Short-form (< 60s)",
+            "Long-form",
+            "Storyboard",
+            "Captioned clip",
+            "YouTube optimized"
+          ],
+          audio: ["Background music", "Voiceover"]
+        },
+        ai_models: {
+          text: ["Gemini 2.5 Flash", "Gemini 2.5 Pro"],
+          image: [
+            "Flux 1.1 Pro",
+            "DALL-E 3",
+            "Stable Diffusion XL",
+            "Ideogram",
+            "Recraft V3",
+            "Mystic V2"
+          ],
+          video: ["Veo 3", "Sora 2", "Runway Gen-4", "Kling 2.0", "Minimax", "Wan 2.1"]
+        },
+        credit_costs: {
+          text_generation: "1-3 credits",
+          image_generation: "2-10 credits",
+          video_generation: "15-80 credits",
+          analytics_query: "0 credits",
+          distribution: "1 credit per platform"
+        },
+        tiers: {
+          free: {
+            price: "$0/mo",
+            credits: 100,
+            mcp_access: false,
+            features: ["5 free tools", "Basic content generation"]
+          },
+          starter: {
+            price: "$29/mo",
+            credits: 800,
+            mcp_access: "Read + Analytics",
+            features: ["All free features", "MCP read access", "Analytics", "3 platforms"]
+          },
+          pro: {
+            price: "$79/mo",
+            credits: 2e3,
+            mcp_access: "Full",
+            features: [
+              "All Starter features",
+              "Full MCP access",
+              "Video generation",
+              "Autopilot",
+              "Priority support"
+            ]
+          },
+          team: {
+            price: "$199/mo",
+            credits: 6500,
+            mcp_access: "Full + Multi-user",
+            features: [
+              "All Pro features",
+              "Team collaboration",
+              "Up to 10 members",
+              "50 projects",
+              "Advanced analytics"
+            ]
+          }
+        }
+      };
+      return {
+        contents: [
+          {
+            uri: "socialneuron://docs/capabilities",
+            mimeType: "application/json",
+            text: JSON.stringify(capabilities, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server2.resource(
+    "getting-started",
+    "socialneuron://docs/getting-started",
+    {
+      description: "Quick start guide for using Social Neuron with AI agents. Covers authentication, first content creation, and common workflows.",
+      mimeType: "text/plain"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "socialneuron://docs/getting-started",
+          mimeType: "text/plain",
+          text: `# Getting Started with Social Neuron MCP Server
+
+## Quick Start
+
+1. Check your account: Read the \`socialneuron://account/overview\` resource
+2. Set up your brand: Use the \`setup_brand_voice\` prompt
+3. Generate content: Call \`generate_social_content\` with a topic
+4. Review & publish: Call \`publish_post\` to distribute
+
+## Common Workflows
+
+### Create & Publish a Post
+1. \`generate_content_ideas\` \u2192 get topic suggestions
+2. \`generate_social_content\` \u2192 create the post
+3. \`score_content_quality\` \u2192 check quality (aim for 70+)
+4. \`publish_post\` \u2192 distribute to platforms
+
+### Analyze Performance
+1. \`get_analytics_summary\` \u2192 see overall metrics
+2. \`get_performance_insights\` \u2192 AI analysis of patterns
+3. \`get_best_posting_times\` \u2192 optimize scheduling
+
+### Repurpose Content
+1. Use the \`repurpose_content\` prompt with your source material
+2. Review each generated variation
+3. Schedule across platforms using \`create_content_plan\`
+
+### Set Up Autopilot
+1. \`get_brand_profile\` \u2192 verify brand settings
+2. \`configure_autopilot\` \u2192 set schedule and preferences
+3. \`enable_autopilot\` \u2192 start automated posting
+
+## Credit Tips
+- Text generation: 1-3 credits
+- Image generation: 2-10 credits
+- Video generation: 15-80 credits
+- Check balance anytime: \`get_credit_balance\`
+
+## Need Help?
+- Docs: https://socialneuron.com/for-developers
+- Support: socialneuronteam@gmail.com
+`
+        }
+      ]
+    })
+  );
+}
+
+// src/index.ts
 function flushAndExit(code) {
   const done = { out: false, err: false };
   const tryExit = () => {
@@ -12126,6 +14807,8 @@ var server = new McpServer({
 });
 applyScopeEnforcement(server, getAuthenticatedScopes);
 registerAllTools(server);
+registerPrompts(server);
+registerResources(server);
 async function shutdown() {
   await shutdownPostHog();
   process.exit(0);