@setluca/mcp 0.1.0 → 0.2.0

package/dist/openapi-zod.js

@@ -15,37 +15,70 @@ function nonNullTypes(schema) {
 function withDescription(schema, description) {
     return description ? schema.describe(description) : schema;
 }
+const JsonLiteralSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+]);
 function enumSchema(values) {
     if (values.length === 0) {
         return z.never();
     }
-    if (values.every((value) => typeof value === "string")) {
-        return z.enum(values);
+    const strings = z.array(z.string()).safeParse(values);
+    if (strings.success) {
+        const [first, ...rest] = strings.data;
+        return first === undefined ? z.never() : z.enum([first, ...rest]);
     }
-    if (values.length === 1) {
-        return z.literal(values[0]);
+    const literals = z.array(JsonLiteralSchema).safeParse(values);
+    if (!literals.success) {
+        return z.never();
+    }
+    const [firstValue, secondValue, ...restValues] = literals.data;
+    if (firstValue === undefined) {
+        return z.never();
     }
-    const literals = values.map((value) => z.literal(value));
-    return z.union(literals);
+    const first = z.literal(firstValue);
+    if (secondValue === undefined) {
+        return first;
+    }
+    const second = z.literal(secondValue);
+    const rest = restValues.map((value) => z.literal(value));
+    return z.union([first, second, ...rest]);
 }
-function stringSchema(schema) {
-    let result = z.string();
-    if (schema.format === "uuid") {
-        result = result.uuid();
+/**
+ * Zod 4 moved the string formats to top-level constructors: the `.uuid()` /
+ * `.url()` / `.datetime()` methods on a ZodString are deprecated. They all
+ * still subclass ZodString, so the length and pattern refinements below chain
+ * onto whichever base a format picks.
+ */
+function formatBase(format) {
+    if (format === "uuid") {
+        return z.uuid();
     }
-    else if (schema.format === "uri") {
-        result = result.url();
+    if (format === "uri") {
+        return z.url();
     }
-    else if (schema.format === "date-time") {
-        result = result.datetime({ offset: true });
+    if (format === "date-time") {
+        return z.iso.datetime({ offset: true });
     }
+    return z.string();
+}
+function stringSchema(schema) {
+    let result = formatBase(schema.format);
     if (schema.minLength !== undefined) {
         result = result.min(schema.minLength);
     }
     if (schema.maxLength !== undefined) {
         result = result.max(schema.maxLength);
     }
+    // Forcing this guard true is an equivalent mutation rather than an untested
+    // branch: with no pattern the body builds `new RegExp(undefined)`, which is
+    // the empty pattern `/(?:)/` and matches every string, so the constraint it
+    // adds rejects nothing. Forcing it false is a real change and is covered.
+    // Stryker disable next-line ConditionalExpression: an absent pattern compiles to /(?:)/, which constrains nothing
     if (schema.pattern) {
+        // fallow-ignore-next-line security-sink -- patterns come from Luca's checked-in generated OpenAPI document at startup, never from MCP tool arguments or request data
         result = result.regex(new RegExp(schema.pattern));
     }
     return result;
@@ -100,18 +133,25 @@ function scalarSchemaWithoutConstraints(schema, type) {
 function objectSchema(schema) {
     const properties = schema.properties ?? {};
     const required = new Set(schema.required ?? []);
-    const shape = {};
+    const fields = {};
     for (const [key, property] of Object.entries(properties)) {
         const propertySchema = schemaToZod(property);
-        shape[key] = required.has(key) ? propertySchema : propertySchema.optional();
+        fields[key] = required.has(key)
+            ? propertySchema
+            : propertySchema.optional();
     }
-    const result = z.object(shape);
+    const result = z.object(fields);
     if (schema.additionalProperties === true) {
         return result.catchall(z.unknown());
     }
-    if (schema.additionalProperties &&
-        typeof schema.additionalProperties === "object") {
-        return result.catchall(schemaToZod(schema.additionalProperties));
+    if (schema.additionalProperties !== undefined &&
+        schema.additionalProperties !== false) {
+        const object = z
+            .record(z.string(), z.unknown())
+            .safeParse(schema.additionalProperties);
+        if (object.success) {
+            return result.catchall(schemaToZod(schema.additionalProperties));
+        }
     }
     return result;
 }
@@ -128,7 +168,8 @@ function schemaToZod(schema) {
 }
 function literalOrEnumSchema(schema) {
     if (schema.const !== undefined) {
-        return z.literal(schema.const);
+        const literal = JsonLiteralSchema.safeParse(schema.const);
+        return literal.success ? z.literal(literal.data) : z.never();
     }
     if (schema.enum) {
         return withDescription(enumSchema(schema.enum), schema.description);
@@ -152,7 +193,14 @@ function variantSchema(schema, variants) {
         const single = unionItems[0] ?? z.never();
         return withDescription(isNullable(schema) ? single.nullable() : single, schema.description);
     }
-    const union = z.union(unionItems);
+    const [first, second, ...rest] = unionItems;
+    if (first === undefined) {
+        return z.never();
+    }
+    if (second === undefined) {
+        return first;
+    }
+    const union = z.union([first, second, ...rest]);
     return withDescription(isNullable(schema) ? union.nullable() : union, schema.description);
 }
 function describedBaseSchema(schema) {
@@ -170,37 +218,37 @@ function mergeAllOf(allOf) {
     }
     return {
         ...merged,
-        ...(Object.keys(properties).length > 0 ? { properties } : {}),
-        ...(required.length > 0 ? { required } : {}),
+        ...(Object.keys(properties).length > 0 ? { properties } : undefined),
+        // Equivalent under this module's public contract: an empty `required: []`
+        // and an absent `required` produce the identical Zod object schema, because
+        // `objectSchema` derives its required-set from `schema.required ?? []` — both
+        // yield an all-optional object. The guard only avoids emitting a noise key.
+        // Stryker disable next-line ConditionalExpression,EqualityOperator: empty and absent `required` are indistinguishable downstream
+        ...(required.length > 0 ? { required } : undefined),
     };
 }
 function baseSchema(schema) {
     const types = nonNullTypes(schema);
-    if (types.length === 0) {
+    const [first, second, ...rest] = types;
+    if (first === undefined) {
         return schema.properties ? objectSchema(schema) : z.unknown();
     }
-    if (types.length === 1) {
-        return scalarSchema(schema, types[0] ?? "unknown");
+    if (second === undefined) {
+        return scalarSchema(schema, first);
     }
-    return z.union(types.map((type) => scalarSchema(schema, type)));
+    return z.union([
+        scalarSchema(schema, first),
+        scalarSchema(schema, second),
+        ...rest.map((type) => scalarSchema(schema, type)),
+    ]);
 }
-/**
- * Relax a response JSON schema to a **structural, type-only** shape 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` (and `nullable`) but drops value-level
- * constraints — `format` (uuid/date-time), `pattern`, length/range bounds,
- * `enum`, and deep array-item schemas — and makes every object open with no
- * required properties. Those constraints are the false-positive risk: they would
- * 500 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). The trade: array element shapes
- * and formats are not deeply validated; the structural contract still is.
- */
 function relaxJsonSchema(schema) {
     const relaxed = {};
+    // Forcing this guard true assigns `relaxed.type = undefined` when there is no
+    // type, which is indistinguishable downstream from omitting the key: both
+    // `nonNullTypes` and the object-routing in `baseSchema` treat an undefined
+    // `type` and an absent `type` identically, producing the same Zod schema.
+    // Stryker disable next-line ConditionalExpression: an undefined `type` and an absent one yield the identical relaxed schema
     if (schema.type !== undefined) {
         relaxed.type = schema.type;
     }
@@ -215,15 +263,24 @@ function relaxJsonSchema(schema) {
         relaxed.properties = properties;
         relaxed.required = [];
         relaxed.additionalProperties = true;
+        // Defensive belt-and-suspenders: with `properties` present, `baseSchema`
+        // routes an absent type and an explicit `"object"` type to the same
+        // `objectSchema` call, so setting the type here never changes the produced
+        // Zod schema. Verified equivalent through both public entry points.
+        // Stryker disable next-line ConditionalExpression,BlockStatement: object routing is identical with or without an explicit type when properties exist
         if (relaxed.type === undefined) {
+            // Stryker disable next-line StringLiteral: type value is inert here — properties already force objectSchema downstream
             relaxed.type = "object";
         }
     }
-    for (const key of ["anyOf", "oneOf", "allOf"]) {
-        const variants = schema[key];
-        if (variants) {
-            relaxed[key] = variants.map(relaxJsonSchema);
-        }
+    if (schema.anyOf) {
+        relaxed.anyOf = schema.anyOf.map(relaxJsonSchema);
+    }
+    if (schema.oneOf) {
+        relaxed.oneOf = schema.oneOf.map(relaxJsonSchema);
+    }
+    if (schema.allOf) {
+        relaxed.allOf = schema.allOf.map(relaxJsonSchema);
     }
     // Array items and scalar formats/patterns/ranges/enums are intentionally
     // dropped — see the doc comment.
@@ -233,37 +290,44 @@ const untrustedProvenanceSchema = z
     .object({ untrusted: z.literal(true), note: z.string() })
     .loose();
 /**
- * The `structuredContent` shape for a tool: `{ result }`, plus an optional
+ * 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, deep-relaxed (see
  * {@link relaxJsonSchema}) so real results validate while malformed ones fail
  * loud.
  */
-export function openApiToolOutputShape(input) {
+export function openApiToolOutputFields(input) {
     const resultSchema = input.body
         ? schemaToZod(relaxJsonSchema(input.body))
         : z.unknown();
-    const shape = { result: resultSchema };
-    if (input.untrustedContent) {
-        shape.provenance = untrustedProvenanceSchema.optional();
-    }
-    return shape;
+    return input.untrustedContent
+        ? {
+            result: resultSchema,
+            provenance: untrustedProvenanceSchema.optional(),
+        }
+        : { result: resultSchema };
 }
-export function openApiToolInputShape(input) {
-    const shape = {};
-    Object.assign(shape, input.workspaceInput);
+export function openApiToolInputFields(input) {
+    const fields = new Map(Object.entries(input.workspaceInput));
     if (input.idempotencyRequired) {
-        Object.assign(shape, input.idempotencyInput);
+        for (const [key, schema] of Object.entries(input.idempotencyInput)) {
+            fields.set(key, schema);
+        }
     }
-    const pathShape = input.spec?.path ? schemaToZod(input.spec.path) : undefined;
-    if (pathShape instanceof z.ZodObject) {
-        Object.assign(shape, pathShape.shape);
+    const pathSchema = input.spec?.path
+        ? schemaToZod(input.spec.path)
+        : undefined;
+    if (pathSchema instanceof z.ZodObject) {
+        // oxlint-disable-next-line typescript/dot-notation -- Zod owns this public property name; bracket access avoids classifying the library member as a local shape symbol.
+        for (const [key, schema] of Object.entries(pathSchema["shape"])) {
+            fields.set(key, schema);
+        }
     }
     if (input.spec?.query) {
-        shape.query = schemaToZod(input.spec.query).optional();
+        fields.set("query", schemaToZod(input.spec.query).optional());
     }
     if (input.spec?.body) {
-        shape.body = schemaToZod(input.spec.body);
+        fields.set("body", schemaToZod(input.spec.body));
     }
-    return shape;
+    return Object.fromEntries(fields);
 }

package/dist/operations/catalog.js

@@ -0,0 +1,50 @@
+import { analyticsOperations } from "./groups/analytics.js";
+import { bookingsOperations } from "./groups/bookings.js";
+import { broadcastsOperations } from "./groups/broadcasts.js";
+import { cadencesOperations } from "./groups/cadences.js";
+import { callEventsOperations } from "./groups/callEvents.js";
+import { campaignsOperations } from "./groups/campaigns.js";
+// The operation table: every public Luca API route this server exposes as a
+// tool, one `op({...})` entry per route, split into one file per group under
+// `groups/`. Data only. The model that gives those entries their shape lives in
+// `registry.ts`, and the views derived from the table (the manifest, the group
+// 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 { coachOperations } from "./groups/coach.js";
+import { conversationsOperations } from "./groups/conversations.js";
+import { insightsOperations } from "./groups/insights.js";
+import { integrationsOperations } from "./groups/integrations.js";
+import { knowledgeOperations } from "./groups/knowledge.js";
+import { leadsOperations } from "./groups/leads.js";
+import { learningOperations } from "./groups/learning.js";
+import { memoryOperations } from "./groups/memory.js";
+import { reportsOperations } from "./groups/reports.js";
+import { reviewQueueOperations } from "./groups/reviewQueue.js";
+import { safetyOperations } from "./groups/safety.js";
+import { usageOperations } from "./groups/usage.js";
+import { voiceOperations } from "./groups/voice.js";
+import { webhooksOperations } from "./groups/webhooks.js";
+export const LUCA_OPERATIONS = [
+    ...capabilitiesOperations,
+    ...leadsOperations,
+    ...conversationsOperations,
+    ...reviewQueueOperations,
+    ...bookingsOperations,
+    ...callEventsOperations,
+    ...campaignsOperations,
+    ...broadcastsOperations,
+    ...webhooksOperations,
+    ...integrationsOperations,
+    ...voiceOperations,
+    ...coachOperations,
+    ...usageOperations,
+    ...safetyOperations,
+    ...reportsOperations,
+    ...insightsOperations,
+    ...learningOperations,
+    ...knowledgeOperations,
+    ...memoryOperations,
+    ...cadencesOperations,
+    ...analyticsOperations,
+];

package/dist/operations/groups/analytics.js

@@ -0,0 +1,122 @@
+import { op } from "../registry.js";
+export const analyticsOperations = [
+    op({
+        id: "analytics.funnel",
+        title: "Read the funnel",
+        description: "Pipeline funnel stage counts with period and channel filters. Returns counts and conversion rates for each funnel stage plus period-over-period deltas.",
+    }),
+    op({
+        id: "analytics.revenue",
+        title: "Read revenue",
+        description: "Revenue attribution and plan ROI for a period. Returns total revenue, ROI, and a per-channel revenue breakdown.",
+    }),
+    op({
+        id: "analytics.speedImpact",
+        title: "Read what reply speed is worth",
+        description: "Fast-vs-slow first-reply booking-rate impact for a period. Returns fast- and slow-reply conversion rates, a lost-opportunity estimate, and the peak performance reply window.",
+    }),
+    op({
+        id: "analytics.forecast",
+        title: "Read the revenue forecast",
+        description: "Point-in-time pipeline revenue forecast with on-track, optimistic, and conservative scenarios based on pipeline stage probabilities and historical conversion rates.",
+    }),
+    op({
+        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"],
+    }),
+    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.",
+    }),
+    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.",
+    }),
+    op({
+        id: "analytics.leadScore",
+        title: "Read a lead's score",
+        description: "Predictive booking-likelihood score (0-100) for one lead from the coach's trained bucket-rate model, with a confidence tier and the top contributing features. Honest about insufficient data: an under-trained model returns a null score and low confidence instead of a fabricated number.",
+    }),
+    op({
+        id: "analytics.lossReasons",
+        title: "Read why deals are lost",
+        description: "Category breakdown of automatic 'why you lost' analyses for a period: count and estimated lost revenue per category (price objection, ghosted after a call-to-action, competitor, slow reply, bad fit, other), derived from a per-lead loss analysis generated when a lead goes silent or lost.",
+    }),
+    op({
+        id: "analytics.contentAttribution",
+        title: "Read which content brings leads",
+        description: "Per-content rollup (leads touched, qualified, booked, revenue) of attributed touches for a period. Content is attributed automatically from an Instagram comment or Story reply that carries a real media id, or tagged manually; an honest empty list means no content is attributed yet, not zero performance.",
+    }),
+    op({
+        id: "analytics.contentPerformance",
+        title: "Read content performance",
+        description: "Per-post rollup (reach, engagement rate, likes/comments/saves/shares, attributed leads/bookings/revenue) for each Instagram post, reel, story, or carousel over a period. Insight fields stay null until the coach's account grants Instagram insights access — read that as not connected yet, not zero engagement.",
+    }),
+    op({
+        id: "analytics.topicPerformance",
+        title: "Read topic performance",
+        description: "Weekly rollup by normalized content topic (post count, average engagement rate, attributed leads/bookings/revenue per theme). Defaults to the most recently computed week when weekStart is omitted; an empty items list is the honest, expected state until content topics are extracted, not zero performance.",
+    }),
+    op({
+        id: "analytics.benchmarks",
+        title: "Read peer benchmarks",
+        description: "This coach's own cross-coach benchmark percentiles (e.g. 'top 15% for response speed among fitness coaches'), never another coach's data. `comingSoon: true` with an empty metrics list is the honest, expected state until the cross-coach benchmark pipeline populates this coach's row — never a fabricated comparison.",
+    }),
+    op({
+        id: "analytics.insights",
+        title: "List insights",
+        description: "The coach's proactive-insights feed (metric drops/spikes, opportunities, risks, milestones) surfaced by the daily insight-detection cron, newest first. Optionally filter to one status via the status query param (e.g. unread). An empty items list is the honest, expected state for a coach nothing has been flagged for yet — never a fabricated alert.",
+    }),
+    op({
+        id: "analytics.trends",
+        title: "Read trends",
+        description: "The coach's weekly metrics as a trend series (leads, qualified, booked, revenue, and rates week over week) for charting direction of travel. An empty series is the honest, expected state until enough weeks of history accrue — never fabricated points.",
+    }),
+    op({
+        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"],
+    }),
+    op({
+        id: "analytics.benchmarkConsent",
+        title: "Check benchmark sharing consent",
+        description: "The coach's cross-coach benchmark opt-in state (whether this workspace contributes to and sees anonymized niche cohort percentiles). Read-only; the opt-in is changed from the app, not through this key surface.",
+    }),
+    op({
+        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",
+        title: "Check CRM sync health",
+        description: "Aggregate CRM-sync health for the coach's post-call summaries: counts of synced, pending, local-only, failed, and permanently-failed pushes. All zeros is the honest, expected state for a coach with no synced summaries yet — never a fabricated status.",
+    }),
+    op({
+        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"],
+    }),
+    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",
+        ],
+    }),
+];

package/dist/operations/groups/bookings.js

@@ -0,0 +1,189 @@
+import { op } from "../registry.js";
+export const bookingsOperations = [
+    op({
+        id: "bookings.list",
+        title: "List bookings",
+        description: "List bookings. Query supports limit, cursor, status, and upcoming.",
+        redactedFields: ["bookings[].rawPayload"],
+    }),
+    op({
+        id: "bookings.create",
+        title: "Book a call",
+        description: "Create a provider-neutral booking record. Body requires leadId and slotAt.",
+        redactedFields: ["booking.rawPayload"],
+    }),
+    op({
+        id: "bookings.get",
+        title: "Get a booking",
+        description: "Read one booking: its slot, status, provider, and lead.",
+        redactedFields: ["booking.rawPayload"],
+    }),
+    op({
+        id: "bookings.availability",
+        title: "Read open call slots",
+        description: "List open slots the coach can actually be booked into. Check this before booking.",
+    }),
+    op({
+        id: "bookings.managedAvailability",
+        title: "Read Luca-managed call slots",
+        description: "List open slots for one of Luca's own call types, with calendar conflicts already removed.",
+    }),
+    op({
+        id: "bookings.types.list",
+        title: "List call types",
+        description: "List the call types a booking can use, with their duration and provider.",
+    }),
+    op({
+        id: "bookings.types.schedule",
+        title: "Read a call type's schedule",
+        description: "Read a call type's weekly schedule: the hours it can be booked and its time zone.",
+    }),
+    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({
+        id: "bookings.providers.list",
+        title: "List booking providers",
+        description: "List every booking provider, what each can do, and whether this coach's connection is healthy.",
+    }),
+    op({
+        id: "bookings.providers.get",
+        title: "Get a booking provider",
+        description: "List the event types and calendars in one connected provider account.",
+    }),
+    op({
+        id: "bookings.calendars.list",
+        title: "List connected calendars",
+        description: "List the calendars Luca reads for conflicts, and which one it writes new events to.",
+    }),
+    op({
+        id: "bookings.outcomeReasons.list",
+        title: "List loss reasons",
+        description: "List the reasons a sale can be lost or a call cancelled. Use one of these codes when recording an outcome.",
+    }),
+    op({
+        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"],
+    }),
+    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"],
+    }),
+    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",
+        description: "Reschedule or update booking status.",
+        redactedFields: ["booking.rawPayload"],
+    }),
+    op({
+        id: "bookings.cancel",
+        title: "Cancel a booking",
+        description: "Cancel a booking.",
+        redactedFields: ["booking.rawPayload"],
+    }),
+    op({
+        id: "bookings.outcome.record",
+        title: "Record a booking's outcome",
+        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",
+        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"],
+    }),
+    op({
+        id: "bookings.providerSync.retry",
+        title: "Retry a booking's provider sync",
+        description: "Retry a failed write-back to the booking provider. A permanent failure returns 409 rather than retrying forever.",
+    }),
+    op({
+        id: "bookings.guestLinks.create",
+        title: "Create a guest link for a booking",
+        description: "Mint revocable reschedule and cancel links for one booking, so a lead can move the call without an account.",
+    }),
+    op({
+        id: "bookings.guestLinks.revoke",
+        title: "Revoke a booking's guest links",
+        description: "Kill every outstanding guest link on a booking at once.",
+    }),
+    op({
+        id: "bookings.outcomeReasons.create",
+        title: "Create a loss reason",
+        description: "Add a lost-sale or cancellation reason in the workspace's own wording. A code already in use returns 409.",
+    }),
+    op({
+        id: "bookings.outcomeReasons.update",
+        title: "Update a loss reason",
+        description: "Rename, reorder, or archive an outcome reason. Archiving hides it from the picker and leaves recorded outcomes alone.",
+    }),
+    op({
+        id: "bookings.types.create",
+        title: "Create a booking type",
+        description: "Define a bookable call: how long it runs, where it happens, and how it looks to the lead. Give it a schedule next \u2014 a booking type with no schedule offers no slots and will never appear in availability.",
+    }),
+    op({
+        id: "bookings.types.update",
+        title: "Update a booking type",
+        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({
+        id: "bookings.types.delete",
+        title: "Delete a booking type",
+        description: "Remove a booking type and get back the types that are left. Calls already booked against it are not cancelled.",
+    }),
+    op({
+        id: "bookings.types.schedule.replace",
+        title: "Replace a booking type schedule",
+        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"],
+        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",
+        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",
+        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.",
+    }),
+];