exponential-mcp 0.6.0 → 0.8.0

package/dist/domains/decisions.js

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { date, id, op, workspaceId } from './framework.js';
+const DECISION_STATUSES = ['OPEN', 'PROPOSED', 'ACCEPTED', 'SUPERSEDED', 'DEPRECATED'];
+const DECISION_SOURCES = ['MEETING', 'MANUAL', 'AGENT'];
+const decisionId = id('Decision');
+const meetingId = id('Meeting (transcription session)');
+const clearable = (what) => z.string().nullable().optional().describe(`${what} (null to clear)`);
+/** Scope links shared by create and update; all nullable to clear. */
+const scopeFields = {
+    productId: clearable('Product ID'),
+    projectId: clearable('Project ID'),
+    goalId: z.number().int().nullable().optional().describe('Objective (goal) integer ID (null to clear)'),
+    keyResultId: clearable('Key result ID'),
+};
+export const decisions = {
+    name: 'decisions',
+    description: 'The Decision Log: decisions and open questions (an open question is a decision with status OPEN — there is no separate model), optionally sourced from a meeting with transcript evidence. Meetings are in `meetings`; decisions can be linked to `tickets` and `features` as "implemented by".',
+    operations: {
+        list: op({
+            summary: 'Confirmed decisions in a workspace, newest decided first. Never includes drafts (see list_for_meeting).',
+            params: z.object({
+                workspaceId,
+                statuses: z.array(z.enum(DECISION_STATUSES)).optional(),
+                sources: z.array(z.enum(DECISION_SOURCES)).optional(),
+                productId: z.string().optional().describe('Product ID, or the literal "workspace" for decisions with no product'),
+                includeWorkspaceWide: z
+                    .boolean()
+                    .optional()
+                    .describe('With a real productId: also include decisions that have no product'),
+                projectId: id('Project').optional(),
+                search: z.string().max(200).optional().describe('Free text over statement and body'),
+                number: z.number().int().min(1).optional().describe('One decision by its workspace sequence number — D-0003 is 3'),
+                limit: z.number().int().min(1).max(500).optional().describe('Unset returns everything visible'),
+            }),
+            run: (client, params) => client.decisions.list(params),
+        }),
+        get: op({
+            summary: 'Get one decision with its deciders, evidence, links and supersession chain.',
+            params: z.object({ workspaceId, decisionId }),
+            run: (client, { workspaceId, decisionId }) => client.decisions.get(workspaceId, decisionId),
+        }),
+        list_for_meeting: op({
+            summary: 'Decisions and open questions logged from one meeting. Includes drafts if you can edit the meeting. No workspaceId needed.',
+            params: z.object({ transcriptionSessionId: meetingId }),
+            run: (client, { transcriptionSessionId }) => client.decisions.listForMeeting(transcriptionSessionId),
+        }),
+        list_for_adr: op({
+            summary: 'Decisions formalised as one ADR ("Decided in").',
+            params: z.object({ workspaceId, adrDocumentId: id('ADR document') }),
+            run: (client, { workspaceId, adrDocumentId }) => client.decisions.listForAdr(workspaceId, adrDocumentId),
+        }),
+        extract_drafts: op({
+            summary: 'AI-extract DRAFT decisions from a meeting’s notes and transcript for review. Idempotent: existing drafts come back; a meeting with confirmed decisions reports alreadyPublished.',
+            params: z.object({ transcriptionSessionId: meetingId }),
+            run: (client, { transcriptionSessionId }) => client.decisions.extractDrafts(transcriptionSessionId),
+        }),
+        create: op({
+            summary: 'Log a decision (status defaults to PROPOSED). Pass status "OPEN" for an open question and transcriptionSessionId to attach it to a meeting.',
+            params: z.object({
+                workspaceId,
+                statement: z.string().max(500).describe('The decision itself, or the open question'),
+                body: z.string().max(20000).nullable().optional().describe('Markdown detail — context, alternatives, consequences'),
+                status: z
+                    .enum(DECISION_STATUSES)
+                    .optional()
+                    .describe('SUPERSEDED and DEPRECATED are rejected here — use set_status'),
+                source: z.enum(DECISION_SOURCES).optional(),
+                decidedAt: date('When it was decided').nullable().optional(),
+                ownerId: z.string().nullable().optional().describe('User ID of the owner'),
+                transcriptionSessionId: z
+                    .string()
+                    .nullable()
+                    .optional()
+                    .describe('Meeting it came out of. Requires edit access to that meeting'),
+                occurrenceId: z.string().nullable().optional().describe('Recurring-meeting occurrence ID'),
+                ...scopeFields,
+                deciders: z
+                    .array(z.object({
+                    userId: z.string().nullable().optional().describe('Omit for external participants'),
+                    name: z.string(),
+                    email: z.string().nullable().optional(),
+                }))
+                    .max(50)
+                    .optional(),
+                evidence: z
+                    .array(z.object({
+                    turnIndex: z.number().int(),
+                    speaker: z.string().nullable().optional(),
+                    startTime: z.number().nullable().optional(),
+                    text: z.string(),
+                }))
+                    .max(50)
+                    .optional()
+                    .describe('Quoted transcript turns. Requires transcriptionSessionId. Turns whose text does not match the transcript are silently dropped; speaker/startTime are overwritten from the transcript'),
+            }),
+            run: (client, params) => client.decisions.create(params),
+        }),
+        update: op({
+            summary: 'Edit a decision’s content and scope. Only the fields you pass change; status goes through set_status.',
+            params: z.object({
+                workspaceId,
+                decisionId,
+                statement: z.string().max(500).optional(),
+                body: clearable('Markdown body'),
+                decidedAt: date('When it was decided').nullable().optional(),
+                ownerId: clearable('Owner user ID'),
+                ...scopeFields,
+                adrDocumentId: clearable('ADR document this decision is formalised in'),
+            }),
+            run: (client, params) => client.decisions.update(params),
+        }),
+        set_status: op({
+            summary: 'Lifecycle transition — e.g. answer an open question by moving OPEN → ACCEPTED.',
+            params: z.object({
+                workspaceId,
+                decisionId,
+                status: z.enum(DECISION_STATUSES),
+                supersededById: z
+                    .string()
+                    .nullable()
+                    .optional()
+                    .describe('Decision ID that replaces this one; expected when moving to SUPERSEDED'),
+            }),
+            run: (client, params) => client.decisions.setStatus(params),
+        }),
+        link_ticket: op({
+            summary: 'Mark a decision as "implemented by" a ticket. Idempotent: an existing link is returned.',
+            params: z.object({ workspaceId, decisionId, ticketId: id('Ticket') }),
+            run: (client, { workspaceId, decisionId, ticketId }) => client.decisions.linkTicket(workspaceId, decisionId, ticketId),
+        }),
+        link_feature: op({
+            summary: 'Mark a decision as "implemented by" a feature. Idempotent: an existing link is returned.',
+            params: z.object({ workspaceId, decisionId, featureId: id('Feature') }),
+            run: (client, { workspaceId, decisionId, featureId }) => client.decisions.linkFeature(workspaceId, decisionId, featureId),
+        }),
+        unlink: op({
+            summary: 'Remove one ticket/feature link.',
+            params: z.object({
+                workspaceId,
+                linkId: z.string().describe('DecisionLink ID from the decision’s links — not the ticket or feature ID'),
+            }),
+            run: (client, { workspaceId, linkId }) => client.decisions.unlink(workspaceId, linkId),
+        }),
+        confirm_draft: op({
+            summary: 'Publish a DRAFT decision into the log.',
+            params: z.object({ workspaceId, decisionId }),
+            run: (client, { workspaceId, decisionId }) => client.decisions.confirmDraft(workspaceId, decisionId),
+        }),
+        reject_draft: op({
+            summary: 'Reject a DRAFT decision. Confirmed decisions cannot be rejected — deprecate or supersede via set_status.',
+            params: z.object({ workspaceId, decisionId }),
+            run: (client, { workspaceId, decisionId }) => client.decisions.rejectDraft(workspaceId, decisionId),
+        }),
+        delete_draft: op({
+            summary: 'Hard-delete a draft or rejected decision. Refused for confirmed decisions — the log keeps its history.',
+            params: z.object({ workspaceId, decisionId }),
+            run: (client, { workspaceId, decisionId }) => client.decisions.deleteDraft(workspaceId, decisionId),
+        }),
+    },
+};

package/dist/domains/epics.d.ts

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

package/dist/domains/epics.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { date, id, op, workspaceId } from './framework.js';
+const EPIC_STATUSES = ['OPEN', 'IN_PROGRESS', 'DONE', 'CANCELLED'];
+const EPIC_PRIORITIES = ['HIGH', 'MEDIUM', 'LOW', 'NONE'];
+export const epics = {
+    name: 'epics',
+    description: 'Epics: large bodies of work in a workspace that group tickets (`tickets`) and actions (`actions`). Each new epic belongs to a product (`products`); older ones may have none.',
+    operations: {
+        list: op({
+            summary: 'List the epics in a workspace (all products), ordered by status then name.',
+            params: z.object({
+                workspaceId,
+                status: z.enum(EPIC_STATUSES).optional(),
+            }),
+            run: (client, params) => client.epics.list(params),
+        }),
+        get: op({
+            summary: 'Get one epic with its owner, tickets and actions.',
+            params: z.object({ id: id('Epic') }),
+            run: (client, { id }) => client.epics.get(id),
+        }),
+        create: op({
+            summary: 'Create an epic owned by you. Priority defaults to MEDIUM.',
+            params: z.object({
+                workspaceId,
+                productId: id('Product').describe('Product ID; must be in the same workspace'),
+                name: z.string().min(1),
+                description: z.string().optional(),
+                priority: z.enum(EPIC_PRIORITIES).optional(),
+                startDate: date('Start date').optional(),
+                targetDate: date('Target date').optional(),
+            }),
+            run: (client, params) => client.epics.create(params),
+        }),
+        update: op({
+            summary: 'Update an epic. Only the fields you pass change.',
+            params: z.object({
+                id: id('Epic'),
+                name: z.string().min(1).optional(),
+                description: z.string().nullable().optional().describe('null to clear'),
+                status: z.enum(EPIC_STATUSES).optional(),
+                priority: z.enum(EPIC_PRIORITIES).optional(),
+                startDate: date('Start date').nullable().optional().describe('ISO 8601 date or datetime; null to clear'),
+                targetDate: date('Target date').nullable().optional().describe('ISO 8601 date or datetime; null to clear'),
+            }),
+            run: (client, params) => client.epics.update(params),
+        }),
+        delete: op({
+            summary: 'Delete an epic permanently (only its owner or a workspace owner/admin may). Its tickets and actions are kept but unlinked.',
+            params: z.object({ id: id('Epic') }),
+            run: (client, { id }) => client.epics.delete(id),
+        }),
+    },
+};

package/dist/domains/features.d.ts

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

package/dist/domains/features.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { id, op } from './framework.js';
+const FEATURE_STATUSES = [
+    'IDEA',
+    'DEFINED',
+    'IN_PROGRESS',
+    'SHIPPED',
+    'DEPRECATED',
+    'ARCHIVED',
+];
+const priority = z.number().int().min(0).max(4).optional().describe('0–4; lower is higher priority');
+const goalId = z.number().int().describe('Objective (goal) ID — an integer, unlike most IDs');
+export const features = {
+    name: 'features',
+    description: 'Product features: long-lived capabilities of a product (see `products`), filed under an area (`areas`). A feature’s shippable increments are in `scopes`, its "shall" statements in `requirements`, and its spec documents are Knowledge pages (`pages`) linked here.',
+    operations: {
+        list: op({
+            summary: 'List a product’s features, newest first, with goal, area, lean key-result links and scope/requirement/ticket counts.',
+            params: z.object({
+                productId: id('Product'),
+                status: z.enum(FEATURE_STATUSES).optional(),
+            }),
+            run: (client, params) => client.features.list(params),
+        }),
+        get: op({
+            summary: 'Get one feature with its scopes, requirements and key-result progress.',
+            params: z.object({ id: id('Feature') }),
+            run: (client, { id }) => client.features.get(id),
+        }),
+        create: op({
+            summary: 'Create a feature in a product. Status defaults to IDEA.',
+            params: z.object({
+                productId: id('Product'),
+                name: z.string(),
+                description: z.string().optional().describe('Markdown PRD body'),
+                vision: z.string().optional(),
+                status: z.enum(FEATURE_STATUSES).optional(),
+                effort: z.number().optional(),
+                priority,
+                goalId: goalId.optional(),
+                areaId: id('Area').optional().describe('Area ID; must belong to the same product'),
+            }),
+            run: (client, params) => client.features.create(params),
+        }),
+        update: op({
+            summary: 'Update a feature. Only the fields you pass change; a feature that was ever live cannot be ARCHIVED (deprecate it instead).',
+            params: z.object({
+                id: id('Feature'),
+                name: z.string().optional(),
+                description: z
+                    .string()
+                    .optional()
+                    .describe('Markdown PRD body; replaces the whole body (the rich doc is re-derived server-side)'),
+                vision: z.string().optional(),
+                status: z.enum(FEATURE_STATUSES).optional(),
+                effort: z.number().optional(),
+                priority,
+                goalId: goalId.nullable().optional().describe('Objective (goal) ID, an integer (null to clear)'),
+                areaId: z.string().nullable().optional().describe('Area ID (null to clear)'),
+            }),
+            run: (client, params) => client.features.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a feature permanently, cascading its scopes, requirements, user stories, comments and page links; linked tickets are kept but unlinked.',
+            params: z.object({ id: id('Feature') }),
+            run: (client, { id }) => client.features.delete(id),
+        }),
+        link_page: op({
+            summary: 'Link a Knowledge page (PRD, spec, research) to a feature. Idempotent: re-linking updates the scope pin. Page must be in the feature’s workspace.',
+            params: z.object({
+                featureId: id('Feature'),
+                pageId: id('Page'),
+                scopeId: z
+                    .string()
+                    .optional()
+                    .describe('Pin the page to one of this feature’s scopes; omitting it on a re-link clears an existing pin'),
+            }),
+            run: (client, params) => client.features.linkPage(params),
+        }),
+        unlink_page: op({
+            summary: 'Unlink a page from a feature. The page itself is not deleted; no-op if not linked.',
+            params: z.object({
+                featureId: id('Feature'),
+                pageId: id('Page'),
+            }),
+            run: (client, { featureId, pageId }) => client.features.unlinkPage(featureId, pageId),
+        }),
+    },
+};

package/dist/domains/framework.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Domain tools: one MCP tool per SDK namespace, taking `{ operation, params }`.
+ *
+ * Each operation declares its params once, as a zod object. That single schema
+ * drives the one-line signature in the tool description, the full JSON Schema
+ * returned by `operation: "describe"`, and runtime validation — so the three
+ * cannot drift apart. A validation failure returns the schema it expected, so
+ * the model can correct itself on the next call without a separate lookup.
+ */
+import { z } from 'zod';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { ExponentialClient } from 'exponential-sdk';
+export interface Operation<S extends z.AnyZodObject = z.AnyZodObject> {
+    /** One line: what the operation does and anything surprising about it. */
+    summary: string;
+    params: S;
+    run: (client: ExponentialClient, params: z.infer<S>) => Promise<unknown>;
+}
+export interface Domain {
+    /** Tool name, e.g. `contacts`. */
+    name: string;
+    /** One or two sentences: what the domain is and how it relates to others. */
+    description: string;
+    operations: Record<string, Operation<any>>;
+}
+/** Identity helper that keeps `params` inferred per operation. */
+export declare function op<S extends z.AnyZodObject>(operation: Operation<S>): Operation<S>;
+/** Shared param building blocks. */
+export declare const id: (what: string) => z.ZodString;
+export declare const workspaceId: z.ZodString;
+/** ISO date or datetime; coerced to a Date before it reaches the SDK. */
+export declare const date: (what: string) => z.ZodDate;
+export declare function toolDefinition(domain: Domain): Tool;
+export declare function runDomainTool(domain: Domain, client: ExponentialClient, args: Record<string, unknown> | undefined): Promise<unknown>;

package/dist/domains/framework.js

@@ -0,0 +1,94 @@
+/**
+ * Domain tools: one MCP tool per SDK namespace, taking `{ operation, params }`.
+ *
+ * Each operation declares its params once, as a zod object. That single schema
+ * drives the one-line signature in the tool description, the full JSON Schema
+ * returned by `operation: "describe"`, and runtime validation — so the three
+ * cannot drift apart. A validation failure returns the schema it expected, so
+ * the model can correct itself on the next call without a separate lookup.
+ */
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+/** Identity helper that keeps `params` inferred per operation. */
+export function op(operation) {
+    return operation;
+}
+/** Shared param building blocks. */
+export const id = (what) => z.string().describe(`${what} ID`);
+export const workspaceId = z.string().describe('Workspace ID (see the `workspaces` tool)');
+/** ISO date or datetime; coerced to a Date before it reaches the SDK. */
+export const date = (what) => z.coerce.date().describe(`${what} (ISO 8601 date or datetime)`);
+const DESCRIBE = 'describe';
+function signature(name, params) {
+    const keys = Object.entries(params.shape).map(([key, schema]) => (schema.isOptional() ? `${key}?` : key));
+    return `${name}(${keys.join(', ')})`;
+}
+function paramsJsonSchema(params) {
+    // Cast: zodToJsonSchema's generics recurse too deep on a bare AnyZodObject (TS2589).
+    const { $schema: _ignored, ...schema } = zodToJsonSchema(params, {
+        target: 'jsonSchema7',
+        $refStrategy: 'none',
+    });
+    return schema;
+}
+export function toolDefinition(domain) {
+    const operations = Object.keys(domain.operations);
+    const lines = Object.entries(domain.operations).map(([name, operation]) => `- ${signature(name, operation.params)} — ${operation.summary}`);
+    return {
+        name: domain.name,
+        description: [
+            domain.description,
+            '',
+            'Call with { operation, params }. Operations (? = optional param):',
+            ...lines,
+            `- ${DESCRIBE}(operation?) — full parameter schema for one operation, or all of them.`,
+        ].join('\n'),
+        inputSchema: {
+            type: 'object',
+            properties: {
+                operation: { type: 'string', enum: [...operations, DESCRIBE] },
+                params: {
+                    type: 'object',
+                    description: 'Parameters for the operation, as listed in the tool description.',
+                },
+            },
+            required: ['operation'],
+        },
+    };
+}
+function describe(domain, only) {
+    const names = typeof only === 'string' && only ? [only] : Object.keys(domain.operations);
+    const out = {};
+    for (const name of names) {
+        const operation = domain.operations[name];
+        if (!operation) {
+            throw new Error(`Unknown operation "${name}" for ${domain.name}. Valid: ${Object.keys(domain.operations).join(', ')}`);
+        }
+        out[name] = { summary: operation.summary, params: paramsJsonSchema(operation.params) };
+    }
+    return out;
+}
+export async function runDomainTool(domain, client, args) {
+    const operationName = args?.operation;
+    const rawParams = (args?.params ?? {});
+    if (operationName === DESCRIBE) {
+        return describe(domain, rawParams.operation);
+    }
+    const operation = typeof operationName === 'string' ? domain.operations[operationName] : undefined;
+    if (!operation) {
+        throw new Error(`Unknown operation "${String(operationName)}" for ${domain.name}. Valid: ${[
+            ...Object.keys(domain.operations),
+            DESCRIBE,
+        ].join(', ')}`);
+    }
+    const parsed = operation.params.safeParse(rawParams);
+    if (!parsed.success) {
+        const issues = parsed.error.issues
+            .map((issue) => `${issue.path.join('.') || 'params'}: ${issue.message}`)
+            .join('; ');
+        throw new Error(`Invalid params for ${domain.name}.${operationName}: ${issues}\nExpected: ${JSON.stringify(paramsJsonSchema(operation.params))}`);
+    }
+    const result = await operation.run(client, parsed.data);
+    // Void SDK calls (deletes) would otherwise serialize to nothing.
+    return result === undefined ? { success: true } : result;
+}

package/dist/domains/goals.d.ts

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

package/dist/domains/goals.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { date, id, op, workspaceId } from './framework.js';
+const GOAL_STATUSES = ['planned', 'active', 'completed', 'archived', 'on-hold'];
+/** `goals.update` rejects `on-hold`; only `set_status` accepts it. */
+const WRITABLE_STATUSES = ['planned', 'active', 'completed', 'archived'];
+/** Objectives are keyed by integer id, unlike most cuid-keyed entities. */
+const goalId = (what = 'Objective (goal)') => z.number().int().describe(`${what} ID — an integer`);
+const period = z.string().describe('Free-form OKR period, e.g. "Q3-2026", "H1-2027", "Annual-2026" (see `periods`)');
+const clearable = (what) => z.string().nullable().optional().describe(`${what} (null to clear)`);
+export const goals = {
+    name: 'goals',
+    description: 'Objectives (`Goal`) — the qualitative half of an OKR, keyed by integer id and nestable up to 5 levels. Their measurable key results live in the `key_results` tool; discussion on an objective is in `comments` (target "goal").',
+    operations: {
+        list: op({
+            summary: 'List objectives with their linked projects. With workspaceId: every member’s; without: only your own.',
+            params: z.object({
+                workspaceId: workspaceId.optional().describe('Workspace ID for the workspace-wide list; omit for only your own'),
+                period: period.optional(),
+                status: z.enum(GOAL_STATUSES).optional(),
+            }),
+            run: (client, params) => client.goals.list(params),
+        }),
+        tree: op({
+            summary: 'Objectives nested parent → child (up to 5 levels), each with projects and key results. Only roots at top level.',
+            params: z.object({
+                workspaceId: workspaceId.optional(),
+                status: z.enum(GOAL_STATUSES).optional(),
+            }),
+            run: (client, params) => client.goals.tree(params),
+        }),
+        get: op({
+            summary: 'Get one objective.',
+            params: z.object({ id: goalId() }),
+            run: (client, { id }) => client.goals.get(id),
+        }),
+        list_by_project: op({
+            summary: 'Objectives linked to a given project.',
+            params: z.object({ projectId: id('Project') }),
+            run: (client, { projectId }) => client.goals.listByProject(projectId),
+        }),
+        create: op({
+            summary: 'Create an objective, optionally nested under a parent and linked to one project.',
+            params: z.object({
+                title: z.string(),
+                description: z.string().optional(),
+                whyThisGoal: z.string().optional(),
+                notes: z.string().optional(),
+                dueDate: date('Due date').optional(),
+                period: period.optional(),
+                status: z.enum(WRITABLE_STATUSES).optional(),
+                lifeDomainId: z.number().int().optional(),
+                projectId: id('Project').optional().describe('Link the objective to one project on creation'),
+                outcomeIds: z.array(z.string()).optional(),
+                driUserId: id('Directly responsible user').optional(),
+                workspaceId: workspaceId.optional(),
+                parentGoalId: goalId('Parent objective').optional().describe('Nest under this objective (integer ID). Max nesting depth is 5'),
+                icon: z.string().nullable().optional(),
+                iconColor: z.string().nullable().optional(),
+            }),
+            run: (client, params) => client.goals.create(params),
+        }),
+        update: op({
+            summary: 'Partial update: omitted fields are untouched, null clears. Prefer set_status / set_parent when that is all you change.',
+            params: z.object({
+                id: goalId(),
+                title: z.string().optional(),
+                description: clearable('Description'),
+                whyThisGoal: clearable('Why this goal'),
+                notes: clearable('Notes'),
+                dueDate: date('Due date').nullable().optional().describe('Due date, ISO 8601 (null to clear)'),
+                period: clearable('Free-form OKR period, e.g. "Q3-2026"'),
+                status: z.enum(WRITABLE_STATUSES).optional().describe('"on-hold" is only accepted by set_status'),
+                lifeDomainId: z.number().int().nullable().optional(),
+                projectId: clearable('Replace the project links with this one project'),
+                projectIds: z.array(z.string()).optional().describe('Replace the project links wholesale; [] clears them'),
+                outcomeIds: z.array(z.string()).optional(),
+                driUserId: clearable('Directly responsible user ID'),
+                workspaceId: clearable('Workspace ID'),
+                parentGoalId: z.number().int().nullable().optional().describe('Parent objective integer ID (null to detach)'),
+                displayOrder: z.number().int().optional(),
+                icon: z.string().nullable().optional(),
+                iconColor: z.string().nullable().optional(),
+            }),
+            run: (client, params) => client.goals.update(params),
+        }),
+        set_status: op({
+            summary: 'Status-only write; the only path that accepts "on-hold". Moving to "completed" also records a workspace milestone.',
+            params: z.object({
+                id: goalId(),
+                status: z.enum(GOAL_STATUSES),
+            }),
+            run: (client, params) => client.goals.setStatus(params),
+        }),
+        set_parent: op({
+            summary: 'Re-parent an objective (or detach with null). Writes only parentGoalId; rejects self-parenting, cycles and depth > 5.',
+            params: z.object({
+                id: goalId(),
+                parentGoalId: z.number().int().nullable().describe('New parent objective integer ID, or null to detach'),
+            }),
+            run: (client, params) => client.goals.setParent(params),
+        }),
+        delete: op({
+            summary: 'Delete an objective permanently. Its key results are deleted with it; child objectives are detached, not deleted.',
+            params: z.object({ id: goalId() }),
+            run: (client, { id }) => client.goals.delete(id),
+        }),
+        periods: op({
+            summary: 'The conventional period strings (quarters, halves, annual) for this year and next.',
+            params: z.object({}),
+            run: (client) => client.goals.periods(),
+        }),
+        stats: op({
+            summary: 'Aggregate objective/key-result counts, status breakdown and average progress.',
+            params: z.object({
+                workspaceId: workspaceId.optional(),
+                period: period.optional(),
+            }),
+            run: (client, params) => client.goals.stats(params),
+        }),
+    },
+};

package/dist/domains/index.d.ts

@@ -0,0 +1,5 @@
+import type { Domain } from './framework.js';
+export { runDomainTool, toolDefinition } from './framework.js';
+export type { Domain } from './framework.js';
+/** Every domain tool, keyed by tool name. */
+export declare const DOMAINS: ReadonlyMap<string, Domain>;

package/dist/domains/index.js

@@ -0,0 +1,48 @@
+import { actions } from './actions.js';
+import { areas } from './areas.js';
+import { comments } from './comments.js';
+import { contacts } from './contacts.js';
+import { deals } from './deals.js';
+import { decisions } from './decisions.js';
+import { epics } from './epics.js';
+import { features } from './features.js';
+import { goals } from './goals.js';
+import { keyResults } from './keyResults.js';
+import { labels } from './labels.js';
+import { meetings } from './meetings.js';
+import { organizations } from './organizations.js';
+import { pages } from './pages.js';
+import { products } from './products.js';
+import { projects } from './projects.js';
+import { requirements } from './requirements.js';
+import { scopes } from './scopes.js';
+import { stories } from './stories.js';
+import { tickets } from './tickets.js';
+import { time } from './time.js';
+import { workspaces } from './workspaces.js';
+export { runDomainTool, toolDefinition } from './framework.js';
+/** Every domain tool, keyed by tool name. */
+export const DOMAINS = new Map([
+    actions,
+    projects,
+    workspaces,
+    goals,
+    keyResults,
+    meetings,
+    time,
+    decisions,
+    contacts,
+    organizations,
+    deals,
+    products,
+    features,
+    scopes,
+    requirements,
+    areas,
+    stories,
+    epics,
+    tickets,
+    labels,
+    pages,
+    comments,
+].map((domain) => [domain.name, domain]));

package/dist/domains/keyResults.d.ts

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