@ornncompute/cli 0.2.18 → 0.2.20

package/vendor/capabilities/capabilities/staff-gtm.js

@@ -0,0 +1,616 @@
+import { z } from "zod";
+import { defineStaffMcpCapability, preview } from "../capability.js";
+import { seg } from "./staff-shared.js";
+const companyFields = {
+    name: z.string().min(1),
+    ownerTags: z.string().default(""),
+    /** The editable company summary that sits above the comment thread. */
+    notes: z.string().optional(),
+};
+/** Narrowing every list accepts, so an agent need not hold the whole table. */
+const listFilterFields = {
+    q: z.string().min(1).optional(),
+    limit: z.number().int().positive().max(500).optional(),
+};
+function listQuery(parsed) {
+    const parts = [];
+    if (parsed.q)
+        parts.push(`q=${encodeURIComponent(parsed.q)}`);
+    if (parsed.limit)
+        parts.push(`limit=${parsed.limit}`);
+    return parts.length ? `?${parts.join("&")}` : "";
+}
+export const gtmCompanyListInput = z.object({ ...listFilterFields });
+export const gtmCompanyListCapability = defineStaffMcpCapability({
+    id: "gtm.company.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: list plaintext CRM companies, their owner tags and summary notes. Narrow with q, cap with limit. A company's running discussion is its comment thread.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/companies" },
+    input: gtmCompanyListInput,
+    execute: (ctx, input) => ctx.fetch(`/internal/v1/gtm/companies${listQuery(gtmCompanyListInput.parse(input))}`, {
+        method: "GET",
+    }),
+});
+export const gtmCompanyWriteInput = z.object({
+    companyId: z.number().int().positive().optional(),
+    ...companyFields,
+    confirm: z.boolean().optional(),
+});
+export const gtmCompanyWriteCapability = defineStaffMcpCapability({
+    id: "gtm.company.write",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: create a plaintext CRM company, or replace its name, owner tags and summary notes when companyId is supplied. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/companies" },
+    input: gtmCompanyWriteInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmCompanyWriteInput.parse(input);
+        const body = { name: parsed.name, owner_tags: parsed.ownerTags };
+        if (parsed.notes !== undefined)
+            body.notes = parsed.notes;
+        if (!ctx.confirmed) {
+            return preview("gtm.company.write", { companyId: parsed.companyId, ...body });
+        }
+        return ctx.fetch(parsed.companyId
+            ? `/internal/v1/gtm/companies/${seg(String(parsed.companyId))}`
+            : "/internal/v1/gtm/companies", { method: parsed.companyId ? "PATCH" : "POST", body });
+    },
+});
+const dealFields = {
+    customer: z.string().min(1),
+    owner: z.string().min(1),
+    supplier: z.string().min(1),
+    gpuType: z.string().min(1),
+};
+export const gtmDealListInput = z.object({ ...listFilterFields });
+export const gtmDealListCapability = defineStaffMcpCapability({
+    id: "gtm.deal.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: list manually entered deals. Each deal has only customer, Ornn owner, supplier, and GPU type. Narrow with q, cap with limit.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/deals" },
+    input: gtmDealListInput,
+    execute: (ctx, input) => ctx.fetch(`/internal/v1/gtm/deals${listQuery(gtmDealListInput.parse(input))}`, {
+        method: "GET",
+    }),
+});
+export const gtmDealWriteInput = z.object({
+    dealId: z.number().int().positive().optional(),
+    ...dealFields,
+    /** The negotiation's one link to Commerce. "" clears it. */
+    listingId: z.union([z.string().uuid(), z.literal("")]).optional(),
+    /** The negotiation's own bid. "" clears it. Never writes the listing. */
+    currentBid: z.string().optional(),
+    confirm: z.boolean().optional(),
+});
+export const gtmDealWriteCapability = defineStaffMcpCapability({
+    id: "gtm.deal.write",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: 'GTM staff only: create a negotiation, or replace it when dealId is supplied. The customer also associates it to that company. listingId links it to one Commerce listing and is the only connection between the two; currentBid records what the buyer offered and never writes the listing. Pass "" to clear either. Requires confirm: true.',
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/deals" },
+    input: gtmDealWriteInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmDealWriteInput.parse(input);
+        const body = {
+            customer: parsed.customer,
+            owner: parsed.owner,
+            supplier: parsed.supplier,
+            gpu_type: parsed.gpuType,
+        };
+        // Omitted leaves the stored value alone; "" clears it.
+        if (parsed.listingId !== undefined)
+            body.listing_id = parsed.listingId;
+        if (parsed.currentBid !== undefined)
+            body.current_bid = parsed.currentBid;
+        if (!ctx.confirmed) {
+            return preview("gtm.deal.write", { dealId: parsed.dealId, ...body });
+        }
+        return ctx.fetch(parsed.dealId
+            ? `/internal/v1/gtm/deals/${seg(String(parsed.dealId))}`
+            : "/internal/v1/gtm/deals", { method: parsed.dealId ? "PATCH" : "POST", body });
+    },
+});
+export const gtmCommentListInput = z.object({
+    dealId: z.number().int().positive().optional(),
+    companyId: z.number().int().positive().optional(),
+});
+export const gtmCommentListCapability = defineStaffMcpCapability({
+    id: "gtm.comment.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: list the plaintext comment thread for one deal or one company, replies included. A reply carries parent_id.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/deals/{dealId}/comments" },
+    input: gtmCommentListInput,
+    execute: (ctx, input) => {
+        const parsed = gtmCommentListInput.parse(input);
+        return ctx.fetch(commentThreadPath(parsed), { method: "GET" });
+    },
+});
+export const gtmCommentWriteInput = z.object({
+    dealId: z.number().int().positive().optional(),
+    companyId: z.number().int().positive().optional(),
+    commentId: z.number().int().positive().optional(),
+    /** Set to reply to an existing comment. Threads are one level deep. */
+    parentId: z.number().int().positive().optional(),
+    body: z.string().min(1),
+    bid: z.boolean().default(false),
+    confirm: z.boolean().optional(),
+});
+export const gtmCommentWriteCapability = defineStaffMcpCapability({
+    id: "gtm.comment.write",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: append a plaintext comment to a deal or a company, reply to one with parentId, or replace one when commentId is supplied. bid=true adds only the BID tag and changes no other behavior. Mention a teammate by writing @name in the body. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/deals/{dealId}/comments" },
+    input: gtmCommentWriteInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmCommentWriteInput.parse(input);
+        if (!parsed.commentId && !parsed.dealId && !parsed.companyId) {
+            throw new Error("dealId or companyId is required when creating a comment");
+        }
+        const body = {
+            body: parsed.body,
+            tag: parsed.bid ? "BID" : null,
+        };
+        if (parsed.parentId) {
+            body.parent_id = parsed.parentId;
+        }
+        if (!ctx.confirmed) {
+            return preview("gtm.comment.write", {
+                dealId: parsed.dealId,
+                companyId: parsed.companyId,
+                commentId: parsed.commentId,
+                ...body,
+            });
+        }
+        return ctx.fetch(parsed.commentId
+            ? `/internal/v1/gtm/comments/${seg(String(parsed.commentId))}`
+            : commentThreadPath(parsed), { method: parsed.commentId ? "PATCH" : "POST", body });
+    },
+});
+/** A comment thread hangs off exactly one subject. */
+function commentThreadPath(parsed) {
+    if (parsed.companyId) {
+        return `/internal/v1/gtm/companies/${seg(String(parsed.companyId))}/comments`;
+    }
+    if (parsed.dealId) {
+        return `/internal/v1/gtm/deals/${seg(String(parsed.dealId))}/comments`;
+    }
+    throw new Error("dealId or companyId is required");
+}
+export const gtmMentionDismissInput = z.object({
+    commentId: z.number().int().positive(),
+    confirm: z.boolean().optional(),
+});
+export const gtmMentionDismissCapability = defineStaffMcpCapability({
+    id: "gtm.mention.dismiss",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: dismiss one mention for the signed-in user. The comment is untouched and everyone else still sees it. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/comments/{commentId}/dismiss" },
+    input: gtmMentionDismissInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmMentionDismissInput.parse(input);
+        if (!ctx.confirmed) {
+            return preview("gtm.mention.dismiss", { commentId: parsed.commentId });
+        }
+        return ctx.fetch(`/internal/v1/gtm/comments/${seg(String(parsed.commentId))}/dismiss`, {
+            method: "POST",
+        });
+    },
+});
+export const gtmWorkspaceShowInput = z.object({});
+export const gtmWorkspaceShowCapability = defineStaffMcpCapability({
+    id: "gtm.workspace.show",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: show companies tagged to the signed-in user, deals they own, undismissed mentions of them, and tickets assigned to them.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/me" },
+    input: gtmWorkspaceShowInput,
+    execute: (ctx) => ctx.fetch("/internal/v1/gtm/me", { method: "GET" }),
+});
+export const gtmTaskListInput = z.object({ ...listFilterFields });
+export const gtmTaskListCapability = defineStaffMcpCapability({
+    id: "gtm.task.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: list isolated CRM tickets tied to companies. Narrow with q, cap with limit.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/tasks" },
+    input: gtmTaskListInput,
+    execute: (ctx, input) => ctx.fetch(`/internal/v1/gtm/tasks${listQuery(gtmTaskListInput.parse(input))}`, {
+        method: "GET",
+    }),
+});
+export const gtmTaskWriteInput = z
+    .object({
+    taskId: z.number().int().positive().optional(),
+    title: z.string().min(1),
+    body: z.string().default(""),
+    companyId: z.number().int().positive(),
+    dealId: z.number().int().positive().nullable().optional(),
+    assignee: z.string().min(1),
+    status: z.enum(["open", "done"]).optional(),
+    confirm: z.boolean().optional(),
+})
+    // Creating defaults to open; updating replaces the whole ticket, so an
+    // omitted status would be sent as empty and rejected by Commerce. Catch it
+    // here instead of after the caller has confirmed.
+    .refine((value) => value.taskId === undefined || value.status !== undefined, {
+    message: "status is required when updating a ticket",
+    path: ["status"],
+});
+export const gtmTaskWriteCapability = defineStaffMcpCapability({
+    id: "gtm.task.write",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: create a company ticket, or replace one when taskId is supplied. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/tasks" },
+    input: gtmTaskWriteInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmTaskWriteInput.parse(input);
+        const body = {
+            title: parsed.title,
+            body: parsed.body,
+            company_id: parsed.companyId,
+            deal_id: parsed.dealId ?? null,
+            assignee: parsed.assignee,
+            status: parsed.status,
+        };
+        if (!ctx.confirmed) {
+            return preview("gtm.task.write", { taskId: parsed.taskId, ...body });
+        }
+        return ctx.fetch(parsed.taskId
+            ? `/internal/v1/gtm/tasks/${seg(String(parsed.taskId))}`
+            : "/internal/v1/gtm/tasks", { method: parsed.taskId ? "PATCH" : "POST", body });
+    },
+});
+/**
+ * Delete verbs. Each takes the record id, previews first, and maps onto the
+ * matching DELETE route. Deleting a deal removes its comments with it; a
+ * company refuses while deals or tickets still name it.
+ */
+function gtmDeleteCapability(entity, idKey, route, consequence) {
+    const input = z.object({
+        [idKey]: z.number().int().positive(),
+        confirm: z.boolean().optional(),
+    });
+    const capability = defineStaffMcpCapability({
+        id: `gtm.${entity}.delete`,
+        domain: "gtm",
+        roles: ["reviewer", "admin"],
+        description: `GTM staff only: delete one ${entity}. ${consequence} Requires confirm: true.`,
+        mutation: "preview-confirm",
+        http: { method: "DELETE", path: `${route}/{${idKey}}` },
+        input,
+        execute: async (ctx, raw) => {
+            const parsed = input.parse(raw);
+            const id = parsed[idKey];
+            if (!ctx.confirmed) {
+                return preview(`gtm.${entity}.delete`, { [idKey]: id });
+            }
+            return ctx.fetch(`${route}/${seg(String(id))}`, { method: "DELETE" });
+        },
+    });
+    return { input, capability };
+}
+const companyDelete = gtmDeleteCapability("company", "companyId", "/internal/v1/gtm/companies", "Refused while the company still has deals or tickets.");
+export const gtmCompanyDeleteInput = companyDelete.input;
+export const gtmCompanyDeleteCapability = companyDelete.capability;
+const dealDelete = gtmDeleteCapability("deal", "dealId", "/internal/v1/gtm/deals", "Its comments are deleted with it; tickets that referenced it are kept.");
+export const gtmDealDeleteInput = dealDelete.input;
+export const gtmDealDeleteCapability = dealDelete.capability;
+const commentDelete = gtmDeleteCapability("comment", "commentId", "/internal/v1/gtm/comments", "Removes only that comment.");
+export const gtmCommentDeleteInput = commentDelete.input;
+export const gtmCommentDeleteCapability = commentDelete.capability;
+const taskDelete = gtmDeleteCapability("task", "taskId", "/internal/v1/gtm/tasks", "Removes only that ticket.");
+export const gtmTaskDeleteInput = taskDelete.input;
+export const gtmTaskDeleteCapability = taskDelete.capability;
+/**
+ * Listing verbs. GTM never touches a Commerce table directly: these call
+ * Commerce's own listing routes through the gateway, exactly as the staff app
+ * does. Nothing here writes a gtm_ row, and nothing in the CRM constrains a
+ * listing.
+ */
+export const gtmListingListInput = z.object({
+    gpuType: z.string().optional(),
+    limit: z.number().int().positive().max(200).optional(),
+});
+export const gtmListingListCapability = defineStaffMcpCapability({
+    id: "gtm.listing.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: list Commerce listings to apply a bid against, optionally filtered by GPU type. Read-only; this is Commerce's catalog, not CRM data.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/listings" },
+    input: gtmListingListInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmListingListInput.parse(input);
+        const parts = [`limit=${encodeURIComponent(String(parsed.limit ?? 50))}`];
+        if (parsed.gpuType)
+            parts.push(`q=${encodeURIComponent(parsed.gpuType)}`);
+        const page = (await ctx.fetch(`/internal/v1/listings?${parts.join("&")}`, {
+            method: "GET",
+        }));
+        return { listings: (page.listings ?? []).map(publicListing) };
+    },
+});
+export const gtmListingUpdateInput = z.object({
+    listingId: z.string().uuid(),
+    buyNowRatePerGpuHour: z.string().optional(),
+    costPerGpuHour: z.string().optional(),
+    /** true = month to month, false = the fixed window the listing already carries. */
+    monthToMonth: z.boolean().optional(),
+    allowsDepositPlan: z.boolean().optional(),
+    downPaymentPct: z.string().optional(),
+    capacityNodes: z.number().int().positive().optional(),
+    state: z.enum(["draft", "listed", "delisted"]).optional(),
+    confirm: z.boolean().optional(),
+});
+export const gtmListingUpdateCapability = defineStaffMcpCapability({
+    id: "gtm.listing.update",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: update a Commerce listing's commercial terms — buy-now rate, cost, term and deposit plan — plus capacity or state. Setting a buy-now rate also enables buy-now, otherwise the rate would be inert. Commerce owns the record; this is its own PATCH, not a CRM write. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "PATCH", path: "/internal/v1/listings/{listingId}" },
+    input: gtmListingUpdateInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmListingUpdateInput.parse(input);
+        const body = listingPatchBody(parsed);
+        if (Object.keys(body).length === 0) {
+            throw new Error("supply at least one field to update");
+        }
+        if (!ctx.confirmed) {
+            return preview("gtm.listing.update", { listingId: parsed.listingId, ...body });
+        }
+        return patchListing(ctx, parsed.listingId, body);
+    },
+});
+/**
+ * Strip true operator identity before it reaches an MCP client. Facility and
+ * region are allowed; operator ids and provider names are not. Every listing
+ * this module returns -- list, update, and the apply result -- goes through it.
+ */
+function publicListing(raw) {
+    const listing = raw;
+    const { operatorId: _operatorId, operatorName: _operatorName, provider: _provider, ...safe } = listing;
+    return safe;
+}
+/**
+ * The listing PATCH is a compare-and-set: it refuses without the version the
+ * row was read at. Read it here so a caller never has to guess, and a listing
+ * changed in between fails loudly rather than being clobbered.
+ */
+async function patchListing(ctx, listingId, body) {
+    const current = (await ctx.fetch(`/internal/v1/listings/${seg(listingId)}`, {
+        method: "GET",
+    }));
+    if (typeof current.version !== "number") {
+        throw new Error("listing did not report a version to update against");
+    }
+    const updated = await ctx.fetch(`/internal/v1/listings/${seg(listingId)}`, {
+        method: "PATCH",
+        body: { ...body, version: current.version },
+    });
+    return publicListing(updated);
+}
+function listingPatchBody(parsed) {
+    const body = {};
+    if (parsed.buyNowRatePerGpuHour !== undefined) {
+        body.buyNowRatePerGpuHour = parsed.buyNowRatePerGpuHour;
+        // A rate with buy-now still disabled would change nothing a buyer sees.
+        body.buyNowEnabled = true;
+    }
+    if (parsed.costPerGpuHour !== undefined)
+        body.costPerGpuHour = parsed.costPerGpuHour;
+    if (parsed.monthToMonth !== undefined)
+        body.monthToMonth = parsed.monthToMonth;
+    if (parsed.allowsDepositPlan !== undefined)
+        body.allowsDepositPlan = parsed.allowsDepositPlan;
+    if (parsed.downPaymentPct !== undefined)
+        body.downPaymentPct = parsed.downPaymentPct;
+    if (parsed.capacityNodes !== undefined)
+        body.capacityNodes = parsed.capacityNodes;
+    if (parsed.state !== undefined)
+        body.state = parsed.state;
+    return body;
+}
+export const gtmTaskActivityListInput = z.object({
+    taskId: z.number().int().positive(),
+});
+export const gtmTaskActivityListCapability = defineStaffMcpCapability({
+    id: "gtm.task.activity.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: read one ticket's timeline — the comments left on it and the field changes recorded against it, oldest first.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/tasks/{taskId}/activity" },
+    input: gtmTaskActivityListInput,
+    execute: (ctx, input) => {
+        const parsed = gtmTaskActivityListInput.parse(input);
+        return ctx.fetch(`/internal/v1/gtm/tasks/${seg(String(parsed.taskId))}/activity`, {
+            method: "GET",
+        });
+    },
+});
+export const gtmTaskActivityWriteInput = z.object({
+    taskId: z.number().int().positive(),
+    body: z.string().min(1),
+    /** Set to reply to a comment on the same ticket. Threads are one level deep. */
+    parentId: z.number().int().positive().optional(),
+    confirm: z.boolean().optional(),
+});
+export const gtmTaskActivityWriteCapability = defineStaffMcpCapability({
+    id: "gtm.task.activity.write",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: add a plaintext comment to a ticket, or reply to one with parentId. Mention a teammate by writing @name in the body. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/tasks/{taskId}/activity" },
+    input: gtmTaskActivityWriteInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmTaskActivityWriteInput.parse(input);
+        const body = { body: parsed.body, parent_id: parsed.parentId ?? null };
+        if (!ctx.confirmed) {
+            return preview("gtm.task.activity.write", { taskId: parsed.taskId, ...body });
+        }
+        return ctx.fetch(`/internal/v1/gtm/tasks/${seg(String(parsed.taskId))}/activity`, {
+            method: "POST",
+            body,
+        });
+    },
+});
+/**
+ * Company cell comments. These hang off one field of one company — the
+ * discussion about a name, its owner tags, its summary, or its tickets —
+ * rather than off the company's main thread.
+ */
+const cellField = z.enum(["name", "owner_tags", "notes", "tickets"]);
+export const gtmCellCommentListInput = z.object({
+    companyId: z.number().int().positive(),
+    field: cellField,
+});
+export const gtmCellCommentListCapability = defineStaffMcpCapability({
+    id: "gtm.cell.comment.list",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: read the comments attached to one field of one company (name, owner_tags, notes or tickets), replies included.",
+    mutation: "read",
+    http: { method: "GET", path: "/internal/v1/gtm/companies/{companyId}/cells/{field}/comments" },
+    input: gtmCellCommentListInput,
+    execute: (ctx, input) => {
+        const parsed = gtmCellCommentListInput.parse(input);
+        return ctx.fetch(`/internal/v1/gtm/companies/${seg(String(parsed.companyId))}/cells/${seg(parsed.field)}/comments`, { method: "GET" });
+    },
+});
+export const gtmCellCommentWriteInput = z.object({
+    companyId: z.number().int().positive().optional(),
+    field: cellField.optional(),
+    /** Set to replace an existing cell comment; companyId and field are then unused. */
+    commentId: z.number().int().positive().optional(),
+    parentId: z.number().int().positive().optional(),
+    body: z.string().min(1),
+    confirm: z.boolean().optional(),
+});
+export const gtmCellCommentWriteCapability = defineStaffMcpCapability({
+    id: "gtm.cell.comment.write",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: comment on one field of one company, reply to such a comment with parentId, or replace one when commentId is supplied. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "POST", path: "/internal/v1/gtm/companies/{companyId}/cells/{field}/comments" },
+    input: gtmCellCommentWriteInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmCellCommentWriteInput.parse(input);
+        if (!parsed.commentId && (!parsed.companyId || !parsed.field)) {
+            throw new Error("companyId and field are required unless commentId is supplied");
+        }
+        if (!ctx.confirmed) {
+            return preview("gtm.cell.comment.write", {
+                companyId: parsed.companyId,
+                field: parsed.field,
+                commentId: parsed.commentId,
+                parentId: parsed.parentId,
+                body: parsed.body,
+            });
+        }
+        if (parsed.commentId) {
+            return ctx.fetch(`/internal/v1/gtm/company-comments/${seg(String(parsed.commentId))}`, {
+                method: "PATCH",
+                body: { body: parsed.body },
+            });
+        }
+        return ctx.fetch(`/internal/v1/gtm/companies/${seg(String(parsed.companyId))}/cells/${seg(parsed.field)}/comments`, { method: "POST", body: { body: parsed.body, parent_id: parsed.parentId ?? null } });
+    },
+});
+const cellCommentDelete = gtmDeleteCapability("cell.comment", "commentId", "/internal/v1/gtm/company-comments", "Removes that field comment and its replies.");
+export const gtmCellCommentDeleteInput = cellCommentDelete.input;
+export const gtmCellCommentDeleteCapability = cellCommentDelete.capability;
+/**
+ * Bulk owner-tag reassignment. This is the one GTM edit that is genuinely
+ * N-at-a-time — a book of companies moving to a new owner — and doing it one
+ * confirmation at a time is both slow and easy to half-finish. Every other
+ * bulk case is a loop over the single-record verbs.
+ */
+export const gtmCompanyBulkRetagInput = z.object({
+    companyIds: z.array(z.number().int().positive()).min(1).max(200),
+    ownerTags: z.string(),
+    confirm: z.boolean().optional(),
+});
+export const gtmCompanyBulkRetagCapability = defineStaffMcpCapability({
+    id: "gtm.company.bulk_retag",
+    domain: "gtm",
+    roles: ["reviewer", "admin"],
+    description: "GTM staff only: set the same owner tags on many companies at once, for moving a book to a new owner. Names, notes and comments are untouched. The preview lists every company it would change. Requires confirm: true.",
+    mutation: "preview-confirm",
+    http: { method: "PATCH", path: "/internal/v1/gtm/companies/{companyId}" },
+    input: gtmCompanyBulkRetagInput,
+    execute: async (ctx, input) => {
+        const parsed = gtmCompanyBulkRetagInput.parse(input);
+        const ids = [...new Set(parsed.companyIds)];
+        if (!ctx.confirmed) {
+            return preview("gtm.company.bulk_retag", { companyIds: ids, ownerTags: parsed.ownerTags });
+        }
+        // PATCH replaces the company's name as well, so the current names are read
+        // once up front rather than per row. Omitting notes preserves them.
+        // Commerce owns no bulk route, so partial progress is reported rather than
+        // rolled back; re-running is safe.
+        const all = (await ctx.fetch("/internal/v1/gtm/companies", { method: "GET" }));
+        const names = new Map(all.map((company) => [company.id, company.name]));
+        const updated = [];
+        const failed = [];
+        for (const companyId of ids) {
+            const name = names.get(companyId);
+            if (name === undefined) {
+                failed.push({ companyId, error: "no such company" });
+                continue;
+            }
+            try {
+                updated.push(await ctx.fetch(`/internal/v1/gtm/companies/${seg(String(companyId))}`, {
+                    method: "PATCH",
+                    body: { name, owner_tags: parsed.ownerTags },
+                }));
+            }
+            catch (error) {
+                failed.push({ companyId, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        return { updated, failed };
+    },
+});
+export const staffGTMCapabilities = [
+    gtmCompanyListCapability,
+    gtmCompanyWriteCapability,
+    gtmCompanyDeleteCapability,
+    gtmCompanyBulkRetagCapability,
+    gtmDealListCapability,
+    gtmDealWriteCapability,
+    gtmDealDeleteCapability,
+    gtmCommentListCapability,
+    gtmCommentWriteCapability,
+    gtmCommentDeleteCapability,
+    gtmCellCommentListCapability,
+    gtmCellCommentWriteCapability,
+    gtmCellCommentDeleteCapability,
+    gtmTaskListCapability,
+    gtmTaskWriteCapability,
+    gtmTaskDeleteCapability,
+    gtmTaskActivityListCapability,
+    gtmTaskActivityWriteCapability,
+    gtmListingListCapability,
+    gtmListingUpdateCapability,
+    gtmMentionDismissCapability,
+    gtmWorkspaceShowCapability,
+];

package/vendor/capabilities/capability.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType } from "zod";
 import type { ClientKind, Role } from "./role.ts";
-export declare const DOMAINS: readonly ["identity", "listings", "fleet", "users", "reservations", "bids", "access", "clusters", "slurm", "kubernetes", "networks", "storage", "vpn", "billing", "observability"];
+export declare const DOMAINS: readonly ["identity", "listings", "fleet", "users", "reservations", "bids", "access", "clusters", "slurm", "kubernetes", "networks", "storage", "vpn", "billing", "observability", "gtm"];
 export type Domain = (typeof DOMAINS)[number];
 export type Mutation = "read" | "preview-confirm" | "local";
 export type HttpSpec = {
@@ -65,7 +65,7 @@ export type Capability<I = unknown, O = unknown> = CapabilityBindings & {
     execute: (ctx: CapabilityContext, input: I) => Promise<O>;
 };
 export type CapabilitySpec<I = unknown, O = unknown> = Omit<Capability<I, O>, "cli" | "mcp" | "slack"> & {
-    slack?: {
+    slack?: false | {
         parameters?: JsonSchema;
     };
 };

package/vendor/capabilities/capability.js

@@ -15,6 +15,7 @@ export const DOMAINS = [
     "vpn",
     "billing",
     "observability",
+    "gtm",
 ];
 /**
  * Build a preview-confirm capability's un-executed result.
@@ -31,14 +32,19 @@ export function preview(action, payload) {
 /** Fill CLI/MCP/Slack names from `id`. Slack parameters stay optional. */
 export function defineCapability(spec) {
     const names = namesFromId(spec.id);
+    const { slack, ...rest } = spec;
     return {
-        ...spec,
+        ...rest,
         cli: { command: names.cli },
         mcp: { name: names.mcp },
-        slack: {
-            name: names.slack,
-            ...(spec.slack?.parameters ? { parameters: spec.slack.parameters } : {}),
-        },
+        ...(slack === false
+            ? {}
+            : {
+                slack: {
+                    name: names.slack,
+                    ...(slack?.parameters ? { parameters: slack.parameters } : {}),
+                },
+            }),
     };
 }
 /**