@bettercms-ai/mcp 0.54.0 → 0.55.0

package/dist/index.js

@@ -2280,7 +2280,9 @@ var fieldShape = {
   ),
   label: z.string().min(1).describe("human label shown in the editor"),
   type: fieldType,
-  required: z.boolean().optional(),
+  required: z.boolean().optional().describe(
+    "an entry cannot be saved without a value \u2014 set it only where the site genuinely cannot render without one"
+  ),
   richText: z.boolean().optional().describe(
     "prose formatting. DEFAULTS TO TRUE for 'text': the field is created as rich text so editors can bold, link and format it on the canvas, and the API returns rich text (render with rich() from @bettercms-ai/sdk; plain() for titles and meta). Pass false for a value that is NOT prose and must stay a bare string \u2014 a URL/href, a slug, an id, an email, a phone number, a CSS class, an icon name. A link stored as rich text will not work as an href."
   ),
@@ -2288,7 +2290,7 @@ var fieldShape = {
     "choices when type is 'select'. A plain string, or {label, value} when the stored value differs from what the editor shows (e.g. {label:'Sold out', value:'soldOut'})."
   ),
   config: z.record(z.string(), z.unknown()).optional().describe(
-    "per-type config: reference {contentModelId}, multi-reference {contentModelId,min,max}, array {itemType: 'text'|'number'|'date'}, date {includeTime}, modular {blockSlugs: ['quote','gallery'], minItems?, maxItems?} \u2014 blockSlugs is REQUIRED, non-empty, and each slug must name an existing kind:'block' model"
+    "per-type config: reference {contentModelId}, multi-reference {contentModelId,min,max}, array {itemType: 'text'|'number'|'date'}, date {includeTime}, modular {blockSlugs: ['quote','gallery'], minItems?, maxItems?} \u2014 blockSlugs is REQUIRED, non-empty, and each slug must name an existing kind:'block' model; richtext {inline:true, hostTag:'h2', accept:['h2','p','b','i','u','link'], features:['bold','italic','underline','link','headings'], allowMultipleParagraphs:false} \u2014 for a field bound to ONE element on the page: `hostTag` is that element's tag and `accept` must name it, so the editor's block-style control opens already showing 'Heading 2' instead of 'Paragraph'. Name exactly ONE heading level: publish refuses an <h3> value bound to an <h2> rather than nesting one heading inside the other. Keep 'p' in `accept` or the sanitiser strips a block demoted to Paragraph"
   ),
   fields: z.array(z.lazy(() => fieldObject)).optional().describe(
     "NESTED child fields \u2014 REQUIRED for type 'group' (one nested object, a Non-Repeatable Zone like blog_hero \u2192 heading, description, hero_image) and type 'repeater' (a repeatable array of such objects, a Repeatable Zone / section-list like testimonials \u2192 quote, author). A section with repeating items is a 'repeater'; a fixed grouped block is a 'group'. Recurse to any depth \u2014 do NOT flatten zones into separate top-level fields."
@@ -2314,7 +2316,7 @@ var fieldShape = {
     "conditional visibility \u2014 hide this field until another field has a given value (e.g. show `external_url` only when `link_type` is 'external'). Admin-only: it changes what an author SEES, never what is stored or delivered. Rules reference fields by BARE KEY, and the key namespace is flat, so the key must exist on this model."
   ),
   ui: uiObject.optional().describe(
-    "AUTHORING CHROME \u2014 how this field presents in the editor. Never a delivery effect. `preview` and `layout` are valid ONLY on a nesting field ('group', 'repeater', an 'array' with config.zones, or 'modular'); `reorderable` only where there is a LIST to lock ('repeater', an 'array' with config.zones.repeatable, or 'modular' \u2014 a 'group' holds one item). preview keys must name real children, or the write is refused with the valid keys listed. An unknown key inside `ui` is a 400, not a silent strip. Read it back with get_content_model / get_page to confirm it landed. There is deliberately no `order`: field order is the array index \u2014 use add_field's `after` to insert."
+    "AUTHORING CHROME \u2014 how this field presents in the editor; never a delivery effect. `preview` slots name a CHILD FIELD KEY and must name real children, or the write is refused with the valid keys listed. `preview`/`layout` need a nesting field, `reorderable` needs a list, and an unknown key inside `ui` is a 400, not a silent strip. No `order`: field order is the array index \u2014 use `after`. Section 14 of bettercms://playbook/schema has each key and where it is legal."
   ),
   // ── G5: the four keys the backend field schema accepts that this whitelist stripped. ──
   fieldsetId: z.string().min(1).optional().describe(
@@ -2428,7 +2430,8 @@ var BRAND_KIT_NOTE = "`brandKit` is the project's brand kit: colors, typography,
 var MODEL_IF_MATCH_NOTE = "optimisticVersion from get_content_model. When sent, the update applies only if the model is still at that version; a 409 means someone changed it since \u2014 read it again and re-apply, never retry blindly. Omitted, the last write wins.";
 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 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, and nothing is rebuilt or delivered; URL folders (page folders) are set in the dashboard. Folders nest at most 4 levels deep (a page or collection may sit in a level-4 folder). Icons are lucide icon names, e.g. "folder", "file-text", "rows-3", "house" (a-z, 0-9 and dashes); null clears one. SYSTEM FOLDERS (CPO-129): "home:pages" (Other pages), "home:collections" (Shared) and "home:globals" (Settings) always exist, even when the document has no record for them. They close the sidebar, below the folders you make, and can never be moved or deleted (400 NAV_SYSTEM_FOLDER), but rename_folder and set_icon work on them and create their record on first use. TYPE PURITY: anything inside Other pages, at any depth, must be a page, and anything inside Shared must be a collection, and Settings holds NO pages or collections at all, because globals are not sidebar items (subfolders under Settings are allowed but stay empty). Any of these is 400 NAV_TYPE_MISMATCH. Your own folders hold either kind. ACCESS (CPO-131): Requires Admin or Developer access to CHANGE the structure, the same access as editing the schema; anyone who can read content can call get_content_structure. A 403 SCHEMA_ACCESS_REQUIRED means the person behind this connection is not an Admin or Developer: stop and tell the user, do not retry. ROOT PINS (CPO-132): folderId \'root\' pins a page or collection at the top level; null returns it to its home (Other pages / Shared). Pins sit above the folders, in their own order, and may be 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). KIND CHECK: an id is either a page or a collection, never both, and a custom folder holds either \u2014 so move_to_folder and set_icon VERIFY that the id really is the `kind` you named on this branch, and refuse a mismatch with 400 NAV_KIND_MISMATCH naming the kind to use; call it again with that kind, which also clears the wrong-kind entry. An id that resolves to nothing is allowed (it may exist on another branch) and the result says so. set_content_structure never refuses: it returns `warnings` and `kindMismatches`. get_content_structure marks such items `kindMismatch: true` and lists them in `summary.kindMismatches`. PAGE-BOUND MODELS (CPO-135): a page with fields has a content model bound to it. That model is NOT a collection \u2014 get_content_structure never lists it among collections or in the tree, and move_to_folder / set_icon / set_content_structure refuse it with 400 NAV_PAGE_BOUND_MODEL naming the owning page (\'This model belongs to the page "\u2026"; organise the page.\'). Organise the PAGE instead, by its page id. If a stored document still references one it appears in `summary.hiddenItems` with `boundToPageId`, and the next single write drops 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 icon 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 do work on them. TYPE PURITY (400 NAV_TYPE_MISMATCH): Other pages holds only pages at any depth, Shared only collections, and Settings neither \u2014 globals are not sidebar items. ACCESS: changing the structure needs Admin or Developer, the same as editing the schema; reading needs only content access. A 403 SCHEMA_ACCESS_REQUIRED means this connection is neither: stop and tell the user, do not retry. Pins sit above the folders, in their own order, and may be 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 model bound to it. That model is NOT a collection: it is 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.";
 function structureResult(d) {
   const message = d?.message;
   return ok(typeof message === "string" ? message : "Updated the Content structure.", d);
@@ -2522,7 +2525,7 @@ function authPrompt(err) {
 }
 var currentProject = new AsyncLocalStorage();
 var projectIdArg = z.string().min(1).optional().describe(
-  "only needed when your grant covers the whole WORKSPACE: the project to act on (from list_projects). A project-scoped key ignores it."
+  "target project id (from list_projects); only for a workspace-wide grant."
 );
 var withProjectId = (def) => ({
   ...def,
@@ -2532,6 +2535,60 @@ var withProjectId = (def) => ({
     return currentProject.run(project, () => 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",
+  // 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",
+  "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();
@@ -2586,7 +2643,7 @@ function buildToolDefs(deps) {
     ]).describe("block type; section/slider/tabs/columns nest child blocks"),
     id: z.string().min(1).describe("stable unique block id"),
     props: z.record(z.string(), z.unknown()).describe(
-      "per-type props: heading {text, level}; text/richtext {html} (NOT {text}); image {src, alt}; button {text, href}; spacer {height}; video {url}; form {formId}; component {componentId, overrides?}; navbar {links:[{label,href}], logo?, cta?}; footer {columns, copyright?}; section {children: block[]}; columns {columns: block[][], gap} \u2014 a column may NOT hold columns/section/slider/tabs; slider {slides:[{id,children}]}; tabs {tabs:[{id,label,children}]}; collection {cardComponentId?, detailComponentId?, titleField?, excerptField?, limit?, order?, emptyText?} \u2014 lists this page's published entries as cards, and renders ONE entry on /<page>/<entrySlug>"
+      "per-type props: heading {text, level}; text/richtext {html} (NOT {text}), and both also take level 1-6, rendering the html AS that <hN> with inline marks kept (one line of inline copy only) \u2014 use it for a title that carries a styled span; image {src, alt}; button {text, href}; spacer {height}; video {url}; form {formId}; component {componentId, overrides?}; navbar {links:[{label,href}], logo?, cta?}; footer {columns, copyright?}; section {children: block[]}; columns {columns: block[][], gap} \u2014 a column may NOT hold columns/section/slider/tabs; slider {slides:[{id,children}]}; tabs {tabs:[{id,label,children}]}; collection {cardComponentId?, detailComponentId?, titleField?, excerptField?, limit?, order?, emptyText?} \u2014 lists this page's published entries as cards, and renders ONE entry on /<page>/<entrySlug>"
     ),
     style: z.record(z.string(), z.unknown()).optional().describe(
       "design tokens: theme, bg (none|surface|muted|accent|dark|custom), bgCustom hex, paddingTop/paddingBottom/paddingSides px, contentWidth (narrow|default|wide|full), align, corner, shadow, borderTop/borderBottom. A real marketing band is a `section` block carrying bg + padding + contentWidth."
@@ -2748,8 +2805,11 @@ function buildToolDefs(deps) {
     ]),
     placeholder: z.string().optional(),
     helpText: z.string().optional().describe("hint shown under the control, muted"),
-    required: z.boolean().optional(),
+    required: z.boolean().optional().describe(
+      "an entry cannot be saved without a value \u2014 set it only where the site genuinely cannot render without one"
+    ),
     options: z.array(z.string()).optional().describe("choices when type is 'select', 'radio' or 'checkboxes'"),
+    optionValues: z.array(z.string()).optional().describe("what each choice SUBMITS, positionally paired with `options` \u2014 only where it differs from the label"),
     hidden: z.boolean().optional().describe("not rendered; pairs with defaultValue to capture context"),
     defaultValue: z.string().optional(),
     showIf: z.object({ field: z.string(), equals: z.string() }).optional().describe("show this field only when another field equals a value"),
@@ -3154,11 +3214,11 @@ function buildToolDefs(deps) {
         z.object({ formId: z.string().min(1), submissionId: z.string().min(1) }).shape,
         async (c, a) => ok("Deleted submission.", await data(c, "DELETE", `/management/forms/${s(a.formId)}/submissions/${s(a.submissionId)}`))
       ),
-      // ── Content structure: the Content sidebar's folders and icons (CPO-127 f) ──
+      // ── Content structure: the Content sidebar's folders and icons  ──
       def(
         "get_content_structure",
         "Get the Content sidebar structure",
-        `Read the Content sidebar's structure for the connected project: its folders, which pages and collections sit in each, and their icons. 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. ${STRUCTURE_NOTE}`,
         z.object({}).shape,
         async (c) => {
           const d = await data(c, "GET", `/management/content-structure`);
@@ -3182,7 +3242,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "set_content_structure",
         "Replace the Content sidebar structure",
-        `Replace the whole Content sidebar document in one write. Follow the structure standard (read ${STRUCTURE_PLAYBOOK_URI} first; suggest_content_structure returns a ready doc). Prefer the single-action tools (create_folder, rename_folder, move_to_folder, set_icon, delete_folder) for small changes; use this to lay out a full structure at once. Send the complete \`doc\` and the \`version\` get_content_structure returned (0 when the project has none yet). Validated exactly like the dashboard: unique folder ids, every parentId/folderId must be a folder in the doc, no cycles, depth at most 4, names 1-80 chars, lucide icon names. A 412 VERSION_CONFLICT means someone changed it since you read it: call get_content_structure again and re-apply your change. Returns the new version and a diff (folders added, removed, renamed or moved; items moved; icons changed). ${STRUCTURE_NOTE}`,
+        `Replace the whole Content sidebar document in one write. Follow the structure standard (read ${STRUCTURE_PLAYBOOK_URI} first; suggest_content_structure returns a ready doc). Send the complete \`doc\` and the \`version\` get_content_structure returned (0 when the project has none yet). Validated exactly like the dashboard: unique folder ids, every parentId/folderId a folder in the doc, no cycles, depth \u22644, names 1-80 chars, lucide icons. A 412 VERSION_CONFLICT means someone changed it since you read it: read again and re-apply. Returns the new version and a diff. ${STRUCTURE_FENCE}`,
         z.object({
           doc: z.object({
             schema: z.literal(1),
@@ -3208,7 +3268,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "create_folder",
         "Create a Content sidebar folder",
-        `Create a folder in the Content sidebar, at the top level or inside \`parentId\`, placed after what is already there. Returns the new \`folderId\`. Reads, applies and writes with the version check, retrying once on a conflict. ${STRUCTURE_NOTE}`,
+        `Create a folder in the Content sidebar, at the top level or inside \`parentId\`, placed after what is already there. Returns the new \`folderId\`. Reads, applies and writes with the version check, retrying once on a conflict. ${STRUCTURE_FENCE}`,
         z.object({
           name: z.string().min(1).describe("the folder's label, 1-80 chars"),
           parentId: z.string().min(1).optional().describe("optional parent folder id (from get_content_structure); omit it, or send 'root', for the top level"),
@@ -3219,7 +3279,7 @@ ${d.outline}` : "Proposed Content structure.", d);
       def(
         "rename_folder",
         "Rename a Content sidebar folder",
-        `Rename a Content sidebar folder. ${STRUCTURE_NOTE}`,
+        `Rename a Content sidebar folder. ${STRUCTURE_FENCE}`,
         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")
@@ -3229,9 +3289,11 @@ ${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_NOTE}`,
+        `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}`,
         z.object({
-          kind: z.enum(["page", "collection", "folder"]),
+          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."
+          ),
           id: z.string().min(1).describe("the page id, collection (content model) id, or folder id"),
           folderId: z.string().min(1).nullable().describe("target folder id; 'root' pins a page or collection at the top level (for a folder, 'root' is the top level); null moves it back to its home (Other pages, the Shared list, or the top level for a folder)")
         }).shape,
@@ -3270,9 +3332,11 @@ ${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_NOTE}`,
+        `Set or clear the sidebar icon of a page, a collection or a folder. ${STRUCTURE_FENCE}`,
         z.object({
-          kind: z.enum(["page", "collection", "folder"]),
+          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."
+          ),
           id: z.string().min(1).describe("the page id, collection (content model) id, or folder id"),
           icon: z.string().min(1).nullable().describe("lucide icon name, e.g. 'file-text'; null clears it")
         }).shape,
@@ -3281,7 +3345,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_NOTE}`,
+        `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}`,
         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))}`))
       ),
@@ -3483,7 +3547,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 conversion run, so the coverage meter can say WHY a path is not declared instead of only that it is not. Submit the receipt `npx @bettercms-ai/convert` wrote (`--receipt out.json`) for the SAME `briefDigest` get_conversion_brief { complete: true } returned: `{ briefDigest, receipt }`, where the receipt carries `paths: { declared, rewritten, alreadyDeclared, pending[{ route, scope, path, kind, file, reason, message, fix }] }`. `paths.declared` must equal rewritten + alreadyDeclared + pending.length, and each pending `reason` is one of the converter's own (IN_EXPRESSION, AMBIGUOUS_LITERAL, REPEATER_FIXED_LENGTH, PARSE_ERROR, \u2026) \u2014 a path with no receipt row simply reads `not-declared`. \u{1F534} A RECEIPT WITH PENDING PATHS IS A PROGRESS REPORT, NOT A FINISH LINE. The response answers `complete` and `pendingTotal`, and echoes the first 40 pending rows WITH their `fix` \u2014 `{ action, file, line, col?, snippet, why?, kind? }`, where `action` is one of `wrap-span` (wrap the literal in a `<span data-bcms-field=\u2026>`), `declare-attr` (add `data-bcms-field=\u2026` to the element at file:line), `bind-expression` (replace the expression with the framework's bcmsField helper), `declare-richtext` (bind the container with the richtext helper \u2014 and when it carries `kind: document` the container is the ONE element wrapping every block of a Body, never the paragraph holding its first block), `bind-data` (the literal comes from the data file at file:line \u2014 bind that field) or `manual` (with a one-sentence `why`). Apply every fix in the source, rerun the codemod, resubmit. `complete: true` is the only receipt that ends a conversion \u2014 do not report a site converted on anything less. It is a RECORD, not a release: it changes nothing about the site, and the meter picks it up on the next get_binding_report after the next deploy. A 404 `unknown-brief` means that digest was never issued here, so convert against a brief this project actually returned. \u{1F534} SUBMIT THE `--forms` RECEIPT TOO, AS A SECOND CALL. A run of `npx @bettercms-ai/convert --forms` writes a receipt whose `paths` are all zero and whose account is in a `forms` block (`{ wired, alreadyWired, pending[{ id, name, reason }], notes, wiredForms[{ id, file }] }`). Write it to its own file (`--receipt forms-receipt.json`) and submit it here under the same `briefDigest`: it is stored BESIDE the binding receipt and never touches coverage, and the next release reads `wiredForms` to say which component renders each form. Then read `forms.pending` and publish every form `forms.notes` names in the Forms tab. Requires artifact:write, the same authority as set_binding_mode; on a workspace-wide connection pass `projectId`.",
+        "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` wrote (`--receipt out.json`) for the SAME `briefDigest` get_conversion_brief { complete: true } returned: `{ briefDigest, receipt }`, where the receipt carries `paths: { declared, rewritten, alreadyDeclared, pending[{ route, scope, path, kind, file, reason, message, fix }] }`. `paths.declared` must equal rewritten + alreadyDeclared + pending.length, and each pending `reason` is one of the converter's own (IN_EXPRESSION, AMBIGUOUS_LITERAL, REPEATER_FIXED_LENGTH, PARSE_ERROR, \u2026) \u2014 a path with no receipt row simply reads `not-declared`. \u{1F534} A RECEIPT WITH PENDING PATHS IS A PROGRESS REPORT, NOT A FINISH LINE: The response answers `complete` and `pendingTotal`, and echoes the first 40 pending rows with their `fix` \u2014 `{ action, file, line, col?, snippet, why?, kind? }`. `action` is `wrap-span`, `declare-attr`, `bind-expression`, `declare-richtext`, `bind-data` or `manual`; each row's `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. `complete: true` is the only receipt that ends a conversion; do not report a site converted on less. It is a RECORD, not a release: it changes nothing about the site, and the meter picks it up on the next 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 `npx @bettercms-ai/convert --forms` run writes a receipt whose `paths` are all zero and whose account is in 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 read `forms.pending` and publish every form it names. Requires artifact:write, the same authority as set_binding_mode.",
         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.")
@@ -3719,8 +3783,8 @@ ${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?'. Every release scans the built HTML for the element that renders each CMS field value; this returns what that scan found, per slot: `mode` ('text-match' = bindings guessed from rendered text, 'declared' = the template declares them), `pagesInspected`, `bound` (elements carrying a binding), and `unmatched` \u2014 per page, each path with its kind and the reason it failed (not-declared / ambiguous-text / no-element). DEPLOY FIRST: before any release there is no report and this answers pages 0, mode null, refreshRequired true. `refreshReason` says which of two states that is: `never-generated` \u2014 no report was ever written for this slot, and only a release BetterCMS itself builds and serves writes one, so a HEADLESS site never gets one and redeploying the same way will not change it (verify that site by fetching it); `outdated` \u2014 a report exists in an older shape, and the next release rewrites it. It certifies exactly one thing \u2014 that every non-empty field of every page has SOME element carrying its path. It cannot see copy that was never modelled, so diff each route's visible text against its entry values yourself before calling a page done. `builtRoutes` lists the routes the live build has HTML for (null when unknown: runtime release, >500 routes, or a report older than this field). `canvas.lane` names the live-preview lane this build gives the editor \u2014 `bridge` (the build ships BcmsDraftBridge), `draft-route` (a node runtime rendering drafts server-side) or `none`, in which case get_next_steps carries the recipe (playbook section 11); null means the report predates the field. `unaddressable` counts visible text on the live site that no field owns \u2014 the one thing `unmatched` structurally cannot see, because it only ever speaks about fields that already exist. EVERY release measures it server-side on every inspected page: `{count, pages, measuredAt, routes:[{path, count, visible, buckets:[{tag, context, chars, nodes, samples}]}]}`, where `path` is the route (the empty string is the home page), `visible` its countable characters (ornaments, skip links and the platform badge excluded from both sides) and `buckets` where the unowned text is, biggest first. Anything over `count / visible > 0.02` is copy the CMS cannot see: 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 section 11 has the loop. An author turning the editor's Unbound text control on posts a bare count of text NODES for the route they opened (no `visible`, no buckets); those rows are reported only for a build the release never measured, never summed with the release's characters. `skipReasons` says why pages were not inspected (`no-html`, `route-cap`, `authored-content` = the singleton lane declined the project, so NO route of it has a page), and `coverage.error` = `nothing-bound` means not one element of this build carries a binding, so the percentage beside it describes a site this build is not. `unaddressable` is measured PER SLOT; on a promote-gated project pass slot:'current' to read the tree the editor frames. Pass `slot` ('current' or 'staging') to read the other tree; the default is the slot this project's releases land in.",
-        z.object({ slot: z.enum(["current", "staging"]).optional().describe("which release tree to read; defaults to the one this project deploys to") }).shape,
+        "The receipt for 'is this site actually EDITABLE?'. Every release scans the built HTML for the element that renders each CMS field value; this returns what that scan found, per slot: `mode` ('text-match' = bindings guessed from rendered text, 'declared' = the template declares them), what was bound, and `unmatched` \u2014 each path with the reason it failed (not-declared / ambiguous-text / no-element). DEPLOY FIRST: before any release there is no report (pages 0, mode null, refreshRequired true). `refreshReason` says which: `never-generated` \u2014 only a release BetterCMS builds and serves writes a report, so a HEADLESS site never gets one and redeploying will not change it (verify that site by fetching it); `outdated` \u2014 the next release rewrites it. It certifies one thing: every non-empty field has SOME element carrying its path. It cannot see copy that was never modelled, so diff each route's visible text against its entry values yourself before calling a page done. `builtRoutes` lists the routes the live build has HTML for, or null when it cannot say. `canvas.lane` names the live-preview lane this build gives the editor \u2014 `bridge`, `draft-route` or `none`, in which case get_next_steps carries the recipe (playbook section 11). `unaddressable` counts visible text on the live site that no field owns \u2014 the one thing `unmatched` structurally cannot see, because it only ever speaks about fields that already exist. EVERY release measures it server-side on every inspected page and the result names the routes, their countable characters and the buckets the unowned text sits in, biggest first. Anything over `count / visible > 0.02` is copy the CMS cannot see: 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 section 11 has the loop. `skipReasons` says why pages were not inspected; `coverage.error` = `nothing-bound` means not one element of this build carries a binding, so the percentage beside it describes a site this build is not.",
+        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.") }).shape,
         async (c, a) => ok("Binding report.", await data(c, "GET", `/management/projects/current/binding-report${q({ slot: a.slot })}`))
       ),
       def(
@@ -3757,13 +3821,13 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "componentize_sections",
         "Turn this site's derived sections into components",
-        "Turn this site's derived sections into components. CONFIRM WITH THE USER FIRST: show them get_componentize_plan's sections and say how many components it will create and which pages it will rewrite. It creates each proposed component as a DRAFT (its `sectionType` family, category 'section', placeable on any page) and replaces each page's DRAFT blocks with an ordered list of `component` instances \u2014 one per group, each carrying `props.bind: \"<groupKey>\"`, which points at the page field group that already holds the copy. So nothing is copied and nothing moves: the page keeps its `fields`, its values and its bindings, click-to-edit keeps working and the coverage meter does not change. Pass the plan's `digest`; a 409 `stale-plan` means the site changed since you read that plan, so read it again, show the user what changed and confirm again. Call it with `dryRun: true` first \u2014 same receipt, nothing written. Read its `components.wouldDuplicate` before applying: each id is an existing component of the same family this run would sit a NEW one beside, because reuse is by identity and slug, never by family. Place those by hand or accept the second component knowingly. Running it twice is safe: a group that already has a placement comes back in `sections.pending` as ALREADY_COMPONENTIZED and no second component is created. DRAFTS ONLY \u2014 an unpublished component renders as an EMPTY STRING on the live site, so publish_component each one and publish the pages before this reaches a visitor. Then run `npx @bettercms-ai/convert --componentize` in the repo so its templates render these sections from `pages[].blocks`. `copy` says WHO OWNS THE COPY. The default `bind` is the above: the words stay in the page's field group. `copy: \"instance\"` is the page-builder model \u2014 each placement takes that group's CURRENT draft values into its own `props.overrides` (a repeater becomes one table prop holding every row), records which page path each came from in `props.source`, and drops `props.bind`; the page's fields are KEPT and marked `origin: \"componentized\"`, so nothing is lost and the editor stops showing a second place to type the same words. Run it again and it converts nothing and duplicates nothing. `sections` narrows a run to named groupKeys (`hero`, `group-fast`); a key the plan does not list on the pages you named is refused as `unknown-section` rather than quietly doing nothing. Every component it CREATES is filed into a Component Group (the folders of the dashboard's Components tab): the one you name in `group` (found or created), else its section family \u2014 nav, header, footer or menu \u2192 Layout, an unnamed section \u2192 Sections, otherwise the family name (Hero, FAQ). A component it reuses keeps the Group it has; the receipt's `components.groups` lists the Groups it filed into.",
+        "Turn this site's derived sections into components. CONFIRM WITH THE USER FIRST: show them get_componentize_plan's sections and say how many components it will create and which pages it will rewrite. It creates each proposed component as a DRAFT and replaces each page's DRAFT blocks with an ordered list of `component` instances \u2014 one per group, each carrying `props.bind: \"<groupKey>\"`, which points at the page field group that already holds the copy. So nothing is copied and nothing moves: the page keeps its `fields`, its values and its bindings, click-to-edit keeps working and the coverage meter does not change. Pass the plan's `digest`; a 409 `stale-plan` means the site changed since you read that plan, so read it again, show the user what changed and confirm again. Read its `components.wouldDuplicate` before applying: each id is an existing component of the same family this run would sit a NEW one beside, because reuse is by identity and slug, never by family. Running it twice is safe: a group that already has a placement comes back in `sections.pending` as ALREADY_COMPONENTIZED and no second component is created. DRAFTS ONLY \u2014 an unpublished component renders as an EMPTY STRING on the live site, so publish_component each one and publish the pages before this reaches a visitor. Then run `npx @bettercms-ai/convert --componentize` in the repo so its templates render these sections from `pages[].blocks`. The default `bind` is the above: the words stay in the page's field group. `copy: \"instance\"` moves the words onto each placement and marks the page's fields `origin: \"componentized\"` \u2014 kept, never deleted (see `copy`). Every component it CREATES is filed into a Component Group (the folders of the dashboard's Components tab): the one you name in `group` (found or created), else its section family \u2014 nav, header, footer or menu \u2192 Layout, an unnamed section \u2192 Sections, otherwise the family name (Hero, FAQ). A component it reuses keeps the Group it has; the receipt's `components.groups` lists the Groups it filed into.",
         z.object({
           digest: z.string().min(1).describe("The `digest` get_componentize_plan returned. A different one is refused with 409 stale-plan."),
           pageIds: z.array(z.string().min(1)).optional().describe("Componentize only these pages (ids from the plan). Omit for every page the plan lists."),
           pages: z.array(z.string().min(1)).optional().describe("The same page filter under the name the dashboard uses. Unioned with pageIds; an EMPTY list is refused rather than treated as every page."),
           sections: z.array(z.string().min(1)).optional().describe("Act only on these section groupKeys (from the plan). Every other section on the page keeps the placement it already has."),
-          copy: z.enum(["bind", "instance"]).optional().describe("Who owns each section's copy: 'bind' (default) leaves it in the page fields; 'instance' moves it onto the placement and marks those fields origin: componentized."),
+          copy: z.enum(["bind", "instance"]).optional().describe("Who owns each section's copy. 'bind' (default) leaves it in the page fields. 'instance' is the page-builder model: each placement takes that group's CURRENT draft values into its own `props.overrides` (a repeater becomes one table prop holding every row), records which page path each came from in `props.source`, and drops `props.bind`; the page's fields are KEPT and marked `origin: \"componentized\"`, so nothing is lost and the editor stops showing a second place to type the same words."),
           dryRun: z.boolean().optional().describe("true = return the receipt without writing anything. Do this first."),
           group: z.string().min(1).max(100).optional().describe("File the components this run creates into this Component Group (by NAME; created when missing). Omit to file each under its section family.")
         }).shape,
@@ -3801,7 +3865,7 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "generate_pages_from_dataset",
         "Generate many pages from a dataset",
-        "Turn a dataset into many pages at once (programmatic SEO from a keyword list, or ABM pages from an account list). Give a template `pageId`, a `mapping` (contentModelId, a slugTemplate like 'for-{{company}}', and per-field values that are either a column name or {ai:{prompt}}), and `rows`. ALWAYS call with dryRun:true first and show the sample \u2014 a real run parks for approval and must be released with approve_ai_job.",
+        "Turn a dataset into many pages at once (programmatic SEO from a keyword list, or ABM pages from an account list). Give a template `pageId`, a `mapping` (contentModelId, a slugTemplate like 'for-{{company}}', and per-field values that are either a column name or {ai:{prompt}}), and `rows`. For an ABM campaign set `mapping.campaign.id` and the run fans out across every page that campaign owns, returning one job id per page in `jobIds`. ALWAYS call with dryRun:true first and show the sample \u2014 a real run parks for approval and must be released with approve_ai_job.",
         z.object({
           pageId: z.string().min(1),
           mapping: z.record(z.string(), z.unknown()),
@@ -3810,6 +3874,121 @@ ${res.warnings.join("\n")}` : summary, res.data);
         }).shape,
         async (c, a) => ok("Generation queued.", await data(c, "POST", `/management/bulk/generate`, { pageId: a.pageId, mapping: a.mapping, rows: a.rows, dryRun: a.dryRun }))
       ),
+      def(
+        "research_account",
+        "Research one account",
+        "Read one company's public site into a cited brief the page generator can use: what they do, who they sell to, what they say is hard, with a source URL on every fact. `lite` is one fetch and costs nothing extra; `deep` searches the web, costs 3 credits and is capped per day. A brief less than 30 days old is returned from cache for free. Company-scoped by design: it never stores a person, an email or a job title.",
+        z.object({
+          campaignId: z.string().min(1),
+          domain: z.string().min(1),
+          name: z.string().optional(),
+          mode: z.enum(["lite", "deep"]).optional(),
+          force: z.boolean().optional()
+        }).shape,
+        async (c, a) => ok("Account brief.", await data(c, "POST", `/management/campaigns/research`, { campaignId: a.campaignId, domain: a.domain, name: a.name, mode: a.mode, force: a.force }))
+      ),
+      def(
+        "claim_abm_task",
+        "Claim an account to research",
+        "Claim the next account of a campaign that is waiting for YOU to research it. Returns the account, a `taskId` and a `leaseToken` good for ten minutes; `null` means there is nothing left and your loop is done. Research the company however you like, then call complete_abm_task with the brief \u2014 or fail_abm_task if you cannot. Never store a person, an email or a job title: the brief is refused if you do.",
+        z.object({ campaignId: z.string().min(1), agentId: z.string().optional() }).shape,
+        async (c, a) => ok("Claimed task.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/tasks/claim`, { agentId: a.agentId }))
+      ),
+      def(
+        "complete_abm_task",
+        "Hand back an account brief",
+        "Hand back the brief for a task you claimed. `brief` is {name, domain, industry?, size?, painPoint?, summary?, facts:[{text, sourceUrl}], logo?, brandColors?} and NOTHING else \u2014 an unknown key is refused with brief_invalid and the path. Every fact needs the URL it came from. When the campaign's last task is done the page generation starts on its own.",
+        z.object({
+          campaignId: z.string().min(1),
+          taskId: z.string().min(1),
+          leaseToken: z.string().min(1),
+          brief: z.record(z.string(), z.unknown())
+        }).shape,
+        async (c, a) => ok("Brief accepted.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/tasks/${s(a.taskId)}/complete`, { leaseToken: a.leaseToken, brief: a.brief }))
+      ),
+      def(
+        "fail_abm_task",
+        "Give an account task back",
+        "Give a claimed task back when you cannot research the account \u2014 the site is down, there is nothing public to read, the domain is wrong. The page is still written, from the dataset alone, and says so.",
+        z.object({
+          campaignId: z.string().min(1),
+          taskId: z.string().min(1),
+          leaseToken: z.string().min(1),
+          reason: z.string().optional()
+        }).shape,
+        async (c, a) => ok("Task returned.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/tasks/${s(a.taskId)}/fail`, { leaseToken: a.leaseToken, reason: a.reason }))
+      ),
+      def(
+        "get_campaign_review",
+        "Review a campaign's pages",
+        "The campaign's generated pages, SORTED BY DOUBT \u2014 flagged first, then least confident. Each row carries its flags (`unsupported_claim:headline` and the like), the claims the model said it made, which fields it wrote, and a preview link for drafts. `filter:'flagged'` is the review queue; `sample:5` is the first look at a big run; `filter:'failed'` lists the rows that produced no page at all and why.",
+        z.object({
+          campaignId: z.string().min(1),
+          filter: z.enum(["all", "flagged", "pending", "approved", "rejected", "low_confidence", "failed"]).optional(),
+          sample: z.number().optional(),
+          pageId: z.string().optional(),
+          runId: z.string().optional(),
+          cursor: z.string().optional(),
+          limit: z.number().optional()
+        }).shape,
+        async (c, a) => ok("Campaign review.", await data(c, "GET", `/management/campaigns/${s(a.campaignId)}/review${q({ filter: a.filter, sample: a.sample, pageId: a.pageId, runId: a.runId, cursor: a.cursor, limit: a.limit })}`))
+      ),
+      def(
+        "regenerate_entry",
+        "Rewrite one account's page",
+        "Rewrite ONE account's page, optionally with an instruction ('lead with the integration story') and optionally only certain fields. Costs one credit and writes a DRAFT \u2014 a published page shows unpublished changes until someone publishes it again. Re-runs from the original spreadsheet row, not from the last answer, so repeated regenerates do not drift.",
+        z.object({
+          campaignId: z.string().min(1),
+          entryId: z.string().min(1),
+          instruction: z.string().optional(),
+          fields: z.array(z.string()).optional()
+        }).shape,
+        async (c, a) => ok("Regeneration queued.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/entries/${s(a.entryId)}/regenerate`, { instruction: a.instruction, fields: a.fields }))
+      ),
+      def(
+        "approve_campaign_entries",
+        "Mark campaign pages reviewed",
+        "Mark campaign pages reviewed. `entryIds:'all_unflagged'` clears every page with nothing wrong with it, which is most of them; a FLAGGED page must be named explicitly, because approving one is a person saying they checked the claim. Approving does not publish \u2014 publish_campaign does, and it refuses pages that are still flagged.",
+        z.object({
+          campaignId: z.string().min(1),
+          entryIds: z.union([z.array(z.string()), z.literal("all_unflagged")]),
+          status: z.enum(["approved", "rejected"]),
+          note: z.string().optional()
+        }).shape,
+        async (c, a) => ok("Entries reviewed.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/entries/review`, { entryIds: a.entryIds, status: a.status, note: a.note }))
+      ),
+      def(
+        "publish_campaign",
+        "Publish a campaign",
+        "Put a campaign's pages on the internet, or schedule them. `confirm: true` is REQUIRED \u2014 this is the one action in the ABM lane that a human, not you, decides. It REFUSES with `entry_flagged` if any page still carries an unchecked claim (call get_campaign_review and approve them first) and with `blueprint_missing_disclaimer` if a campaign page has lost its 'not affiliated with' band. Pages somebody rejected are skipped and counted.",
+        z.object({
+          campaignId: z.string().min(1),
+          scheduledAt: z.string().optional(),
+          unpublishAt: z.string().optional(),
+          confirm: z.boolean()
+        }).shape,
+        async (c, a) => ok("Campaign publish queued.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/publish`, { scheduledAt: a.scheduledAt, unpublishAt: a.unpublishAt, confirm: a.confirm }))
+      ),
+      def(
+        "get_campaign_share_link",
+        "Make a share link",
+        "Make a link a rep can send before the pages are published. `scope:'campaign'` opens the whole account index; `scope:'account'` with an `externalKey` (the account's domain) opens exactly that account's pages and 404s on anyone else's. At most 14 days, revocable, rate-limited and noindex. The link's `uses` is how a rep sees Not sent / Sent / Visited.",
+        z.object({
+          campaignId: z.string().min(1),
+          scope: z.enum(["campaign", "account"]).optional(),
+          externalKey: z.string().optional(),
+          expiresIn: z.string().optional(),
+          label: z.string().optional()
+        }).shape,
+        async (c, a) => ok("Share link.", await data(c, "POST", `/management/campaigns/${s(a.campaignId)}/share-links`, { scope: a.scope, externalKey: a.externalKey, expiresIn: a.expiresIn, label: a.label }))
+      ),
+      def(
+        "revoke_campaign_share_link",
+        "Withdraw a share link",
+        "Withdraw ONE share link by its `jti`, leaving every other link to the same campaign working. The link then answers 404. Safe to call twice.",
+        z.object({ campaignId: z.string().min(1), jti: z.string().min(1) }).shape,
+        async (c, a) => ok("Share link revoked.", await data(c, "DELETE", `/management/campaigns/${s(a.campaignId)}/share-links/${s(a.jti)}`))
+      ),
       def(
         "list_ai_jobs",
         "List bulk jobs",
@@ -3820,7 +3999,7 @@ ${res.warnings.join("\n")}` : summary, res.data);
       def(
         "get_ai_job",
         "Get a bulk job",
-        "One bulk job \u2014 status, rows processed, rows created, conflicts, and the approval plan if it is still parked.",
+        "One bulk job \u2014 its `type` (generate, seo, rename, migrate, publish, unpublish, research), status, rows processed, rows created, conflicts, and the approval plan if it is still parked. `rowResults` is the per-row ledger: every row that FAILED or was skipped, with a reason code, which is the only place \u201C20 rows in, 18 pages out\u201D is explained. `summary` splits a rerun into added / updated / unchanged, and `campaignId` / `collectionSlug` say which campaign and collection the pages landed in.",
         z.object({ jobId: z.string().min(1) }).shape,
         async (c, a) => ok("Bulk job.", await data(c, "GET", `/management/bulk/jobs/${s(a.jobId)}`))
       ),
@@ -4477,7 +4656,7 @@ ${notes.join("\n")}` : summary, created);
       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 whenever you are making more than three: a whole-site componentize run (playbook \xA712) is dozens, and one call each spends the turn on plumbing. 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. " + SECTION_DOCTRINE,
+        description: "Create up to 50 components in ONE call \u2014 the same input as create_component, once per item. Prefer it over create_component whenever you are making more than three: a whole-site componentize run (playbook \xA712) is dozens, and one call each spends the turn on plumbing. 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: inside a component only the leaves a declared prop TARGETS are click-to-edit, and copy no prop points at is reachable neither from the canvas nor from the dock. A page is composed of SECTIONS; the full doctrine is in the bettercms://playbook/schema resource, \xA712.",
         inputSchema: createComponentsInput.shape
       },
       handler: guard(
@@ -4538,7 +4717,7 @@ ${notes.join("\n")}` : summary, created);
       name: "compose_pages",
       config: {
         title: "Set many pages' block composition in one call",
-        description: "Give up to 50 pages their block composition in ONE call \u2014 the same write as update_page's `blockJson`, once per item, and it REPLACES each page's whole block array. Address a page by `pageId` or by `slug`. Each item reports `{ ok, pageId, slug, error }` and a failure does not stop the run. BEFORE writing anything it reads this project's component catalogue once and REFUSES any item placing a componentId the project does not have \u2014 that page would render the missing sections as empty strings with no error anywhere, which is the single hardest failure on this platform to trace back. Writes DRAFTS: publish each page with update_page status:'published' afterwards. " + SECTION_DOCTRINE,
+        description: "Give up to 50 pages their block composition in ONE call \u2014 the same write as update_page's `blockJson`, once per item, and it REPLACES each page's whole block array. Address a page by `pageId` or by `slug`. Each item reports `{ ok, pageId, slug, error }` and a failure does not stop the run. BEFORE writing anything it reads this project's component catalogue once and REFUSES any item placing a componentId the project does not have \u2014 that page would render the missing sections as empty strings with no error anywhere, which is the single hardest failure on this platform to trace back. Writes DRAFTS: publish each page with update_page status:'published' afterwards. A page is composed of SECTIONS: a recurring band is a component with a `sectionType`, a one-off band is a `section` block whose `props.children` hold its blocks \u2014 never loose top-level heading/text/image blocks, which no editor can move, name or swap as a unit. The full doctrine is in the bettercms://playbook/schema resource, \xA712.",
         inputSchema: composePagesInput.shape
       },
       handler: guard(
@@ -4844,7 +5023,10 @@ ${lines.join("\n")}`, found);
     // through the client's request plumbing — no bespoke SDK method per endpoint.
     ...lifecycleTools()
   ];
-  return defs.map(withProjectId);
+  return [
+    ...defs.filter((d) => !LISTING_TAIL.has(d.name)),
+    ...defs.filter((d) => LISTING_TAIL.has(d.name))
+  ].map(withProjectId);
 }
 function registerTools(server, deps) {
   const withElicit = {
@@ -5874,16 +6056,31 @@ End-to-end authoring from a repo or a brief. Confirm-first at every stage.
    apply via \`set_page_content\` / \`create_content_entry\` / \`update_content_entry\`.
 3. **SEO** \u2014 run the SEO flow to fill metaTitle/metaDescription for each page.
 Never invent brand facts \u2014 ask the user for anything the repo/brief doesn't state.`;
-var LANDING_PAGES_FLOW = `### Generate landing pages (programmatic SEO / ABM) \u2192 \`write_content\` + \`create_content_entry\` + \`generate_seo_meta\`
+var LANDING_PAGES_FLOW = `### Generate landing pages (programmatic SEO / ABM) \u2192 \`generate_pages_from_dataset\`
 Spin up many pages sharing one template, each personalized per row (company, keyword, persona).
-1. **Template** \u2014 ensure a dynamic page or content model exists for the template
-   (\`create_page\` pageType 'dynamic' / \`create_content_model\`); its fields are the per-page slots.
-2. **Dataset** \u2014 get the list of targets from the user (rows of variables, e.g. company + industry).
-3. **Per row (loop)** \u2014 draft each slot with \`write_content\` (the row's variables as the brief/
-   \`context\`), pick a unique slug, then \`create_content_entry\` { contentModelId, data, slug, status }.
-   Add SEO with \`generate_seo_meta\` on the drafted copy and store it on the entry.
-Confirm the first 1\u20132 rows with the user before generating the rest. For hundreds of rows,
-the dashboard AI Page Builder bulk-imports a CSV \u2014 mention it.`;
+
+For an ABM campaign \u2014 a page per NAMED COMPANY \u2014 the whole flow is eight steps, in this order:
+1. **Research** \u2014 \`research_account\` per account, or set \`mapping.campaign.research\` and let the
+   run do it ('lite' reads the company's own site, 'deep' searches the web, 'agent' hands the work
+   to YOU through \`claim_abm_task\` / \`complete_abm_task\`).
+2. **Generate** \u2014 \`generate_pages_from_dataset\` with \`mapping.campaign = { id, research,
+   externalKeyColumn: 'domain' }\`. It fans out across every page the campaign owns and parks for
+   approval. Re-running the same export UPDATES each account's page rather than duplicating it.
+3. **Approve the job** \u2014 \`approve_ai_job\`, only once the user has said yes.
+4. **Review** \u2014 \`get_campaign_review\` with \`sample: 5\`, then \`filter: 'flagged'\`. A flag reads
+   \`unsupported_claim:headline\`: a figure that is in none of the account's own facts, so the field
+   fell back to the blueprint's copy. \`filter: 'failed'\` lists rows that produced no page at all.
+5. **Regenerate** \u2014 \`regenerate_entry\` with an instruction, one row at a time.
+6. **Approve entries** \u2014 \`approve_campaign_entries\`; \`'all_unflagged'\` clears the rest in one call.
+   A FLAGGED page must be named explicitly: approving one says a person checked the claim.
+7. **Publish** \u2014 \`publish_campaign\` with \`confirm: true\`. It refuses \`entry_flagged\` while any
+   page carries an unresolved flag, and \`blueprint_missing_disclaimer\` if a page has lost its
+   "not affiliated with" band. The user decides this step, never you.
+8. **Share** \u2014 \`get_campaign_share_link\` for a link a rep can send before publishing.
+
+For a plain programmatic-SEO run (a page per keyword, no named companies) the same tool works
+with no \`campaign\`, and \`write_content\` + \`create_content_entry\` per row is still fine for a
+handful. ALWAYS dry-run first and show the sample.`;
 var SEO_FLOW = `### Optimize SEO \u2192 \`generate_seo_meta\` + the page/entry update tools
 Fill or refresh SEO metadata across the site.
 1. **Target** \u2014 pick the pages/entries (\`list_pages\` / \`list_content_entries\`); confirm scope with the user.
@@ -6167,7 +6364,7 @@ Confirm each stage with the user before writing. On 401/403, the MCP key needs (
     "generate_landing_pages",
     {
       title: "Generate landing pages (programmatic SEO / ABM)",
-      description: "Spin up many personalized landing pages from one template + a dataset, drafting each page's copy with write_content and SEO with generate_seo_meta.",
+      description: "Spin up many personalized landing pages from one template + a dataset. For ABM (a page per named company) this is the research -> generate -> review -> approve -> publish -> share order.",
       argsSchema: {
         request: z2.string().optional().describe("the campaign, e.g. 'a page per target company for our ABM push'")
       }