@wix/mcp 1.0.94 → 1.0.96

package/build/esm/toolkit.js

@@ -10682,6 +10682,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");
   }
   logger.log(
     `[SemanticSearch] Tool: ${toolName}, KBs: [${kbNames.join(", ")}], Query: "${toolParams.searchTerm}"`
@@ -10714,9 +10716,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;
   logger.log(
     `[SemanticSearch/v2] Tool: ${documentTypes ? documentTypes.join("+") : toolName}, Query: "${searchTerm}"`
   );
@@ -10760,15 +10762,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(
@@ -11685,6 +11689,7 @@ function captureException(exception, hint) {
 // 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`;
@@ -11705,7 +11710,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;
@@ -11803,6 +11814,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 path = parsed.searchParams.get("path");
+  const commitHash = parsed.searchParams.get("commitHash");
+  if (!repo || !path) return void 0;
+  return commitHash ? { repo, path, commitHash } : { repo, path };
+}
+async function fetchSourceContent(httpClient, repo, path, commitHash) {
+  const url = new URL(GET_SOURCE_CONTENT_URL);
+  url.searchParams.set("repo", repo);
+  url.searchParams.set("path", path);
+  if (commitHash) url.searchParams.set("commitHash", commitHash);
+  let data;
+  try {
+    ({ data } = await httpClient.get(url.toString()));
+  } catch (error) {
+    const { message, status } = getHttpErrorDetails(error);
+    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;
@@ -11816,7 +11861,10 @@ async function fetchArticleContent(httpClient, articleUrl, mode, stripHeader = f
         `[fetch] Override failed for ${effectiveUrl}, falling back to ${articleUrl}:`,
         error instanceof Error ? error.message : error
       );
-      content = isSkillsRegistryUrl(articleUrl) ? await fetchSkillsRegistryPage(httpClient, articleUrl) : await fetchArticleContentFromDigor(
+      content = isSkillsRegistryUrl(articleUrl) ? await fetchSkillsRegistryPage(
+        httpClient,
+        normalizeSkillsUrl(articleUrl)
+      ) : await fetchArticleContentFromDigor(
         httpClient,
         articleUrl,
         mode,
@@ -11824,7 +11872,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 {
@@ -11967,6 +12018,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(a, b) {
+  const x = slugWords(a);
+  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 = (path) => path.slice(path.lastIndexOf("/") + 1);
+var folderOf = (path) => path.includes("/") ? path.slice(0, path.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((a, b) => b.score - a.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((a, b) => b.score - a.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((a, b) => b.score - a.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 ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
@@ -12111,54 +12296,97 @@ function rethrowIfUnauthorized(error) {
 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:"
     );
   }
@@ -12191,41 +12419,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:
@@ -12311,7 +12520,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 ===
@@ -12326,6 +12535,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" }]
@@ -12449,22 +12659,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}
@@ -12486,6 +12711,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"}]).
@@ -12500,6 +12726,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." : ""}
 
@@ -12520,13 +12747,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.
@@ -12536,34 +12763,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.
@@ -12585,25 +12817,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.
@@ -12633,6 +12847,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.
@@ -12643,7 +12864,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`
@@ -12655,7 +12876,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]\`.
@@ -13036,27 +13258,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.
 
@@ -13090,102 +13303,211 @@ 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).
   `
   };
+  descriptions.SupportAndFeedback = descriptions.ReportIssueToWix;
+  return descriptions;
 }
-var defaultToolDescriptions = buildToolDescriptions(true);
+var defaultToolDescriptions = buildToolDescriptions(true, true, { usageGuideOnce: true });
 var executeCodeModeToolDescriptions = {
   ExecuteWixAPI: executeWixApiDescription
 };
+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();
 function mergeConfig(base, overrides) {
   return {
     toolDescriptions: {
@@ -13224,7 +13546,7 @@ var defaultConfig = {
 var widgetSiteCreationConfig = {
   toolDescriptions: Object.fromEntries(
     [
-      "WixSiteBuilder",
+      "WixHarmonyEditorBuild",
       "WixSiteCreation",
       "SearchSiteTemplates",
       "CreateSiteFromTemplate"
@@ -13371,6 +13693,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");
@@ -13391,6 +13716,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 = [];
@@ -13417,7 +13747,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}`);
@@ -13462,6 +13792,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("");
@@ -13481,6 +13818,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;
@@ -13533,9 +13871,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 i = 0; i < sitesToRender.length; i++) {
-      sections.push(renderSite(sitesToRender[i], i + 1, knownApps));
+      sections.push(renderSite(sitesToRender[i], i + 1, knownApps, includeCompanionApp));
     }
   }
   if (!response.account && !siteCount && (!includePartnerContext || !hasPartnerContext(response.partnerContext))) {
@@ -13543,9 +13890,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();
@@ -13608,6 +13957,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;
@@ -13661,6 +14011,7 @@ async function getDynamicContext(auth, httpClient, filter, options) {
     const context = 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 } : {}
     });
@@ -13714,6 +14065,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",
@@ -13730,6 +14096,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 !!!",
@@ -13765,18 +14132,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"
@@ -13815,8 +14173,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).",
@@ -13832,7 +14195,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.',
@@ -13869,10 +14232,315 @@ 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 path = pathname.replace(/\.md$/, "").replace(/\/+$/, "");
+  return path === "" ? "/" : path;
+}
+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 path2 = cleanPath(url.pathname);
+    return { url: `${MINTLIFY_HOST}${path2}`, path: path2, 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 path = `/${segments.join("/")}`;
+  return { url: `${MINTLIFY_HOST}${path}`, path, 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(path, result) {
+  const now = Date.now();
+  checkCache.delete(path);
+  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(path, { 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(path) {
+  const cached = checkCache.get(path);
+  if (cached && cached.expires > Date.now()) {
+    return cached.result;
+  }
+  if (cached) checkCache.delete(path);
+  let result;
+  try {
+    let current = path;
+    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 (error) {
+    logger.error(`[mintlify] page check failed for ${path}: ${error}`);
+    result = { outcome: "error" };
+  }
+  rememberCheck(path, 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 check = await checkMintlifyPage(candidate.path);
+  if (check.path) {
+    return {
+      outcome: check.outcome,
+      url: `${MINTLIFY_HOST}${check.path}${query}`
+    };
+  }
+  return { outcome: check.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(/[.,;:!?*]+$/, "");
+}
+var MINTLIFY_LINK_PATTERN = /https:\/\/wix-internal\.mintlify\.(?:site|app)\/[^\s)\]"'<>`]*/g;
+function toDevWixHostText(text) {
+  return text.replace(MINTLIFY_LINK_PATTERN, (match) => {
+    const link = trimTrailingPunctuation(match);
+    let url;
+    try {
+      url = new URL(link);
+    } catch {
+      return match;
+    }
+    if (!MINTLIFY_TABS.has(url.pathname.split("/")[1] ?? "")) return match;
+    return toDevWixUrl(link) + url.hash + match.slice(link.length);
+  });
+}
+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 replacements = /* @__PURE__ */ new Map();
+  found.forEach((url, i) => {
+    const { outcome, url: target } = resolved[i];
+    stats.byOutcome[outcome] = (stats.byOutcome[outcome] ?? 0) + 1;
+    if (outcome === "identity" || outcome === "redirect") {
+      if (target !== url) replacements.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 = replacements.get(url);
+    return target ? target + match.slice(url.length) : match;
+  });
+  logger.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);
+  logger.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,
   authStrategy,
+  includeCompanionApp = false,
   toolDescriptions
 }) {
   const d = desc("GetSiteContext");
@@ -13902,7 +14570,8 @@ function addGetSiteContextTool({
       try {
         context = await getDynamicContext(authStrategy, httpClient, filter, {
           partnerContextEnabled: false,
-          includeAccountContext: false
+          includeAccountContext: false,
+          includeCompanionApp
         });
       } catch (err) {
         rethrowIfUnauthorized(err);
@@ -13938,15 +14607,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) : [];
   server.tool(
     "WixREADME",
     toolDescriptions?.["WixREADME"] ?? defaultToolDescriptions.WixREADME,
@@ -14018,6 +14689,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,
@@ -14060,9 +14743,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;
@@ -14082,7 +14765,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({
@@ -14092,9 +14775,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",
@@ -14112,7 +14793,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 }]
       };
@@ -14121,13 +14803,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
@@ -14135,10 +14818,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()
@@ -14146,7 +14830,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(server, disableTools = [], toolDescriptions, fetchOptions = {}) {
@@ -14194,36 +14878,21 @@ function addStartDeployWebsiteTool(server, 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(server, disableTools = [], toolDescriptions, fetchOptions = {}) {
   if (disableTools.includes(START_HEADLESS_BUILD_TOOL_NAME)) {
@@ -14236,13 +14905,13 @@ function addStartHeadlessBuildTool(server, 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(
@@ -14264,7 +14933,7 @@ function addStartHeadlessBuildTool(server, disableTools = [], toolDescriptions,
         content: [
           {
             type: "text",
-            text: startHeadlessBuildResponse(guide, args.startingPoint)
+            text: startHeadlessBuildResponse(guide)
           }
         ]
       };
@@ -14300,9 +14969,16 @@ function shouldTryMenuFallbackForDocsRead(error, articleUrl) {
   if (!message.includes("404") || !isMenuFallbackUrl) {
     return false;
   }
-  return !["This resource is deprecated", "No schema found"].some(
-    (knownArticleError) => message.includes(knownArticleError)
-  );
+  return !isKnownArticleError(error);
+}
+function isKnownArticleError(error) {
+  const message = getErrorMessage(error);
+  return [
+    "This resource is deprecated",
+    "This method is deprecated",
+    "This article is deprecated",
+    "No schema found"
+  ].some((knownArticleError) => message.includes(knownArticleError));
 }
 function formatDocsReadError(toolAction, error) {
   return `Could not fetch ${toolAction}: "${getErrorMessage(error)}".`;
@@ -14315,7 +14991,8 @@ var addDocsTools = (server, allowedTools = [
   "WIX_HEADLESS",
   "BUSINESS_SOLUTIONS",
   "CLI",
-  "OVERVIEW"
+  "OVERVIEW",
+  "HELP_CENTER"
 ], options = {}) => {
   const {
     getToKnowWixEnabled = false,
@@ -14331,14 +15008,47 @@ var addDocsTools = (server, 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);
@@ -14355,10 +15065,77 @@ var addDocsTools = (server, 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 (error) {
+      logger.error(`[docs] no nearest page for ${url}: ${error}`);
+    }
+    return null;
+  };
+  if (startDeployWebsiteEnabled) {
+    addStartDeployWebsiteTool(server, disableTools || [], toolDescriptions, {
+      skillsPortalUrl,
+      repo: effectiveRepo,
+      commitHash: effectiveCommitHash
+    });
+  }
+  if (startHeadlessBuildEnabled) {
+    addStartHeadlessBuildTool(server, disableTools || [], toolDescriptions, {
+      skillsPortalUrl,
+      repo: effectiveRepo,
+      commitHash: effectiveCommitHash
+    });
+  }
   if (dynamicContextEnabled && authStrategy && !disableTools?.includes("GetSiteContext")) {
     addGetSiteContextTool({
       server,
       authStrategy,
+      includeCompanionApp,
       toolDescriptions,
       disableTools: disableTools || []
     });
@@ -14374,21 +15151,9 @@ var addDocsTools = (server, allowedTools = [
       dynamicContextEnabled,
       repo: effectiveRepo,
       commitHash: effectiveCommitHash,
-      skillsTags
-    });
-  }
-  if (startDeployWebsiteEnabled) {
-    addStartDeployWebsiteTool(server, disableTools || [], toolDescriptions, {
-      skillsPortalUrl,
-      repo: effectiveRepo,
-      commitHash: effectiveCommitHash
-    });
-  }
-  if (startHeadlessBuildEnabled) {
-    addStartHeadlessBuildTool(server, disableTools || [], toolDescriptions, {
-      skillsPortalUrl,
-      repo: effectiveRepo,
-      commitHash: effectiveCommitHash
+      skillsTags,
+      readmeRecipesIndexEnabled,
+      docsSite
     });
   }
   if (allowedTools.includes("WDS") && !disableTools?.includes("SearchWixWDSDocumentation")) {
@@ -14399,7 +15164,7 @@ var addDocsTools = (server, 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)
@@ -14409,7 +15174,7 @@ var addDocsTools = (server, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger.log(`Searching for ${searchTerm} in Wix WDS`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "WDS",
             toolParams: {
               searchTerm
@@ -14452,7 +15217,7 @@ var addDocsTools = (server, 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),
@@ -14465,7 +15230,7 @@ var addDocsTools = (server, allowedTools = [
           logger.log(
             `[SearchWixRESTDocumentation] searchTerm="${searchTerm}", reason="${reason}"`
           );
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "REST",
             toolParams: {
               searchTerm
@@ -14516,7 +15281,7 @@ var addDocsTools = (server, 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)
@@ -14526,7 +15291,7 @@ var addDocsTools = (server, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger.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
@@ -14572,7 +15337,7 @@ var addDocsTools = (server, 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)
@@ -14583,7 +15348,7 @@ var addDocsTools = (server, allowedTools = [
         try {
           logger.log(`Searching for ${searchTerm} in Wix SDK`);
           panorama.transaction("SearchWixSDKDocumentation").start({ maxResults });
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "SDK",
             toolParams: {
               searchTerm
@@ -14631,7 +15396,7 @@ var addDocsTools = (server, 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)
@@ -14641,7 +15406,7 @@ var addDocsTools = (server, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger.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}`
@@ -14683,7 +15448,7 @@ var addDocsTools = (server, 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)
@@ -14693,7 +15458,7 @@ var addDocsTools = (server, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger.log(`Searching for ${searchTerm} in Wix Overview`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "OVERVIEW",
             toolParams: {
               searchTerm
@@ -14735,7 +15500,7 @@ var addDocsTools = (server, 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)
@@ -14745,7 +15510,7 @@ var addDocsTools = (server, allowedTools = [
       async ({ searchTerm, maxResults }, { panorama }) => {
         try {
           logger.log(`Searching for ${searchTerm} in Headless`);
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "WIX_HEADLESS",
             toolParams: {
               searchTerm
@@ -14790,7 +15555,7 @@ var addDocsTools = (server, 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)
@@ -14801,7 +15566,7 @@ var addDocsTools = (server, allowedTools = [
         try {
           logger.log(`Searching for ${searchTerm} in Velo`);
           panorama.transaction("SearchWixVeloDocumentation").start({ maxResults });
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "VELO",
             toolParams: {
               searchTerm
@@ -14839,6 +15604,72 @@ var addDocsTools = (server, allowedTools = [
       }
     );
   }
+  if (allowedTools.includes("HELP_CENTER") && !disableTools?.includes("SearchWixHelpCenter")) {
+    server.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 {
+          logger.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 (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchWixHelpCenter",
+              toolName: "SearchWixHelpCenter"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in the Wix Help Center: ${error}`
+          );
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error.message}
+
+${HELP_CENTER_IS_FOR_PEOPLE}`
+              }
+            ]
+          };
+        }
+      }
+    );
+  }
   if (allowedTools.includes("CLI") && !disableTools?.includes("SearchWixCLIDocumentation")) {
     server.tool(
       "SearchWixCLIDocumentation",
@@ -14847,7 +15678,7 @@ var addDocsTools = (server, 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),
@@ -14860,7 +15691,7 @@ var addDocsTools = (server, allowedTools = [
           logger.log(
             `[SearchWixCLIDocumentation] searchTerm="${searchTerm}", reason="${reason}"`
           );
-          const result = await runSemanticSearchAndFormat({
+          const result = await runSearch({
             toolName: "CLI",
             toolParams: {
               searchTerm
@@ -14904,14 +15735,39 @@ var addDocsTools = (server, 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 (error) {
+            logger.error(
+              `Error fetching source content for ${articleUrl}: ${error}`
+            );
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: formatDocsReadError("source content", error)
+                }
+              ]
+            };
+          }
+        }
+        const validPrefixes = [...docsUrlPrefixes, "https://support.wix.com/"];
         if (skillsPortalUrl) validPrefixes.push(skillsPortalUrl);
         const isSkillsPage = isSkillsRegistryUrl(articleUrl);
         if (!isSkillsPage && !validPrefixes.some((p) => articleUrl.startsWith(p))) {
@@ -14920,7 +15776,7 @@ var addDocsTools = (server, 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}"`
               }
             ]
           };
@@ -14928,6 +15784,27 @@ var addDocsTools = (server, 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 (error) {
+            logger.error(
+              `[mintlify] reading ${articleUrl} from Mintlify failed, falling back: ${error}`
+            );
+          }
+          articleUrl = toBackendUrl(articleUrl);
+        }
         try {
           const articleContent = await fetchArticleContent(
             httpClient,
@@ -14948,7 +15825,10 @@ var addDocsTools = (server, 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 (error) {
@@ -14973,6 +15853,16 @@ ${text}`
             } catch {
             }
           }
+          if (getErrorMessage(error).includes("404") && !isKnownArticleError(error)) {
+            const nearest = await nearestToMissingPage(
+              httpClient,
+              articleUrl,
+              isSkillsPage
+            );
+            if (nearest) {
+              return { content: [{ type: "text", text: nearest }] };
+            }
+          }
           return {
             isError: true,
             content: [
@@ -14994,7 +15884,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)
@@ -15002,7 +15892,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 {
@@ -15018,6 +15908,7 @@ ${text}`
         if (articleUrl.startsWith("https://dev.wix.com/docs/")) {
           articleUrl = articleUrl.replace(/\.md$/, "");
         }
+        articleUrl = toBackendUrl(articleUrl);
         try {
           logger.log(
             `[ReadFullDocsMethodSchema] url="${articleUrl}", reason="${reason}"`
@@ -15035,12 +15926,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 (error) {
@@ -15086,7 +15983,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)
@@ -15095,7 +15992,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: [
                 {
@@ -15156,6 +16053,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 safeParseJSON = (text) => {
   try {
     return JSON.parse(text);
@@ -15167,7 +16074,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;
@@ -15179,7 +16087,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"];
@@ -15375,7 +16283,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,
@@ -15385,7 +16293,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 {
@@ -15483,7 +16391,10 @@ function formatBatchResults(results) {
   };
 }
 function addUploadImageTool(server, 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,
@@ -15550,7 +16461,9 @@ function addUploadImageTool(server, 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) {
@@ -15586,6 +16499,9 @@ function addUploadImageTool(server, 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") {
@@ -15617,7 +16533,8 @@ function formatApiResponse(responseData, maxResponseSize = DEFAULT_MAX_RESPONSE_
   }
   return { text: responseText, isError: false, originalLength, returnedRows };
 }
-function addApiCallTool(server, strategy, allowedTools = ["CallWixSiteAPI", "ListWixSites", "ManageWixSite"], disableTools = [], enableTools = [], toolDescriptions, toolHints, maxResponseSize) {
+function addApiCallTool(server, 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));
@@ -15630,7 +16547,14 @@ function addApiCallTool(server, strategy, allowedTools = ["CallWixSiteAPI", "Lis
   if (effectiveAllowedTools.includes("CallWixSiteAPI") && !disableTools.includes("CallWixSiteAPI")) {
     server.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 {
@@ -15639,6 +16563,13 @@ function addApiCallTool(server, strategy, allowedTools = ["CallWixSiteAPI", "Lis
           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)
         };
       })(),
@@ -15649,9 +16580,17 @@ function addApiCallTool(server, strategy, allowedTools = ["CallWixSiteAPI", "Lis
         destructiveHint: true,
         openWorldHint: true
       }),
-      async ({ url, body, method, siteId, reason, sourceDocUrl }, { httpClient, setToolBiParams }) => {
+      async ({
+        url,
+        body,
+        method,
+        siteId,
+        reason,
+        whyNotExecuteWixAPI,
+        sourceDocUrl
+      }, { httpClient, setToolBiParams }) => {
         logger.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
@@ -15886,6 +16825,18 @@ function addApiCallTool(server, strategy, allowedTools = ["CallWixSiteAPI", "Lis
           if (!response) {
             throw new Error(`Failed to call Wix Account API: ${error}`);
           }
+          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);
         }
       }
@@ -15894,7 +16845,8 @@ function addApiCallTool(server, strategy, allowedTools = ["CallWixSiteAPI", "Lis
   if (effectiveAllowedTools.includes("UploadImageToWixSite") && !disableTools.includes("UploadImageToWixSite")) {
     addUploadImageTool(server, strategy, {
       description: getDescription("UploadImageToWixSite", ""),
-      hints: toolHints?.["UploadImageToWixSite"]
+      hints: toolHints?.["UploadImageToWixSite"],
+      imagePickerToolName: options?.imagePickerToolName
     });
   }
 }
@@ -15912,10 +16864,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
@@ -16676,7 +17632,7 @@ ${text.slice(0, 2e3)}`
 
 // src/code-mode/attachments.ts
 var MAX_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
-var MAX_REDIRECTS = 4;
+var MAX_REDIRECTS2 = 4;
 var OAI_USERCONTENT_HOST = /^[a-z0-9-]+\.oaiusercontent\.com$/;
 var OAI_BLOB_ACCOUNTS = new Set(
   [
@@ -16707,15 +17663,18 @@ var OAI_BLOB_ACCOUNTS = new Set(
     "westus3"
   ].map((region) => `oaisdmntpr${region}.blob.core.windows.net`)
 );
-function isAllowedAttachmentHost(hostname) {
+var WIX_AI_ASSISTANT_ATTACHMENT_HOSTS = /* @__PURE__ */ new Set([
+  "wixmp-a85a29aaf55baa3e5171a82d.wixmp.com"
+]);
+function isAllowedAttachmentHost(hostname, extraHosts) {
   const h = hostname.toLowerCase();
-  return OAI_USERCONTENT_HOST.test(h) || OAI_BLOB_ACCOUNTS.has(h);
+  return OAI_USERCONTENT_HOST.test(h) || OAI_BLOB_ACCOUNTS.has(h) || !!extraHosts?.has(h);
 }
-function checkAttachmentUrl(url) {
+function checkAttachmentUrl(url, extraHosts) {
   if (url.protocol !== "https:") return "is not an https URL";
   if (url.port) return "uses a non-default port";
-  if (!isAllowedAttachmentHost(url.hostname)) {
-    return `host "${url.hostname}" is not a ChatGPT file host`;
+  if (!isAllowedAttachmentHost(url.hostname, extraHosts)) {
+    return `host "${url.hostname}" is not a chat attachment host`;
   }
   return void 0;
 }
@@ -16742,7 +17701,7 @@ function toBase64(bytes) {
   }
   return btoa(binary);
 }
-async function fetchAllowed(start, fetchImpl, label) {
+async function fetchAllowed(start, fetchImpl, label, extraHosts) {
   let url = start;
   for (let hop = 0; ; hop++) {
     const res = await fetchImpl(url.toString(), { redirect: "manual" });
@@ -16750,7 +17709,7 @@ async function fetchAllowed(start, fetchImpl, label) {
     const isRedirect = res.status >= 300 && res.status < 400 && location;
     if (!isRedirect) return res;
     await res.body?.cancel().catch(() => void 0);
-    if (hop >= MAX_REDIRECTS) {
+    if (hop >= MAX_REDIRECTS2) {
       throw new AttachmentError(`${label}: too many redirects.`);
     }
     let next;
@@ -16759,7 +17718,7 @@ async function fetchAllowed(start, fetchImpl, label) {
     } catch {
       throw new AttachmentError(`${label}: redirect to an invalid URL.`);
     }
-    const problem = checkAttachmentUrl(next);
+    const problem = checkAttachmentUrl(next, extraHosts);
     if (problem) {
       throw new AttachmentError(
         `${label}: the download redirected to a URL that ${problem}; refused.`
@@ -16797,7 +17756,7 @@ async function readWithin(res, budget, overBudget) {
   }
   return out;
 }
-async function resolveAttachments(attachments, fetchImpl = fetch) {
+async function resolveAttachments(attachments, fetchImpl = fetch, extraHosts) {
   if (!Array.isArray(attachments) || attachments.length === 0) return [];
   const items = [];
   attachments.forEach((raw, i) => {
@@ -16816,10 +17775,10 @@ async function resolveAttachments(attachments, fetchImpl = fetch) {
         )}). \`attachments\` works only in ChatGPT, which swaps each file for a download URL before the call reaches Wix. Here it arrived as written, and Wix cannot read a path on your machine, so retrying the same value fails the same way. Upload another way. With a shell that reaches the internet, send the file from there (for a site, the StartDeployWebsite recipe's curl drop). Otherwise leave \`attachments\` out and put the files in \`files\`: text as is, and a binary as a \`=== FILE: <path> base64 ===\` entry only when it is a few KB (an icon, a logo), since a larger base64 payload does not survive your own output. A larger image goes in by public URL or through the user (the Media Manager).`
       );
     }
-    const problem = checkAttachmentUrl(url);
+    const problem = checkAttachmentUrl(url, extraHosts);
     if (problem) {
       throw new AttachmentError(
-        `attachments[${i}].download_url ${problem}. Only platform-resolved attachments are accepted here; for any other URL fetch it in \`code\` via wix.request or put the bytes in the \`files\` bundle.`
+        `attachments[${i}].download_url ${problem}. \`attachments\` takes only files the chat platform attached and resolved; leave it out. For a file at a URL, import it in \`code\` with \`POST https://www.wixapis.com/site-media/v1/files/import\` and \`{ url }\` (Wix fetches it); for a small file you have as text, use the \`files\` bundle.`
       );
     }
     items.push({ a, url });
@@ -16831,7 +17790,7 @@ async function resolveAttachments(attachments, fetchImpl = fetch) {
     const label = `attachments[${i}] (${path})`;
     let res;
     try {
-      res = await fetchAllowed(url, fetchImpl, label);
+      res = await fetchAllowed(url, fetchImpl, label, extraHosts);
     } catch (e) {
       if (e instanceof AttachmentError) throw e;
       throw new AttachmentError(
@@ -16916,7 +17875,13 @@ async function unzip(z) {
   let p = u32(end + 16);
   let total = 0;
   const decoder = new TextDecoder();
-  for (let i = 0, n = u16(end + 10); i < n; i++) {
+  const n = u16(end + 10);
+  if (n > MAX_SITE_FILES) {
+    throw new Error(
+      `zip holds ${n} entries; a site upload is at most ${MAX_SITE_FILES} files`
+    );
+  }
+  for (let i = 0; i < n; i++) {
     const path = decoder.decode(z.slice(p + 46, p + 46 + u16(p + 28)));
     const method = u16(p + 10);
     const size = u32(p + 24);
@@ -16952,20 +17917,106 @@ async function unzip(z) {
   }
   return out;
 }
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++)
+    c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function zipStored(files) {
+  const encoder = new TextEncoder();
+  const entries = files.map((f) => ({
+    name: encoder.encode(f.path),
+    bytes: f.bytes,
+    crc: crc32(f.bytes)
+  }));
+  const localSize = entries.reduce(
+    (sum, e) => sum + 30 + e.name.length + e.bytes.length,
+    0
+  );
+  const centralSize = entries.reduce((sum, e) => sum + 46 + e.name.length, 0);
+  const out = new Uint8Array(localSize + centralSize + 22);
+  const view = new DataView(out.buffer);
+  const UTF8_FLAG = 2048;
+  let p = 0;
+  const offsets = [];
+  for (const e of entries) {
+    offsets.push(p);
+    view.setUint32(p, 67324752, true);
+    view.setUint16(p + 4, 20, true);
+    view.setUint16(p + 6, UTF8_FLAG, true);
+    view.setUint16(p + 8, 0, true);
+    view.setUint32(p + 10, 0, true);
+    view.setUint32(p + 14, e.crc, true);
+    view.setUint32(p + 18, e.bytes.length, true);
+    view.setUint32(p + 22, e.bytes.length, true);
+    view.setUint16(p + 26, e.name.length, true);
+    view.setUint16(p + 28, 0, true);
+    out.set(e.name, p + 30);
+    out.set(e.bytes, p + 30 + e.name.length);
+    p += 30 + e.name.length + e.bytes.length;
+  }
+  const centralStart = p;
+  entries.forEach((e, i) => {
+    view.setUint32(p, 33639248, true);
+    view.setUint16(p + 4, 20, true);
+    view.setUint16(p + 6, 20, true);
+    view.setUint16(p + 8, UTF8_FLAG, true);
+    view.setUint16(p + 10, 0, true);
+    view.setUint32(p + 12, 0, true);
+    view.setUint32(p + 16, e.crc, true);
+    view.setUint32(p + 20, e.bytes.length, true);
+    view.setUint32(p + 24, e.bytes.length, true);
+    view.setUint16(p + 28, e.name.length, true);
+    view.setUint32(p + 42, offsets[i], true);
+    out.set(e.name, p + 46);
+    p += 46 + e.name.length;
+  });
+  view.setUint32(p, 101010256, true);
+  view.setUint16(p + 8, entries.length, true);
+  view.setUint16(p + 10, entries.length, true);
+  view.setUint32(p + 12, p - centralStart, true);
+  view.setUint32(p + 16, centralStart, true);
+  return out;
+}
 var isZip = (f) => f.bytes.length >= 4 && f.bytes[0] === 80 && f.bytes[1] === 75 && (f.bytes[2] === 3 && f.bytes[3] === 4 || f.bytes[2] === 5 && f.bytes[3] === 6) || /\.zip$/i.test(f.path);
 var isRootIndex = (p) => /^index\.html?$/i.test(p);
-async function normalizeSiteFiles(input) {
-  let list = [];
+async function expandSiteFiles(input) {
+  const list = [];
+  let bytes = 0;
   for (const f of input) {
-    if (isZip(f)) list.push(...await unzip(f.bytes));
-    else list.push(f);
+    const added = isZip(f) ? await unzip(f.bytes) : [f];
+    list.push(...added);
+    bytes += added.reduce((sum, a) => sum + a.bytes.byteLength, 0);
+    if (list.length > MAX_SITE_FILES) {
+      throw new Error(
+        `Too many files (more than ${MAX_SITE_FILES}); a site upload is at most ${MAX_SITE_FILES}.`
+      );
+    }
+    if (bytes > MAX_UNZIP_BYTES) {
+      throw new Error(
+        `The upload expands past ${MAX_UNZIP_BYTES} bytes; send only the site's files.`
+      );
+    }
   }
-  list = list.map((f) => ({
+  return list.map((f) => ({
     ...f,
     path: f.path.replace(/\\/g, "/").replace(/^\.?\//, "")
   })).filter(
     (f) => f.path && !f.path.startsWith("__MACOSX/") && !/(^|\/)\.DS_Store$/.test(f.path) && !f.path.split("/").includes("..")
   );
+}
+function staticSiteFiles(expanded) {
+  let list = expanded;
   if (list.length === 0) {
     throw new Error(
       "No files to upload: pass the site in `files` or `attachments`."
@@ -17045,21 +18096,281 @@ function buildFormData(files) {
   return fd;
 }
 
+// src/api-call/headless-release.ts
+var BUILD_METADATA_SUFFIX = ".wix/build-metadata.json";
+function withoutEmptyStatics(files, build) {
+  const dir = build.clientDir;
+  if (dir === void 0) return { files, dropped: [] };
+  const dropped = [];
+  const kept = files.filter((f) => {
+    const path = normalizePath(f.path);
+    if (f.bytes.byteLength === 0 && path.startsWith(dir)) {
+      dropped.push(path.slice(dir.length));
+      return false;
+    }
+    return true;
+  });
+  return { files: kept, dropped };
+}
+var normalizePath = (p) => p.replace(/\\/g, "/").replace(/^\.?\//, "");
+function findHeadlessBuild(files) {
+  const entries = new Map(files.map((f) => [normalizePath(f.path), f.bytes]));
+  const metadataEntry = [...entries.keys()].find(
+    (name) => name === BUILD_METADATA_SUFFIX || name.endsWith(`/${BUILD_METADATA_SUFFIX}`)
+  );
+  if (metadataEntry === void 0) return null;
+  const zipRoot = metadataEntry.slice(
+    0,
+    metadataEntry.length - BUILD_METADATA_SUFFIX.length
+  );
+  let metadata;
+  try {
+    metadata = JSON.parse(
+      new TextDecoder().decode(entries.get(metadataEntry))
+    );
+  } catch {
+    throw new Error(`${BUILD_METADATA_SUFFIX} is not valid JSON.`);
+  }
+  if (typeof metadata.appManifestPath !== "string") {
+    throw new Error(
+      `${BUILD_METADATA_SUFFIX} has no appManifestPath; send the build as the Wix hosting adapter wrote it (.wix/ and dist/ zipped from the project root).`
+    );
+  }
+  const manifestPath = resolveZipPath(
+    metadata.appManifestPath,
+    zipRoot,
+    entries
+  );
+  if (manifestPath === void 0) {
+    throw new Error(
+      `The build's app manifest (${metadata.appManifestPath}) is not in the upload; zip .wix/ and dist/ together from the project root after \`astro build\`.`
+    );
+  }
+  const builderRoot = metadata.appManifestPath.slice(
+    0,
+    metadata.appManifestPath.length - (manifestPath.length - zipRoot.length)
+  );
+  const clientDir = metadata.clientDir === void 0 ? void 0 : toZipDir(metadata.clientDir, builderRoot, zipRoot);
+  const serverDir = metadata.serverDir === void 0 ? void 0 : toZipDir(metadata.serverDir, builderRoot, zipRoot);
+  const clientFiles = [];
+  const serverFiles = [];
+  for (const [name, bytes] of entries) {
+    if (name === manifestPath) continue;
+    if (serverDir !== void 0 && name.startsWith(serverDir)) {
+      serverFiles.push({ path: name.slice(serverDir.length), bytes });
+    } else if (clientDir !== void 0 && name.startsWith(clientDir)) {
+      clientFiles.push({ path: name.slice(clientDir.length), bytes });
+    }
+  }
+  if (clientFiles.length + serverFiles.length === 0) {
+    throw new Error(
+      "The build has no client or server output files; run `astro build` first and zip .wix/ and dist/ from the project root."
+    );
+  }
+  if (serverFiles.length > 0 && !serverFiles.some((f) => f.path === "entry.mjs")) {
+    throw new Error(
+      "The server build has no entry.mjs, which the Wix hosting adapter (@wix/astro-wix-hosting-adapter) writes into the server folder on every build. Build with the project's own `astro build` (the adapter in astro.config) and zip .wix/ and dist/ from the project root as the build left them."
+    );
+  }
+  const manifestText = new TextDecoder().decode(entries.get(manifestPath));
+  return {
+    metadata,
+    root: zipRoot,
+    manifestText,
+    clientFiles,
+    serverFiles,
+    clientDir
+  };
+}
+var NOT_SOURCE_TOP = /* @__PURE__ */ new Set(["dist", ".wix", ".astro", ".agents"]);
+var isSourcePath = (relative) => {
+  const segments = relative.split("/");
+  return !NOT_SOURCE_TOP.has(segments[0]) && !segments.some((s) => s === "node_modules" || s.startsWith(".env"));
+};
+function buildSourceFiles(files, build) {
+  return files.flatMap((f) => {
+    const path = normalizePath(f.path);
+    if (!path.startsWith(build.root)) return [];
+    const relative = path.slice(build.root.length);
+    return relative && isSourcePath(relative) ? [{ path: relative, bytes: f.bytes }] : [];
+  });
+}
+function resolveZipPath(builderPath, zipRoot, entries) {
+  const segments = normalizePath(builderPath).split("/").filter((s) => s.length > 0);
+  for (let k = 0; k < segments.length; k++) {
+    const candidate = zipRoot + segments.slice(k).join("/");
+    if (entries.has(candidate)) return candidate;
+  }
+  return void 0;
+}
+function toZipDir(builderDir, builderRoot, zipRoot) {
+  const normalized = normalizePath(builderDir);
+  const normalizedRoot = normalizePath(builderRoot);
+  const relative = builderDir.startsWith(builderRoot) ? builderDir.slice(builderRoot.length) : normalized.startsWith(normalizedRoot) ? normalized.slice(normalizedRoot.length) : normalized;
+  const dir = zipRoot + normalizePath(relative);
+  return dir.endsWith("/") ? dir : `${dir}/`;
+}
+
+// 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 record = value;
+  if (!FREE_TEXT_INFO_PARAMS.some((key) => typeof record[key] === "string")) {
+    return value;
+  }
+  const redacted = { ...record };
+  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 record = value;
+  const files = record.files;
+  if (typeof files === "string") {
+    return { ...record, files: summarizeFileBundle(files) };
+  }
+  if (Array.isArray(files) && files.length > 0 && files.every(
+    (entry) => entry && typeof entry === "object" && typeof entry.content === "string"
+  )) {
+    return {
+      ...record,
+      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/api-call/upload-headless-website-files.ts
 var UPLOAD_HEADLESS_WEBSITE_FILES_TOOL_NAME = "UploadHeadlessWebsiteFiles";
 var HEADLESS_BUSINESS = "https://www.wixapis.com/headless-business-setup/v1/headless-business";
+var MAX_BUNDLE_BYTES = 100 * 1024 * 1024;
+var MAX_RELEASE_STATIC_FILES = 2500;
+var MAX_SOURCE_ZIP_BYTES = 64 * 1024 * 1024;
 function dropAttribution(clientName) {
   const slug = (clientName ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   return `?campaign=mcp&agent=${encodeURIComponent(slug || "wix-mcp")}`;
 }
 var UPLOAD_HEADLESS_WEBSITE_FILES_PARAM_DESCRIPTIONS = {
-  files: "The site files as text, so file bytes never pass through a code string. Sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root and must include `index.html`. Use base64 for small binaries (icons, logos, fonts); large images/video belong behind a URL in the HTML, not in the bundle. Optional when `attachments` carries the files.",
-  attachments: "ChatGPT only. Files attached in the chat or created in your sandbox \u2014 any type: a zip of the whole site, HTML, CSS, JS, images. Pass each file as you have it, its file id or its /mnt/data path, and ChatGPT swaps it for { download_url, file_id, file_name?, mime_type? } before the call reaches Wix. No other client does this swap, so outside ChatGPT a path or file:// URL here fails at once; leave this out and use `files`, or, with a shell that reaches the internet, drop the files with curl as the StartDeployWebsite recipe shows. A zip is unpacked; a top-level folder wrapping the site is stripped. Prefer this over base64 in `files` whenever you have a file handle. Up to 10 MB per call.",
-  siteId: "The metaSiteId of the Wix Headless site to upload into: the one returned by the provision call of the StartDeployWebsite recipe for a new site, or of a site deployed earlier to replace its files. Every upload replaces the whole file set, so send all files; the URL stays the same.",
+  files: "The site files as text, so file bytes never pass through a code string. Sections delimited by a line `=== FILE: <path> ===` (text, raw) or `=== FILE: <path> base64 ===` (binary, base64); `<path>` is relative to the site root; a static site must include `index.html`. Use base64 for small binaries (icons, logos, fonts); large images/video belong behind a URL in the HTML, not in the bundle. Optional when `attachments` carries the files. A Wix Astro build (`.wix/build-metadata.json` and `dist/` as `astro build` with the Wix hosting adapter wrote them, zipped from the project root) needs no `index.html`: it is released to the site's Wix hosting instead of dropped, and the project's other files in the upload are stored as its source when the site's repository accepts it.",
+  attachments: fileParamNote(
+    "for a static site use `files`, or drop the files as the StartDeployWebsite recipe shows; for a Wix Astro build from a shell that reaches the internet, zip it, call with `prepare: true` and its `size` and PUT the zips with curl"
+  ) + " Any type: a zip of the whole site, HTML, CSS, JS, images. A zip is unpacked; a top-level folder wrapping the site is stripped. A Wix Astro build zipped with the whole project (minus `node_modules`) is released with its source stored when the site's repository accepts it. Prefer this over base64 in `files` whenever you have a file handle. Up to 10 MB per call.",
+  prepare: "Phase one of the two-call upload of a Wix Astro build, for a shell that reaches the internet and no file handle (a sandbox whose network is limited to a few hosts cannot upload to the URLs): zip the build first, then `true` with its `size` returns presigned upload URLs for the build zip and, when the site's repository takes it, the project source zip, as `curl` commands to run verbatim, with the exact second call. The two calls: {siteId, prepare: true, size}, then {siteId, uploadKey, sourceUploadId?, expectedHeadRevisionId?, releaseNotes?}. No `files`, `attachments`, `uploadKey` or `sourceUploadId` on the first; `expectedHeadRevisionId` and `releaseNotes` given on the first are echoed into the second. Not for a static site: send its files in `files` or `attachments`, or drop them as the StartDeployWebsite recipe shows.",
+  size: `Phase one, with \`prepare: true\` only, and required there: the build zip's length in bytes (\`wc -c < build.zip\`), 1 to ${MAX_BUNDLE_BYTES} (100 MB). The upload URL takes a body of exactly this length; a zip changed after the prepare needs a new prepare.`,
+  uploadKey: "Phase two of the two-call upload: the `uploadKey` the `prepare` call returned, after the build zip was PUT to its URL. Releases that build to the site: {siteId, uploadKey, sourceUploadId?, expectedHeadRevisionId?, releaseNotes?}. Excludes `files` and `attachments`.",
+  sourceUploadId: "Phase two: the `sourceUploadId` the `prepare` call returned, after the source zip was PUT to its URL. Stores the project source with the release. Needs `uploadKey`; leave it out when the prepare returned no source upload.",
+  expectedHeadRevisionId: "The repository revision your project started from, so the source replaces only that and a commit made since (another chat, a Dev Machine) is never dropped unseen: the revision you downloaded the project at; for a project started here, the `headRevisionId` the `prepare` call returned. Leave it out only for a repository with nothing in it yet. Goes with `uploadKey`, or with `files`/`attachments` holding a build.",
+  releaseNotes: "Optional: one line on what this release changes, at most 200 characters, kept with the deployment of a Wix Astro build, whether it comes in `files`/`attachments` or as the second call with `uploadKey` (given on the `prepare` call it is echoed into the second). A static drop keeps no notes.",
+  siteId: "The metaSiteId of the Wix Headless site to upload into: the one returned by the provision call of the StartDeployWebsite recipe for a new site, or of a site deployed earlier to replace its files. Every upload replaces the whole file set, so send all files; the URL stays the same. A build released here replaces static pages dropped earlier, at the same URL.",
   calledStartDeployWebsite: "Whether you called StartDeployWebsite earlier in this conversation and are following the recipe it returned. Answer truthfully; it is recorded, not checked.",
   agentIdentity: START_DEPLOY_WEBSITE_PARAM_DESCRIPTIONS.agentIdentity,
-  reason: "One sentence: the user request that led here and what is being published."
+  reason: `One sentence: the user request that led here and what is being published. ${NO_PERSONAL_DATA}`
 };
+var UPLOAD_RECIPE_SKILL_URL = "https://www.wix.com/skills/wix-manage/references/sites/upload-static-site.md";
+var DOMAIN_RECIPE_SKILL_URL = "https://www.wix.com/skills/wix-manage/references/domains/domain-search-purchase-and-connect.md";
+function formatInlineGuide(guide) {
+  if (!guide || !guide.trim()) return "";
+  return [
+    "",
+    "---",
+    "",
+    `Wix's headless guide, the build of a site that needs Wix business features (also at https://www.wix.com/headless/skill.md):`,
+    "",
+    guide.trim()
+  ].join("\n");
+}
 function formatDropResult(r) {
   const shown = r.files.slice(0, 60);
   return [
@@ -17069,10 +18380,203 @@ function formatDropResult(r) {
     `Dashboard: https://manage.wix.com/dashboard/${r.metaSiteId}`,
     `${r.files.length} file(s): ${shown.join(", ")}${r.files.length > shown.length ? ", \u2026" : ""}`,
     "",
-    "Give the user the live URL and the dashboard link.",
-    `The upload step is done. For what comes next \u2014 changing the site later, connecting a domain, or adding a Wix backend (forms, bookings, a store) to this same site \u2014 continue with the guide you are following, from where it left off: the StartDeployWebsite recipe (${START_DEPLOY_WEBSITE_RECIPE_URL}) or, for a site built through StartHeadlessBuild, the headless guide (${HEADLESS_GUIDE_URL}).`
+    `Give the user both links, each on its own line and named for what it is: the live site, and the site's dashboard. Then offer a custom domain, bought through Wix or one they already own (${DOMAIN_RECIPE_SKILL_URL}).`,
+    "",
+    `- To change this site later: "Change it later" in ${UPLOAD_RECIPE_SKILL_URL}, with this metaSiteId (${r.metaSiteId}). The same site every time, never a new one.`,
+    `- When the site needs Wix business features (${WIX_BUSINESS_FEATURES}), a drop of static pages is not its build: a full Wix Headless site has those features run by Wix and its pages reading from them. That build is Wix's headless guide, https://www.wix.com/headless/skill.md (what StartHeadlessBuild returns; call it with startingPoint "an existing Wix Headless site", this site is one): it installs the solution on this site, seeds its content through the API, and puts up pages that fetch it, uploaded here again. A site with no business features is done.`
+  ].join("\n");
+}
+function curlPut(zipName, put, fallback) {
+  const headers = Object.entries(
+    put.headers && Object.keys(put.headers).length ? put.headers : fallback
+  );
+  return [
+    "curl -X PUT",
+    ...headers.map(([k, v]) => `-H "${k}: ${v}"`),
+    `--data-binary @${zipName} "${put.putUrl}"`
+  ].join(" ");
+}
+var BUILD_ZIP_CONTENTS = "Build zip, from the project root after `astro build` with the Wix hosting adapter: `dist/` (with `dist/_wix/app-manifest.json`) and `.wix/build-metadata.json`.";
+var SOURCE_ZIP_CONTENTS = "Source zip, from the project root: the project minus `node_modules`, `dist`, `.wix`, `.astro`, `.env*` and `.agents`.";
+function formatPrepareResult(siteId, urls, size, given = {}) {
+  const expiry = urls.expiresAt ? ` They expire at ${urls.expiresAt}.` : "";
+  const secondCall = {
+    siteId,
+    uploadKey: urls.uploadKey
+  };
+  const zipHeaders = {
+    "content-type": "application/zip",
+    ...size ? { "content-length": String(size) } : {}
+  };
+  const lines = [
+    `Upload URLs ready for site ${siteId}.${expiry} Two steps, then call this tool again.`,
+    "",
+    `1. ${BUILD_ZIP_CONTENTS} Its client folder (\`dist/client\`) holds at most ${MAX_RELEASE_STATIC_FILES} files (\`find dist/client -type f | wc -l\`); a larger build fails the release. Upload the zip you measured${size ? ` (${size} bytes)` : ""}; the URL takes a body of exactly that length, so a zip changed since needs a new prepare with its size:`,
+    `   ${curlPut("build.zip", urls, zipHeaders)}`
+  ];
+  if (given.expectedHeadRevisionId)
+    secondCall.expectedHeadRevisionId = given.expectedHeadRevisionId;
+  if (urls.source) {
+    const s = urls.source;
+    secondCall.sourceUploadId = s.uploadId;
+    if (!secondCall.expectedHeadRevisionId && s.headRevisionId)
+      secondCall.expectedHeadRevisionId = s.headRevisionId;
+    lines.push(
+      "",
+      `2. ${SOURCE_ZIP_CONTENTS} At most 64 MiB (\`wc -c < source.zip\`): a larger one fails the whole release. Leave large media and generated files out of it; if it is still larger, skip this upload and leave \`sourceUploadId\` out of the second call, and the site is released without its source. Upload it:`,
+      `   ${curlPut("source.zip", s, { "content-type": "application/zip" })}`,
+      ...s.expiresAt && s.expiresAt !== urls.expiresAt ? [`   This URL expires at ${s.expiresAt}.`] : [],
+      ...s.headRevisionId ? [
+        `   The repository's head revision is ${s.headRevisionId}. The second call passes \`expectedHeadRevisionId\`: this head for a project started here; if you downloaded the project from the repository, the revision you downloaded it at instead, so a commit made since is never dropped.`
+      ] : []
+    );
+  } else {
+    lines.push(
+      "",
+      "2. The site's repository takes no source this time: the project's source is not uploaded, and the second call carries no `sourceUploadId`."
+    );
+  }
+  if (given.releaseNotes)
+    secondCall.releaseNotes = releaseNotesForService(given.releaseNotes);
+  lines.push(
+    "",
+    `3. Call UploadHeadlessWebsiteFiles again with ${JSON.stringify(secondCall)} (plus \`calledStartDeployWebsite\`, \`agentIdentity\`, \`reason\`). No \`files\` or \`attachments\` on that call.`
+  );
+  if (secondCall.sourceUploadId) {
+    const withoutSource = { ...secondCall };
+    delete withoutSource.sourceUploadId;
+    lines.push(
+      `   If you skipped the source upload in step 2, call with ${JSON.stringify(withoutSource)} instead: a \`sourceUploadId\` whose zip was never uploaded fails the release.`
+    );
+  }
+  return lines.join("\n");
+}
+function formatBundleReleaseResult(siteId, r, notes = []) {
+  return [
+    "Released; the site is live.",
+    `Live URL: ${r.siteUrl ?? "(not returned)"}`,
+    `metaSiteId: ${siteId} \u2014 pass it as \`siteId\` to release this site again, the same way. The URL stays.`,
+    `Dashboard: https://manage.wix.com/dashboard/${siteId}`,
+    `Deployment ${r.deploymentId ?? "(id not returned)"}.${r.revision?.id ? ` Source stored as revision ${r.revision.id}.` : ""}`,
+    ...notes,
+    "",
+    "This release replaced whatever the site served before, at the same URL. A change to the site is a change to the project: edit, build if it is an Astro project, upload again.",
+    "Give the user both links, each on its own line and named for what it is: the live site, and the site's dashboard."
   ].join("\n");
 }
+var startOver = (retry) => retry === "prepare" ? "call with `prepare: true` and the zip's `size` again, upload the zips to the new URLs, and release with the new `uploadKey`" : "call this tool again with the same files";
+var apiBody = (err) => err.response.data ? ` (${err.response.data.slice(0, 300)})` : "";
+var SITE_ACCESS_PERMISSION = "OAUTH_APP.APP_CREATE";
+function describeSiteAccessDenied(err, siteId, stagedKey) {
+  if (!(err instanceof WixFetchError) || err.status !== 403 || !err.response.data.includes(SITE_ACCESS_PERMISSION)) {
+    return null;
+  }
+  const site = siteId ? `site ${siteId}` : "this site";
+  const outcome = stagedKey ? `Nothing was released; the build you uploaded is still staged under uploadKey ${stagedKey} and counts against the site's unreleased uploads, so do not call \`prepare\` again and do not send the files again. The same call fails the same way until the login changes; once connected as the owning account, release that staged upload by calling with \`uploadKey: "${stagedKey}"\` before preparing a new one.` : "Nothing was uploaded, and the same call fails the same way, so do not retry and do not stage another upload.";
+  return `The connected Wix login has no rights on ${site}: Wix refused it the \`${SITE_ACCESS_PERMISSION}\` permission there. That means the site belongs to another Wix account, or this login's role on the owning account is too low (a Basic Team Member cannot upload). ${outcome} Ask the user which Wix account owns the site. Reconnecting Wix helps only if they pick that account, as its owner or an admin, at the consent screen; otherwise the owner has to give this login a higher role on the account, or move the site to it.${apiBody(err)}`;
+}
+function describeBundleUploadUrlError(err, siteId) {
+  if (!(err instanceof WixFetchError)) {
+    return err instanceof Error ? err.message : String(err);
+  }
+  const denied = describeSiteAccessDenied(err, siteId);
+  if (denied) return denied;
+  const body = apiBody(err);
+  switch (err.status) {
+    case 400:
+      return `The upload URL was refused: \`size\` is the build zip's length in bytes, an integer from 1 to ${MAX_BUNDLE_BYTES} (100 MB). A larger build: leave out what the site does not serve (source maps, unused assets).${body}`;
+    case 429:
+      return `Too many unreleased uploads are waiting for this site: release one with its \`uploadKey\`, or wait for a running release to finish, then ask again.${body}`;
+    default:
+      return err.message;
+  }
+}
+function deployAuthorization(siteHeaders) {
+  const authorization3 = siteHeaders.Authorization ?? siteHeaders.authorization;
+  return authorization3 ? { deployAuthorization: authorization3 } : {};
+}
+var RELEASE_NOTES_MAX_CHARS = 200;
+function releaseNotesForService(notes) {
+  const chars = [...notes.replace(/\s+/g, " ").trim()];
+  return chars.length <= RELEASE_NOTES_MAX_CHARS ? chars.join("") : `${chars.slice(0, RELEASE_NOTES_MAX_CHARS - 1).join("").trimEnd()}\u2026`;
+}
+function describeBundleReleaseError(err, uploadKey, retry = "prepare", siteId) {
+  if (!(err instanceof WixFetchError)) {
+    return err instanceof Error ? err.message : String(err);
+  }
+  const denied = describeSiteAccessDenied(err, siteId, uploadKey);
+  if (denied) return denied;
+  const body = apiBody(err);
+  const code = err.response.data ?? "";
+  const sameCall = `calling with \`uploadKey: "${uploadKey}"\`${retry === "resend" ? " (plus the `expectedHeadRevisionId` and `releaseNotes` you passed, if any; the source is stored with the next release)" : " and the same ids and `releaseNotes`"}`;
+  const afterDrop = "If an earlier call with this `uploadKey` ended in a dropped connection, that release went through: the site is live with this build, so do not upload it again.";
+  if (err.status >= 502 && err.status <= 504 && !code.includes("RELEASE_NOT_HELD") && !code.includes("{")) {
+    return `The connection to Wix dropped while the release ran (HTTP ${err.status}); the release most likely went through. Do not call \`prepare\` again and do not send the files again. Wait two minutes, then check once by ${sameCall}: an answer that nothing is staged for this key, or that the repository moved, means the first release went through and the site is live. Any other answer is about the release itself.${body}`;
+  }
+  switch (err.status) {
+    case 404:
+      return `Nothing uploaded for uploadKey ${uploadKey}: the build zip was not PUT to its URL, the URL expired, or a release of it already went through (a staged zip is deleted once released). ${afterDrop} Otherwise, to try again, ${startOver(retry)}.${body}`;
+    case 409:
+      return `The project's source repository moved since the upload URLs were made; nothing was released by this call. ${afterDrop} Otherwise: ${retry === "prepare" ? "call with `prepare: true` and the zip's `size` again, re-upload the source zip to the new URL, and release with the new `uploadKey`, `sourceUploadId` and `expectedHeadRevisionId`." : "download the project again from the repository, carry your change over, and upload with `expectedHeadRevisionId` set to the revision you downloaded."}${body}`;
+    case 403:
+      return `Wix refused to deploy this build onto the site's project; nothing was released, and the same call will be refused again. Do not call \`prepare\` again. Tell the user the release is blocked on Wix's side and give them the request id from the error.${body}`;
+    case 413:
+    case 428:
+      return `The build's server code is larger than the release can carry from here; nothing was released. Do not call \`prepare\` again. Tell the user the release is blocked on Wix's side and give them the request id from the error.${body}`;
+    case 400:
+      if (code.includes("EXPECTED_HEAD_REQUIRED")) {
+        return `The site's repository already holds work, and the source replaces only what you started from; nothing was released. ${retry === "prepare" ? "Call with `prepare: true` and the zip's `size` again and pass the `headRevisionId` it returns as `expectedHeadRevisionId` (with its new `uploadKey` and `sourceUploadId`)." : "Call again with `expectedHeadRevisionId`: the revision you downloaded the project at, so the source replaces only that. To replace the repository with this upload on purpose, pass its current head."}${body}`;
+      }
+      if (code.includes("BUNDLE_TOO_LARGE")) {
+        return `The build zip is over ${MAX_BUNDLE_BYTES} bytes (100 MB): leave out what the site does not serve (source maps, unused assets), then ${startOver(retry)}.${body}`;
+      }
+      if (code.includes("INVALID_RELEASE")) {
+        return `The release was refused by Wix's deployment service; nothing was released. The staged upload is kept: call again with the same \`uploadKey\` and the field the message names fixed (release notes are cut to ${RELEASE_NOTES_MAX_CHARS} characters here).${body}`;
+      }
+      if (code.includes("INVALID_UPLOAD_KEY")) {
+        return `\`uploadKey\` is the lowercase UUID the \`prepare\` call returned; pass it as it came.${body}`;
+      }
+      return `The uploaded zip was not accepted. Zip \`dist/\` and \`.wix/build-metadata.json\` from the project root after \`astro build\` with the Wix hosting adapter, then ${startOver(retry)}. A static site goes in \`files\` or \`attachments\` instead, or is dropped as the StartDeployWebsite recipe shows.${body}`;
+    default:
+      if (err.status >= 500) {
+        const what = code.includes("RELEASE_NOT_HELD") ? "The release could not hold its upload" : `Wix's release step failed on its side (HTTP ${err.status})`;
+        const limits = retry === "prepare" && !code.includes("RELEASE_NOT_HELD") ? ` A build over Wix's limits fails here with no reason given: more than ${MAX_RELEASE_STATIC_FILES} files in its client folder (\`find dist/client -type f | wc -l\`), or a source zip over 64 MiB (\`wc -c < source.zip\`). If either is over, a retry fails the same way: make the build or the source zip smaller, then call with \`prepare: true\` again.` : "";
+        return `${what}; nothing was released.${limits} The staged upload is kept under uploadKey ${uploadKey}, so do not call \`prepare\` again${limits ? " for the same zips" : ""} and do not send the files again: every upload staged and not released counts against the site, which refuses new ones after a few. Retry once, after a minute, by ${sameCall}. If that fails too, stop and tell the user the release is blocked on Wix's side, with the request id from the error.${body}`;
+      }
+      return err.message;
+  }
+}
+function validateBundleArgs(a) {
+  const hasContent = !!a.files?.trim() || !!(a.attachments && a.attachments.length);
+  if (a.prepare) {
+    if (hasContent || a.uploadKey || a.sourceUploadId) {
+      return "`prepare: true` goes with `siteId` and `size`: no `files`, `attachments`, `uploadKey` or `sourceUploadId` on that call. Example: {siteId, prepare: true, size}, then {siteId, uploadKey, sourceUploadId?, expectedHeadRevisionId?, releaseNotes?}.";
+    }
+    if (a.size === void 0) {
+      return "`prepare: true` needs `size`: zip the build first and pass the zip's length in bytes (`wc -c < build.zip`).";
+    }
+    if (!Number.isInteger(a.size) || a.size < 1 || a.size > MAX_BUNDLE_BYTES) {
+      return `\`size\` is the build zip's length in bytes, an integer from 1 to ${MAX_BUNDLE_BYTES} (100 MB); got ${a.size}.`;
+    }
+    return null;
+  }
+  if (a.size !== void 0) {
+    return "`size` goes only with `prepare: true`: it is the length of the build zip that call makes an upload URL for.";
+  }
+  if (a.uploadKey) {
+    if (hasContent) {
+      return "`uploadKey` releases a build zip already uploaded to its URL: pass no `files` or `attachments` with it.";
+    }
+    return null;
+  }
+  if (a.sourceUploadId) {
+    return "`sourceUploadId` goes with the `uploadKey` the `prepare` call returned.";
+  }
+  if (a.expectedHeadRevisionId && !hasContent) {
+    return "`expectedHeadRevisionId` goes with `uploadKey`, or with `files`/`attachments` holding a build.";
+  }
+  return null;
+}
 async function readJson(res, what) {
   const text = await res.text();
   if (!res.ok)
@@ -17083,6 +18587,65 @@ async function readJson(res, what) {
     throw new Error(`${what} returned a non-JSON body: ${text.slice(0, 200)}`);
   }
 }
+async function putZip(fetchImpl, put, bytes, what) {
+  const headers = Object.fromEntries(
+    Object.entries(put.headers ?? { "content-type": "application/zip" }).filter(
+      ([k]) => k.toLowerCase() !== "content-length"
+    )
+  );
+  const res = await fetchImpl(put.putUrl, {
+    method: "PUT",
+    headers,
+    body: bytes
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(
+      `The ${what} upload was refused (${res.status}${text ? `: ${text.slice(0, 200)}` : ""}); call this tool again with the same files.`
+    );
+  }
+}
+async function releaseBuildByUrl(o) {
+  const log = o.log ?? (() => {
+  });
+  const headers = { ...o.siteHeaders, "Content-Type": "application/json" };
+  const urls = await readJson(
+    await o.fetchImpl(`${HEADLESS_BUSINESS}/${o.siteId}/bundle-upload-url`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ size: o.siteZip.byteLength })
+    }),
+    "bundle-upload-url"
+  );
+  if (!urls.uploadKey || !urls.putUrl) {
+    throw new Error("bundle-upload-url returned no uploadKey or putUrl.");
+  }
+  await putZip(o.fetchImpl, urls, o.siteZip, "site zip");
+  o.onStaged?.(urls.uploadKey);
+  log(
+    `staged ${urls.uploadKey} (${o.siteZip.byteLength} bytes), source ${urls.source ? `offered, ${o.sourceFiles.length} file(s)` : "not offered"}`
+  );
+  const source = urls.source && o.sourceFiles.length > 0 ? urls.source : void 0;
+  if (source) {
+    await putZip(o.fetchImpl, source, zipStored(o.sourceFiles), "source zip");
+  }
+  return await readJson(
+    await o.fetchImpl(`${HEADLESS_BUSINESS}/${o.siteId}/release-bundle`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        uploadKey: urls.uploadKey,
+        ...deployAuthorization(o.siteHeaders),
+        ...o.releaseNotes ? { releaseNotes: releaseNotesForService(o.releaseNotes) } : {},
+        ...source ? {
+          sourceUploadId: source.uploadId,
+          ...o.expectedHeadRevisionId ? { expectedHeadRevisionId: o.expectedHeadRevisionId } : {}
+        } : {}
+      })
+    }),
+    "release-bundle"
+  );
+}
 function errorResult2(message) {
   return {
     isError: true,
@@ -17098,6 +18661,18 @@ function addUploadHeadlessWebsiteFilesTool(server, options) {
   const { authStrategy, toolDescriptions } = options;
   const clientName = () => options.clientName ?? server.clientName?.() ?? server.server?.getClientVersion?.()?.name;
   const fetchImpl = options.fetchImpl ?? ((u, i) => fetch(u, i));
+  const guideFetch = options.guideFetch ?? (async (httpClient) => {
+    if (!httpClient) return void 0;
+    return fetchArticleContent(
+      httpClient,
+      HEADLESS_GUIDE_URL,
+      "article",
+      true,
+      options.guide?.skillsPortalUrl,
+      options.guide?.repo,
+      options.guide?.commitHash
+    );
+  });
   const d = UPLOAD_HEADLESS_WEBSITE_FILES_PARAM_DESCRIPTIONS;
   const registered = server.tool(
     UPLOAD_HEADLESS_WEBSITE_FILES_TOOL_NAME,
@@ -17112,6 +18687,12 @@ function addUploadHeadlessWebsiteFilesTool(server, options) {
           mime_type: external_exports.string().optional()
         })
       ).optional().describe(d.attachments),
+      prepare: external_exports.boolean().optional().describe(d.prepare),
+      size: external_exports.number().int().optional().describe(d.size),
+      uploadKey: external_exports.string().min(1).optional().describe(d.uploadKey),
+      sourceUploadId: external_exports.string().min(1).optional().describe(d.sourceUploadId),
+      expectedHeadRevisionId: external_exports.string().min(1).optional().describe(d.expectedHeadRevisionId),
+      releaseNotes: external_exports.string().optional().describe(d.releaseNotes),
       siteId: external_exports.string().uuid("siteId must be a Wix metaSiteId (UUID)").describe(d.siteId),
       calledStartDeployWebsite: external_exports.boolean().describe(d.calledStartDeployWebsite),
       agentIdentity: external_exports.string().min(1).describe(d.agentIdentity),
@@ -17124,31 +18705,185 @@ function addUploadHeadlessWebsiteFilesTool(server, options) {
       const {
         files,
         attachments,
+        prepare,
+        size,
+        uploadKey,
+        sourceUploadId,
+        expectedHeadRevisionId,
+        releaseNotes,
         siteId,
         calledStartDeployWebsite,
         agentIdentity,
         reason
       } = rawArgs;
+      const phase = prepare ? "prepare" : uploadKey ? "release-bundle" : "files";
       logger.log(
-        `[UploadHeadlessWebsiteFiles] siteId=${siteId} calledStartDeployWebsite=${calledStartDeployWebsite} agent="${agentIdentity}" files=${files?.length ?? 0} chars attachments=${attachments?.length ?? 0} reason="${reason}"`
+        `[UploadHeadlessWebsiteFiles] siteId=${siteId} phase=${phase} calledStartDeployWebsite=${calledStartDeployWebsite} agent="${redactPersonalData(agentIdentity)}" files=${files?.length ?? 0} chars attachments=${attachments?.length ?? 0} reason="${redactPersonalData(reason)}"`
       );
+      const invalid = validateBundleArgs(rawArgs);
+      if (invalid) return errorResult2(invalid);
+      if (prepare || uploadKey) {
+        const siteHeaders = await authStrategy.getSiteAuthHeaders(siteId);
+        const headers = {
+          ...siteHeaders,
+          "Content-Type": "application/json"
+        };
+        try {
+          extra?.setToolBiParams?.({ siteId });
+          if (prepare) {
+            const urls = await readJson(
+              await fetchImpl(
+                `${HEADLESS_BUSINESS}/${siteId}/bundle-upload-url`,
+                {
+                  method: "POST",
+                  headers,
+                  body: JSON.stringify({ size })
+                }
+              ),
+              "bundle-upload-url"
+            );
+            if (!urls.uploadKey || !urls.putUrl) {
+              throw new Error(
+                "bundle-upload-url returned no uploadKey or putUrl."
+              );
+            }
+            extra?.setToolBiParams?.({
+              siteId,
+              upload: { path: "prepare", sourceOffered: Boolean(urls.source) }
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatPrepareResult(siteId, urls, size, {
+                    expectedHeadRevisionId,
+                    releaseNotes
+                  })
+                }
+              ]
+            };
+          }
+          const released = await readJson(
+            await fetchImpl(`${HEADLESS_BUSINESS}/${siteId}/release-bundle`, {
+              method: "POST",
+              headers,
+              body: JSON.stringify({
+                uploadKey,
+                ...deployAuthorization(siteHeaders),
+                ...sourceUploadId ? { sourceUploadId } : {},
+                ...expectedHeadRevisionId ? { expectedHeadRevisionId } : {},
+                ...releaseNotes ? { releaseNotes: releaseNotesForService(releaseNotes) } : {}
+              })
+            }),
+            "release-bundle"
+          );
+          extra?.setToolBiParams?.({
+            siteId,
+            upload: {
+              path: "release-bundle",
+              sourceStored: Boolean(released.revision?.id)
+            }
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatBundleReleaseResult(siteId, released)
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          logger.log(`[UploadHeadlessWebsiteFiles] ${phase} error: ${message}`);
+          rethrowIfUnauthorized(err);
+          await authStrategy.enforceValidWixToken?.(err);
+          return errorResult2(
+            uploadKey ? describeBundleReleaseError(err, uploadKey, "prepare", siteId) : describeBundleUploadUrlError(err, siteId)
+          );
+        }
+      }
       if (!files?.trim() && !(attachments && attachments.length)) {
         return errorResult2(
-          "Nothing to publish: pass the site in `files` (text bundle) or `attachments` (files from this chat or your sandbox)."
+          "Nothing to publish: pass the site in `files` (text bundle) or `attachments` (files from this chat or your sandbox), or, for a Wix Astro build from a shell that reaches the internet, zip it and call with `prepare: true` and its `size`."
         );
       }
-      let siteFiles;
+      let siteFiles = [];
+      let uploaded = [];
+      let given = [];
+      let build = null;
       try {
         const fromAttachments = (await resolveAttachments(attachments, fetchImpl)).map((a) => ({ path: a.path, bytes: base64ToBytes(a.content) }));
-        siteFiles = await normalizeSiteFiles([
-          ...parseFileBundle(files),
-          ...fromAttachments
-        ]);
+        given = [...parseFileBundle(files), ...fromAttachments];
+        uploaded = await expandSiteFiles(given);
+        build = findHeadlessBuild(uploaded);
+        if (!build) siteFiles = staticSiteFiles(uploaded);
       } catch (e) {
         if (e instanceof AttachmentError || e instanceof Error)
           return errorResult2(e.message);
         throw e;
       }
+      if (!build && expectedHeadRevisionId) {
+        return errorResult2(
+          "`expectedHeadRevisionId` applies to a Wix Astro build, whose source is stored in the site's repository; these files are a static site, which has none. Call again without it."
+        );
+      }
+      if (build) {
+        const siteHeaders = await authStrategy.getSiteAuthHeaders(siteId);
+        let stagedKey;
+        try {
+          extra?.setToolBiParams?.({ siteId });
+          const sourceFiles = buildSourceFiles(uploaded, build);
+          const statics = withoutEmptyStatics(uploaded, build);
+          const released = await releaseBuildByUrl({
+            siteId,
+            // One zip as given goes as is; anything else is zipped from the expanded files.
+            siteZip: given.length === 1 && isZip(given[0]) && statics.dropped.length === 0 ? given[0].bytes : zipStored(statics.files),
+            sourceFiles,
+            expectedHeadRevisionId,
+            releaseNotes,
+            siteHeaders,
+            fetchImpl,
+            onStaged: (key) => {
+              stagedKey = key;
+            },
+            log: (line) => logger.log(`[UploadHeadlessWebsiteFiles] release ${line}`)
+          });
+          const sourceStored = Boolean(released.revision?.id);
+          extra?.setToolBiParams?.({
+            siteId,
+            upload: {
+              path: "build",
+              sourceStored,
+              sourceFiles: sourceFiles.length,
+              emptyStaticsDropped: statics.dropped.length
+            }
+          });
+          const notes = [
+            ...statics.dropped.length ? [
+              `Left out, empty: ${statics.dropped.slice(0, 20).join(", ")} (the hosting serves no file of size 0).`
+            ] : [],
+            ...sourceStored ? [] : [
+              sourceFiles.length ? "The project's source was not stored: the site's repository took none this time." : "The project's source was not stored: the upload held only the build. A later chat can continue this site only from its source; next time zip the whole project from its root, leaving out node_modules, .env files and the caches."
+            ]
+          ];
+          return {
+            content: [
+              {
+                type: "text",
+                text: formatBundleReleaseResult(siteId, released, notes)
+              }
+            ]
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          logger.log(`[UploadHeadlessWebsiteFiles] release error: ${message}`);
+          rethrowIfUnauthorized(err);
+          await authStrategy.enforceValidWixToken?.(err);
+          return errorResult2(
+            stagedKey ? describeBundleReleaseError(err, stagedKey, "resend", siteId) : describeBundleUploadUrlError(err, siteId)
+          );
+        }
+      }
       const authHeaders = await authStrategy.getAccountAuthHeaders();
       try {
         const metaSiteId = siteId;
@@ -17165,6 +18900,18 @@ function addUploadHeadlessWebsiteFilesTool(server, options) {
           ),
           "drop"
         );
+        extra?.setToolBiParams?.({
+          siteId: metaSiteId,
+          upload: { path: "drop", files: siteFiles.length }
+        });
+        let guide;
+        try {
+          guide = await guideFetch(extra?.httpClient);
+        } catch (e) {
+          logger.log(
+            `[UploadHeadlessWebsiteFiles] guide fetch failed: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
         return {
           content: [
             {
@@ -17174,7 +18921,7 @@ function addUploadHeadlessWebsiteFilesTool(server, options) {
                 siteUrl: dropped.siteUrl,
                 uploadId: dropped.uploadId,
                 files: siteFiles.map((f) => f.path)
-              })
+              }) + (releaseNotes ? "\n\nRelease notes are kept for a Wix Astro build only; a static drop has none, so yours were not stored." : "") + formatInlineGuide(guide)
             }
           ]
         };
@@ -17183,7 +18930,7 @@ function addUploadHeadlessWebsiteFilesTool(server, options) {
         logger.log(`[UploadHeadlessWebsiteFiles] Error: ${message}`);
         rethrowIfUnauthorized(err);
         await authStrategy.enforceValidWixToken?.(err);
-        return errorResult2(message);
+        return errorResult2(describeSiteAccessDenied(err, siteId) ?? message);
       }
     }
   );
@@ -17203,7 +18950,8 @@ function addSearchCodeModeTool(server, options) {
     authStrategy,
     disableTools = [],
     toolDescriptions,
-    maxResponseSize
+    maxResponseSize,
+    docsSite
   } = options;
   if (disableTools.includes(SEARCH_TOOL_NAME)) {
     return;
@@ -17215,7 +18963,8 @@ function addSearchCodeModeTool(server, options) {
     description,
     maxResponseSize,
     authStrategy,
-    codeModeFetch
+    codeModeFetch,
+    docsSite
   );
 }
 function addExecuteCodeModeTool(server, options) {
@@ -17241,6 +18990,7 @@ function addExecuteCodeModeTool(server, options) {
   });
 }
 var SEARCH_MAX_RESPONSE_CHARS = 64e3;
+var EXECUTE_MAX_RESPONSE_CHARS = 1e5;
 async function resolveLoopbackAuthorization(authStrategy) {
   try {
     return (await authStrategy?.getAccountAuthHeaders())?.Authorization;
@@ -17248,7 +18998,7 @@ async function resolveLoopbackAuthorization(authStrategy) {
     return void 0;
   }
 }
-function registerSearchTool(server, codeModeBaseUrl, description, maxResponseSize, authStrategy, codeModeFetch = defaultCodeModeFetch) {
+function registerSearchTool(server, codeModeBaseUrl, description, maxResponseSize, authStrategy, codeModeFetch = defaultCodeModeFetch, docsSite) {
   const searchUrl = `${codeModeBaseUrl}/api/code-mode/search`;
   server.tool(
     SEARCH_TOOL_NAME,
@@ -17274,7 +19024,8 @@ function registerSearchTool(server, codeModeBaseUrl, description, maxResponseSiz
             "Content-Type": "application/json",
             ...authorization3 ? { Authorization: authorization3 } : {}
           },
-          body: JSON.stringify({ code })
+          // docsSite only when set: without it the request is as before.
+          body: JSON.stringify(docsSite ? { code, docsSite } : { code })
         });
         if (!resp.ok) {
           const errorBody = await resp.text();
@@ -17301,8 +19052,14 @@ function registerSearchTool(server, codeModeBaseUrl, description, maxResponseSiz
             ]
           };
         }
+        const result = isMintlifyDocsSite(docsSite) && data.result !== void 0 ? JSON.parse(
+          (await rewriteDocsLinks(
+            toDevWixHostText(JSON.stringify(data.result)),
+            { label: "search SearchWixAPISpec" }
+          )).text
+        ) : data.result;
         const text = truncateResponse(
-          data.result,
+          result,
           maxResponseSize ?? SEARCH_MAX_RESPONSE_CHARS
         );
         return {
@@ -17335,10 +19092,13 @@ async function postExecute(executeUrl, body, authorization3, codeModeFetch = def
   }
   return await resp.json();
 }
-function executeErrorResult(message) {
+function executeErrorResult(message, failedCalls) {
   return {
     isError: true,
-    content: [{ type: "text", text: `Execute error: ${message}` }]
+    content: [{ type: "text", text: `Execute error: ${message}` }],
+    // The failed calls as fields, request ids included. The text carries the
+    // ids too, for clients that don't read structured results.
+    ...failedCalls?.length ? { structuredContent: { failedCalls } } : {}
   };
 }
 function executeTextResult(message) {
@@ -17348,7 +19108,7 @@ function executeTextResult(message) {
 }
 function formatExecuteResult(data, maxResponseSize, reportBi) {
   if (data.error) {
-    return executeErrorResult(data.error);
+    return executeErrorResult(data.error, data.failedCalls);
   }
   reportBi?.({
     originalLength: typeof data.result === "string" ? data.result.length : JSON.stringify(data.result)?.length
@@ -17368,7 +19128,13 @@ function formatExecuteResult(data, maxResponseSize, reportBi) {
   }
   return {
     content: [
-      { type: "text", text: truncateResponse(data.result, maxResponseSize) }
+      {
+        type: "text",
+        text: truncateResponse(
+          data.result,
+          maxResponseSize ?? EXECUTE_MAX_RESPONSE_CHARS
+        )
+      }
     ]
   };
 }
@@ -17430,7 +19196,9 @@ function addExecuteTool(server, options) {
           mime_type: external_exports.string().optional()
         })
       ).optional().describe(
-        'ChatGPT only. Files attached in the chat or created in your sandbox (any type: a zip of a site, HTML, images, PDFs): pass each file as you have it, its file id or its /mnt/data path, and ChatGPT swaps it for { download_url, file_id, file_name?, mime_type? } before the call reaches Wix. No other client does this swap, so outside ChatGPT a path or file:// URL here fails at once; leave this out and use `files`, or upload from your shell if it reaches the internet. The bytes are fetched here and appended to the `files` global as { path, content, encoding: "base64" } entries (path = file_name), so `wix.multipart()` and `wix.unzip()` work on them unchanged. Prefer this over base64 in `files` whenever you have a file handle. Up to 10 MB per call.'
+        fileParamNote(
+          "use `files`, or upload from your shell if it reaches the internet"
+        ) + ' Any type: a zip of a site, HTML, images, PDFs. The bytes are fetched here and appended to the `files` global as { path, content, encoding: "base64" } entries (path = file_name), so `wix.multipart()` and `wix.unzip()` work on them unchanged. Prefer this over base64 in `files` whenever you have a file handle. Up to 10 MB per call.'
       ),
       // Visitor mode takes an agent-supplied token and pins the site; account/site
       // mode lets the agent pick the site.
@@ -17471,7 +19239,11 @@ function addExecuteTool(server, options) {
       }
       let attachmentFiles = [];
       try {
-        attachmentFiles = await resolveAttachments(attachments);
+        attachmentFiles = await resolveAttachments(
+          attachments,
+          void 0,
+          WIX_AI_ASSISTANT_ATTACHMENT_HOSTS
+        );
       } catch (e) {
         if (e instanceof AttachmentError) return executeErrorResult(e.message);
         throw e;
@@ -17503,6 +19275,7 @@ function addExecuteTool(server, options) {
             sessionId,
             toolInvocationId,
             clientName: server.server?.getClientVersion?.()?.name,
+            ...visitor ? { visitorMode: true } : {},
             // A visitor token is a site-scoped bearer token: sent as siteToken
             // (→ Authorization + wix-site-id) and as accountToken only to satisfy
             // the runtime's required field. Account/site mode uses strategy tokens.
@@ -19529,6 +21302,7 @@ function createWixToolkit(options) {
       readmeDocs,
       authStrategy,
       dynamicContextEnabled: true,
+      includeCompanionApp: true,
       // README-free defaults first so consumer overrides still win.
       toolDescriptions: {
         ...descriptionsWithoutReadme,
@@ -19539,6 +21313,7 @@ function createWixToolkit(options) {
     addDocsTools(server, void 0, {
       authStrategy,
       dynamicContextEnabled: true,
+      includeCompanionApp: true,
       toolDescriptions: descriptionsWithoutReadme
     });
   }
@@ -19579,7 +21354,9 @@ function createWixToolkit(options) {
         authStrategy,
         disableTools,
         toolDescriptions: effectiveToolDescriptions,
-        maxResponseSize
+        maxResponseSize,
+        // The connection's docs site (`docs.docsSite`) applies to spec search too.
+        docsSite: docs?.docsSite
       });
     }
     if (requestedTools.has("ExecuteWixAPI") && !disableTools?.includes("ExecuteWixAPI")) {
@@ -19596,7 +21373,13 @@ function createWixToolkit(options) {
       addUploadHeadlessWebsiteFilesTool(server, {
         authStrategy,
         toolDescriptions: effectiveToolDescriptions,
-        clientName
+        clientName,
+        // The headless guide the drop reply carries is read the way the docs tools read it.
+        guide: {
+          skillsPortalUrl: docs?.skillsPortalUrl,
+          repo: docs?.repo ?? docs?.skillsRepo,
+          commitHash: docs?.commitHash ?? docs?.skillsPr
+        }
       });
     }
     const requestedGraphqlTools = GRAPHQL_TOOL_NAMES.filter(
@@ -19659,7 +21442,7 @@ function createWixToolkit(options) {
         biLogger.updateDefaults({ _uuid: "" });
         panorama.transaction(toolName).start({
           toolInvocationId,
-          params: JSON.stringify(mergedArgs)
+          params: serializeToolParamsForBi(mergedArgs)
         });
       }
       const startTime = performance.now();
@@ -19679,7 +21462,8 @@ function createWixToolkit(options) {
             cbResult,
             {
               returnedRows: toolBiParams.returnedRows,
-              originalLength: toolBiParams.originalLength
+              originalLength: toolBiParams.originalLength,
+              upload: toolBiParams.upload
             },
             { name: clientName }
           );
@@ -19694,7 +21478,7 @@ function createWixToolkit(options) {
                 context: {
                   toolName,
                   toolInvocationId,
-                  params: JSON.stringify(mergedArgs),
+                  params: serializeToolParamsForBi(mergedArgs),
                   error: JSON.stringify(cbResult, null, 2)
                 }
               }
@@ -19712,7 +21496,7 @@ function createWixToolkit(options) {
             context: {
               toolName,
               toolInvocationId,
-              params: JSON.stringify(mergedArgs),
+              params: serializeToolParamsForBi(mergedArgs),
               error: errorBody
             }
           });
@@ -19740,7 +21524,7 @@ function createWixToolkit(options) {
             errorBody,
             toolInvocationId,
             toolName,
-            params: JSON.stringify(mergedArgs),
+            params: serializeToolParamsForBi(mergedArgs),
             origin: nodeEnv,
             sessionId,
             executionResult: toolSucceeded ? "Success" : "Error",
@@ -19788,7 +21572,8 @@ function createWixToolkit(options) {
         const httpClient = new HttpClient();
         return await getDynamicContext(authStrategy, httpClient, defaults2, {
           partnerContextEnabled: true,
-          includeAccountContext: true
+          includeAccountContext: true,
+          includeCompanionApp: true
         }) || null;
       } catch {
         return null;