@setluca/mcp 0.2.1 → 0.3.0

package/dist/openapi-schema.js

@@ -0,0 +1,175 @@
+import * as Arr from "effect/Array";
+import * as EffectJsonSchema from "effect/JsonSchema";
+import * as P from "effect/Predicate";
+import * as R from "effect/Record";
+import * as Schema from "effect/Schema";
+import * as SchemaRepresentation from "effect/SchemaRepresentation";
+import { ISO_DATE_TIME_PATTERN, UUID_PATTERN } from "./fields.js";
+import { optionalField, optionalFields } from "./optional-field.js";
+/**
+ * Patterns for the string formats a tool argument is checked against. Effect
+ * keeps `format` as an annotation and does not validate it, so each format the
+ * server enforces is restated as a pattern. These are the three formats the
+ * server checked before the move to Effect Schema; `date` and `email` stay
+ * advisory and the API validates them.
+ */
+const FORMAT_PATTERNS = {
+    uuid: UUID_PATTERN.source,
+    "date-time": ISO_DATE_TIME_PATTERN.source,
+    uri: "^[A-Za-z][A-Za-z0-9+.-]*:[^\\s]+$",
+};
+/** Whether a `format` is one {@link FORMAT_PATTERNS} enforces. */
+const isEnforcedFormat = Schema.is(Schema.Literals(R.keys(FORMAT_PATTERNS)));
+const isJsonLiteral = (value) => P.isString(value) ||
+    P.isNumber(value) ||
+    P.isBoolean(value) ||
+    P.isNull(value);
+/**
+ * The shapes the API's OpenAPI 3.1 document does not use and this importer
+ * does not translate, each named so a schema that starts using one fails the
+ * generator with the keyword to handle rather than importing as something
+ * looser than it says.
+ */
+const UNSUPPORTED_KEYWORDS = [
+    ["allOf", (node) => node.allOf !== undefined],
+    ["nullable (OpenAPI 3.0)", (node) => node.nullable !== undefined],
+    [
+        "a boolean exclusive bound (OpenAPI 3.0)",
+        (node) => P.isBoolean(node.exclusiveMinimum) || P.isBoolean(node.exclusiveMaximum),
+    ],
+    [
+        "an object or array enum or const value",
+        (node) => {
+            const values = node.enum;
+            const constant = node.const;
+            return ((Arr.isArray(values) && !Arr.every(values, isJsonLiteral)) ||
+                (constant !== undefined && !isJsonLiteral(constant)));
+        },
+    ],
+    [
+        "properties without type: object",
+        (node) => P.isObject(node.properties) && node.type === undefined,
+    ],
+    [
+        "an additionalProperties schema beside declared properties",
+        (node) => {
+            const extra = node.additionalProperties;
+            return (P.isObject(node.properties) &&
+                P.isObject(extra) &&
+                !R.isEmptyRecord(extra));
+        },
+    ],
+];
+function unsupportedKeywords(node) {
+    return Arr.flatMap(UNSUPPORTED_KEYWORDS, ([keyword, appears]) => appears(node) ? [keyword] : []);
+}
+/**
+ * The extra-key rule for an object node. A declared object without the key is
+ * closed, `true` and a nested schema stay as they are, and any other value is
+ * malformed and closes the object rather than opening it.
+ */
+function closeObject(node) {
+    const extra = node.additionalProperties;
+    if (P.isBoolean(extra) || P.isObject(extra)) {
+        return node;
+    }
+    return extra === undefined && !P.isObject(node.properties)
+        ? node
+        : { ...node, additionalProperties: false };
+}
+function formatPattern(node) {
+    const format = node.format;
+    if (!isEnforcedFormat(format) || node.pattern !== undefined) {
+        return node;
+    }
+    return { ...node, pattern: FORMAT_PATTERNS[format] };
+}
+/**
+ * Rewrites one JSON Schema node before Effect translates it, so the imported
+ * schema checks what this server has always checked:
+ *
+ * - `oneOf` is read as `anyOf`. Every `oneOf` in the manifest is a tagged
+ *   union, so the two agree on real input, and `anyOf` cannot reject a value
+ *   for matching two variants.
+ * - An object that declares properties and says nothing about others is
+ *   closed, and so is one with a malformed `additionalProperties`.
+ * - The enforced formats gain the pattern from {@link FORMAT_PATTERNS}.
+ *
+ * A node using a shape {@link unsupportedKeywords} names throws instead.
+ * Every step leaves its own output alone, so running it twice on a node is the
+ * same as running it once.
+ */
+function tightenNode(node) {
+    const unsupported = unsupportedKeywords(node);
+    if (Arr.isReadonlyArrayNonEmpty(unsupported)) {
+        // oxlint-disable-next-line effect/avoid-untagged-errors -- a schema the importer cannot translate is a build-time programming error, not a runtime failure
+        throw new Error(`Unsupported OpenAPI schema shape: ${unsupported.join(", ")}. Teach src/openapi-schema.ts to translate it.`);
+    }
+    const { oneOf, ...rest } = node;
+    return formatPattern(closeObject(oneOf === undefined ? rest : { ...rest, anyOf: oneOf }));
+}
+function importNode(node) {
+    // SAFETY: a schema translated from JSON Schema is built from plain
+    // structural schemas and checks, none of which require a service.
+    return SchemaRepresentation.fromJsonSchemaDocument(EffectJsonSchema.fromSchemaOpenApi3_1(node), { patterns: "apply", onEnter: tightenNode });
+}
+/**
+ * The Effect Schema for one OpenAPI JSON Schema node. Patterns in the document
+ * are applied, and {@link tightenNode} runs on every node first.
+ *
+ * Tool inputs go through this when `src/generated/openapi-inputs.ts` is
+ * generated, not at runtime, so a change here needs `bun run openapi:generate`.
+ * `openapi:inputs:check` fails until it runs.
+ */
+export function schemaFromOpenApi(schema) {
+    return importNode(tightenNode(schema));
+}
+/** The node's type, with `object` assumed for a node that declares properties. */
+function relaxedType(schema) {
+    const declared = schema.type ?? (schema.properties === undefined ? undefined : "object");
+    return declared === undefined ? {} : { type: declared };
+}
+/**
+ * Relax a response JSON schema to a **structural, type-only** schema for output
+ * validation. The goal is a check that fails loud on a genuinely malformed
+ * payload (a field typed as the wrong primitive, `result` that is not an object
+ * at all) while never rejecting a well-formed real result.
+ *
+ * So it keeps each field's base `type` but drops value-level
+ * constraints, meaning `format`, `pattern`, length and range bounds, `enum`,
+ * and array-item schemas, and makes every object open with no required
+ * properties. Those constraints are the false-positive risk: they would fail a
+ * real tool call on a non-v4 uuid, an enum that drifted, or an omitted optional
+ * field, and they also break the pagination merge (which drops `nextCursor`
+ * and adds a `pagination` block).
+ */
+function relaxJsonSchema(schema) {
+    return {
+        ...relaxedType(schema),
+        ...optionalFields(schema.properties, (properties) => ({
+            properties: R.map(properties, relaxJsonSchema),
+            required: [],
+            additionalProperties: true,
+        })),
+        ...optionalField("anyOf", schema.anyOf?.map(relaxJsonSchema)),
+        ...optionalField("oneOf", schema.oneOf?.map(relaxJsonSchema)),
+    };
+}
+const UntrustedProvenance = Schema.Struct({
+    untrusted: Schema.Literal(true),
+    note: Schema.String,
+});
+/**
+ * The `structuredContent` fields for a tool: `{ result }`, plus an optional
+ * `provenance` marker for operations that carry lead-authored text. `result` is
+ * the operation's success-response body, relaxed by {@link relaxJsonSchema} so
+ * real results validate while malformed ones fail loud.
+ */
+export function openApiToolOutputFields(input) {
+    const result = input.body
+        ? schemaFromOpenApi(relaxJsonSchema(input.body))
+        : Schema.Unknown;
+    return input.untrustedContent
+        ? { result, provenance: Schema.optionalKey(UntrustedProvenance) }
+        : { result };
+}

package/dist/operations/catalog.js

@@ -1,3 +1,4 @@
+import * as R from "effect/Record";
 import { analyticsOperations } from "./groups/analytics.js";
 import { bookingsOperations } from "./groups/bookings.js";
 import { broadcastsOperations } from "./groups/broadcasts.js";
@@ -11,6 +12,7 @@ import { campaignsOperations } from "./groups/campaigns.js";
 // summary) live in `manifest.ts`, so adding a route stays a one-entry edit in
 // the file its group already owns.
 import { capabilitiesOperations } from "./groups/capabilities.js";
+import { channelsOperations } from "./groups/channels.js";
 import { coachOperations } from "./groups/coach.js";
 import { conversationsOperations } from "./groups/conversations.js";
 import { insightsOperations } from "./groups/insights.js";
@@ -40,6 +42,7 @@ export const LUCA_OPERATIONS = [
     ...coachOperations,
     ...usageOperations,
     ...safetyOperations,
+    ...channelsOperations,
     ...reportsOperations,
     ...insightsOperations,
     ...learningOperations,
@@ -48,3 +51,17 @@ export const LUCA_OPERATIONS = [
     ...cadencesOperations,
     ...analyticsOperations,
 ];
+const OPERATIONS_BY_ID = R.fromEntries(LUCA_OPERATIONS.map((operation) => [operation.id, operation]));
+/**
+ * The catalog entry for an id. Callers name ids in code, so a missing entry is
+ * a wiring bug rather than a runtime condition, and it throws where the first
+ * test that touches the caller will see it.
+ */
+export function operationById(id) {
+    const operation = OPERATIONS_BY_ID[id];
+    if (operation === undefined) {
+        // oxlint-disable-next-line effect/avoid-untagged-errors -- a missing catalog entry is a programming error, not a runtime failure
+        throw new Error(`Luca operation ${id} is not in the catalog.`);
+    }
+    return operation;
+}

package/dist/operations/groups/analytics.js

@@ -24,23 +24,27 @@ export const analyticsOperations = [
         id: "analytics.callIntelligence",
         title: "Read call intelligence",
         description: "Post-call intelligence for a period: show rate, close rate, average rating and rating distribution, call-to-close lag, repeat-call cohort, day-of-week and call-sequence show rates, and surprise patterns, derived from post-call events and coach-recorded outcomes.",
-        redactedFields: ["surprisePatterns"],
     }),
     op({
         id: "analytics.callIntelligenceCalls",
         title: "List calls behind call intelligence",
         description: "Most recent completed calls with a generated summary, newest first: the coach-facing summary, attendance outcome, rating, and lead name.",
-        redactedFields: ["calls[].leadName", "calls[].summary"],
+        // The summary is generated from what the lead said on the call and the
+        // lead name comes off their channel profile, so both are text the lead
+        // controls. Same reasoning as the `callEvents.summary.*` overrides.
+        untrustedContent: true,
     }),
     op({
         id: "analytics.ghostedLeads",
         title: "List ghosted leads",
         description: "Ghosted-lead counts, rescue-recovery rate, lost-revenue estimate, and top conversation-killer clusters for a period.",
+        // Each top-killer cluster label is free text drawn from lead messages.
+        untrustedContent: true,
     }),
     op({
         id: "analytics.trustScore",
         title: "Read the trust score",
-        description: "Draft approval, edit, and rejection rates plus auto-send gate state (auto-send flag and any open human-approval window) for a period.",
+        description: "Draft approval, edit, and rejection rates plus the auto-send gate flag for a period.",
     }),
     op({
         id: "analytics.leadScore",
@@ -86,7 +90,11 @@ export const analyticsOperations = [
         id: "analytics.recommendations",
         title: "Read recommendations",
         description: "The coach's active prescriptive recommendations for a week (what to change and why), generated weekly from detected insights and deduped by title. An empty list is the honest, expected state when nothing is recommended for the window — never a fabricated action.",
-        redactedFields: ["recommendations[].body"],
+        // The recommender is handed a verbatim lead-message excerpt per
+        // conversation-killer cluster, which `packages/agents/src/recommendations.ts`
+        // labels UNTRUSTED and tells the model to use "for color", so the body is
+        // the one field here that can echo a lead's own words back out.
+        untrustedContent: true,
     }),
     op({
         id: "analytics.benchmarkConsent",
@@ -97,7 +105,6 @@ export const analyticsOperations = [
         id: "analytics.learningInsights",
         title: "Read what Luca has learned",
         description: "Read-only rollup of the agent-improvement signals mined from post-call feedback for a period: total/applied/pending signal counts, a per-type breakdown (qualification, objection handling, lead quality, general), and recent example notes. An empty rollup is the honest, expected state until the coach submits call feedback — never fabricated learning.",
-        redactedFields: ["recentExamples[].note"],
     }),
     op({
         id: "analytics.crmSyncHealth",
@@ -108,15 +115,18 @@ export const analyticsOperations = [
         id: "analytics.objections",
         title: "Read objection patterns",
         description: "Objection-bucket rollup over the review queue's qualifier signals for a period (price, timing, trust, fit, authority, smokescreen): per-bucket occurrence count, distinct leads, handled rate, wins, and up to three of the most frequent verbatim lead quotes. Filter by channel. An empty bucket list is the honest, expected state until objections are raised — never fabricated.",
-        redactedFields: ["buckets[].topPhrases"],
+        // `topPhrases` is lifted verbatim out of the lead's own messages by
+        // `objectionRollup` in packages/db, so an objection a lead phrases as an
+        // instruction arrives here as one.
+        untrustedContent: true,
     }),
     op({
         id: "analytics.objectionDrilldown",
         title: "Drill into one objection type",
         description: "Per-conversation drilldown for one objection bucket: one row per matching conversation with the lead's display name, the verbatim objection quote, whether the draft was sent without an edit, and the lead's most recent call outcome. Bounded by a limit with a hasMore truncation flag; an empty list is the honest, expected state for a bucket with no conversations in the window.",
-        redactedFields: [
-            "conversations[].leadDisplayName",
-            "conversations[].phrase",
-        ],
+        // The row-level half of the rollup above: `phrase` is the same verbatim
+        // lead quote, and `leadDisplayName` is whatever the lead set on their
+        // channel profile.
+        untrustedContent: true,
     }),
 ];

package/dist/operations/groups/bookings.js

@@ -4,19 +4,27 @@ export const bookingsOperations = [
         id: "bookings.list",
         title: "List bookings",
         description: "List bookings. Query supports limit, cursor, status, and upcoming.",
-        redactedFields: ["bookings[].rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.create",
         title: "Book a call",
+        // Moves the lead to booked and tells every webhook subscriber. Gated like
+        // reschedule and cancel so one approval covers each change to a lead's call.
+        confirm: "always",
+        // The booking webhook reaches subscribers outside Luca.
+        openWorld: true,
         description: "Create a provider-neutral booking record. Body requires leadId and slotAt.",
-        redactedFields: ["booking.rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.get",
         title: "Get a booking",
         description: "Read one booking: its slot, status, provider, and lead.",
-        redactedFields: ["booking.rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.availability",
@@ -41,7 +49,6 @@ export const bookingsOperations = [
     op({
         id: "bookings.types.attendees",
         title: "List a call type's attendees",
-        redactedFields: ["attendees[].email", "attendees[].name"],
         description: "List the people invited to every call of this type, on top of the lead.",
     }),
     op({
@@ -68,60 +75,76 @@ export const bookingsOperations = [
         id: "bookings.outcome.get",
         title: "Get a booking's outcome",
         description: "Read where the sale stands on a booking, plus the version you send back to correct it.",
-        redactedFields: ["episode.note"],
     }),
     op({
         id: "bookings.outcome.history",
         title: "Read a booking's outcome history",
         description: "Read every outcome ever recorded on a booking, in order. Corrections append rather than overwrite.",
-        redactedFields: ["episode.note", "events[].note"],
     }),
     op({
         id: "bookings.needsOutcome",
         title: "List calls with no outcome recorded",
         description: "List attended calls with no outcome recorded yet. The work list for closing revenue attribution.",
-        redactedFields: ["bookings[].leadName"],
+        // Each row carries the lead's name, which the lead controls.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.lifecycleAttention",
         title: "List bookings needing attention",
         description: "List bookings where Luca's record and the provider's disagree and a human has to decide.",
-        redactedFields: ["bookings[].rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.brief",
         title: "Read a pre-call brief",
         description: "Read the pre-call brief: who the lead is, what they want, and the objections to expect.",
         untrustedContent: true,
-        redactedFields: ["brief"],
     }),
     op({
         id: "bookings.update",
         title: "Reschedule or edit a booking",
+        openWorld: true,
+        mutatesExisting: true,
+        // Moves the call on the provider calendar and re-arms the lead's reminder.
+        confirm: "always",
         description: "Reschedule or update booking status.",
-        redactedFields: ["booking.rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.cancel",
         title: "Cancel a booking",
+        openWorld: true,
+        mutatesExisting: true,
+        // Cancels a real call on the lead's and the coach's calendars.
+        confirm: "always",
         description: "Cancel a booking.",
-        redactedFields: ["booking.rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.outcome.record",
         title: "Record a booking's outcome",
+        mutatesExisting: true,
         description: "Record what the call was worth: won, lost with a reason, or still open. To correct an earlier outcome send the expectedVersion you read; a stale version returns 409 with the current one.",
-        redactedFields: ["episode.note"],
     }),
     op({
         id: "bookings.lifecycleResolution",
         title: "Resolve a booking's lifecycle flag",
+        openWorld: true,
+        confirm: "always",
+        mutatesExisting: true,
         description: "Settle one booking whose record disagrees with the provider's: retry the sync, dismiss the duplicate, or keep Luca's version.",
-        redactedFields: ["booking.rawPayload"],
+        // Each booking carries a cancellation reason the invitee may have written.
+        untrustedContent: true,
     }),
     op({
         id: "bookings.providerSync.retry",
         title: "Retry a booking's provider sync",
+        openWorld: true,
+        confirm: "always",
+        mutatesExisting: true,
         description: "Retry a failed write-back to the booking provider. A permanent failure returns 409 rather than retrying forever.",
     }),
     op({
@@ -132,6 +155,7 @@ export const bookingsOperations = [
     op({
         id: "bookings.guestLinks.revoke",
         title: "Revoke a booking's guest links",
+        mutatesExisting: true,
         description: "Kill every outstanding guest link on a booking at once.",
     }),
     op({
@@ -142,6 +166,7 @@ export const bookingsOperations = [
     op({
         id: "bookings.outcomeReasons.update",
         title: "Update a loss reason",
+        mutatesExisting: true,
         description: "Rename, reorder, or archive an outcome reason. Archiving hides it from the picker and leaves recorded outcomes alone.",
     }),
     op({
@@ -152,6 +177,7 @@ export const bookingsOperations = [
     op({
         id: "bookings.types.update",
         title: "Update a booking type",
+        mutatesExisting: true,
         description: "Update only the fields you send on one booking type. Sending `location` replaces the whole location, because its shape depends on the type.",
     }),
     op({
@@ -162,28 +188,30 @@ export const bookingsOperations = [
     op({
         id: "bookings.types.schedule.replace",
         title: "Replace a booking type schedule",
+        mutatesExisting: true,
         description: "Replace a booking type's schedule outright. Send every rule and override you want to keep \u2014 anything left out is dropped, which is also how you clear a day. Read the current schedule first unless you mean to start over.",
     }),
     op({
         id: "bookings.types.attendees.add",
         title: "Add a booking type attendee",
-        redactedFields: ["attendees[].email", "attendees[].name"],
         description: "Add a standing attendee to one booking type, so they are invited to every call booked against it. Returns the full attendee list.",
     }),
     op({
         id: "bookings.types.attendees.remove",
         title: "Remove a booking type attendee",
-        redactedFields: ["attendees[].email", "attendees[].name"],
+        mutatesExisting: true,
         description: "Remove a standing attendee from one booking type and get back the ones that are left. Calls already booked keep the invitees they were created with.",
     }),
     op({
         id: "bookings.calendars.select",
         title: "Select a booking calendar",
+        mutatesExisting: true,
         description: "Add or update a calendar selection, either for conflict checks or as the destination new bookings are written to. The destination has to be writable: a read-only calendar returns 400, and a Google connection needing attention returns 409.",
     }),
     op({
         id: "bookings.calendars.remove",
         title: "Remove a booking calendar",
+        mutatesExisting: true,
         description: "Stop using a calendar for conflict checks or as the booking destination. The calendar itself is left alone in Google; only Luca's selection changes.",
     }),
 ];

package/dist/operations/groups/broadcasts.js

@@ -1,4 +1,7 @@
 import { op } from "../registry.js";
+// Operations that return a broadcast carry its recipient snapshot: each lead's
+// display name and custom fields, which the lead wrote on their own profile.
+// The coach-written message body alone would not need the untrusted frame.
 export const broadcastsOperations = [
     op({
         id: "broadcasts.list",
@@ -8,99 +11,67 @@ export const broadcastsOperations = [
     op({
         id: "broadcasts.get",
         title: "Get a broadcast",
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Get broadcast detail.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.create",
         title: "Create a broadcast",
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Create a broadcast draft. Body requires campaignId and name.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.preview",
         title: "Preview a broadcast",
+        mutatesExisting: true,
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Refresh broadcast recipient and sample-message preview.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.approve",
         title: "Approve a broadcast",
+        mutatesExisting: true,
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Approve a safe broadcast draft and snapshot recipients.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.launch",
         title: "Launch a broadcast",
-        confirmRequired: true,
+        openWorld: true,
+        mutatesExisting: true,
+        confirm: "always",
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Launch an approved broadcast. Sends messages to live leads.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.pause",
         title: "Pause a broadcast",
+        mutatesExisting: true,
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Pause a running broadcast with an optional operator reason.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.retry",
         title: "Retry a broadcast's failed sends",
-        confirmRequired: true,
+        openWorld: true,
+        mutatesExisting: true,
+        confirm: "always",
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Retry failed broadcast recipients after operator review. Re-sends messages to leads.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
     op({
         id: "broadcasts.cancel",
         title: "Cancel a broadcast",
+        mutatesExisting: true,
+        // Recipient snapshot, see the note above this list.
+        untrustedContent: true,
         description: "Cancel a draft, approved, running, paused, or failed broadcast.",
-        redactedFields: [
-            "recipients[].messageBody",
-            "sampleMessages[].body",
-            "segmentSnapshot.excludedRecipients[].displayName",
-            "segmentSnapshot.leads[].customFields",
-            "segmentSnapshot.leads[].displayName",
-        ],
     }),
 ];

package/dist/operations/groups/cadences.js

@@ -3,12 +3,14 @@ export const cadencesOperations = [
     op({
         id: "cadences.rescueStart",
         title: "Start a silent-lead rescue",
-        confirmRequired: true,
+        openWorld: true,
+        confirm: "always",
         description: "Enroll silent leads into the multi-day rescue cadence. Starts outbound touches to real leads.",
     }),
     op({
         id: "cadences.pause",
         title: "Pause a lead's cadence",
+        mutatesExisting: true,
         description: "Pause (cancel) a lead's running rescue cadence with an optional reason.",
     }),
 ];