@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/mcp/tools/brief.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Brief domain — read + write tools.
+ *
+ * Two tools, workflow-shaped:
+ *
+ *   - `brief_inspect` (read) discriminates on `verb` so a single entry
+ *     point covers list-briefs, get-brief-by-id, list/get-brief-types,
+ *     list-todos (tenant-wide or per-brief), and list-comments.
+ *   - `brief_manage` (write) discriminates on `resource` + `verb`:
+ *     `brief-type` create/update/delete, `brief` set-status/delete, and
+ *     `comment` create. Brief-type writes verified 2026-05-15 against the
+ *     agents tenant; brief delete uses the verified SDK `deleteBrief`;
+ *     comment create is wired UNVERIFIED (best-guess body).
+ */
+import type { McpRegistry } from "../registry";
+export declare const registerBriefTools: (registry: McpRegistry) => void;

package/dist/mcp/tools/brief.js

@@ -0,0 +1,388 @@
+"use strict";
+/**
+ * Brief domain — read + write tools.
+ *
+ * Two tools, workflow-shaped:
+ *
+ *   - `brief_inspect` (read) discriminates on `verb` so a single entry
+ *     point covers list-briefs, get-brief-by-id, list/get-brief-types,
+ *     list-todos (tenant-wide or per-brief), and list-comments.
+ *   - `brief_manage` (write) discriminates on `resource` + `verb`:
+ *     `brief-type` create/update/delete, `brief` set-status/delete, and
+ *     `comment` create. Brief-type writes verified 2026-05-15 against the
+ *     agents tenant; brief delete uses the verified SDK `deleteBrief`;
+ *     comment create is wired UNVERIFIED (best-guess body).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBriefTools = void 0;
+const zod_1 = require("zod");
+const tasks_1 = require("../../brief/tasks");
+const errors_1 = require("../../shared/errors");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const baseTaskOptions = (config, envName, overrides = {}) => ({
+    config,
+    environmentName: envName,
+    quiet: true,
+    json: false,
+    ...overrides,
+});
+const registerBriefTools = (registry) => {
+    registry.registerTool({
+        name: "brief_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.brief_inspect,
+        auth: "read",
+        annotations: {
+            title: "Inspect Sitecore Brief content-ops resources",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            verb: zod_1.z
+                .enum(["list", "show", "types", "type", "todos", "comments"])
+                .describe("Which read operation to run: list (briefs), show (one brief), types (list brief schemas), type (one brief schema by id), todos, comments."),
+            briefId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Brief UUID. Required for verb='show'. Optional filter for verb='todos' and verb='comments'."),
+            briefTypeId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Brief type UUID. Required for verb='type'."),
+            locale: zod_1.z.string().optional().describe("Locale filter for verb='list' — e.g. 'en-us'."),
+            assignees: zod_1.z.boolean().optional().describe("Expand assignee metadata for verb='todos'."),
+            limit: zod_1.z
+                .number()
+                .int()
+                .positive()
+                .max(500)
+                .optional()
+                .describe("Page size for list-style verbs (default: server choice)."),
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const taskOpts = baseTaskOptions(context.configPath, input.environmentName ?? context.envName);
+            switch (input.verb) {
+                case "list": {
+                    const result = await (0, tasks_1.runBriefList)({
+                        ...taskOpts,
+                        ...(input.limit !== undefined && { limit: input.limit }),
+                        ...(input.locale !== undefined && { locale: input.locale }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${result.totalCount} brief(s) in tenant${result.data.length < result.totalCount ? ` (showing ${result.data.length})` : ""}.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "show": {
+                    if (!input.briefId) {
+                        throw (0, errors_1.createScaiError)("verb='show' requires `briefId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefShow)({
+                        ...taskOpts,
+                        briefId: input.briefId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Brief ${result.id}: '${result.name}' (${result.status}, ${result.tasks.length} to-do(s), ${result.comments.length} comment(s)).`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "types": {
+                    const result = await (0, tasks_1.runBriefTypes)(taskOpts);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${result.totalCount} brief type(s): ${result.data.map((t) => t.name).join(", ") || "(none)"}.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "type": {
+                    if (!input.briefTypeId) {
+                        throw (0, errors_1.createScaiError)("verb='type' requires `briefTypeId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefTypeGet)({
+                        ...taskOpts,
+                        briefTypeId: input.briefTypeId,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Brief type ${result.id}: '${result.name}' (${result.fields.length} field(s)).`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "todos": {
+                    const result = await (0, tasks_1.runBriefTodosList)({
+                        ...taskOpts,
+                        ...(input.briefId !== undefined && { briefId: input.briefId }),
+                        ...(input.assignees !== undefined && { assignees: input.assignees }),
+                        ...(input.limit !== undefined && { limit: input.limit }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: input.briefId
+                                    ? `${result.totalCount} to-do(s) on brief ${input.briefId}.`
+                                    : `${result.totalCount} to-do(s) tenant-wide.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+                case "comments": {
+                    const result = await (0, tasks_1.runBriefCommentsList)({
+                        ...taskOpts,
+                        ...(input.briefId !== undefined && { briefId: input.briefId }),
+                        ...(input.limit !== undefined && { limit: input.limit }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: input.briefId
+                                    ? `${result.totalCount} comment(s) on brief ${input.briefId}.`
+                                    : `${result.totalCount} comment(s) tenant-wide.`,
+                            },
+                        ],
+                        structuredContent: { verb: input.verb, result },
+                    };
+                }
+            }
+        },
+    });
+    registry.registerTool({
+        name: "brief_manage",
+        description: descriptions_1.TOOL_DESCRIPTIONS.brief_manage,
+        auth: "write",
+        annotations: {
+            title: "Manage Sitecore Content Operations Brief resources (brief types)",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            resource: zod_1.z
+                .enum(["brief-type", "brief", "comment"])
+                .describe("Which Brief resource the verb targets. 'brief-type' supports create/update/delete; 'brief' supports set-status/delete; 'comment' supports create."),
+            verb: zod_1.z
+                .enum(["create", "update", "delete", "set-status"])
+                .describe("Mutation verb. brief-type: create (POST), update (PUT-replace), delete (irreversible). brief: set-status, delete. comment: create."),
+            briefTypeId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Brief type UUID. Required for brief-type verb='update' and verb='delete'."),
+            briefId: zod_1.z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Brief UUID. Required for resource='brief' verb='set-status'."),
+            status: zod_1.z
+                .enum(["Draft", "InReview", "Approved", "Canceled", "Archived"])
+                .optional()
+                .describe("Target brief status for verb='set-status'. Wire form — 'InReview' is the 'In Review' UI label. A brief must leave 'Draft' before it can be linked to a campaign."),
+            commentText: zod_1.z
+                .string()
+                .optional()
+                .describe("Comment text. Required for resource='comment' verb='create'."),
+            body: zod_1.z
+                .object({
+                name: zod_1.z
+                    .string()
+                    .regex(/^[A-Za-z][A-Za-z0-9_]*$/, "Must start with a letter and contain only letters, digits, or underscores."),
+                label: zod_1.z
+                    .record(zod_1.z.string(), zod_1.z.string())
+                    .describe("Localized label, keyed by BCP-47-ish locale (e.g. en-us)."),
+                description: zod_1.z.string(),
+                icon: zod_1.z.string().describe("mdi icon codepoint name."),
+                iconColor: zod_1.z.string().describe("Hex or named color used by the brief authoring UI."),
+                fields: zod_1.z
+                    .array(zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()))
+                    .describe("Field definitions (RichText | DateTime | Timeline | Budget). Use brief_inspect verb='type' on an existing type for a worked example."),
+            })
+                .optional()
+                .describe("Full BriefType body for verb='create' or verb='update'. Required on writes; ignored on delete."),
+            ...common_1.environmentBindingShape,
+            ...common_1.allowWriteShape,
+            ...common_1.whatIfShape,
+        },
+        handler: async (input, context) => {
+            const taskOpts = baseTaskOptions(context.configPath, input.environmentName ?? context.envName);
+            const whatIf = input.whatIf;
+            if (input.resource === "brief") {
+                if (input.verb === "set-status") {
+                    if (!input.briefId) {
+                        throw (0, errors_1.createScaiError)("verb='set-status' requires `briefId`.", "INPUT_INVALID");
+                    }
+                    if (!input.status) {
+                        throw (0, errors_1.createScaiError)("verb='set-status' requires `status`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefSetStatus)({
+                        ...taskOpts,
+                        briefId: input.briefId,
+                        status: input.status,
+                        whatIf,
+                    });
+                    const isPlan = "plan" in result;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: isPlan
+                                    ? `Plan: set brief ${input.briefId} status to '${input.status}'.`
+                                    : `Brief ${input.briefId} status set to '${input.status}'.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+                if (input.verb === "delete") {
+                    if (!input.briefId) {
+                        throw (0, errors_1.createScaiError)("verb='delete' on resource='brief' requires `briefId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefDelete)({
+                        ...taskOpts,
+                        briefId: input.briefId,
+                        whatIf,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result.deleted
+                                    ? `Deleted brief ${input.briefId}.`
+                                    : `Plan: delete brief ${input.briefId}.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+                throw (0, errors_1.createScaiError)("resource='brief' supports verb='set-status' and verb='delete'.", "INPUT_INVALID");
+            }
+            if (input.resource === "comment") {
+                if (input.verb !== "create") {
+                    throw (0, errors_1.createScaiError)("resource='comment' supports only verb='create'.", "INPUT_INVALID");
+                }
+                if (!input.briefId) {
+                    throw (0, errors_1.createScaiError)("verb='create' on resource='comment' requires `briefId`.", "INPUT_INVALID");
+                }
+                if (!input.commentText) {
+                    throw (0, errors_1.createScaiError)("verb='create' on resource='comment' requires `commentText`.", "INPUT_INVALID");
+                }
+                const result = await (0, tasks_1.runBriefCommentAdd)({
+                    ...taskOpts,
+                    briefId: input.briefId,
+                    text: input.commentText,
+                    whatIf,
+                });
+                const isPlan = "plan" in result;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: isPlan
+                                ? `Plan: post a comment to brief ${input.briefId}.`
+                                : `Posted a comment to brief ${input.briefId}.`,
+                        },
+                    ],
+                    structuredContent: { resource: input.resource, verb: input.verb, result },
+                };
+            }
+            if (input.verb === "set-status") {
+                throw (0, errors_1.createScaiError)("verb='set-status' is only valid for resource='brief'.", "INPUT_INVALID");
+            }
+            switch (input.verb) {
+                case "create": {
+                    if (!input.body) {
+                        throw (0, errors_1.createScaiError)("verb='create' requires `body`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefTypeCreate)({
+                        ...taskOpts,
+                        input: input.body,
+                        whatIf,
+                    });
+                    const isPlan = "plan" in result;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: isPlan
+                                    ? `Plan: create brief type '${input.body.name}'.`
+                                    : `Created brief type '${input.body.name}'.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+                case "update": {
+                    if (!input.briefTypeId) {
+                        throw (0, errors_1.createScaiError)("verb='update' requires `briefTypeId`.", "INPUT_INVALID");
+                    }
+                    if (!input.body) {
+                        throw (0, errors_1.createScaiError)("verb='update' requires `body`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefTypeUpdate)({
+                        ...taskOpts,
+                        briefTypeId: input.briefTypeId,
+                        input: input.body,
+                        whatIf,
+                    });
+                    const isPlan = "plan" in result;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: isPlan
+                                    ? `Plan: PUT-replace brief type ${input.briefTypeId}.`
+                                    : `Updated brief type ${input.briefTypeId}.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+                case "delete": {
+                    if (!input.briefTypeId) {
+                        throw (0, errors_1.createScaiError)("verb='delete' requires `briefTypeId`.", "INPUT_INVALID");
+                    }
+                    const result = await (0, tasks_1.runBriefTypeDelete)({
+                        ...taskOpts,
+                        briefTypeId: input.briefTypeId,
+                        whatIf,
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: result.deleted
+                                    ? `Deleted brief type ${input.briefTypeId}.`
+                                    : `Plan: delete brief type ${input.briefTypeId}.`,
+                            },
+                        ],
+                        structuredContent: { resource: input.resource, verb: input.verb, result },
+                    };
+                }
+            }
+        },
+    });
+};
+exports.registerBriefTools = registerBriefTools;

package/dist/mcp/tools/browse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `content_browse` — read-only content-tree browse.
+ *
+ * Enumerates the items under a path (bounded depth) so an agent can see
+ * "what is under here" in one call. The thin MCP wrapper over
+ * `runContentBrowse` (`@/hygiene/tasks/browse`).
+ */
+import type { McpRegistry } from "../registry";
+export declare const registerBrowseTools: (registry: McpRegistry) => void;

package/dist/mcp/tools/browse.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * `content_browse` — read-only content-tree browse.
+ *
+ * Enumerates the items under a path (bounded depth) so an agent can see
+ * "what is under here" in one call. The thin MCP wrapper over
+ * `runContentBrowse` (`@/hygiene/tasks/browse`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBrowseTools = void 0;
+const zod_1 = require("zod");
+const browse_1 = require("../../hygiene/tasks/browse");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const registerBrowseTools = (registry) => {
+    registry.registerTool({
+        name: "content_browse",
+        description: descriptions_1.TOOL_DESCRIPTIONS.content_browse,
+        auth: "read",
+        annotations: {
+            title: "Browse the content tree",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            path: zod_1.z
+                .string()
+                .min(1)
+                .describe("Content-tree path to browse, e.g. /sitecore/templates/Project."),
+            depth: zod_1.z
+                .number()
+                .int()
+                .min(1)
+                .max(browse_1.MAX_BROWSE_DEPTH)
+                .default(1)
+                .describe(`Recursion depth — 1 is direct children only (max ${browse_1.MAX_BROWSE_DEPTH}).`),
+            ...common_1.environmentBindingShape,
+        },
+        handler: async (input, context) => {
+            const result = await (0, browse_1.runContentBrowse)({
+                config: context.configPath,
+                environmentName: input.environmentName ?? context.envName,
+                path: input.path,
+                depth: input.depth,
+            });
+            const text = result.totalCount === 0
+                ? `No items under '${result.path}'.`
+                : `${result.totalCount} item(s) under '${result.path}' (depth ${result.depth}).`;
+            return {
+                content: [{ type: "text", text }],
+                structuredContent: result,
+            };
+        },
+    });
+};
+exports.registerBrowseTools = registerBrowseTools;

package/dist/mcp/tools/campaign-recipe.d.ts

@@ -0,0 +1,2 @@
+import type { McpRegistry } from "../registry";
+export declare const registerCampaignRecipeTools: (registry: McpRegistry) => void;

package/dist/mcp/tools/campaign-recipe.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCampaignRecipeTools = void 0;
+/**
+ * Campaign recipe surface — the MCP projection of the `campaign` recipe
+ * kind. Two workflow-shaped tools:
+ *
+ *   - `campaign_recipe_inspect` — read. `verb=pull` captures a live
+ *     campaign as a declarative recipe; `verb=diff` plans the
+ *     convergence of a campaign onto a given recipe. Neither writes.
+ *
+ *   - `campaign_recipe_push` — write. Converges a campaign onto a
+ *     recipe, gated by `allowWrite`; `whatIf` returns the plan without
+ *     writing.
+ *
+ * The `recipe` input field IS `CampaignRecipeSchema` — the single
+ * source of truth feeds the agent-facing tool surface for free. See
+ * docs/recipe-sync-architecture.md.
+ */
+const zod_1 = require("zod");
+const recipe_1 = require("../../campaigns/recipe");
+const errors_1 = require("../../shared/errors");
+const sync_1 = require("../../sync");
+const descriptions_1 = require("../descriptions");
+const common_1 = require("../schemas/common");
+const syncContextFrom = (context, signal) => ({
+    environmentName: context.envName,
+    configPath: context.configPath,
+    signal,
+});
+const planSummaryText = (plan) => {
+    const tally = (0, sync_1.summarizePlan)(plan);
+    return `Plan: ${tally.create} create, ${tally.update} update, ${tally.delete} delete, ${tally.noop} unchanged.`;
+};
+const registerCampaignRecipeTools = (registry) => {
+    registry.registerTool({
+        name: "campaign_recipe_inspect",
+        description: descriptions_1.TOOL_DESCRIPTIONS.campaign_recipe_inspect,
+        auth: "read",
+        annotations: {
+            title: "Pull or diff a campaign as a declarative recipe",
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            verb: zod_1.z
+                .enum(["pull", "diff"])
+                .describe("pull: capture the live campaign named `campaignName` as a recipe. diff: compare `recipe` against the live campaign and return the plan."),
+            campaignName: zod_1.z
+                .string()
+                .optional()
+                .describe("Campaign display name. Required for verb='pull'."),
+            recipe: recipe_1.campaignKind.schema
+                .optional()
+                .describe("A campaign recipe. Required for verb='diff'."),
+        },
+        handler: async (input, context) => {
+            const ctx = syncContextFrom(context);
+            if (input.verb === "pull") {
+                if (!input.campaignName) {
+                    throw (0, errors_1.createScaiError)("verb='pull' requires `campaignName`.", "INPUT_INVALID");
+                }
+                const recipe = await (0, sync_1.syncPull)(recipe_1.campaignKind, { kind: recipe_1.campaignKind.name, id: input.campaignName }, ctx);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: recipe
+                                ? `Captured "${input.campaignName}" as a recipe.`
+                                : `No campaign named "${input.campaignName}".`,
+                        },
+                    ],
+                    structuredContent: { verb: input.verb, found: recipe !== null, recipe },
+                };
+            }
+            if (!input.recipe) {
+                throw (0, errors_1.createScaiError)("verb='diff' requires `recipe`.", "INPUT_INVALID");
+            }
+            const plan = await (0, sync_1.syncDiff)(recipe_1.campaignKind, input.recipe, { kind: recipe_1.campaignKind.name, id: input.recipe.name }, ctx);
+            return {
+                content: [{ type: "text", text: planSummaryText(plan) }],
+                structuredContent: { verb: input.verb, plan, summary: (0, sync_1.summarizePlan)(plan) },
+            };
+        },
+    });
+    registry.registerTool({
+        name: "campaign_recipe_push",
+        description: descriptions_1.TOOL_DESCRIPTIONS.campaign_recipe_push,
+        auth: "write",
+        annotations: {
+            title: "Push a campaign recipe — converge the campaign onto the recipe",
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: true,
+        },
+        inputSchema: {
+            recipe: recipe_1.campaignKind.schema.describe("The campaign recipe to converge onto. The campaign is identified by `recipe.name`."),
+            prune: zod_1.z
+                .boolean()
+                .default(false)
+                .describe("Include delete changes. Off by default — push is additive."),
+            ...common_1.whatIfShape,
+            ...common_1.allowWriteShape,
+        },
+        handler: async (input, context, extra) => {
+            const ctx = syncContextFrom(context, extra.signal);
+            const mode = input.whatIf ? "what-if" : "apply";
+            const outcome = await (0, sync_1.syncPush)(recipe_1.campaignKind, input.recipe, { kind: recipe_1.campaignKind.name, id: input.recipe.name }, ctx, { mode, prune: input.prune });
+            const text = outcome.result
+                ? `Applied ${outcome.result.applied.length} change(s); ${outcome.result.skipped.length} skipped.`
+                : planSummaryText(outcome.plan);
+            return {
+                content: [{ type: "text", text }],
+                structuredContent: {
+                    mode,
+                    plan: outcome.plan,
+                    summary: (0, sync_1.summarizePlan)(outcome.plan),
+                    result: outcome.result,
+                },
+            };
+        },
+    });
+};
+exports.registerCampaignRecipeTools = registerCampaignRecipeTools;

package/dist/mcp/tools/campaign.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Campaign domain — read + write tools over the Sitecore Orchestrate API.
+ *
+ * Two tools, workflow-shaped:
+ *
+ *   - `campaign_inspect` (read) discriminates on `verb` — list campaigns,
+ *     show one campaign (deliverables/tasks inline), list tasks under a
+ *     deliverable, show one task, or list the member directory.
+ *   - `campaign_manage` (write) discriminates on `resource` + `verb` —
+ *     create a campaign/deliverable/task, update a task, or delete a
+ *     campaign/deliverable/task.
+ *
+ * A campaign is an Orchestrate `project`. Built from a HAR capture
+ * 2026-05-15; the OAuth scope is unverified — see
+ * `docs/campaigns-followups.md`. The `delete` verb hits Orchestrate
+ * DELETE endpoints that were never captured: they are wired
+ * optimistically per REST conventions and remain UNVERIFIED.
+ */
+import type { McpRegistry } from "../registry";
+export declare const registerCampaignTools: (registry: McpRegistry) => void;