@bettercms-ai/mcp 0.63.2 → 0.64.1

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { realpathSync } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { loadConfig, FileTokenStore, DeviceAuthClient } from "@bettercms-ai/device-auth";
 
@@ -2266,7 +2266,7 @@ import { DeviceAuthPendingError } from "@bettercms-ai/device-auth";
 // src/structure-playbook.ts
 var STRUCTURE_PLAYBOOK_URI = "bettercms://playbook/structure";
 var STRUCTURE_DEFAULT_INSTRUCTION = `After you create collections or pages, organise them per the structure playbook: read ${STRUCTURE_PLAYBOOK_URI}, call suggest_content_structure (read-only), show the user its outline, then apply it with set_content_structure and the version it returned (the If-Match). A project that already has a structure keeps it: file only what you created, with move_to_folder, unless the user asks for a full re-organisation.`;
-var SKILLS_ROUTING_INSTRUCTION = "Before writing code in a repo that uses BetterCMS, explore the repo, then read the installed `bettercms` skill (`npx @bettercms-ai/install --project -y` adds it if missing): its table turns what you found into the one reference the task needs \u2014 read only that.";
+var SKILLS_ROUTING_INSTRUCTION = "Before writing code in a repo that uses BetterCMS, explore the repo, then read the installed `bettercms` skill (`npx @bettercms-ai/install --project -y` adds it if missing): its table turns what you found into the one reference the task needs \u2014 read only that. Without the skill installed, read the same files as resources: bettercms://skill/bettercms, then bettercms://skill/<reference>.";
 var DOCK_UI_ROUTING_INSTRUCTION = "How fields and props look in the editor (groups, tabs, rows, icons, item names) is playbook \xA714 or the `field-ui` prompt: write it with update_content_model field* or update_component prop* plus ifMatch, read it back, and finish when get_next_steps reports no dock-* step.";
 var RECEIPT_FIRST_INSTRUCTION = "Start every project with get_next_steps: its `receipt` lists what is already done (`done`), what is still missing (`missing`, each item citing the count it reacted to) and the one `nextAction`. Work from that receipt instead of re-reading the site, call get_next_steps again after each batch of edits, and before you tell the user you are finished. Fix what it lists, or say why you are leaving it.";
 var NEXT_STEPS_DESCRIPTION = `Call this FIRST on a project. Returns \`receipt\` \u2014 \`done\` (live release, bound elements, conversion coverage, composed pages, published components and Layout), \`missing\`, \`nextAction\` and \`notes\` (unjudged: unknown, not done) \u2014 plus \`data\`, the unfinished items: missing meta descriptions, drafts, empty collections, unnotified forms, writes awaiting approval, unstamped bindings or sections, \`authoring-undecided\` and the Layout lane (\`layout-write-blocked\`, \`layout-field-unread\`, \`layout-locator-stale\`, \`layout-rebuild-required\`, \`chrome-duplicated\`). Each item cites its count and may carry \`payload\` {rows, total}, at most 20 rows. Call it again after a batch of edits and before telling the user you are done. \`organise-content\`: pages and collections are in no folder \u2014 read ${STRUCTURE_PLAYBOOK_URI}, call suggest_content_structure and, once the user agrees, set_content_structure.`;
@@ -2348,6 +2348,29 @@ ever changes.
    reading needs only content access. A 403 \`SCHEMA_ACCESS_REQUIRED\` means this connection is
    neither: stop and tell the user, do not retry.
 
+## Refusals
+
+What the structure writes refuse, and the code each refusal carries:
+
+- **System folders.** \`home:pages\` (Other pages), \`home:collections\` (Shared) and
+  \`home:globals\` (Settings) always exist and can never be moved or deleted (400
+  \`NAV_SYSTEM_FOLDER\`); \`rename_folder\` and \`set_icon\` work on them.
+- **Type purity** (400 \`NAV_TYPE_MISMATCH\`): Other pages holds only pages at any depth, Shared
+  only collections, Settings neither \u2014 globals are not sidebar items.
+- **Pins** sit above the folders in their own order, pages or collections. In a document a pin is
+  \`folderId: "home:root"\`, a virtual id with no folder record; a folder record with that id is
+  400 \`NAV_SYSTEM_FOLDER\`. In \`move_to_folder\`, \`folderId: 'root'\` pins and \`null\` returns
+  the item to its home (Other pages / Shared).
+- **Kind.** \`move_to_folder\` and \`set_icon\` VERIFY what an id is: a page id sent as a
+  collection is 400 \`NAV_KIND_MISMATCH\` naming the kind to use. \`set_content_structure\` never
+  refuses a kind mismatch: it returns \`warnings\` and \`kindMismatches\` instead.
+- **Page-bound models** are refused with 400 \`NAV_PAGE_BOUND_MODEL\` naming their page; organise
+  the page, by its page id.
+- **Shape:** folders nest at most 4 levels deep; names are 1-80 characters; icons are lucide
+  names (a-z, 0-9, dashes) and null clears one.
+- **Access:** 403 \`SCHEMA_ACCESS_REQUIRED\` (rule 12).
+- **Version:** 412 \`VERSION_CONFLICT\` (workflow step 4).
+
 ## The workflow
 
 1. \`get_content_structure\` \u2014 note \`version\` and whether a structure exists.
@@ -2396,6 +2419,316 @@ ${JSON.stringify(STRUCTURE_EXAMPLE_PAYLOAD, null, 2)}
 \`\`\`
 `;
 
+// src/entry-merge.ts
+function planEntryMerge(stored, patch, callerIfMatch) {
+  const data = { ...stored.data ?? {}, ...patch };
+  const ifMatch = callerIfMatch ?? (typeof stored.optimisticVersion === "number" ? stored.optimisticVersion : void 0);
+  return ifMatch === void 0 ? { data } : { data, ifMatch };
+}
+
+// src/whoami.ts
+var WHOAMI_DESCRIPTION = "Who this connection acts as. Call it first when a call is refused for access. Returns the principal (`device_grant` from the connect flow, or `api_key`), the workspace, `scope` ('project' = bound to one project; 'workspace' = pass projectId on every project tool) and, where the server can see them, `grants`: content:publish takes content live, artifact:write runs the code and deploy tools, schema:manage changes the Content sidebar. `grants: null` means this server cannot see them, not that there are none. Reads nothing else and changes nothing.";
+
+// src/model-field-edit.ts
+function fieldRemovalRequest(args) {
+  const { removeFields, allowFieldRemoval, pageId } = args;
+  if (removeFields === void 0 && allowFieldRemoval === void 0) return { kind: "none" };
+  if (removeFields === void 0) {
+    return { kind: "refuse", error: "allowFieldRemoval names no field: pass removeFields with the top-level keys to delete." };
+  }
+  if (!Array.isArray(removeFields) || removeFields.length === 0 || !removeFields.every((k) => typeof k === "string" && k)) {
+    return { kind: "refuse", error: "removeFields must be a non-empty list of top-level field keys (from get_content_model)." };
+  }
+  if (pageId !== void 0) {
+    return { kind: "refuse", error: "A page's fields are removed with remove_page_fields, which has a dry run; removeFields takes modelId." };
+  }
+  if (allowFieldRemoval !== true) {
+    return {
+      kind: "refuse",
+      error: "removeFields deletes those fields and DISCARDS their values in every entry: send allowFieldRemoval: true with it, once the user has agreed."
+    };
+  }
+  return { kind: "remove", keys: [...new Set(removeFields)] };
+}
+function planFieldRemoval(model, keys, callerIfMatch) {
+  const fields = model.fields ?? [];
+  const present = new Set(fields.map((f) => f.key));
+  const unknown = keys.filter((k) => !present.has(k));
+  if (unknown.length > 0) {
+    return {
+      ok: false,
+      error: `Not top-level fields of this model: ${unknown.join(", ")}. Nothing was removed; read get_content_model for its keys (a group's child goes with its group, or is edited in the dashboard).`
+    };
+  }
+  const drop = new Set(keys);
+  const ifMatch = callerIfMatch ?? (typeof model.optimisticVersion === "number" ? model.optimisticVersion : void 0);
+  const kept = fields.filter((f) => !drop.has(f.key));
+  return ifMatch === void 0 ? { ok: true, fields: kept } : { ok: true, fields: kept, ifMatch };
+}
+var CHILD_LISTS = [
+  ["fields"],
+  ["config", "zones", "nonRepeatable"],
+  ["config", "zones", "repeatable", "fields"],
+  ["config", "fields"],
+  ["config", "itemFields"]
+];
+var getIn = (node, at) => at.reduce((n, k) => n && typeof n === "object" ? n[k] : void 0, node);
+var setIn = (node, [head, ...rest], value) => ({ ...node, [head]: rest.length === 0 ? value : setIn(node[head] ?? {}, rest, value) });
+function patchAt(fields, [key, ...rest], edit) {
+  const at = fields.findIndex((f) => f.key === key);
+  if (at === -1) return null;
+  const field = fields[at];
+  let next = null;
+  if (rest.length === 0) next = edit(field);
+  else {
+    for (const list of CHILD_LISTS) {
+      const kids = getIn(field, list);
+      const patched = Array.isArray(kids) ? patchAt(kids, rest, edit) : null;
+      if (patched) {
+        next = setIn(field, list, patched);
+        break;
+      }
+    }
+  }
+  return next && fields.map((f, i) => i === at ? next : f);
+}
+function fieldAt(fields, keys) {
+  let found;
+  patchAt(fields, keys, (f) => (found = f, f));
+  return found;
+}
+function allKeys(fields) {
+  return fields.flatMap((f) => [
+    String(f.key),
+    ...CHILD_LISTS.flatMap((list) => {
+      const kids = getIn(f, list);
+      return Array.isArray(kids) ? allKeys(kids) : [];
+    })
+  ]);
+}
+var CLEARABLE = ["helpText", "showIf", "ui", "placement"];
+var SETTABLE = ["label", "required", ...CLEARABLE];
+function mergeConfig(current, patch) {
+  const out = { ...current ?? {} };
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === null) delete out[k];
+    else out[k] = v;
+  }
+  return out;
+}
+function planFieldEdit(model, edit, callerIfMatch) {
+  const fields = model.fields ?? [];
+  const keys = typeof edit.path === "string" && edit.path ? edit.path.split(".") : [];
+  const current = keys.length ? fieldAt(fields, keys) : void 0;
+  if (!current) {
+    return { ok: false, error: `No field at path '${String(edit.path ?? "")}'. Paths are dot-separated keys from get_content_model or get_page, e.g. 'hero.title'.` };
+  }
+  const retype = edit.type !== void 0 && edit.type !== current.type;
+  if (retype && edit.allowRetype !== true) {
+    return {
+      ok: false,
+      error: `Changing '${keys.join(".")}' from ${String(current.type)} to ${String(edit.type)} changes how every stored value is read, and values that do not fit are lost. Send allowRetype: true with it, once the user has agreed.`
+    };
+  }
+  const rename = typeof edit.key === "string" && edit.key !== current.key ? edit.key : void 0;
+  if (rename !== void 0 && allKeys(fields).includes(rename)) {
+    return { ok: false, error: `The key '${rename}' is already used in this schema; keys share one flat namespace, nested fields included.` };
+  }
+  const changes = SETTABLE.filter((k) => edit[k] !== void 0);
+  if (!retype && rename === void 0 && edit.config === void 0 && changes.length === 0) {
+    return { ok: false, error: "Nothing to change: pass label, helpText, required, config, showIf, ui, placement, type or key." };
+  }
+  const next = patchAt(fields, keys, (f) => {
+    let out = { ...f };
+    for (const k of changes) {
+      if (edit[k] === null && CLEARABLE.includes(k)) delete out[k];
+      else out[k] = edit[k];
+    }
+    if (edit.config && typeof edit.config === "object") out = { ...out, config: mergeConfig(f.config, edit.config) };
+    if (retype) out.type = edit.type;
+    if (rename !== void 0) out.key = rename;
+    return out;
+  });
+  const ifMatch = callerIfMatch ?? (typeof model.optimisticVersion === "number" ? model.optimisticVersion : void 0);
+  return {
+    ok: true,
+    fields: next,
+    ...ifMatch === void 0 ? {} : { ifMatch },
+    ...rename === void 0 ? {} : { renamed: { from: String(current.key), to: rename } }
+  };
+}
+
+// src/toolsets.ts
+var LISTING_TAIL = /* @__PURE__ */ new Set([
+  // The agent-job lane: a dashboard surface an agent rarely drives.
+  "list_ai_jobs",
+  "get_ai_job",
+  "approve_ai_job",
+  "reject_ai_job",
+  "list_ai_reports",
+  "connect_native_ai",
+  // Component validation: a CI lane, not an authoring one.
+  "request_component_validation",
+  "declare_component_route",
+  "clear_component_source",
+  "submit_componentize_receipt",
+  // Reporting, history and workflow chrome.
+  "get_analytics_overview",
+  "get_analytics_top_pages",
+  "list_activity",
+  "get_workflow_board",
+  "move_stage",
+  "list_entry_versions",
+  "restore_entry_version",
+  // One-off project operations and the extraction lane.
+  "clone_project",
+  "promote_project",
+  "generate_pages_from_dataset",
+  "extract_component",
+  "list_extraction_candidates",
+  "create_deploy_upload",
+  "set_authoring_preference",
+  "set_media_delivery",
+  "delete_form_submission",
+  "remove_page_fields",
+  // Access troubleshooting and platform feedback: called when something is refused or missing.
+  "whoami",
+  "give_feedback",
+  "search_docs",
+  // Search, batch and localisation: reached for once the site exists.
+  "search_content",
+  "discard_draft",
+  "publish_entries",
+  "create_content_entries",
+  "translate_entry",
+  "update_field",
+  "refresh_search_index",
+  // Automation, branches and AI images.
+  "list_webhooks",
+  "create_webhook",
+  "list_branches",
+  "create_branch",
+  "apply_branch",
+  "generate_image",
+  "transform_image",
+  // The ABM campaign lane — also hidden from the default listing (ABM_TOOLS below).
+  "research_account",
+  "build_abm_page",
+  "claim_abm_task",
+  "complete_abm_task",
+  "fail_abm_task",
+  "get_campaign_review",
+  "regenerate_entry",
+  "approve_campaign_entries",
+  "publish_campaign",
+  "get_campaign_share_link",
+  "revoke_campaign_share_link"
+]);
+var ABM_TOOLS = /* @__PURE__ */ new Set([
+  "research_account",
+  "build_abm_page",
+  "claim_abm_task",
+  "complete_abm_task",
+  "fail_abm_task",
+  "get_campaign_review",
+  "regenerate_entry",
+  "approve_campaign_entries",
+  "publish_campaign",
+  "get_campaign_share_link",
+  "revoke_campaign_share_link"
+]);
+var TOOLSETS = ["core", "abm", "all"];
+function toolsetsOf(raw) {
+  const names = (raw ?? "").toLowerCase().split(",").map((s) => s.trim());
+  return new Set(names.filter((n) => TOOLSETS.includes(n)));
+}
+function listsTool(name, sets) {
+  if (sets.has("all")) return true;
+  if (ABM_TOOLS.has(name)) return sets.has("abm");
+  return !sets.has("core") || !LISTING_TAIL.has(name);
+}
+
+// src/tool-text.ts
+var ADD_FIELD_DESCRIPTION = "Append ONE field to a content model (`modelId`) or to a page's schema (`pageId`) \u2014 additive, never overwrites; a key already in use is refused. For a section/zone add ONE 'group' (fixed block) or 'repeater' (repeating list) carrying its child `fields`, not the zone's inner fields as separate top-level fields. Pass `after` to insert it after an existing top-level field instead of at the end; `ui`, `helpText`, `showIf`, `placement` and `fieldsetId` declare how it presents in the editor \u2014 read them back with get_content_model or get_page. On a page a 'group' is stored as type 'array' with `config.zones.nonRepeatable`: entry and delivery data carry `<key>.nonRepeatable.<sub>`, while data-bcms-field paths are `<key>.<sub>`. Schema only \u2014 never places a section; use componentize_sections to turn a group into a section. To change a field that exists, use update_field.";
+var MOVE_STAGE_DESCRIPTION = "Move a content entry (`entryId`) or a page (`pageId`) to another editorial stage \u2014 this is how you take it OUT of review so it can be published. `workflowStage` is a stage key from get_workflow_board; pass `fromStage` to 409 if someone moved it first. Moving into the publish-gate stage is an approval and needs a publish-enabled connection. Publish afterwards with update_content_entry or update_page status:'published' \u2014 approving and publishing are deliberately two separate calls.";
+var WEBHOOK_EVENTS = [
+  "content.publish",
+  "content.unpublish",
+  "content.stage_changed",
+  "content.created",
+  "content.updated",
+  "content.deleted",
+  "deployment.triggered"
+];
+var NEW_TOOL_TEXT = {
+  search_content: "Full-text search over the project's PUBLISHED pages and entries (the site-search index). Returns id, type ('page'|'entry'), title, slug and a snippet per hit; `type` narrows to one kind. Drafts are not indexed: find those with list_content_entries `where`. `meta.unavailable` means site search is off for this project.",
+  discard_draft: "Throw away unpublished edits to an entry (`entryId`) or a page (`pageId`) \u2014 exactly one: the draft returns to exactly what is live and `pendingChanges` becomes false. A page resets its blockJson and its published Layout overrides. 409 no_published_version means it was never published (delete it instead). Pass ifMatch (optimisticVersion) to refuse if it changed since you read it.",
+  give_feedback: "Tell the BetterCMS team about a tool that failed, a capability you needed and did not have, or docs that misled you. Opens a ticket for the team; nothing in the project changes. Name the `tool`, and paste the request and response into `context`. Never include secrets or personal data.",
+  publish_entries: "Publish or unpublish many entries and pages in ONE call (up to 100 ids of each; pages publish only). Needs a publish-enabled connection, and each item still passes its own gates (editorial stage, required fields). Nothing stops the run: the result lists what changed (`published` or `unpublished`) and every refusal in `failed` with its reason. A publish answers 202 with the routes being rebuilt.",
+  create_content_entries: "Create up to 200 DRAFT entries of one collection in ONE call, each {slug?, data} as create_content_entry takes it. Every row reports `created` (with id and slug) or `failed` (with the error), a failure does not stop the others, and `meta` counts both. Publish afterwards with publish_entries.",
+  translate_entry: "Create an entry's `targetLocale` translation with AI (uses AI credits: 402/403 when out or not on the plan). Text and longtext fields are translated; rich text and documents are copied for you to translate; the rest is copied. The new entry is a DRAFT with `locale` set and `translationOf` = the source; `meta` lists translated and copied keys. `targetLocale` must be one of the project's locales; 409 locale_conflict means that translation exists, so edit it instead.",
+  list_webhooks: "List the project's outgoing webhooks: name, url, events, whether active, and delivery health (total, failed, last attempt). Signing secrets are never returned.",
+  create_webhook: "Create an outgoing webhook: BetterCMS POSTs each subscribed event to your https `url`, signed with HMAC-SHA256 in X-BetterCMS-Signature. The response carries the signing `secret` ONCE: store it now. `test: true` also sends a sample delivery. Payloads carry ids and metadata, never the content: fetch it from the API. A receiver that writes back on content.updated loops unless it skips its own writes.",
+  list_branches: "List the project's content branches (id, name, slug, parent, status, whether main) and the `currentBranchId` this connection is on. To work inside a branch, pass its id as `branchId` on any tool call; apply_branch merges it into its parent.",
+  create_branch: "Create a content branch: a copy of the project's content to edit without touching the live site. Returns the branch; pass its id as `branchId` on later calls to work in it, then apply_branch. 409 means the name or slug is taken.",
+  apply_branch: "Merge a branch into its parent. dryRun: true returns the diff (changes, summary, conflicts) and writes nothing: ALWAYS read it and show the user first. `include` limits the merge to those change keys; `fields` resolves a conflicting field per change key ('keep_branch' or 'keep_parent'). 409 names unresolved conflicts, missing dependencies, or a merge already running.",
+  search_docs: "Search the BetterCMS documentation. Returns the best pages (title, url, breadcrumbs, snippet). Use it before guessing how a feature works; `meta.unavailable` means docs search is down right now.",
+  generate_image: "Generate an image with AI and add it to the Media Library (5 AI credits; free with the workspace's own Together key). `width`/`height` are 256-1440 in multiples of 16 (default 1024x768). Returns the new asset (id, url, altText): use the url as an 'image' field value. Always set `altText`.",
+  refresh_search_index: "Tell search engines and site search about published changes; costs nothing. action 'indexnow' submits `urls` (this site's own, up to 1000) to IndexNow, or every change since the last submission when omitted. action 'reindex' rebuilds the project's site-search index. 503 means the index is unreachable: try again later.",
+  transform_image: "Edit an existing Media Library image with an instruction (e.g. 'remove the background', 'make it dusk'); the result is saved as a NEW asset and the original is kept (5 AI credits). Returns the new asset (id, url, altText)."
+};
+var PARAM_TEXT = {
+  where: "field filters: {field: value} is equality, {field: {op: value}} with op eq|ne|gt|gte|lt|lte|contains|in, and an array means `in`. System fields slug, status, publishedAt, locale work anywhere; a data field needs modelId. Compares the served copy (live for published, working for draft)",
+  sort: "comma list, a leading - sorts descending, e.g. '-publishedAt,title'",
+  page: "1-based page of `limit` rows; the response's meta says totalPages",
+  locale: "BCP-47 locale, one of the project's locales; null = the default language",
+  translationOf: "the SOURCE's id this translates (never another translation); null unlinks. One per locale: set locale on the translation and translationOf to the source",
+  pageScheduledAt: "ISO datetime to publish this page's draft at (needs publish permission); null cancels. An edit that omits scheduledAt CANCELS a pending schedule",
+  pageUnpublishAt: "ISO datetime at which the published page returns to draft; null cancels; omitting it never cancels it",
+  sourceUrl: "instead of data: a public http(s) URL the server fetches and stores (private or internal addresses are refused)",
+  focalX: "focal point, 0-1 across from the left edge; null resets to the centre",
+  focalY: "focal point, 0-1 down from the top edge; null resets to the centre"
+};
+var UPDATE_FIELD_DESCRIPTION = "Change ONE existing field of a content model (`modelId`) or of a page's schema (`pageId`), addressed by `path`: its key, or dot-separated keys through groups and repeaters ('hero.title'). Set its label, helpText, required, validation `config` (merged by key; null deletes one), showIf, ui or placement (null clears those). The rest of the schema is written back unchanged at the version read; a 409 means it changed since, so read again. `type` changes how every stored value is read and needs allowRetype: true. `key` renames it: stored values stay under the old key, so the route answers 409 with the entry count unless allowFieldRemoval: true discards them \u2014 migrate the values first. Ask the user before a retype or a rename.";
+var GET_SEO_DESCRIPTION = "Get the connected project's site-wide SEO settings \u2014 every key update_seo writes: seoDefaults (metaTitle, metaDescription, ogImage, twitterHandle, og, twitter, collectionSchemaTypes), siteSchema (the site's JSON-LD), robotsConfig, sitemapConfig, rssConfig, indexnowConfig and searchConfig.";
+var UPDATE_SEO_DESCRIPTION = "Set the connected project's site-wide SEO defaults and config. Each key you send is REPLACED whole (not deep-merged), so read get_seo and send the complete object. `seoDefaults` applies to every page that does not override it, and its `collectionSchemaTypes` maps a collection's model id to the schema.org type of its entries. `siteSchema` is the site's own JSON-LD (Organization/WebSite, emitted on the home page). `robotsConfig`, `sitemapConfig` and `rssConfig` shape robots.txt, sitemap.xml and the feed; `indexnowConfig` pings search engines on publish; `searchConfig` is site search. A key the plan does not include answers 403 FEATURE_LOCKED. Rebuilds the site.";
+var SEO_KEY_TEXT = {
+  seoDefaults: "site-wide meta defaults every page inherits",
+  siteSchema: "the site's JSON-LD: an object or an array of objects",
+  robotsConfig: "robots.txt: 'auto', or 'custom' with its text",
+  sitemapConfig: "sitemap.xml: generated ('auto') or 'custom', defaults and extra URLs",
+  rssConfig: "the RSS feed on or off",
+  indexnowConfig: "IndexNow on publish, minus URL patterns to leave out",
+  searchConfig: "site search: on/off, the box's placeholder, AI answers"
+};
+var VARIANT_GROUP_NOTE = "When the component belongs to a family of looks, `variantGroup` names the family and lists its looks.";
+var UNPROPPED_COPY_NOTE = "A `warnings` entry UNPROPPED_COPY names copy no prop targets, which nobody can edit: add a prop with a `target` for each leaf it lists.";
+var UPDATE_PAGE_IF_MATCH_NOTE = "get_page's `optimisticVersion`: the write applies only at that version, and a 409 means the page changed since, so read it again. Send it whenever you pass blockJson, which REPLACES the whole composition.";
+
+// src/entry-query.ts
+var text = (v) => Array.isArray(v) ? v.map(String).join(",") : String(v);
+function whereToQuery(where) {
+  const out = [];
+  for (const [field, cond] of Object.entries(where ?? {})) {
+    if (cond === void 0 || cond === null) continue;
+    if (Array.isArray(cond)) out.push([`filter[${field}][in]`, text(cond)]);
+    else if (typeof cond === "object") {
+      for (const [op, v] of Object.entries(cond)) {
+        if (v !== void 0 && v !== null) out.push([`filter[${field}][${op}]`, text(v)]);
+      }
+    } else out.push([`filter[${field}]`, text(cond)]);
+  }
+  return out;
+}
+function entryListSearch(args) {
+  const q = new URLSearchParams();
+  for (const key of ["modelId", "pageId", "status"]) if (args[key]) q.set(key, String(args[key]));
+  for (const [k, v] of whereToQuery(args.where)) q.append(k, v);
+  for (const key of ["sort", "page", "limit"]) if (args[key] !== void 0 && args[key] !== null) q.set(key, String(args[key]));
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+
 // src/tools.ts
 async function askHuman(deps, q) {
   if (!deps.elicit) return { prompt: q.prompt };
@@ -2647,7 +2980,34 @@ var fieldsetsArg = z.array(
 );
 var dropProvenance = (sets) => sets?.map(({ uiOrigin: _origin, uiBefore: _before, ...set }) => set) ?? sets;
 var RICH_TEXT_NOTE = "\u{1F534} A field of type 'text' is created as RICH TEXT unless you send `richText: false` on it. Send `richText: false` for every value that is not prose: a name used as a title, a URL, slug, id, SKU, email, phone, CSS class or icon name.";
-var PAGES_NOT_COLLECTIONS_NOTE = "A collection is only for items one template route repeats (/blog/:slug: set urlPattern). A single page's copy (home, about, contact, pricing, legal) is page fields in sections (add_page_field / set_page_content), never a one-entry collection.";
+var SCHEMA_ORG_TYPES = ["WebPage", "AboutPage", "ContactPage", "CollectionPage", "Blog", "BlogPosting", "Article", "Product", "FAQPage", "Event", "Organization", "LocalBusiness"];
+var changefreq = z.enum(["auto", "always", "hourly", "daily", "weekly", "monthly", "yearly", "never"]);
+var jsonObject = z.record(z.string(), z.unknown());
+var seoPatchShape = {
+  seoDefaults: z.object({
+    metaTitle: z.string().max(255).optional(),
+    metaDescription: z.string().max(500).optional(),
+    ogImage: z.string().url().max(2e3).nullable().optional(),
+    twitterHandle: z.string().max(255).nullable().optional(),
+    og: z.object({ image: z.string().max(2048).optional(), type: z.string().max(50).optional() }).optional(),
+    twitter: z.object({ card: z.string().max(50).optional() }).optional(),
+    collectionSchemaTypes: z.record(z.string().min(1).max(64), z.enum(SCHEMA_ORG_TYPES)).optional()
+  }).optional().describe(SEO_KEY_TEXT.seoDefaults),
+  siteSchema: z.union([jsonObject, z.array(jsonObject)]).optional().describe(SEO_KEY_TEXT.siteSchema),
+  robotsConfig: z.object({ mode: z.enum(["auto", "custom"]), custom: z.string().max(1e4).optional() }).optional().describe(SEO_KEY_TEXT.robotsConfig),
+  sitemapConfig: z.object({
+    enabled: z.boolean(),
+    mode: z.enum(["auto", "custom"]).optional(),
+    custom: z.string().max(5e5).optional(),
+    defaultChangefreq: changefreq.optional(),
+    defaultPriority: z.number().min(0).max(1).optional(),
+    extraUrls: z.array(z.object({ loc: z.string().min(1).max(2e3), changefreq: changefreq.optional(), priority: z.number().min(0).max(1).optional() })).max(1e3).optional()
+  }).optional().describe(SEO_KEY_TEXT.sitemapConfig),
+  rssConfig: z.object({ enabled: z.boolean() }).optional().describe(SEO_KEY_TEXT.rssConfig),
+  indexnowConfig: z.object({ enabled: z.boolean(), excludePatterns: z.array(z.string().max(2e3)).max(200).optional() }).optional().describe(SEO_KEY_TEXT.indexnowConfig),
+  searchConfig: z.object({ enabled: z.boolean(), placeholder: z.string().max(120), aiEnabled: z.boolean().optional() }).optional().describe(SEO_KEY_TEXT.searchConfig)
+};
+var PAGES_NOT_COLLECTIONS_NOTE = "A collection is only for items one template route repeats (/blog/:slug: set urlPattern). A single page's copy (home, about, contact, pricing, legal) is page fields in sections (add_field with pageId / set_page_content), never a one-entry collection.";
 function flatFieldKeys(fields) {
   const out = [];
   const childrenOf = (f) => {
@@ -2730,7 +3090,9 @@ function toField(f) {
   };
 }
 var BRAND_KIT_NOTE = "`brandKit` (colors, typography, radius and any typeScale/spacing/elevation/motion/graphics) is edited in the BetterCMS dashboard AND by set_brand_assets and set_brand_graphics; every write is a version a person can restore. ASSETS: a media asset OF THIS PROJECT by id; null clears one; a slot a person chose needs `replace: true`. GRAPHICS: `kind`, optional `angle`, 2-8 stops naming `colors.*` or `extras` keys \u2014 never a CSS string and never a hex. CONSUME, DO NOT COPY: a hosted page exposes `--brand-color-<key>`, `--brand-shadow-<key>` and `--brand-gradient-<key>`; style sections with their `style` tokens (`nav.backgroundGradient` and `footer.backgroundGradient` take a gradient key), never copied values. Never invent brand facts: read them from get_project.";
-var UPDATE_MODEL_DESCRIPTION = "Edit a content model: rename it, change description/slug/urlPattern, set its `fieldsets`, or reshape how its EXISTING fields look in the editor. Never adds, removes or retypes a field (use add_field). Send modelId, or pageId for the model a page's schema lives in. `fieldsets` REPLACES the list (null drops all); a field joins one with fieldFieldset or add_field's `fieldsetId`. The field* args address fields by dotted key path ('hero.title'). Read with get_content_model, then pass `ifMatch` = the version from that read. A taken slug is 409 `slug_taken`. Section 14 of bettercms://playbook/schema.";
+var UPDATE_MODEL_DESCRIPTION = "Edit a content model: rename it, change description/slug/urlPattern, set its `fieldsets`, or reshape how its EXISTING fields look in the editor. Never adds or retypes a field (use add_field). It removes one only with `removeFields` plus `allowFieldRemoval: true`, which DISCARDS its data in every entry and has no dry run; a page's fields go through remove_page_fields. Send modelId, or pageId for the model a page's schema lives in. `fieldsets` REPLACES the list (null drops all); a field joins one with fieldFieldset or add_field's `fieldsetId`. The field* args address fields by dotted key path ('hero.title'). Read with get_content_model, then pass `ifMatch` = the version from that read. A taken slug is 409 `slug_taken`. Section 14 of bettercms://playbook/schema.";
+var FIELD_REMOVAL_NOTE = "top-level field keys (from get_content_model) to DELETE from this model with every entry's value for them; needs allowFieldRemoval: true. An unknown key refuses the whole call. Never for a rename: rename the label instead.";
+var ALLOW_FIELD_REMOVAL_NOTE = "true = the user accepts that removeFields discards those fields' data in every entry. There is no dry run on this route: confirm first.";
 var MODEL_IF_MATCH_NOTE = "optimisticVersion from get_content_model (with pageId: get_page backingModel). The write applies only at that version; a 409 version-conflict means it changed since: read it again and re-apply, never retry blindly. REQUIRED with field*, override or a fieldset kind/tab/icon/collapsed (428 without); otherwise, omitted, the last write wins.";
 var COMPONENT_IF_MATCH_NOTE = "optimisticVersion from get_component. The write applies only at that version; a 409 version-conflict means it changed since: read it again and re-apply. REQUIRED with prop*, override or a prop ui icon/itemLabel/group (428 without).";
 var PROP_UI_ARG_NOTE = "top-level prop key \u2192 ui patch, the same vocabulary as a prop's `ui`: each key merges, a null key clears it, null clears the whole ui";
@@ -2750,9 +3112,15 @@ var MODEL_UPDATE_KEYS = [
   "override"
 ];
 var ENTRY_META_NOTE = "SEO is native: set this entry's metaTitle, metaDescription, noindex, canonical, og, twitter, schemaType or schema in `meta` (never as model fields). `meta` MERGES into what is stored: a key you leave out is kept, null or an empty string clears it.";
+var ENTRY_MERGE_NOTE = "true = keep the fields you leave out: the entry is read, `data` is laid over its stored data by top-level key (a group or repeater value replaces that whole key) and written at the version read. Default false: `data` REPLACES the whole object.";
+var ENTRY_IF_MATCH_NOTE = "optimisticVersion from get_content_entry: the write applies only at that version, and a 409 means it changed since: read it again and re-apply. With merge it defaults to the version merge read.";
+var ENTRY_SCHEDULED_AT_NOTE = "ISO datetime to publish this draft at (needs publish permission); null cancels. An edit that omits scheduledAt CANCELS a pending publish schedule, so send it again with every edit made before it fires.";
+var ENTRY_UNPUBLISH_AT_NOTE = "ISO datetime at which the published entry returns to draft; null cancels. Omitting it never cancels it.";
+var ENTRY_LIST_LIMIT_NOTE = "entries per page, 1-200; 50 when omitted. Read `meta.totalPages` and ask for the next `page`.";
 var PAGE_HEAD_NOTE = "noindex, canonical, og and twitter set the page's head extras; each MERGES into what is stored (a key you leave out is kept, null or an empty string clears it).";
-var STRUCTURE_NOTE = 'ORGANISATION ONLY: Content sidebar folders never change a URL, slug, content or publish state; URL folders (page folders) are set in the dashboard. Folders nest at most 4 levels deep. Icons are lucide names (a-z, 0-9, dashes); null clears one. SYSTEM FOLDERS "home:pages" (Other pages), "home:collections" (Shared) and "home:globals" (Settings) always exist and can never be moved or deleted (400 NAV_SYSTEM_FOLDER); rename_folder and set_icon work on them. TYPE PURITY (400 NAV_TYPE_MISMATCH): Other pages holds only pages at any depth, Shared only collections, Settings neither \u2014 globals are not sidebar items. ACCESS: changing the structure needs Admin or Developer, reading only content access; a 403 SCHEMA_ACCESS_REQUIRED means neither: stop and tell the user, do not retry. PINS sit above the folders in their own order, pages or collections; in a document a pin is folderId "home:root", a virtual id with no folder record (a folder record with that id is 400 NAV_SYSTEM_FOLDER). set_content_structure never refuses a kind mismatch: it returns `warnings` and `kindMismatches` (the single writes do \u2014 see `kind`). PAGE-BOUND MODELS: a page with fields has a bound model that is NOT a collection: never listed or filed, and the writes refuse it with 400 NAV_PAGE_BOUND_MODEL naming its page. Organise the PAGE instead, by its page id. ';
 var STRUCTURE_FENCE = "ORGANISATION ONLY: Content sidebar folders never change a URL, slug, content or publish state, and nothing is rebuilt or delivered; URL folders (page folders) are set in the dashboard. Read the resource bettercms://playbook/structure before you organise anything: it holds the rules this refuses on \u2014 system folders, type purity, the Admin/Developer access check, root pins and page-bound models. A resource is never truncated; a long description is.";
+var STRUCTURE_POINTER = "Sidebar only, never a URL; rules: bettercms://playbook/structure.";
+var BRAND_KIT_POINTER = "The brand kit's rules (consume its tokens, never copy values or invent brand facts) are on get_project.";
 function structureResult(d) {
   const message = d?.message;
   return ok(typeof message === "string" ? message : "Updated the Content structure.", d);
@@ -2844,97 +3212,51 @@ function refusalDetail(err) {
 ${lines.join("\n")}` : "";
 }
 function authPrompt(err) {
-  const text = [
+  const text2 = [
     "\u{1F510} BetterCMS authorization required \u2014 you're not signed in yet.",
     "",
     `1. Open this link and approve:  ${err.verificationUriComplete}`,
     `   (or visit ${err.verificationUri} and enter code ${err.userCode})`,
     "2. Once approved, run this tool again \u2014 it resumes automatically and completes your request."
   ].join("\n");
-  return { content: [{ type: "text", text }], isError: true };
+  return { content: [{ type: "text", text: text2 }], isError: true };
 }
 var currentProject = new AsyncLocalStorage();
+var currentBranch = new AsyncLocalStorage();
 var projectIdArg = z.string().min(1).optional().describe(
   "target project id (from list_projects); only for a workspace-wide grant."
 );
+var branchIdArg = z.string().min(1).optional().describe("content branch id (from list_branches); omit to work on main");
 var withProjectId = (def) => ({
   ...def,
-  config: def.config.inputSchema.projectId ? def.config : { ...def.config, inputSchema: { ...def.config.inputSchema, projectId: projectIdArg } },
+  config: {
+    ...def.config,
+    inputSchema: {
+      ...def.config.inputSchema,
+      ...def.config.inputSchema.projectId ? {} : { projectId: projectIdArg },
+      ...def.config.inputSchema.branchId ? {} : { branchId: branchIdArg }
+    }
+  },
   handler: (args) => {
-    const project = typeof args?.projectId === "string" && args.projectId ? args.projectId : void 0;
-    return currentProject.run(project, () => def.handler(args));
+    const arg = (key) => typeof args?.[key] === "string" && args[key] ? args[key] : void 0;
+    return currentProject.run(arg("projectId"), () => currentBranch.run(arg("branchId"), () => def.handler(args)));
   }
 });
-var LISTING_TAIL = /* @__PURE__ */ new Set([
-  // The agent-job lane: a dashboard surface an agent rarely drives.
-  "list_ai_jobs",
-  "get_ai_job",
-  "approve_ai_job",
-  "reject_ai_job",
-  "list_ai_reports",
-  "connect_native_ai",
-  "native_bridge_heartbeat",
-  // Section evidence and component validation: a CI lane, not an authoring one.
-  "claim_section_validation_request",
-  "complete_section_validation_request",
-  "fail_section_validation_request",
-  "list_section_validation_requests",
-  "submit_section_validation",
-  "submit_section_manifest",
-  "request_component_validation",
-  "declare_component_route",
-  "clear_component_source",
-  "submit_componentize_receipt",
-  // Reporting, history and workflow chrome.
-  "get_analytics_overview",
-  "get_analytics_top_pages",
-  "list_activity",
-  "get_workflow_board",
-  "move_entry_stage",
-  "move_page_stage",
-  "list_entry_versions",
-  "restore_entry_version",
-  // One-off project operations and the extraction lane.
-  "clone_project",
-  "promote_project",
-  "generate_pages_from_dataset",
-  "extract_component",
-  "list_extraction_candidates",
-  "create_deploy_upload",
-  "deploy_from_upload",
-  "set_authoring_preference",
-  "set_media_delivery",
-  "delete_form_submission",
-  "remove_page_fields",
-  // The ABM campaign lane: a marketer's dashboard surface, plus the worker tools a task runner
-  // claims with. Ten more tools than the tail was written for, and a connector that truncates
-  // would otherwise lose `get_deploy_status` and the GitHub lane to make room for them.
-  "research_account",
-  "build_abm_page",
-  "claim_abm_task",
-  "complete_abm_task",
-  "fail_abm_task",
-  "get_campaign_review",
-  "regenerate_entry",
-  "approve_campaign_entries",
-  "publish_campaign",
-  "get_campaign_share_link",
-  "revoke_campaign_share_link"
-]);
 function buildToolDefs(deps) {
   async function withClient(fn) {
     const token = await deps.auth.getAccessToken();
     const project = currentProject.getStore();
+    const branch = currentBranch.getStore();
     try {
-      return await fn(deps.createClient(token, project));
+      return await fn(deps.createClient(token, project, branch));
     } catch (err) {
       if (err instanceof BetterCMSError && err.status === 401) {
         const next = await deps.auth.refresh() ?? await deps.auth.getAccessToken();
-        return await fn(deps.createClient(next, project));
+        return await fn(deps.createClient(next, project, branch));
       }
       if (err instanceof BetterCMSError && err.status === 409 && err.bodyCode === "PROJECT_DELETED") {
         const next = await deps.auth.resetAndReauthorize();
-        return await fn(deps.createClient(next, project));
+        return await fn(deps.createClient(next, project, branch));
       }
       throw err;
     }
@@ -2997,7 +3319,9 @@ function buildToolDefs(deps) {
       "a SINGLETON's field VALUES keyed by field key \u2014 seeds its entry in the same call. If any value is refused the page is still created, none of `data` is saved, and the result names ENTRY_SEED_FAILED with the per-field reasons: fix them and write with set_page_content."
     ),
     metaTitle: z.string().optional().describe("SEO meta title"),
-    metaDescription: z.string().optional().describe("SEO meta description")
+    metaDescription: z.string().optional().describe("SEO meta description"),
+    locale: z.string().nullable().optional().describe(PARAM_TEXT.locale),
+    translationOf: z.string().nullable().optional().describe(PARAM_TEXT.translationOf)
   });
   const writeContentInput = z.object({
     action: z.enum(["write", "rewrite", "translate"]).describe("'write' = draft from a brief, 'rewrite' = improve existing copy, 'translate' = needs targetLang"),
@@ -3015,13 +3339,6 @@ function buildToolDefs(deps) {
       "optional \u2014 any of inspect, propose, implement, cancel, question. Defaults to inspect+propose+cancel."
     )
   });
-  const nativeBridgeHeartbeatInput = z.object({
-    protocolVersion: z.string().min(1).describe("executor protocol version; currently '1'"),
-    capabilities: z.array(z.string().min(1)).min(1).describe(
-      "what this executor can do: any of inspect, propose, implement, cancel, question. Must include inspect, propose and cancel. An unknown value is refused, never ignored."
-    ),
-    session: z.object({ sessionId: z.string(), sessionEpoch: z.number().int().positive() }).optional().describe("the `session` from the previous response; omit on first contact to reconnect")
-  });
   const createModelInput = z.object({
     name: z.string().min(1).describe("human model name, e.g. 'Blog Post'"),
     slug: slug.describe("url-safe unique slug, e.g. 'blog-post'"),
@@ -3039,18 +3356,15 @@ function buildToolDefs(deps) {
     "OPTIONAL insertion point: the key of an existing TOP-LEVEL field to insert this one directly after. Omit to append at the end (the default, and the behaviour before this existed). Use it to put a field where an author expects it instead of at the bottom \u2014 e.g. after:'hero_title' for a subtitle. An unknown key is refused rather than silently appended."
   );
   const addFieldInput = z.object({
-    modelId: z.string().min(1).describe("id of the content model to extend"),
-    ...fieldShape,
-    after: afterArg
-  });
-  const addPageFieldInput = z.object({
-    pageId: z.string().min(1).describe("id of the page to extend (from list_pages / create_page)"),
+    modelId: z.string().min(1).optional().describe("the content model to extend (from list_content_models); or send pageId"),
+    pageId: z.string().min(1).optional().describe("instead of modelId: the page whose schema to extend (from list_pages / create_page)"),
     ...fieldShape,
     after: afterArg
   });
   const uploadAssetInput = z.object({
     localPath: z.string().min(1).optional().describe("absolute path to a local file (e.g. a repo image); provide this OR url"),
-    url: z.string().url().optional().describe("remote image URL to ingest; provide this OR localPath"),
+    url: z.string().url().optional().describe("remote image URL this client downloads and uploads; provide this OR localPath OR sourceUrl"),
+    sourceUrl: z.string().url().optional().describe(PARAM_TEXT.sourceUrl),
     filename: z.string().optional().describe("override the stored filename"),
     altText: z.string().optional().describe("accessibility alt text"),
     caption: z.string().optional(),
@@ -3061,7 +3375,9 @@ function buildToolDefs(deps) {
     contentModelId: z.string().min(1).describe("id of the model this entry belongs to"),
     slug: slug.optional(),
     status: z.enum(["draft", "published"]).optional().describe("defaults to draft"),
-    data: z.record(z.string(), z.unknown()).optional().describe("field values keyed by field key")
+    data: z.record(z.string(), z.unknown()).optional().describe("field values keyed by field key"),
+    locale: z.string().nullable().optional().describe(PARAM_TEXT.locale),
+    translationOf: z.string().nullable().optional().describe(PARAM_TEXT.translationOf)
   });
   const getPageInput = z.object({
     pageId: z.string().min(1).describe("page id (from list_pages / create_page)")
@@ -3080,7 +3396,11 @@ function buildToolDefs(deps) {
   const listEntriesInput = z.object({
     modelId: z.string().optional().describe("filter by content model id"),
     pageId: z.string().optional().describe("filter by page id (a singleton page has one entry)"),
-    status: z.enum(["draft", "published"]).optional()
+    status: z.enum(["draft", "published"]).optional(),
+    where: z.record(z.string(), z.unknown()).optional().describe(PARAM_TEXT.where),
+    sort: z.string().max(100).optional().describe(PARAM_TEXT.sort),
+    page: z.number().int().min(1).optional().describe(PARAM_TEXT.page),
+    limit: z.number().int().min(1).max(200).optional().describe(ENTRY_LIST_LIMIT_NOTE)
   });
   const clearableText = (max) => z.string().max(max).nullable().optional();
   const headPatchShape = {
@@ -3101,7 +3421,13 @@ function buildToolDefs(deps) {
     data: z.record(z.string(), z.unknown()).optional().describe("field values keyed by field key"),
     status: z.enum(["draft", "published"]).optional(),
     slug: slug.optional(),
-    meta: entryMetaInput.optional().describe("the entry's native SEO; merges into what is stored")
+    meta: entryMetaInput.optional().describe("the entry's native SEO; merges into what is stored"),
+    merge: z.boolean().optional().describe(ENTRY_MERGE_NOTE),
+    ifMatch: z.number().int().min(0).optional().describe(ENTRY_IF_MATCH_NOTE),
+    scheduledAt: z.string().datetime().nullable().optional().describe(ENTRY_SCHEDULED_AT_NOTE),
+    unpublishAt: z.string().datetime().nullable().optional().describe(ENTRY_UNPUBLISH_AT_NOTE),
+    locale: z.string().nullable().optional().describe(PARAM_TEXT.locale),
+    translationOf: z.string().nullable().optional().describe(PARAM_TEXT.translationOf)
   });
   const deletePageInput = z.object({
     pageId: z.string().min(1).describe("id of the page to delete (from list_pages)")
@@ -3298,7 +3624,7 @@ function buildToolDefs(deps) {
     description: z.string().optional(),
     blockJson: z.array(blockObject).default([]).describe("the component's block tree"),
     props: z.array(componentPropObject).default([]).describe(
-      "overridable fields. Each one may carry `ui` to say how its control presents in the inspector \u2014 a collapsed group, what titles and thumbnails a table's rows, whether that table's rows can be dragged at all."
+      "overridable fields. DECLARE A PROP \u2014 WITH A `target` \u2014 for every string, link and image a marketer will ever touch: only the leaves a prop targets are click-to-edit. Each one may carry `ui` to say how its control presents in the inspector \u2014 a collapsed group, what titles and thumbnails a table's rows, whether that table's rows can be dragged at all."
     )
   });
   const updateComponentInput = z.object({
@@ -3347,14 +3673,6 @@ function buildToolDefs(deps) {
   const getComponentInput = z.object({
     componentId: z.string().min(1).describe("component id (from list_components)")
   });
-  const duplicateComponentInput = z.object({
-    componentId: z.string().min(1).describe("the look to copy (from list_components)"),
-    name: z.string().min(1).max(255).describe("the new look's name, unique in its family, e.g. 'Ghost'"),
-    preset: z.enum(["primary", "secondary", "outline", "ghost", "link"]).optional().describe("restyle the copy's button (see above); omit for a plain copy")
-  });
-  const createComponentsInput = z.object({
-    components: z.array(createComponentInput).min(1).max(50).describe("up to 50 components, each exactly the create_component input")
-  });
   const publishComponentsInput = z.object({
     componentIds: z.array(z.string().min(1)).min(1).max(100).describe("component ids (from list_components)")
   });
@@ -3379,83 +3697,6 @@ function buildToolDefs(deps) {
     slug: slug.describe("url-safe unique slug (lowercase letters/numbers/hyphens)"),
     projectId: z.string().min(1).optional().describe("only needed for a workspace-wide key")
   });
-  const sectionEvidenceProjectId = z.string().min(1).max(64).describe("exact project id from get_project (not a slug); Section evidence is project-local and never reusable across projects");
-  const sectionId = z.string().uuid().describe("Section definition id from Section Studio");
-  const sectionVersion = z.number().int().positive().describe("exact Section schema version implemented or tested");
-  const sha256 = z.string().regex(/^[0-9a-f]{64}$/i, "Expected a SHA-256 hex digest");
-  const sectionViewport = z.object({
-    name: z.string().trim().min(1).max(64),
-    width: z.number().int().min(240).max(7680),
-    height: z.number().int().min(240).max(7680)
-  });
-  const sectionEvidenceDigest = z.string().regex(/^(?:sha256:)?[0-9a-f]{64}$/i, "Expected a SHA-256 digest");
-  const nonEmptyDescriptor = z.record(z.string(), z.unknown()).refine((value) => Object.keys(value).length > 0, "Descriptor cannot be empty");
-  const sectionRequestId = z.string().uuid().describe("durable Section validation request id returned by list_section_validation_requests or the dashboard");
-  const sectionHttpUrl = z.string().url().max(2048).refine((value) => {
-    try {
-      const protocol = new URL(value).protocol;
-      return protocol === "http:" || protocol === "https:";
-    } catch {
-      return false;
-    }
-  }, "Expected an HTTP or HTTPS URL");
-  const sectionValidationViewport = sectionViewport.extend({
-    status: z.enum(["passed", "failed"]),
-    evidenceDigest: sectionEvidenceDigest
-  });
-  const submitSectionManifestInput = z.object({
-    projectId: sectionEvidenceProjectId,
-    requestId: sectionRequestId.optional().describe("include when fulfilling a claimed dashboard request so the evidence is bound to that exact run"),
-    sectionId,
-    version: sectionVersion,
-    apiId: z.string().regex(/^[a-z][A-Za-z0-9]*$/, "Use lower camelCase").max(100),
-    schemaHash: sha256.describe("exact SHA-256 hex hash shown for this Section version"),
-    commitSha: z.string().regex(/^[0-9a-f]{7,64}$/i).describe("git commit containing the implementation"),
-    loader: nonEmptyDescriptor.describe("non-empty serializable loader descriptor emitted by the repo build; never executable code"),
-    previewAdapter: nonEmptyDescriptor.describe("non-empty serializable adapter descriptor for the customer's real app shell; never executable code"),
-    nativeViewports: z.array(sectionViewport).max(20).optional().describe("the customer's named responsive viewports; BetterCMS also enforces Desktop 1440x900, Tablet 768x1024, and Mobile 390x844")
-  });
-  const submitSectionValidationInput = z.object({
-    projectId: sectionEvidenceProjectId.describe("exact project id from get_project (not a slug); must match the manifest's project"),
-    requestId: sectionRequestId.optional().describe("same claimed request id used for the manifest; binds and terminalizes that run"),
-    sectionId: sectionId.describe("exact Section definition id"),
-    version: sectionVersion,
-    manifestId: z.string().uuid().describe("manifest id returned by submit_section_manifest; it pins the schema hash and commit SHA"),
-    status: z.enum(["passed", "failed"]).describe("the actual result of the external repo/app-shell validation"),
-    fixtureHash: sha256.describe("SHA-256 hex hash of the canonical preview dataset and stress fixtures used"),
-    evidenceDigest: sectionEvidenceDigest.describe("SHA-256 digest of the immutable validation evidence bundle (screenshots/report/results)"),
-    appShell: z.object({
-      kind: z.literal("actual-app"),
-      identifier: z.string().trim().min(1).max(255),
-      url: sectionHttpUrl.optional()
-    }).describe("the real customer application shell used for the validation run"),
-    viewportResults: z.array(sectionValidationViewport).min(1).max(23).describe("one signed result for every required and native manifest viewport")
-  });
-  const listSectionValidationRequestsInput = z.object({
-    projectId: sectionEvidenceProjectId,
-    limit: z.number().int().min(1).max(100).optional()
-  });
-  const claimSectionValidationRequestInput = z.object({
-    projectId: sectionEvidenceProjectId,
-    requestId: sectionRequestId,
-    commitSha: z.string().regex(/^[0-9a-f]{7,64}$/i).describe("exact git commit the agent will inspect and validate; evidence must use this same commit"),
-    providerRunId: z.string().trim().min(1).max(255).optional(),
-    providerRunUrl: sectionHttpUrl.optional().describe("optional HTTP(S) link to the user's external agent run")
-  });
-  const completeSectionValidationRequestInput = z.object({
-    projectId: sectionEvidenceProjectId,
-    requestId: sectionRequestId,
-    manifestId: z.string().uuid().optional(),
-    validationRunId: z.string().uuid().optional()
-  });
-  const failSectionValidationRequestInput = z.object({
-    projectId: sectionEvidenceProjectId,
-    requestId: sectionRequestId,
-    errorCode: z.string().trim().regex(/^[A-Z][A-Z0-9_]*$/).max(100),
-    errorMessage: z.string().trim().min(1).max(2e3),
-    providerRunId: z.string().trim().min(1).max(255).optional(),
-    providerRunUrl: sectionHttpUrl.optional().describe("optional HTTP(S) link to the user's external agent run")
-  });
   function lifecycleTools() {
     const def = (name, title, description, shape, run) => ({
       name,
@@ -3508,14 +3749,16 @@ function buildToolDefs(deps) {
       def(
         "update_media",
         "Update a media asset",
-        "Describe an existing media asset: set its alt text, caption or transcript. A transcript (video/audio only, \u2264 100,000 chars) is stored ON the asset, so every page and entry using the file publishes it \u2014 hosted pages, the .md twin, llms-full.txt and the delivery API. Pass null to clear a field. Use this after your own speech-to-text; BetterCMS does not generate transcripts.",
+        "Describe an existing media asset: set its alt text, caption, transcript or focal point (focalX/focalY, the spot crops keep in frame; delivered images carry it with width, height and thumbHash). A transcript (video/audio only, \u2264 100,000 chars) is stored ON the asset, so every page and entry using the file publishes it \u2014 hosted pages, the .md twin, llms-full.txt and the delivery API. Pass null to clear a field. Use this after your own speech-to-text; BetterCMS does not generate transcripts.",
         z.object({
           assetId: z.string().min(1).describe("media asset id (from list_media / upload_asset)"),
           altText: z.string().max(500).nullable().optional().describe("alt text; null clears"),
           caption: z.string().max(1e3).nullable().optional().describe("caption; null clears"),
-          transcript: z.string().max(1e5).nullable().optional().describe("the spoken words; null clears. Video/audio only.")
+          transcript: z.string().max(1e5).nullable().optional().describe("the spoken words; null clears. Video/audio only."),
+          focalX: z.number().min(0).max(1).nullable().optional().describe(PARAM_TEXT.focalX),
+          focalY: z.number().min(0).max(1).nullable().optional().describe(PARAM_TEXT.focalY)
         }).shape,
-        async (c, a) => ok("Updated media asset.", await data(c, "PATCH", `/management/media/${encodeURIComponent(s(a.assetId))}`, { altText: a.altText, caption: a.caption, transcript: a.transcript }))
+        async (c, a) => ok("Updated media asset.", await data(c, "PATCH", `/management/media/${encodeURIComponent(s(a.assetId))}`, { altText: a.altText, caption: a.caption, transcript: a.transcript, focalX: a.focalX, focalY: a.focalY }))
       ),
       def(
         "list_media",
@@ -3563,7 +3806,7 @@ function buildToolDefs(deps) {
       def(
         "get_content_structure",
         "Get the Content sidebar structure",
-        `Returns { doc, version, summary }: \`doc\` is the raw document ({ schema: 1, folders: [{ id, parentId, name, icon, sort }], items: [{ kind: 'page'|'collection', id, folderId, sort, icon }] }), \`version\` is what set_content_structure needs, and \`summary\` is the resolved tree with page and collection TITLES (\`outline\` is a readable version), ids that no longer resolve (\`missing\`), and the pages and collections not in any folder yet. Call it before changing the structure, and read the resource ${STRUCTURE_PLAYBOOK_URI} (the structure standard) before you organise anything. ${STRUCTURE_NOTE}`,
+        `Returns { doc, version, summary }: \`doc\` is the raw document ({ schema: 1, folders: [{ id, parentId, name, icon, sort }], items: [{ kind: 'page'|'collection', id, folderId, sort, icon }] }), \`version\` is what set_content_structure needs, and \`summary\` is the resolved tree with page and collection TITLES (\`outline\` is a readable version), ids that no longer resolve (\`missing\`), and the pages and collections not in any folder yet. Call it before changing the structure, and read the resource ${STRUCTURE_PLAYBOOK_URI} (the structure standard) before you organise anything. Changing it needs Admin or Developer; a 403 SCHEMA_ACCESS_REQUIRED means neither: stop and tell the user, do not retry. ${STRUCTURE_FENCE}`,
         z.object({}).shape,
         async (c) => {
           const d = await data(c, "GET", `/management/content-structure`);
@@ -3624,7 +3867,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "rename_folder",
         "Rename a Content sidebar folder",
-        `Rename a Content sidebar folder. ${STRUCTURE_FENCE}`,
+        `Rename a Content sidebar folder. ${STRUCTURE_POINTER}`,
         z.object({
           folderId: z.string().min(1).describe("folder id (from get_content_structure)"),
           name: z.string().min(1).describe("the new label, 1-80 chars")
@@ -3634,7 +3877,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "move_to_folder",
         "Move into a Content sidebar folder",
-        `Move a page, a collection or a folder into a folder. folderId null moves it back to its home: Other pages for a page, the Shared list for a collection, the top level for a folder. It lands after what is already there. Moving a folder takes its contents with it and is refused if the result would nest deeper than 4 levels or put a folder inside itself. ${STRUCTURE_FENCE}`,
+        `Move a page, a collection or a folder into a folder. folderId null moves it back to its home: Other pages for a page, the Shared list for a collection, the top level for a folder. It lands after what is already there. Moving a folder takes its contents with it and is refused if the result would nest deeper than 4 levels or put a folder inside itself. ${STRUCTURE_POINTER}`,
         z.object({
           kind: z.enum(["page", "collection", "folder"]).describe(
             "what the id IS on this branch \u2014 VERIFIED, not assumed: an id is either a page or a collection, never both, and a mismatch is refused with 400 NAV_KIND_MISMATCH naming the kind to use. Call it again with that kind, which also clears the wrong-kind entry."
@@ -3647,7 +3890,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "set_brand_assets",
         "Point the brand's logo or favicon at a media asset",
-        `Point the brand's logo (mark) or favicon at a media asset of this project \u2014 upload it to this project's media library first if it is not there. A slot a PERSON chose is refused without replace: true, and the refusal says so. ${BRAND_KIT_NOTE}`,
+        `Point the brand's logo (mark) or favicon at a media asset of this project \u2014 upload it to this project's media library first if it is not there. A slot a PERSON chose is refused without replace: true, and the refusal says so. ${BRAND_KIT_POINTER}`,
         z.object({
           mark: z.string().min(1).nullable().optional().describe("media asset id for the logo; null clears it"),
           favicon: z.string().min(1).nullable().optional().describe("media asset id for the favicon; null clears it"),
@@ -3658,7 +3901,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "set_brand_graphics",
         "Add, replace or remove the brand's gradients",
-        `Add, replace or remove the brand's gradients \u2014 the blobs and washes a site uses as backgrounds. They are TOKENS, not media. A stop naming a colour the kit does not have is refused; add it to \`extras\` first. Upsert matches BY KEY. ${BRAND_KIT_NOTE}`,
+        `Add, replace or remove the brand's gradients \u2014 the blobs and washes a site uses as backgrounds. They are TOKENS, not media. A stop naming a colour the kit does not have is refused; add it to \`extras\` first. Upsert matches BY KEY. ${BRAND_KIT_POINTER}`,
         z.object({
           upsert: z.array(z.object({
             key: z.string().min(1).describe("token key: lowercase letters, digits and hyphens. Emitted as --brand-gradient-<key>"),
@@ -3677,7 +3920,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "set_icon",
         "Set a Content sidebar icon",
-        `Set or clear the sidebar icon of a page, a collection or a folder. ${STRUCTURE_FENCE}`,
+        `Set or clear the sidebar icon of a page, a collection or a folder. ${STRUCTURE_POINTER}`,
         z.object({
           kind: z.enum(["page", "collection", "folder"]).describe(
             "what the id IS on this branch \u2014 VERIFIED, not assumed: an id is either a page or a collection, never both, and a mismatch is refused with 400 NAV_KIND_MISMATCH naming the kind to use. Call it again with that kind, which also clears the wrong-kind entry."
@@ -3690,7 +3933,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "delete_folder",
         "Delete a folder (its contents move up; nothing is deleted)",
-        `Delete a folder (its contents move up; nothing is deleted). NOTHING ELSE IS DELETED: its pages, collections and sub-folders move up to the folder's parent, in the same order. ${STRUCTURE_FENCE}`,
+        `Delete a folder (its contents move up; nothing is deleted). NOTHING ELSE IS DELETED: its pages, collections and sub-folders move up to the folder's parent, in the same order. ${STRUCTURE_POINTER}`,
         z.object({ folderId: z.string().min(1).describe("folder id (from get_content_structure)") }).shape,
         async (c, a) => structureResult(await data(c, "DELETE", `/management/content-structure/folders/${encodeURIComponent(s(a.folderId))}`))
       ),
@@ -3725,16 +3968,16 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "get_seo",
         "Get site SEO",
-        "Get the connected project's site-wide SEO settings \u2014 default meta (title/description/ogImage), JSON-LD siteSchema, and robots/sitemap/rss config.",
+        GET_SEO_DESCRIPTION,
         z.object({}).shape,
         async (c) => ok("SEO settings.", await data(c, "GET", `/management/seo`))
       ),
       def(
         "update_seo",
         "Update site SEO",
-        "Set site-wide SEO defaults. `seoDefaults` { metaTitle, metaDescription, ogImage, twitterHandle } applies to every page unless overridden. Optionally robotsConfig / sitemapConfig / rssConfig. Each field is REPLACED whole. Rebuilds the site.",
-        z.object({ seoDefaults: z.record(z.string(), z.unknown()).optional(), siteSchema: z.record(z.string(), z.unknown()).optional(), robotsConfig: z.record(z.string(), z.unknown()).optional(), sitemapConfig: z.record(z.string(), z.unknown()).optional(), rssConfig: z.record(z.string(), z.unknown()).optional() }).shape,
-        async (c, a) => ok("Updated SEO.", await data(c, "PATCH", `/management/seo`, a))
+        UPDATE_SEO_DESCRIPTION,
+        seoPatchShape,
+        async (c, a) => ok("Updated SEO.", await data(c, "PATCH", `/management/seo`, Object.fromEntries(Object.keys(seoPatchShape).filter((k) => a[k] !== void 0).map((k) => [k, a[k]]))))
       ),
       def(
         "get_site_files",
@@ -3765,23 +4008,25 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "get_workflow_board",
         "List editorial workflow stages",
-        "List the connected project's editorial board columns in order \u2014 each stage's `key`, name, and whether it is the `publishGate` (the one stage content may go live from). Read this BEFORE move_entry_stage / move_page_stage: stage keys are per-project and not guessable, because a project can rename or replace every column.",
+        "List the connected project's editorial board columns in order \u2014 each stage's `key`, name, and whether it is the `publishGate` (the one stage content may go live from). Read this BEFORE move_stage: stage keys are per-project and not guessable, because a project can rename or replace every column.",
         z.object({}).shape,
         async (c) => ok("Workflow stages.", await data(c, "GET", `/management/workflow/stages`))
       ),
       def(
-        "move_entry_stage",
-        "Move a content entry across the board",
-        "Move a content entry to another editorial stage \u2014 this is how you get an entry OUT of review so it can be published. `workflowStage` is a stage key from get_workflow_board (null clears it). Optionally set `workflowAssigneeIds` / `workflowDueDate`, or pass `fromStage` to fail with 409 if someone moved it first. Moving into the publish-gate stage is an approval and needs a publish-enabled connection. Publish afterwards with update_content_entry status:'published' \u2014 approving and publishing are deliberately two separate calls.",
-        z.object({ entryId: z.string().min(1), workflowStage: z.string().max(64).describe("stage key from get_workflow_board"), fromStage: z.string().max(64).optional().describe("the stage you believe it is in \u2014 409s if it has moved") }).shape,
-        async (c, a) => ok("Moved entry.", await data(c, "PATCH", `/management/content/entries/${s(a.entryId)}/workflow`, { workflowStage: a.workflowStage, fromStage: a.fromStage }))
-      ),
-      def(
-        "move_page_stage",
-        "Move a page across the board",
-        "Move a page to another editorial stage \u2014 the page twin of move_entry_stage, and the only way to take a page out of review so update_page (status:'published') can go live. `workflowStage` is a stage key from get_workflow_board. Moving into the publish-gate stage is an approval and needs a publish-enabled connection.",
-        z.object({ pageId: z.string().min(1), workflowStage: z.string().max(64).describe("stage key from get_workflow_board"), fromStage: z.string().max(64).optional().describe("the stage you believe it is in \u2014 409s if it has moved") }).shape,
-        async (c, a) => ok("Moved page.", await data(c, "PATCH", `/management/pages/${s(a.pageId)}/workflow`, { workflowStage: a.workflowStage, fromStage: a.fromStage }))
+        "move_stage",
+        "Move an entry or a page across the board",
+        MOVE_STAGE_DESCRIPTION,
+        z.object({
+          entryId: z.string().min(1).optional().describe("the entry to move; or send pageId"),
+          pageId: z.string().min(1).optional().describe("instead of entryId: the page to move"),
+          workflowStage: z.string().max(64).describe("stage key from get_workflow_board"),
+          fromStage: z.string().max(64).optional().describe("the stage you believe it is in \u2014 409s if it has moved")
+        }).shape,
+        async (c, a) => {
+          if (!a.entryId === !a.pageId) return fail("Pass exactly one of entryId (a content entry) or pageId (a page).");
+          const path = a.pageId ? `/management/pages/${s(a.pageId)}/workflow` : `/management/content/entries/${s(a.entryId)}/workflow`;
+          return ok(a.pageId ? "Moved page." : "Moved entry.", await data(c, "PATCH", path, { workflowStage: a.workflowStage, fromStage: a.fromStage }));
+        }
       ),
       def(
         "promote_project",
@@ -3819,6 +4064,48 @@ ${d.outline}` : "Proposed Content structure.", d);
         z.object({}).shape,
         async (c) => ok("Projects.", await data(c, "GET", `/management/projects`))
       ),
+      {
+        name: "whoami",
+        config: { title: "Who this connection acts as", description: WHOAMI_DESCRIPTION, inputSchema: {} },
+        /**
+         * The stdio server holds a device-grant token and nothing that lists its grants, so it
+         * reports only what it can observe: whether GET /projects/current resolves a project with
+         * none named (a project-bound grant) or refuses with 400 (a workspace-wide one). The
+         * lifted `projectId`, when sent, is checked separately — it must not decide the scope.
+         */
+        handler: guard(async () => {
+          const requested = currentProject.getStore();
+          const current = (c) => data(c, "GET", `/management/projects/current`);
+          const bound = await currentProject.run(
+            void 0,
+            () => withClient(async (c) => {
+              try {
+                return { apiBaseUrl: c.url(""), project: await current(c) };
+              } catch (err) {
+                if (err instanceof BetterCMSError && err.status === 400) return { apiBaseUrl: c.url(""), project: null };
+                throw err;
+              }
+            })
+          );
+          const target = requested ? await withClient(current) : null;
+          const pick = (p) => p ? { id: p.id, name: p.name, slug: p.slug } : null;
+          const scope = bound.project ? "project" : "workspace";
+          return ok(
+            bound.project ? `Bound to project '${bound.project.slug}' through a device grant.` : "A workspace-wide device grant: pass projectId on every project tool.",
+            {
+              surface: "stdio",
+              principal: { kind: "device_grant" },
+              apiBaseUrl: bound.apiBaseUrl,
+              scope,
+              workspaceSlug: (bound.project ?? target)?.workspaceSlug ?? null,
+              project: pick(bound.project),
+              ...requested ? { requestedProject: pick(target) } : {},
+              grants: null,
+              note: "This server cannot see the connection's grants; a missing one is a 403 naming it on the call that needs it. The hosted connector's whoami lists them."
+            }
+          );
+        })
+      },
       def(
         "update_project",
         "Update the connected project",
@@ -3848,7 +4135,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "set_authoring_preference",
         "Set the site's authoring architecture",
-        "Record which authoring architecture this site uses \u2014 'components' (RECOMMENDED: reusable section components placed as blocks; editors add, reorder and swap sections without touching a schema \u2014 recommend it for every marketing, landing, agency or product site) or 'fields' (a typed field schema per page \u2014 only for a blog, catalogue or directory where many rows share one shape). ASK THE USER; do not pick for them. Called without `preference`, this tool asks them directly (or hands you the question to ask). deploy_project, deploy_from_upload and promote_project all refuse with 409 AUTHORING_DECISION_REQUIRED until it is set, carrying this project's real page counts to show the user. Unset, the release lane already acts as `components`; only `fields` stops it. On a site whose pages were DERIVED at import, answering 'components' redoes nothing: after set_authoring_preference, get_componentize_plan proposes one component per section (it reads the PUBLISHED pages \u2014 no deploy needed to reach it), you confirm it with the user, then componentize_sections places them with `props.bind` (dry run first \u2014 they land as drafts and the page keeps its fields, values and bindings, so click-to-edit and the coverage meter are unchanged), then publish_component each one, publish the pages, run `npx @bettercms-ai/convert --componentize` in the repo, and deploy. Asked once per project; re-callable if the user changes their mind.",
+        "Record which authoring architecture this site uses \u2014 'components' (RECOMMENDED: reusable section components placed as blocks; editors add, reorder and swap sections without touching a schema \u2014 recommend it for every marketing, landing, agency or product site) or 'fields' (a typed field schema per page \u2014 only for a blog, catalogue or directory where many rows share one shape). ASK THE USER; do not pick for them. Called without `preference`, this tool asks them directly (or hands you the question to ask). deploy_project and promote_project both refuse with 409 AUTHORING_DECISION_REQUIRED until it is set, carrying this project's real page counts to show the user. Unset, the release lane already acts as `components`; only `fields` stops it. On a site whose pages were DERIVED at import, answering 'components' redoes nothing: after set_authoring_preference, get_componentize_plan proposes one component per section (it reads the PUBLISHED pages \u2014 no deploy needed to reach it), you confirm it with the user, then componentize_sections places them with `props.bind` (dry run first \u2014 they land as drafts and the page keeps its fields, values and bindings, so click-to-edit and the coverage meter are unchanged), then publish_component each one, publish the pages, run `npx @bettercms-ai/convert --componentize` in the repo, and deploy. Asked once per project; re-callable if the user changes their mind.",
         // Optional in the schema for exactly the reason `framework` is above: a required arg is
         // rejected by the SDK before the handler runs, which would kill the elicitation below
         // and leave the model guessing. Optional here, answered by a human there. The backend
@@ -3892,7 +4179,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "submit_conversion_receipt",
         "Record what the conversion codemod could and could not do",
-        "Hand BetterCMS the codemod's own account of a run, so the meter can say WHY a path is undeclared. Submit the receipt `npx @bettercms-ai/convert --receipt out.json` wrote as `{ briefDigest, receipt }`, for the SAME `briefDigest` get_conversion_brief { complete: true } returned (its shape: see `receipt`). \u{1F534} A RECEIPT WITH PENDING PATHS IS A PROGRESS REPORT, NOT A FINISH LINE: the response answers `complete` (`sourceComplete` is the receipt's own verdict; `liveChecks` gives the last release's `structureUnstamped` route count and `reportSha`) and `pendingTotal`, and echoes the first 40 pending rows with their `fix` \u2014 `{ action, file, line, col?, snippet, why?, kind? }`, `action` one of `wrap-span`, `declare-attr`, `bind-expression`, `declare-richtext`, `bind-data`, `manual`; `snippet` and `why` say what to change there. On a `declare-richtext` with `kind: document`, bind the ONE element wrapping every block of the Body, never the paragraph holding its first. Apply every fix, rerun, resubmit: only `complete: true` ends a conversion \u2014 never report a site converted on less. It is a RECORD, not a release: nothing on the site changes; the meter reads it on the get_binding_report after the next deploy. A 404 `unknown-brief` means that digest was never issued here. \u{1F534} SUBMIT THE `--forms` RECEIPT TOO, AS A SECOND CALL: a `--forms` run's receipt has all-zero `paths` and a `forms` block; write it to its own file (`--receipt forms-receipt.json`) and submit it under the same `briefDigest` (stored beside the binding receipt, never counted in coverage), then publish every form its `forms.pending` names. \u{1F534} THE SITE'S DESIGN IS NOT YOURS TO CHANGE: run `npx @bettercms-ai/convert --verify-styles --base <commit before the conversion> --root .` and include its `styleEdits` in the receipt; one listing any changed class, className or style is refused with 409 `style-edits` naming every token \u2014 restore them. Requires artifact:write.",
+        "Hand BetterCMS the codemod's own account of a run, so the meter can say WHY a path is undeclared. Submit the receipt `npx @bettercms-ai/convert --receipt out.json` wrote as `{ briefDigest, receipt }`, for the SAME `briefDigest` get_conversion_brief { complete: true } returned (its shape: see `receipt`). \u{1F534} A RECEIPT WITH PENDING PATHS IS A PROGRESS REPORT, NOT A FINISH LINE: the response answers `complete` (`sourceComplete` is the receipt's own verdict; `liveChecks` gives the last release's `structureUnstamped` route count and `reportSha`) and `pendingTotal`, and echoes the first 40 pending rows with their `fix` \u2014 `{ action, file, line, col?, snippet, why?, kind? }`, `action` one of `wrap-span`, `declare-attr`, `bind-expression`, `declare-richtext`, `bind-data`, `manual`; `snippet` and `why` say what to change there. On a `declare-richtext` with `kind: document`, bind the ONE element wrapping every block of the Body, never the paragraph holding its first. Apply every fix, rerun, resubmit: only `complete: true` ends a conversion \u2014 never report a site converted on less. It is a RECORD, not a release: nothing on the site changes; the meter reads it on the get_binding_report after the next deploy. A 404 `unknown-brief` means that digest was never issued here. \u{1F534} The same run owes two more things (playbook \xA713 steps 2b and 3b): the `--forms` receipt, submitted as a SECOND call under the same `briefDigest`, and the `styleEdits` of `npx @bettercms-ai/convert --verify-styles` inside this receipt \u2014 one listing a changed class, className or style is refused with 409 `style-edits`. Requires artifact:write.",
         z.object({
           briefDigest: z.string().min(1).describe("The `briefDigest` get_conversion_brief { complete: true } returned. Must match the receipt's own."),
           receipt: z.record(z.string(), z.unknown()).describe("The receipt `npx @bettercms-ai/convert --receipt out.json` wrote, verbatim: `paths: { declared, rewritten, alreadyDeclared, pending[{ route, scope, path, kind, file, reason, message, fix }] }` plus `styleEdits`. `paths.declared` must equal rewritten + alreadyDeclared + pending.length; each pending `reason` is the converter's own (IN_EXPRESSION, AMBIGUOUS_LITERAL, REPEATER_FIXED_LENGTH, PARSE_ERROR, \u2026); a path with no row reads `not-declared`.")
@@ -3906,20 +4193,6 @@ ${d.outline}` : "Proposed Content structure.", d);
         z.object({ sourceProjectId: z.string().optional(), name: z.string().optional(), slug: z.string().optional() }).shape,
         async (c, a) => ok("Cloned project.", await data(c, "POST", `/management/projects/clone`, a))
       ),
-      def(
-        "create_template",
-        "Save a project/page as a template",
-        "Save a project (or one page) as a REUSABLE template \u2014 a frozen snapshot of its content models, pages, entries, components, and forms (secrets/domains/analytics excluded). Later seed a new project from it with create_project { templateId }. Set visibility 'public' to list it in the cross-workspace gallery. Returns the new template's id.",
-        z.object({ sourceProjectId: z.string().min(1), name: z.string().min(1), scope: z.string().optional(), sourcePageId: z.string().optional(), description: z.string().optional(), visibility: z.string().optional() }).shape,
-        async (c, a) => ok("Created template.", await data(c, "POST", `/management/templates`, a))
-      ),
-      def(
-        "list_templates",
-        "List saved templates",
-        "List your workspace's saved templates (id, name, scope, visibility). Use a template's id as create_project { templateId } to seed a new project from it.",
-        z.object({}).shape,
-        async (c) => ok("Templates.", await data(c, "GET", `/management/templates`))
-      ),
       // ── Content models (read/metadata; parity with remote /mcp) ──
       def(
         "list_content_models",
@@ -3931,7 +4204,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "get_content_model",
         "Get a content model",
-        "Get one content model by id INCLUDING its full field schema (keys, types, nested group/repeater children) AND each field's stored authoring props \u2014 `helpText`, `showIf`, `ui`. Read it before add_field so you know the existing keys, and AFTER declaring `ui`/`showIf`/`helpText` as the receipt that the declaration actually landed: a prop that is missing from this response was not stored, whatever the write returned.",
+        "Get one content model by id INCLUDING its full field schema (keys, types, nested group/repeater children) AND each field's stored authoring props \u2014 `helpText`, `showIf`, `ui`. Read it before add_field so you know the existing keys, and AFTER declaring `ui`/`showIf`/`helpText` as the receipt that the declaration actually landed: a prop that is missing from this response was not stored, whatever the write returned. Its `optimisticVersion` is the ifMatch for update_content_model.",
         z.object({ modelId: z.string().min(1) }).shape,
         async (c, a) => ok("Content model.", await data(c, "GET", `/management/content/models/${s(a.modelId)}`))
       ),
@@ -3953,21 +4226,34 @@ ${d.outline}` : "Proposed Content structure.", d);
           fieldLabel: z.record(z.string(), z.string().min(1).max(255)).optional().describe("path \u2192 label"),
           fieldHelpText: z.record(z.string(), z.string().max(500).nullable()).optional().describe("path \u2192 help text, null clears it"),
           override: z.boolean().optional().describe(OVERRIDE_NOTE),
-          ifMatch: z.number().int().min(0).optional().describe(MODEL_IF_MATCH_NOTE)
+          ifMatch: z.number().int().min(0).optional().describe(MODEL_IF_MATCH_NOTE),
+          removeFields: z.array(z.string().min(1)).min(1).max(100).optional().describe(FIELD_REMOVAL_NOTE),
+          allowFieldRemoval: z.boolean().optional().describe(ALLOW_FIELD_REMOVAL_NOTE)
         }).shape,
-        // `fields` is deliberately not sent: the PATCH replaces `fields` wholesale when present.
+        // `fields` is sent only by removeFields, rebuilt from the model just read: the PATCH
+        // replaces `fields` wholesale when present.
         async (c, a) => {
           if (Boolean(a.modelId) === Boolean(a.pageId)) return fail("Send exactly one of modelId or pageId.");
           const path = a.pageId ? `/management/pages/${s(a.pageId)}/model` : `/management/content/models/${s(a.modelId)}`;
           const body = Object.fromEntries(
             MODEL_UPDATE_KEYS.filter((k) => a[k] !== void 0).map((k) => [k, k === "fieldsets" ? dropProvenance(a[k]) : a[k]])
           );
+          let ifMatch = a.ifMatch;
+          const removal = fieldRemovalRequest(a);
+          if (removal.kind === "refuse") return fail(removal.error);
+          if (removal.kind === "remove") {
+            const plan = planFieldRemoval(await data(c, "GET", path), removal.keys, a.ifMatch);
+            if (!plan.ok) return fail(plan.error);
+            body.fields = plan.fields;
+            body.allowFieldRemoval = true;
+            ifMatch = plan.ifMatch;
+          }
           return ok(
             "Updated content model.",
             (await c.fetchJSON(c.url(path), {
               method: "PATCH",
               body: JSON.stringify(body),
-              ...a.ifMatch !== void 0 ? { headers: { "if-match": `W/"${a.ifMatch}"` } } : {}
+              ...ifMatch !== void 0 ? { headers: { "if-match": `W/"${ifMatch}"` } } : {}
             })).data
           );
         }
@@ -4002,14 +4288,15 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "update_page",
         "Edit a page",
-        "Edit a page: title, slug, SEO metaTitle/metaDescription, structured data (`schemaType`, `schema`), publish status (draft|published), and `blockJson` (its block composition \u2014 passing it REPLACES the whole array, so read get_page first). A `blockJson` that swaps a component block to another component comes back with `warnings` (COMPONENT_SWAP_DROPS_OVERRIDES) naming the overrides the new component does not render; they stay on the block, so swapping back restores them. It does NOT change the field SCHEMA \u2014 use add_page_field / set_page_content for that. Renaming the slug keeps content intact. Publishing copies the draft blocks live in the same call \u2014 and on a singleton it publishes the page's content entry too; if the entry's workflow stage refuses, the page still goes live and `warnings` carries ENTRY_STILL_DRAFT with the entry id and the reason. STRUCTURED DATA is native SEO, never a field: leave it out and the page gets Automatic JSON-LD from its content (WebSite on the home page, Blog/CollectionPage on a collection's list page, WebPage otherwise); `schemaType` picks an explicit schema.org type whose properties are filled from the content; `schema` is pasted JSON-LD and wins over both (null clears it). " + PAGE_HEAD_NOTE + " " + SECTION_DOCTRINE,
-        z.object({ ...headPatchShape, noindex: z.boolean().optional().describe("hide this page from search engines and site search"), pageId: z.string().min(1), title: z.string().optional(), slug: z.string().optional(), blockJson: z.array(blockObject).optional().describe("REPLACES the page's block composition"), metaTitle: z.string().optional(), metaDescription: z.string().optional(), schemaType: z.enum(["auto", "WebPage", "AboutPage", "ContactPage", "CollectionPage", "Blog", "BlogPosting", "Article", "Product", "FAQPage", "Event", "Organization", "LocalBusiness"]).optional().describe("structured data type; 'auto' (the default) derives it from the content"), schema: z.union([z.record(z.string(), z.unknown()), z.array(z.record(z.string(), z.unknown()))]).nullable().optional().describe("custom JSON-LD; wins over schemaType; null clears it"), status: z.enum(["draft", "published"]).optional() }).shape,
+        "Edit a page: title, slug, SEO metaTitle/metaDescription, structured data (`schemaType`, `schema`), publish status (draft|published), and `blockJson` (its block composition \u2014 passing it REPLACES the whole array, so read get_page first and send its `optimisticVersion` as `ifMatch`). A `blockJson` that swaps a component block to another component comes back with `warnings` (COMPONENT_SWAP_DROPS_OVERRIDES) naming the overrides the new component does not render; they stay on the block, so swapping back restores them. It does NOT change the field SCHEMA \u2014 use add_field (pageId) / set_page_content for that. Renaming the slug keeps content intact. Publishing copies the draft blocks live in the same call \u2014 and on a singleton it publishes the page's content entry too; if the entry's workflow stage refuses, the page still goes live and `warnings` carries ENTRY_STILL_DRAFT with the entry id and the reason. STRUCTURED DATA is native SEO, never a field: leave it out and the page gets Automatic JSON-LD from its content (WebSite on the home page, Blog/CollectionPage on a collection's list page, WebPage otherwise); `schemaType` picks an explicit schema.org type whose properties are filled from the content; `schema` is pasted JSON-LD and wins over both (null clears it). " + PAGE_HEAD_NOTE + " " + SECTION_DOCTRINE,
+        z.object({ ...headPatchShape, noindex: z.boolean().optional().describe("hide this page from search engines and site search"), pageId: z.string().min(1), title: z.string().optional(), slug: z.string().optional(), blockJson: z.array(blockObject).optional().describe("REPLACES the page's block composition"), metaTitle: z.string().optional(), metaDescription: z.string().optional(), schemaType: z.enum(["auto", "WebPage", "AboutPage", "ContactPage", "CollectionPage", "Blog", "BlogPosting", "Article", "Product", "FAQPage", "Event", "Organization", "LocalBusiness"]).optional().describe("structured data type; 'auto' (the default) derives it from the content"), schema: z.union([z.record(z.string(), z.unknown()), z.array(z.record(z.string(), z.unknown()))]).nullable().optional().describe("custom JSON-LD; wins over schemaType; null clears it"), status: z.enum(["draft", "published"]).optional(), scheduledAt: z.string().datetime().nullable().optional().describe(PARAM_TEXT.pageScheduledAt), unpublishAt: z.string().datetime().nullable().optional().describe(PARAM_TEXT.pageUnpublishAt), locale: z.string().nullable().optional().describe(PARAM_TEXT.locale), translationOf: z.string().nullable().optional().describe(PARAM_TEXT.translationOf), ifMatch: z.number().int().min(0).optional().describe(UPDATE_PAGE_IF_MATCH_NOTE) }).shape,
         async (c, a) => {
           const res = await c.fetchJSON(
             c.url(`/management/pages/${s(a.pageId)}/meta`),
             {
               method: "PATCH",
-              body: JSON.stringify({ title: a.title, slug: a.slug, blockJson: a.blockJson, metaTitle: a.metaTitle, metaDescription: a.metaDescription, schemaType: a.schemaType, schema: a.schema, status: a.status, noindex: a.noindex, canonical: a.canonical, og: a.og, twitter: a.twitter })
+              ...a.ifMatch !== void 0 ? { headers: { "If-Match": `W/"${a.ifMatch}"` } } : {},
+              body: JSON.stringify({ title: a.title, slug: a.slug, blockJson: a.blockJson, metaTitle: a.metaTitle, metaDescription: a.metaDescription, schemaType: a.schemaType, schema: a.schema, status: a.status, noindex: a.noindex, canonical: a.canonical, og: a.og, twitter: a.twitter, scheduledAt: a.scheduledAt, unpublishAt: a.unpublishAt, locale: a.locale, translationOf: a.translationOf })
             }
           );
           const note = res.redirectNote;
@@ -4031,24 +4318,24 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "deploy_project",
         "Deploy new source/build",
-        "Deploy new source/build for the connected project and make it live at its <handle>.bettercms.site. Pass a .tgz or .zip of the project as a base64 string in `data`: SOURCE (has package.json) is built server-side in an isolated sandbox; a prebuilt static site is served as-is. Returns the release id + sha \u2014 then poll get_deploy_status until it is live. IMPORTANT \u2014 you MUST exclude node_modules, .git and build output/caches (dist, build, .next, .astro, .cache) from the archive: the source is reinstalled and built server-side, and the ~100 MB upload ceiling is enforced in transit (a 413/502 with no server-side detail) \u2014 server-side stripping runs AFTER the upload and cannot rescue an over-limit body. For a LARGE archive (or a 413/502) use create_deploy_upload + deploy_from_upload, which uploads straight to storage with no size ceiling. Returns `canvas.lane` (the editor's live-preview lane: `bridge` / `draft-route` / `none`; playbook section 11) and `editorUrl`, the visual editor to hand the user. On a workspace-wide connection pass `projectId` (from list_projects) to say which site this ships to.",
-        z.object({ data: z.string().min(1).describe("base64 .tgz/.zip of the project"), mimeType: z.string().optional() }).shape,
-        async (c, a) => ok("Deploy queued.", await raw(c, `/management/projects/deploy`, s(a.data), a.mimeType))
+        "Deploy new source/build for the connected project and make it live at its <handle>.bettercms.site. Pass a .tgz or .zip of the project as a base64 string in `data`, or the `uploadKey` of an archive you PUT through create_deploy_upload (no size ceiling: use it for anything large, or after a 413/502). SOURCE (has package.json) is built server-side in an isolated sandbox; a prebuilt static site is served as-is. Returns the release id + sha \u2014 then poll get_deploy_status until it is live. IMPORTANT \u2014 you MUST exclude node_modules, .git and build output/caches (dist, build, .next, .astro, .cache) from the archive: the source is reinstalled and built server-side, and the ~100 MB upload ceiling is enforced in transit (a 413/502 with no server-side detail) \u2014 server-side stripping runs AFTER the upload and cannot rescue an over-limit body. Returns `canvas.lane` (the editor's live-preview lane: `bridge` / `draft-route` / `none`; playbook section 11) and `editorUrl`, the visual editor to hand the user. On a workspace-wide connection pass `projectId` (from list_projects) to say which site this ships to.",
+        z.object({
+          data: z.string().min(1).optional().describe("base64 .tgz/.zip of the project; or send uploadKey"),
+          uploadKey: z.string().min(1).optional().describe("instead of data: the uploadKey from create_deploy_upload, after PUTting the archive to its uploadUrl"),
+          mimeType: z.string().optional()
+        }).shape,
+        async (c, a) => {
+          if (!a.data === !a.uploadKey) return fail("Pass exactly one of data (the archive, base64) or uploadKey (from create_deploy_upload).");
+          return ok("Deploy queued.", a.uploadKey ? await data(c, "POST", `/management/projects/deploy/from-upload`, { uploadKey: a.uploadKey }) : await raw(c, `/management/projects/deploy`, s(a.data), a.mimeType));
+        }
       ),
       def(
         "create_deploy_upload",
         "Get a presigned deploy-upload URL",
-        'Get a presigned URL to upload a LARGE deploy archive directly to storage, bypassing the ~100 MB body limit deploy_project\'s inline `data` hits. Flow: (1) call this for `uploadUrl` + `uploadKey`; (2) PUT your .tgz/.zip to `uploadUrl` (e.g. `curl -X PUT --data-binary @archive.tgz "<uploadUrl>"`) \u2014 straight to storage, no size ceiling; (3) call deploy_from_upload with `uploadKey`. Still exclude node_modules/.git/build caches. URL expires in 10 minutes.',
+        'Get a presigned URL to upload a LARGE deploy archive directly to storage, bypassing the ~100 MB body limit deploy_project\'s inline `data` hits. Flow: (1) call this for `uploadUrl` + `uploadKey`; (2) PUT your .tgz/.zip to `uploadUrl` (e.g. `curl -X PUT --data-binary @archive.tgz "<uploadUrl>"`) \u2014 straight to storage, no size ceiling; (3) call deploy_project with `uploadKey`. Still exclude node_modules/.git/build caches. URL expires in 10 minutes.',
         z.object({}).shape,
         async (c) => ok("Upload URL.", await data(c, "POST", `/management/projects/deploy/upload-url`))
       ),
-      def(
-        "deploy_from_upload",
-        "Deploy from a staged upload",
-        "Deploy from an archive already uploaded via create_deploy_upload (step 3). Pass the `uploadKey` you received. Builds SOURCE server-side or serves a prebuilt site \u2014 then poll get_deploy_status until live.",
-        z.object({ uploadKey: z.string().min(1).describe("the uploadKey from create_deploy_upload, after PUTting the archive to its uploadUrl") }).shape,
-        async (c, a) => ok("Deploy queued.", await data(c, "POST", `/management/projects/deploy/from-upload`, { uploadKey: a.uploadKey }))
-      ),
       // ── Git (import a repository, read it, push commits back) ──
       // Same artifact:write authority as the deploy tools: on the build branch a push IS a
       // deploy. Every call runs server-side as the GitHub App installation, so the agent
@@ -4145,20 +4432,228 @@ ${res.warnings.join("\n")}` : summary, res.data);
         async (c, a) => ok("Pull requests.", await data(c, "GET", `/management/git/pulls${q({ state: a.state, limit: a.limit })}`))
       ),
       // ── Insight: what happened, what's working, what's broken ─────────────────
+      def(
+        "update_field",
+        "Change one field of a model or a page",
+        UPDATE_FIELD_DESCRIPTION,
+        z.object({
+          modelId: z.string().min(1).optional().describe("the content model (from list_content_models); or send pageId"),
+          pageId: z.string().min(1).optional().describe("instead of modelId: the page whose schema to edit"),
+          path: z.string().min(1).describe("the field's key, or dot-separated keys through its parents, e.g. 'hero.title'"),
+          label: z.string().min(1).optional(),
+          helpText: z.string().nullable().optional().describe("null clears it"),
+          required: z.boolean().optional(),
+          config: z.record(z.string(), z.unknown()).optional().describe("per-type validation/config keys, merged into the stored config; null deletes a key"),
+          showIf: z.record(z.string(), z.unknown()).nullable().optional().describe("same shape as on add_field; null clears it"),
+          ui: z.record(z.string(), z.unknown()).nullable().optional().describe("same vocabulary as on add_field; null clears it"),
+          placement: z.enum(["cover", "title", "excerpt", "body", "inline", "panel"]).nullable().optional(),
+          type: fieldType.optional().describe("a new type; needs allowRetype"),
+          key: fieldKey.optional().describe("a new key (flat namespace, unique in the schema)"),
+          allowRetype: z.boolean().optional().describe("confirm a type change, once the user has agreed"),
+          allowFieldRemoval: z.boolean().optional().describe("with a rename: discard the old key's stored values"),
+          ifMatch: z.number().int().min(0).optional().describe("the model's optimisticVersion; the version read when omitted")
+        }).shape,
+        // Read the model (a page's through its backingModel), patch ONE field with the helper the
+        // hosted catalogue uses, and PATCH the whole list at the version read.
+        async (c, a) => {
+          let modelId = a.modelId;
+          if (a.pageId) {
+            const page = await data(c, "GET", `/management/pages/${s(a.pageId)}`);
+            modelId = page?.backingModel?.id;
+            if (!modelId) return fail("This page has no backing content model; address its schema by modelId.");
+          }
+          if (!modelId) return fail("Pass modelId (a content model) or pageId (a page).");
+          const plan = planFieldEdit(await data(c, "GET", `/management/content/models/${s(modelId)}`), a, a.ifMatch);
+          if (!plan.ok) return fail(plan.error);
+          const path = a.pageId ? `/management/pages/${s(a.pageId)}/model` : `/management/content/models/${s(modelId)}`;
+          const updated = (await c.fetchJSON(c.url(path), {
+            method: "PATCH",
+            body: JSON.stringify({ fields: plan.fields, ...a.allowFieldRemoval === true ? { allowFieldRemoval: true } : {} }),
+            ...plan.ifMatch !== void 0 ? { headers: { "If-Match": `W/"${plan.ifMatch}"` } } : {}
+          })).data;
+          return ok(plan.renamed ? `Renamed '${plan.renamed.from}' to '${plan.renamed.to}'.` : `Updated field '${s(a.path)}'.`, updated);
+        }
+      ),
+      // ── Search, batch, localisation, automation, branches and AI images (2026-09-30) ──
+      // Descriptions from ./tool-text.ts, shared word for word with the hosted catalogue.
+      def(
+        "search_content",
+        "Search published content",
+        NEW_TOOL_TEXT.search_content,
+        z.object({
+          q: z.string().min(1).max(200).describe("the words to find, 1-200 chars"),
+          type: z.enum(["page", "entry"]).optional().describe("only pages, or only entries"),
+          limit: z.number().int().min(1).max(50).optional().describe("hits to return; 10 when omitted")
+        }).shape,
+        async (c, a) => ok("Search results.", await c.fetchJSON(c.url(`/management/search${q({ q: a.q, type: a.type, limit: a.limit })}`), { method: "GET" }))
+      ),
+      def(
+        "discard_draft",
+        "Discard unpublished edits",
+        NEW_TOOL_TEXT.discard_draft,
+        z.object({
+          entryId: z.string().min(1).optional().describe("the entry (from list_content_entries); or send pageId"),
+          pageId: z.string().min(1).optional().describe("instead of entryId: the page (from list_pages)"),
+          ifMatch: z.number().int().min(0).optional().describe("optimisticVersion from get_content_entry or get_page")
+        }).shape,
+        async (c, a) => {
+          if (!a.entryId === !a.pageId) return fail("Pass exactly one of entryId (an entry) or pageId (a page).");
+          const path = a.pageId ? `/management/pages/${s(a.pageId)}/discard-draft` : `/management/content/entries/${s(a.entryId)}/discard-draft`;
+          return ok("Draft discarded.", (await c.fetchJSON(c.url(path), {
+            method: "POST",
+            body: JSON.stringify({}),
+            ...a.ifMatch !== void 0 ? { headers: { "If-Match": `W/"${a.ifMatch}"` } } : {}
+          })).data);
+        }
+      ),
+      def(
+        "refresh_search_index",
+        "Refresh IndexNow or site search",
+        NEW_TOOL_TEXT.refresh_search_index,
+        z.object({
+          action: z.enum(["indexnow", "reindex"]).describe("'indexnow' pings search engines; 'reindex' rebuilds site search"),
+          urls: z.array(z.string().min(1)).min(1).max(1e3).optional().describe("indexnow only: this site's URLs; every change since the last submission when omitted")
+        }).shape,
+        async (c, a) => ok(a.action === "reindex" ? "Site search rebuilt." : "IndexNow submission.", a.action === "reindex" ? await data(c, "POST", `/management/search/reindex`, {}) : await data(c, "POST", `/management/seo/indexnow/submit`, { urls: a.urls }))
+      ),
+      def(
+        "give_feedback",
+        "Send feedback to the BetterCMS team",
+        NEW_TOOL_TEXT.give_feedback,
+        z.object({
+          kind: z.enum(["bug", "missing_capability", "unclear_docs", "other"]).describe("what went wrong"),
+          message: z.string().min(1).max(1e4).describe("what you tried, what happened and what you expected (1-10000 chars)"),
+          tool: z.string().max(100).optional().describe("the tool it is about, if any"),
+          context: z.string().max(4e3).optional().describe("the request and response, or other detail (up to 4000 chars)")
+        }).shape,
+        async (c, a) => ok("Feedback sent.", await data(c, "POST", `/management/feedback`, { kind: a.kind, message: a.message, tool: a.tool, context: a.context }))
+      ),
+      def(
+        "publish_entries",
+        "Publish or unpublish many entries and pages",
+        NEW_TOOL_TEXT.publish_entries,
+        z.object({
+          action: z.enum(["publish", "unpublish"]).describe("take the items live, or back to draft"),
+          entryIds: z.array(z.string().min(1)).max(100).optional().describe("entry ids (from list_content_entries)"),
+          pageIds: z.array(z.string().min(1)).max(100).optional().describe("page ids (from list_pages); publish only")
+        }).shape,
+        async (c, a) => ok(a.action === "publish" ? "Publish receipt." : "Unpublish receipt.", await data(c, "POST", `/management/publish`, { action: a.action, entryIds: a.entryIds, pageIds: a.pageIds }))
+      ),
+      def(
+        "create_content_entries",
+        "Create many draft entries",
+        NEW_TOOL_TEXT.create_content_entries,
+        z.object({
+          contentModelId: z.string().min(1).describe("the collection every entry belongs to (from list_content_models)"),
+          entries: z.array(z.object({ slug: z.string().optional(), data: z.record(z.string(), z.unknown()) })).min(1).max(200).describe("1-200 entries, each {slug?, data}")
+        }).shape,
+        // The whole body: the per-row receipt is `data`, the counts ride in `meta`.
+        async (c, a) => ok("Batch receipt.", await c.fetchJSON(c.url(`/management/content/entries/batch`), { method: "POST", body: JSON.stringify({ contentModelId: a.contentModelId, entries: a.entries }) }))
+      ),
+      def(
+        "translate_entry",
+        "Translate an entry into another locale",
+        NEW_TOOL_TEXT.translate_entry,
+        z.object({
+          entryId: z.string().min(1).describe("the SOURCE entry, never another translation"),
+          targetLocale: z.string().min(1).describe("BCP-47 locale from the project's locales, e.g. 'fr'"),
+          slug: z.string().optional().describe("the translation's slug; <source slug>-<locale> when omitted"),
+          fields: z.array(z.string().min(1)).optional().describe("translate only these field keys")
+        }).shape,
+        async (c, a) => ok("Translation created.", await c.fetchJSON(c.url(`/management/content/entries/${s(a.entryId)}/translate`), { method: "POST", body: JSON.stringify({ targetLocale: a.targetLocale, slug: a.slug, fields: a.fields }) }))
+      ),
+      def(
+        "list_webhooks",
+        "List webhooks",
+        NEW_TOOL_TEXT.list_webhooks,
+        z.object({}).shape,
+        async (c) => ok("Webhooks.", await data(c, "GET", `/management/webhooks`))
+      ),
+      def(
+        "create_webhook",
+        "Create a webhook",
+        NEW_TOOL_TEXT.create_webhook,
+        z.object({
+          name: z.string().min(1).max(255).describe("a label, 1-255 chars"),
+          url: z.string().url().describe("the https endpoint that receives the events"),
+          events: z.array(z.enum(WEBHOOK_EVENTS)).min(1).optional().describe("events to send; ['content.publish'] when omitted"),
+          isActive: z.boolean().optional().describe("default true"),
+          test: z.boolean().optional().describe("send a sample delivery now")
+        }).shape,
+        // The whole body: a `test` delivery's outcome rides beside `data`.
+        async (c, a) => ok("Webhook created. Store the `secret` now: it is never shown again.", await c.fetchJSON(c.url(`/management/webhooks`), { method: "POST", body: JSON.stringify({ name: a.name, url: a.url, events: a.events, isActive: a.isActive, test: a.test }) }))
+      ),
+      def(
+        "list_branches",
+        "List content branches",
+        NEW_TOOL_TEXT.list_branches,
+        z.object({}).shape,
+        async (c) => ok("Branches.", await c.fetchJSON(c.url(`/management/branches`), { method: "GET" }))
+      ),
+      def(
+        "create_branch",
+        "Create a content branch",
+        NEW_TOOL_TEXT.create_branch,
+        z.object({
+          name: z.string().min(1).max(80).describe("1-80 chars"),
+          slug: z.string().max(80).optional().describe("derived from the name when omitted")
+        }).shape,
+        async (c, a) => ok("Branch created.", await data(c, "POST", `/management/branches`, { name: a.name, slug: a.slug }))
+      ),
+      def(
+        "apply_branch",
+        "Merge a branch into its parent",
+        NEW_TOOL_TEXT.apply_branch,
+        z.object({
+          branchId: z.string().min(1).describe("the branch to merge (from list_branches)"),
+          dryRun: z.boolean().optional().describe("true = return the diff and write nothing"),
+          include: z.array(z.string().min(1)).max(500).optional().describe("change keys to merge (from the diff); all when omitted"),
+          fields: z.record(z.string(), z.record(z.string(), z.enum(["keep_branch", "keep_parent"]))).optional().describe("change key \u2192 field \u2192 'keep_branch' | 'keep_parent', for each conflict")
+        }).shape,
+        async (c, a) => a.dryRun === true ? ok("Branch diff (nothing was written).", await data(c, "GET", `/management/branches/${s(a.branchId)}/diff`)) : ok("Branch applied.", await c.fetchJSON(c.url(`/management/branches/${s(a.branchId)}/apply`), { method: "POST", body: JSON.stringify({ include: a.include, fields: a.fields }) }))
+      ),
+      def(
+        "search_docs",
+        "Search the BetterCMS docs",
+        NEW_TOOL_TEXT.search_docs,
+        z.object({
+          q: z.string().min(1).describe("the question or words to find"),
+          limit: z.number().int().min(1).max(20).optional().describe("pages to return; 5 when omitted")
+        }).shape,
+        async (c, a) => ok("Docs.", await c.fetchJSON(c.url(`/management/docs/search${q({ q: a.q, limit: a.limit })}`), { method: "GET" }))
+      ),
+      def(
+        "generate_image",
+        "Generate an image with AI",
+        NEW_TOOL_TEXT.generate_image,
+        z.object({
+          prompt: z.string().min(1).max(2e3).describe("what the image shows, 1-2000 chars"),
+          altText: z.string().optional().describe("alt text for the new asset"),
+          width: z.number().int().min(256).max(1440).multipleOf(16).optional(),
+          height: z.number().int().min(256).max(1440).multipleOf(16).optional(),
+          folderId: z.string().optional().describe("Media Library folder id")
+        }).shape,
+        async (c, a) => ok("Generated image.", await data(c, "POST", `/management/ai/image`, { prompt: a.prompt, altText: a.altText, width: a.width, height: a.height, folderId: a.folderId }))
+      ),
+      def(
+        "transform_image",
+        "Edit an image with AI",
+        NEW_TOOL_TEXT.transform_image,
+        z.object({
+          mediaId: z.string().min(1).describe("the image to edit (from list_media)"),
+          prompt: z.string().min(1).max(2e3).describe("the change to make, 1-2000 chars"),
+          altText: z.string().optional().describe("alt text for the new asset"),
+          folderId: z.string().optional().describe("Media Library folder id")
+        }).shape,
+        async (c, a) => ok("Edited image (a new asset).", await data(c, "POST", `/management/ai/image/transform`, { mediaId: a.mediaId, prompt: a.prompt, altText: a.altText, folderId: a.folderId }))
+      ),
       def(
         "list_activity",
         "List project activity",
-        "Recent activity in the connected project \u2014 who changed what, and when. Filter by `category` (comma-separated: content, pages, media, forms, deployment, settings, members), `actorId`, or a `since`/`until` ISO window.",
+        "Recent activity in the connected project \u2014 who changed what, and when. Filter by `category` (comma-separated: content, pages, media, forms, deployment, settings, members), `actorId`, or a `since`/`until` ISO window. At the start of a turn, pass `since` (your last look) to notice dashboard or agent edits made since.",
         z.object({ category: z.string().optional(), actorId: z.string().optional(), since: z.string().optional(), until: z.string().optional(), limit: z.number().optional() }).shape,
         async (c, a) => ok("Project activity.", await data(c, "GET", `/management/insights/activity${q({ category: a.category, actorId: a.actorId, since: a.since, until: a.until, limit: a.limit })}`))
       ),
-      def(
-        "get_changes",
-        "Get changes since a timestamp",
-        "Read the durable project change feed since an ISO timestamp. Call this at the start of a new turn to notice dashboard or agent edits made since your previous observation.",
-        z.object({ since: z.string().datetime(), limit: z.number().int().min(1).max(100).optional() }).shape,
-        async (c, a) => ok("Project changes.", await data(c, "GET", `/management/insights/activity${q({ since: a.since, limit: a.limit ?? 100 })}`))
-      ),
       def(
         "get_next_steps",
         "Get what to do next",
@@ -4170,14 +4665,14 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "get_binding_report",
         "Check what on the live site is editable",
-        "The receipt for 'is this site actually EDITABLE?'. Each release scans the built HTML for the element rendering each CMS field value; per slot this returns `mode` ('text-match' = guessed from rendered text, 'declared' = template-declared), what was bound, and `unmatched`: each path with its reason \u2014 not-declared, ambiguous-text, no-element, declared-only, needs-wrap, refused, layout-owned, page-owned, layout-locator-stale, locale-unvarianted, svg-unavailable, partial and unstamped (a page list the content apply left as built: `kind` `list <bound>/<total>`), mismatch (a text-match stamp whose element shows MORE than the value, or no longer the text it was matched on (`data-bcms-from`): never written), report-outdated. DEPLOY FIRST: before any release there is no report (pages 0, mode null, refreshRequired true). `refreshReason`: `never-generated` \u2014 only a release BetterCMS builds and serves writes a report, so a HEADLESS site never gets one, redeploy or not; `outdated` \u2014 the next release rewrites it. It certifies only that every non-empty field has SOME element carrying its path. `unaddressable` is the copy it cannot see: visible live text no field owns, by route and bucket, biggest first (null = unmeasured: diff visible text against entry values). Over `count / visible > 0.02`, fix it in the SOURCE (wrap the run in an element the codemod can bind, or declare `<BcmsField path=\u2026>`), deploy, re-read \u2014 playbook \xA711. `builtRoutes`: routes the live build has HTML for (null = cannot say). `layoutIncomplete`: Layout paths the last content apply could not write (their publish waits); `layoutUnread`: Layout fields no route reads (`layoutUnreadJudged` false = not judged). `canvas.lane`: the editor's live-preview lane (`bridge`, `draft-route`; `none` \u2192 get_next_steps). `coverage.error` `nothing-bound`: no element of this build is bound, so its percentage describes another site.",
-        z.object({ slot: z.enum(["current", "staging"]).optional().describe("which release tree to read \u2014 everything here, `unaddressable` included, is measured PER SLOT, so on a promote-gated project pass 'current' to read the tree the editor frames. Defaults to the slot this project's releases land in. The response's `sha` is the build the report describes; `refreshRequired` is true when that is not the build this slot serves.") }).shape,
+        "The receipt for 'is this site actually EDITABLE?'. Each release scans the built HTML for the element rendering each CMS field value; per slot this returns `mode` ('text-match' = guessed from rendered text, 'declared' = template-declared), what was bound, and `unmatched`: each path with its reason \u2014 not-declared, ambiguous-text, no-element, declared-only, needs-wrap, refused, layout-owned, page-owned, layout-locator-stale, locale-unvarianted, svg-unavailable, partial and unstamped (a page list the content apply left as built: `kind` `list <bound>/<total>`), mismatch (a text-match stamp whose element shows MORE than the value, or no longer the text it was matched on (`data-bcms-from`): never written), report-outdated. DEPLOY FIRST: before any release there is no report (pages 0, mode null, refreshRequired true). `refreshReason`: `never-generated` \u2014 only a release BetterCMS builds and serves writes a report, so a HEADLESS site never gets one, redeploy or not; `outdated` \u2014 the next release rewrites it. It certifies only that every non-empty field has SOME element carrying its path. `unaddressable` is the copy it cannot see: visible live text no field owns, by route and bucket, biggest first (null = unmeasured: diff visible text against entry values). Over `count / visible > 0.02`, fix it in the SOURCE (wrap the run in an element the codemod can bind, or declare `<BcmsField path=\u2026>`), deploy, re-read \u2014 playbook \xA711. `canvas.lane`: the editor's live-preview lane (`bridge`, `draft-route`; `none` \u2192 get_next_steps). `coverage.error` `nothing-bound`: no element of this build is bound, so its percentage describes another site.",
+        z.object({ slot: z.enum(["current", "staging"]).optional().describe("which release tree to read \u2014 everything here, `unaddressable` included, is measured PER SLOT, so on a promote-gated project pass 'current' to read the tree the editor frames. Defaults to the slot this project's releases land in. The response's `sha` is the build the report describes; `refreshRequired` is true when that is not the build this slot serves. Also per slot: `builtRoutes`: routes the live build has HTML for (null = cannot say). `layoutIncomplete`: Layout paths the last content apply could not write (their publish waits); `layoutUnread`: Layout fields no route reads (`layoutUnreadJudged` false = not judged).") }).shape,
         async (c, a) => ok("Binding report.", await data(c, "GET", `/management/projects/current/binding-report${q({ slot: a.slot })}`))
       ),
       def(
         "get_conversion_brief",
         "Get the brief for making this site's bindings durable",
-        "The per-project brief for making this site's bindings DURABLE \u2014 read it before you touch the templates. Returns what already exists in the CMS: every live page with its route, every bindable field path with its `label`, `kind`, the CMS value (`current`) and the copy the repo renders today (`original`), the exact attributes to declare, and the ordered steps. Call it for any site whose pages were DERIVED at import, and whenever get_next_steps reports `bindings-not-declared`. It REPLACES re-registering a schema: these pages, fields and values exist already, so create_page / add_page_field / create_content_model would build a second schema over the first \u2014 edit values with set_page_content instead. `lane`: 'git-connected' = pull_project_source returns a repo; 'archive' = a tarball. Full recipe: section 13 of bettercms://playbook/schema; get_binding_report is the receipt that says you finished. Pass `complete: true` before running the CODEMOD (`npx @bettercms-ai/convert`): the brief UNCAPPED and paged, its full path list pinned under a `briefDigest` \u2014 what the coverage meter measures the build against. The complete brief also carries `forms` (id, status, fields, submitUrl), which `npx @bettercms-ai/convert --forms --brief brief.json --root . --receipt forms-receipt.json` wires into the repository's own <form> elements after the binding pass; read its `forms.pending` and publish every form its `forms.notes` names in the Forms tab (a draft form rejects every submission with a 403).",
+        "The per-project brief for making this site's bindings DURABLE \u2014 read it before you touch the templates. Returns what already exists in the CMS: every live page with its route, every bindable field path with its `label`, `kind`, the CMS value (`current`) and the copy the repo renders today (`original`), the exact attributes to declare, and the ordered steps. Call it for any site whose pages were DERIVED at import, and whenever get_next_steps reports `bindings-not-declared`. It REPLACES re-registering a schema: these pages, fields and values exist already, so create_page / add_field / create_content_model would build a second schema over the first \u2014 edit values with set_page_content instead. `lane`: 'git-connected' = pull_project_source returns a repo; 'archive' = a tarball. Full recipe: section 13 of bettercms://playbook/schema; get_binding_report is the receipt that says you finished. Pass `complete: true` before running the CODEMOD (`npx @bettercms-ai/convert`): the brief UNCAPPED and paged, its full path list pinned under a `briefDigest` \u2014 what the coverage meter measures the build against. The complete brief also carries `forms` (id, status, fields, submitUrl), which `npx @bettercms-ai/convert --forms --brief brief.json --root . --receipt forms-receipt.json` wires into the repository's own <form> elements after the binding pass; read its `forms.pending` and publish every form its `forms.notes` names in the Forms tab (a draft form rejects every submission with a 403).",
         z.object({
           complete: z.boolean().optional().describe("true = the COMPLETE brief for a codemod: nothing truncated, no page omitted, paged 50 pages at a time. Page 1 pins the path list the coverage meter measures against."),
           cursor: z.string().optional().describe("The `cursor` from the previous page. Implies complete. A 409 BRIEF_CHANGED means the brief was re-derived mid-pagination \u2014 start again with no cursor.")
@@ -4201,9 +4696,9 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "get_componentize_plan",
         "Get the plan for turning this site's sections into components",
-        "What this site's SECTIONS would become as components \u2014 a proposal that creates nothing and is computed live. For a site whose pages were DERIVED at import, each top-level field GROUP is one section: `hero-*` and `faq-*` keys, and the repeaters the import folded (`group-*`). Per page: each section's `groupKey`, `sectionType` family, leaf `fields` with their CMS values, `shapeHash`, and either the component already rendering it (`reuse.componentId`) or the proposed one (`reuse.proposedSlug`). Under `components`, a NEW one carries the exact `props` and `blockJson` create_component would take; an EXISTING one only `componentId`, `slug` and `name` (nothing is written for it). Every page gets its OWN components; a locale copy (`/fr`) reuses its default-locale page's. A COLLECTION TEMPLATE (dynamic page, `pattern: \"{slug}\"`) is planned ONCE, every prop reading the rendered entry: only its prose body and object-row lists are bands; frontmatter (author, images, tags, dates) stays entry fields. `pending` says why a group is not offered: `NO_GROUP_ROOT` (keys are still derive-lane names like `h1-welcome` \u2014 rename them into families first), `NOT_A_SECTION` (a lone scalar or the page's own metadata; `detail: ENTRY_METADATA` = collection-template frontmatter, `detail: DECLINED` = declined with componentize_sections `decline`), `IMAGE_AS_TEXT` (a text field holding an image path \u2014 make it an image field), `ALREADY_COMPONENTIZED`, `EMPTY_GROUP`, `NESTED_REPEATER` (three deep; two levels become a nested `table` sub-field), `PAGE_NOT_EMPTY` (blocks this lane does not own and will not overwrite). Chrome (`nav`/`footer`/`modal`: LAYOUT_CHROME, or in the Layout) is NEVER a section: edit it through the Layout. READ `summary: true` FIRST \u2014 the full plan runs to hundreds of KB; `paged` pages it (409 PLAN_CHANGED = start again); the unpaged full read is what `--plan plan.json` takes. Keep the `digest` \u2014 componentize_sections refuses any other.",
+        "What this site's SECTIONS would become as components \u2014 a proposal that creates nothing and is computed live. For a site whose pages were DERIVED at import, each top-level field GROUP is one section: `hero-*` and `faq-*` keys, and the repeaters the import folded (`group-*`). Per page: each section's `groupKey`, `sectionType` family, leaf `fields` with their CMS values, `shapeHash`, and either the component already rendering it (`reuse.componentId`) or the proposed one (`reuse.proposedSlug`). Under `components`, a NEW one carries the exact `props` and `blockJson` create_component would take; an EXISTING one only `componentId`, `slug` and `name` (nothing is written for it). Every page gets its OWN components; a locale copy (`/fr`) reuses its default-locale page's. A COLLECTION TEMPLATE (dynamic page, `pattern: \"{slug}\"`) is planned ONCE, every prop reading the rendered entry: only its prose body and object-row lists are bands; frontmatter (author, images, tags, dates) stays entry fields. `pending` says why a group is not offered (its codes: see `summary`). Chrome (`nav`/`footer`/`modal`: LAYOUT_CHROME, or in the Layout) is NEVER a section: edit it through the Layout. READ `summary: true` FIRST \u2014 the full plan runs to hundreds of KB; `paged` pages it (409 PLAN_CHANGED = start again); the unpaged full read is what `--plan plan.json` takes. Keep the `digest` \u2014 componentize_sections refuses any other.",
         z.object({
-          summary: z.boolean().optional().describe("true = no values: each section's groupKey, family, pending and component slug. Read this first."),
+          summary: z.boolean().optional().describe("true = no values: each section's groupKey, family, pending and component slug. Read this first. `pending` codes: `NO_GROUP_ROOT` (keys are still derive-lane names like `h1-welcome` \u2014 rename them into families first), `NOT_A_SECTION` (a lone scalar or the page's own metadata; `detail: ENTRY_METADATA` = collection-template frontmatter, `detail: DECLINED` = declined with componentize_sections `decline`), `IMAGE_AS_TEXT` (a text field holding an image path \u2014 make it an image field), `ALREADY_COMPONENTIZED`, `EMPTY_GROUP`, `NESTED_REPEATER` (three deep; two levels become a nested `table` sub-field), `PAGE_NOT_EMPTY` (blocks this lane does not own and will not overwrite)."),
           paged: z.boolean().optional().describe("true = 10 pages at a time; the response carries `page`, `pageCount` and a `cursor` for the next."),
           cursor: z.string().optional().describe("The `cursor` from the previous page. Implies paged. A 409 `PLAN_CHANGED` means start again with no cursor.")
         }).shape,
@@ -4437,102 +4932,6 @@ ${res.warnings.join("\n")}` : summary, res.data);
         z.object({ jobId: z.string().min(1) }).shape,
         async (c, a) => ok("Job rejected.", await data(c, "POST", `/management/bulk/jobs/${s(a.jobId)}/reject`))
       ),
-      def(
-        "list_section_validation_requests",
-        "List queued Section validation requests",
-        "Poll for user-agent Section implementation-validation requests in this exact project. BetterCMS cannot push work into an ordinary MCP client: call this explicitly, claim one request, inspect and run the customer's real repository/app shell, then submit request-bound evidence and complete it. Returns only unclaimed user-agent requests; it never exposes another project.",
-        listSectionValidationRequestsInput.shape,
-        async (c, a) => ok("Queued user-agent Section validation requests.", await data(
-          c,
-          "GET",
-          `/projects/${s(a.projectId)}/section-evidence/implementation-requests${q({ limit: a.limit })}`
-        ))
-      ),
-      def(
-        "claim_section_validation_request",
-        "Claim a Section validation request",
-        "Atomically claim one queued user-agent request and pin the exact git commit you will inspect. Claim BEFORE submitting evidence. BetterCMS records coordination only; all customer code and responsive checks must run in the user's repository and real app shell.",
-        claimSectionValidationRequestInput.shape,
-        async (c, a) => ok("Section validation request claimed.", await data(
-          c,
-          "POST",
-          `/projects/${s(a.projectId)}/section-evidence/implementation-requests/${s(a.requestId)}/claim`,
-          {
-            commitSha: a.commitSha,
-            providerRunId: a.providerRunId,
-            providerRunUrl: a.providerRunUrl
-          }
-        ))
-      ),
-      def(
-        "complete_section_validation_request",
-        "Complete a Section validation request",
-        "Complete a claimed request only after submit_section_manifest and submit_section_validation have bound exact, passed evidence to the same requestId and pinned commit. This cannot grant the separate human Visual Approval.",
-        completeSectionValidationRequestInput.shape,
-        async (c, a) => ok("Section validation request completed.", await data(
-          c,
-          "POST",
-          `/projects/${s(a.projectId)}/section-evidence/implementation-requests/${s(a.requestId)}/complete`,
-          { manifestId: a.manifestId, validationRunId: a.validationRunId }
-        ))
-      ),
-      def(
-        "fail_section_validation_request",
-        "Fail a Section validation request",
-        "Truthfully close a claimed request when the renderer, validation command, app shell, or required evidence is missing or fails. This path intentionally works without a manifest so 'not implemented' is representable instead of being reported as passed or left queued forever.",
-        failSectionValidationRequestInput.shape,
-        async (c, a) => ok("Section validation request failed.", await data(
-          c,
-          "POST",
-          `/projects/${s(a.projectId)}/section-evidence/implementation-requests/${s(a.requestId)}/fail`,
-          {
-            errorCode: a.errorCode,
-            errorMessage: a.errorMessage,
-            providerRunId: a.providerRunId,
-            providerRunUrl: a.providerRunUrl
-          }
-        ))
-      ),
-      def(
-        "submit_section_manifest",
-        "Submit a Section implementation manifest",
-        "Record the implementation manifest produced for one exact Section schema version by CI or an agent running INSIDE the user's repository. BetterCMS does not execute customer code: inspect/build the real renderer in the user's app shell first, then submit its exact API ID, schema hash, commit SHA, loader, preview adapter, and native responsive viewports. Requires a project-scoped artifact:write credential. This records evidence only; it does not validate the implementation and cannot create human Visual Approval.",
-        submitSectionManifestInput.shape,
-        async (c, a) => ok("Section implementation manifest recorded.", await data(
-          c,
-          "POST",
-          `/projects/${s(a.projectId)}/section-evidence/sections/${s(a.sectionId)}/versions/${a.version}/manifests`,
-          {
-            requestId: a.requestId,
-            apiId: a.apiId,
-            schemaHash: a.schemaHash,
-            commitSha: a.commitSha,
-            loader: a.loader,
-            previewAdapter: a.previewAdapter,
-            nativeViewports: a.nativeViewports
-          }
-        ))
-      ),
-      def(
-        "submit_section_validation",
-        "Submit a Section validation result",
-        "Record a real validation result for one exact Section schema version and manifest. Run the component in the user's repository and real app shell across the canonical preview dataset, AI stress fixtures, and required/native viewports BEFORE calling this tool; BetterCMS never runs that customer code. Pass status 'passed' only when those checks actually passed, otherwise 'failed'. The manifest pins schemaHash and commitSha; fixtureHash and evidenceDigest pin the tested data and immutable evidence bundle. Requires project-scoped artifact:write and cannot create the separate human Visual Approval required for publication.",
-        submitSectionValidationInput.shape,
-        async (c, a) => ok("Section validation result recorded.", await data(
-          c,
-          "POST",
-          `/projects/${s(a.projectId)}/section-evidence/sections/${s(a.sectionId)}/versions/${a.version}/validations`,
-          {
-            requestId: a.requestId,
-            manifestId: a.manifestId,
-            status: a.status,
-            fixtureHash: a.fixtureHash,
-            evidenceDigest: a.evidenceDigest,
-            appShell: a.appShell,
-            viewportResults: a.viewportResults
-          }
-        ))
-      ),
       def(
         "get_deploy_status",
         "Get deploy/build status",
@@ -4582,7 +4981,7 @@ ${res.warnings.join("\n")}` : summary, res.data);
       name: "list_pages",
       config: {
         title: "List pages in the current project",
-        description: "List the pages in the project this MCP key is bound to, each with its full field SCHEMA, pageType (singleton|dynamic), and status. Use it to verify WHERE content lands and to read field keys/types before set_page_content / add_page_field.",
+        description: "List the pages in the project this MCP key is bound to, each with its full field SCHEMA, pageType (singleton|dynamic), and status. Use it to verify WHERE content lands and to read field keys/types before set_page_content / add_field.",
         inputSchema: {}
       },
       handler: guard(
@@ -4606,7 +5005,7 @@ ${res.warnings.join("\n")}` : summary, res.data);
       name: "get_page",
       config: {
         title: "Get a page (with its field schema)",
-        description: "Get one page by id INCLUDING its full field schema (keys, types, nested group/repeater children) and pageType. Read this before set_page_content so you write correctly-keyed values, or before add_page_field so you know the existing keys.",
+        description: "Get one page by id INCLUDING its full field schema (keys, types, nested group/repeater children) and pageType. Read this before set_page_content so you write correctly-keyed values, or before add_field so you know the existing keys.",
         inputSchema: getPageInput.shape
       },
       handler: guard(
@@ -4640,7 +5039,9 @@ ${res.warnings.join("\n")}` : summary, res.data);
             ...args.fields ? { fields: args.fields.map(toField) } : {},
             ...args.data !== void 0 ? { data: args.data } : {},
             ...args.metaTitle !== void 0 ? { metaTitle: args.metaTitle } : {},
-            ...args.metaDescription !== void 0 ? { metaDescription: args.metaDescription } : {}
+            ...args.metaDescription !== void 0 ? { metaDescription: args.metaDescription } : {},
+            ...args.locale !== void 0 ? { locale: args.locale } : {},
+            ...args.translationOf !== void 0 ? { translationOf: args.translationOf } : {}
           });
           const { warnings, seedErrors, ...created } = page;
           const summary = `Created ${created.pageType ?? "page"} page '${created.title}' (id ${created.id}, slug ${created.slug}) with ${created.fields.length} field(s).`;
@@ -4683,13 +5084,24 @@ ${notes.join("\n")}` : summary, created);
     {
       name: "add_field",
       config: {
-        title: "Add a field to a content model",
-        description: "Append a field to an existing content model. Reads the model's current fields and adds yours (read-modify-write) \u2014 never removes existing fields. For a section/zone, add ONE 'group' (fixed block) or 'repeater' (repeating list) field carrying its child `fields` \u2014 don't add the zone's inner fields as separate top-level fields. `fieldsetId` puts it in one of the model's fieldsets (set them with update_content_model). " + RICH_TEXT_NOTE,
+        title: "Add a field to a content model or a page",
+        description: ADD_FIELD_DESCRIPTION + " " + RICH_TEXT_NOTE,
         inputSchema: addFieldInput.shape
       },
       handler: guard(
         async (args) => withClient(async (client) => {
-          const model = await client.getModel(args.modelId);
+          if (!args.modelId === !args.pageId) return fail("Pass exactly one of modelId (a content model) or pageId (a page).");
+          if (args.pageId) {
+            const page = await client.addPageFields(args.pageId, {
+              // Cast: the SDK types `options` as string[], narrower than the API, which also takes
+              // {label, value} (backend selectFieldSchema).
+              addFields: [toField(args)],
+              ...args.after !== void 0 ? { after: args.after } : {}
+            });
+            return ok(`Added field '${args.key}' to page '${page.title}'. Page now has ${page.fields.length} field(s).`, page);
+          }
+          const modelId = args.modelId;
+          const model = await client.getModel(modelId);
           const dupes = duplicateKeys([...flatFieldKeys(model.fields), args.key]);
           if (dupes.length > 0) return fail(duplicateKeyFailure(dupes));
           const existingFields = model.fields;
@@ -4707,9 +5119,8 @@ ${notes.join("\n")}` : summary, created);
           }
           const nextFields = [...existingFields];
           nextFields.splice(at, 0, toField(args));
-          const updated = await client.updateModel(args.modelId, {
-            fields: nextFields
-          });
+          const input = { fields: nextFields };
+          const updated = model.optimisticVersion !== void 0 ? await client.updateModel(modelId, input, { ifMatch: model.optimisticVersion }) : await client.updateModel(modelId, input);
           return ok(
             `Added field '${args.key}' to '${updated.name}'${args.after ? ` after '${args.after}'` : ""}. Model now has ${updated.fields.length} field(s).`,
             updated
@@ -4717,33 +5128,11 @@ ${notes.join("\n")}` : summary, created);
         })
       )
     },
-    {
-      name: "add_page_field",
-      config: {
-        title: "Add a field to a page",
-        description: "Append a field to an existing page's schema (Home, About, a blog template, etc.). Additive \u2014 the API rejects a key that already exists and never overwrites or retypes existing fields. Use this when the target is a page (singleton or dynamic); use add_field when the target is a content model. For a section/zone, add ONE 'group' (fixed block) or 'repeater' (repeating list) field carrying its child `fields` \u2014 don't add the zone's inner fields as separate top-level fields. A 'group' is stored as type 'array' with `config.zones.nonRepeatable`: entry and delivery data carry `<key>.nonRepeatable.<sub>`, while data-bcms-field paths are `<key>.<sub>`. Schema only \u2014 never places a section; use componentize_sections to turn a group into a section.",
-        inputSchema: addPageFieldInput.shape
-      },
-      handler: guard(
-        async (args) => withClient(async (client) => {
-          const page = await client.addPageFields(args.pageId, {
-            // Cast: same as create_page. The SDK types `options` as string[], narrower than the
-            // API, which also takes {label, value} (backend selectFieldSchema).
-            addFields: [toField(args)],
-            ...args.after !== void 0 ? { after: args.after } : {}
-          });
-          return ok(
-            `Added field '${args.key}' to page '${page.title}'. Page now has ${page.fields.length} field(s).`,
-            page
-          );
-        })
-      )
-    },
     {
       name: "create_content_entry",
       config: {
         title: "Create a content entry",
-        description: "Create a content entry under a model. " + PAGES_NOT_COLLECTIONS_NOTE + " Pass its field VALUES in `data`, keyed by field key \u2014 INCLUDE ALL REQUIRED FIELDS (create validates them). New entries are drafts; pass status:'published' to take it live. Read get_content_model first for the field keys and which are required.",
+        description: "Create a content entry under a model. " + PAGES_NOT_COLLECTIONS_NOTE + " Pass its field VALUES in `data`, keyed by field key \u2014 INCLUDE ALL REQUIRED FIELDS (create validates them). New entries are drafts; pass status:'published' to take it live. Read get_content_model first for the field keys and which are required. One entry per call: for volume, run code against the Management API.",
         inputSchema: createEntryInput.shape
       },
       handler: guard(
@@ -4751,7 +5140,10 @@ ${notes.join("\n")}` : summary, created);
           const created = await client.createEntry({
             contentModelId: args.contentModelId,
             ...args.slug !== void 0 ? { slug: args.slug } : {},
-            ...args.data !== void 0 ? { data: args.data } : {}
+            ...args.data !== void 0 ? { data: args.data } : {},
+            // The SDK's input type predates localization; its body is the input as given.
+            ...args.locale !== void 0 ? { locale: args.locale } : {},
+            ...args.translationOf !== void 0 ? { translationOf: args.translationOf } : {}
           });
           const published = args.status !== void 0 && args.status !== "draft" ? await client.updateEntry(created.id, { status: args.status }) : created;
           const { warnings, ...entry } = published;
@@ -4767,7 +5159,7 @@ ${notes.join("\n")}` : summary, created);
       name: "set_page_content",
       config: {
         title: "Set a page's field values (content)",
-        description: "Set a page's field VALUES \u2014 the actual content. For a SINGLETON page (Home, About, Site Settings) this creates or updates its one entry, so call it again to edit. `data` is keyed by field key: a nested 'array' (zone) value is an OBJECT { nonRepeatable: { childKey: value }, repeatable: [ { childKey: value } ] }; a primitive 'array' is a plain list; an 'image' value is an asset URL. Read the schema first with get_page. This is how you populate Home/About/Settings \u2014 create_content_entry is for dynamic collections only. Merges by top-level key (a zone value replaces that whole zone); pass replace:true to remove omitted fields.",
+        description: "Set a page's field VALUES \u2014 the actual content. For a SINGLETON page (Home, About, Site Settings) this creates or updates its one entry, so call it again to edit. `data` is keyed by field key: a nested 'array' (zone) value is an OBJECT { nonRepeatable: { childKey: value }, repeatable: [ { childKey: value } ] }; a primitive 'array' is a plain list; an 'image' value is an asset URL or { url, altText?, focal?, crop? } \u2014 focal {x,y} and crop {top,right,bottom,left} (0\u20131, cut from each edge) frame THIS placement only. Read the schema first with get_page. This is how you populate Home/About/Settings \u2014 create_content_entry is for dynamic collections only. Merges by top-level key (a zone value replaces that whole zone); pass replace:true to remove omitted fields.",
         inputSchema: setPageContentInput.shape
       },
       handler: guard(
@@ -4788,17 +5180,26 @@ ${notes.join("\n")}` : summary, created);
       name: "list_content_entries",
       config: {
         title: "List content entries (incl. drafts)",
-        description: "List content entries \u2014 including drafts \u2014 filtered by model and/or page. Use it to SEE existing content before editing. For a singleton page, pass its pageId to get its single entry. A project-scoped connection sees its own project's entries plus workspace-level ones, which it can read but not change.",
+        description: "List content entries \u2014 including drafts \u2014 filtered by model and/or page, by field values (`where`), sorted and paged. Use it to SEE existing content before editing. For a singleton page, pass its pageId to get its single entry. A project-scoped connection sees its own project's entries plus workspace-level ones, which it can read but not change. Returns `limit` entries per `page` (50 by default); the summary says which page of how many.",
         inputSchema: listEntriesInput.shape
       },
       handler: guard(
         async (args) => withClient(async (client) => {
-          const entries = await client.listEntries({
+          const filter = {
             ...args.modelId ? { modelId: args.modelId } : {},
             ...args.pageId ? { pageId: args.pageId } : {},
             ...args.status ? { status: args.status } : {}
-          });
-          return ok(`${entries.length} entr(y/ies).`, entries);
+          };
+          if ([args.limit, args.where, args.sort, args.page].every((v) => v === void 0)) {
+            const entries = await client.listEntries(filter);
+            return ok(`${entries.length} entr(y/ies).`, entries);
+          }
+          const res = await client.fetchJSON(
+            client.url(`/management/content/entries${entryListSearch(args)}`),
+            { method: "GET" }
+          );
+          const paged = res.meta ? ` Page ${res.meta.page} of ${res.meta.totalPages} (${res.meta.total} in all).` : "";
+          return ok(`${res.data.length} entr(y/ies).${paged}`, res.data);
         })
       )
     },
@@ -4820,17 +5221,24 @@ ${notes.join("\n")}` : summary, created);
       name: "update_content_entry",
       config: {
         title: "Update a content entry's values",
-        description: "Update a content entry's `data` (field values) and/or status by id. `data` is keyed by field key; a nested 'array' (zone) value is an object { nonRepeatable: {\u2026}, repeatable: [{\u2026}] }, a primitive 'array' is a plain list. Use this to edit an existing entry; for a singleton page prefer set_page_content. \u{1F534} `data` REPLACES the entry's whole value object: an optional field you leave out is DELETED, and a required one you leave out fails the whole write. To change one field, read the entry (get_content_entry), change that key, and send the whole object back. " + ENTRY_META_NOTE,
+        description: "Update a content entry's `data` (field values) and/or status by id. `data` is keyed by field key; a nested 'array' (zone) value is an object { nonRepeatable: {\u2026}, repeatable: [{\u2026}] }, a primitive 'array' is a plain list; an image value may carry this placement's focal {x,y} and crop {top,right,bottom,left} (0\u20131). Use this to edit an existing entry; for a singleton page prefer set_page_content. \u{1F534} `data` REPLACES the entry's whole value object: an optional field you leave out is DELETED, and a required one you leave out fails the whole write. To change one field, pass merge:true, or read the entry (get_content_entry), change that key and send the whole object back. " + ENTRY_META_NOTE,
         inputSchema: updateEntryInput.shape
       },
       handler: guard(
         async (args) => withClient(async (client) => {
-          const { warnings, ...entry } = await client.updateEntry(args.entryId, {
-            ...args.data !== void 0 ? { data: args.data } : {},
+          const write = args.merge === true && args.data !== void 0 ? planEntryMerge(await client.getEntry(args.entryId), args.data, args.ifMatch) : { data: args.data, ifMatch: args.ifMatch };
+          const input = {
+            ...write.data !== void 0 ? { data: write.data } : {},
             ...args.status !== void 0 ? { status: args.status } : {},
             ...args.slug !== void 0 ? { slug: args.slug } : {},
-            ...args.meta !== void 0 ? { meta: args.meta } : {}
-          });
+            ...args.meta !== void 0 ? { meta: args.meta } : {},
+            // Not on the SDK's input type yet; the route accepts both (null cancels).
+            ...args.scheduledAt !== void 0 ? { scheduledAt: args.scheduledAt } : {},
+            ...args.unpublishAt !== void 0 ? { unpublishAt: args.unpublishAt } : {},
+            ...args.locale !== void 0 ? { locale: args.locale } : {},
+            ...args.translationOf !== void 0 ? { translationOf: args.translationOf } : {}
+          };
+          const { warnings, ...entry } = write.ifMatch === void 0 ? await client.updateEntry(args.entryId, input) : await client.updateEntry(args.entryId, input, { ifMatch: write.ifMatch });
           return ok([`Updated entry '${entry.slug}' (id ${entry.id}, status ${entry.status}).`, ...warnings ?? []].join("\n"), entry);
         })
       )
@@ -4839,12 +5247,15 @@ ${notes.join("\n")}` : summary, created);
       name: "upload_asset",
       config: {
         title: "Upload an asset to the Media Library",
-        description: "Upload an image/asset from a local file path or a remote URL into the project's Media Library. Returns the asset's stable CDN URL \u2014 put that URL into a content entry's image field. Use this BEFORE creating entries that reference images.",
+        description: "Upload an image/asset from a local file path or a remote URL into the project's Media Library, or have the server fetch a public `sourceUrl` itself. Returns the asset's stable CDN URL \u2014 put that URL into a content entry's image field. Use this BEFORE creating entries that reference images.",
         inputSchema: uploadAssetInput.shape
       },
       handler: guard(
         async (args) => withClient(async (client) => {
-          const asset = await client.uploadAsset(args);
+          const asset = args.sourceUrl && !args.localPath && !args.url ? (await client.fetchJSON(client.url(`/management/media/import`), {
+            method: "POST",
+            body: JSON.stringify({ url: args.sourceUrl, altText: args.altText, caption: args.caption, folderId: args.folderId })
+          })).data : await client.uploadAsset(args);
           return ok(
             `Uploaded '${asset.filename}' (id ${asset.id}). Put this URL (or the id ${asset.id}) into an image field to attach it: ${asset.url}`,
             asset
@@ -5070,7 +5481,7 @@ ${notes.join("\n")}` : summary, created);
       name: "get_component",
       config: {
         title: "Get a component (with its blockJson)",
-        description: "Get one component by id INCLUDING its blockJson tree and props (with any stored `ui` authoring chrome on them). Read this before update_component so you keep the existing blocks, and after declaring field UI as the receipt that it landed \u2014 a prop absent here was not stored.",
+        description: "Get one component by id INCLUDING its blockJson tree and props (with any stored `ui` authoring chrome on them). Read this before update_component so you keep the existing blocks, and after declaring field UI as the receipt that it landed \u2014 a prop absent here was not stored. " + VARIANT_GROUP_NOTE,
         inputSchema: getComponentInput.shape
       },
       handler: guard(
@@ -5084,7 +5495,7 @@ ${notes.join("\n")}` : summary, created);
       name: "create_component",
       config: {
         title: "Create a reusable component",
-        description: "Create a reusable component from a blockJson tree. THIS IS ALSO HOW A PAGE GETS ITS SECTIONS: set `sectionType` (e.g. 'Hero') and the component becomes a placeable section, selectable in the editor's 'Add a section' picker. Components sharing a `sectionType` are its layout VARIANTS \u2014 one Hero with a 'Centered' and a 'Two-column' variant, same prop keys, so a swap keeps the content. CONFIRM the structure with the user first. blockJson is an array of blocks \u2014 the same set create_page accepts (heading, text/richtext, image, button, spacer, video, columns, section, slider, tabs, navbar, footer, form, component, collection), NOT a narrower one; `section` nests child blocks in props.children and `columns` in props.columns. `props` declares overridable fields. Returns the new id \u2014 render with `<BcmsBlocks>`. Always lands as a DRAFT \u2014 call publish_component to put it on the live site; until then it renders as NOTHING there, with no error.  Buttons auto-join the project's Button family; section buttons link to its looks." + SECTION_DOCTRINE,
+        description: "Create a reusable component from a blockJson tree. THIS IS ALSO HOW A PAGE GETS ITS SECTIONS: set `sectionType` (e.g. 'Hero') and the component becomes a placeable section, selectable in the editor's 'Add a section' picker. Components sharing a `sectionType` are its layout VARIANTS \u2014 one Hero with a 'Centered' and a 'Two-column' variant, same prop keys, so a swap keeps the content. CONFIRM the structure with the user first. blockJson is an array of blocks \u2014 the same set create_page accepts (heading, text/richtext, image, button, spacer, video, columns, section, slider, tabs, navbar, footer, form, component, collection), NOT a narrower one; `section` nests child blocks in props.children and `columns` in props.columns. `props` declares overridable fields. Returns the new id \u2014 render with `<BcmsBlocks>`. Always lands as a DRAFT \u2014 call publish_component to put it on the live site; until then it renders as NOTHING there, with no error.  Buttons auto-join the project's Button family; section buttons link to its looks." + SECTION_DOCTRINE + " " + UNPROPPED_COPY_NOTE,
         inputSchema: createComponentInput.shape
       },
       handler: guard(
@@ -5108,32 +5519,6 @@ ${notes.join("\n")}` : summary, created);
      * no receipt mentions, and the agent's only safe move is to re-run it and duplicate them.
      * Every item reports its own outcome instead, and the summary line says how many failed.
      */
-    {
-      name: "create_components",
-      config: {
-        title: "Create many components in one call",
-        description: "Create up to 50 components in ONE call \u2014 the same input as create_component, once per item. Prefer it over create_component for more than three: a whole-site componentize run (playbook \xA712) is dozens. Each item reports its own `{ ok, id, slug, error }`: a failure does NOT stop the run and the successful rows stay, so read the receipt and retry only the failures (a 409 on `slug` means that name is taken \u2014 change it, do not re-run the batch). Every component lands as a DRAFT, exactly as create_component does \u2014 it renders as NOTHING on the live site until it is published, which needs the owner's approval in the dashboard. Pass `group` on each item to file it into the folder editors browse. DECLARE A PROP \u2014 WITH A `target` \u2014 for every string, link and image a marketer will ever touch: only the leaves a declared prop TARGETS are click-to-edit; copy no prop points at is unreachable from canvas and dock alike. A page is composed of SECTIONS; the full doctrine is in the bettercms://playbook/schema resource, \xA712.",
-        inputSchema: createComponentsInput.shape
-      },
-      handler: guard(
-        async (args) => withClient(async (client) => {
-          const results = [];
-          for (const input of args.components) {
-            try {
-              const cmp = await client.createComponent(input);
-              results.push({ ok: true, slug: cmp.slug, id: cmp.id, name: cmp.name });
-            } catch (err) {
-              results.push({ ok: false, slug: input.slug, error: errorText(err) });
-            }
-          }
-          const failed = results.filter((r) => !r.ok).length;
-          return ok(
-            `Created ${results.length - failed} of ${args.components.length} component(s)${failed ? `; ${failed} failed \u2014 see the per-item errors` : ""}. All are DRAFTS: publish_components once the owner has approved them, or they render as empty strings.`,
-            results
-          );
-        })
-      )
-    },
     {
       name: "publish_components",
       config: {
@@ -5262,7 +5647,7 @@ ${lines.join("\n")}`, found);
       name: "update_component",
       config: {
         title: "Update a reusable component",
-        description: "Update a component by id \u2014 blockJson, props, name, or category. Read with get_component, then pass `ifMatch` = the version from that read. Passing `blockJson`/`props` REPLACES them. This writes the DRAFT: call publish_component to push the change live.",
+        description: "Update a component by id \u2014 blockJson, props, name, or category. Read with get_component, then pass `ifMatch` = the version from that read. Passing `blockJson`/`props` REPLACES them. This writes the DRAFT: call publish_component to push the change live. " + UNPROPPED_COPY_NOTE,
         inputSchema: updateComponentInput.shape
       },
       handler: guard(
@@ -5395,24 +5780,6 @@ ${lines.join("\n")}`, found);
         })
       )
     },
-    {
-      name: "duplicate_component",
-      config: {
-        title: "Add a look to a component family",
-        description: "Add a new LOOK to a component's variant family (\"+ New variant\"), e.g. a Ghost button the site does not have: copy the component into the same family and folder under `name`, with a new unique slug. `preset` restyles its button block: primary / secondary fill it with the brand kit's primary / accent colour; ghost drops the fill and border, keeps the padding and colours the text with the old fill; link is a ghost with no padding. Omit `preset` for a plain copy. Starts a family if none. outline drops the fill, keeps the padding and draws a border all round in the old fill's colour, which becomes the text colour. A look the style vocabulary cannot express is refused with 422 and the reason \u2014 relay it, never approximate it with update_component. 409 means that name is already a look in the family. When the family's contract is published and this connection may publish, the new look is published at once and is choosable in every section's style select; otherwise it is a draft: call publish_component.",
-        inputSchema: duplicateComponentInput.shape
-      },
-      handler: guard(
-        async (args) => withClient(async (client) => {
-          const { componentId, ...body } = args;
-          const res = await client.fetchJSON(
-            client.url(`/management/components/${encodeURIComponent(componentId)}/duplicate`),
-            { method: "POST", body: JSON.stringify(body) }
-          );
-          return ok(`Added look '${res.data.name}' (id ${res.data.id}, ${res.data.status}).`, res.data);
-        })
-      )
-    },
     // ── AI content + SEO actions (Option B) ────────────────────────────────────
     {
       name: "write_content",
@@ -5467,30 +5834,6 @@ ${lines.join("\n")}`, found);
         })
       )
     },
-    {
-      name: "native_bridge_heartbeat",
-      config: {
-        title: "Register as a native bridge and report liveness",
-        description: "Register this client as a native-bridge executor for the connected project and report that it is alive. The dashboard's 'Native AI Connection' panel shows an executor as live ONLY while heartbeats keep arriving: call this again every `nextHeartbeatMs` (25s), because liveness lapses 90s after the last call and the panel then stops offering this executor. Idempotent \u2014 registration happens on the first call, so a restart or a reconnect is just another call. Echo back the `session` from the previous response so the same connection epoch is kept; omit it to reconnect, which fences the previous one. A 422 names a refused capability or protocol; it does not retry into success. THIS GRANTS NO REPOSITORY MUTATION \u2014 it is presence only, and starting a run still requires a human in the dashboard.",
-        inputSchema: nativeBridgeHeartbeatInput.shape
-      },
-      handler: guard(
-        async (args) => withClient(async (client) => {
-          const result = await client.fetchJSON(client.url("/management/orchestration/bridge/heartbeat"), {
-            method: "POST",
-            body: JSON.stringify({
-              protocolVersion: args.protocolVersion,
-              capabilities: args.capabilities,
-              ...args.session ? { session: args.session } : {}
-            })
-          });
-          return ok(
-            `Bridge ${result.liveness}. Call again within ${Math.round(result.nextHeartbeatMs / 1e3)}s to stay live.`,
-            result
-          );
-        })
-      )
-    },
     // ── Lifecycle tools (parity with the remote /mcp surface) ──────────────────
     // Media management, form submissions (leads), redirects, SEO, AEO site-files,
     // promote, and entry version history. These call the management endpoints straight
@@ -5502,12 +5845,13 @@ ${lines.join("\n")}`, found);
     ...defs.filter((d) => LISTING_TAIL.has(d.name))
   ].map(withProjectId);
 }
-function registerTools(server, deps) {
+function registerTools(server, deps, tools = process.env.BETTERCMS_MCP_TOOLS) {
   const withElicit = {
     ...deps,
     elicit: deps.elicit ?? ((params) => server.server.elicitInput(params))
   };
-  for (const def of buildToolDefs(withElicit)) {
+  const sets = toolsetsOf(tools);
+  for (const def of buildToolDefs(withElicit).filter((d) => listsTool(d.name, sets))) {
     server.registerTool(def.name, def.config, def.handler);
   }
 }
@@ -5541,7 +5885,7 @@ DERIVED at import, where the componentize lane in \xA710 reuses every field.
     A stack of mixed, reorderable content? -> kind:'block' models + a \`modular\` field
     A row in a list (post, author, tier)?  -> a collection (kind:'model'); rows one template
                                               route renders get urlPattern, e.g. '/blog/:slug'
-    Copy for ONE page (home, about, legal)?-> page fields in sections (add_page_field /
+    Copy for ONE page (home, about, legal)?-> page fields in sections (add_field {pageId} /
                                               set_page_content) \u2014 never a one-entry collection
     The one body of an article?            -> type:'document'  (exactly one, top level)
     A fixed cluster of fields?             -> group     (never a 1-item repeater)
@@ -5726,7 +6070,7 @@ written to the wrong project can only be demoted (\`sectionType: null\`) and lef
 
 ## 10. You imported a site, or you are about to deploy one
 
-\`deploy_project\`, \`deploy_from_upload\` and \`promote_project\` all answer **409
+\`deploy_project\` and \`promote_project\` both answer **409
 AUTHORING_DECISION_REQUIRED** until a human has chosen this project's architecture. This is
 asked ONCE per project, ever. It is not an error to retry or route around: read the message
 out, let the user pick, call \`set_authoring_preference\`, then deploy again.
@@ -5861,7 +6205,7 @@ renders. Three consequences, each load-bearing:
        route, in this order (get_next_steps reports the state until it is done):
 
          a. create_page            one per route, slug matching the route
-         b. add_page_field         the fields its content needs (or create_component +
+         b. add_field {pageId}     the fields its content needs (or create_component +
                                    publish_component + component blocks, per your \xA710 answer)
          c. set_page_content       values EXACTLY equal to the text the site renders \u2014
                                    binding matches by value, so a paraphrase binds nothing
@@ -6030,8 +6374,8 @@ assembled from registered components?": per page its blocks and every component
 that component's status, plus site totals \u2014 unpublished, awaiting evidence, awaiting approval,
 missing from the picker, placed nowhere \u2014 and \`verdict.everyPageComposed\` with the reasons it
 is false. A component reaches a visitor only once PUBLISHED, and publishing needs the project
-owner's approval in the DASHBOARD: evidence goes \`submit_section_manifest\` \u2192
-\`submit_section_validation\`, the owner approves there, then \`publish_components\`. There is no
+owner's approval in the DASHBOARD: evidence comes from \`request_component_validation\` and a
+validation run in the repository, the owner approves there, then \`publish_components\`. There is no
 bulk approve, and no tool here can grant that approval. Finish with \`get_next_steps\`.
 
 **Order of operations.**
@@ -6041,10 +6385,10 @@ bulk approve, and no tool here can grant that approval. Finish with \`get_next_s
     3.  componentize_sections       dryRun first, then for real
     3b. npx @bettercms-ai/convert --componentize --receipt componentize.json, push,
         then submit_componentize_receipt { receipt }   every section's Output source, ONE call
-    4.  create_components           everything the plan did not cover, ONE call, each with a group
+    4.  create_component            each section the plan did not cover, each with a group
     5.  compose_pages               every page's blockJson, ONE call
     6.  update_layout { commands }  nav/footer chrome + add-component, ONE call
-    7.  evidence                    submit_section_manifest -> submit_section_validation
+    7.  evidence                    request_component_validation -> the repo's validation run
     8.  owner approves in the dashboard, then publish_components   ONE call, per-item receipts
     9.  update_page status:'published', publish_layout
     10. get_site_composition, then get_next_steps
@@ -6093,7 +6437,7 @@ either way.
 **If you know Sanity, this is the same shape under different names:**
 
     defineType schema in code   ->  content models / page fields (create_content_model,
-                                    add_page_field, or bcms-content.json "schema")
+                                    add_field, or bcms-content.json "schema")
     TypeGen                     ->  @bettercms-ai/codegen
     GROQ query in the page      ->  @bettercms-ai/sdk read client, or the bcms-content.json
                                     build snapshot
@@ -6127,8 +6471,9 @@ hand. THE ORDER, and every step of it matters:
    fallback, and declares each binding.
 2b. IF THE BRIEF CARRIES \`forms\`, wire them too:
    \`npx @bettercms-ai/convert --forms --brief brief.json --root . --receipt forms-receipt.json\`
-   \u2014 ITS OWN receipt file, submitted with submit_conversion_receipt as a second call: the
-   server stores its \`forms\` block beside the binding receipt (coverage is untouched), and
+   \u2014 ITS OWN receipt file, submitted with submit_conversion_receipt as a second call under the
+   SAME \`briefDigest\` (its \`paths\` are all zero): the server stores its \`forms\` block
+   beside the binding receipt (never counted in coverage), and
    the next release reads \`wiredForms\` to say which component renders each form.
    A site imported by phase 1 has a DRAFT form row per \`<form>\` in its build, so the Forms tab
    is full while the repository's markup still posts wherever it always did \u2014 to nothing, or to
@@ -6149,6 +6494,11 @@ hand. THE ORDER, and every step of it matters:
    in the data file or collection entry it names) or \`manual\` (do what its \`why\` says). A row
    with no \`fix\` is still yours. Then RERUN step 2 and repeat until \`paths.pending\` is empty \u2014
    the codemod is idempotent, so a second run over converted source rewrites nothing.
+3b. THE SITE'S DESIGN IS NOT YOURS TO CHANGE. The \`--verify-styles\` pass of the same codemod
+   (\`--root .\`, with \`--base\` set to the last commit before you started converting) lists every
+   \`class\`, \`className\` and \`style\` the conversion altered as \`styleEdits\`; they travel
+   inside the receipt, and a non-empty list is refused with 409 \`style-edits\` naming every
+   token. Restore them in the source, rerun, resubmit.
 4. \`submit_conversion_receipt { briefDigest, receipt }\` with the receipt file, verbatim. It
    answers \`complete\`, \`pendingTotal\` and the first 40 pending rows with their \`fix\`. \`complete: true\` \u2014 nothing
    pending \u2014 is the ONLY receipt that ends a conversion; on anything less go back to step 3. It
@@ -6180,7 +6530,7 @@ conversion is yours to write.
    reconstruct content from the deployed HTML \u2014 that is how a site ends up bound to a copy of
    its own stale build.
 2. Decide the architecture WITH the human (\xA710) and record it: \`set_authoring_preference\`.
-3. Register the schema. Per route: \`create_page\` + \`add_page_field\` (text / longtext /
+3. Register the schema. Per route: \`create_page\` + \`add_field\` { pageId } (text / longtext /
    richtext / image / array groups). Per repeated content type: \`create_content_model\`, with a
    \`document\` body for articles. Site chrome goes through \`update_layout\`; images through
    \`create_media_upload\` / \`upload_asset\`, then reference the CMS URL. The repo-owned
@@ -6237,7 +6587,7 @@ conversion is yours to write.
       \`BCMS_API_KEY_PROD\`, is the validation workflows' key; they fall back to the shared
       \`BCMS_API_KEY\` only for a repo whose last connect predates it.) Read that file, with in-code
       fallbacks so a local or CI build without it still renders.
-    - ARCHIVE (\`deploy_project\` / \`deploy_from_upload\`): the sandbox build runs with no env
+    - ARCHIVE (\`deploy_project\`, inline or by \`uploadKey\`): the sandbox build runs with no env
       and no network content step, by design. So the archive MUST SHIP its own
       \`bcms-content.json\` \u2014 generate it locally with a delivery key and commit it. Without
       one the site renders its fallbacks and the report says \`no-element\` for every path.
@@ -6278,7 +6628,7 @@ conversion is yours to write.
 
 You can create the schema. You can also say how it PRESENTS to the person filling it in. These
 three props ride on any field, on any field-creating tool (\`create_content_model\`,
-\`create_page\`, \`add_field\`, \`add_page_field\`), and none of them can move, reshape or hide a
+\`create_page\`, \`add_field\`), and none of them can move, reshape or hide a
 delivered value \u2014 they change editor chrome only.
 
 \`\`\`jsonc
@@ -6417,7 +6767,7 @@ Importance orders a screen: required fields first, then array order.
   Name props from the code (\`plan.cents\` \u2192 Cents), help text as \`e.g. "49"\`; repeated cards are one \`table\` prop.
   They write the DRAFT props; no publish is needed for the editor to show them.
 - Always send \`ifMatch\`, the \`optimisticVersion\` you read.
-- A NEW field carries its chrome in the same \`add_field\` / \`add_page_field\` call.
+- A NEW field carries its chrome in the same \`add_field\` call.
 
 **The dock's refusals, each named in the message.**
 - **428** \`precondition-required\` \u2014 a chrome key without \`ifMatch\`. Read, then send it.
@@ -6429,6 +6779,9 @@ Importance orders a screen: required fields first, then array order.
   fieldset its fields still name.
 - \`row_member_type\`, \`row_member_count\`, \`row_member_control\` \u2014 the row rule.
 - \`pair_split\` \u2014 a button's label and href in different fieldsets.
+- \`cta_pair\` \u2014 a NEW text field beside a link keyed like it plus \`-href\` (\`hero-span-go\` + \`hero-a-go-href\`): one
+  call to action. Add ONE \`type: "button"\` field (value \`{ label, href }\`); on a component, point both props
+  at one button block.
 - \`ui.icon\` or \`ui.itemLabel\` on a leaf; an icon name not in \`bettercms://icons/dock\`.
 - \`layout_grid\` \u2014 a grid with no image or file child. \`layout_table\` \u2014 more than 3 columns, or a
   column that is not a scalar.
@@ -6444,8 +6797,8 @@ stored, whatever the write returned \u2014 \xA711 RECEIPTS rule 3, applied to th
 and \`dock-showif-order\` must all be gone. Declare, then read back, then say it works.
 
 **No \`order\` property. Ever.** A field's order IS its index in \`fields\`. To put a new field
-somewhere other than the end, pass \`after: '<existing top-level field key>'\` to \`add_field\` /
-\`add_page_field\`; omit it and the field appends, exactly as before. \`after\` is an argument
+somewhere other than the end, pass \`after: '<existing top-level field key>'\` to \`add_field\`;
+omit it and the field appends, exactly as before. \`after\` is an argument
 applied once at the write \u2014 a stored ordering prop would be a second source of truth that
 disagrees with the array the moment anyone drags a row in the builder.
 
@@ -6511,7 +6864,7 @@ Do not stop at the plan or at a partial receipt \u2014 finish the whole site, ne
    with no \`fix\` is still yours. Then rerun step 4 until \`paths.pending\` is EMPTY.
 6. \`npx @bettercms-ai/convert --verify-styles --base <commit before step 4>\`, restore what it lists, then
    \`submit_conversion_receipt { briefDigest, receipt }\` with its \`styleEdits\`: only \`complete: true\` ends it (else step 5).
-7. Deploy the working tree (\`create_deploy_upload\` + \`deploy_from_upload\`); poll \`get_deploy_status\` until live. No git yet.
+7. Deploy the working tree (\`create_deploy_upload\`, then \`deploy_project\` with its \`uploadKey\`); poll \`get_deploy_status\` until live. No git yet.
 8. \`get_binding_report\`: \`unmatched\` 0, \`unaddressable\` under 2% per route; fix the SOURCE, deploy, re-read (playbook \xA711).
 9. \`set_binding_mode { declaredBindings: true }\`, deploy AGAIN and poll, then confirm \`get_binding_report\`
    reads mode "declared", unmatched 0, bound above 0, \`coverage.pending\` empty. Send me that report.
@@ -6539,7 +6892,7 @@ shape, then ask me, once and batched). Icon names are in bettercms://icons/dock.
      fieldHelpText by field path, plus \`fieldsets\`. A singleton page: send \`pageId\` instead of
      modelId, with its backingModel's version;
    - component props: \`update_component\` propUi / propGroup / propLabel / propHelpText;
-   - a NEW field: ui / helpText / showIf in the same \`add_field\` / \`add_page_field\` call, with \`after\`.
+   - a NEW field: ui / helpText / showIf in the same \`add_field\` call, with \`after\`.
    A 409 \`ui_human_owned\` names chrome a person set: leave it, or ask me and send \`override: true\`
    only on my word.
 4. **RECEIPT, non-negotiable.** Re-read every target and confirm the stored chrome matches what you
@@ -6581,15 +6934,15 @@ Author a page (the page-first schema). Ask, in order, via AskUserQuestion:
 4. **Review** the assembled tree, then call \`create_page\` with
    { title, slug, pageType, fields, metaTitle?, metaDescription? }. Field object:
    { key, label, type, required?, options?, config?, fields? }.`;
-var FIELD_FLOW = `### Add a field \u2192 \`add_field\` (models) / \`add_page_field\` (pages)
+var FIELD_FLOW = `### Add a field \u2192 \`add_field\` (a model or a page)
 Append a field to an existing schema. First decide the target: a **content model**
 or a **page** (Home, About, a blog template). Ask: which target (id \u2014 use
 \`list_pages\` to find a page id), then the field (key, label, type \u2014 any of the 13
 above, including nested group/repeater), required?. Confirm, then call:
 - a model \u2192 \`add_field\` { modelId, key, label, type, ... }
-- a page  \u2192 \`add_page_field\` { pageId, key, label, type, ... }
-Both are additive: they reject a key that already exists and never retype/overwrite
-an existing field (edit those in the dashboard).`;
+- a page  \u2192 \`add_field\` { pageId, key, label, type, ... }
+It is additive: it rejects a key that already exists and never retypes/overwrites
+an existing field \u2014 change one of those with \`update_field\` { path, \u2026 }.`;
 var ENTRY_FLOW = `### Create an entry \u2192 \`create_content_entry\` tool
 Create a content entry under a model. Ask: which model (id), the field values (data),
 status (draft/published). Then call \`create_content_entry\` { contentModelId, data?, status?, slug? }.`;
@@ -6662,11 +7015,11 @@ Read \`bettercms://playbook/schema\` \xA712 first \u2014 this is the short form
    restyle. Dry-run first.
 6. **Validation** = \`get_site_composition\`: every page's placements, each component's status,
    and \`verdict.everyPageComposed\` with its reasons. Publishing needs the OWNER's approval in
-   the dashboard (evidence via \`submit_section_manifest\` \u2192 \`submit_section_validation\`), then
+   the dashboard (evidence via \`request_component_validation\` and a run in the repository), then
    \`publish_components\`. No tool here can grant that approval, and there is no bulk approve.
 
 **Order:** get_site_composition \u2192 (get_componentize_plan \u2192 componentize_sections) \u2192
-create_components \u2192 compose_pages \u2192 update_layout { commands } \u2192 evidence + owner approval \u2192
+create_component per uncovered section \u2192 compose_pages \u2192 update_layout { commands } \u2192 evidence + owner approval \u2192
 publish_components \u2192 publish the pages / publish_layout \u2192 get_site_composition \u2192 get_next_steps.
 Prefer the batch tools whenever there is more than three of anything.`;
 var LAYOUT_FLOW = `### Project/page Layout authoring \u2192 \`get_layout\` / \`update_layout\` / \`publish_layout\`
@@ -7070,7 +7423,7 @@ Read bettercms://playbook/schema section 11 first, then work this order:
 
 1. AUTHORING GATE \u2014 if any deploy answered 409 AUTHORING_DECISION_REQUIRED, ask ME
    components-or-fields (do not choose), then set_authoring_preference.
-2. CONTENT INTO THE CMS, per route: create_page (slug = route) -> add_page_field (or
+2. CONTENT INTO THE CMS, per route: create_page (slug = route) -> add_field {pageId} (or
    create_component + publish_component + component blocks) -> set_page_content with values
    EXACTLY equal to the rendered text (binding matches by value; a paraphrase binds nothing)
    -> update_page status 'published' (the canvas binds the PUBLISHED copy).
@@ -7100,6 +7453,67 @@ On 401/403, the MCP key needs (re)authorizing.`
   );
 }
 
+// src/skill-docs.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+var SKILL_URI_PREFIX = "bettercms://skill/";
+var CORE_SKILL = "bettercms";
+var CANDIDATES = ["./skills/bettercms/", "../../skills/bettercms/"];
+function defaultSkillDir() {
+  for (const rel of CANDIDATES) {
+    const dir = fileURLToPath(new URL(rel, import.meta.url));
+    if (existsSync(join(dir, "SKILL.md"))) return dir;
+  }
+  return null;
+}
+function frontmatterOf(text2) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/.exec(text2);
+  if (!m) return {};
+  const out = {};
+  const lines = m[1].split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const kv = /^([A-Za-z_][\w-]*):\s*(.*)$/.exec(lines[i]);
+    if (!kv) continue;
+    let value = kv[2].trim();
+    if (value === ">" || value === "|" || value === ">-" || value === "|-") {
+      const block = [];
+      while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1])) block.push(lines[++i].trim());
+      value = block.join(value.startsWith(">") ? " " : "\n");
+    } else if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    if (value) out[kv[1]] = value;
+  }
+  return out;
+}
+function skillDocOf(stem, text2) {
+  const fm = frontmatterOf(text2);
+  const heading = /^#\s+(.+?)\s*$/m.exec(text2)?.[1];
+  const title = fm.title ?? heading ?? stem;
+  const description = fm.description ?? heading;
+  return {
+    uri: `${SKILL_URI_PREFIX}${stem}`,
+    name: `skill-${stem}`,
+    title,
+    ...description ? { description } : {},
+    mimeType: "text/markdown",
+    text: text2
+  };
+}
+function loadSkillDocs(dir = defaultSkillDir()) {
+  if (!dir) return [];
+  const docs = [skillDocOf(CORE_SKILL, readFileSync(join(dir, "SKILL.md"), "utf8"))];
+  const refs = join(dir, "references");
+  if (!existsSync(refs)) return docs;
+  for (const file of readdirSync(refs).filter((f) => f.endsWith(".md")).sort()) {
+    const stem = file.slice(0, -3);
+    if (stem === CORE_SKILL) continue;
+    docs.push(skillDocOf(stem, readFileSync(join(refs, file), "utf8")));
+  }
+  return docs;
+}
+
 // src/server.ts
 var SERVER_NAME = "bettercms";
 var SERVER_VERSION = "1.5.0";
@@ -7111,6 +7525,12 @@ var SERVER_DISPLAY = {
     { src: "https://api.bettercms.ai/brand/mark.svg", mimeType: "image/svg+xml", sizes: ["any"] }
   ]
 };
+function withBranch(client, branch) {
+  if (!branch) return client;
+  const base = client.headers.bind(client);
+  client.headers = () => ({ ...base(), "X-Branch-Id": branch });
+  return client;
+}
 function buildServer(deps) {
   const server = new McpServer(
     { name: SERVER_NAME, version: SERVER_VERSION, ...SERVER_DISPLAY },
@@ -7119,7 +7539,7 @@ function buildServer(deps) {
       // 🔴 The plain-language ask, routed — the stdio twin of the hosted connector's line
       // (src/routes/mcp/index.ts MCP_INSTRUCTIONS). "Make my site editable" has one recipe and
       // one definition of done; without this an agent converts the page it landed on and stops.
-      instructions: RECEIPT_FIRST_INSTRUCTION + " When the user asks to make a site or all of its pages editable, to convert it, or to bind its fields: this is playbook \xA713. Read `bettercms://playbook/schema` \xA713, call get_binding_report and get_conversion_brief { complete: true }, convert EVERY route the brief lists, and finish only when get_binding_report shows coverage.pending empty on every route \u2014 not when the first page works. On a workspace-wide connection pass projectId on every call; never ask the user to re-scope the connection. " + LAYOUT_CHROME_INSTRUCTION + " When the user asks to componentize the whole site, to turn every section into a component, or to build a component library from the site: this is playbook \xA712. Read `bettercms://playbook/schema` \xA712, start with get_site_composition, and use the batch tools \u2014 create_components, compose_pages, update_layout with `commands`, publish_components \u2014 rather than one call per component. Finish with get_site_composition and tell the user what the platform does not model (cookie banners, modals, breadcrumbs, pagination) and which components still need the owner's approval in the dashboard before they can be published. BetterCMS never executes a customer's Section renderer or app code. An ordinary MCP connection is not a push runner: explicitly poll list_section_validation_requests, claim one request at an exact git commit, run implementation and responsive checks inside the user's own repository and real app shell, then submit manifest + validation with that requestId and complete it\u2014or truthfully fail it when implementation/evidence is missing. Never invent a manifest, a passing validation, or visual evidence; these tools cannot grant the separate human Visual Approval required for publication. " + // The default after authoring (the structure standard): organise what you made. Same
+      instructions: RECEIPT_FIRST_INSTRUCTION + " When the user asks to make a site or all of its pages editable, to convert it, or to bind its fields: this is playbook \xA713. Read `bettercms://playbook/schema` \xA713, call get_binding_report and get_conversion_brief { complete: true }, convert EVERY route the brief lists, and finish only when get_binding_report shows coverage.pending empty on every route \u2014 not when the first page works. On a workspace-wide connection pass projectId on every call; never ask the user to re-scope the connection. " + LAYOUT_CHROME_INSTRUCTION + " When the user asks to componentize the whole site, to turn every section into a component, or to build a component library from the site: this is playbook \xA712. Read `bettercms://playbook/schema` \xA712, start with get_site_composition, and use the batch tools \u2014 componentize_sections, compose_pages, update_layout with `commands`, publish_components \u2014 rather than one call per component. Finish with get_site_composition and tell the user what the platform does not model (cookie banners, modals, breadcrumbs, pagination) and which components still need the owner's approval in the dashboard before they can be published. " + // The default after authoring (the structure standard): organise what you made. Same
       // sentence as the hosted connector's MCP_INSTRUCTIONS.
       STRUCTURE_DEFAULT_INSTRUCTION + " " + SKILLS_ROUTING_INSTRUCTION + " " + DOCK_UI_ROUTING_INSTRUCTION
     }
@@ -7152,12 +7572,15 @@ function buildServer(deps) {
   server.registerResource(dockIconsName, dockIconsUri, dockIconsMeta, () => ({
     contents: [{ uri: dockIconsUri, mimeType: dockIconsMeta.mimeType, text: DOCK_ICONS_TEXT }]
   }));
+  for (const { uri, name, text: text2, ...meta } of loadSkillDocs()) {
+    server.registerResource(name, uri, meta, () => ({ contents: [{ uri, mimeType: meta.mimeType, text: text2 }] }));
+  }
   registerTools(server, {
     auth: deps.auth,
     // `project` is the per-call target of a workspace-wide grant; the SDK sends it as
     // X-BCMS-Project. Omitted entirely when absent so a project-scoped key's request is
     // byte-identical to before.
-    createClient: (apiKey, project) => BetterCMS.management({ apiKey, baseUrl: deps.managementBaseUrl, ...project ? { project } : {} })
+    createClient: (apiKey, project, branch) => withBranch(BetterCMS.management({ apiKey, baseUrl: deps.managementBaseUrl, ...project ? { project } : {} }), branch)
   });
   registerPrompts(server);
   return server;
@@ -7179,7 +7602,7 @@ function isMainModule() {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    return realpathSync(argv1) === fileURLToPath(import.meta.url);
+    return realpathSync(argv1) === fileURLToPath2(import.meta.url);
   } catch {
     return false;
   }