exponential-mcp 0.6.0 → 0.7.0

package/dist/domains/keyResults.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { id, op, workspaceId } from './framework.js';
+const KR_STATUSES = ['not-started', 'on-track', 'at-risk', 'off-track', 'achieved'];
+const KR_UNITS = ['percent', 'count', 'currency', 'hours', 'custom'];
+/** Key results are cuid-keyed; the objective they hang off is an integer. */
+const keyResultId = id('Key result');
+const goalId = z.number().int().describe('Objective (goal) ID — an integer, unlike the key result’s own cuid');
+const period = z.string().describe('Free-form OKR period, e.g. "Q3-2026" (see `goals` periods)');
+export const keyResults = {
+    name: 'key_results',
+    description: 'Key results — the measurable half of an OKR, each hanging off one objective. Objectives themselves are in the `goals` tool; key results can be linked to projects and features as the work that moves them.',
+    operations: {
+        list: op({
+            summary: 'List key results. With workspaceId: every member’s (older servers may return only yours — prefer by_objective); without: only your own.',
+            params: z.object({
+                workspaceId: workspaceId.optional(),
+                goalId: goalId.optional(),
+                period: period.optional(),
+                status: z.enum(KR_STATUSES).optional(),
+                onlyMine: z.boolean().optional().describe('Narrow a workspace-scoped list back to key results you own'),
+            }),
+            run: (client, params) => client.keyResults.list(params),
+        }),
+        by_objective: op({
+            summary: 'Objectives with their key results nested and progress/status counts — the richest OKR read; workspace-correct on every server.',
+            params: z.object({
+                workspaceId: workspaceId.optional(),
+                period: period.optional(),
+                includePairedPeriod: z
+                    .boolean()
+                    .optional()
+                    .describe('Also include the period’s parent annual period (Q3-2026 → Annual-2026)'),
+                onlyMine: z.boolean().optional(),
+            }),
+            run: (client, params) => client.keyResults.byObjective(params),
+        }),
+        get: op({
+            summary: 'Get one key result with its check-ins and linked projects/features.',
+            params: z.object({ id: keyResultId }),
+            run: (client, { id }) => client.keyResults.get(id),
+        }),
+        create: op({
+            summary: 'Create a key result on an objective. Omit workspaceId to inherit the objective’s workspace.',
+            params: z.object({
+                goalId,
+                title: z.string(),
+                targetValue: z.number(),
+                period,
+                description: z.string().optional(),
+                startValue: z.number().optional(),
+                currentValue: z.number().optional(),
+                unit: z.enum(KR_UNITS).optional(),
+                unitLabel: z.string().optional().describe('Display label for the unit, e.g. "users" or "€"'),
+                driUserId: id('Directly responsible user').optional(),
+                workspaceId: workspaceId.optional(),
+            }),
+            run: (client, params) => client.keyResults.create(params),
+        }),
+        update: op({
+            summary: 'Update a key result. Only the fields you pass change. Use check_in to record progress with history.',
+            params: z.object({
+                id: keyResultId,
+                title: z.string().optional(),
+                description: z.string().optional(),
+                targetValue: z.number().optional(),
+                currentValue: z.number().optional(),
+                startValue: z.number().optional(),
+                unit: z.enum(KR_UNITS).optional(),
+                unitLabel: z.string().optional(),
+                status: z.enum(KR_STATUSES).optional(),
+                confidence: z.number().min(0).max(100).optional().describe('0–100'),
+                driUserId: id('Directly responsible user').optional(),
+                goalId: goalId.optional().describe('Move the key result to a different objective (integer ID)'),
+            }),
+            run: (client, params) => client.keyResults.update(params),
+        }),
+        check_in: op({
+            summary: 'Record a progress check-in. The server re-derives status from where value lands between start and target.',
+            params: z.object({
+                id: keyResultId,
+                value: z.number().describe('The new current value'),
+                note: z.string().optional(),
+            }),
+            run: (client, params) => client.keyResults.checkIn(params),
+        }),
+        delete: op({
+            summary: 'Delete a key result permanently.',
+            params: z.object({ id: keyResultId }),
+            run: (client, { id }) => client.keyResults.delete(id),
+        }),
+        link_project: op({
+            summary: 'Link a project to a key result as executing work. Idempotent.',
+            params: z.object({ keyResultId, projectId: id('Project') }),
+            run: (client, params) => client.keyResults.linkProject(params),
+        }),
+        unlink_project: op({
+            summary: 'Remove a project link from a key result.',
+            params: z.object({ keyResultId, projectId: id('Project') }),
+            run: (client, params) => client.keyResults.unlinkProject(params),
+        }),
+        link_feature: op({
+            summary: 'Link a feature as executing work. Idempotent; feature must be in the same workspace. An unaligned feature inherits the objective.',
+            params: z.object({ keyResultId, featureId: id('Feature') }),
+            run: (client, params) => client.keyResults.linkFeature(params),
+        }),
+        unlink_feature: op({
+            summary: 'Remove a feature link. Removes only the link row — never the feature’s objective alignment.',
+            params: z.object({ keyResultId, featureId: id('Feature') }),
+            run: (client, params) => client.keyResults.unlinkFeature(params),
+        }),
+    },
+};

package/dist/domains/labels.d.ts

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

package/dist/domains/labels.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { id, op, workspaceId } from './framework.js';
+const ENTITY_TYPES = ['action', 'ticket', 'feature', 'epic'];
+const TAG_COLORS = [
+    'avatar-red',
+    'avatar-teal',
+    'avatar-blue',
+    'avatar-green',
+    'avatar-yellow',
+    'avatar-plum',
+    'avatar-mint',
+    'avatar-lightYellow',
+    'avatar-lightPurple',
+    'avatar-lightBlue',
+    'avatar-orange',
+    'avatar-lightGreen',
+    'avatar-lightRed',
+    'avatar-skyBlue',
+    'avatar-paleGreen',
+    'avatar-paleYellow',
+    'avatar-lavender',
+    'avatar-powderBlue',
+    'avatar-lightPink',
+    'avatar-lightGray',
+    'brand-primary',
+    'brand-success',
+    'brand-warning',
+    'brand-error',
+    'brand-info',
+];
+const category = z
+    .string()
+    .nullable()
+    .optional()
+    .describe('Tag category; null means a plain label');
+export const labels = {
+    name: 'labels',
+    description: 'Labels (tags) that can be attached to actions (`actions`), tickets (`tickets`), features (`features`) and epics (`epics`). There are global system tags and per-workspace tags; a "label" is a tag whose category is null.',
+    operations: {
+        list: op({
+            summary: 'List available tags as { globalTags, workspaceTags, allTags }. Without workspaceId, workspaceTags covers every workspace you belong to. Omit category for all categories; null for plain labels only.',
+            params: z.object({
+                workspaceId: workspaceId.optional(),
+                category,
+            }),
+            run: (client, params) => client.labels.list(params),
+        }),
+        create: op({
+            summary: 'Create a workspace tag. Fails if a tag with the same name (slug) already exists in the workspace.',
+            params: z.object({
+                workspaceId,
+                name: z.string().min(1).max(50),
+                color: z.string().describe(`One of: ${TAG_COLORS.join(', ')}`),
+                description: z.string().max(200).optional(),
+                category,
+            }),
+            run: (client, params) => client.labels.create(params),
+        }),
+        set_for_entity: op({
+            summary: 'Replace the full tag set on an action, ticket, feature or epic (an empty list clears it). Tags must be global or from the entity’s workspace.',
+            params: z.object({
+                entityType: z.enum(ENTITY_TYPES),
+                entityId: z.string().describe('ID of the action, ticket, feature or epic'),
+                tagIds: z.array(id('Tag')),
+            }),
+            run: (client, params) => client.labels.setEntityTags(params),
+        }),
+        list_for_entity: op({
+            summary: 'List the tags on an action, ticket, feature or epic.',
+            params: z.object({
+                entityType: z.enum(ENTITY_TYPES),
+                entityId: z.string().describe('ID of the action, ticket, feature or epic'),
+            }),
+            run: (client, params) => client.labels.listForEntity(params),
+        }),
+    },
+};

package/dist/domains/meetings.d.ts

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

package/dist/domains/meetings.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { date, id, op } from './framework.js';
+const meetingId = id('Meeting');
+export const meetings = {
+    name: 'meetings',
+    description: 'Meetings (transcription sessions): recorded, imported or manually created, each with free-form `notes`, an AI `summary` and the raw `transcription`. Actions extracted from them are in the `actions` tool; people in `contacts`.',
+    operations: {
+        list: op({
+            summary: 'List meetings you can see (owner, participant, project or workspace access), newest first. Rows include full notes/summary/transcription — expect large payloads.',
+            params: z.object({
+                workspaceId: z
+                    .string()
+                    .optional()
+                    .describe('Workspace ID (see the `workspaces` tool); omit for all workspaces'),
+                includeArchived: z.boolean().optional(),
+                meetingType: z
+                    .enum(['all', 'mine', 'one_on_one', 'customer', 'internal'])
+                    .optional()
+                    .describe('mine = you own or attend; one_on_one = exactly two participants; customer/internal always empty for now'),
+            }),
+            run: (client, params) => client.meetings.list(params),
+        }),
+        get: op({
+            summary: 'Get one meeting with participants, linked actions, workspace and project.',
+            params: z.object({ id: meetingId }),
+            run: (client, { id }) => client.meetings.get(id),
+        }),
+        create: op({
+            summary: 'Create a meeting manually. A project-linked meeting inherits its project’s workspace.',
+            params: z.object({
+                title: z.string(),
+                transcription: z.string().min(1).describe('Raw transcript text (required, non-empty)'),
+                description: z.string().optional(),
+                notes: z.string().optional().describe('Meeting notes (Markdown)'),
+                meetingDate: date('When the meeting happened').optional(),
+                projectId: id('Project').optional(),
+                workspaceId: z.string().optional().describe('Workspace ID (see the `workspaces` tool)'),
+                participants: z
+                    .array(z.object({
+                    userId: z.string().optional().describe('Workspace member user ID'),
+                    contactId: z.string().optional().describe('CRM contact ID'),
+                    email: z.string().optional(),
+                    name: z.string().optional(),
+                }))
+                    .optional()
+                    .describe('Each: a member (userId), a CRM contact (contactId), or a name/email'),
+            }),
+            run: (client, params) => client.meetings.create(params),
+        }),
+        update: op({
+            summary: 'Update a meeting. Only the fields you pass change; passing none is an error. `notes` replaces the whole body — use append_notes to add.',
+            params: z.object({
+                id: meetingId,
+                title: z.string().optional(),
+                description: z.string().optional(),
+                notes: z.string().optional(),
+                summary: z.string().optional(),
+                transcription: z.string().optional(),
+                meetingDate: date('When the meeting happened').nullable().optional(),
+                workspaceId: z.string().nullable().optional().describe('Workspace ID (null to clear)'),
+            }),
+            run: (client, params) => client.meetings.update(params),
+        }),
+        get_notes: op({
+            summary: 'Get just the meeting’s notes body (null when none written).',
+            params: z.object({ id: meetingId }),
+            run: (client, { id }) => client.meetings.getNotes(id),
+        }),
+        set_notes: op({
+            summary: 'Replace the meeting’s notes wholesale.',
+            params: z.object({ id: meetingId, notes: z.string() }),
+            run: (client, { id, notes }) => client.meetings.setNotes(id, notes),
+        }),
+        append_notes: op({
+            summary: 'Append a block to the meeting’s notes (blank-line separated), creating them if empty. Read-modify-write, not atomic.',
+            params: z.object({ id: meetingId, text: z.string() }),
+            run: (client, { id, text }) => client.meetings.appendNotes(id, text),
+        }),
+        delete: op({
+            summary: 'Permanently delete one meeting you own (FORBIDDEN otherwise). Linked actions survive, unlinked.',
+            params: z.object({ id: meetingId }),
+            run: (client, { id }) => client.meetings.delete(id),
+        }),
+        delete_many: op({
+            summary: 'Permanently delete meetings in bulk. Ids that are missing or not yours are silently skipped — compare the returned count to what you sent.',
+            params: z.object({ ids: z.array(meetingId) }),
+            run: (client, { ids }) => client.meetings.deleteMany(ids),
+        }),
+    },
+};

package/dist/domains/organizations.d.ts

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

package/dist/domains/organizations.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { id, op, workspaceId } from './framework.js';
+const ORGANIZATION_SIZES = ['1-10', '11-50', '51-200', '201-500', '501-1000', '1000+'];
+export const organizations = {
+    name: 'organizations',
+    description: 'CRM organizations (companies) in a workspace. People are in the `contacts` tool and deals in `deals`.',
+    operations: {
+        list: op({
+            summary: 'List organizations alphabetically, with contact counts. Paginate with the returned nextCursor.',
+            params: z.object({
+                workspaceId,
+                search: z.string().optional().describe('Case-insensitive match on name or description'),
+                industry: z.string().optional().describe('Exact match'),
+                limit: z.number().int().min(1).max(100).optional().describe('Default 50'),
+                cursor: z.string().optional(),
+            }),
+            run: (client, params) => client.organizations.list(params),
+        }),
+        get: op({
+            summary: 'Get one organization.',
+            params: z.object({ id: id('Organization') }),
+            run: (client, { id }) => client.organizations.get(id),
+        }),
+        create: op({
+            summary: 'Create an organization.',
+            params: z.object({
+                workspaceId,
+                name: z.string(),
+                websiteUrl: z.string().nullable().optional().describe('Full URL including scheme'),
+                logoUrl: z.string().nullable().optional().describe('Full URL including scheme'),
+                description: z.string().optional(),
+                industry: z.string().optional(),
+                size: z.enum(ORGANIZATION_SIZES).optional().describe('Headcount band'),
+            }),
+            run: (client, params) => client.organizations.create(params),
+        }),
+    },
+};

package/dist/domains/pages.d.ts

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

package/dist/domains/pages.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { id, op, workspaceId } from './framework.js';
+export const pages = {
+    name: 'pages',
+    description: 'Knowledge pages: workspace-scoped Markdown documents (PRDs, research, technical specs), optionally filed under a project. Link one to a feature with `features` link_page; page comments are in the `comments` tool.',
+    operations: {
+        list: op({
+            summary: 'List pages you can view, most recently edited first. Returns metadata only (no body) — use get for the content.',
+            params: z.object({
+                workspaceId,
+                projectId: id('Project').optional(),
+                search: z.string().optional().describe('Case-insensitive match on title only'),
+            }),
+            run: (client, params) => client.pages.list(params),
+        }),
+        get: op({
+            summary: 'Get one page with its Markdown body and whether you can edit it (canEdit).',
+            params: z.object({ id: id('Page') }),
+            run: (client, { id }) => client.pages.get(id),
+        }),
+        create: op({
+            summary: 'Create a page. Title defaults to "Untitled"; a non-empty body is indexed for search.',
+            params: z.object({
+                workspaceId,
+                projectId: z.string().nullable().optional().describe('Project ID to file it under (null/omit = workspace-level)'),
+                title: z.string().optional(),
+                body: z.string().optional().describe('Markdown body'),
+                includeInSearch: z.boolean().optional().describe('Default true'),
+            }),
+            run: (client, params) => client.pages.create(params),
+        }),
+        update: op({
+            summary: 'Update a page. Only the fields you pass change; body replaces the whole document (comment anchors are carried across where their text survives).',
+            params: z.object({
+                id: id('Page'),
+                title: z.string().optional(),
+                projectId: z.string().nullable().optional().describe('Project ID (null to move to workspace-level)'),
+                includeInSearch: z.boolean().optional(),
+                body: z.string().optional().describe('Markdown body; replaces the existing body entirely'),
+            }),
+            run: (client, params) => client.pages.update(params),
+        }),
+    },
+};

package/dist/domains/products.d.ts

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

package/dist/domains/products.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { id, op, workspaceId } from './framework.js';
+const productFields = {
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    color: z.string().optional(),
+};
+export const products = {
+    name: 'products',
+    description: 'Products: the container under a workspace that owns features (`features`), tickets (`tickets`), product epics (`epics`) and research. Most product-side tools need a product ID — find it here by slug or ID.',
+    operations: {
+        list: op({
+            summary: 'List the products in a workspace.',
+            params: z.object({ workspaceId }),
+            run: (client, { workspaceId }) => client.products.list(workspaceId),
+        }),
+        get: op({
+            summary: 'Get one product by ID, or by slug when workspaceId is given (a slug-or-ID with workspaceId tries the ID first, then the slug).',
+            params: z.object({
+                slugOrId: z.string().describe('Product ID, or its URL slug (slug requires workspaceId)'),
+                workspaceId: workspaceId.optional().describe('Required to look up by slug'),
+            }),
+            run: (client, { slugOrId, workspaceId }) => workspaceId ? client.products.resolve(workspaceId, slugOrId) : client.products.get(slugOrId),
+        }),
+        create: op({
+            summary: 'Create a product in a workspace. The slug must be unique within the workspace.',
+            params: z.object({
+                workspaceId,
+                name: z.string(),
+                slug: z
+                    .string()
+                    .regex(/^[a-z0-9-]+$/)
+                    .describe('Kebab-case URL slug (a–z, 0–9, hyphens)'),
+                ...productFields,
+            }),
+            run: (client, params) => client.products.create(params),
+        }),
+        update: op({
+            summary: 'Update a product. Only the fields you pass change.',
+            params: z.object({
+                id: id('Product'),
+                name: z.string().optional(),
+                ...productFields,
+                funTicketIds: z
+                    .boolean()
+                    .optional()
+                    .describe('Give new tickets word-pair shortIds (e.g. "prime.toucan") instead of plain numbers'),
+            }),
+            run: (client, params) => client.products.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a product permanently. Cascades: all its features, tickets, research, insights and product-bound epics are deleted too. Cycles and retrospectives survive, unlinked.',
+            params: z.object({ id: id('Product') }),
+            run: (client, { id }) => client.products.delete(id),
+        }),
+    },
+};

package/dist/domains/projects.d.ts

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

package/dist/domains/projects.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { date, id, op } from './framework.js';
+const clearableDate = (what) => date(what).nullable().optional().describe(`${what} (ISO 8601; null to clear)`);
+export const projects = {
+    name: 'projects',
+    description: 'Projects: containers of actions, optionally linked to a product, objectives (goals) and key results. Their actions are in the `actions` tool; workspaces in `workspaces`.',
+    operations: {
+        list: op({
+            summary: 'List projects you can see. Carries no OKR links — use get for those.',
+            params: z.object({
+                workspaceId: z
+                    .string()
+                    .optional()
+                    .describe('Workspace ID (see the `workspaces` tool); omit for all workspaces'),
+                includeActions: z.boolean().optional(),
+            }),
+            run: (client, params) => client.projects.list(params),
+        }),
+        get: op({
+            summary: 'Get one project with its actions, linked objectives and key results, DRI and team — the only way to see what a project is driving.',
+            params: z.object({
+                id: z.string().describe('Project cuid, slug, or the `slug-cuid` form from app URLs'),
+            }),
+            run: (client, { id }) => client.projects.get(id),
+        }),
+        update: op({
+            summary: 'Update a project. Only the fields you pass change (omitted name/status/priority cost one extra read).',
+            params: z.object({
+                id: id('Project'),
+                name: z.string().optional(),
+                description: z.string().optional().describe("Pass '' to blank it; there is no null-to-clear"),
+                status: z.enum(['ACTIVE', 'ON_HOLD', 'COMPLETED', 'CANCELLED']).optional(),
+                priority: z.enum(['HIGH', 'MEDIUM', 'LOW', 'NONE']).optional(),
+                productId: z.string().nullable().optional().describe('Product ID (null to unlink)'),
+                workspaceId: z.string().nullable().optional().describe('Workspace ID (null makes the project personal)'),
+                driId: z.string().nullable().optional().describe('User ID of the directly responsible individual (null to clear)'),
+                goalIds: z
+                    .array(z.string())
+                    .optional()
+                    .describe('Replace objective links; integer goal ids as strings. [] is a no-op, not a clear'),
+                outcomeIds: z.array(z.string()).optional(),
+                keyResultIds: z.array(z.string()).optional().describe('Replace key-result links wholesale; [] clears them'),
+                lifeDomainIds: z.array(z.number().int()).optional(),
+                reviewDate: clearableDate('Review date'),
+                nextActionDate: clearableDate('Next action date'),
+                startDate: clearableDate('Start date'),
+                endDate: clearableDate('End date'),
+            }),
+            run: (client, params) => client.projects.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a project AND all its actions. No undo.',
+            params: z.object({ id: id('Project') }),
+            run: (client, { id }) => client.projects.delete(id),
+        }),
+    },
+};

package/dist/domains/requirements.d.ts

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

package/dist/domains/requirements.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { id, op } from './framework.js';
+export const requirements = {
+    name: 'requirements',
+    description: 'Requirements on a feature: atomic EARS-style "shall" statements, optionally pinned to one of its scopes, each checkable met/unmet. Features are in `features`, scopes in `scopes`.',
+    operations: {
+        list: op({
+            summary: 'List a feature’s requirements in display order, optionally only those pinned to one scope.',
+            params: z.object({
+                featureId: id('Feature'),
+                scopeId: id('Scope').optional(),
+            }),
+            run: (client, params) => client.requirements.list(params),
+        }),
+        create: op({
+            summary: 'Add a requirement to the end of a feature’s list.',
+            params: z.object({
+                featureId: id('Feature'),
+                scopeId: id('Scope').optional().describe('Scope ID; must belong to the same feature'),
+                statement: z.string().describe('One EARS-style "shall" statement'),
+                kind: z.enum(['FUNCTIONAL', 'NON_FUNCTIONAL', 'CONSTRAINT']).optional(),
+            }),
+            run: (client, params) => client.requirements.create(params),
+        }),
+        set_checked: op({
+            summary: 'Mark a requirement met (true, stamped with you and now) or unmet (false, clears the stamp).',
+            params: z.object({
+                id: id('Requirement'),
+                checked: z.boolean(),
+            }),
+            run: (client, { id, checked }) => client.requirements.setChecked(id, checked),
+        }),
+        delete: op({
+            summary: 'Delete a requirement permanently.',
+            params: z.object({ id: id('Requirement') }),
+            run: (client, { id }) => client.requirements.delete(id),
+        }),
+    },
+};

package/dist/domains/scopes.d.ts

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

package/dist/domains/scopes.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { date, id, op } from './framework.js';
+const SCOPE_STATUSES = ['PLANNED', 'IN_PROGRESS', 'SHIPPED', 'DEPRECATED'];
+export const scopes = {
+    name: 'scopes',
+    description: 'Feature scopes: shippable increments of a feature ("V1", "V2: auto-sync"), each with its own lifecycle. Scope status rolls up to the parent feature (see `features`); requirements can be pinned to a scope (see `requirements`).',
+    operations: {
+        list: op({
+            summary: 'List a feature’s scopes in display order.',
+            params: z.object({ featureId: id('Feature') }),
+            run: (client, params) => client.scopes.list(params),
+        }),
+        create: op({
+            summary: 'Add a scope to the end of a feature’s list. Status defaults to PLANNED; rolls up the feature’s status.',
+            params: z.object({
+                featureId: id('Feature'),
+                version: z.string().describe('Short label for the increment, e.g. "V1" or "V2: auto-sync" (max 60 chars)'),
+                description: z.string(),
+                status: z.enum(SCOPE_STATUSES).optional(),
+                shippedAt: date('When it shipped').optional(),
+            }),
+            run: (client, params) => client.scopes.create(params),
+        }),
+        update: op({
+            summary: 'Update a scope. Only the fields you pass change; setting SHIPPED stamps shippedAt now unless you pass one, and any status change rolls up to the feature.',
+            params: z.object({
+                id: id('Scope'),
+                version: z.string().optional(),
+                description: z.string().optional(),
+                status: z.enum(SCOPE_STATUSES).optional(),
+                shippedAt: date('When it shipped').nullable().optional().describe('ISO 8601 date or datetime (null to clear)'),
+                displayOrder: z.number().int().optional().describe('Position among the feature’s scopes, 0-based'),
+            }),
+            run: (client, params) => client.scopes.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a scope permanently. Requirements, tickets and pages pinned to it are kept but unpinned; its comments are deleted.',
+            params: z.object({ id: id('Scope') }),
+            run: (client, { id }) => client.scopes.delete(id),
+        }),
+    },
+};

package/dist/domains/stories.d.ts

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

package/dist/domains/stories.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { id, op } from './framework.js';
+const storyFields = {
+    asA: z.string().max(500).optional().describe('"As a …" — the role'),
+    iWant: z.string().max(1000).optional().describe('"I want …" — the capability'),
+    soThat: z.string().max(1000).optional().describe('"So that …" — the benefit'),
+    acceptanceCriteria: z.string().optional(),
+};
+export const stories = {
+    name: 'stories',
+    description: 'User stories on a feature (As a / I want / So that, plus acceptance criteria), optionally grouped under one of the feature’s scopes. Features live in `features`, scopes in `scopes`.',
+    operations: {
+        list: op({
+            summary: 'List a feature’s user stories in display order.',
+            params: z.object({ featureId: id('Feature') }),
+            run: (client, params) => client.userStories.list(params),
+        }),
+        create: op({
+            summary: 'Add a user story to a feature, appended at the end of the display order.',
+            params: z.object({
+                featureId: id('Feature'),
+                ...storyFields,
+                scopeId: id('Feature scope').optional().describe('Feature scope ID; must belong to the same feature'),
+            }),
+            run: (client, params) => client.userStories.create(params),
+        }),
+        update: op({
+            summary: 'Update a user story. Only the fields you pass change.',
+            params: z.object({
+                id: id('User story'),
+                ...storyFields,
+                scopeId: z
+                    .string()
+                    .nullable()
+                    .optional()
+                    .describe('Feature scope ID, which must belong to the story’s feature (null to ungroup)'),
+            }),
+            run: (client, params) => client.userStories.update(params),
+        }),
+        delete: op({
+            summary: 'Delete a user story permanently.',
+            params: z.object({ id: id('User story') }),
+            run: (client, { id }) => client.userStories.delete(id),
+        }),
+    },
+};

package/dist/domains/tickets.d.ts

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