@socialneuron/mcp-server 1.6.1 → 1.7.0

package/dist/http.js

@@ -304,7 +304,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`,
       {
@@ -339,12 +339,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,
@@ -369,11 +369,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) {
@@ -420,6 +456,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) {
@@ -523,7 +565,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";
@@ -538,15 +580,15 @@ 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();
   }
 });
 
 // src/http.ts
 import express from "express";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
@@ -576,6 +618,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",
@@ -591,6 +636,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",
@@ -629,7 +675,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;
@@ -640,6 +698,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(server) {
+  const annotations = buildAnnotationsMap();
+  const registeredTools = server._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
 import { z } from "zod";
 
@@ -1376,7 +1575,7 @@ function sanitizeError(error) {
 init_request_context();
 
 // src/lib/version.ts
-var MCP_VERSION = "1.6.0";
+var MCP_VERSION = "1.7.0";
 
 // src/tools/content.ts
 var MAX_CREDITS_PER_RUN = Math.max(
@@ -5447,6 +5646,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(server) {
@@ -5454,13 +5669,6 @@ function registerRemotionTools(server) {
     "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) {
@@ -5489,13 +5697,6 @@ function registerRemotionTools(server) {
         "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();
@@ -5627,6 +5828,134 @@ function registerRemotionTools(server) {
       }
     }
   );
+  server.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
@@ -7035,7 +7364,6 @@ ${"=".repeat(40)}
 }
 
 // src/tools/autopilot.ts
-init_supabase();
 import { z as z15 } from "zod";
 function asEnvelope11(data) {
   return {
@@ -7054,46 +7382,35 @@ function registerAutopilotTools(server) {
       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: [
             {
@@ -7138,18 +7455,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,
@@ -7158,22 +7468,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: [
             {
@@ -7183,18 +7478,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: [
           {
@@ -7213,26 +7527,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 {
@@ -7253,22 +7560,93 @@ ${"=".repeat(40)}
       text += `Pending Approvals: ${statusData.pendingApprovals}
 
 `;
-      if (statusData.recentRuns.length > 0) {
-        text += `Recent Runs:
+      text += `No 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.
-`;
-      }
       return {
         content: [{ type: "text", text }]
       };
     }
   );
+  server.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
@@ -9010,6 +9388,24 @@ var TOOL_CATALOG = [
     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",
@@ -9048,10 +9444,16 @@ var TOOL_CATALOG = [
     module: "remotion",
     scope: "mcp:read"
   },
-  // youtube-analytics
   {
-    name: "fetch_youtube_analytics",
-    description: "Fetch YouTube channel analytics data",
+    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",
+    description: "Fetch YouTube channel analytics data",
     module: "youtube-analytics",
     scope: "mcp:analytics"
   },
@@ -9220,6 +9622,58 @@ var TOOL_CATALOG = [
     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"
   }
 ];
 function getToolsByModule(module) {
@@ -9235,59 +9689,1750 @@ function searchTools(query) {
   );
 }
 
-// src/tools/discovery.ts
-function registerDiscoveryTools(server) {
+// src/tools/discovery.ts
+function registerDiscoveryTools(server) {
+  server.tool(
+    "search_tools",
+    'Search available tools by name, description, module, or scope. Use "name" detail (~50 tokens) for quick lookup, "summary" (~500 tokens) for descriptions, "full" for complete input schemas. Start here if unsure which tool to call \u2014 filter by module (e.g. "planning", "content", "analytics") to narrow results.',
+    {
+      query: z20.string().optional().describe("Search query to filter tools by name or description"),
+      module: z20.string().optional().describe('Filter by module name (e.g. "planning", "content", "analytics")'),
+      scope: z20.string().optional().describe('Filter by required scope (e.g. "mcp:read", "mcp:write")'),
+      detail: z20.enum(["name", "summary", "full"]).default("summary").describe(
+        'Detail level: "name" for just tool names, "summary" for names + descriptions, "full" for complete info including scope and module'
+      )
+    },
+    {
+      title: "Search Tools",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async ({ query, module, scope, detail }) => {
+      let results = [...TOOL_CATALOG];
+      if (query) {
+        results = searchTools(query);
+      }
+      if (module) {
+        const moduleTools = getToolsByModule(module);
+        results = results.filter((t) => moduleTools.some((mt) => mt.name === t.name));
+      }
+      if (scope) {
+        const scopeTools = getToolsByScope(scope);
+        results = results.filter((t) => scopeTools.some((st) => st.name === t.name));
+      }
+      let output;
+      switch (detail) {
+        case "name":
+          output = results.map((t) => t.name);
+          break;
+        case "summary":
+          output = results.map((t) => ({ name: t.name, description: t.description }));
+          break;
+        case "full":
+        default:
+          output = results;
+          break;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ toolCount: results.length, tools: output }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/pipeline.ts
+import { z as z21 } from "zod";
+import { randomUUID as randomUUID3 } from "node:crypto";
+init_supabase();
+
+// 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(server) {
+  server.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
+        };
+      }
+    }
+  );
+  server.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: `Insufficient credits: ${availableCredits} available, ~${estimatedCost} needed.`
+              }
+            ],
+            isError: true
+          };
+        }
+        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: `Planning failed: ${planError ?? "No AI response"}` }
+            ],
+            isError: true
+          };
+        }
+        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
+        };
+      }
+    }
+  );
+  server.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") }] };
+    }
+  );
+  server.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
+import { z as z22 } from "zod";
+init_supabase();
+function asEnvelope17(data) {
+  return { _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, data };
+}
+function registerSuggestTools(server) {
+  server.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
+import { z as z23 } from "zod";
+init_supabase();
+
+// 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 platform2 of allPlatforms) {
+    const current = currentAgg.get(platform2) ?? { views: 0, engagement: 0, posts: 0 };
+    const previous = previousAgg.get(platform2) ?? { 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: platform2,
+        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 ${platform2}. Analyze what worked and double down.` : `Views down ${Math.abs(Math.round(viewsChange))}% on ${platform2}. 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: platform2,
+        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 ${platform2}. Replicate this content style.` : `Engagement down ${Math.abs(Math.round(engagementChange))}% on ${platform2}. 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: platform2,
+          magnitude: Math.round(currentAvgViews / avgViews * 100) / 100,
+          period,
+          affected_posts: [],
+          confidence: 0.9,
+          suggested_action: `Viral content detected on ${platform2}! 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: platform2,
+        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 ${platform2}. Current audience is more responsive.` : `Engagement rate declining on ${platform2} 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
+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(server) {
+  server.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 [platform2, postSet] of platformPosts) {
+          const existing = platformMap.get(platform2);
+          if (existing) existing.posts = postSet.size;
+        }
+        const platformBreakdown = [...platformMap.entries()].map(([platform2, m]) => ({
+          platform: platform2,
+          ...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
+        };
+      }
+    }
+  );
+  server.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
+import { z as z24 } from "zod";
+init_supabase();
+function asEnvelope19(data) {
+  return {
+    _meta: { version: MCP_VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+    data
+  };
+}
+function registerBrandRuntimeTools(server) {
   server.tool(
-    "search_tools",
-    'Search available tools by name, description, module, or scope. Use "name" detail (~50 tokens) for quick lookup, "summary" (~500 tokens) for descriptions, "full" for complete input schemas. Start here if unsure which tool to call \u2014 filter by module (e.g. "planning", "content", "analytics") to narrow results.',
+    "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.",
     {
-      query: z20.string().optional().describe("Search query to filter tools by name or description"),
-      module: z20.string().optional().describe('Filter by module name (e.g. "planning", "content", "analytics")'),
-      scope: z20.string().optional().describe('Filter by required scope (e.g. "mcp:read", "mcp:write")'),
-      detail: z20.enum(["name", "summary", "full"]).default("summary").describe(
-        'Detail level: "name" for just tool names, "summary" for names + descriptions, "full" for complete info including scope and module'
-      )
+      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) }]
+      };
+    }
+  );
+  server.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.",
     {
-      title: "Search Tools",
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
+      project_id: z24.string().optional().describe("Project ID. Defaults to current project.")
     },
-    async ({ query, module, scope, detail }) => {
-      let results = [...TOOL_CATALOG];
-      if (query) {
-        results = searchTools(query);
+    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." }
+          ]
+        };
       }
-      if (module) {
-        const moduleTools = getToolsByModule(module);
-        results = results.filter((t) => moduleTools.some((mt) => mt.name === t.name));
+      const row = result.profile;
+      if (!row?.profile_data) {
+        return {
+          content: [
+            { type: "text", text: "No brand profile found. Run extract_brand first." }
+          ]
+        };
       }
-      if (scope) {
-        const scopeTools = getToolsByScope(scope);
-        results = results.filter((t) => scopeTools.some((st) => st.name === t.name));
+      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}%)`);
       }
-      let output;
-      switch (detail) {
-        case "name":
-          output = results.map((t) => t.name);
-          break;
-        case "summary":
-          output = results.map((t) => ({ name: t.name, description: t.description }));
-          break;
-        case "full":
-        default:
-          output = results;
-          break;
+      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: JSON.stringify({ toolCount: results.length, tools: output }, null, 2)
-          }
-        ]
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+  server.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) }]
       };
     }
   );
@@ -9328,12 +11473,46 @@ function applyScopeEnforcement(server, scopeResolver) {
             isError: true
           };
         }
-        return originalHandler(...handlerArgs);
+        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(server, options) {
   registerIdeationTools(server);
   registerContentTools(server);
@@ -9357,6 +11536,11 @@ function registerAllTools(server, options) {
   registerPlanningTools(server);
   registerPlanApprovalTools(server);
   registerDiscoveryTools(server);
+  registerPipelineTools(server);
+  registerSuggestTools(server);
+  registerDigestTools(server);
+  registerBrandRuntimeTools(server);
+  applyAnnotations(server);
 }
 
 // src/http.ts
@@ -10542,7 +12726,8 @@ setInterval(() => {
   }
 }, IP_RATE_CLEANUP_INTERVAL).unref();
 app.use((req, res, next) => {
-  if (req.path === "/health") return next();
+  if (req.path === "/health" || req.path === "/.well-known/mcp/server-card.json" || req.path === "/.well-known/oauth-protected-resource")
+    return next();
   const ip = req.ip ?? req.socket.remoteAddress ?? "unknown";
   const now = Date.now();
   let bucket = ipBuckets.get(ip);
@@ -10641,6 +12826,210 @@ async function authenticateRequest(req, res, next) {
     });
   }
 }
+app.get("/.well-known/mcp/server-card.json", (_req, res) => {
+  res.setHeader("Cache-Control", "public, max-age=3600");
+  res.json({
+    serverInfo: {
+      name: "socialneuron",
+      version: MCP_VERSION
+    },
+    authentication: {
+      required: true,
+      schemes: ["oauth2"]
+    },
+    tools: [
+      {
+        name: "generate_content",
+        description: "Create a script, caption, hook, or blog post tailored to a specific platform.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            prompt: { type: "string" },
+            platform: { type: "string" }
+          },
+          required: ["prompt"]
+        }
+      },
+      {
+        name: "schedule_post",
+        description: "Publish or schedule a post to connected social platforms.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            platform: { type: "string" }
+          },
+          required: ["content", "platform"]
+        }
+      },
+      {
+        name: "fetch_analytics",
+        description: "Get post performance metrics for connected platforms.",
+        inputSchema: {
+          type: "object",
+          properties: { platform: { type: "string" } }
+        }
+      },
+      {
+        name: "extract_brand",
+        description: "Analyze a website URL and extract brand identity data.",
+        inputSchema: {
+          type: "object",
+          properties: { url: { type: "string" } },
+          required: ["url"]
+        }
+      },
+      {
+        name: "plan_content_week",
+        description: "Generate a full week content plan with platform-specific drafts.",
+        inputSchema: {
+          type: "object",
+          properties: { niche: { type: "string" } },
+          required: ["niche"]
+        }
+      },
+      {
+        name: "generate_video",
+        description: "Start an async AI video generation job.",
+        inputSchema: {
+          type: "object",
+          properties: { prompt: { type: "string" } },
+          required: ["prompt"]
+        }
+      },
+      {
+        name: "generate_image",
+        description: "Start an async AI image generation job.",
+        inputSchema: {
+          type: "object",
+          properties: { prompt: { type: "string" } },
+          required: ["prompt"]
+        }
+      },
+      {
+        name: "adapt_content",
+        description: "Rewrite existing content for a different platform.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            target_platform: { type: "string" }
+          },
+          required: ["content", "target_platform"]
+        }
+      },
+      {
+        name: "quality_check",
+        description: "Score post quality across 7 categories (0-100).",
+        inputSchema: {
+          type: "object",
+          properties: { content: { type: "string" } },
+          required: ["content"]
+        }
+      },
+      {
+        name: "run_content_pipeline",
+        description: "Full pipeline: trends \u2192 plan \u2192 quality check \u2192 schedule.",
+        inputSchema: {
+          type: "object",
+          properties: { niche: { type: "string" } },
+          required: ["niche"]
+        }
+      },
+      {
+        name: "fetch_trends",
+        description: "Get current trending topics for content inspiration.",
+        inputSchema: {
+          type: "object",
+          properties: { platform: { type: "string" } }
+        }
+      },
+      {
+        name: "get_credit_balance",
+        description: "Check remaining credits and plan tier.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "list_connected_accounts",
+        description: "Check which social platforms have active OAuth connections.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "get_brand_profile",
+        description: "Load the active brand voice profile.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "list_comments",
+        description: "List YouTube comments for moderation.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "reply_to_comment",
+        description: "Reply to a YouTube comment.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            comment_id: { type: "string" },
+            text: { type: "string" }
+          },
+          required: ["comment_id", "text"]
+        }
+      }
+    ],
+    prompts: [
+      {
+        name: "create_weekly_content_plan",
+        description: "Generate a full week of social media content with structured plan."
+      },
+      {
+        name: "analyze_top_content",
+        description: "Analyze best-performing posts to identify patterns and replicate success."
+      },
+      {
+        name: "repurpose_content",
+        description: "Transform one piece of content into 8-10 pieces across platforms."
+      },
+      {
+        name: "setup_brand_voice",
+        description: "Define or refine brand voice profile for consistent content."
+      },
+      {
+        name: "run_content_audit",
+        description: "Audit recent content performance with prioritized action plan."
+      }
+    ],
+    resources: [
+      {
+        uri: "socialneuron://brand/profile",
+        name: "brand-profile",
+        description: "Brand voice profile with personality traits, audience, tone, and content pillars."
+      },
+      {
+        uri: "socialneuron://account/overview",
+        name: "account-overview",
+        description: "Account status including plan tier, credits, and feature access."
+      },
+      {
+        uri: "socialneuron://docs/capabilities",
+        name: "platform-capabilities",
+        description: "Complete reference of all capabilities, platforms, AI models, and credit costs."
+      },
+      {
+        uri: "socialneuron://docs/getting-started",
+        name: "getting-started",
+        description: "Quick start guide for using Social Neuron with AI agents."
+      }
+    ]
+  });
+});
+app.get("/config", (_req, res) => {
+  res.setHeader("Cache-Control", "public, max-age=3600");
+  res.json({
+    supabaseUrl: SUPABASE_URL2,
+    anonKey: SUPABASE_ANON_KEY
+  });
+});
 app.get("/health", (_req, res) => {
   res.json({ status: "ok", version: MCP_VERSION });
 });
@@ -10719,7 +13108,7 @@ app.post(
       applyScopeEnforcement(server, () => getRequestScopes() ?? auth.scopes);
       registerAllTools(server, { skipScreenshots: true });
       const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID3(),
+        sessionIdGenerator: () => randomUUID4(),
         onsessioninitialized: (sessionId) => {
           sessions.set(sessionId, {
             transport,