rankcontrol 0.2.0 → 0.7.0

package/src/mcp.mjs

@@ -29,7 +29,7 @@ const plannedTitle = z.object({
 });
 
 export async function startMcpServer() {
-  const server = new McpServer({ name: "rankcontrol", version: "0.2.0" });
+  const server = new McpServer({ name: "rankcontrol", version: "0.6.0" });
 
   server.tool(
     "get_overview_funnel",
@@ -57,11 +57,230 @@ export async function startMcpServer() {
 
   server.tool(
     "get_visibility_score",
-    "Current overall AI visibility score for the workspace.",
+    "Composite visibility score for the workspace: 50% AI citation rate + 30% Google + 20% Bing position-weighted top-10 rank share (top 3 = full credit, 4-10 = half). Returns the composite, weights, and per-pillar subscores (the AI pillar includes a per-model breakdown).",
     {},
     run(() => api.visibilityScore())
   );
 
+  server.tool(
+    "get_citability_report",
+    "Published pages ranked by citability score (how extractable each page is for AI answers), worst first, each with its top open fixes. Use to decide which articles to improve.",
+    { limit: z.number().max(100).optional().describe("Max rows, default 25") },
+    run(({ limit }) => api.optimizer(limit ?? 25))
+  );
+
+  server.tool(
+    "get_citation_sentiment",
+    "How AI answers frame the brand when it's cited: positive / neutral / negative counts, daily trend, and recent answer snippets as receipts.",
+    { days: z.number().min(7).max(90).optional().describe("Window in days, default 30") },
+    run(({ days }) => api.citationSentiment(days ?? 30))
+  );
+
+  server.tool(
+    "get_citation_sources",
+    "Which domains AI engines cite when answering the brand's tracked queries, typed brand / competitive / UGC / editorial with counts and share. Shows where citation presence must be earned.",
+    { days: z.number().min(7).max(90).optional().describe("Window in days, default 30") },
+    run(({ days }) => api.citationSources(days ?? 30))
+  );
+
+  server.tool(
+    "get_share_of_voice",
+    "Share of voice vs competitors: the brand's citation rate, top competitor mention rates, and the brand's share of all brand appearances in AI answers over the window.",
+    { days: z.number().min(7).max(90).optional().describe("Window in days, default 30") },
+    run(({ days }) => api.shareOfVoice(days ?? 30))
+  );
+
+  server.tool(
+    "list_leads",
+    "Captured leads with source attribution: email, name, company, status, lead score, and the AI model / query / page that produced each lead.",
+    { limit: z.number().max(500).optional().describe("Max rows, default 100") },
+    run(({ limit }) => api.leads(limit ?? 100))
+  );
+
+  server.tool(
+    "list_tracked_queries",
+    "The workspace's tracked queries — the questions RankControl checks weekly across the 6 AI engines for brand citations — with their status and metadata.",
+    {},
+    run(() => api.trackedQueries())
+  );
+
+  server.tool(
+    "get_crawler_access",
+    "Daily AI-crawler reachability probe result — a DIAGNOSTIC, not a traffic metric: whether the site's edge (e.g. Cloudflare Bot Fight Mode) or robots.txt blocks GPTBot/ClaudeBot. 'shielded' means browsers and bots are both challenged (site-wide shield, ambiguous for real, signed crawlers).",
+    {},
+    run(() => api.crawlerAccess())
+  );
+
+  server.tool(
+    "get_analytics_sources",
+    "Per-workspace analytics source setup: the selected writer for human traffic and AI-crawler data, which sources the setup qualifies for, and install state (Cloudflare zone/sync, WordPress plugin version, embed liveness). Both Analytics and Reports screens ship disabled until activated.",
+    {},
+    run(() => api.analyticsSources())
+  );
+
+  server.tool(
+    "set_analytics_source",
+    "Select the active writer for a data type. Validated server-side against what the customer's setup supports. Switching aiCrawlers to cloudflare starts a backfill sync.",
+    {
+      dataType: z.enum(["humanTraffic", "aiCrawlers"]),
+      source: z
+        .string()
+        .describe("embed, wordpress_plugin, cloudflare or none"),
+    },
+    run(({ dataType, source }) => api.setAnalyticsSource(dataType, source))
+  );
+
+  server.tool(
+    "activate_analytics_screen",
+    "Turn on the Analytics or Reports screen for this workspace (they ship disabled; activation is one-time per screen).",
+    { screen: z.enum(["analytics", "reports"]) },
+    run(({ screen }) => api.activateScreen(screen))
+  );
+
+  server.tool(
+    "get_cloudflare_connect_url",
+    "OAuth URL to connect read-only Cloudflare analytics (AI-crawler data source). Open it in a browser; the grant is scoped to Analytics:Read.",
+    {},
+    run(() => api.cloudflareConnectUrl())
+  );
+
+  server.tool(
+    "list_cloudflare_zones",
+    "Cloudflare zones visible to the connected grant, for picking which zone to poll.",
+    {},
+    run(() => api.cloudflareZones())
+  );
+
+  server.tool(
+    "select_cloudflare_zone",
+    "Pick the Cloudflare zone to poll. Also selects Cloudflare as the AI-crawler source and starts the first sync (backfills up to 7 days).",
+    {
+      zoneId: z.string(),
+      zoneName: z.string().describe("Zone name, e.g. example.com"),
+    },
+    run(({ zoneId, zoneName }) => api.cloudflareSelectZone(zoneId, zoneName))
+  );
+
+  server.tool(
+    "install_framer_embed",
+    "Install site-wide visit tracking on the connected Framer project via its custom-code API. Dry run unless confirm is true. Confirming ALSO PUBLISHES the customer's Framer site.",
+    {
+      integrationId: z.string().optional(),
+      confirm: z.boolean().optional().describe("Actually install (default: dry run)"),
+    },
+    run(({ integrationId, confirm }) =>
+      api.framerInstallEmbed({
+        ...(integrationId ? { integrationId } : {}),
+        confirm: confirm === true,
+      })
+    )
+  );
+
+  server.tool(
+    "install_webflow_custom_code",
+    "Register and apply the tracking loader via Webflow's Custom Code API. Dry run unless confirm is true. Needs a site token with CMS + Custom code scopes (pass apiToken to upgrade the stored one). Goes live on the customer's next Webflow site publish.",
+    {
+      integrationId: z.string().optional(),
+      apiToken: z.string().optional().describe("New site token with CMS + Custom code scopes"),
+      confirm: z.boolean().optional().describe("Actually install (default: dry run)"),
+    },
+    run(({ integrationId, apiToken, confirm }) =>
+      api.webflowInstallCustomCode({
+        ...(integrationId ? { integrationId } : {}),
+        ...(apiToken ? { apiToken } : {}),
+        confirm: confirm === true,
+      })
+    )
+  );
+
+  server.tool(
+    "add_tracked_query",
+    "Add a query to the tracking pool. It starts weekly AI citation checks immediately when a plan slot is free; otherwise it joins the pool untracked.",
+    { queryText: z.string().describe("The search/AI query to track") },
+    run(({ queryText }) => api.addQuery(queryText))
+  );
+
+  server.tool(
+    "remove_tracked_query",
+    "Delete a query from the tracking pool. Frees its plan slot if it was tracking.",
+    { queryId: z.string().describe("Query id from get_tracked_queries") },
+    run(({ queryId }) => api.removeQuery(queryId))
+  );
+
+  server.tool(
+    "set_query_tracking",
+    "Pause or resume weekly AI citation checks on a pooled query. Tracking consumes one plan slot; pausing frees it. The query stays in the pool either way.",
+    {
+      queryId: z.string().describe("Query id from get_tracked_queries"),
+      tracked: z.boolean().describe("true to track weekly, false to pause"),
+    },
+    run(({ queryId, tracked }) => api.setQueryTracking(queryId, tracked))
+  );
+
+  server.tool(
+    "update_tracked_query",
+    "Rewrite a tracked query's text. Future weekly checks use the new text.",
+    {
+      queryId: z.string().describe("Query id from get_tracked_queries"),
+      queryText: z.string().describe("New query text (min 5 characters)"),
+    },
+    run(({ queryId, queryText }) => api.updateQuery(queryId, queryText))
+  );
+
+  server.tool(
+    "get_competitors",
+    "Tracked competitors used in share-of-voice and visibility comparisons.",
+    {},
+    run(() => api.competitors())
+  );
+
+  server.tool(
+    "add_competitor",
+    "Track a competitor (max 10). They enter weekly share-of-voice comparisons against the org's own citation rate.",
+    {
+      name: z.string().describe("Competitor name"),
+      websiteUrl: z.string().describe("Competitor website URL"),
+    },
+    run(({ name, websiteUrl }) => api.addCompetitor(name, websiteUrl))
+  );
+
+  server.tool(
+    "remove_competitor",
+    "Stop tracking a competitor.",
+    { competitorId: z.string().describe("Competitor id from get_competitors") },
+    run(({ competitorId }) => api.removeCompetitor(competitorId))
+  );
+
+  server.tool(
+    "get_topics",
+    "The org's pillar list (topic clusters). Tracked queries, content ideas and planned articles all group under these.",
+    {},
+    run(() => api.topics())
+  );
+
+  server.tool(
+    "set_topics",
+    "Replace the FULL pillar list. Send every topic that should exist; missing ones are safe-deleted, new ones created, duplicates merged. Read get_topics first and modify that list.",
+    {
+      topics: z.array(z.string()).describe("The complete list of topic names"),
+    },
+    run(({ topics }) => api.setTopics(topics))
+  );
+
+  server.tool(
+    "delete_planned_title",
+    "Remove a planned title from the content calendar. The title returns to Content Ideas as a pool query (deduped), so the topic is not lost. Only planned rows qualify; use archive for generated articles.",
+    { contentId: z.string().describe("Planned contentPage id") },
+    run(({ contentId }) => api.deletePlanned(contentId))
+  );
+
+  server.tool(
+    "get_traffic_overview",
+    "Traffic overview from RankControl's own page analytics: total page views, unique visitors, sessions, bounce rate, and average time on page.",
+    { days: z.enum(["7", "30", "90"]).optional().describe("Window in days, default 30") },
+    run(({ days }) => api.trafficOverview(days ? Number(days) : 30))
+  );
+
   server.tool(
     "get_planning_capacity",
     "How many article titles can still be planned onto the content calendar within the scheduling horizon. Check before plan_content.",
@@ -69,6 +288,88 @@ export async function startMcpServer() {
     run(() => api.planningCapacity())
   );
 
+  const permLevel = z.enum(["none", "read", "write"]);
+  server.tool(
+    "get_team",
+    "Workspace members and pending invites, with each member's per-screen permission matrix and the seat cap.",
+    {},
+    run(() => api.team())
+  );
+
+  server.tool(
+    "invite_team_member",
+    "Invite a member to the workspace with per-screen none/read/write access (unspecified screens default to none — grant at least one). Dry-run unless confirm is true; confirming sends the invite email.",
+    {
+      email: z.string().describe("Invitee email address"),
+      screenPermissions: z
+        .object({
+          overview: permLevel.optional(),
+          content: permLevel.optional(),
+          visibility: permLevel.optional(),
+          brandControl: permLevel.optional(),
+          linkControl: permLevel.optional(),
+          analytics: permLevel.optional(),
+          reports: permLevel.optional(),
+        })
+        .optional(),
+      confirm: z
+        .boolean()
+        .optional()
+        .describe("Set true to actually send the invite (default dry-run)"),
+    },
+    run((args) => api.teamInvite(args))
+  );
+
+  server.tool(
+    "revoke_team_invite",
+    "Revoke a pending team invite by invitation id (from get_team).",
+    { invitationId: z.string() },
+    run(({ invitationId }) => api.teamRevoke(invitationId))
+  );
+
+  server.tool(
+    "remove_team_member",
+    "Remove a member from the workspace (access revoked immediately). Dry-run unless confirm is true.",
+    {
+      userId: z.string().describe("Member user id from get_team"),
+      confirm: z.boolean().optional(),
+    },
+    run((args) => api.teamRemove(args))
+  );
+
+  server.tool(
+    "list_outreach_prospects",
+    "Link outreach pipeline: prospect sites per published article with status (identified → contacted → replied → link placed) and any contact email already found.",
+    {},
+    run(() => api.outreachProspects())
+  );
+
+  server.tool(
+    "find_outreach_contact",
+    "Find an outreach email for one prospect by scraping their site (mailto links, contact page, obfuscated text; Prospeo fallback when configured). Returns the stored contact or found:false. Capped at 5/min.",
+    { backlinkId: z.string().describe("Prospect id from list_outreach_prospects") },
+    run(({ backlinkId }) => api.outreachFindContact(backlinkId))
+  );
+
+  server.tool(
+    "draft_outreach_reply",
+    "AI-draft the next reply in an outreach conversation where the prospect has responded (replySnippet present on the prospect). Returns subject/body only — nothing sends; follow with queue_outreach_email to send it.",
+    { backlinkId: z.string().describe("Prospect id from list_outreach_prospects") },
+    run(({ backlinkId }) => api.outreachDraftReply(backlinkId))
+  );
+
+  server.tool(
+    "queue_outreach_email",
+    "Queue an outreach email to a prospect. It sends from the workspace's own connected mailbox, paced ~1 per 10 minutes up to the daily cap. Uses the stored draft unless subject/body are given. Dry-run unless confirm is true — a confirmed queue leads to a REAL email being sent.",
+    {
+      backlinkId: z.string().describe("Prospect id from list_outreach_prospects"),
+      subject: z.string().optional().describe("Override the drafted subject"),
+      body: z.string().optional().describe("Override the drafted body"),
+      confirm: z.boolean().optional().describe("Set true to actually queue the send"),
+    },
+    run((args) => api.outreachQueue({ ...args, confirm: args.confirm === true }))
+  );
+
   server.tool(
     "list_jobs",
     "Recent agent runs (job status feed). Async actions like content planning show up here with their outputs.",
@@ -117,6 +418,437 @@ export async function startMcpServer() {
     run(({ contentId, confirm }) => api.publishContent(contentId, confirm === true))
   );
 
+  server.tool(
+    "generate_article",
+    "Write a PLANNED article's body immediately instead of waiting for the scheduled pipeline (generate-only: its publish slot is unchanged). Allowed for past-due slots and up to 3 days ahead. Defaults to a DRY RUN; a human should approve before calling again with confirm=true since generation spends LLM budget.",
+    {
+      contentId: z.string().describe("The planned content page id"),
+      confirm: z.boolean().optional().describe("Set true to actually start generation (default: dry run)"),
+    },
+    run(({ contentId, confirm }) => api.generateContent(contentId, confirm === true))
+  );
+
+  server.tool(
+    "shopify_install_url",
+    "Mint an install link for the RankControl Shopify app. A human opens it in a browser and approves the install in Shopify; the Shopify destination is then added to the workspace automatically. The link expires in 10 minutes and minting it has no side effect on its own.",
+    {
+      shop: z.string().describe("The store's .myshopify.com domain"),
+    },
+    run(({ shop }) => api.shopifyInstallUrl(shop))
+  );
+
+  server.tool(
+    "get_article_settings",
+    "The workspace article policy: per-article defaults (auto-write, auto-publish, images, title-in-hero, section infographics, Related Reading, YouTube, emojis, link counts, global instructions) plus the flexible-scheduling flag.",
+    {},
+    run(() => api.articleSettings())
+  );
+
+  const articleSettingsShape = {
+    autoPublish: z.boolean().optional(),
+    autoGenerate: z.boolean().optional().describe("Off = fully manual mode: articles are written only on demand (generate_article) and publish only from the editor"),
+    includeInfographics: z.boolean().optional().describe("AI hero + section images"),
+    titleInHeroImage: z.boolean().optional().describe("Write the post title into the hero image"),
+    includeSectionInfographics: z.boolean().optional().describe("Informational panels in 2,000+ word articles"),
+    includeRelatedReading: z.boolean().optional().describe("Related Reading link block at the end"),
+    includeYouTube: z.boolean().optional(),
+    useEmojis: z.boolean().optional(),
+    internalLinksPerArticle: z.number().min(1).max(20).optional(),
+    externalLinksPerArticle: z.number().min(0).max(15).optional(),
+    globalInstructions: z.string().optional(),
+  };
+
+  server.tool(
+    "update_article_settings",
+    "Merge-patch the article policy: only the fields you pass change. Set flexibleScheduling true to allow 1-5 articles/day and manual rescheduling. styleSet picks the image style set applied to all generated images (heroes, infographic panels, social cards).",
+    {
+      articleSettings: z.object(articleSettingsShape).optional(),
+      flexibleScheduling: z.boolean().optional(),
+      styleSet: z
+        .enum([
+          "classic-editorial",
+          "print-craft",
+          "storybook-painterly",
+          "modern-saas",
+          "dark-premium",
+          "bold-poster",
+        ])
+        .optional()
+        .describe("Image style set for all generated images"),
+    },
+    run((args) => api.updateArticleSettings(args))
+  );
+
+  server.tool(
+    "reschedule_article",
+    "Move a PLANNED article to another day (requires the flexible schedule; max 5/day; the exact hour is placed automatically). Pass the target day as epoch ms of local midnight.",
+    {
+      contentId: z.string(),
+      targetDayStartMs: z.number().describe("Epoch ms of the target day's local midnight"),
+    },
+    run(({ contentId, targetDayStartMs }) => api.reschedule(contentId, targetDayStartMs))
+  );
+
+  server.tool(
+    "get_internal_links",
+    "How the workspace's articles interlink: how many published articles link TO this page (with the source list) and how many internal links it sends out. Recorded from the real injected links at publish render time.",
+    { contentId: z.string().describe("The content page id") },
+    run(({ contentId }) => api.internalLinks(contentId))
+  );
+
+  server.tool(
+    "list_site_pages",
+    "Site pages RankControl links to from inside articles and the Related Reading block (with linkable/alive flags).",
+    {},
+    run(() => api.sitePages())
+  );
+
+  server.tool(
+    "detect_site_links",
+    "Scan the customer's sitemap (nested indexes handled) or crawl a blog root page and return same-site page URLs. Costly (3/min); review the URLs, then call add_site_pages with the keepers.",
+    {
+      source: z.enum(["sitemap", "blogroot"]),
+      url: z.string().describe("Sitemap XML URL or a page URL to crawl"),
+    },
+    run(({ source, url }) => api.detectSiteLinks(source, url))
+  );
+
+  server.tool(
+    "add_site_pages",
+    "Add site page URLs for internal linking. Duplicates are skipped; page titles fill in automatically in the background.",
+    { urls: z.array(z.string()) },
+    run(({ urls }) => api.addSitePages(urls))
+  );
+
+  server.tool(
+    "list_repurpose_queue",
+    "Published articles with their social repurpose drafts per platform (platform + status chips). Shows which articles still need drafts and whether Postiz is connected.",
+    {},
+    run(() => api.repurposeQueue())
+  );
+
+  server.tool(
+    "get_repurpose_drafts",
+    "Full social drafts (title, body, images, status) for one published article across the 8 platforms (LinkedIn, X/Twitter, Pinterest, Instagram, Facebook, Threads, YouTube, TikTok).",
+    { contentId: z.string().describe("The content page id") },
+    run(({ contentId }) => api.repurposeDrafts(contentId))
+  );
+
+  server.tool(
+    "generate_repurpose_drafts",
+    "Draft platform-native social posts for a published article. Regeneration replaces unposted drafts for the chosen platforms. Defaults to a DRY RUN; confirm=true generates (spends LLM budget).",
+    {
+      contentId: z.string(),
+      platforms: z
+        .array(
+          z.enum([
+            "linkedin",
+            "twitter",
+            "pinterest",
+            "instagram",
+            "facebook",
+            "threads",
+            "youtube",
+            "tiktok",
+          ])
+        )
+        .optional()
+        .describe("Subset of platforms; omit for the workspace default"),
+      confirm: z.boolean().optional(),
+    },
+    run((args) => api.repurposeGenerate(args))
+  );
+
+  server.tool(
+    "update_repurpose_draft",
+    "Edit a repurpose draft's body and/or title before pushing or posting.",
+    {
+      draftId: z.string(),
+      body: z.string().optional(),
+      title: z.string().optional(),
+    },
+    run((args) => api.repurposeEditDraft(args))
+  );
+
+  server.tool(
+    "mark_repurpose_posted",
+    "Mark a repurpose draft as posted — use after publishing its text manually (outside Postiz).",
+    { draftId: z.string() },
+    run(({ draftId }) => api.repurposeMarkPosted(draftId))
+  );
+
+  server.tool(
+    "list_postiz_channels",
+    "Connected Postiz social channels (id, name, platform). Channel ids are required by push_repurpose_draft.",
+    {},
+    run(() => api.repurposeChannels())
+  );
+
+  server.tool(
+    "push_repurpose_draft",
+    "Send a repurpose draft to connected Postiz channels (post now, schedule, or save as a Postiz draft). PUBLICLY VISIBLE side effect: defaults to a DRY RUN; a human should approve before calling again with confirm=true.",
+    {
+      draftId: z.string(),
+      integrationIds: z
+        .array(z.string())
+        .optional()
+        .describe(
+          "Postiz channel ids from list_postiz_channels (required with confirm)"
+        ),
+      scheduleType: z
+        .enum(["now", "schedule", "draft"])
+        .optional()
+        .describe("Default now"),
+      date: z.string().optional().describe("ISO time for scheduleType=schedule"),
+      confirm: z.boolean().optional(),
+    },
+    run((args) => api.repurposePush(args))
+  );
+
+  server.tool(
+    "get_content_ideas",
+    "Scored content-idea backlog: uncovered tracked queries ranked by citation gaps, competitor citations, trending topics, and quick-win rankings. Each idea carries a suggested title and winnability metrics.",
+    {},
+    run(() => api.contentIdeas())
+  );
+
+  server.tool(
+    "plan_content_idea",
+    "Put a content idea on the calendar as a planned article. Pass the idea's queryText (and its suggested title if you have it — otherwise a title is generated).",
+    {
+      queryText: z.string().describe("The idea's keyword/query text"),
+      title: z.string().optional().describe("Exact headline to plan"),
+    },
+    run((args) => api.planIdea(args))
+  );
+
+  server.tool(
+    "archive_content",
+    "Archive an article, removing it from the working set. Reversible in the dashboard.",
+    { contentId: z.string() },
+    run(({ contentId }) => api.archiveContent(contentId))
+  );
+
+  server.tool(
+    "get_page_engagement",
+    "Per-page engagement for the last 30 days: views, AI citations, and a view sparkline per published page.",
+    {},
+    run(() => api.pageEngagement())
+  );
+
+  server.tool(
+    "get_exec_summary",
+    "Executive report: last 30 days vs the 30 before — cite rate, citations, page views, AI-referred views, crawler hits, and articles published.",
+    {},
+    run(() => api.reportSummary())
+  );
+
+  server.tool(
+    "get_top_wins",
+    "Biggest wins of the last 30 days: most-cited page, best query cite-rate jump, biggest Google ranking climb, best new backlink.",
+    {},
+    run(() => api.reportWins())
+  );
+
+  server.tool(
+    "get_agent_activity",
+    "Recent pipeline runs per agent lane (brand control, radar, forge, recon, deploy, outreach, sentinel, social).",
+    {
+      perAgent: z.number().max(50).optional().describe("Runs per lane, default 15"),
+      sinceDays: z.number().optional().describe("Window in days, default 30"),
+    },
+    run((args) => api.agentActivity(args))
+  );
+
+  server.tool(
+    "list_backlinks",
+    "The workspace's backlink table, newest first.",
+    {
+      status: z
+        .string()
+        .optional()
+        .describe(
+          "Filter: discovered, verified, lost, identified, contacted, replied, link_placed, rejected"
+        ),
+    },
+    run(({ status }) => api.backlinks(status))
+  );
+
+  server.tool(
+    "get_backlink_stats",
+    "Backlink totals (live, lost, avg DA, unique domains) plus outreach pipeline counts.",
+    {},
+    run(() => api.backlinkStats())
+  );
+
+  server.tool(
+    "update_outreach_status",
+    "Move an outreach prospect through the pipeline.",
+    {
+      backlinkId: z.string(),
+      status: z.enum(["identified", "contacted", "replied", "link_placed", "rejected"]),
+    },
+    run(({ backlinkId, status }) => api.outreachStatus(backlinkId, status))
+  );
+
+  server.tool(
+    "get_link_network",
+    "Link Network state: credit balance/earn/spend, membership (optedIn), and hosted/received placements with partners and anchors.",
+    {},
+    run(() => api.linkNetwork())
+  );
+
+  server.tool(
+    "set_link_network_opt_in",
+    "Join or leave the Link Network. SIDE EFFECT on partner sites (leaving retires live links): defaults to a DRY RUN; a human should approve before calling again with confirm=true.",
+    { optIn: z.boolean(), confirm: z.boolean().optional() },
+    run(({ optIn, confirm }) => api.linkNetworkOptIn(optIn, confirm))
+  );
+
+  server.tool(
+    "remove_network_placement",
+    "Retire one Link Network placement. VISIBLE on the partner site: defaults to a DRY RUN; call again with confirm=true after human approval.",
+    { placementId: z.string(), confirm: z.boolean().optional() },
+    run(({ placementId, confirm }) => api.linkNetworkRemovePlacement(placementId, confirm))
+  );
+
+  server.tool(
+    "list_social_threads",
+    "Social thread prospects (Reddit/X) where the brand's articles could earn a mention, with subreddit rules context, sorted by intent.",
+    {
+      platform: z.enum(["reddit", "twitter"]).optional(),
+      status: z.string().optional(),
+      age: z.enum(["ranked", "new"]).optional(),
+    },
+    run((args) => api.socialThreads(args))
+  );
+
+  server.tool(
+    "get_social_stats",
+    "Social thread pipeline counts.",
+    {},
+    run(() => api.socialStats())
+  );
+
+  server.tool(
+    "update_social_thread_status",
+    "Move a social thread through the pipeline (e.g. dismissed, replied).",
+    { threadId: z.string(), status: z.string() },
+    run(({ threadId, status }) => api.socialStatus(threadId, status))
+  );
+
+  server.tool(
+    "draft_social_reply",
+    "AI-draft a reply for a social thread. Nothing posts — the draft lands on the thread for human review. Subject to the same warm-up/pacing guards as the dashboard.",
+    {
+      threadId: z.string(),
+      mentionMode: z
+        .enum(["none", "natural", "founderOpen"])
+        .optional()
+        .describe("Brand-mention mode; warm-up accounts are clamped to none"),
+    },
+    run(({ threadId, mentionMode }) => api.socialDraftReply(threadId, mentionMode))
+  );
+
+  server.tool(
+    "contact_support",
+    "Send a message or bug report to the RankControl team (emails support with the workspace identified; the org owner is set as reply-to). Use when an API call errors unexpectedly or data looks wrong — include the failing request, ids, and what you expected. Capped at 3/min.",
+    {
+      subject: z.string(),
+      message: z.string().describe("Details: what happened, errors, ids, steps to reproduce"),
+      pageUrl: z.string().optional().describe("Related dashboard or API URL"),
+    },
+    run((args) => api.support(args))
+  );
+
+  server.tool(
+    "get_brand",
+    "The workspace's brand data in one read: brand profile (voice, colors, meta), links/CTAs, products, and buyer profiles (ICPs). This is the context RankControl's writers use.",
+    {},
+    run(() => api.brand())
+  );
+
+  server.tool(
+    "update_brand_profile",
+    "Patch brand voice/style fields: tone, colors, fontFamily, metaTitle/Description/Keywords, defaultLocale, flexibleScheduling. Only provided fields change; they steer all future article generation.",
+    {
+      tone: z.string().optional(),
+      primaryColor: z.string().optional(),
+      secondaryColor: z.string().optional(),
+      fontFamily: z.string().optional(),
+      metaTitle: z.string().optional(),
+      metaDescription: z.string().optional(),
+      metaKeywords: z.string().optional(),
+      defaultLocale: z.string().optional().describe("BCP-47 tag from the supported registry"),
+      flexibleScheduling: z.boolean().optional(),
+    },
+    run((args) => api.brandProfileSet(args))
+  );
+
+  server.tool(
+    "update_brand_identity",
+    "Update workspace identity: name, industry, productDescription, authors (EEAT bylines used in article JSON-LD), styleReferenceUrls (articles whose writing style the writer imitates). authors and styleReferenceUrls REPLACE the stored list — call get_brand first and send the full updated list. websiteUrl is immutable and cannot be changed.",
+    {
+      name: z.string().optional(),
+      industry: z.string().optional(),
+      productDescription: z.string().optional(),
+      authors: z
+        .array(
+          z.object({
+            name: z.string(),
+            bio: z.string().optional(),
+            linkedinUrl: z
+              .string()
+              .optional()
+              .describe("Person sameAs URL for article JSON-LD"),
+          })
+        )
+        .optional(),
+      styleReferenceUrls: z.array(z.string()).optional(),
+    },
+    run((args) => api.brandIdentitySet(args))
+  );
+
+  server.tool(
+    "write_brand_product",
+    "Create, update, or delete a product in brand memory (feeds article context + entity triples). Create: name+description+category. Update: productId + changed fields. Delete: productId + del=true.",
+    {
+      productId: z.string().optional(),
+      del: z.boolean().optional(),
+      name: z.string().optional(),
+      description: z.string().optional(),
+      url: z.string().optional(),
+      features: z.array(z.string()).optional(),
+      pricing: z.string().optional(),
+      category: z.string().optional(),
+      usps: z.array(z.string()).optional(),
+      isActive: z.boolean().optional(),
+    },
+    run((args) => api.brandProductWrite(args))
+  );
+
+  server.tool(
+    "write_brand_icp",
+    "Create, update, or delete a buyer profile / ICP (feeds article targeting + entity triples). Create: title+industry+demographics. Update: profileId + changed fields. Delete: profileId + del=true.",
+    {
+      profileId: z.string().optional(),
+      del: z.boolean().optional(),
+      title: z.string().optional(),
+      industry: z.string().optional(),
+      companySize: z.string().optional(),
+      painPoints: z.array(z.string()).optional(),
+      buyingTriggers: z.array(z.string()).optional(),
+      objections: z.array(z.string()).optional(),
+      preferredChannels: z.array(z.string()).optional(),
+      demographics: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Demographics object; required on create (same shape the dashboard saves)"),
+      isActive: z.boolean().optional(),
+    },
+    run((args) => api.brandIcpWrite(args))
+  );
+
   await server.connect(new StdioServerTransport());
   // Keep the process alive; the transport owns stdin/stdout from here
   console.error("rankcontrol MCP server running on stdio");