@wix/mcp 1.0.94 → 1.0.96

package/build/bin-standalone.js

@@ -71066,6 +71066,8 @@ var runSemanticSearch = async (toolName, toolParams, maxResults = 20, rerank = f
     kbNames.push("VELO_DOCS_KB_ID", "VELO_METHODS_KB_ID");
   } else if (toolName === "CLI") {
     kbNames.push("CLI_KB_ID");
+  } else if (toolName === "HELP_CENTER") {
+    kbNames.push("HELP_CENTER_KB_ID");
   }
   logger2.log(
     `[SemanticSearch] Tool: ${toolName}, KBs: [${kbNames.join(", ")}], Query: "${toolParams.searchTerm}"`
@@ -71098,9 +71100,9 @@ var runSemanticSearch = async (toolName, toolParams, maxResults = 20, rerank = f
   );
   return data?.results;
 };
-var runPlatformizedSemanticSearch = async (toolName, searchTerm, maxResults = 20, linesInEachResult, extraDocumentTypes) => {
+var runPlatformizedSemanticSearch = async (toolName, searchTerm, maxResults = 20, linesInEachResult, extraDocumentTypes, documentTypesOverride) => {
   const startTime = Date.now();
-  const documentTypes = extraDocumentTypes?.length ? [toolName, ...extraDocumentTypes] : void 0;
+  const documentTypes = documentTypesOverride?.length ? documentTypesOverride : extraDocumentTypes?.length ? [toolName, ...extraDocumentTypes] : void 0;
   logger2.log(
     `[SemanticSearch/v2] Tool: ${documentTypes ? documentTypes.join("+") : toolName}, Query: "${searchTerm}"`
   );
@@ -71144,15 +71146,17 @@ var runSemanticSearchAndFormat = async ({
   rerank,
   linesInEachResult,
   usePlatformizedSearch = true,
-  extraDocumentTypes
+  extraDocumentTypes,
+  documentTypes
 }) => {
-  if (usePlatformizedSearch) {
+  if (usePlatformizedSearch || documentTypes?.length) {
     return runPlatformizedSemanticSearch(
       toolName,
       toolParams.searchTerm,
       maxResults,
       linesInEachResult,
-      extraDocumentTypes
+      extraDocumentTypes,
+      documentTypes
     );
   } else {
     const results = await runSemanticSearch(
@@ -71168,6 +71172,7 @@ var runSemanticSearchAndFormat = async ({
 // src/constants.ts
 var RAW_DOCS_API_URL = "https://dev.wix.com/rawdocs/api";
 var GET_ARTICLE_CONTENT_URL = `${RAW_DOCS_API_URL}/get-article-content`;
+var GET_SOURCE_CONTENT_URL = `${RAW_DOCS_API_URL}/get-source-content`;
 var PORTAL_INDEX_URL = `${RAW_DOCS_API_URL}/portal-index`;
 var DOCS_API_BASE_URL = "https://dev.wix.com/docs/api/v1";
 var GET_SKILLS_BY_PORTAL_URL = `${DOCS_API_BASE_URL}/docs-web-app/menu-node/get-skills-by-portal`;
@@ -71180,7 +71185,13 @@ var SKILLS_REGISTRY_URL = new RegExp(
   "^https://(?:dev\\.wix\\.com(?:/docs)?|www\\.wix\\.com(?:/velo/reference)?)/skills(?:[/.?#]|$)|^https://www\\.wix\\.com/headless/"
 );
 function isSkillsRegistryUrl(url) {
-  return SKILLS_REGISTRY_URL.test(url.trim());
+  return SKILLS_REGISTRY_URL.test(normalizeSkillsUrl(url));
+}
+var GITHUB_SKILLS_URL = /^https:\/\/(?:www\.)?github\.com\/wix\/skills\/(?:blob|raw|tree)\/[^/]+\/skills\/([^#?]+)/;
+function normalizeSkillsUrl(url) {
+  const apex = url.trim().replace(/^https:\/\/wix\.com\//, "https://www.wix.com/");
+  const gh = apex.match(GITHUB_SKILLS_URL);
+  return gh ? `https://www.wix.com/skills/${gh[1]}` : apex;
 }
 async function fetchSkillsRegistryPage(httpClient, url) {
   let data;
@@ -71278,6 +71289,40 @@ async function fetchArticleContentFromDigor(httpClient, articleUrl, mode, stripH
   }
   return articleContent;
 }
+function parseSourceContentUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return void 0;
+  }
+  if (`${parsed.origin}${parsed.pathname}` !== GET_SOURCE_CONTENT_URL) {
+    return void 0;
+  }
+  const repo = parsed.searchParams.get("repo");
+  const path10 = parsed.searchParams.get("path");
+  const commitHash = parsed.searchParams.get("commitHash");
+  if (!repo || !path10) return void 0;
+  return commitHash ? { repo, path: path10, commitHash } : { repo, path: path10 };
+}
+async function fetchSourceContent(httpClient, repo, path10, commitHash) {
+  const url = new URL(GET_SOURCE_CONTENT_URL);
+  url.searchParams.set("repo", repo);
+  url.searchParams.set("path", path10);
+  if (commitHash) url.searchParams.set("commitHash", commitHash);
+  let data;
+  try {
+    ({ data } = await httpClient.get(url.toString()));
+  } catch (error2) {
+    const { message, status } = getHttpErrorDetails(error2);
+    const statusSuffix = status ? ` (status ${status})` : "";
+    throw new Error(`${message}${statusSuffix}`);
+  }
+  if (!data?.content) {
+    throw new Error("Source content is empty");
+  }
+  return data.content;
+}
 async function fetchArticleContent(httpClient, articleUrl, mode, stripHeader = false, skillsPortalUrl, repo, commitHash, fetchMcpWhiteList) {
   const effectiveUrl = applyPortalUrlOverride(articleUrl, skillsPortalUrl);
   const isOverridden = effectiveUrl !== articleUrl;
@@ -71291,7 +71336,10 @@ async function fetchArticleContent(httpClient, articleUrl, mode, stripHeader = f
         `[fetch] Override failed for ${effectiveUrl}, falling back to ${articleUrl}:`,
         error2 instanceof Error ? error2.message : error2
       );
-      content = isSkillsRegistryUrl(articleUrl) ? await fetchSkillsRegistryPage(httpClient, articleUrl) : await fetchArticleContentFromDigor(
+      content = isSkillsRegistryUrl(articleUrl) ? await fetchSkillsRegistryPage(
+        httpClient,
+        normalizeSkillsUrl(articleUrl)
+      ) : await fetchArticleContentFromDigor(
         httpClient,
         articleUrl,
         mode,
@@ -71299,7 +71347,10 @@ async function fetchArticleContent(httpClient, articleUrl, mode, stripHeader = f
       );
     }
   } else if (isSkillsRegistryUrl(articleUrl)) {
-    content = await fetchSkillsRegistryPage(httpClient, articleUrl);
+    content = await fetchSkillsRegistryPage(
+      httpClient,
+      normalizeSkillsUrl(articleUrl)
+    );
   } else if (mode === "raw") {
     let parsedUrl;
     try {
@@ -71442,6 +71493,140 @@ async function fetchPlatformizedMenu(menuUrl) {
   return data.content;
 }
 
+// src/docs/guessed-url.ts
+var SKILLS_BASE = "https://www.wix.com/skills/";
+var registryUrl = (url) => normalizeSkillsUrl(url).replace(
+  /^https:\/\/(?:dev\.wix\.com(?:\/docs)?|www\.wix\.com\/velo\/reference)\/skills\//,
+  SKILLS_BASE
+);
+var DOCS_BASE = "https://dev.wix.com/docs/";
+var FILLER = /* @__PURE__ */ new Set([
+  "",
+  "md",
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "of",
+  "to",
+  "wix",
+  "s"
+]);
+var slugWords = (slug) => new Set(
+  slug.toLowerCase().replace(/\.md$/, "").split(/[^a-z0-9]+/).filter((w) => !FILLER.has(w)).map((w) => w.length > 3 && w.endsWith("s") ? w.slice(0, -1) : w)
+);
+function slugSimilarity(a2, b) {
+  const x = slugWords(a2);
+  const y = slugWords(b);
+  if (x.size === 0 || y.size === 0) return 0;
+  let shared = 0;
+  for (const w of x) if (y.has(w)) shared++;
+  return shared / (x.size + y.size - shared);
+}
+var lastSegment = (path10) => path10.slice(path10.lastIndexOf("/") + 1);
+var folderOf = (path10) => path10.includes("/") ? path10.slice(0, path10.lastIndexOf("/")) : "";
+var SKILL_FILE_MATCH = 0.5;
+function closestSkillFile(url, manifest, manifestUrl) {
+  const normalized = registryUrl(url).replace(/[?#].*$/, "");
+  if (!normalized.startsWith(SKILLS_BASE)) return null;
+  const [, ...rest] = normalized.slice(SKILLS_BASE.length).split("/");
+  const asked = rest.join("/");
+  const paths = (manifest.files ?? []).map((f) => f.path);
+  if (!asked || paths.length === 0) return null;
+  const base = manifest.base ?? manifestUrl.replace(/\.manifest\.json$/, "/");
+  const name = lastSegment(asked);
+  const folder = folderOf(asked);
+  const sameName = paths.filter((p) => lastSegment(p) === name);
+  if (sameName.length === 1) {
+    return { kind: "file", path: sameName[0], url: base + sameName[0] };
+  }
+  const ranked = paths.filter((p) => folderOf(p) === folder).map((p) => ({ p, score: slugSimilarity(lastSegment(p), name) })).sort((a2, b) => b.score - a2.score);
+  const [best, next] = ranked;
+  if (best && best.score >= SKILL_FILE_MATCH && best.score > (next?.score ?? 0)) {
+    return { kind: "file", path: best.p, url: base + best.p };
+  }
+  if (ranked.length > 0) {
+    return {
+      kind: "folder",
+      folder,
+      files: ranked.map((r) => base + r.p),
+      manifestUrl
+    };
+  }
+  const top = [...new Set(paths.map((p) => p.split("/")[0]))].sort();
+  return {
+    kind: "folder",
+    folder: "",
+    files: top.map((t) => base + t),
+    manifestUrl
+  };
+}
+function skillManifestUrl(url) {
+  const normalized = registryUrl(url);
+  if (!normalized.startsWith(SKILLS_BASE)) return null;
+  const skill = normalized.slice(SKILLS_BASE.length).split(/[/?#]/)[0];
+  return skill ? `${SKILLS_BASE}${skill}.manifest.json` : null;
+}
+var MENU_WALK_UP_LEVELS = 3;
+var MIN_MENU_SEGMENTS = 3;
+function parentMenuUrls(url) {
+  const clean = url.replace(/[?#].*$/, "").replace(/\/+$/, "");
+  if (!clean.startsWith(DOCS_BASE)) return [];
+  const segments = clean.slice(DOCS_BASE.length).split("/");
+  const out = [];
+  for (let up = 1; up <= MENU_WALK_UP_LEVELS; up++) {
+    const kept = segments.length - up;
+    if (kept < MIN_MENU_SEGMENTS) break;
+    out.push(DOCS_BASE + segments.slice(0, kept).join("/"));
+  }
+  return out;
+}
+function closestMenuLinks(menuText, menuUrl, askedUrl, limit = 3) {
+  const asked = lastSegment(
+    askedUrl.replace(/[?#].*$/, "").replace(/\/+$/, "")
+  );
+  const under = `${menuUrl.replace(/\/+$/, "")}/`;
+  const links = [
+    ...new Set(
+      menuText.match(/https:\/\/dev\.wix\.com\/docs\/[^\s)\]>"'`]+/g) ?? []
+    )
+  ].filter((l) => l.startsWith(under));
+  return links.map((l) => ({
+    l,
+    score: slugSimilarity(lastSegment(l.replace(/\.md$/, "")), asked)
+  })).filter((r) => r.score > 0).sort((a2, b) => b.score - a2.score).slice(0, limit).map((r) => r.l);
+}
+var SMALL_MENU = 3;
+var MENU_ENTRY_MATCH = 0.75;
+function subMenusToRead(menuText, menuUrl, askedUrl, limit = 2) {
+  const asked = lastSegment(
+    askedUrl.replace(/[?#].*$/, "").replace(/\/+$/, "")
+  );
+  const under = `${menuUrl.replace(/\/+$/, "")}/`;
+  const methods = new Set(
+    [
+      ...menuText.matchAll(
+        /\]\((https:\/\/dev\.wix\.com\/docs\/[^)\s]+)\)\s*_\((?:GET|POST|PUT|PATCH|DELETE)\)_/g
+      )
+    ].map((m) => m[1])
+  );
+  const entries = [
+    ...new Set(
+      menuText.match(/https:\/\/dev\.wix\.com\/docs\/[^\s)\]>"'`]+/g) ?? []
+    )
+  ].filter(
+    (l) => l.startsWith(under) && !l.slice(under.length).replace(/\.md$/, "").includes("/") && !methods.has(l)
+  );
+  const scored = entries.map((l) => ({
+    l,
+    score: slugSimilarity(lastSegment(l.replace(/\.md$/, "")), asked)
+  })).sort((a2, b) => b.score - a2.score);
+  if (scored.some((s) => s.score >= MENU_ENTRY_MATCH)) return [];
+  if (entries.length <= SMALL_MENU) return entries;
+  return scored.filter((s) => s.score > 0).slice(0, limit).map((s) => s.l);
+}
+
 // ../../node_modules/dedent/dist/dedent.mjs
 function ownKeys2(object3, enumerableOnly) {
   var keys = Object.keys(object3);
@@ -71586,54 +71771,97 @@ function rethrowIfUnauthorized(error2) {
 var ARRAY_QUERY_PARAMS_RULE = "Repeat array query params once per value: `?fieldsets=URL&fieldsets=RICH_CONTENT`. Do NOT comma-join values (`fieldsets=URL,RICH_CONTENT`), do NOT leave a trailing comma, and do NOT use a value the method schema does not list, even if a sibling method accepts it (draft posts have no `SEO` fieldset).";
 var WQL_FILTER_RULE = "Query and search filters are written in WQL: each field takes a single operator, so combine conditions with the logical operators \u2014 `$and` and `$or` take an array of expressions, `$not` takes one, and they can nest.";
 
+// src/config/file-params.ts
+var FILE_PARAM_CLIENTS = "OpenAI clients (ChatGPT, Codex)";
+function fileParamNote(otherwise) {
+  return `${FILE_PARAM_CLIENTS} only: pass each file as you have it (attached in the chat or created in your sandbox, by its file id or path) and the client swaps it for { download_url, file_id, file_name?, mime_type? } before the call reaches Wix. No other client does this swap, so elsewhere a path or file:// URL here fails at once; leave this out and ${otherwise}.`;
+}
+
+// src/site-widget-tools/constants.ts
+var WIX_BUSINESS_FEATURES = "a store, bookings or appointments, rentals, events and tickets, a restaurant menu with online orders or reservations, a blog, a portfolio, pricing plans and memberships, donations, Wix Forms, members and login, a CMS, payments";
+var SITE_CREATION_DEFAULT_ACTIONS = "add products, set up bookings, and adjust your content";
+var SITE_CREATION_CUSTOM_ACTIONS_GUIDANCE = `2\u20133 specific, high-value setup actions for the site's industry, written as a comma-separated phrase (it slots into "\u2026ask me to ___ right here in the chat"). Use the following domain patterns as guidance:
+* E-commerce / Retail: "add products, set up payment methods, and organize collections"
+* Restaurants / Food / Bakeries: "add menu items, set up online ordering, and collect table reservations"
+* Services / Fitness / Salons / Consultants: "set up booking slots, add service pricing, and manage appointments"
+* Creative / Portfolios / Photographers: "upload project galleries, feature client reviews, and customize contact forms"
+* Events / Weddings / Real Estate: "add event schedules, display listings, and manage RSVP forms"
+* General / Unspecified: "${SITE_CREATION_DEFAULT_ACTIONS}"
+If none of these patterns fit the site, infer 2\u20133 actions that suit what that kind of business would manage on its site.`;
+var SITE_BUILDER_CHOICE = {
+  here: {
+    label: "Build it here with me",
+    pitch: "I build it in code right here, and you change anything by asking me"
+  },
+  editor: {
+    label: "Design it in Wix's editor",
+    pitch: "Wix designs a first version or you start from a template, then you edit it in Wix"
+  },
+  /** The editor's second step, in the widget and its reply. */
+  editorStart: {
+    wix: {
+      label: "Let Wix design it",
+      pitch: "Wix designs a first version from your description for you to edit"
+    },
+    template: {
+      label: "Browse templates",
+      pitch: "start from a ready-made design and edit it in Wix"
+    }
+  },
+  /** Asked in chat when no widget is shown: who builds it. */
+  whoQuestion: "Do you want me to build it here, so you can change anything just by asking me, or do you want to design it yourself in Wix's editor?",
+  /** Asked next, only when the user chose Wix's editor. */
+  editorQuestion: "Should Wix design a first version for you to edit, or do you want to start from a template?",
+  /** What the widget sends as the user's message when they pick "Build it here with me". */
+  hereFollowUp: "Build it here with me, in code, so I can keep changing it by asking you."
+};
+
 // src/config/default-config.ts
 var AGENT_GOAL = dedent_default`
-  You are an agent that helps the user manage their Wix site.
-  Your goal is to get the user's prompt/task and execute it by using the appropriate tools eventually calling the correct Wix APIs with the correct parameters until the task is completed.
+  You help the user with their Wix sites and account.
+  Work out what the task needs and do it: read the Wix skills, docs and API schemas that cover it, and write and run the code that calls Wix APIs, until the task is done.
 `;
+var CALL_WIX_SITE_API_RECONNECT_LINE = "If the Wix MCP offers no ExecuteWixAPI at all, your Wix connection is likely an old or cached version: tell the user once to reconnect the Wix connector or restart the client, and use this tool until then.";
+var CALL_WIX_SITE_API_NO_EXECUTE_LINE = "If ExecuteWixAPI isn't in your tool list, use this tool.";
 var DISCOVERY_FLOWS = [
-  "- CONVERSATION CONTEXT BASED: find relevant docs article or API example for the user's prompt/task in the conversation context -> call API using CallWixSiteAPI() based on the docs article or API example",
-  "- METHOD CODE EXAMPLE BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call API using CallWixSiteAPI() based on the method code examples",
-  "- FULL SCHEMA BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call API using CallWixSiteAPI() based on the schema"
+  "- CONVERSATION CONTEXT BASED: find relevant docs article or API example for the user's prompt/task in the conversation context -> call the API with ExecuteWixAPI based on the docs article or API example",
+  "- METHOD CODE EXAMPLE BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call the API with ExecuteWixAPI based on the method code examples",
+  "- FULL SCHEMA BASED: BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call the API with ExecuteWixAPI based on the schema"
 ];
+function directRouteLines(includeReadme, includeImageUploadGuidance) {
+  return [
+    ...includeReadme ? [
+      `- **Creating a new site.** Skip the docs too. A site is written in code and uploaded: StartDeployWebsite returns the upload guide; StartHeadlessBuild returns the headless guide, for a site that needs Wix business features (${WIX_BUSINESS_FEATURES}). Call one right away, without asking the user anything first: StartHeadlessBuild when the site needs Wix business features, otherwise StartDeployWebsite. WixHarmonyEditorBuild or SearchSiteTemplates only when the user asked for Wix's editor, the Wix Harmony Editor, a template, Wix Studio or the Classic Editor. Never create a site through ManageWixSite, CallWixSiteAPI or ExecuteWixAPI.`,
+      "- **Suggesting domain names**: call GetSuggestedDomains directly, with the business or site name as the query."
+    ] : [],
+    "- **Listing, showing or finding their Wix sites**: call ListWixSites directly.",
+    ...includeImageUploadGuidance ? [
+      "- **Uploading local or attached image files to a Wix site**: call UploadImageToWixSite directly, with no docs, schema or API calls. Do NOT use ExecuteWixAPI, SearchWixAPISpec, or any Media Manager REST API for image uploads."
+    ] : []
+  ];
+}
 function buildSystemReminderGuidelines(includeReadme, includeImageUploadGuidance) {
-  const exception = includeReadme ? "**Exception:** " : "";
   const lines = [];
-  if (includeReadme) {
-    lines.push(
-      "if the WixREADME tool is available to you, YOU MUST USE IT AT THE BEGINNING OF ANY CONVERSATION and then continue with calling the other tools and calling the Wix APIs until the task is completed.",
-      "**Creating a new Wix site \u2014 and only then \u2014 skip WixREADME and the docs.** First settle one thing: will the user keep working on this site with you, in code, or design it themselves in Wix's editor? In code \u2014 you or the user have code, the two of you designed it here, they asked you to build it, they asked for a headless site, or it is an app: StartDeployWebsite if the code exists in any form, StartHeadlessBuild if not, called right away (it only returns the guide; the site's purpose is not needed first). In Wix's editor: the site-creation tools; their descriptions carry the rules. Everything else starts with WixREADME as usual.",
-      "Never default to AI or search templates unless the user explicitly requests it. When the user named no creation method - let the user make that choice as the site-creation tools' descriptions direct. Never route site creation through ManageWixSite, CallWixSiteAPI, or ExecuteWixAPI."
-    );
-  }
   lines.push(
-    `${exception}If the user asks to list, show, or find their Wix sites, ${includeReadme ? "skip WixREADME and " : ""}call ListWixSites directly.`
+    includeReadme ? "Start every Wix task with WixREADME, questions included, then use the other tools and the Wix APIs until the task is done. If WixREADME is not available, follow the flows without it. These requests skip it and go straight to their own tool:" : "These requests go straight to their own tool, with no docs or API calls first:"
   );
-  if (includeImageUploadGuidance) {
-    lines.push(
-      `${exception}If the user wants to upload local or attached image files to a Wix site, skip ${includeReadme ? "WixREADME and " : ""}all docs/schema/API flows \u2014 call UploadImageToWixSite directly. Do NOT use ExecuteWixAPI, SearchWixAPISpec, or any Media Manager REST API for image uploads.`
-    );
-  }
-  if (includeReadme) {
-    lines.push(
-      "If the WixREADME tool is not available to you, you should use the other flows as described without using the WixREADME tool until the task is completed."
-    );
-  }
+  lines.push(...directRouteLines(includeReadme, includeImageUploadGuidance));
   lines.push(
-    `This applies to QUESTIONS too, not only action tasks (the ${includeReadme ? "exceptions" : "direct-tool routes"} above still apply \u2014 question-shaped variants of those intents, e.g. "can you show my sites?", follow their ${includeReadme ? "exception's " : ""}direct tool): never answer a Wix-specific question from memory, and never reply that you lack the tools or APIs to answer, without first ${includeReadme ? "calling the WixREADME tool (if available) and checking its recipes index, searching the docs," : "searching the docs"} and reading the matching docs articles \u2014 many questions (including ones that need no API call) are answered by a ${includeReadme ? "recipe or docs article" : "docs article"}.`,
-    "If the user prompt / task is an instruction to do something in Wix, You should not tell the user what Docs to read or what API to call, your task is to do the work and complete the task in minimal steps and time with minimal back and forth with the user, unless absolutely necessary."
+    `A question follows the same routes: one about those requests goes to its tool ("can you show my sites?" is ListWixSites). Any other Wix question is answered from ${includeReadme ? "WixREADME, the Wix skills, " : ""}the docs search and the matching docs articles, never from memory, and never with a reply that you lack the tools or APIs to answer. Many questions, including ones that need no API call, are answered by a ${includeReadme ? "Wix skill or docs article" : "docs article"}.`,
+    "When the user asks you to do something in Wix, do it, in as few steps and questions as you can; don't tell them which docs to read or which API to call."
   );
   return lines.join("\n");
 }
 function buildSystemReminderFlows(includeReadme) {
   const lines = ["Wix MCP Site Management Flows"];
+  const noSkill = "no Wix skill covers the user's prompt/task -> ";
   if (includeReadme) {
     lines.push(
       "With WixREADME tool:",
-      "- RECIPE BASED (PREFERRED!): WixREADME() -> find relevant recipe for the user's prompt/task -> read recipe using ReadFullDocsArticle() -> call Wix API using CallWixSiteAPI() based on the recipe",
+      "- SKILL BASED (PREFERRED!): WixREADME() -> find the Wix skill for the user's prompt/task (WixREADME says how to read one) -> follow it -> call the API with ExecuteWixAPI based on it",
       DISCOVERY_FLOWS[0],
-      "- EXAMPLE BASED: WixREADME() -> no relevant recipe found for user's prompt/task -> BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call API using CallWixSiteAPI() based on the method code examples",
-      "- SCHEMA BASED, FALLBACK: WixREADME() -> no relevant recipe found for user's prompt/task -> BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call API using CallWixSiteAPI() based on the schema",
+      `- EXAMPLE BASED: WixREADME() -> ${noSkill}BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() to get method code examples -> call the API with ExecuteWixAPI based on the method code examples`,
+      `- SCHEMA BASED, FALLBACK: WixREADME() -> ${noSkill}BrowseWixRESTDocsMenu() or SearchWixRESTDocumentation() -> find relevant method -> read method article using ReadFullDocsArticle() -> no method code examples found -> inspect the method schema using SearchWixAPISpec or ReadFullDocsMethodSchema -> call the API with ExecuteWixAPI based on the schema`,
       "Without WixREADME tool:"
     );
   }
@@ -71666,41 +71894,22 @@ function buildSystemReminder(includeReadme, includeImageUploadGuidance = true) {
   `;
 }
 var SYSTEM_REMINDER = buildSystemReminder(true);
+var HELP_CENTER_IS_FOR_PEOPLE = "The Help Center is written for people doing things by hand in Wix's dashboard and editors. To act on a site yourself, the Wix developer docs come first: find the method with SearchWixRESTDocumentation or BrowseWixRESTDocsMenu.";
 var SITE_CREATION_COPY = {
   templatePick: {
     nonWidget: "After the user selects a template, call `CreateSiteFromTemplate`.",
     widget: "The gallery creates the site when the user picks one."
-  },
-  unstatedMethod: {
-    nonWidget: "you MUST ask whether they want to build with AI or start from a template, and create nothing and show nothing until they answer",
-    widget: "you MUST call `WixSiteCreation` and let them choose"
   }
 };
-var SITE_GUIDANCE = dedent_default`
-  First decide who keeps building the site:
-  - **You, in code**: a Wix Headless site, with full control of the design, changed and redeployed from this conversation, Wix business features added as a backend. This is the case when you or the user have code (hand-written files, a static build, a zip, another builder's export, a page you made here): call StartDeployWebsite. It is also the case when nothing is coded yet but the user asked you to build it or asked for a headless site, the two of you worked out its design in this conversation, or it is an app (a game, a dashboard, a tool): call StartHeadlessBuild right away, before asking what the site is for. Do not offer AI or templates for either.
-  - **The user, in Wix's editor**: Wix generates it with AI or starts it from a template, and the user designs it in Wix. That is what the site-creation tools do; they never take files you already have.
-
-  For a new site in Wix's editor there are two things to settle: what the site is for, and how to build it. The how is AI generation vs. starting from a template, so naming templates, a template id or Wix Studio (Wix Studio is also the template side) already settles it.
-
-  Settle what the site is for first: its purpose, topic, business type, audience, or main visitor action. Naming a method is not a description of the site, and neither is the business or industry on its own.
-  If you can't tell yet, ask the preferred question below and nothing else — one question, no creation-method question in the same reply, and no internal tool names.
-  Once the purpose is clear, unless the user already named a method, ${SITE_CREATION_COPY.unstatedMethod.nonWidget}. A method they named is settled — never re-open it. Never default to AI or to templates, and never ask the user to choose between Harmony and Wix Studio; infer that from their words.
-  With the purpose and the method known, that's enough to begin — route and refine the specifics with the user afterward.
-
-  Preferred question when the user has given no site context at all:
-  Happy to help. To give you the right starting point, tell me a bit more about what you have in mind:
-  - What's the site for? (e.g. an online clothing store, a yoga studio that takes bookings, a restaurant)
-  - What's the vibe? (e.g. sleek and modern, cozy and rustic, bold and energetic)
-  Give me a quick summary and I'll take it from there
-
-  Tone: helpful, practical, short. Speak about the user's site — what you're making and what comes next — not the tools, payloads, or routing behind it.`;
+var EDITOR_TAIL = `When the user wants Wix's editor, or to design the site themselves, without saying how to start, ask them first: "${SITE_BUILDER_CHOICE.editorQuestion}" A new site is otherwise written in code and uploaded: call StartDeployWebsite, or StartHeadlessBuild when it needs Wix business features, right away and without asking the user anything first.`;
 var toWidget = (text) => Object.values(SITE_CREATION_COPY).reduce(
   (acc, { nonWidget, widget }) => acc.replaceAll(nonWidget, widget),
   text
 );
+var WIX_API_DATA = "products, inventory, carts, checkouts, orders, bookings, services, staff, time slots, rentals, restaurant menus, online orders, reservations, events, tickets, RSVPs, blog posts, CMS collections and items, pricing plans, subscriptions, portfolios, gift cards, coupons, donations, forms, form submissions, contacts, members, loyalty points, groups, reviews, inbox messages, CRM tasks, automations, email campaigns, payments, invoices, SEO, redirects, translations, locations, analytics, media files, site properties, installed apps, and the account's sites and domains (searching whether a domain is available, buying one, and connecting one bought elsewhere)";
 var EXECUTE_WIX_API_INTRO = dedent_default`
-  Execute JavaScript code against the Wix REST API when code is useful for chaining related calls, pagination, loops, branching, or in-memory transformation.
+  Reads and changes the data of a Wix site or account: query, list, count, create, update and delete it with one JavaScript function over the Wix REST API.
+  One function holds the whole task: chained calls, pagination, loops, branching, and the reads that feed its writes.
   Putting a site live or changing a headless site's files starts with StartDeployWebsite; building a new site in code with StartHeadlessBuild.
 
   CODE CONTRACT:
@@ -71786,7 +71995,7 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
   declare const files: Array<{ path: string; content: string; encoding?: "base64" }>;
   \`\`\`
 
-  FILE UPLOADS: files never go inline in \`code\`; two params feed the \`files\` global. \`attachments\` works in ChatGPT only: pass files attached in the chat or created in your sandbox (any type, up to 10 MB per call: a zip of a whole site, HTML, images, PDFs) as you have them, by file id or /mnt/data path, all in one call. ChatGPT swaps each for \`{ download_url, file_id, file_name?, mime_type? }\` before the call reaches Wix, and the bytes arrive as base64 entries named by file name. Other clients send the value unchanged and the call fails before running; there, leave \`attachments\` out, or upload from your shell if it reaches the internet. The \`files\` param takes content you have as text here: text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
+  FILE UPLOADS: files never go inline in \`code\`; two params feed the \`files\` global. \`attachments\`: ${fileParamNote("upload from your shell if it reaches the internet")} Any type, up to 10 MB per call, all in one call: a zip of a whole site, HTML, images, PDFs; the bytes arrive as base64 entries named by file name. The \`files\` param takes content you have as text here: text goes raw; a small binary (icon, logo, font) rides as a \`base64\`-tagged entry — large images/video are referenced by URL (\`<img src="https://...">\`), not bundled. \`wix.multipart()\` turns the whole set into one upload body (bytes, so binary is safe):
   \`\`\`javascript
   // files param:
   //   === FILE: index.html ===
@@ -71801,6 +72010,7 @@ var ACCOUNT_SITE_EXECUTE_SCOPE = dedent_default`
     return res.data;
   }
   \`\`\`
+  HEADLESS SITE EDITS: \`wix.headless.files.list({siteId, prefix?, offset?, limit?})\` returns file metadata; \`read({siteId, path})\` returns UTF-8 text (up to 256 KB); \`patch({siteId, files?, deletePaths?, agent?})\` applies changed files and explicit deletions while preserving everything else. Patch defaults to the Execute \`files\` global (including resolved attachments and ZIPs). Paths are literal site-relative paths; no wrapping-folder stripping. It returns added/replaced/deleted/unchanged/missingDeletes path lists. List/read reuse one downloaded ZIP snapshot for the current site within an Execute call; switching sites discards the previous snapshot, and a new call downloads afresh. Patch downloads a fresh ZIP, then drops the full merged site and clears the read snapshot. Serialize edits to the same site; there is no atomic concurrency guarantee. For a full replacement, use the existing upload/drop path. See the upload-static-site recipe for examples and older-server fallback.
   A site zip passed through \`attachments\` is one base64 entry; unzip it and upload the entries:
   \`\`\`javascript
   // attachments: [site.zip] → files = [{ path: "site.zip", content: "<base64>", encoding: "base64" }]
@@ -71924,22 +72134,37 @@ var executeWixApiDescription = dedent_default`
 
   ${EXECUTE_WIX_API_MULTI_SITE_EXAMPLE}
 `;
-function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true) {
-  const reminder = buildSystemReminder(
+function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true, { usageGuideOnce = false } = {}) {
+  const usageGuide = buildSystemReminder(
     includeReadme,
     includeImageUploadGuidance
   );
-  return {
+  const reminder = includeReadme && usageGuideOnce ? "" : usageGuide;
+  const descriptions = {
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
     WixREADME: dedent_default`
     # Tool: WixREADME
-    **Directive:** \`WixREADME\` is the **MANDATORY FIRST STEP** for all Wix-related tasks. Its output (including relevant linked documents) provides foundational context for all other Wix tools. Adherence to this protocol is **NON-NEGOTIABLE**.
-
-    **Mid-conversation site switching:** If the user references a different site by name or ID after WixREADME has already been called, use \`GetSiteContext\` directly — no need to call WixREADME again.
-    ${reminder}
+    The context every other Wix tool assumes. Call it first, once per conversation, for any Wix task or question; for another site later in the conversation, call \`GetSiteContext\` instead of calling this again.
+    A Wix task includes reading or changing a site's or account's data: ${WIX_API_DATA}.
+    These requests skip it and go straight to their own tool:
+    ${directRouteLines(includeReadme, includeImageUploadGuidance).join("\n")}
+    A question about one of those goes to the same tool ("can you show my sites?" is ListWixSites). Any other Wix question is answered from a Wix skill or the docs, never from memory, and never with a reply that you lack the tools to answer.
+    It returns, in full:
+    - **Source of truth**: nothing Wix-specific from memory. Every URL, ID, setting location, product fact, request shape and field name comes from the docs tools, a Wix skill, an earlier tool result in the conversation, or the user.
+    - **The site**: the account's sites with their properties and installed apps. The \`siteId\` comes from there (ask when several fit); a business solution's API works only on a site with its app installed, and an app's version changes its endpoints.
+    - **Find the method**: an earlier tool result, else a Wix skill's recipe (wix-manage to manage a site, wix-headless-kit to build a headless one), else the docs: SearchWixRESTDocumentation or BrowseWixRESTDocsMenu, then ReadFullDocsArticle; the SDK, CLI, headless and apps docs for code.
+    - **The exact shape**: model a call only on an example that matches the case; fill the rest with SearchWixAPISpec on the method's docs URL (request and response schemas, \`method.publicUrl\` for REST, \`method.sdk\` for the JavaScript SDK). A query's filter and sort fields and operators are a closed list per method.
+    - **The call, or the code**: ExecuteWixAPI runs one async function holding every step code can resolve, the reads and the writes they feed together, \`hasMutations: true\` when anything writes. Code the user keeps (an app, a headless site, a script over REST or the JavaScript SDK) is written from the same shapes; the headless skills are a shortcut on that path.
+    - **When a call fails**: the error says what was wrong and carries a Wix request id; fix that, never resend unchanged or guess.
+    - **Wix skills**, what each is for and how to read one: from disk when installed (the Wix plugin, or \`npx skills add wix/skills\`, \`--skill <name>\` for one, \`-g\` for the user's home, into \`.agents/skills/<skill>/\` or a similar folder the client reads, such as \`.claude/skills/<skill>/\`), else online with ReadFullDocsArticle at \`https://www.wix.com/skills/<skill>/<path>\`.
+      - **wix-manage**: REST recipes for managing a site's business solutions, one per task; follow the recipe and make its calls with ExecuteWixAPI, its docs URL in \`sourceDocUrls\`. Its list of recipes is \`SKILL.md\` in the installed skill, or online https://dev.wix.com/docs/api-reference/articles/ai-tools/wix-mcp/skills/wix-management-recipes-index.md, and each API area has its own \`<API section>/skills.md\` (for example https://dev.wix.com/docs/api-reference/business-solutions/bookings/skills.md).
+      - **wix-headless-kit**: builds a Wix Headless site on shipped, verified code from wix-headless-templates, a \`@wix/sdk\` React core or the same data layer as plain REST calls: scaffold with the CLI, deploy, seed, design on the shipped hooks, release. https://www.wix.com/skills/headless-kit/SKILL.md
+      - **wix-headless-templates**: the code wix-headless-kit builds from, one folder per Wix Business Solution. https://www.wix.com/skills/headless-templates/
+    When the user asks you to do something in Wix, do it yourself, in as few steps and questions as you can; don't tell them which docs to read or which API to call.
   `,
     SearchWixRESTDocumentation: dedent_default`
     **Searches the official Wix REST API documentation — the starting point for any Wix REST API task.** Unless you already have the exact method \`docsUrl\` in context, begin the task here; this is how you discover the right endpoint. Reach for it before \`SearchWixAPISpec\`, and avoid writing code that scans or filters \`lightIndex\` to find an endpoint (e.g. \`lightIndex.filter(...)\`, \`lightIndex.flatMap(...)\`, or substring-matching on \`docsUrl\`/\`name\`/\`summary\`) — that has no relevance ranking and silently misses composite and method-level operations. This is the ranked semantic-search discovery tool over the Wix REST API docs: describe your intent in natural language and it returns the matching REST endpoints/methods (with their \`docsUrl\`) ranked by relevance. It is the first step whenever you need to do something on a Wix site via HTTP and don't already have the exact \`docsUrl\` in context — for creating, reading, updating, or deleting any kind of Wix entity, across every business domain.
-    It covers all Wix REST domains equally — Stores, eCommerce/orders, Bookings, CRM/contacts, Members, CMS/data collections, Events, Blog, Forms, Marketing, Media, site settings, SEO, and the rest. Just describe the resource, action, or goal in plain words (e.g. 'add a catalog item with inventory', 'book a service', 'update a data collection item', 'create a discount', 'list contacts', 'get site details endpoint', 'REST authentication'); the ranking handles matching your wording to the right API regardless of domain.
+    It covers all Wix REST domains equally, every product's data: ${WIX_API_DATA}, and the rest. Just describe the resource, action, or goal in plain words (e.g. 'add a catalog item with inventory', 'book a service', 'update a data collection item', 'create a discount', 'list contacts', 'get site details endpoint', 'REST authentication'); the ranking handles matching your wording to the right API regardless of domain.
     **Next step after this tool:** take the \`docsUrl\` it returns and inspect that method's exact request/response schema with \`SearchWixAPISpec\` (\`getResourceSchemaByUrl(docsUrl)\`), then execute. \`SearchWixAPISpec\` is only for INSPECTING a \`docsUrl\` you already have — it is NOT a discovery tool. Skipping this step to hand-search \`lightIndex\` yourself is a mistake: raw index filtering has no relevance ranking and misses operations this ranked search finds. Discover here first, every time.
     If you can't find what you need, rephrase your search term or use a bigger maxResults value.
     ${reminder}
@@ -71961,6 +72186,7 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
   `,
     CallWixSiteAPI: dedent_default`
     Call Wix apis on a business or site. Use this to create, read, update, and delete data and other Wix entities in your Wix site.
+    ExecuteWixAPI is the preferred tool for Wix API calls: one function holds every call of the task, the reads and the writes they feed together, where this tool makes one call per invocation. If your client loads tools on demand (tool search, deferred tools), load ExecuteWixAPI before using this tool. ${CALL_WIX_SITE_API_RECONNECT_LINE}
     Site-level: this tool reads and writes inside the single site named by the required \`siteId\`.
     **Prefer using the "ListWixSites" tool when the user asks to list or show their sites.** Only use this tool for site listing if the user needs advanced filtering or specific site details beyond what ListWixSites provides.
     For POST/PATCH/PUT requests, pass the request body as a JSON object or array in the "body" parameter with all the required fields and values as described in the API schema, code examples, or docs you retrieved (e.g. body: {"name": "value", "nested": {"key": "value"}} or body: [{"key": "value"}]).
@@ -71975,6 +72201,7 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     Docs urls like https://dev.wix.com/docs/... are not api urls, if you want to read the docs, use the "ReadFullDocsArticle" tool
     ${reminder}
   `,
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
     ListWixSites: dedent_default`
     **Use this tool whenever the user asks to list, show, get, or find their Wix sites.** This is the dedicated tool for listing Wix sites for the current user. By default it returns all sites, but you can filter by name.${includeReadme ? "\n\n**Do NOT use WixREADME before this tool.** When the user asks to list their sites, call this tool directly \u2014 no need to read documentation first." : ""}
 
@@ -71995,13 +72222,13 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     ${reminder}
   `,
     ManageWixSite: dedent_default`
-    Use account level API in order to update a site.
-    Account-level only: this tool acts on the account itself, or on sites as objects within it, and sends no site context. Anything that reads or writes inside a site is site-level and does not belong here — use a site-level tool with that site's \`siteId\`.
+    Calls an account-level Wix API: one that acts on the account itself (its sites list, domains, account settings) or on sites as objects in it (create, rename, duplicate, delete a site). It sends no site, so an API that reads or writes inside a site (its products, data, bookings, members, pages, publishing) fails here: call that through ExecuteWixAPI with the site's \`siteId\`.
     For POST/PATCH/PUT requests, pass the request body as a JSON object or array in the "body" parameter with all the required fields and values as described in the API schema, code examples, or docs you retrieved (e.g. body: {"name": "value", "nested": {"key": "value"}} or body: [{"key": "value"}]).
     The API endpoint url param MUST ALWAYS be taken from the conversation context.
     By conversation context we mean the endpoint url was given in the user prompt or got into the conversation context ${includeReadme ? 'by the "WixREADME" tool or ' : ""}by the "SearchWixRESTDocumentation" tool or by the "BrowseWixRESTDocsMenu" tool or by the "ReadFullDocsArticle" tool.
     ${reminder}
   `,
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
     UploadImageToWixSite: dedent_default`
     Upload one or more images to a Wix site's Media Manager. Returns wixstatic.com URL and media ID.
     Do NOT use ExecuteWixAPI or code execution for image uploads — use this tool directly.
@@ -72011,34 +72238,39 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     NEVER call this tool with a missing, empty, or guessed siteId — ask first instead.
 
     Parameters — provide image input via image and/or imageUrls, OR imageBase64:
-    • image (array): chat file ATTACHMENTS — files the user attached, or files you created in your own file sandbox. Each item is an object with download_url and file_id (both required), plus optional file_name and mime_type. Pass ALL attachments in one call.
+    • image (array): ${fileParamNote("send the image as imageBase64 (the whole file, one per call) or as a public URL in imageUrls")} Pass ALL of them in one call.
     • imageUrls (array): plain public image URLs the user pasted or other tools produced (no file_id). Pass ALL URLs in one call. Can be combined with image.
     • imageBase64 (string): base64-encoded image + mimeType. One image at a time. Do NOT combine with image/imageUrls.
 
     Delivering the bytes — this is where uploads most often fail:
-    • Pass a file as a file, in image: the platform resolves it into download_url and file_id before it reaches this tool — this includes files you created in your sandbox. This server does not share your filesystem, so a bare path string (e.g. /mnt/..., /home/user/..., /Users/...) is not a file. Without a file to pass, use a public http(s) URL (imageUrls) or the complete base64 (imageBase64).
+    • This server does not share your filesystem: outside image's clients, a file you can only reach by path (e.g. /mnt/..., /home/user/..., /Users/...) goes as imageBase64 (the whole file, one per call) or, if it is public, as imageUrls.
     • imageBase64 must be the WHOLE file, not truncated. For large images prefer imageUrls, since long base64 is easily cut off and will be rejected as unreadable.
   `,
-    SupportAndFeedback: dedent_default`
-    Send the user's feedback about the experience of building with Wix — the Wix MCP tools, APIs, docs, and tooling — to Wix, attributed to the authenticated user.
-    This is meta-feedback about building with Wix; it is NOT a support channel and not for the user's own site content.
+    // Registered for Claude clients only, beside UploadImageToWixSite.
+    PickImagesForWixMedia: dedent_default`
+    Shows a file picker where the user selects images from their device; they upload to the site's Media Manager and the result (each image's media ID and wixstatic URL) comes back in the conversation.
+    Use it only when you can't deliver the image yourself with UploadImageToWixSite: the image is on the user's device and not in your files, or it is a file in your sandbox that you can't pass as a file, a public URL or base64. When UploadImageToWixSite can take it, use that.
+  `,
+    ReportIssueToWix: dedent_default`
+    Report one specific problem with Wix's tools, APIs or docs to the Wix team, attributed to the authenticated user: an API error or a confusing API, wrong or missing docs, a Wix MCP tool or auth dead end. It is NOT a support channel and not for the user's own site content.
 
     When to offer it (user-approved only — NEVER auto-send):
-    - The user explicitly asks to send feedback / report something to Wix ("tell Wix that...", "report this", "send feedback"). Then just confirm the wording and send.
-    - The user complains, is frustrated, or reports a Wix bug in the course of the work ("this API is broken", "the docs are wrong", "why is this so hard"). Acknowledge, then offer to pass it on.
-    - The session hit substantial friction — repeated API failures, wrong/missing docs, a tooling dead end, or a workaround you had to invent. When you notice the pattern, offer: "This tripped us up a few times — want me to send it to Wix as feedback?"
-
-    When you offer, invite the user to add anything in their own words — whatever they give you goes into the message verbatim.
-
-    What to send — a summary of the whole run, not just the last error. Structure it in four layers:
-    1. Provenance — agent/model; Wix tooling used; platform/hosting; Wix areas/APIs touched; Wix products; project type/frontend; site id; relevant links (dashboard, docs pages, live site, repos); skill areas/recipes involved; other ids created this run.
-    2. Narrative — user intent and run summary (what they set out to build, what worked vs. what fought back); a condensed play-by-play of the session (key exchanges, tool calls, decisions, course-corrections).
-    3. Friction points — for each friction point: the step/endpoint, HTTP status and error message, the gap, the workaround you had to invent, and what you expected instead. Include ones you recovered from silently — a retry that eventually worked is exactly the signal Wix wants.
-    4. Attribution — per friction point, where the fault likely lives: API behavior / API schema / API reference docs / docs articles or examples / Wix tooling / other/unsure. Don't force a tag; "unsure" beats a wrong route.
-    End with a bottom line: one or two sentences on the single most important problem and its impact — a plain engineering assessment, not softened or hedged.
-
-    **IMPORTANT**: This tool actually sends the message to Wix. Confirm the final wording with the user and call it only after an explicit yes.
-    Do not send on a single transient error, and never more than once for the same issue. Feedback cannot be replied to or tracked by the user.
+    - The user asks to report something to Wix ("tell Wix that...", "report this", "send feedback"). Then confirm the wording and send.
+    - The user complains or reports a Wix bug in the course of the work ("this API is broken", "the docs are wrong"). Acknowledge, then offer to pass it on.
+    - A Wix API, tool or doc kept failing, or you had to invent a workaround for it. Offer: "This tripped us up — want me to report it to Wix?"
+
+    When you offer, invite the user to add anything in their own words — whatever they give you goes into the report verbatim.
+
+    What to send — that one issue, not the session:
+    - What was being attempted, in a sentence.
+    - Where it failed: the tool or endpoint, the HTTP status and error message, and the request id if there is one (pass it as requestId).
+    - What you expected instead, and the workaround if you found one.
+    - Where the fault likely lives: API behavior / API schema / API reference docs / docs articles or examples / Wix tooling / unsure.
+    - Only the context needed to reproduce it: agent/model, site id, the Wix area or API.
+    No session summary or play-by-play, and nothing unrelated to the issue. Several distinct issues are separate reports, each approved by the user.
+
+    **IMPORTANT**: This tool actually sends the report to Wix. Confirm the final wording with the user and call it only after an explicit yes.
+    Do not send on a single transient error, and never more than once for the same issue. Reports cannot be replied to or tracked by the user.
   `,
     BrowseWixRESTDocsMenu: dedent_default`
     Browse the Wix REST API documentation menu hierarchy.
@@ -72060,25 +72292,7 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     ${reminder}
   `,
     WixSiteCreation: dedent_default`
-    ${SITE_GUIDANCE}
-
-    Opens the in-chat Wix site creation chooser as an interactive widget where the user chooses between "Build with AI" and "Pick a template."
-
-    **Once you can tell what the site is for, call this tool directly** — no ${includeReadme ? "WixREADME, skill," : "skill"} or docs search first.${includeReadme ? " Any other Wix request still starts with WixREADME as usual." : ""}
-
-    Call this for normal new Wix site creation requests when the user's site intent is clear, but they have not chosen AI, templates, or Wix Studio.
-    Do not guess, and never default to AI — even after the user answers a clarifying question about the site's purpose or features.
-    This chooser is how the builder choice gets made — never ask in chat whether they want AI or a template; that choice is made in the widget.
-    The widget also does the creating: once the user picks, it runs that path itself and the site is created there, so never call \`WixSiteBuilder\`, \`SearchSiteTemplates\`, or \`CreateSiteFromTemplate\` yourself after opening it.
-    After calling, reply with the message it returns, which presents both options and the next steps.
-
-    Do not call this if the user explicitly asks to build with AI; call \`WixSiteBuilder\` instead.
-    Do not call this if the user asks for templates or Wix Studio; call \`SearchSiteTemplates\` instead.
-    Not for a site the user wants you to build in code, a design you worked out together, or an app: call \`StartHeadlessBuild\`.
-
-    When calling this tool, infer \`customActions\` from the user's request so the reply can be tailored — 2-3 concrete, industry-specific setup actions for the site (see the input's guidance).
-
-    After calling, you MUST speak the message provided in the tool result to the user as your reply — do not stay silent and do not replace it with a one-line pointer to the widget. Write out ALL of it, word for word: its opening line (the "Ready to set up your … site?" question INCLUDING "Choose your path in the widget above:"), BOTH of its option bullets, and its "Next up:" line, each on its own line and in that order. Do not summarize, shorten, drop any line, invent your own opener, rename the options, or add an intro or outro.
+    Returns which Wix tool creates a new site, and creates nothing itself. A new site is written in code and uploaded: StartDeployWebsite returns the upload guide, and StartHeadlessBuild returns the guide for a site that needs Wix business features. Use WixHarmonyEditorBuild or SearchSiteTemplates only when the user asked for Wix's editor, a template, Wix Studio or the Classic Editor.
   `,
     "import-claude-design-from-url": dedent_default`
     Import a design created in Claude's design tool into Wix. Only for the signed \`claudeusercontent.com\` bundle URL Claude Design's "Send to Wix" produces (a self-contained HTML bundle with all images, fonts, and styles inlined). Creates a live Wix-hosted site and returns its URL.
@@ -72108,6 +72322,13 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
   `,
     SearchWixWDSDocumentation: dedent_default`
     Searches the Wix Design System (WDS) documentation.
+  `,
+    SearchWixHelpCenter: dedent_default`
+    Searches the Wix Help Center (support.wix.com): how site owners do things in the Wix dashboard and editors, such as connecting a domain, managing a Premium plan, setting up a store or bookings, and fixing account or site issues.
+    ${HELP_CENTER_IS_FOR_PEOPLE}
+    Use it for "how do I ... in Wix" questions about the product, or to give the user click-by-click steps for something no API covers.
+    Not for building with code: for Wix APIs, SDK, CLI, apps, or Headless, use the matching developer documentation search.
+    Results are excerpts; read a full article by passing its support.wix.com link to \`ReadFullDocsArticle\`.
   `,
     SearchWixSDKDocumentation: dedent_default`
     Searches the Wix JavaScript SDK documentation.
@@ -72118,7 +72339,7 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
   `,
     SearchDevelopmentDocumentation: dedent_default`
     Broad Wix development documentation (platform concepts, developer guides, getting started). **Last resort — development tasks only.**
-    Skip it entirely for general, business, support, or Wix-editor questions.
+    Skip it entirely for general, business, support, or Wix-editor questions; for those, use \`SearchWixHelpCenter\`.
     Call it only after the specific search for your task returned nothing useful: \`SearchWixRESTDocumentation\` (REST), \`SearchWixSDKDocumentation\` (JS SDK), \`SearchWixCLIDocumentation\` (CLI), \`SearchBuildAppsDocumentation\` (apps), \`SearchWixHeadlessDocumentation\` (Headless), \`SearchWixWDSDocumentation\` (WDS). Never use it as a first search.
   `,
     SearchWixHeadlessDocumentation: dedent_default`
@@ -72130,7 +72351,8 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     // `sdk` is simply absent on methods the SDK docs don't list.
     SearchWixAPISpec: dedent_default`
     Inspect the Wix REST API spec, and the JavaScript SDK call for each method, by writing JavaScript code that runs in a sandboxed read-only environment.
-    **Precondition:** you already have a method \`docsUrl\` — from \`SearchWixRESTDocumentation\`, \`SearchWixSDKDocumentation\` (its \`?apiView=SDK\` URLs work here as-is), \`BrowseWixRESTDocsMenu\`, \`ReadFullDocsArticle\`, ${includeReadme ? "a `WixREADME` recipe, " : ""}or a prior tool result / the user's message in this conversation. If you don't have one yet, call \`SearchWixRESTDocumentation\` (or \`SearchWixSDKDocumentation\` when writing SDK code) FIRST to discover it; do not use this tool to search for or choose an endpoint.
+    The spec covers every Wix product's methods and their data: ${WIX_API_DATA}.
+    **Precondition:** you already have a method \`docsUrl\` — from \`SearchWixRESTDocumentation\`, \`SearchWixSDKDocumentation\` (its \`?apiView=SDK\` URLs work here as-is), \`BrowseWixRESTDocsMenu\`, \`ReadFullDocsArticle\`, ${includeReadme ? "a Wix skill, " : ""}or a prior tool result / the user's message in this conversation. If you don't have one yet, call \`SearchWixRESTDocumentation\` (or \`SearchWixSDKDocumentation\` when writing SDK code) FIRST to discover it; do not use this tool to search for or choose an endpoint.
     **Never pass a \`docsUrl\` you produced from memory.** If the exact URL you are about to pass to \`getResourceSchemaByUrl\` did not appear verbatim in an earlier tool result (or the user's message), it is a guess — call \`SearchWixRESTDocumentation\` first and use a URL from its ranked results. A guessed URL that merely looks plausible routinely resolves to the WRONG sibling method (e.g. \`.../products-v3/create-product\` when the task needs \`.../products-v3/create-product-with-inventory\`), sending the whole turn down a dead end. When in doubt, discover — don't guess.
     **This tool's job is to INSPECT the exact schema of a method you have ALREADY located — its request/response shape, nested types, and enums, and its SDK call (\`method.sdk\`). It is NOT a discovery tool for choosing which method to use.**
     With a method \`docsUrl\` in hand, call \`getResourceSchemaByUrl(methodDocsUrl)\` to get the resource schema, then read the target method from \`schema.methods\` and resolve any nested \`{ $circular: name }\` types via \`schema.components.schemas[name]\`.
@@ -72511,27 +72733,18 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     \`\`\`
   `,
     ExecuteWixAPI: executeWixApiDescription,
-    WixSiteBuilder: dedent_default`
-    ${SITE_GUIDANCE}
-
-    Tool for generating a Wix site with AI (creating / building a site in Wix Harmony) from a description. It does not take pages or files you already have — those go to StartDeployWebsite.
-
-    Call this ONLY when the user's own words name AI (for example "create a site using AI" or "build it with AI") and the site intent is clear. A description of what the site should do — reservations, online ordering, a store, bookings, menus, a portfolio, and the like — is NOT a request for AI and NOT enough to call this tool; never infer AI from features or industry.
-    Never default to this tool: if the user hasn't explicitly named AI, don't call this tool — ${SITE_CREATION_COPY.unstatedMethod.nonWidget}.
-
-    For templates or Wix Studio, call \`SearchSiteTemplates\` (\`builder: classic\` for the Classic Editor); for a template id, \`CreateSiteFromTemplate\`. A site the user wants you to build in code, or an app: \`StartHeadlessBuild\`.
-
-    Do NOT suggest HTML code, prompt templates, or alternative approaches instead of building — actually build the site through this tool. (HTML the user already has is the StartDeployWebsite case, not a reason to build.)
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
+    WixHarmonyEditorBuild: dedent_default`
+    A secondary site-creation tool, only for a user who asked for the Wix Harmony Editor or for Wix to design the site in Wix's editor. A request for a site on Wix, or for Wix to build or make one, is neither. Don't call it for any other site request, not even to check with the flag false. A new site is otherwise written in code and uploaded, with StartDeployWebsite, or StartHeadlessBuild when it needs Wix business features.
+    Builds a site with the Wix Harmony Editor: Wix designs a first version from the user's description, and the user keeps designing it in Wix's editor. Shows the build's progress and a preview.
+    Call it when the user asked for the Wix Harmony Editor, or for Wix to design the site in Wix's editor, in their own words or as their answer to your question, and quote those words in \`editorRequest\`. ${EDITOR_TAIL}
   `,
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
     SearchSiteTemplates: dedent_default`
-    ${SITE_GUIDANCE}
-
-    Searches Wix templates and shows the template gallery, from the Harmony, the Studio or the Classic Editor template source.
-
-    Call this ONLY when the user's own words ask for a template, for Wix Studio or for the Classic Editor (for example "start from a template", "show me some templates", "build it in Wix Studio", "the old Wix editor") and you can already tell what the site is for. If they mention Wix Studio, search Studio templates; if they ask for the Classic Editor (the Wix Editor), search \`classic\`; otherwise search Harmony templates.
-    ${SITE_CREATION_COPY.templatePick.nonWidget}
-
-    A description of what the site should do — bookings, a store, a menu, a portfolio, and the like — is NOT a request for templates or for Wix Studio; never infer either from features or industry. Templates are not the default: if the site intent is clear but no method is named, do not guess — ${SITE_CREATION_COPY.unstatedMethod.nonWidget}.`,
+    A secondary site-creation tool, only for a user who asked for a template, Wix Studio or the Classic Editor. Don't call it for any other site request, not even to check with the flag false. A new site is otherwise written in code and uploaded, with StartDeployWebsite, or StartHeadlessBuild when it needs Wix business features.
+    Shows a gallery of Wix templates, from Harmony, Wix Studio or the Classic Editor, for a site the user will design in Wix's editor. Wix templates come with Wix's business features (a store, online ordering, bookings, forms), so a request for a template comes here even when the site needs them.
+    Call it when the user asked for a template, Wix Studio or the Classic Editor, in their own words or as their answer to your question, and quote those words in \`templateRequest\`. ${EDITOR_TAIL} ${SITE_CREATION_COPY.templatePick.nonWidget}
+  `,
     CreateSiteFromTemplate: dedent_default`
     Creates a Wix site from a specific template (by \`metaSiteId\` or \`templateId\`), publishes it when possible, and shows a live preview with links to the editor and the published site.
 
@@ -72565,103 +72778,212 @@ function buildToolDescriptions(includeReadme, includeImageUploadGuidance = true)
     Set \`hasMutations: true\` for any document containing a mutation root field.
   `,
     UploadHeadlessWebsiteFiles: dedent_default`
-    The upload step of the StartDeployWebsite and StartHeadlessBuild guides, and nothing else: puts a finished static website's files — index.html plus its CSS/JS/images, a static build, or a zip of the site — onto an existing Wix Headless site by its metaSiteId. Call it ONLY after one of them has returned its guide in this conversation and the site exists: for a new site, first run the recipe's provision call and pass the metaSiteId it returns; for a site deployed earlier, pass its metaSiteId. It does not create sites. Every upload replaces the whole file set and the URL stays. Returns the live URL and the dashboard link, and points back to the recipe for what comes next.
-    Pass the files themselves: in ChatGPT as \`attachments\` (any type, a zip is unpacked), elsewhere as the \`files\` text bundle (\`=== FILE: <path> ===\` sections, \`base64\` tag for small binaries). The site must contain index.html at its root.
-    NOT a site-creation tool: a request to create, build, design or generate a site — with or without a description — never comes here (those are the site-creation tools, after their own questions). Also NOT for media uploads to an existing site (UploadImageToWixSite) or any other API call (ExecuteWixAPI).
+    The upload step of the StartDeployWebsite and StartHeadlessBuild guides, and nothing else: puts a finished website's files — a static site (index.html plus its CSS/JS/images, a static build, or a zip of the site) or a Wix Astro build — onto an existing Wix Headless site by its metaSiteId. Call it ONLY after one of them has returned its guide in this conversation and the site exists: for a new site, first run the recipe's provision call and pass the metaSiteId it returns; for a site deployed earlier, pass its metaSiteId. It does not create sites. Every upload replaces the whole file set and the URL stays. Returns the live URL and the dashboard link, and points back to the recipe for what comes next.
+    Pass the files themselves: in ${FILE_PARAM_CLIENTS} as \`attachments\` (any type, a zip is unpacked), elsewhere as the \`files\` text bundle (\`=== FILE: <path> ===\` sections, \`base64\` tag for small binaries). A static site must contain index.html at its root. A Wix Astro build with no file handle, from a shell that reaches the internet, goes in two calls: zip the build, call with \`prepare: true\` and the zip's \`size\` in bytes, PUT the zips it names with the \`curl\` commands it returns (the build, and the project source when the site's repository accepts it), then call again with the \`uploadKey\` it returned; that releases the build. The two calls, literally: {siteId, prepare: true, size} then {siteId, uploadKey, sourceUploadId?, expectedHeadRevisionId?, releaseNotes?}. A sandbox whose network is limited to a few hosts cannot upload to those URLs. A static site does not use the two calls. A Wix Astro build (the project's .wix/ and dist/ after \`astro build\` with the Wix hosting adapter, zipped from the project root) needs no index.html: it is released to the site's Wix hosting instead, server-rendered pages, the same site and URL. The project's source is stored with the release when the upload holds the project and the site's repository accepts it.
+    NOT a site-creation tool: a request to create, build, design or generate a site — with or without a description — never comes here first. Unless the user asked for Wix's editor or a template (WixHarmonyEditorBuild, SearchSiteTemplates), call StartDeployWebsite right away, without asking the user anything: it also takes files the user brought, uploaded first even when the site needs business features. StartHeadlessBuild instead for a new site with no files that needs Wix business features. Also NOT for media uploads to an existing site (UploadImageToWixSite) or any other API call (ExecuteWixAPI).
   `,
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
     StartDeployWebsite: dedent_default`
-    The user — or you, earlier in this conversation — ALREADY HAVE a finished page or site, in any form, and it should be live on Wix — or an already-deployed Wix Headless site whose files should be replaced. The site can be HTML/CSS/JS files, a static build (dist/, out/), a zip, another AI builder's export, or a page/design you created in this conversation (export it to HTML first — a finished design IS a finished page). Call this when the user says deploy, host, put online, make it live, get a URL, upload my site / index.html, or wants to update or redeploy the files of a site you or the user deployed as code.
-    Updates keep the same site and URL. Also for implementing a backend on such a site as a Wix Headless project — same site, same URL. Works with or without a Wix login (anonymous deploy with a save link), through the Wix MCP alone or from a shell.
-    Missing real functionality — a fake checkout, a form that goes nowhere, bookings — is NOT a reason to rebuild the site with a site-creation tool: deploy the page as is, then add the backend afterwards (the recipe covers it).
-    Returns the full recipe; follow it and run the flow yourself. When the UploadHeadlessWebsiteFiles tool is available, use it for the recipe's upload step — after the site exists (the recipe's provision call, or a metaSiteId from an earlier deploy) — instead of building the multipart body in code; never before this tool. The drop page is only the fallback when you can't.
-    NOT for: a screenshot or reference of a site the user wants Wix to generate (the site-creation tools); a site described in words with no code yet (StartHeadlessBuild); a Wix editor site's content or settings (WixSiteBuilder's edit mode, or WixREADME); a Claude Design bundle URL (import-claude-design-from-url); migrating a live site by URL or CSV exports; adding HTML or code into an existing Wix site; uploading images or documents to a site's media (UploadImageToWixSite).
+    Creates a website on Wix and puts it live, or replaces the files of one deployed earlier. You write the site's code, or take the files the user brought (HTML/CSS/JS, a static build, a zip, another builder's export), and this returns the guide to create the site and upload them. Updates keep the same site and URL. Works with or without a Wix login (anonymous deploy with a save link), through the Wix MCP alone or from a shell. Call it right away, without asking the user anything first.
+    When a new site needs Wix business features (${WIX_BUSINESS_FEATURES}), call StartHeadlessBuild instead. When the user brought files and the site needs those features, upload the files here first; the upload's result then points to StartHeadlessBuild to connect them.
+    Returns the guide; follow it and do the work yourself. Upload with UploadHeadlessWebsiteFiles once the site exists; the drop page is only the fallback.
+    NOT for: a user who asked for Wix's editor, the Wix Harmony Editor, a template, Wix Studio or the Classic Editor (WixHarmonyEditorBuild, SearchSiteTemplates); a Claude Design bundle URL (import-claude-design-from-url); migrating a live site by URL or CSV exports; adding HTML or code into an existing Wix editor site; uploading images or documents to a site's media (UploadImageToWixSite).
   `,
+    // Named in SERVER_INSTRUCTIONS: when this tool's name or what it is for changes, update them to match.
     StartHeadlessBuild: dedent_default`
-    The user wants a site or web app that you build and keep changing in code, here with them, and no code exists yet. Wix runs its business side (store, bookings, CMS, forms, members, payments) as a Wix Headless site. Call this when the user asks you to build it yourself rather than Wix's AI or a template; when the two of you worked out a design in this conversation and nothing is coded yet; when it is an app (a game, a dashboard, a tool); when the user asks for a headless site; when a prompt links \`wix.com/headless/skill.md\` or a project's \`download.zip\`; or to move a Wix site to code.
-    Call it right away: it only returns the guide, and the site's purpose is not needed first (pass "not stated yet" for what you don't know). Returns the full guide; follow it and do the work yourself, choosing its route by what you can reach (a shell that reaches Wix, or this MCP alone).
-    NOT for: files, a build, a zip or a page that already exist (StartDeployWebsite); a site the user will design in Wix's editor (the site-creation tools); a Claude Design URL (import-claude-design-from-url).
+    Returns Wix's headless guide, for a site that needs Wix business features (${WIX_BUSINESS_FEATURES}), run by Wix as a Wix Headless site. You write the site; the guide creates it, connects the features, and uploads it. Also to add those features to an existing Wix Headless site (one deployed from files is one), from a project download link, or to move a Wix site to code.
+    Call it right away: it only returns the guide, and the site's details are not needed first.
+    NOT for: a site that needs no Wix business feature, or files the user brought that are not live yet (StartDeployWebsite: upload them first, then come back here for the features); a user who asked for Wix's editor, the Wix Harmony Editor, a template, Wix Studio or the Classic Editor, even when the site needs business features (WixHarmonyEditorBuild, SearchSiteTemplates); a Claude Design URL (import-claude-design-from-url).
   `
   };
-}
-var defaultToolDescriptions = buildToolDescriptions(true);
+  descriptions.SupportAndFeedback = descriptions.ReportIssueToWix;
+  return descriptions;
+}
+var defaultToolDescriptions = buildToolDescriptions(true, true, { usageGuideOnce: true });
+var WIX_SKILLS_README_SECTION = dedent_default`
+  ## Wix skills
+
+  Wix publishes agent skills: folders of instructions, scripts and shipped code for building on Wix, each with a \`SKILL.md\` at its root that says what the skill does and which of its files to read when. The source is https://github.com/wix/skills. Three of them matter here:
+
+  - **wix-headless-kit**: builds a Wix Headless site on shipped, verified code. In the Wix plugin. Its contents are below.
+  - **wix-headless-templates**: the code wix-headless-kit builds from, one folder per Wix Business Solution. In the Wix plugin for Codex and Cursor. Its contents are below.
+  - **wix-manage**: REST recipes to configure and manage a site's business solutions. In the Wix plugin. Its \`SKILL.md\` is the index of every recipe by area, with what it does and a link to read it.
+
+  On a site built in code (one deployed through StartDeployWebsite, started through StartHeadlessBuild, or any Wix Headless project), wix-headless-kit carries the work, with wix-headless-templates as its code, and it names the wix-manage recipes it uses as steps.
+
+  ### How to read a skill
+
+  A skill is a folder, and every file in it has a path inside that folder (\`SKILL.md\`, \`guides/api-run.md\`). The same path finds the file on disk and online, so the paths below work either way.
+
+  1. **From disk, when it is already there.** This is the preferred way: the files are complete and need no network. The Wix plugin loads its skills into the client; \`npx skills add\` puts them under \`.agents/skills/<skill>/\` in the project, or in the user's home with \`-g\`; an earlier install may have left them wherever the client keeps skills (for example \`.claude/skills/\` or the plugin's folder). Open \`<skill folder>/SKILL.md\` and the files it names. An installed copy can be an older snapshot. A file whose byte size differs from the one in the skill's manifest (below) is out of date, so read it online; a matching size makes a file likely current, not certain, so when a file decides the work, read it online too.
+  2. **Install them, with a shell that reaches the internet.** \`npx skills add wix/skills\` installs every skill; \`npx skills add wix/skills --skill wix-headless-kit\` installs one. Then read them from disk. To keep them across projects, the user can install the Wix plugin instead (in Claude Code: \`/plugin marketplace add wix/skills\`, then \`/plugin install wix@wix\`).
+  3. **Read them online, with ReadFullDocsArticle**, when neither works: no shell, or a sandbox without internet. Call ReadFullDocsArticle with the URL as \`articleUrl\`; it returns the file whole, where a client's own web tool often cannot reach www.wix.com or summarizes what it fetches. The skills registry mirrors every skill from the main branch of wix/skills:
+     - **A file**: \`https://www.wix.com/skills/<skill>/<path>\`, with \`<path>\` its path inside the skill folder. Start with \`<path>\` = \`SKILL.md\`, then read the files it names.
+     - **A folder**: \`https://www.wix.com/skills/<skill>/<folder>\` returns the full URL of every file under it, at any depth. \`https://www.wix.com/skills/<skill>/<folder>/_content\` returns those files' contents in one response, each under a heading with its URL, Markdown first; binary files and lockfiles are left out, and past 150K characters the rest are named by URL, to read one by one.
+     - **The skill's file list**: \`https://www.wix.com/skills/<skill>/\`, with the trailing slash, returns the full URL of every file in the skill; without the slash it returns the SKILL.md.
+     - **Every file in the skill**: \`https://www.wix.com/skills/<skill>.manifest.json\` lists each path with its size, under a \`base\` URL.
+     - **Names and hosts**: \`<skill>\` is the folder name with or without its \`wix-\` prefix (\`wix-headless-kit\` or \`headless-kit\`), and \`dev.wix.com\` works in place of \`www.wix.com\`.
+     - **What comes back**: a Markdown file comes with a short note on top (it is mirrored from the main branch of wix/skills; the skill's manifest, folder listings, \`_content\`, and ReadFullDocsArticle) and its relative links turned into full URLs; code, scripts and JSON come as they are.
+     - **A wrong path**: the answer names the files with that name elsewhere in the skill and the manifest URL, so one more call reaches the right file. ReadFullDocsArticle shows that answer as an error.
+     - **Not served**: a whole skill as one page (\`<skill>-full\`) returns 404; read the skill's files instead.
+
+     The wix-manage recipes are also published in the Wix docs, as articles at \`…/skills/<recipe>\` under each API's section. Find the one that matches the task in the skill's recipe index (\`SKILL.md\`) or with SearchWixRESTDocumentation, and read it with ReadFullDocsArticle. Only wix-manage is in the docs. For example, one recipe in all three places:
+       - on disk: \`<wix-manage folder>/references/sites/upload-static-site.md\`;
+       - in the registry: https://www.wix.com/skills/manage/references/sites/upload-static-site.md;
+       - in the docs: https://dev.wix.com/docs/api-reference/account-level/sites/skills/upload-a-website-or-html-files.
+
+  ### wix-manage
+
+  REST recipes for managing a site's business solutions: one recipe per task (installing apps, products, booking services, CMS items, SEO, domains and more), each with the exact endpoints, request bodies and order of steps. Open the recipe for a task before calling its APIs.
+
+  Ways to find and read a recipe, in this order:
+  1. **On disk**: the Wix plugin's wix-manage folder, or \`.agents/skills/wix-manage/\` after \`npx skills add wix/skills --skill wix-manage\`. \`SKILL.md\` lists every recipe by area with what it does; the recipe itself is under \`references/<area>/\` (ecommerce nests one more folder, such as \`references/ecommerce/shipping/\`), so open the path \`SKILL.md\` gives rather than building it. An installed copy can be an older snapshot: when a recipe decides the work, read it online too.
+  2. **Online**: the list of every recipe by area, each a link to its docs article, is https://dev.wix.com/docs/api-reference/articles/ai-tools/wix-mcp/skills/wix-management-recipes-index.md. Read it with ReadFullDocsArticle, or with \`curl\` from a shell, then read the recipe for the task the same way. It is public: no sign-in or token.
+
+  Using a recipe: follow its steps, and make its calls with ExecuteWixAPI, passing the recipe's docs URL in \`sourceDocUrls\`. When a recipe's example doesn't fit a call, read that method's schema with SearchWixAPISpec first. When no recipe matches the task, find the method with SearchWixRESTDocumentation or BrowseWixRESTDocsMenu, read it with ReadFullDocsArticle, and call it the same way.
+     Each API area also has a page that lists only its own recipes: the area's docs section with \`/skills.md\` appended. These are the ones today, but it is not a closed list: areas are added, so look a task up in the full list first, and for an API not named here try its section URL with \`/skills.md\` appended.
+     - Accessibility: https://dev.wix.com/docs/api-reference/site/accessibility/skills.md
+     - Analytics: https://dev.wix.com/docs/api-reference/business-management/analytics/skills.md
+     - App Installation: https://dev.wix.com/docs/api-reference/business-management/app-installation/skills.md
+     - App tools: https://dev.wix.com/docs/api-reference/app-management/app-tools/skills.md
+     - Automations: https://dev.wix.com/docs/api-reference/business-management/automations/skills.md
+     - Blog: https://dev.wix.com/docs/api-reference/business-solutions/blog/skills.md
+     - Bookings: https://dev.wix.com/docs/api-reference/business-solutions/bookings/skills.md
+     - Calendar: https://dev.wix.com/docs/api-reference/business-management/calendar/skills.md
+     - CMS: https://dev.wix.com/docs/api-reference/business-solutions/cms/skills.md
+     - Contacts: https://dev.wix.com/docs/api-reference/crm/members-contacts/contacts/skills.md
+     - Domains: https://dev.wix.com/docs/api-reference/account-level/domains/skills.md
+     - eCommerce: https://dev.wix.com/docs/api-reference/business-solutions/e-commerce/skills.md
+     - Events: https://dev.wix.com/docs/api-reference/business-solutions/events/skills.md
+     - Forms: https://dev.wix.com/docs/api-reference/crm/forms/skills.md
+     - Get Paid: https://dev.wix.com/docs/api-reference/business-management/get-paid/skills.md
+     - Google Ads: https://dev.wix.com/docs/api-reference/business-management/marketing/ads/google-ads/skills.md
+     - Google Business Profile: https://dev.wix.com/docs/api-reference/business-management/google-business-profile/skills.md
+     - Google Search Console: https://dev.wix.com/docs/api-reference/business-management/seo/google-search-console/skills.md
+     - Headless: https://dev.wix.com/docs/api-reference/business-management/headless/skills.md
+     - Marketing: https://dev.wix.com/docs/api-reference/business-management/marketing/skills.md
+     - Media: https://dev.wix.com/docs/api-reference/assets/media/skills.md
+     - Pricing Plans: https://dev.wix.com/docs/api-reference/business-solutions/pricing-plans/skills.md
+     - Restaurants: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/skills.md
+     - Rich Content: https://dev.wix.com/docs/api-reference/assets/rich-content/skills.md
+     - SEO: https://dev.wix.com/docs/api-reference/business-management/seo/skills.md
+     - SEO redirects: https://dev.wix.com/docs/api-reference/business-management/seo/redirects/skills.md
+     - Site Properties: https://dev.wix.com/docs/api-reference/business-management/site-properties/skills.md
+     - Sites: https://dev.wix.com/docs/api-reference/account-level/sites/skills.md
+     - Stores: https://dev.wix.com/docs/api-reference/business-solutions/stores/skills.md
+     - Wix MCP: https://dev.wix.com/docs/api-reference/articles/ai-tools/wix-mcp/skills.md
+
+  ### wix-headless-kit
+
+  Builds a Wix Headless site on shipped, verified code instead of writing the integration: each Wix Business Solution comes with a typed data layer, hooks, components, pages and a seed script that are already correct. The data layer ships twice, on \`@wix/sdk\` for the React core and as plain REST calls for a stack that cannot run it (\`guides/reference-mode.md\`), and the agent's work narrows to brand, layout, copy and wiring. It runs as a CLI flow from a shell that reaches Wix, and as Wix API calls through this MCP when it cannot.
+
+  Paths are inside the skill folder; online, each is \`https://www.wix.com/skills/headless-kit/<path>\`.
+  - Before the skill: the cold start installs it, signs in and hands off. It is another skill's file, https://www.wix.com/skills/headless-cold-start/headless-kit.md, and StartHeadlessBuild returns it.
+  - \`SKILL.md\`: the steps of a build and the table of Business Solutions the kit ships.
+  - \`guides/api-run.md\`: the whole run as Wix API calls through this MCP, for an agent whose shell cannot reach Wix or that has no shell.
+  - \`guides/capabilities.md\`: which Wix product owns which feature, and what the kit ships for it.
+  - \`guides/existing-site.md\`: a new frontend for a Wix site that already has its content.
+  - \`guides/migration.md\`: a site moving to code after "Go Headless" in its dashboard.
+  - \`guides/reference-mode.md\`: a stack that cannot run the shipped React code (a static site, a server-rendered app in another language).
+  - \`guides/feedback.md\`: sending the user's building-with-Wix feedback to Wix.
+  - \`install/\`: the bootstrap, setup, deploy and templates scripts, and \`install/pins.json\` with the pinned CLI and templates versions.
+
+  ### wix-headless-templates
+
+  The code wix-headless-kit builds from, one folder per Wix Business Solution: \`storefront\`, \`bookings\`, \`rentals\`, \`blog\`, \`cms\`, \`forms\`, \`members\`, \`events\`, \`restaurants\`, \`donations\`, \`pricing-plans\`, \`portfolio\`, \`faq\`. It holds no flow of its own; wix-headless-kit fetches it and copies, deploys and seeds from it.
+
+  Paths are inside the skill folder; online, each is \`https://www.wix.com/skills/headless-templates/<path>\`. Every Business Solution folder has the same parts, with \`<solution>\` one of the names above:
+  - \`<solution>/INSTRUCTIONS.md\`: the playbook, covering what ships, what you build, and each page's contract.
+  - \`<solution>/app/\`: the typed React core: the data layer under \`wix/<solution>/\`, hooks and components.
+  - \`<solution>/app-astro/\`: the Astro page skeletons for Wix-managed Astro sites (every solution but \`forms\`).
+  - \`<solution>/project/\`: the whole runnable project for that solution.
+  - \`<solution>/rest/\`: the same data layer as plain REST calls, for stacks that cannot run the React core.
+  - \`<solution>/seed/SEED.md\`: how to seed that solution's content, with the script that creates it in the right order.
+
+  Shared by every solution:
+  - \`shared/DESIGN.md\`: the design floor when the brief gives no design direction.
+  - \`shared/CONTENT.md\`: the copy floor for every page written.
+  - \`shared/SUPPLIED-CONTENT.md\`: content the user brings (a CSV, a menu, a folder of photos) as the seed plan.
+  - \`shared/CUSTOM_OPERATIONS.md\`: operations beyond what the shipped code covers.
+  - \`shared/rest/client.ts\`: the REST client the \`rest/\` layers use.
+
+  Online, a solution's folder lists everything it ships: https://www.wix.com/skills/headless-templates/storefront returns the URLs of the store's files, and \`…/storefront/app\` those of its React core. A part is often small enough to read whole in one call: https://www.wix.com/skills/headless-templates/storefront/seed/_content returns the store's seeding guide and scripts together. A whole solution passes the 150K cap, so read it part by part.
+`;
 var recipesIndexDoc = {
   url: "https://dev.wix.com/docs/api-reference/articles/ai-tools/wix-mcp/skills/wix-management-recipes-index",
   action: "include"
 };
 var README_INTRO = dedent_default`
-  <wix-usage-guide>
+  # How to work with Wix through these tools
 
-  How to work with Wix through these tools:
+  ## Source of truth
 
-  <source-of-truth>
-  Do not answer from memory about anything Wix-specific — this covers every part of your answer, not only API calls: any URL, link, ID, setting location, or product fact you give the user must come from the docs tools, the recipes below, a previous tool result in this conversation, or the user's own message (identifiers and URLs the user supplies are fine to use as given). If a recipe in the index below matches what the user asked for, read it before answering. For APIs, use the search, browse, read-docs, and schema tools as the source of truth for the exact URL, HTTP method, request body shape, response shape, field names, required fields, and enum values before calling an API.
-  </source-of-truth>
+  Do not answer from memory about anything Wix-specific — this covers every part of your answer, not only API calls: any URL, link, ID, setting location, or product fact you give the user must come from the docs tools, a Wix skill (installed, or read online as the Wix skills section below explains), a previous tool result in this conversation, or the user's own message (identifiers and URLs the user supplies are fine to use as given). When a Wix skill covers what the user asked for, read it before answering. For APIs, use the search, browse, read-docs, and schema tools as the source of truth for the exact URL, HTTP method, request body shape, response shape, field names, required fields, and enum values before calling an API.
 
-  <management-flow>
-  <goal>
+  ## Goal
 `;
-var README_FLOWS_HEADING = dedent_default`
-  </goal>
+var README_FLOWS_HEADING = "## Wix MCP Flows";
+var README_FLOWS_SITE = dedent_default`
+      ### The site
 
-  ## Wix MCP Site Management Flows
+      The site context below lists the account's sites with their installed apps. Take the \`siteId\` from there; when more than one site fits and the user's words don't pick one, ask which before any read or write. A business solution's API (Stores, Bookings, CMS and the rest) works only on a site with that app installed, and some apps have versions with different endpoints (Wix Stores V1 vs V3): check the site's apps first, and when the app is missing, install it (a Wix skill has the steps) before using its API.
 `;
-var README_BODY = dedent_default`
-      ### Discovery & Call Flow
+var README_FIND_SOURCES = dedent_default`
+  ### Find the method
 
-      Common paths (use the highest you can satisfy for each method you'll call):
-      - Already have what you need from previous tool results in this conversation (not from memory) → ExecuteWixAPI
-      - Pick a matching article from the Recipes index below → ReadFullDocsArticle (find relevant code examples) → (probe SearchWixAPISpec for response shapes if needed) → ExecuteWixAPI
-      - SearchWixRESTDocumentation or BrowseWixRESTDocsMenu → ReadFullDocsArticle (find relevant code examples) → (probe SearchWixAPISpec for response shapes if needed) → ExecuteWixAPI
-      - SearchWixRESTDocumentation or BrowseWixRESTDocsMenu → ReadFullDocsArticle (no usable example) → SearchWixAPISpec for request schemas → ExecuteWixAPI
+  A task may need several API methods. For each, take the first source that gives it:
+  - A previous tool result in this conversation (not memory) already shows its request: go straight to the call.
+  - A Wix skill that covers the task (the Wix skills section below says what each is for): follow it, from disk or online. When its example for a call matches your case, that is the source: pass its docs URL in \`sourceDocUrls\` instead of searching for the method pages (when it has no docs URL, one SearchWixRESTDocumentation call on its title finds the article).
+  - The docs: SearchWixRESTDocumentation (semantic search) or BrowseWixRESTDocsMenu (menu hierarchy), then ReadFullDocsArticle on the method's article for its code examples. For SDK code, the CLI, a headless site or an app, start from those docs instead: SearchWixSDKDocumentation, SearchWixCLIDocumentation, SearchWixHeadlessDocumentation, SearchBuildAppsDocumentation.
 
-      Fallbacks: use ReadFullDocsMethodSchema in place of SearchWixAPISpec when SearchWixAPISpec is unavailable or didn't return enough detail; use CallWixSiteAPI in place of ExecuteWixAPI when a single REST call is enough and code adds no value.
+  Keep each method's docs URL even when no source gives a usable example: the shape comes from its schema, as the next section says.
+`;
+var README_FLOWS_BODY = dedent_default`
+      ### The exact shape
 
-      Tools (relevant for the management flow):
-      - SearchWixRESTDocumentation — semantic search over the Wix REST docs by keywords or natural-language queries.
-      - BrowseWixRESTDocsMenu — navigate the Wix REST docs by menu hierarchy; alternative to keyword search.
-      - ReadFullDocsArticle — fetch a full docs article by its docs URL; returns prose, fields, and code examples.
-      - SearchWixAPISpec — JS-sandboxed query over the REST API spec; returns request schema, response schema, and the executable \`method.publicUrl\`.
-      - ExecuteWixAPI — runs an async JS function in a sandbox with \`wix.request()\`; a single invocation can chain multiple API calls, paginate, loop, transform, and branch.
+      A code example is the model for your call only when it matches your case, with every field your case needs. Fill the rest from the method's schema: SearchWixAPISpec on its docs URL (REST or SDK) returns the request and response schemas, \`method.publicUrl\` and \`method.sdk\`; ReadFullDocsMethodSchema when SearchWixAPISpec isn't available. A query's filter and sort fields and operators are a closed list per method: use only what its schema declares.
 
-      Steps:
+      None of this comes from memory.
 
-      1. A single user task may need one or more API methods. For each method you'll call, find a code example that fits the user's intent — you'll model the API call (URL, method, body) on it. An example only "fits" if it is **complete** (not truncated) AND matches your exact case — same operation and same variant/shape (e.g. the same \`productType\`), with every field your case needs actually shown. **If the closest example is truncated (it shows a \`... N more lines ...\` marker), do NOT call the API off it; continue discovery first: \`ReadFullDocsArticle\` for the complete example, or \`SearchWixAPISpec\` for the exact request schema.** Never fill in required fields from memory. Skip this step for any method you already have from a previous tool result in this conversation (not from memory):
-         a. First try the WixREADME Recipes index below (pre-curated guides for common tasks). If a recipe matches, ReadFullDocsArticle on its docs URL to find relevant code examples; many recipes cover multi-step flows and supply code examples for several methods in one article.
-         b. If no recipe matches the user's intent, or the matched recipe didn't yield the code examples you need, discover each missing method's docs URL via SearchWixRESTDocumentation (semantic search) or BrowseWixRESTDocsMenu (menu hierarchy), then ReadFullDocsArticle on each to find relevant code examples.
-         c. If neither path turns up a usable code example for some method, continue without one for that method — step 2 will derive its request directly from the schema. Make sure you've still captured the docs URL of each method.
+      ### The call, or the code that makes it
 
-      2. Before calling, fill any remaining gaps with SearchWixAPISpec on each method's docs URL. It returns both request and response schemas. For each method, check:
-         - **Request** (URL, HTTP method, body fields) — skip the probe if a code example already shows them; otherwise SearchWixAPISpec returns publicUrl + exact request shape.
-         - **Response shape** (field paths your code will read) — only relevant if your code reads response fields; skip the probe if the article(s) already made it clear; otherwise probe SearchWixAPISpec for the response schema.
-         - **Filter and sort** (query/search methods only) — an example proves only the fields and operators it uses. Each method declares which fields it can filter and sort by, and with which operators; that list is closed for fields and their operators and covers that method only — \`$and\`/\`$or\`/\`$not\` are filter syntax and never appear in it. Anything else errors or silently returns the wrong rows. A listed operator is valid on its own, since a field takes a single operator; to combine conditions, use the logical operators instead — \`$and\` and \`$or\` take an array of expressions, \`$not\` takes one, and they can nest.
-         - Never guess any of this from memory.
+      **Call it with ExecuteWixAPI**: one async JS function with \`wix.request()\`, holding every step of the task that code can resolve. The reads that fetch an ID, check whether a record exists or list items to choose from go in the same function as the writes they feed; step numbers in a guide or skill give logical order, not separate calls. Set \`hasMutations: true\` when any step writes. Return the write's response as is and report from it; don't read again to confirm. A new invocation only for what code can't resolve: the user's answer, or a job that finishes later. One function chains calls, paginates, lists all, loops, transforms and branches. Without ExecuteWixAPI, make each call with CallWixSiteAPI (a site's APIs) or ManageWixSite (the account's), from the same exact shape.
 
-      3. Before calling: collapse ALL planned steps — preliminary reads AND mutations — into a single async function. Step numbers in any guide or skill doc describe logical order for human comprehension — they do NOT define invocation boundaries. Steps that feed into each other belong in a single invocation: read, use the result, write, and return. A read that fetches IDs or checks existence before a create/update is part of that mutation's invocation, not a separate preceding call. This includes any read whose result feeds directly into a subsequent write — fetching a required ID, checking whether a record already exists, listing items to choose one — all belong in the same invocation as the write that follows. Set hasMutations: true whenever any step in the function writes. Return the mutation response directly — do not follow up with a read to confirm what was just created or updated; trust the response. Only split into multiple invocations when a later step genuinely depends on information you cannot resolve in code (e.g. a user decision or an out-of-band event). A single invocation can chain several related calls, paginate, "list all", loop, transform, and branch on responses.
+      **Write the code** when the task is code the user keeps: an app (built and run with the Wix CLI), a headless site, or a script that calls the REST API or the JavaScript SDK. The path is the same: find the method, learn its exact shape, then write the call from \`method.publicUrl\` (REST) or \`method.sdk\` (the JavaScript SDK), never from memory. Every way of building against Wix in code is this path; the headless skills are a shortcut on it, not a different one. wix-headless-kit builds a Wix Headless site from shipped, verified code (wix-headless-templates holds it, one folder per business solution: a \`@wix/sdk\` React core, and the same data layer as plain REST calls for a stack that cannot run it): scaffold with the CLI, deploy, seed, design the presentation on the shipped code, release. What no shipped solution covers is written from the docs, as above. A new site is written in code and uploaded: StartDeployWebsite returns the upload guide (create the site, upload its files, change them later); StartHeadlessBuild returns the headless guide, for a site that needs Wix business features: you write the site, and the guide creates it, connects the features and uploads it, through the cold start that hands off to the kit (or the same run as API calls when there is no shell).
 
-      </management-flow>
+      ### When a call fails
 
-      <other-uses>
-      Beyond managing user sites, the Wix MCP tools can be used for any other purpose they support — for example, reading Wix SDK docs to write code against the SDK, using the Wix CLI to create apps, answering documentation questions, and so on.
-      </other-uses>
-      </wix-usage-guide>
+      The error carries the failed call's status and message and a Wix request id. Read it: it says what was wrong, and that is what to fix before calling again, whether the request (from the schema), the site and what is installed on it, or what the account is allowed to do. Never resend the same request unchanged, and never guess a fix. When you report the failure to the user, include the request id.
 `;
-var defaultReadmeDocs = [
-  {
-    action: "text",
-    content: [
-      README_INTRO,
-      AGENT_GOAL,
-      README_FLOWS_HEADING,
-      "",
-      README_BODY
-    ].join("\n")
-  },
-  recipesIndexDoc
-];
+function buildReadmeDocs({
+  recipesIndex = true
+} = {}) {
+  return [
+    {
+      action: "text",
+      content: [
+        README_INTRO,
+        "",
+        AGENT_GOAL,
+        "",
+        README_FLOWS_HEADING,
+        "",
+        README_FLOWS_SITE,
+        "",
+        README_FIND_SOURCES,
+        "",
+        README_FLOWS_BODY
+      ].join("\n")
+    },
+    { action: "text", content: WIX_SKILLS_README_SECTION },
+    ...recipesIndex ? [recipesIndexDoc] : []
+  ];
+}
+var defaultReadmeDocs = buildReadmeDocs();
 var widgetSiteCreationConfig = {
   toolDescriptions: Object.fromEntries(
     [
-      "WixSiteBuilder",
+      "WixHarmonyEditorBuild",
       "WixSiteCreation",
       "SearchSiteTemplates",
       "CreateSiteFromTemplate"
@@ -72808,6 +73130,9 @@ function renderApps(apps, knownApps) {
     if (app.catalogVersion) {
       line += ` \u2014 Catalog app version: **${app.catalogVersion}**`;
     }
+    if (app.invoicesVersion) {
+      line += ` \u2014 Invoices app version: **${app.invoicesVersion}**`;
+    }
     lines.push(line);
   }
   return lines.join("\n");
@@ -72828,6 +73153,11 @@ function renderCustomAppsWithSkillsTools(apps) {
   }
   return lines.join("\n");
 }
+function renderCompanionApp(installedApps) {
+  const appId = installedApps.find((app) => app.companionApp === true)?.appId;
+  if (!appId || !GUID_PATTERN.test(appId)) return "";
+  return `The site's code lives in its companion app (ID: \`${appId}\`).`;
+}
 function renderProperties(props) {
   const sections = [];
   const regionalFormat = [];
@@ -72854,7 +73184,7 @@ ${contact.join("\n")}`);
   }
   return sections.join("\n\n");
 }
-function renderSite(site, index, knownApps) {
+function renderSite(site, index, knownApps, includeCompanionApp) {
   const lines = [];
   const heading = site.displayName ?? `Site ${index}`;
   lines.push(`## ${index}. ${heading}`);
@@ -72899,6 +73229,13 @@ function renderSite(site, index, knownApps) {
     lines.push("");
     lines.push(customAppsWithSkillsToolsContent);
   }
+  const companionAppContent = includeCompanionApp ? renderCompanionApp(site.installedApps ?? []) : "";
+  if (companionAppContent) {
+    lines.push("");
+    lines.push("### Site code (companion app)");
+    lines.push("");
+    lines.push(companionAppContent);
+  }
   lines.push("");
   lines.push("---");
   lines.push("");
@@ -72918,6 +73255,7 @@ function enrichDynamicContext(data, knownApps = {}, options = {}) {
   const response = snakeToCamel(parsed);
   const includePartnerContext = options.includePartnerContext ?? false;
   const includeAccountContext = options.includeAccountContext ?? false;
+  const includeCompanionApp = options.includeCompanionApp ?? false;
   const sections = [];
   const allSites = response.sites ?? [];
   const maxSites = options.maxSites ?? Infinity;
@@ -72970,9 +73308,18 @@ function enrichDynamicContext(data, knownApps = {}, options = {}) {
     );
     sections.push("");
   }
+  const hasInvoicesVersion = sitesToRender.some(
+    (site) => site.installedApps?.some((app) => app.appId && knownApps[app.appId] && app.invoicesVersion)
+  );
+  if (hasInvoicesVersion) {
+    sections.push(
+      "> **Wix Invoices \u2014 Version**: Some sites below have Wix Invoices installed and show their Invoices version (V1/V2). When working on an Invoices task, check the version for that site \u2014 only read recipes and call endpoints that match its version. Never use an Invoices V2 skill or API on a V1 site, and vice versa."
+    );
+    sections.push("");
+  }
   if (sitesToRender.length) {
     for (let i2 = 0; i2 < sitesToRender.length; i2++) {
-      sections.push(renderSite(sitesToRender[i2], i2 + 1, knownApps));
+      sections.push(renderSite(sitesToRender[i2], i2 + 1, knownApps, includeCompanionApp));
     }
   }
   if (!response.account && !siteCount && (!includePartnerContext || !hasPartnerContext(response.partnerContext))) {
@@ -72980,9 +73327,11 @@ function enrichDynamicContext(data, knownApps = {}, options = {}) {
   }
   return sections.join("\n");
 }
+var GUID_PATTERN;
 var init_enrich = __esm2({
   "src/enrich.ts"() {
     "use strict";
+    GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   }
 });
 init_enrich();
@@ -73045,6 +73394,7 @@ async function getDynamicContext(auth, httpClient, filter, options) {
   } : options;
   const includePartnerContext = contextOptions?.partnerContextEnabled ?? true;
   const includeAccountContext = contextOptions?.includeAccountContext ?? true;
+  const includeCompanionApp = contextOptions?.includeCompanionApp ?? false;
   try {
     const accountHeaders = await auth.getAccountAuthHeaders();
     const noFilter = !filter?.siteId && !filter?.siteName;
@@ -73098,6 +73448,7 @@ async function getDynamicContext(auth, httpClient, filter, options) {
     const context2 = enrichDynamicContext2(response.data, known_apps_default, {
       includePartnerContext,
       includeAccountContext,
+      includeCompanionApp,
       // Cap the account-wide view to the first N sites; a targeted fetch returns one site.
       ...noFilter ? { maxSites: MAX_SITES_FOR_DYNAMIC_CONTEXT, totalSiteCount } : {}
     });
@@ -73151,6 +73502,21 @@ function isApiUrlAllowed(url) {
 }
 
 // src/config/param-descriptions.ts
+var REPORT_ISSUE_TO_WIX_PARAMS = {
+  message: [
+    "The report of one issue, sent to Wix as free text. Only this issue \u2014 no session summary, play-by-play or unrelated problems:",
+    "- What was being attempted, in a sentence.",
+    "- The tool or endpoint, the HTTP status and the error message.",
+    "- What you expected instead, and the workaround if any.",
+    "- Where the fault likely lives (API behavior / API schema / docs / Wix tooling / unsure), and whether you confirmed it.",
+    "- The context needed to reproduce it: agent/model, site id, the Wix area or API.",
+    "- The user's own words, verbatim, if they added any.",
+    "NEVER include secrets \u2014 no bearer tokens, API keys, or credentials \u2014 and no personal data beyond what the report needs."
+  ].join("\n"),
+  requestId: "Optional request id (x-wix-request-id) of the failed Wix API call this report is about."
+};
+var WHY_NOT_EXECUTE_RECONNECT = "if the Wix MCP doesn't offer it at all, say so here, and tell the user once that their Wix connection may be an old or cached version that a reconnect refreshes.";
+var WHY_NOT_EXECUTE_NO_EXECUTE = "if it isn't in your tool list, say so.";
 var paramDescriptions = {
   CallWixSiteAPI: {
     siteId: "The id of the site selected using site selection tool",
@@ -73167,6 +73533,7 @@ var paramDescriptions = {
       WQL_FILTER_RULE
     ].join("\n"),
     reason: "One sentence explaining the original user request and why you are calling this API to complete it.",
+    whyNotExecuteWixAPI: `One sentence: why this call goes through CallWixSiteAPI and not ExecuteWixAPI, the preferred tool. If ExecuteWixAPI isn't loaded, load it through your client's tool search before calling this tool; ${WHY_NOT_EXECUTE_RECONNECT}`,
     sourceDocUrl: [
       "The URL of the documentation or recipe where you found this API endpoint.",
       "MAKE SURE THE ENDPOINT URL IS REALLY THERE AND YOUR ARE NOT GUESSING IT !!!",
@@ -73202,18 +73569,9 @@ var paramDescriptions = {
       'Use ["other"] ONLY IF YOU HAVE A VERY GOOD REASON TO DO SO'
     ].join("\n")
   },
-  SupportAndFeedback: {
-    message: [
-      "The composed feedback message to send to Wix. Wix receives only free text, so a bare sentence is low-signal \u2014 send a summary of the whole session, not just the last error. Structure it in three layers:",
-      "1. Provenance \u2014 labelled lines (omit ones that do not apply): agent/model, Wix tooling used, Wix areas/APIs touched, Wix products (stores, bookings, ...), site id, relevant links (dashboard, docs pages read, live site) and other ids created this run.",
-      `2. Narrative \u2014 "In the user's words": anything the user added when you offered, quoted verbatim (redact secrets only). Then user intent + run summary (what they set out to build, what worked vs. what fought back), a condensed play-by-play of the session (key exchanges, tool calls, decisions), and the friction points \u2014 every place something got in the way, each with specifics: the step/endpoint, HTTP status and error message, the gap, the workaround, and what you expected instead. Include issues you recovered from.`,
-      '3. Attribution \u2014 for each significant friction point, your best diagnosis of where the fault lives: API behavior / API schema / API reference docs / docs articles or examples / Wix tooling (MCP tools, auth flow) / other-unsure \u2014 plus whether you confirmed it or are assuming. Do not force a tag; "unsure" beats a wrong route.',
-      "End with a bottom line: one or two sentences naming the single most important problem and its impact \u2014 a concise engineering assessment, not softened or hedged.",
-      "Write it as a scannable few paragraphs or a short bulleted list \u2014 thorough on the friction, distilled rather than a transcript dump.",
-      "NEVER include secrets \u2014 no bearer tokens, API keys, or credentials \u2014 and no personal data beyond what the feedback needs."
-    ].join("\n"),
-    requestId: "Optional request id (x-wix-request-id) returned from a failed Wix API call this feedback relates to."
-  },
+  ReportIssueToWix: REPORT_ISSUE_TO_WIX_PARAMS,
+  // The tool's former name, kept for importers that read it by that key.
+  SupportAndFeedback: REPORT_ISSUE_TO_WIX_PARAMS,
   SearchWixWDSDocumentation: {
     searchTerm: "The search term to search for in the Wix Design System Documentation",
     maxResults: "The maximum number of results to return, default is 10, max is 15"
@@ -73252,8 +73610,13 @@ var paramDescriptions = {
     maxResults: "The maximum number of results to return, default is 10, max is 15",
     reason: "One sentence describing the original user request and the task you are trying to accomplish with this search."
   },
+  SearchWixHelpCenter: {
+    searchTerm: 'What the site owner wants to do or fix, in plain words (e.g. "connect a domain bought elsewhere", "cancel a Premium plan")',
+    maxResults: "The maximum number of articles to return (1\u201315, default 15). Each article is returned with up to 60 lines.",
+    reason: "One sentence describing the original user request and the task you are trying to accomplish with this search."
+  },
   ReadFullDocsArticle: {
-    articleUrl: "The URL of the docs article or method article to fetch. Should be something like https://dev.wix.com/docs/.../... For REST docs, use the URL as-is. For SDK docs, the URL SHOULD include the query param ?apiView=SDK (e.g. https://dev.wix.com/docs/...?apiView=SDK). Wix skills pages (https://www.wix.com/skills/..., https://dev.wix.com/docs/skills/...) and Wix Headless agent pages (https://www.wix.com/headless/..., e.g. https://www.wix.com/headless/skill.md) are read as-is, including their referenced files."
+    articleUrl: "The URL of the docs article or method article to fetch. Should be something like https://dev.wix.com/docs/.../... For REST docs, use the URL as-is. For SDK docs, the URL SHOULD include the query param ?apiView=SDK (e.g. https://dev.wix.com/docs/...?apiView=SDK). Wix Help Center articles (https://support.wix.com/en/article/...) are read as-is. Wix skills pages (https://www.wix.com/skills/..., https://dev.wix.com/docs/skills/...) and Wix Headless agent pages (https://www.wix.com/headless/..., e.g. https://www.wix.com/headless/skill.md) are read as-is, including their referenced files. Source links (https://dev.wix.com/rawdocs/api/get-source-content?repo=...&path=...) found in skills and recipes are read as-is."
   },
   ReadFullDocsMethodSchema: {
     articleUrl: "The URL of the documentation to fetch. Should be something like https://dev.wix.com/docs/.../... For REST docs, use the URL as-is. For SDK docs, the URL SHOULD include the query param ?apiView=SDK (e.g. https://dev.wix.com/docs/...?apiView=SDK).",
@@ -73269,7 +73632,7 @@ var paramDescriptions = {
   },
   UploadImageToWixSite: {
     siteId: "The ID (UUID) of the Wix site to upload to. REQUIRED. If the user has not clearly specified which site, ASK them which site to upload to (or use ListWixSites to help them pick) BEFORE calling this tool. NEVER call this tool with a missing, empty, placeholder, or guessed siteId \u2014 ask first instead.",
-    image: "Array of file ATTACHMENTS: files the user uploaded in the chat, or files you created in your own file sandbox. Each item requires download_url and file_id, and may optionally include file_name and mime_type \u2014 the platform resolves a file passed here into these fields automatically, so just include the files. For plain image URLs the user pasted, use imageUrls instead. ALWAYS pass ALL attachments together in a single call \u2014 NEVER call this tool once per image. Do NOT use together with imageBase64.",
+    image: `${fileParamNote("send the image as imageBase64 (the whole file, one per call) or as a public URL in imageUrls")} For plain image URLs the user pasted, use imageUrls instead. ALWAYS pass ALL files together in a single call \u2014 NEVER call this tool once per image. Do NOT use together with imageBase64.`,
     imageUrls: "Array of publicly accessible image URLs (e.g. links the user pasted or URLs produced by other tools). Use this for plain URLs that are NOT chat attachments \u2014 no file_id is needed. ALWAYS pass ALL URLs together in a single call. Can be combined with image; do NOT use together with imageBase64.",
     imageBase64: 'Base64-encoded image data. Use when the client can read a file and encode it as base64. May include a data URL prefix (e.g. "data:image/jpeg;base64,...") or be raw base64. Do NOT use together with image.',
     mimeType: 'MIME type of the image (e.g. "image/jpeg", "image/png", "image/webp"). Required when imageBase64 does not include a data URL prefix.',
@@ -73306,10 +73669,301 @@ var paramDescriptions = {
 };
 var desc = (toolName) => paramDescriptions[toolName];
 
+// src/docs/mintlify-docs.ts
+var MINTLIFY_LINKS_DOCS_SITE = "mintlify-links";
+var MINTLIFY_DOCS_SITE = "mintlify";
+var MINTLIFY_HOST = "https://wix-internal.mintlify.site";
+var MINTLIFY_HOSTNAMES = /* @__PURE__ */ new Set([
+  "wix-internal.mintlify.site",
+  "wix-internal.mintlify.app"
+]);
+var DEV_WIX_DOCS = "https://dev.wix.com/docs";
+var PORTAL_SLUG_TO_TAB = {
+  rest: "api-reference",
+  "mintlify-sandbox": "sandbox"
+};
+var TAB_TO_PORTAL_SLUG = {
+  sandbox: "mintlify-sandbox"
+};
+var MINTLIFY_TABS = /* @__PURE__ */ new Set(["api-reference", "sandbox", "kb"]);
+var NON_DOCS_SLUGS = /* @__PURE__ */ new Set(["skills", "kb-only", "api"]);
+var CHECK_TTL_MS = 10 * 60 * 1e3;
+var MAX_CHECK_ENTRIES = 5e3;
+var CHECK_TIMEOUT_MS = 5e3;
+var MAX_REDIRECTS = 3;
+var CHECK_CONCURRENCY = 8;
+function isMintlifyDocsSite(docsSite) {
+  return docsSite === MINTLIFY_LINKS_DOCS_SITE || docsSite === MINTLIFY_DOCS_SITE;
+}
+var MINTLIFY_DOCUMENT_TYPES = {
+  REST: ["MINTLIFY_REST"],
+  // includes the skills, as REST + SKILLS does today
+  SDK: ["MINTLIFY_SDK"]
+};
+function mintlifyDocumentTypes(docsSite, toolName) {
+  return docsSite === MINTLIFY_DOCS_SITE ? MINTLIFY_DOCUMENT_TYPES[toolName] : void 0;
+}
+function isMintlifyUrl(url) {
+  try {
+    return MINTLIFY_HOSTNAMES.has(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+}
+var MINTLIFY_URL_PREFIXES = [...MINTLIFY_HOSTNAMES].map(
+  (host) => `https://${host}/`
+);
+function cleanPath(pathname) {
+  const path10 = pathname.replace(/\.md$/, "").replace(/\/+$/, "");
+  return path10 === "" ? "/" : path10;
+}
+function flavourOf(url) {
+  return url.searchParams.get("apiView")?.toUpperCase() === "SDK" ? "sdk" : "rest";
+}
+function toMintlifyCandidate(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return null;
+  }
+  if (MINTLIFY_HOSTNAMES.has(url.hostname)) {
+    const path11 = cleanPath(url.pathname);
+    return { url: `${MINTLIFY_HOST}${path11}`, path: path11, flavour: flavourOf(url) };
+  }
+  if (url.hostname !== "dev.wix.com" || !url.pathname.startsWith("/docs/")) {
+    return null;
+  }
+  const segments = cleanPath(url.pathname.slice("/docs".length)).split("/").filter(Boolean);
+  if (segments.length === 0 || NON_DOCS_SLUGS.has(segments[0])) {
+    return null;
+  }
+  segments[0] = PORTAL_SLUG_TO_TAB[segments[0]] ?? segments[0];
+  const path10 = `/${segments.join("/")}`;
+  return { url: `${MINTLIFY_HOST}${path10}`, path: path10, flavour: flavourOf(url) };
+}
+function toDevWixUrl(rawUrl) {
+  const url = new URL(rawUrl);
+  const segments = cleanPath(url.pathname).split("/").filter(Boolean);
+  if (segments.length > 0) {
+    segments[0] = TAB_TO_PORTAL_SLUG[segments[0]] ?? segments[0];
+  }
+  const query = flavourOf(url) === "sdk" ? "?apiView=SDK" : "";
+  return `${DEV_WIX_DOCS}/${segments.join("/")}${query}`;
+}
+var checkCache = /* @__PURE__ */ new Map();
+function rememberCheck(path10, result) {
+  const now = Date.now();
+  checkCache.delete(path10);
+  if (checkCache.size >= MAX_CHECK_ENTRIES) {
+    for (const [key, entry] of checkCache) {
+      if (entry.expires <= now) checkCache.delete(key);
+    }
+  }
+  while (checkCache.size >= MAX_CHECK_ENTRIES) {
+    const oldest = checkCache.keys().next().value;
+    if (oldest === void 0) break;
+    checkCache.delete(oldest);
+  }
+  checkCache.set(path10, { result, expires: now + CHECK_TTL_MS });
+}
+async function headOnce(url) {
+  return fetch(url, {
+    method: "HEAD",
+    redirect: "manual",
+    signal: AbortSignal.timeout(CHECK_TIMEOUT_MS)
+  });
+}
+async function checkMintlifyPage(path10) {
+  const cached2 = checkCache.get(path10);
+  if (cached2 && cached2.expires > Date.now()) {
+    return cached2.result;
+  }
+  if (cached2) checkCache.delete(path10);
+  let result;
+  try {
+    let current = path10;
+    let hops = 0;
+    for (; ; ) {
+      const response = await headOnce(`${MINTLIFY_HOST}${current}`);
+      if (response.status === 200) {
+        result = {
+          outcome: hops === 0 ? "identity" : "redirect",
+          path: current
+        };
+        break;
+      }
+      const location = response.headers.get("location");
+      if (response.status >= 300 && response.status < 400 && location && hops < MAX_REDIRECTS) {
+        current = cleanPath(new URL(location, MINTLIFY_HOST).pathname);
+        hops++;
+        continue;
+      }
+      result = { outcome: response.status === 404 ? "missing" : "error" };
+      break;
+    }
+  } catch (error2) {
+    logger2.error(`[mintlify] page check failed for ${path10}: ${error2}`);
+    result = { outcome: "error" };
+  }
+  rememberCheck(path10, result);
+  return result;
+}
+async function resolveDocsLink(rawUrl, { verify = true } = {}) {
+  const candidate = toMintlifyCandidate(rawUrl);
+  if (!candidate) {
+    return { outcome: "not-docs", url: rawUrl };
+  }
+  const tab = candidate.path.split("/")[1];
+  if (!MINTLIFY_TABS.has(tab)) {
+    return { outcome: "other-portal", url: rawUrl };
+  }
+  const query = candidate.flavour === "sdk" ? "?apiView=SDK" : "";
+  if (!verify) {
+    return { outcome: "identity", url: `${candidate.url}${query}` };
+  }
+  const check2 = await checkMintlifyPage(candidate.path);
+  if (check2.path) {
+    return {
+      outcome: check2.outcome,
+      url: `${MINTLIFY_HOST}${check2.path}${query}`
+    };
+  }
+  return { outcome: check2.outcome, url: rawUrl };
+}
+var DOCS_LINK_PATTERN = /https:\/\/(?:dev\.wix\.com\/docs|wix-internal\.mintlify\.(?:site|app))\/[^\s)\]"'<>`]*/g;
+function trimTrailingPunctuation(url) {
+  return url.replace(/[.,;:!?*]+$/, "");
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from(
+    { length: Math.min(limit, items.length) },
+    async () => {
+      while (next < items.length) {
+        const index = next++;
+        results[index] = await fn(items[index]);
+      }
+    }
+  );
+  await Promise.all(workers);
+  return results;
+}
+async function rewriteDocsLinks(text, { verify = true, label = "text" } = {}) {
+  const found = [
+    ...new Set(
+      (text.match(DOCS_LINK_PATTERN) ?? []).map(trimTrailingPunctuation)
+    )
+  ];
+  const stats = {
+    links: found.length,
+    byOutcome: {},
+    misses: []
+  };
+  if (found.length === 0) {
+    return { text, stats };
+  }
+  const resolved = await mapWithConcurrency(
+    found,
+    CHECK_CONCURRENCY,
+    (url) => resolveDocsLink(url, { verify })
+  );
+  const replacements2 = /* @__PURE__ */ new Map();
+  found.forEach((url, i2) => {
+    const { outcome, url: target } = resolved[i2];
+    stats.byOutcome[outcome] = (stats.byOutcome[outcome] ?? 0) + 1;
+    if (outcome === "identity" || outcome === "redirect") {
+      if (target !== url) replacements2.set(url, target);
+    } else if (outcome !== "not-docs") {
+      stats.misses.push(`${outcome} ${url}`);
+    }
+  });
+  const rewritten = text.replace(DOCS_LINK_PATTERN, (match) => {
+    const url = trimTrailingPunctuation(match);
+    const target = replacements2.get(url);
+    return target ? target + match.slice(url.length) : match;
+  });
+  logger2.log(
+    `[mintlify] ${label}: ${stats.links} links ${JSON.stringify(stats.byOutcome)}` + (stats.misses.length ? ` misses: ${stats.misses.slice(0, 10).join(" | ")}` : "")
+  );
+  return { text: rewritten, stats };
+}
+var INDEX_BANNER = /^> ## Documentation Index\n(?:>.*\n)*\n?/;
+var INLINED_SNIPPET = /^export const \w+ = [\s\S]*?^};\n/gm;
+var REST_TAB = /<Tab title="REST">([\s\S]*?)<\/Tab>/;
+var SDK_TAB = /<Tab title="SDK">([\s\S]*?)<\/Tab>/;
+function cleanMintlifyMarkdown(markdown, flavour) {
+  const text = markdown.replace(INLINED_SNIPPET, "");
+  const rest = text.match(REST_TAB);
+  const sdk = text.match(SDK_TAB);
+  if (!rest || !sdk || (text.match(/<Tab title=/g) ?? []).length !== 2) {
+    return text;
+  }
+  const start = text.lastIndexOf("<Tabs>", rest.index);
+  const end = text.indexOf("</Tabs>", sdk.index);
+  if (start === -1 || end === -1) {
+    return text;
+  }
+  const kept = (flavour === "sdk" ? sdk : rest)[1];
+  const note = flavour === "sdk" ? "_This is the SDK view. Drop `?apiView=SDK` from the URL for the REST view._" : "_This is the REST view. Add `?apiView=SDK` to the URL for the JavaScript SDK view._";
+  return `${text.slice(0, start)}${note}
+
+${kept.trim()}
+${text.slice(end + "</Tabs>".length)}`;
+}
+var DOCS_URL_IN_TEXT = /https:\/\/dev\.wix\.com\/docs\/(?=api-reference\b|\.\.\.)/g;
+function toMintlifyHostText(text) {
+  return text.replace(DOCS_URL_IN_TEXT, `${MINTLIFY_HOST}/`);
+}
+var SITE_RELATIVE_LINK = /(\]\(|href=["'])\/(?!\/)/g;
+function absolutizeSiteLinks(markdown) {
+  return markdown.replace(
+    SITE_RELATIVE_LINK,
+    (_, open) => `${open}${MINTLIFY_HOST}/`
+  );
+}
+async function readMintlifyMarkdown(rawUrl) {
+  const resolved = await resolveDocsLink(rawUrl);
+  if (resolved.outcome !== "identity" && resolved.outcome !== "redirect") {
+    return null;
+  }
+  const pageUrl = new URL(resolved.url);
+  const response = await fetch(`${MINTLIFY_HOST}${pageUrl.pathname}.md`, {
+    headers: { accept: "text/markdown" },
+    redirect: "follow",
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (response.status === 404) {
+    return null;
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Mintlify returned ${response.status} for ${pageUrl.pathname}.md`
+    );
+  }
+  const flavour = toMintlifyCandidate(rawUrl)?.flavour ?? "rest";
+  const cleaned = cleanMintlifyMarkdown(
+    (await response.text()).replace(INDEX_BANNER, ""),
+    flavour
+  );
+  const { text: rewritten } = await rewriteDocsLinks(cleaned, {
+    label: `read ${pageUrl.pathname}`
+  });
+  const markdown = absolutizeSiteLinks(rewritten);
+  logger2.log(
+    `[mintlify] read ${pageUrl.pathname}.md (${markdown.length} chars) for ${rawUrl}`
+  );
+  return { url: `${MINTLIFY_HOST}${pageUrl.pathname}`, markdown };
+}
+
 // src/docs/get-to-know.ts
+var AX_SKILLS_REPO = "wix-private/ax-skills";
+var AX_SKILLS_INDEX_PATH = "skills/wix-manage/SKILL.md";
 function addGetSiteContextTool({
   server: server2,
   authStrategy,
+  includeCompanionApp = false,
   toolDescriptions
 }) {
   const d = desc("GetSiteContext");
@@ -73339,7 +73993,8 @@ function addGetSiteContextTool({
       try {
         context2 = await getDynamicContext(authStrategy, httpClient, filter, {
           partnerContextEnabled: false,
-          includeAccountContext: false
+          includeAccountContext: false,
+          includeCompanionApp
         });
       } catch (err) {
         rethrowIfUnauthorized(err);
@@ -73375,15 +74030,17 @@ async function addGetToKnowTools({
   dynamicContextEnabled,
   repo,
   commitHash,
-  skillsTags
+  skillsTags,
+  readmeRecipesIndexEnabled = true,
+  docsSite
 }) {
   if (disableTools.includes("WixREADME")) {
     return;
   }
   const baseDocs = readmeDocs ?? defaultReadmeDocs;
-  const baseDocsWithoutRecipes = baseDocs.filter(
-    (doc) => doc.url !== RECIPES_INDEX_URL
-  );
+  const isRecipesIndex = (doc) => doc.url?.replace(/\.md$/, "") === RECIPES_INDEX_URL;
+  const baseDocsWithoutRecipes = baseDocs.filter((doc) => !isRecipesIndex(doc));
+  const recipesIndexDocs = readmeRecipesIndexEnabled ? baseDocs.filter(isRecipesIndex) : [];
   server2.tool(
     "WixREADME",
     toolDescriptions?.["WixREADME"] ?? defaultToolDescriptions.WixREADME,
@@ -73455,6 +74112,18 @@ ${responseText}` : responseText;
           if (!url) {
             throw new Error('URL is required for "include" action');
           }
+          const readsAxSkills = isRecipesIndex({ action, url }) && !skillsPortalUrl && (repo ? repo === AX_SKILLS_REPO : !commitHash);
+          if (readsAxSkills) {
+            return {
+              type: "text",
+              text: await fetchSourceContent(
+                httpClient,
+                AX_SKILLS_REPO,
+                AX_SKILLS_INDEX_PATH,
+                repo === AX_SKILLS_REPO ? commitHash : void 0
+              )
+            };
+          }
           const fetchedContent = await fetchArticleContent(
             httpClient,
             url,
@@ -73497,9 +74166,9 @@ Failed to fetch content: ${errorMsg}`
       }).catch((err) => {
         console.error("[WixREADME] Failed to fetch skills by portal:", err);
         return null;
-      }) : fetchDoc({ action: "include", url: RECIPES_INDEX_URL }).then(
+      }) : readmeRecipesIndexEnabled ? fetchDoc({ action: "include", url: RECIPES_INDEX_URL }).then(
         (doc) => doc?.text ?? null
-      );
+      ) : Promise.resolve(null);
       const filter = {};
       if (siteId) filter.siteId = siteId;
       else if (siteName) filter.siteName = siteName;
@@ -73519,7 +74188,7 @@ Failed to fetch content: ${errorMsg}`
       const recipesIntro = dedent_default`
           Reusable how-to guides for common ${isVisitorFlow ? "Wix site visitor" : "Wix management"} tasks, grouped by product area. Each recipe is a Wix docs article that bundles the right endpoints, request shapes, field names, and step ordering for one real-world use case.
 
-          Scan the index below and open any relevant article with \`ReadFullDocsArticle\`. If the article contains a code example that fits the user's intent — a **complete** example (not a truncated \`... N more lines ...\` snippet) that matches your exact case, same variant/shape — call the API directly. If the closest example is truncated or omits a field your case needs, do NOT call the API off it — continue discovery first: \`ReadFullDocsArticle\` for the complete example, or \`SearchWixAPISpec\` for the exact schema. On query and search methods an example proves only the fields and operators it uses; the endpoint's own declared list covers the rest. Otherwise (no fitting recipe, no usable code example, or persistent errors after retrying), fall back to docs discovery: \`SearchWixRESTDocumentation\` or \`BrowseWixRESTDocsMenu\` to find the right method, then \`SearchWixAPISpec\` for the exact schema.
+          Open the recipe that matches the task with \`ReadFullDocsArticle\` and follow it. When its example for a call matches your case (the same variant and shape), call from it; when it doesn't, or leaves out a field your case needs, read the method's schema with \`SearchWixAPISpec\` first. On query and search methods an example proves only the fields and operators it uses; the method's own declared list covers the rest. When no recipe fits, find the method with \`SearchWixRESTDocumentation\` or \`BrowseWixRESTDocsMenu\`, then \`SearchWixAPISpec\` for its schema.
         `;
       const recipesContents = skillsContent !== null ? [
         await fetchDoc({
@@ -73529,9 +74198,7 @@ Failed to fetch content: ${errorMsg}`
 
 ${skillsContent}`
         })
-      ] : await Promise.all(
-        baseDocs.filter((doc) => doc.url === RECIPES_INDEX_URL).map(fetchDoc)
-      );
+      ] : await Promise.all(recipesIndexDocs.map(fetchDoc));
       const recipeNotes = !skillsContent?.includes("Dashboard Navigation") ? [] : [
         await fetchDoc({
           action: "text",
@@ -73549,7 +74216,8 @@ ${skillsContent}`
         ).map((item) => item.text),
         ...dynamicContext ? [dynamicContext] : []
       ];
-      const text = parts.join("\n\n");
+      const joined = parts.join("\n\n");
+      const text = isMintlifyDocsSite(docsSite) ? (await rewriteDocsLinks(joined, { label: "readme WixREADME" })).text : joined;
       return {
         content: [{ type: "text", text }]
       };
@@ -73558,13 +74226,14 @@ ${skillsContent}`
 }
 
 // src/docs/start-deploy-website.ts
+var NO_PERSONAL_DATA = "No personal data: no names, emails, phones, passwords, keys or local paths.";
 var START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS = {
-  userRequest: "The user's request that led here, quoted if short, otherwise summarized in a sentence.",
-  siteDescription: "What the site is: its purpose and who it is for. One or two sentences.",
-  siteForm: "The form the site exists in right now (HTML/CSS/JS files, a static build, a zip, another builder's export, a design created in this conversation, or something else), roughly how many files, and whether it includes images.",
-  siteFunctionality: "What the site must be able to do for its visitors beyond showing pages, if anything (for example selling, bookings or reservations, tickets, menus and orders, rentals, forms, memberships or paid plans, donations, a blog, or anything else the user expects to work), in your own words. If it is a plain static site with no such needs, say so.",
-  agentIdentity: "Which agent or product you are and the harness you run in.",
-  wixAccess: "How you can reach Wix from where you run: through this MCP only, or also from a shell whose network can reach wixapis.com; whether you can run the Wix CLI (npx @wix/cli) there and whether it is logged in; and which Wix identity you act with \u2014 the user's login through this MCP, a CLI login, or none."
+  userRequest: `A short summary of what the user asked for and the context that led here, in a sentence or two, including whether this is a new site or an edit or new version of a site already on Wix. ${NO_PERSONAL_DATA}`,
+  siteDescription: `What the site is: its purpose and who it is for. One or two sentences. ${NO_PERSONAL_DATA}`,
+  siteForm: `The form the site exists in right now (HTML/CSS/JS files, a static build, a zip, a framework project, another builder's export, a design created in this conversation, or something else), roughly how many files, and whether it includes images. For a framework project: which framework, whether you have its built static output (for example dist/) or only the source, and whether it needs a server at runtime (SSR, API routes, a backend), or that you don't know. Also where it came from: built in this conversation, the user's own project or repo, another builder (which one), or a Wix skill or template (which one). ${NO_PERSONAL_DATA}`,
+  siteFunctionality: `What the site must be able to do for its visitors beyond showing pages, if anything (for example selling, bookings or reservations, tickets, menus and orders, rentals, forms, memberships or paid plans, donations, a blog, or anything else the user expects to work), in your own words. If it is a plain static site with no such needs, say so. ${NO_PERSONAL_DATA}`,
+  agentIdentity: `Which agent or product you are, which model if you know it, and the harness you run in. ${NO_PERSONAL_DATA}`,
+  wixAccess: `How you can reach Wix from where you run: through this MCP only, or also from a shell whose network can reach wixapis.com; whether you can run the Wix CLI (npx @wix/cli) there and whether it is logged in; which Wix identity you act with \u2014 the user's login through this MCP, a CLI login, or none; and which Wix skills you have (for example wix-headless-kit or wix-manage), by name and where they come from (installed on disk, a plugin, read online), or none. Name the kind of identity, not the account or its email. ${NO_PERSONAL_DATA}`
 };
 var START_DEPLOY_WEBSITE_PARAMS = Object.keys(
   START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS
@@ -73572,10 +74241,11 @@ var START_DEPLOY_WEBSITE_PARAMS = Object.keys(
 var START_DEPLOY_WEBSITE_TOOL_NAME = "StartDeployWebsite";
 var START_DEPLOY_WEBSITE_RECIPE_URL = "https://dev.wix.com/docs/api-reference/account-level/sites/skills/upload-a-website-or-html-files.md";
 var DROP_PAGE_URL = "https://www.wix.com/headless/drop?utm_campaign=mcp";
+var WRITE_THE_CODE_LINE = "When the user brought no files, write the site's code yourself, then upload it as the guide shows.";
 var FALLBACK_LINE = `Only if you cannot run it (you can't reach the file bytes, or a step fails and you can't fix it): send the user to ${DROP_PAGE_URL} \u2014 give that URL exactly as written, keeping the utm_campaign=mcp parameter.`;
 function startDeployWebsiteResponse(recipe) {
   return [
-    `The following is the content of ${START_DEPLOY_WEBSITE_RECIPE_URL}. Follow it end to end and do the publishing yourself \u2014 do not hand the user instructions.`,
+    `The following is the content of ${START_DEPLOY_WEBSITE_RECIPE_URL}. Follow it end to end and do the publishing yourself \u2014 do not hand the user instructions. ${WRITE_THE_CODE_LINE}`,
     FALLBACK_LINE,
     "---",
     recipe.trim()
@@ -73583,7 +74253,7 @@ function startDeployWebsiteResponse(recipe) {
 }
 var START_DEPLOY_WEBSITE_POINTER_RESPONSE = [
   `Read and follow this recipe end to end: ${START_DEPLOY_WEBSITE_RECIPE_URL}`,
-  "It covers creating the site and uploading the files (with or without a Wix login), updating a site deployed this way, and implementing a backend on it (stores, bookings, CMS, members) as a Wix Headless project. Do the publishing yourself \u2014 do not hand the user instructions.",
+  `It covers creating the site and uploading the files (with or without a Wix login), updating a site deployed this way, and implementing a backend on it (stores, bookings, CMS, members) as a Wix Headless project. Do the publishing yourself \u2014 do not hand the user instructions. ${WRITE_THE_CODE_LINE}`,
   FALLBACK_LINE
 ].join("\n\n");
 function addStartDeployWebsiteTool(server2, disableTools = [], toolDescriptions, fetchOptions = {}) {
@@ -73631,36 +74301,21 @@ function addStartDeployWebsiteTool(server2, disableTools = [], toolDescriptions,
 // src/docs/start-headless-build.ts
 var START_HEADLESS_BUILD_TOOL_NAME = "StartHeadlessBuild";
 var HEADLESS_GUIDE_URL = "https://www.wix.com/skills/headless-cold-start/headless-kit.md";
-var START_HEADLESS_BUILD_STARTING_POINTS = [
-  "nothing yet",
-  "a design worked out in this conversation",
-  "an existing Wix Headless site",
-  "a project download link",
-  "a Wix site to move to code"
-];
 var START_HEADLESS_BUILD_PARAM_DESCRIPTIONS = {
   userRequest: START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS.userRequest,
   siteDescription: START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS.siteDescription,
-  startingPoint: "What the build starts from: nothing yet; a design worked out in this conversation; an existing Wix Headless site; a project download link (a download.zip from Wix); or a Wix site to move to code.",
+  startingPoint: `What the site starts from, in your own words: a new site; an existing Wix Headless site (a site deployed from files is one), with its metaSiteId if you have it; a project download link (a download.zip from Wix); a Wix site moving to code; or something else. ${NO_PERSONAL_DATA}`,
   siteFunctionality: START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS.siteFunctionality,
   agentIdentity: START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS.agentIdentity,
   wixAccess: START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS.wixAccess
 };
-var PREFIX2 = "The following is Wix's headless guide. Follow it end to end and do the work yourself. If you find the user already has the site's code, call StartDeployWebsite instead.";
-var MOVE_TO_CODE_LINE = `Moving a Wix site to code starts from the site's dashboard (Headless settings, "Go Headless"), which hands the owner a prompt with the project's download link. Ask the user for that prompt, then follow the guide with it.`;
-function startHeadlessBuildResponse(guide, startingPoint) {
-  const lines = [];
-  if (startingPoint === "a Wix site to move to code") {
-    lines.push(MOVE_TO_CODE_LINE);
-  }
+var BUILT_HERE = "The site is built here, in code: don't offer Wix's editor or a template instead.";
+var PREFIX2 = `The following is Wix's headless guide. Follow it end to end and do the work yourself: you write the site, and the guide creates it, connects its Wix business features, and uploads it. ${BUILT_HERE}`;
+function startHeadlessBuildResponse(guide) {
   if (guide && guide.trim()) {
-    lines.push(PREFIX2, "---", guide.trim());
-  } else {
-    lines.push(
-      `Wix's headless guide could not be loaded here. It is at ${HEADLESS_GUIDE_URL}: read it whole with ReadFullDocsArticle if you have that tool, otherwise fetch it with curl or your web tool, then follow it end to end and do the work yourself. If you find the user already has the site's code, call StartDeployWebsite instead.`
-    );
+    return [PREFIX2, "---", guide.trim()].join("\n\n");
   }
-  return lines.join("\n\n");
+  return `Wix's headless guide could not be loaded here. It is at ${HEADLESS_GUIDE_URL}: read it whole with ReadFullDocsArticle if you have that tool, otherwise fetch it with curl or your web tool, then follow it end to end and do the work yourself. ${BUILT_HERE}`;
 }
 function addStartHeadlessBuildTool(server2, disableTools = [], toolDescriptions, fetchOptions = {}) {
   if (disableTools.includes(START_HEADLESS_BUILD_TOOL_NAME)) {
@@ -73673,13 +74328,13 @@ function addStartHeadlessBuildTool(server2, disableTools = [], toolDescriptions,
     {
       userRequest: external_exports.string().min(1).describe(d.userRequest),
       siteDescription: external_exports.string().min(1).describe(d.siteDescription),
-      startingPoint: external_exports.enum(START_HEADLESS_BUILD_STARTING_POINTS).describe(d.startingPoint),
+      startingPoint: external_exports.string().optional().describe(d.startingPoint),
       siteFunctionality: external_exports.string().min(1).describe(d.siteFunctionality),
       agentIdentity: external_exports.string().min(1).describe(d.agentIdentity),
       wixAccess: external_exports.string().min(1).describe(d.wixAccess)
     },
     { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-    async (args, { httpClient }) => {
+    async (_args, { httpClient }) => {
       let guide;
       try {
         guide = await fetchArticleContent(
@@ -73701,7 +74356,7 @@ function addStartHeadlessBuildTool(server2, disableTools = [], toolDescriptions,
         content: [
           {
             type: "text",
-            text: startHeadlessBuildResponse(guide, args.startingPoint)
+            text: startHeadlessBuildResponse(guide)
           }
         ]
       };
@@ -73719,7 +74374,8 @@ var VALID_DOCS_TOOLS = [
   "VELO",
   "BUSINESS_SOLUTIONS",
   "CLI",
-  "OVERVIEW"
+  "OVERVIEW",
+  "HELP_CENTER"
 ];
 var REST_SEARCH_API_GROUNDING_REMINDER = dedent_default`
   # Before calling a Wix API
@@ -73748,9 +74404,16 @@ function shouldTryMenuFallbackForDocsRead(error2, articleUrl) {
   if (!message.includes("404") || !isMenuFallbackUrl) {
     return false;
   }
-  return !["This resource is deprecated", "No schema found"].some(
-    (knownArticleError) => message.includes(knownArticleError)
-  );
+  return !isKnownArticleError(error2);
+}
+function isKnownArticleError(error2) {
+  const message = getErrorMessage(error2);
+  return [
+    "This resource is deprecated",
+    "This method is deprecated",
+    "This article is deprecated",
+    "No schema found"
+  ].some((knownArticleError) => message.includes(knownArticleError));
 }
 function formatDocsReadError(toolAction, error2) {
   return `Could not fetch ${toolAction}: "${getErrorMessage(error2)}".`;
@@ -73763,7 +74426,8 @@ var addDocsTools = (server2, allowedTools = [
   "WIX_HEADLESS",
   "BUSINESS_SOLUTIONS",
   "CLI",
-  "OVERVIEW"
+  "OVERVIEW",
+  "HELP_CENTER"
 ], options = {}) => {
   const {
     getToKnowWixEnabled = false,
@@ -73779,14 +74443,47 @@ var addDocsTools = (server2, allowedTools = [
     skillsPr,
     commitHash,
     skillsTags,
+    readmeRecipesIndexEnabled,
     dynamicContextEnabled,
+    includeCompanionApp,
     usePlatformizedSearch = true,
-    usePlatformizedBrowse = true
+    usePlatformizedBrowse = true,
+    docsSite
   } = options;
   const effectiveRepo = repo ?? skillsRepo;
   const effectiveCommitHash = commitHash ?? skillsPr;
-  const getDescription = (toolName, defaultDesc) => toolDescriptions?.[toolName] ?? defaultDesc;
+  const mintlifyDocs = isMintlifyDocsSite(docsSite);
+  const runSearch = mintlifyDocs ? async (params) => {
+    const documentTypes = mintlifyDocumentTypes(docsSite, params.toolName);
+    const result = await runSemanticSearchAndFormat(
+      documentTypes ? { ...params, documentTypes } : params
+    );
+    return (await rewriteDocsLinks(result, { label: `search ${params.toolName}` })).text;
+  } : runSemanticSearchAndFormat;
+  const docsUrlPrefixes = mintlifyDocs ? ["https://dev.wix.com/docs/", ...MINTLIFY_URL_PREFIXES] : ["https://dev.wix.com/docs/"];
+  const toBackendUrl = (url) => mintlifyDocs && isMintlifyUrl(url) ? toDevWixUrl(url) : url;
+  const sourceNote = (source) => mintlifyDocs ? [{ type: "text", text: `[docs source] ${source}` }] : [];
+  const docsText = (text) => mintlifyDocs ? toMintlifyHostText(text) : text;
+  const desc2 = (toolName) => {
+    const descriptions = desc(toolName);
+    if (!mintlifyDocs) return descriptions;
+    return Object.fromEntries(
+      Object.entries(descriptions).map(([param, text]) => [
+        param,
+        docsText(text)
+      ])
+    );
+  };
+  const getDescription = (toolName, defaultDesc) => docsText(toolDescriptions?.[toolName] ?? defaultDesc);
   const fetchMenuTextForUrl = async (httpClient, url) => {
+    const text = await fetchMenuTextForBackendUrl(
+      httpClient,
+      toBackendUrl(url)
+    );
+    if (!text || !mintlifyDocs) return text;
+    return (await rewriteDocsLinks(text, { verify: false, label: "menu" })).text;
+  };
+  const fetchMenuTextForBackendUrl = async (httpClient, url) => {
     if (usePlatformizedBrowse) {
       try {
         return await fetchPlatformizedMenu(url);
@@ -73803,10 +74500,77 @@ var addDocsTools = (server2, allowedTools = [
     }
     return menuContent.length > MENU_CONTENT_THRESHOLD ? summarizeLargeMenu(menuContent, url) : normalizeMenuContent(menuContent);
   };
+  const nearestToMissingPage = async (httpClient, url, isSkillsPage) => {
+    try {
+      if (isSkillsPage) {
+        const manifestUrl = skillManifestUrl(url);
+        if (!manifestUrl) return null;
+        const manifest = JSON.parse(
+          await fetchArticleContent(httpClient, manifestUrl, "article")
+        );
+        const guess = closestSkillFile(url, manifest, manifestUrl);
+        if (!guess) return null;
+        if (guess.kind === "file") {
+          const text = await fetchArticleContent(
+            httpClient,
+            guess.url,
+            "article"
+          );
+          return `Note: "${url}" does not exist. Found a similar file in the skill, ${guess.url}, and read it:
+
+${text}`;
+        }
+        return `Note: "${url}" does not exist, and no file in ${guess.folder ? `its folder (${guess.folder}/)` : "the skill"} has a name close to it. ${guess.folder ? "The files in that folder" : "The skill's top-level folders and files"}, to read the one you need (every file: ${guess.manifestUrl}):
+
+${guess.files.map((f) => `- ${f}`).join("\n")}`;
+      }
+      for (const menuUrl of parentMenuUrls(url)) {
+        const text = await fetchMenuTextForUrl(httpClient, menuUrl);
+        if (!text) continue;
+        const subMenus = (await Promise.all(
+          subMenusToRead(text, menuUrl, url).map(async (sub) => ({
+            sub,
+            text: await fetchMenuTextForUrl(httpClient, sub).catch(() => null)
+          }))
+        )).filter((m) => !!m.text);
+        const closest = closestMenuLinks(
+          [text, ...subMenus.map((m) => m.text)].join("\n"),
+          menuUrl,
+          url
+        );
+        return [
+          `Note: "${url}" does not exist. Showing the nearest documentation menu above it, ${menuUrl}; read the page you need from its links.`,
+          ...closest.length ? [
+            `Closest to what you asked for:
+${closest.map((l) => `- ${l}`).join("\n")}`
+          ] : [],
+          text
+        ].join("\n\n");
+      }
+    } catch (error2) {
+      logger2.error(`[docs] no nearest page for ${url}: ${error2}`);
+    }
+    return null;
+  };
+  if (startDeployWebsiteEnabled) {
+    addStartDeployWebsiteTool(server2, disableTools || [], toolDescriptions, {
+      skillsPortalUrl,
+      repo: effectiveRepo,
+      commitHash: effectiveCommitHash
+    });
+  }
+  if (startHeadlessBuildEnabled) {
+    addStartHeadlessBuildTool(server2, disableTools || [], toolDescriptions, {
+      skillsPortalUrl,
+      repo: effectiveRepo,
+      commitHash: effectiveCommitHash
+    });
+  }
   if (dynamicContextEnabled && authStrategy && !disableTools?.includes("GetSiteContext")) {
     addGetSiteContextTool({
       server: server2,
       authStrategy,
+      includeCompanionApp,
       toolDescriptions,
       disableTools: disableTools || []
     });
@@ -73822,21 +74586,9 @@ var addDocsTools = (server2, allowedTools = [
       dynamicContextEnabled,
       repo: effectiveRepo,
       commitHash: effectiveCommitHash,
-      skillsTags
-    });
-  }
-  if (startDeployWebsiteEnabled) {
-    addStartDeployWebsiteTool(server2, disableTools || [], toolDescriptions, {
-      skillsPortalUrl,
-      repo: effectiveRepo,
-      commitHash: effectiveCommitHash
-    });
-  }
-  if (startHeadlessBuildEnabled) {
-    addStartHeadlessBuildTool(server2, disableTools || [], toolDescriptions, {
-      skillsPortalUrl,
-      repo: effectiveRepo,
-      commitHash: effectiveCommitHash
+      skillsTags,
+      readmeRecipesIndexEnabled,
+      docsSite
     });
   }
   if (allowedTools.includes("WDS") && !disableTools?.includes("SearchWixWDSDocumentation")) {
@@ -73847,7 +74599,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchWixWDSDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchWixWDSDocumentation");
+        const d = desc2("SearchWixWDSDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15)
@@ -73857,7 +74609,7 @@ var addDocsTools = (server2, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger2.log(`Searching for ${searchTerm} in Wix WDS`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "WDS",
             toolParams: {
               searchTerm
@@ -73900,7 +74652,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchWixRESTDocumentation
       ),
       (() => {
-        const d = desc("SearchWixRESTDocumentation");
+        const d = desc2("SearchWixRESTDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(17).optional().default(17),
@@ -73913,7 +74665,7 @@ var addDocsTools = (server2, allowedTools = [
           logger2.log(
             `[SearchWixRESTDocumentation] searchTerm="${searchTerm}", reason="${reason}"`
           );
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "REST",
             toolParams: {
               searchTerm
@@ -73964,7 +74716,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.WixBusinessFlowsDocumentation ?? ""
       ),
       (() => {
-        const d = desc("WixBusinessFlowsDocumentation");
+        const d = desc2("WixBusinessFlowsDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15)
@@ -73974,7 +74726,7 @@ var addDocsTools = (server2, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger2.log(`Searching for ${searchTerm} in Wix Sample Flows`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "BUSINESS_SOLUTIONS",
             toolParams: {
               searchTerm: "**RECIPE**:  Business Recipes - full setup flow for::: " + searchTerm
@@ -74020,7 +74772,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchWixSDKDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchWixSDKDocumentation");
+        const d = desc2("SearchWixSDKDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15)
@@ -74031,7 +74783,7 @@ var addDocsTools = (server2, allowedTools = [
         try {
           logger2.log(`Searching for ${searchTerm} in Wix SDK`);
           panorama.transaction("SearchWixSDKDocumentation").start({ maxResults });
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "SDK",
             toolParams: {
               searchTerm
@@ -74079,7 +74831,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchBuildAppsDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchBuildAppsDocumentation");
+        const d = desc2("SearchBuildAppsDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15)
@@ -74089,7 +74841,7 @@ var addDocsTools = (server2, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger2.log(`Searching for ${searchTerm} in Build Apps`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "BUILD_APPS",
             toolParams: {
               searchTerm: `wix cli docs for ${searchTerm}`
@@ -74131,7 +74883,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchDevelopmentDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchDevelopmentDocumentation");
+        const d = desc2("SearchDevelopmentDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15)
@@ -74141,7 +74893,7 @@ var addDocsTools = (server2, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger2.log(`Searching for ${searchTerm} in Wix Overview`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "OVERVIEW",
             toolParams: {
               searchTerm
@@ -74183,7 +74935,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchWixHeadlessDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchWixHeadlessDocumentation");
+        const d = desc2("SearchWixHeadlessDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(17).optional().default(17)
@@ -74193,7 +74945,7 @@ var addDocsTools = (server2, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger2.log(`Searching for ${searchTerm} in Headless`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "WIX_HEADLESS",
             toolParams: {
               searchTerm
@@ -74238,7 +74990,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchWixVeloDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchWixVeloDocumentation");
+        const d = desc2("SearchWixVeloDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15)
@@ -74249,7 +75001,7 @@ var addDocsTools = (server2, allowedTools = [
         try {
           logger2.log(`Searching for ${searchTerm} in Velo`);
           panorama.transaction("SearchWixVeloDocumentation").start({ maxResults });
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "VELO",
             toolParams: {
               searchTerm
@@ -74287,6 +75039,72 @@ var addDocsTools = (server2, allowedTools = [
       }
     );
   }
+  if (allowedTools.includes("HELP_CENTER") && !disableTools?.includes("SearchWixHelpCenter")) {
+    server2.tool(
+      "SearchWixHelpCenter",
+      getDescription(
+        "SearchWixHelpCenter",
+        defaultToolDescriptions.SearchWixHelpCenter ?? ""
+      ),
+      (() => {
+        const d = desc2("SearchWixHelpCenter");
+        return {
+          searchTerm: external_exports.string().describe(d.searchTerm),
+          maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15),
+          reason: external_exports.string().describe(d.reason)
+        };
+      })(),
+      { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+      async ({ searchTerm, maxResults, reason }, { panorama }) => {
+        try {
+          logger2.log(
+            `[SearchWixHelpCenter] searchTerm="${searchTerm}", reason="${reason}"`
+          );
+          const result = await runSemanticSearchAndFormat({
+            toolName: "HELP_CENTER",
+            toolParams: {
+              searchTerm
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 15, 15)),
+            linesInEachResult: 60,
+            usePlatformizedSearch
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${HELP_CENTER_IS_FOR_PEOPLE}
+
+${result}`
+              }
+            ]
+          };
+        } catch (error2) {
+          panorama.errorMonitor().reportError(error2);
+          captureException(error2, {
+            tags: {
+              componentId: "SearchWixHelpCenter",
+              toolName: "SearchWixHelpCenter"
+            }
+          });
+          logger2.error(
+            `Error searching for ${searchTerm} in the Wix Help Center: ${error2}`
+          );
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error2.message}
+
+${HELP_CENTER_IS_FOR_PEOPLE}`
+              }
+            ]
+          };
+        }
+      }
+    );
+  }
   if (allowedTools.includes("CLI") && !disableTools?.includes("SearchWixCLIDocumentation")) {
     server2.tool(
       "SearchWixCLIDocumentation",
@@ -74295,7 +75113,7 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.SearchWixCLIDocumentation ?? ""
       ),
       (() => {
-        const d = desc("SearchWixCLIDocumentation");
+        const d = desc2("SearchWixCLIDocumentation");
         return {
           searchTerm: external_exports.string().describe(d.searchTerm),
           maxResults: external_exports.number().describe(d.maxResults).min(1).max(15).optional().default(15),
@@ -74308,7 +75126,7 @@ var addDocsTools = (server2, allowedTools = [
           logger2.log(
             `[SearchWixCLIDocumentation] searchTerm="${searchTerm}", reason="${reason}"`
           );
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "CLI",
             toolParams: {
               searchTerm
@@ -74352,14 +75170,39 @@ var addDocsTools = (server2, allowedTools = [
         defaultToolDescriptions.ReadFullDocsArticle
       ),
       (() => {
-        const d = desc("ReadFullDocsArticle");
+        const d = desc2("ReadFullDocsArticle");
         return {
           articleUrl: external_exports.string().url().describe(d.articleUrl)
         };
       })(),
       { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       async ({ articleUrl }, { httpClient }) => {
-        const validPrefixes = ["https://dev.wix.com/docs/"];
+        const source = parseSourceContentUrl(articleUrl);
+        if (source) {
+          try {
+            const text = await fetchSourceContent(
+              httpClient,
+              source.repo,
+              source.path,
+              source.commitHash
+            );
+            return { content: [{ type: "text", text }] };
+          } catch (error2) {
+            logger2.error(
+              `Error fetching source content for ${articleUrl}: ${error2}`
+            );
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: formatDocsReadError("source content", error2)
+                }
+              ]
+            };
+          }
+        }
+        const validPrefixes = [...docsUrlPrefixes, "https://support.wix.com/"];
         if (skillsPortalUrl) validPrefixes.push(skillsPortalUrl);
         const isSkillsPage = isSkillsRegistryUrl(articleUrl);
         if (!isSkillsPage && !validPrefixes.some((p) => articleUrl.startsWith(p))) {
@@ -74368,7 +75211,7 @@ var addDocsTools = (server2, allowedTools = [
             content: [
               {
                 type: "text",
-                text: `Invalid article URL: must start with https://dev.wix.com/docs/, or be a Wix skills page (https://www.wix.com/skills/..., https://www.wix.com/headless/...). Got: "${articleUrl}"`
+                text: `Invalid article URL: must start with https://dev.wix.com/docs/ or https://support.wix.com/, or be a Wix skills page (https://www.wix.com/skills/..., https://www.wix.com/headless/..., or that file's github.com/wix/skills source). Got: "${articleUrl}"`
               }
             ]
           };
@@ -74376,6 +75219,27 @@ var addDocsTools = (server2, allowedTools = [
         if (!isSkillsPage && articleUrl.startsWith("https://dev.wix.com/docs/")) {
           articleUrl = articleUrl.replace(/\.md$/, "");
         }
+        if (mintlifyDocs && !isSkillsPage) {
+          try {
+            const page = await readMintlifyMarkdown(articleUrl);
+            if (page) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: isQueryOrSearchEndpoint(page.url) ? [page.markdown, ARTICLE_CAPABILITY_NOTE].join("\n\n") : page.markdown
+                  },
+                  ...sourceNote(`Mintlify site: ${page.url}.md`)
+                ]
+              };
+            }
+          } catch (error2) {
+            logger2.error(
+              `[mintlify] reading ${articleUrl} from Mintlify failed, falling back: ${error2}`
+            );
+          }
+          articleUrl = toBackendUrl(articleUrl);
+        }
         try {
           const articleContent = await fetchArticleContent(
             httpClient,
@@ -74396,7 +75260,10 @@ var addDocsTools = (server2, allowedTools = [
                 // The article's own URL, never its body — a filter/sort reference page links query
                 // methods in its prose but isn't one.
                 text: isQueryOrSearchEndpoint(articleUrl) ? [articleContent, ARTICLE_CAPABILITY_NOTE].join("\n\n") : articleContent
-              }
+              },
+              ...sourceNote(
+                isSkillsPage ? `skills registry: ${articleUrl}` : `today's backend (dev.wix.com/rawdocs, ingvar), not on the Mintlify site: ${articleUrl}`
+              )
             ]
           };
         } catch (error2) {
@@ -74421,6 +75288,16 @@ ${text}`
             } catch {
             }
           }
+          if (getErrorMessage(error2).includes("404") && !isKnownArticleError(error2)) {
+            const nearest = await nearestToMissingPage(
+              httpClient,
+              articleUrl,
+              isSkillsPage
+            );
+            if (nearest) {
+              return { content: [{ type: "text", text: nearest }] };
+            }
+          }
           return {
             isError: true,
             content: [
@@ -74442,7 +75319,7 @@ ${text}`
         defaultToolDescriptions.ReadFullDocsMethodSchema
       ),
       (() => {
-        const d = desc("ReadFullDocsMethodSchema");
+        const d = desc2("ReadFullDocsMethodSchema");
         return {
           articleUrl: external_exports.string().url().describe(d.articleUrl),
           reason: external_exports.string().describe(d.reason)
@@ -74450,7 +75327,7 @@ ${text}`
       })(),
       { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       async ({ articleUrl, reason }, { httpClient }) => {
-        const validPrefixes = ["https://dev.wix.com/docs/"];
+        const validPrefixes = [...docsUrlPrefixes];
         if (skillsPortalUrl) validPrefixes.push(skillsPortalUrl);
         if (!validPrefixes.some((p) => articleUrl.startsWith(p))) {
           return {
@@ -74466,6 +75343,7 @@ ${text}`
         if (articleUrl.startsWith("https://dev.wix.com/docs/")) {
           articleUrl = articleUrl.replace(/\.md$/, "");
         }
+        articleUrl = toBackendUrl(articleUrl);
         try {
           logger2.log(
             `[ReadFullDocsMethodSchema] url="${articleUrl}", reason="${reason}"`
@@ -74483,12 +75361,18 @@ ${text}`
           if (!articleContent) {
             throw new Error("Method schema is empty");
           }
+          const schemaText = mintlifyDocs ? (await rewriteDocsLinks(articleContent, {
+            label: "schema ReadFullDocsMethodSchema"
+          })).text : articleContent;
           return {
             content: [
               {
                 type: "text",
-                text: articleContent
-              }
+                text: schemaText
+              },
+              ...sourceNote(
+                `PAPI, through today's backend (dev.wix.com/rawdocs, ingvar): ${articleUrl}`
+              )
             ]
           };
         } catch (error2) {
@@ -74534,7 +75418,7 @@ ${text}`
         defaultToolDescriptions.BrowseWixRESTDocsMenu
       ),
       (() => {
-        const d = desc("BrowseWixRESTDocsMenu");
+        const d = desc2("BrowseWixRESTDocsMenu");
         return {
           menuUrl: external_exports.string().optional().describe(d.menuUrl),
           reason: external_exports.string().describe(d.reason)
@@ -74543,7 +75427,7 @@ ${text}`
       { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
       async ({ menuUrl, reason }, { httpClient }) => {
         try {
-          if (menuUrl && !menuUrl.startsWith("https://dev.wix.com/docs/")) {
+          if (menuUrl && !docsUrlPrefixes.some((p) => menuUrl.startsWith(p))) {
             return {
               content: [
                 {
@@ -78655,11 +79539,11 @@ var getEncodingTransformGenerator = (binary, encoding, skipped) => {
     final: encodingStringFinal.bind(void 0, stringDecoder)
   };
 };
-var encodingUint8ArrayGenerator = function* (textEncoder3, chunk) {
+var encodingUint8ArrayGenerator = function* (textEncoder4, chunk) {
   if (Buffer3.isBuffer(chunk)) {
     yield bufferToUint8Array(chunk);
   } else if (typeof chunk === "string") {
-    yield textEncoder3.encode(chunk);
+    yield textEncoder4.encode(chunk);
   } else {
     yield chunk;
   }
@@ -85465,6 +86349,16 @@ var getRetryHint = (errorDetails) => {
   }
   return /"operator":"\{/.test(errorDetails) ? SINGLE_OPERATOR_PER_FIELD_HINT : FIELD_CAPABILITIES_HINT;
 };
+var NO_SITE_IN_REQUEST = /META_SITE_NOT_FOUND|MetaSite(?:Id)? (?:context )?(?:is missing|was not found|not found)|NO_METASITE_IN_CALL_CONTEXT|MISSING_METASITE_ID|MISSING_REQUEST_SITE_CONTEXT|metasiteId from the request context/i;
+function missingSiteContext(status, responseData) {
+  const details = typeof responseData === "string" ? responseData : JSON.stringify(responseData ?? "");
+  if (NO_SITE_IN_REQUEST.test(details)) return "certain";
+  const parsed = typeof responseData === "string" ? safeParseJSON(responseData) : responseData;
+  if (status === 403 && parsed && typeof parsed === "object" && !parsed.message) {
+    return "likely";
+  }
+  return null;
+}
 var DEFAULT_OPENAI_SECURITY_SCHEMES = [
   { type: "oauth2", scopes: ["offline_access"] }
 ];
@@ -85479,7 +86373,8 @@ var buildErrorMessage = ({
   status,
   statusText,
   requestId,
-  responseData
+  responseData,
+  retryHint
 }) => {
   const responseDataObject = typeof responseData === "string" ? safeParseJSON(responseData) : responseData;
   const errorDetails = typeof responseDataObject === "object" ? JSON.stringify(responseDataObject) : responseDataObject;
@@ -85491,7 +86386,7 @@ var buildErrorMessage = ({
   ].filter((str) => !!str).join("\n");
   return `${baseMessage}
 
-${getRetryHint(String(errorDetails))}`;
+${retryHint ?? getRetryHint(String(errorDetails))}`;
 };
 var handleWixAPIResponse = async (response) => {
   const requestId = response.headers?.["x-wix-request-id"];
@@ -85632,6 +86527,170 @@ function createToolBiEvent(params) {
   return wixMcpRequestSrc39Evid1607(params);
 }
 
+// src/api-call/site-files.ts
+var MAX_FILES_BUNDLE_CHARS = 4e6;
+var MAX_UNZIP_BYTES = 64 * 1024 * 1024;
+var textEncoder3 = new TextEncoder();
+function base64ToBytes(b64) {
+  const clean = b64.replace(/^data:[^,]*,/, "").replace(/\s+/g, "");
+  return Uint8Array.from(atob(clean), (c3) => c3.charCodeAt(0));
+}
+function parseFileBundle(bundle) {
+  if (!bundle || !bundle.trim()) return [];
+  if (bundle.length > MAX_FILES_BUNDLE_CHARS) {
+    throw new Error(
+      `files bundle is too large (${bundle.length} chars; max ${MAX_FILES_BUNDLE_CHARS}). Keep it to text and small base64 assets; pass larger files through attachments or reference media by URL.`
+    );
+  }
+  const delimiter = /^=== FILE: (.+?)(?: (base64))? ===[ \t]*$/gm;
+  const matches = [...bundle.matchAll(delimiter)];
+  if (matches.length === 0) {
+    throw new Error(
+      "files bundle has no `=== FILE: <path> ===` sections. Start each file with that line (add ` base64` before the closing === for binary content)."
+    );
+  }
+  return matches.map((match, i2) => {
+    const path10 = match[1].trim();
+    const start = (match.index ?? 0) + match[0].length;
+    const end = i2 + 1 < matches.length ? matches[i2 + 1].index ?? bundle.length : bundle.length;
+    const content = bundle.slice(start, end).replace(/^\r?\n/, "").replace(/\r?\n$/, "");
+    return {
+      path: path10,
+      bytes: match[2] === "base64" ? base64ToBytes(content) : textEncoder3.encode(content)
+    };
+  });
+}
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n2 = 0; n2 < 256; n2++) {
+    let c3 = n2;
+    for (let k = 0; k < 8; k++) c3 = c3 & 1 ? 3988292384 ^ c3 >>> 1 : c3 >>> 1;
+    t[n2] = c3 >>> 0;
+  }
+  return t;
+})();
+
+// src/infra/redact-personal-data.ts
+var FREE_TEXT_INFO_PARAMS = [
+  "userRequest",
+  "siteDescription",
+  "siteForm",
+  "siteFunctionality",
+  "agentIdentity",
+  "wixAccess",
+  "reason",
+  "whyNotExecuteWixAPI",
+  "editorRequest",
+  "templateRequest"
+];
+var EMAIL = /[A-Z0-9._%+-]+@[A-Z0-9-]+(?:\.[A-Z0-9-]+)*\.[A-Z]{2,}/gi;
+var NAMED_SECRET = /\b(passwords?|passwd|pwd|passcodes?|secrets?|tokens?|api[ _-]?keys?|access[ _-]?keys?|credentials?)(\s*[:=]\s*|\s+(?:is|was|to)\s+)(?:"[^"]*"|'[^']*'|`[^`]*`|[^\s"'`,;][^,;\n]*?(?=[.!?]\s|[,;\n]|$))/gi;
+var BEARER = /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi;
+var JWT = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var KEY_PREFIXES = /\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|github_pat_\w{20,}|xox[abprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{35})\b/g;
+var BACKTICK = "`";
+var UNIX_ROOT = String.raw`(?<![\w.:/~-])(?:~|/(?:Users|home|root|mnt|tmp|private|var|Volumes|workspace|work))`;
+var WINDOWS_ROOT = String.raw`(?<!\w)[A-Za-z]:(?=\\\w)`;
+var PATH_ROOT = `(?:${UNIX_ROOT}|${WINDOWS_ROOT})`;
+var QUOTED_PATH = new RegExp(
+  String.raw`(?<![\w])(["'${BACKTICK}])${PATH_ROOT}[^"'${BACKTICK}\n]*\1`,
+  "g"
+);
+var FOLDER = String.raw`[^\s/\\"'${BACKTICK},;()<>]+(?: [^\s/\\"'${BACKTICK},;()<>]+)*`;
+var LOCAL_PATH = new RegExp(
+  String.raw`${PATH_ROOT}(?:[/\\]${FOLDER}(?=[/\\]))*[/\\][^\s"'${BACKTICK},;()<>]*`,
+  "g"
+);
+var PHONE_CANDIDATE = /(?<![\w-])\+?\(?\d[\d\s().-]{7,}\d(?![\w-])/g;
+var DATE_START = /^\d{4}-\d{2}-\d{2}/;
+function redactPhone(match, offset, text) {
+  if (DATE_START.test(match) || /^:\d{2}\b/.test(text.slice(offset + match.length))) {
+    return match;
+  }
+  const digits = match.replace(/\D/g, "").length;
+  return digits >= 9 && digits <= 15 ? "[phone]" : match;
+}
+function redactPersonalData(text) {
+  return text.replace(EMAIL, "[email]").replace(BEARER, "Bearer [secret]").replace(JWT, "[secret]").replace(KEY_PREFIXES, "[secret]").replace(NAMED_SECRET, "$1$2[secret]").replace(QUOTED_PATH, "$1[path]$1").replace(LOCAL_PATH, "[path]").replace(PHONE_CANDIDATE, redactPhone);
+}
+function redactInfoParams(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const record2 = value;
+  if (!FREE_TEXT_INFO_PARAMS.some((key) => typeof record2[key] === "string")) {
+    return value;
+  }
+  const redacted = { ...record2 };
+  for (const key of FREE_TEXT_INFO_PARAMS) {
+    if (typeof redacted[key] === "string") {
+      redacted[key] = redactPersonalData(redacted[key]);
+    }
+  }
+  return redacted;
+}
+var MAX_LISTED_PATHS_CHARS = 2e3;
+function summarizeFileBundle(bundle) {
+  let sections;
+  try {
+    sections = parseFileBundle(bundle).map((file) => ({
+      path: file.path,
+      bytes: file.bytes.length
+    }));
+  } catch {
+    sections = [];
+  }
+  if (sections.length === 0) {
+    return `${new TextEncoder().encode(bundle).length} bytes, no file sections`;
+  }
+  return formatFileSummary(sections);
+}
+function formatFileSummary(files) {
+  const total = files.reduce((sum, file) => sum + file.bytes, 0);
+  let listed = "";
+  let shown = 0;
+  for (const file of files) {
+    const entry = `${shown ? ", " : ""}${file.path} (${file.bytes})`;
+    if (listed.length + entry.length > MAX_LISTED_PATHS_CHARS) break;
+    listed += entry;
+    shown++;
+  }
+  const more = files.length - shown;
+  return `${files.length} file(s), ${total} bytes: ${listed}${more ? `${shown ? ", " : ""}and ${more} more` : ""}`;
+}
+function compactFileParams(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const record2 = value;
+  const files = record2.files;
+  if (typeof files === "string") {
+    return { ...record2, files: summarizeFileBundle(files) };
+  }
+  if (Array.isArray(files) && files.length > 0 && files.every(
+    (entry) => entry && typeof entry === "object" && typeof entry.content === "string"
+  )) {
+    return {
+      ...record2,
+      files: formatFileSummary(
+        files.map((entry) => ({
+          path: entry.path ?? "?",
+          bytes: new TextEncoder().encode(entry.content).length
+        }))
+      )
+    };
+  }
+  return value;
+}
+function prepareForBi(value) {
+  return compactFileParams(redactInfoParams(value));
+}
+function serializeToolParamsForBi(args) {
+  return JSON.stringify(
+    Array.isArray(args) ? args.map(prepareForBi) : prepareForBi(args)
+  );
+}
+
 // src/wix-mcp-server.ts
 var WixMcpServer = class extends McpServer {
   constructor(serverInfo, options, context2) {
@@ -85656,13 +86715,14 @@ var WixMcpServer = class extends McpServer {
   gptAppSchemesEnabled = false;
   openAiMcpAppsEnabled = false;
   mcpAppsInMcpEnabled = true;
+  registeredTools = /* @__PURE__ */ new Map();
   setUserIdGetter(getUserId) {
     this.getUserId = getUserId;
   }
   getSessionId() {
     return this.sessionId;
   }
-  /** The connected client's name: the host's getter (User-Agent fallback) first, then clientInfo. */
+  /** The connected client's name: the host's getter (initialize name, then User-Agent) first, then clientInfo. */
   clientName() {
     return this.getClientName?.() ?? this.server.getClientVersion()?.name;
   }
@@ -85672,6 +86732,17 @@ var WixMcpServer = class extends McpServer {
   setUserAgentGetter(getUserAgent) {
     this.getUserAgent = getUserAgent;
   }
+  /** True when every named tool is registered and enabled in this session. */
+  hasTools(...names) {
+    return names.every((name) => this.registeredTools.get(name)?.enabled);
+  }
+  /**
+   * Sets the `instructions` the server returns at initialize. Call it before the transport
+   * connects. The SDK keeps them on the low-level server and has no setter for them.
+   */
+  setInstructions(instructions) {
+    this.server._instructions = instructions;
+  }
   setGptAppSchemesEnabled(enabled) {
     this.gptAppSchemesEnabled = enabled;
   }
@@ -85727,6 +86798,7 @@ var WixMcpServer = class extends McpServer {
       args[cbIndex] = this.wrapToolCallback(toolName, originalCb);
     }
     const registeredTool = super.tool.apply(this, args);
+    this.registeredTools.set(args[0], registeredTool);
     if (this.isGptAppSchemesEnabled() && !registeredTool._meta?.securitySchemes) {
       registeredTool.update({
         _meta: {
@@ -85748,11 +86820,13 @@ var WixMcpServer = class extends McpServer {
       };
     }
     const wrappedCb = this.wrapToolCallback(name, cb);
-    return super.registerTool(
+    const registeredTool = super.registerTool(
       name,
       config3,
       wrappedCb
     );
+    this.registeredTools.set(name, registeredTool);
+    return registeredTool;
   }
   wrapToolCallback(toolName, originalCb) {
     const isDevEnvironment = DEV_ENVIRONMENTS.includes(this.nodeEnv);
@@ -85794,7 +86868,7 @@ var WixMcpServer = class extends McpServer {
         });
         panorama.transaction(toolName).start({
           toolInvocationId,
-          params: JSON.stringify(argsBeforeExtra)
+          params: serializeToolParamsForBi(argsBeforeExtra)
         });
       }
       const startTime = performance.now();
@@ -85811,7 +86885,8 @@ var WixMcpServer = class extends McpServer {
             cbResult,
             {
               returnedRows: toolBiParams.returnedRows,
-              originalLength: toolBiParams.originalLength
+              originalLength: toolBiParams.originalLength,
+              upload: toolBiParams.upload
             },
             {
               name: this.getClientName?.() || this.server.getClientVersion()?.name,
@@ -85827,7 +86902,7 @@ var WixMcpServer = class extends McpServer {
             context: {
               toolName,
               toolInvocationId,
-              params: JSON.stringify(argsBeforeExtra),
+              params: serializeToolParamsForBi(argsBeforeExtra),
               error: JSON.stringify(cbResult, null, 2)
             }
           });
@@ -85841,7 +86916,7 @@ var WixMcpServer = class extends McpServer {
             context: {
               toolName,
               toolInvocationId,
-              params: JSON.stringify(argsBeforeExtra),
+              params: serializeToolParamsForBi(argsBeforeExtra),
               error: errorBody
             }
           });
@@ -85890,7 +86965,7 @@ var WixMcpServer = class extends McpServer {
               errorBody,
               toolInvocationId,
               toolName,
-              params: JSON.stringify(argsBeforeExtra),
+              params: serializeToolParamsForBi(argsBeforeExtra),
               origin: this.nodeEnv,
               sessionId: this.sessionId,
               executionResult: toolSucceeded ? "Success" : "Error",
@@ -86133,7 +87208,7 @@ function resolveBase64Image(imageBase64, mimeType) {
 function errorResponse(text) {
   return { isError: true, content: [{ type: "text", text }] };
 }
-async function uploadFromUrl(item, authHeaders, displayName) {
+async function uploadFromUrl(item, authHeaders, displayName, imagePickerToolName) {
   if (!item.download_url) {
     return {
       success: false,
@@ -86143,7 +87218,7 @@ async function uploadFromUrl(item, authHeaders, displayName) {
   if (!/^https?:\/\//i.test(item.download_url)) {
     return {
       success: false,
-      error: `download_url must be a publicly accessible http(s) URL, not a local or sandbox file path (got: "${item.download_url}"). For a user-attached file, pass the file so the platform resolves it to a real download_url; if you only have the raw bytes, use imageBase64 instead.`
+      error: `This server can't read files on your machine or sandbox (got: "${item.download_url}"). Send this image as imageBase64 (the whole file, one per call) or as a public URL in imageUrls${imagePickerToolName ? `, or call ${imagePickerToolName} so the user picks it` : ""}.`
     };
   }
   try {
@@ -86241,7 +87316,10 @@ function formatBatchResults(results) {
   };
 }
 function addUploadImageTool(server2, strategy, options) {
-  const description = options?.description ?? defaultToolDescriptions.UploadImageToWixSite;
+  const imagePickerToolName = options?.imagePickerToolName;
+  const baseDescription = options?.description || defaultToolDescriptions.UploadImageToWixSite;
+  const description = imagePickerToolName ? `${baseDescription}
+If you can't deliver the image any of these ways, call ${imagePickerToolName} so the user picks it.` : baseDescription;
   const hints = {
     readOnlyHint: options?.hints?.readOnlyHint ?? false,
     destructiveHint: options?.hints?.destructiveHint ?? false,
@@ -86308,7 +87386,9 @@ function addUploadImageTool(server2, strategy, options) {
       try {
         const authHeaders = await strategy.getSiteAuthHeaders(siteId);
         const urlResults = await Promise.all(
-          urlItems.map((item) => uploadFromUrl(item, authHeaders, displayName))
+          urlItems.map(
+            (item) => uploadFromUrl(item, authHeaders, displayName, imagePickerToolName)
+          )
         );
         let base64Result = null;
         if (imageBase64) {
@@ -86344,6 +87424,9 @@ function addUploadImageTool(server2, strategy, options) {
 var MAX_ALLOWED_RESPONSE_CHARS = 2e6;
 
 // src/api-call/index.ts
+var siteToolCall = (executeServed) => executeServed ? "through ExecuteWixAPI with that site's `siteId` (`scope: \"site\"`), loading ExecuteWixAPI through your client's tool search if it isn't loaded" : "through CallWixSiteAPI with that site's `siteId`";
+var manageNoSiteHint = (executeServed) => `This is a site-level API: it acts inside a site, and ManageWixSite sends no site, so the same call fails here every time. Call the same URL, method and body ${siteToolCall(executeServed)}.`;
+var manageEmpty403Hint = (executeServed) => `If this endpoint acts inside a site (its products, data, bookings, members, pages, publishing), it is site-level, and ManageWixSite sends no site: call the same URL, method and body ${siteToolCall(executeServed)}. If it acts on the account or on sites as objects in it, the account lacks the permission; don't retry.`;
 var DEFAULT_MAX_RESPONSE_SIZE = 5e4;
 function extractReturnedRows(responseData) {
   if (responseData === null || typeof responseData !== "object") {
@@ -86375,7 +87458,8 @@ function formatApiResponse(responseData, maxResponseSize = DEFAULT_MAX_RESPONSE_
   }
   return { text: responseText, isError: false, originalLength, returnedRows };
 }
-function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "ListWixSites", "ManageWixSite"], disableTools = [], enableTools = [], toolDescriptions, toolHints, maxResponseSize) {
+function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "ListWixSites", "ManageWixSite"], disableTools = [], enableTools = [], toolDescriptions, toolHints, maxResponseSize, options) {
+  const executeAdvice = (text, reconnect, plain) => options?.executeWixAPIServed ? text : text.replace(reconnect, plain);
   const effectiveAllowedTools = [
     .../* @__PURE__ */ new Set([...allowedTools, ...enableTools])
   ].filter((tool) => !disableTools.includes(tool));
@@ -86388,7 +87472,14 @@ function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "Li
   if (effectiveAllowedTools.includes("CallWixSiteAPI") && !disableTools.includes("CallWixSiteAPI")) {
     server2.tool(
       "CallWixSiteAPI",
-      getDescription("CallWixSiteAPI", defaultToolDescriptions.CallWixSiteAPI),
+      executeAdvice(
+        getDescription(
+          "CallWixSiteAPI",
+          defaultToolDescriptions.CallWixSiteAPI
+        ),
+        CALL_WIX_SITE_API_RECONNECT_LINE,
+        CALL_WIX_SITE_API_NO_EXECUTE_LINE
+      ),
       (() => {
         const d = desc("CallWixSiteAPI");
         return {
@@ -86397,6 +87488,13 @@ function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "Li
           method: external_exports.string().describe(d.method),
           body: external_exports.union([external_exports.object({}).passthrough(), external_exports.array(external_exports.unknown())]).optional().describe(d.body),
           reason: external_exports.string().describe(d.reason),
+          whyNotExecuteWixAPI: external_exports.string().optional().describe(
+            executeAdvice(
+              d.whyNotExecuteWixAPI,
+              WHY_NOT_EXECUTE_RECONNECT,
+              WHY_NOT_EXECUTE_NO_EXECUTE
+            )
+          ),
           sourceDocUrl: external_exports.string().describe(d.sourceDocUrl)
         };
       })(),
@@ -86407,9 +87505,17 @@ function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "Li
         destructiveHint: true,
         openWorldHint: true
       }),
-      async ({ url, body, method, siteId, reason, sourceDocUrl }, { httpClient, setToolBiParams }) => {
+      async ({
+        url,
+        body,
+        method,
+        siteId,
+        reason,
+        whyNotExecuteWixAPI,
+        sourceDocUrl
+      }, { httpClient, setToolBiParams }) => {
         logger2.log(
-          `[CallWixSiteAPI] siteId=${siteId}, method=${method}, url=${url}, sourceDocUrl=${sourceDocUrl}, reason="${reason}", body=${JSON.stringify(body)}`
+          `[CallWixSiteAPI] siteId=${siteId}, method=${method}, url=${url}, sourceDocUrl=${sourceDocUrl}, reason="${reason}", whyNotExecuteWixAPI="${whyNotExecuteWixAPI ?? ""}", body=${JSON.stringify(body)}`
         );
         const requestHeaders = {
           // Ask the Wix API edge for JSON error bodies (it serves a branded HTML
@@ -86644,6 +87750,18 @@ function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "Li
           if (!response) {
             throw new Error(`Failed to call Wix Account API: ${error2}`);
           }
+          const noSite = missingSiteContext(response.status, response.data);
+          if (noSite) {
+            throw new Error(
+              buildErrorMessage({
+                status: response.status,
+                statusText: response.statusText,
+                requestId: response.headers?.["x-wix-request-id"] ?? null,
+                responseData: response.data,
+                retryHint: (noSite === "certain" ? manageNoSiteHint : manageEmpty403Hint)(!!options?.executeWixAPIServed)
+              })
+            );
+          }
           return handleWixAPIResponse(response);
         }
       }
@@ -86652,7 +87770,8 @@ function addApiCallTool(server2, strategy, allowedTools = ["CallWixSiteAPI", "Li
   if (effectiveAllowedTools.includes("UploadImageToWixSite") && !disableTools.includes("UploadImageToWixSite")) {
     addUploadImageTool(server2, strategy, {
       description: getDescription("UploadImageToWixSite", ""),
-      hints: toolHints?.["UploadImageToWixSite"]
+      hints: toolHints?.["UploadImageToWixSite"],
+      imagePickerToolName: options?.imagePickerToolName
     });
   }
 }
@@ -86932,10 +88051,14 @@ function truncateResponse(content, maxChars = DEFAULT_MAX_CHARS) {
   const truncated = text.slice(0, effectiveMax);
   const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
   const limitTokens = Math.ceil(effectiveMax / CHARS_PER_TOKEN);
-  return `${truncated}
+  const cutChars = text.length - effectiveMax;
+  const note = `Response was ~${estimatedTokens.toLocaleString()} tokens (limit: ${limitTokens.toLocaleString()}). Showing the first ${effectiveMax.toLocaleString()} of ${text.length.toLocaleString()} characters; the last ${cutChars.toLocaleString()} were cut. To get the rest, run again and return less per call \u2014 only the fields you need, the next page (cursor or offset), or the next slice of a large array \u2014 and repeat until you have it all.`;
+  return `[TRUNCATED: ${note}]
+
+${truncated}
 
 --- TRUNCATED ---
-Response was ~${estimatedTokens.toLocaleString()} tokens (limit: ${limitTokens.toLocaleString()}). Refine your code to return less data.`;
+${note}`;
 }
 
 // src/graphql/constants.ts
@@ -87772,7 +88895,9 @@ if (docsTools.length > 0 || hasGetToKnowWix) {
   logger2.log("Adding docs tools:", docsTools);
   addDocsTools(server, docsTools, {
     getToKnowWixEnabled: hasGetToKnowWix,
-    dynamicContextEnabled: hasDynamicContext
+    dynamicContextEnabled: hasDynamicContext,
+    // Mintlify docs: --docsSite=mintlify-links (or WIX_MCP_DOCS_SITE).
+    docsSite: parsedArgs["docsSite"] ?? process.env.WIX_MCP_DOCS_SITE
   });
 }
 if (activeTools.includes("VELO_README")) {