exponential-mcp 0.6.0 → 0.7.0

package/README.md

@@ -44,6 +44,9 @@ Once connected, Claude can:
 - **Complete actions** – "Mark the report task as done"
 - **View OKRs** – "What are my Q1 goals?"
 - **Search** – "Find anything related to Kenya"
+- **Work the CRM** – "Log that I emailed Keily today" / "Move the Onionpress deal to Proposal"
+- **Run the product backlog** – tickets, features, epics, stories, pages and decisions
+- **Track time** – log, confirm and report on the day
 
 ## Manual Setup
 
@@ -125,6 +128,30 @@ exponential-mcp serve
 | `append_meeting_notes` | Add to a meeting's notes without overwriting them |
 | `search` | Search across everything |
 
+### Domain tools
+
+Alongside the tools above, every part of the [Exponential SDK](https://www.npmjs.com/package/exponential-sdk)
+is exposed as one tool per domain, so the MCP server can do anything the SDK
+and CLI can:
+
+`actions` · `projects` · `workspaces` · `goals` · `key_results` · `meetings` ·
+`time` · `decisions` · `contacts` · `organizations` · `deals` · `products` ·
+`features` · `scopes` · `requirements` · `areas` · `stories` · `epics` ·
+`tickets` · `labels` · `pages` · `comments`
+
+Each takes `{ operation, params }`. The tool description lists every operation
+with a one-line signature; `operation: "describe"` returns the full parameter
+schema for one operation (`params: { operation: "create" }`) or all of them.
+Invalid params come back as an error that includes the expected schema.
+
+```json
+{ "operation": "add_interaction",
+  "params": { "contactId": "…", "type": "EMAIL", "direction": "OUTBOUND", "subject": "Intro" } }
+```
+
+`comments` covers comments on actions, features, pages, goals and tickets — pass
+`target` to choose which.
+
 ### Asking about the day
 
 Use **`get_todays_actions`**, not `get_actions`, for anything about today,

package/dist/domains/actions.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const actions: Domain;

package/dist/domains/actions.js

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { date, id, op } from './framework.js';
+const KANBAN_STATUSES = ['BACKLOG', 'TODO', 'IN_PROGRESS', 'IN_REVIEW', 'DONE', 'CANCELLED'];
+const ACTION_STATUSES = ['ACTIVE', 'COMPLETED', 'CANCELLED', 'DELETED', 'DRAFT'];
+const PRIORITIES = [
+    'Quick',
+    'Scheduled',
+    '1st Priority',
+    '2nd Priority',
+    '3rd Priority',
+    '4th Priority',
+    '5th Priority',
+    'Errand',
+    'Remember',
+    'Watch',
+    'Someday Maybe',
+];
+const optionalWorkspaceId = z
+    .string()
+    .optional()
+    .describe('Workspace ID (see the `workspaces` tool); omit for all workspaces');
+const clearableDate = (what) => date(what).nullable().optional().describe(`${what} (ISO 8601; null to clear)`);
+export const actions = {
+    name: 'actions',
+    description: 'Actions: the personal and project to-dos on the user’s plate, with due/scheduled dates, priority and a kanban column. Projects live in the `projects` tool, logged time in `time`, and meetings (which can spawn actions) in `meetings`.',
+    operations: {
+        list: op({
+            summary: 'List your open actions (completed/cancelled hidden unless `status` is set). With projectId, returns that project’s actions and ignores `status`; with status alone, returns only actions you created in that kanban column.',
+            params: z.object({
+                projectId: id('Project').optional(),
+                status: z.enum(KANBAN_STATUSES).optional().describe('Kanban column to filter by'),
+                assigneeId: id('User').optional(),
+            }),
+            run: (client, params) => client.actions.list(params),
+        }),
+        get_today: op({
+            summary: 'What is actually on the user’s plate today, split into overdue / today / inbox — the /today page’s own partition. Prefer this for "what should I do today". Each group is capped at 50 rows; `count` is the true total.',
+            params: z.object({ workspaceId: optionalWorkspaceId }),
+            run: (client, { workspaceId }) => client.actions.getTodaysActions(workspaceId),
+        }),
+        get_due_today: op({
+            summary: 'Narrow slice: only actions whose dueDate is today. Excludes overdue and scheduled-but-undated work — use get_today for "what is on my plate".',
+            params: z.object({ workspaceId: optionalWorkspaceId }),
+            run: (client, { workspaceId }) => client.actions.getToday(workspaceId),
+        }),
+        get_overdue_triage: op({
+            summary: 'Explain the overdue pile: cohorts (actions sharing one exact timestamp, i.e. a bulk-dated plan — usually bulk_defer them) vs loose, individually-dated debt.',
+            params: z.object({ workspaceId: optionalWorkspaceId }),
+            run: (client, { workspaceId }) => client.actions.getOverdueTriage(workspaceId),
+        }),
+        bulk_reschedule: op({
+            summary: 'Move actions to a new date: sets both scheduledStart and dueDate to `dueDate`. Pass null to clear both (bulk_defer says that more clearly). Actions you cannot access are silently skipped.',
+            params: z.object({
+                actionIds: z.array(id('Action')),
+                dueDate: date('New date').nullable().describe('New do/due date (ISO 8601), or null to clear'),
+            }),
+            run: (client, { actionIds, dueDate }) => client.actions.bulkReschedule(actionIds, dueDate),
+        }),
+        bulk_defer: op({
+            summary: 'Amnesty: clear the dates on actions so they fall back to their project backlog untimed (1–200 ids). Kanban column is untouched. For work that was never really due — typically an overdue cohort.',
+            params: z.object({
+                actionIds: z.array(id('Action')).min(1).max(200),
+            }),
+            run: (client, { actionIds }) => client.actions.bulkDefer(actionIds),
+        }),
+        list_by_date_range: op({
+            summary: 'Your ACTIVE actions whose dueDate falls in [start, end) — end is exclusive. The workspace filter matches via the action’s project, so project-less actions drop out when it is set.',
+            params: z.object({
+                start: date('Range start (inclusive)'),
+                end: date('Range end (exclusive)'),
+                workspaceId: optionalWorkspaceId,
+            }),
+            run: (client, { start, end, workspaceId }) => client.actions.getByDateRange(start, end, workspaceId),
+        }),
+        list_kanban: op({
+            summary: 'Kanban-board actions (those with a kanban column), ordered by column then board order. Only returns actions you created.',
+            params: z.object({
+                projectId: id('Project').optional(),
+                status: z.enum(KANBAN_STATUSES).optional().describe('Kanban column to filter by'),
+                assigneeId: id('User').optional(),
+            }),
+            run: (client, params) => client.actions.getKanban(params),
+        }),
+        list_project_actions: op({
+            summary: 'All actions in one project, including completed ones (unlike list). FORBIDDEN if you lack project access.',
+            params: z.object({
+                projectId: id('Project'),
+                assigneeId: id('User').optional(),
+            }),
+            run: (client, { projectId, assigneeId }) => client.actions.getProjectActions(projectId, assigneeId),
+        }),
+        create: op({
+            summary: 'Create an action. Priority defaults to "Quick" and status to ACTIVE.',
+            params: z.object({
+                name: z.string(),
+                description: z.string().optional(),
+                projectId: id('Project').optional(),
+                workspaceId: optionalWorkspaceId.describe('Workspace ID (see the `workspaces` tool)'),
+                dueDate: date('Due date').optional(),
+                scheduledStart: date('Scheduled start (do-date)').optional(),
+                scheduledEnd: date('Scheduled end').optional(),
+                duration: z.number().optional().describe('Planned duration in minutes'),
+                priority: z.enum(PRIORITIES).optional(),
+                status: z.enum(ACTION_STATUSES).optional(),
+                epicId: id('Epic').optional(),
+                effortEstimate: z.number().optional(),
+                blockedByIds: z.array(id('Action')).optional().describe('IDs of actions this one is blocked by'),
+            }),
+            run: (client, params) => client.actions.create(params),
+        }),
+        update: op({
+            summary: 'Update an action. Only the fields you pass change. Complete it with status COMPLETED or kanbanStatus DONE.',
+            params: z.object({
+                id: id('Action'),
+                name: z.string().optional(),
+                description: z.string().optional(),
+                projectId: id('Project').optional().describe('Project ID to move the action to'),
+                workspaceId: z.string().nullable().optional().describe('Workspace ID (null to clear)'),
+                dueDate: clearableDate('Due date'),
+                scheduledStart: clearableDate('Scheduled start (do-date)'),
+                scheduledEnd: clearableDate('Scheduled end'),
+                duration: z.number().nullable().optional().describe('Planned duration in minutes (null to clear)'),
+                priority: z.enum(PRIORITIES).optional(),
+                status: z.enum(ACTION_STATUSES).optional(),
+                kanbanStatus: z.enum(KANBAN_STATUSES).optional(),
+                epicId: z.string().nullable().optional().describe('Epic ID (null to unlink)'),
+                effortEstimate: z.number().nullable().optional().describe('Effort estimate (null to clear)'),
+                blockedByIds: z
+                    .array(id('Action'))
+                    .optional()
+                    .describe('Replaces the full set of blocking action IDs; omit to leave untouched'),
+            }),
+            run: (client, params) => client.actions.update(params),
+        }),
+        upsert_by_source: op({
+            summary: 'Idempotent create keyed on (workspaceId, sourceType, sourceId): refreshes name/links if found, else creates. Returns { action, outcome: "created" | "updated" }.',
+            params: z.object({
+                sourceType: z.string().describe('External source kind, e.g. `claude-session` for the Daily worklog'),
+                sourceId: z.string().describe('External id within sourceType (e.g. the conversation id)'),
+                name: z.string(),
+                workspaceId: z.string().describe('Workspace ID (see the `workspaces` tool)'),
+                description: z.string().optional(),
+                projectId: z
+                    .string()
+                    .nullable()
+                    .optional()
+                    .describe('Project ID; must be in workspaceId or the call is NOT_FOUND'),
+                ticketId: z
+                    .string()
+                    .nullable()
+                    .optional()
+                    .describe('Ticket ID; its product must be in workspaceId or the call is NOT_FOUND'),
+            }),
+            run: (client, params) => client.actions.upsertBySource(params),
+        }),
+    },
+};

package/dist/domains/areas.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const areas: Domain;

package/dist/domains/areas.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { id, op } from './framework.js';
+export const areas = {
+    name: 'areas',
+    description: 'Areas: per-product buckets a feature is filed under (exactly one or none). Products are in `products`; file a feature under an area via `features` create/update `areaId`.',
+    operations: {
+        list: op({
+            summary: 'List a product’s areas in display order, with feature counts.',
+            params: z.object({ productId: id('Product') }),
+            run: (client, params) => client.areas.list(params),
+        }),
+        create: op({
+            summary: 'Create an area at the end of a product’s list. Names are unique per product.',
+            params: z.object({
+                productId: id('Product'),
+                name: z.string(),
+                description: z.string().optional(),
+            }),
+            run: (client, params) => client.areas.create(params),
+        }),
+    },
+};

package/dist/domains/comments.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const comments: Domain;

package/dist/domains/comments.js

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+import { op } from './framework.js';
+const TARGETS = ['action', 'feature', 'page', 'goal', 'ticket'];
+const target = z.enum(TARGETS).describe('Kind of entity the comment is on');
+const targetId = z
+    .union([z.string(), z.number()])
+    .describe('ID of the entity being commented on: the action/feature/page/ticket ID, or the goal’s integer ID');
+const commentId = z.string().describe('Comment ID');
+const body = z
+    .string()
+    .min(1)
+    .describe('Comment text (markdown). Mention members with @[Name](userId) — see the `workspaces` tool’s members');
+function unsupported(operation, t, supported) {
+    throw new Error(`comments.${operation} is not supported for target "${t}". Supported targets: ${supported}.`);
+}
+function goalIdOf(value) {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isInteger(n)) {
+        throw new Error(`Goal targetId must be an integer, got ${JSON.stringify(value)}.`);
+    }
+    return n;
+}
+/** Feature-only / goal-only add fields, rejected loudly on other targets rather than silently dropped. */
+function assertOnly(t, allowed, fields) {
+    if (t === allowed)
+        return;
+    const present = Object.entries(fields)
+        .filter(([, v]) => v !== undefined)
+        .map(([k]) => k);
+    if (present.length) {
+        throw new Error(`${present.join(', ')} can only be used with target "${allowed}", not "${t}".`);
+    }
+}
+async function listTicketComments(client, ticketId) {
+    // There is no standalone ticket-comment list endpoint; the detail read carries them.
+    const ticket = await client.tickets.get(ticketId);
+    return ticket.comments ?? [];
+}
+export const comments = {
+    name: 'comments',
+    description: 'Comments on actions, features (PRDs), knowledge pages, goals (objectives) and tickets — pick the entity with `target`. Threaded replies and anchored-thread resolve/unresolve exist only on features. Editing and deleting are author-only.',
+    operations: {
+        list: op({
+            summary: 'List comments on an entity. All targets. For tickets this reads the ticket detail (newest first) — there is no separate list endpoint.',
+            params: z.object({ target, targetId }),
+            run: (client, { target: t, targetId: tid }) => {
+                switch (t) {
+                    case 'action':
+                        return client.actionComments.list(String(tid));
+                    case 'feature':
+                        return client.featureComments.list(String(tid));
+                    case 'page':
+                        return client.pageComments.list(String(tid));
+                    case 'goal':
+                        return client.goalComments.list(goalIdOf(tid));
+                    case 'ticket':
+                        return listTicketComments(client, String(tid));
+                }
+            },
+        }),
+        add: op({
+            summary: 'Add a top-level comment. All targets; scopeId/threadId/quotedText are feature-only, parentUpdateId is goal-only.',
+            params: z.object({
+                target,
+                targetId,
+                body,
+                scopeId: z.string().optional().describe('Feature only: post to this scope’s activity feed instead of the feature’s'),
+                threadId: z.string().optional().describe('Feature only: anchor to a span of the PRD body; omit for a doc-level comment'),
+                quotedText: z.string().optional().describe('Feature only: the anchored text being quoted'),
+                parentUpdateId: z.string().optional().describe('Goal only: thread under this goal update instead of the goal itself'),
+            }),
+            run: (client, { target: t, targetId: tid, body, scopeId, threadId, quotedText, parentUpdateId }) => {
+                assertOnly(t, 'feature', { scopeId, threadId, quotedText });
+                assertOnly(t, 'goal', { parentUpdateId });
+                switch (t) {
+                    case 'action':
+                        return client.actionComments.add({ actionId: String(tid), content: body });
+                    case 'feature':
+                        return client.featureComments.create({ featureId: String(tid), body, scopeId, threadId, quotedText });
+                    case 'page':
+                        return client.pageComments.create({ pageId: String(tid), body });
+                    case 'goal':
+                        return client.goalComments.add({ goalId: goalIdOf(tid), content: body, parentUpdateId });
+                    case 'ticket':
+                        return client.tickets.addComment({ ticketId: String(tid), content: body });
+                }
+            },
+        }),
+        update: op({
+            summary: 'Replace a comment’s text. All targets; author-only.',
+            params: z.object({ target, commentId, body }),
+            run: (client, { target: t, commentId, body }) => {
+                switch (t) {
+                    case 'action':
+                        return client.actionComments.update({ commentId, content: body });
+                    case 'feature':
+                        return client.featureComments.update({ commentId, body });
+                    case 'page':
+                        return client.pageComments.update({ commentId, body });
+                    case 'goal':
+                        return client.goalComments.update({ commentId, content: body });
+                    case 'ticket':
+                        return client.tickets.updateComment({ id: commentId, content: body });
+                }
+            },
+        }),
+        delete: op({
+            summary: 'Delete a comment permanently. All targets; author-only. On features, deleting a root also deletes its replies.',
+            params: z.object({ target, commentId }),
+            run: (client, { target: t, commentId }) => {
+                switch (t) {
+                    case 'action':
+                        return client.actionComments.delete(commentId);
+                    case 'feature':
+                        return client.featureComments.delete(commentId);
+                    case 'page':
+                        return client.pageComments.delete(commentId);
+                    case 'goal':
+                        return client.goalComments.delete(commentId);
+                    case 'ticket':
+                        return client.tickets.deleteComment(commentId);
+                }
+            },
+        }),
+        reply: op({
+            summary: 'Reply to a comment. Feature target only. Replies to replies still hang off the root comment.',
+            params: z.object({
+                target,
+                commentId: z.string().describe('ID of the comment being replied to'),
+                body,
+            }),
+            run: (client, { target: t, commentId, body }) => {
+                if (t !== 'feature')
+                    unsupported('reply', t, 'feature');
+                return client.featureComments.reply({ parentId: commentId, body });
+            },
+        }),
+        resolve: op({
+            summary: 'Mark an anchored comment thread resolved. Feature target only; only anchored threads have a threadId.',
+            params: z.object({
+                target,
+                targetId,
+                threadId: z.string().describe('The anchored thread’s threadId (from the comment), not a comment ID'),
+            }),
+            run: (client, { target: t, targetId: tid, threadId }) => {
+                if (t !== 'feature')
+                    unsupported('resolve', t, 'feature');
+                return client.featureComments.resolve({ featureId: String(tid), threadId });
+            },
+        }),
+        unresolve: op({
+            summary: 'Reopen a resolved anchored comment thread. Feature target only.',
+            params: z.object({
+                target,
+                targetId,
+                threadId: z.string().describe('The anchored thread’s threadId (from the comment), not a comment ID'),
+            }),
+            run: (client, { target: t, targetId: tid, threadId }) => {
+                if (t !== 'feature')
+                    unsupported('unresolve', t, 'feature');
+                return client.featureComments.unresolve({ featureId: String(tid), threadId });
+            },
+        }),
+    },
+};

package/dist/domains/contacts.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const contacts: Domain;

package/dist/domains/contacts.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { id, op, workspaceId } from './framework.js';
+const INTERACTION_TYPES = [
+    'EMAIL',
+    'TELEGRAM',
+    'PHONE_CALL',
+    'MEETING',
+    'NOTE',
+    'LINKEDIN',
+    'OTHER',
+];
+/** Fields shared by create and update; update additionally accepts null to clear. */
+const contactFields = {
+    firstName: z.string().optional(),
+    lastName: z.string().optional(),
+    about: z.string().optional().describe('Free-text notes about the person'),
+    profileType: z.string().optional(),
+    skills: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    organizationName: z
+        .string()
+        .optional()
+        .describe('Link to an organization by name, creating it if needed. Ignored when organizationId is set'),
+};
+const clearable = (what) => z.string().nullable().optional().describe(`${what} (null to clear)`);
+export const contacts = {
+    name: 'contacts',
+    description: 'CRM contacts (people) in a workspace, with their interaction history. Organizations live in the `organizations` tool and deals in `deals`. Personal fields are encrypted at rest; list/search runs server-side.',
+    operations: {
+        list: op({
+            summary: 'List contacts, newest first. Paginate with the returned nextCursor.',
+            params: z.object({
+                workspaceId,
+                search: z.string().optional().describe('Match on name, email or organization'),
+                tags: z.array(z.string()).optional(),
+                organizationId: id('Organization').optional(),
+                limit: z.number().int().min(1).max(100).optional(),
+                cursor: z.string().optional(),
+            }),
+            run: (client, params) => client.contacts.list(params),
+        }),
+        get: op({
+            summary: 'Get one contact, optionally with its interaction timeline.',
+            params: z.object({
+                id: id('Contact'),
+                includeInteractions: z.boolean().optional(),
+            }),
+            run: (client, { id, includeInteractions }) => client.contacts.get(id, { includeInteractions }),
+        }),
+        create: op({
+            summary: 'Create a contact.',
+            params: z.object({
+                workspaceId,
+                ...contactFields,
+                email: z.string().nullable().optional(),
+                phone: z.string().optional(),
+                linkedIn: z.string().optional(),
+                telegram: z.string().optional(),
+                twitter: z.string().optional(),
+                github: z.string().optional(),
+                bluesky: z.string().optional(),
+                organizationId: id('Organization').optional(),
+            }),
+            run: (client, params) => client.contacts.create(params),
+        }),
+        update: op({
+            summary: 'Update a contact. Only the fields you pass change.',
+            params: z.object({
+                id: id('Contact'),
+                ...contactFields,
+                email: clearable('Email'),
+                phone: clearable('Phone'),
+                linkedIn: clearable('LinkedIn URL'),
+                telegram: clearable('Telegram handle'),
+                twitter: clearable('Twitter/X handle'),
+                github: clearable('GitHub handle'),
+                bluesky: clearable('Bluesky handle'),
+                organizationId: clearable('Organization ID'),
+            }),
+            run: (client, params) => client.contacts.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a contact permanently.',
+            params: z.object({ id: id('Contact') }),
+            run: (client, { id }) => client.contacts.delete(id),
+        }),
+        add_interaction: op({
+            summary: 'Log an interaction (email, call, meeting, note…) on a contact’s timeline.',
+            params: z.object({
+                contactId: id('Contact'),
+                type: z.enum(INTERACTION_TYPES),
+                direction: z.enum(['INBOUND', 'OUTBOUND']),
+                subject: z.string().optional(),
+                notes: z.string().optional(),
+                metadata: z.record(z.unknown()).optional(),
+            }),
+            run: (client, params) => client.contacts.addInteraction(params),
+        }),
+        enrich: op({
+            summary: 'Queue a web-search enrichment job for a contact. Idempotent: a job already in flight is not re-queued.',
+            params: z.object({ id: id('Contact') }),
+            run: (client, { id }) => client.contacts.enrich(id),
+        }),
+    },
+};

package/dist/domains/deals.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const deals: Domain;

package/dist/domains/deals.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { date, id, op, workspaceId } from './framework.js';
+const probability = z.number().int().min(0).max(100);
+const value = z.number().min(0);
+export const deals = {
+    name: 'deals',
+    description: 'CRM deals moving through the workspace’s sales pipeline stages, plus the pipeline and its stages. Deals link to people in `contacts` and companies in `organizations`. All operations target the workspace’s default (oldest active) pipeline.',
+    operations: {
+        pipeline: op({
+            summary: 'Get the workspace’s default pipeline with its stages, or null if there is none you can access.',
+            params: z.object({ workspaceId }),
+            run: (client, { workspaceId }) => client.pipelines.get(workspaceId),
+        }),
+        stages: op({
+            summary: 'List the pipeline’s stages in order, with deal counts. Use a stage ID for create/move.',
+            params: z.object({ workspaceId }),
+            run: (client, { workspaceId }) => client.pipelines.getStages(workspaceId),
+        }),
+        list: op({
+            summary: 'List every deal in the pipeline (unpaginated), ordered by position within stage.',
+            params: z.object({ workspaceId }),
+            run: (client, { workspaceId }) => client.pipelines.listDeals(workspaceId),
+        }),
+        get: op({
+            summary: 'Get one deal with its stage, contact, organization, assignee and latest 50 activities.',
+            params: z.object({ id: id('Deal') }),
+            run: (client, { id }) => client.pipelines.getDeal(id),
+        }),
+        create: op({
+            summary: 'Create a deal at the end of a stage. Logs a CREATED activity.',
+            params: z.object({
+                workspaceId,
+                stageId: id('Pipeline stage'),
+                title: z.string(),
+                description: z.string().optional(),
+                value: value.optional(),
+                currency: z.string().optional().describe('ISO currency code; default USD'),
+                probability: probability.optional().describe('Win probability, 0–100'),
+                expectedCloseDate: date('Expected close date').optional(),
+                contactId: id('Contact').optional(),
+                organizationId: id('Organization').optional(),
+                assignedToId: id('User').optional(),
+            }),
+            run: (client, params) => client.pipelines.createDeal(params),
+        }),
+        update: op({
+            summary: 'Update a deal’s fields (not its stage — use move). Only the fields you pass change; a value change is logged as an activity.',
+            params: z.object({
+                id: id('Deal'),
+                title: z.string().optional(),
+                description: z.string().nullable().optional().describe('null to clear'),
+                value: value.nullable().optional().describe('null to clear'),
+                currency: z.string().optional(),
+                probability: probability.nullable().optional().describe('Win probability, 0–100 (null to clear)'),
+                expectedCloseDate: date('Expected close date').nullable().optional().describe('ISO 8601 date or datetime (null to clear)'),
+                contactId: z.string().nullable().optional().describe('Contact ID (null to clear)'),
+                organizationId: z.string().nullable().optional().describe('Organization ID (null to clear)'),
+                assignedToId: z.string().nullable().optional().describe('User ID (null to clear)'),
+            }),
+            run: (client, params) => client.pipelines.updateDeal(params),
+        }),
+        move: op({
+            summary: 'Move a deal to a stage and position. Entering a won/lost stage sets closedAt (leaving one clears it); a stage change is logged. Other deals are not re-ordered.',
+            params: z.object({
+                id: id('Deal'),
+                stageId: id('Target pipeline stage'),
+                stageOrder: z.number().int().min(0).describe('0-based position within the target stage'),
+            }),
+            run: (client, params) => client.pipelines.moveDeal(params),
+        }),
+        delete: op({
+            summary: 'Delete a deal permanently, with its activity history.',
+            params: z.object({ id: id('Deal') }),
+            run: (client, { id }) => client.pipelines.deleteDeal(id),
+        }),
+    },
+};

package/dist/domains/decisions.d.ts

@@ -0,0 +1,2 @@
+import { type Domain } from './framework.js';
+export declare const decisions: Domain;