@ourroadmaps/mcp 0.23.0 → 0.24.1

package/dist/index.js

@@ -94,387 +94,497 @@ var domainContextSchema = z3.object({
   definitions: z3.record(z3.string(), z3.string()),
   schemas: z3.record(z3.string(), z3.array(z3.string()))
 });
-// ../../packages/shared/src/schemas/feature.ts
+// ../../packages/shared/src/schemas/export.ts
 import { z as z4 } from "zod";
-var featureOutcomeSchema = z4.object({
+var localEntityTypeSchema = z4.enum(["roadmap", "prd", "epic", "story", "design"]);
+var externalSystemSchema = z4.enum(["linear", "notion", "jira", "github"]);
+var exportSchema = z4.object({
   id: z4.string().uuid(),
-  description: z4.string(),
-  order: z4.number().int(),
+  roadmapItemId: z4.string().uuid(),
+  localEntityType: localEntityTypeSchema,
+  localEntityId: z4.string().uuid(),
+  externalSystem: externalSystemSchema,
+  externalObjectType: z4.string(),
+  externalId: z4.string(),
+  externalUrl: z4.string().nullable(),
+  metadata: z4.record(z4.unknown()).nullable(),
   createdAt: z4.string(),
   updatedAt: z4.string()
 });
-var featureSchema = z4.object({
-  id: z4.string().uuid(),
-  organizationId: z4.string(),
-  type: featureTypeSchema,
-  name: z4.string(),
-  description: z4.string().nullable(),
-  parentId: z4.string().uuid().nullable(),
-  order: z4.number().int(),
-  isExpanded: z4.boolean(),
-  deletedAt: z4.string().nullable(),
-  createdAt: z4.string(),
-  createdBy: z4.string()
-});
-var roadmapLinkSchema = z4.object({
-  id: z4.string().uuid(),
+var createExportInputSchema = z4.object({
   roadmapId: z4.string().uuid(),
-  roadmap: z4.object({
-    id: z4.string().uuid(),
-    title: z4.string(),
-    status: z4.string(),
-    horizon: z4.string()
-  }),
-  createdAt: z4.string()
-});
-var featureWithRelationsSchema = featureSchema.extend({
-  outcomes: z4.array(featureOutcomeSchema),
-  roadmapLinks: z4.array(roadmapLinkSchema),
-  children: z4.array(featureSchema).optional()
-});
-var createFeatureSchema = z4.object({
-  name: z4.string().min(1),
-  description: z4.string().nullable().optional(),
-  type: featureTypeSchema.optional(),
-  parentId: z4.string().uuid().nullable().optional()
+  localEntityType: localEntityTypeSchema,
+  localEntityId: z4.string().uuid(),
+  externalSystem: externalSystemSchema,
+  externalObjectType: z4.string().min(1),
+  externalId: z4.string().min(1),
+  externalUrl: z4.string().url().optional(),
+  metadata: z4.record(z4.unknown()).optional()
 });
-var updateFeatureSchema = z4.object({
-  name: z4.string().min(1).optional(),
-  description: z4.string().nullable().optional(),
-  type: featureTypeSchema.optional(),
-  parentId: z4.string().uuid().nullable().optional(),
-  order: z4.number().int().optional()
+var updateExportInputSchema = z4.object({
+  externalUrl: z4.string().url().nullable().optional(),
+  metadata: z4.record(z4.unknown()).optional()
 });
-var saveFeatureOutcomesSchema = z4.object({
-  outcomes: z4.array(z4.object({
-    id: z4.string().uuid().optional(),
-    description: z4.string()
-  }))
+var searchExportsInputSchema = z4.object({
+  roadmapId: z4.string().uuid().optional(),
+  externalSystem: externalSystemSchema.optional(),
+  localEntityType: localEntityTypeSchema.optional(),
+  localEntityId: z4.string().uuid().optional(),
+  limit: z4.number().int().min(1).max(100).optional(),
+  offset: z4.number().int().min(0).optional()
 });
-var featureListSchema = z4.array(featureSchema);
-// ../../packages/shared/src/schemas/idea.ts
+// ../../packages/shared/src/schemas/feature.ts
 import { z as z5 } from "zod";
-var ideaSchema = z5.object({
+var featureOutcomeSchema = z5.object({
+  id: z5.string().uuid(),
+  description: z5.string(),
+  order: z5.number().int(),
+  createdAt: z5.string(),
+  updatedAt: z5.string()
+});
+var featureSchema = z5.object({
   id: z5.string().uuid(),
   organizationId: z5.string(),
-  title: z5.string(),
+  type: featureTypeSchema,
+  name: z5.string(),
   description: z5.string().nullable(),
-  status: ideaStatusSchema,
-  source: z5.string().nullable(),
-  submittedBy: z5.string().nullable(),
-  value: effortSchema.nullable(),
-  effort: effortSchema.nullable(),
+  parentId: z5.string().uuid().nullable(),
   order: z5.number().int(),
+  isExpanded: z5.boolean(),
+  deletedAt: z5.string().nullable(),
   createdAt: z5.string(),
   createdBy: z5.string()
 });
-var createIdeaSchema = z5.object({
-  title: z5.string().min(1),
+var roadmapLinkSchema = z5.object({
+  id: z5.string().uuid(),
+  roadmapId: z5.string().uuid(),
+  roadmap: z5.object({
+    id: z5.string().uuid(),
+    title: z5.string(),
+    status: z5.string(),
+    horizon: z5.string()
+  }),
+  createdAt: z5.string()
+});
+var featureWithRelationsSchema = featureSchema.extend({
+  outcomes: z5.array(featureOutcomeSchema),
+  roadmapLinks: z5.array(roadmapLinkSchema),
+  children: z5.array(featureSchema).optional()
+});
+var createFeatureSchema = z5.object({
+  name: z5.string().min(1),
   description: z5.string().nullable().optional(),
-  status: ideaStatusSchema.optional(),
-  effort: effortSchema.nullable().optional(),
-  source: z5.string().nullable().optional()
+  type: featureTypeSchema.optional(),
+  parentId: z5.string().uuid().nullable().optional()
 });
-var updateIdeaSchema = z5.object({
-  title: z5.string().min(1).optional(),
+var updateFeatureSchema = z5.object({
+  name: z5.string().min(1).optional(),
   description: z5.string().nullable().optional(),
-  status: ideaStatusSchema.optional(),
-  effort: effortSchema.nullable().optional(),
-  source: z5.string().nullable().optional(),
+  type: featureTypeSchema.optional(),
+  parentId: z5.string().uuid().nullable().optional(),
   order: z5.number().int().optional()
 });
-var ideaListSchema = z5.array(ideaSchema);
-// ../../packages/shared/src/schemas/product.ts
+var saveFeatureOutcomesSchema = z5.object({
+  outcomes: z5.array(z5.object({
+    id: z5.string().uuid().optional(),
+    description: z5.string()
+  }))
+});
+var featureListSchema = z5.array(featureSchema);
+// ../../packages/shared/src/schemas/idea.ts
 import { z as z6 } from "zod";
-var productSchema = z6.object({
+var ideaSchema = z6.object({
   id: z6.string().uuid(),
   organizationId: z6.string(),
-  parentId: z6.string().uuid().nullable(),
-  type: productTypeSchema,
-  name: z6.string(),
+  title: z6.string(),
+  description: z6.string().nullable(),
+  status: ideaStatusSchema,
+  source: z6.string().nullable(),
+  submittedBy: z6.string().nullable(),
+  value: effortSchema.nullable(),
+  effort: effortSchema.nullable(),
   order: z6.number().int(),
-  isExpanded: z6.boolean(),
-  deletedAt: z6.string().nullable(),
-  createdAt: z6.string()
+  createdAt: z6.string(),
+  createdBy: z6.string()
 });
-var createProductSchema = z6.object({
-  name: z6.string().min(1),
+var createIdeaSchema = z6.object({
+  title: z6.string().min(1),
   description: z6.string().nullable().optional(),
-  type: productTypeSchema,
-  parentId: z6.string().uuid().nullable().optional()
+  status: ideaStatusSchema.optional(),
+  effort: effortSchema.nullable().optional(),
+  source: z6.string().nullable().optional()
 });
-var updateProductSchema = z6.object({
-  name: z6.string().min(1).optional(),
+var updateIdeaSchema = z6.object({
+  title: z6.string().min(1).optional(),
   description: z6.string().nullable().optional(),
-  type: productTypeSchema.optional(),
-  parentId: z6.string().uuid().nullable().optional(),
+  status: ideaStatusSchema.optional(),
+  effort: effortSchema.nullable().optional(),
+  source: z6.string().nullable().optional(),
   order: z6.number().int().optional()
 });
-var productListSchema = z6.array(productSchema);
-// ../../packages/shared/src/schemas/roadmap.ts
-import { z as z8 } from "zod";
-
-// ../../packages/shared/src/schemas/story.ts
+var ideaListSchema = z6.array(ideaSchema);
+// ../../packages/shared/src/schemas/presentation.ts
 import { z as z7 } from "zod";
-var epicSchema = z7.object({
-  id: z7.string().uuid(),
-  roadmapItemId: z7.string().uuid(),
-  organizationId: z7.string(),
-  title: z7.string(),
-  description: z7.string().nullable(),
-  order: z7.number().int(),
-  createdAt: z7.string(),
-  updatedAt: z7.string(),
-  deletedAt: z7.string().nullable()
-});
-var storySchema = z7.object({
+var presentationSchema = z7.object({
   id: z7.string().uuid(),
-  roadmapItemId: z7.string().uuid(),
-  epicId: z7.string().uuid().nullable(),
   organizationId: z7.string(),
   title: z7.string(),
   description: z7.string().nullable(),
   order: z7.number().int(),
   createdAt: z7.string(),
-  updatedAt: z7.string(),
-  deletedAt: z7.string().nullable()
-});
-var epicWithStoriesSchema = epicSchema.extend({
-  stories: z7.array(storySchema)
+  createdBy: z7.string(),
+  updatedAt: z7.string().nullable()
 });
-var createEpicSchema = z7.object({
+var createPresentationSchema = z7.object({
   title: z7.string().min(1),
   description: z7.string().nullable().optional()
 });
-var createStorySchema = z7.object({
-  title: z7.string().min(1),
+var updatePresentationSchema = z7.object({
+  title: z7.string().min(1).optional(),
   description: z7.string().nullable().optional()
 });
-var saveStoriesInputSchema = z7.object({
-  epics: z7.array(z7.object({
-    title: z7.string().min(1),
-    description: z7.string().nullable().optional(),
-    stories: z7.array(z7.object({
-      title: z7.string().min(1),
-      description: z7.string().nullable().optional()
+var presentationListSchema = z7.array(presentationSchema);
+// ../../packages/shared/src/schemas/product.ts
+import { z as z8 } from "zod";
+var productSchema = z8.object({
+  id: z8.string().uuid(),
+  organizationId: z8.string(),
+  parentId: z8.string().uuid().nullable(),
+  type: productTypeSchema,
+  name: z8.string(),
+  order: z8.number().int(),
+  isExpanded: z8.boolean(),
+  deletedAt: z8.string().nullable(),
+  createdAt: z8.string()
+});
+var createProductSchema = z8.object({
+  name: z8.string().min(1),
+  description: z8.string().nullable().optional(),
+  type: productTypeSchema,
+  parentId: z8.string().uuid().nullable().optional()
+});
+var updateProductSchema = z8.object({
+  name: z8.string().min(1).optional(),
+  description: z8.string().nullable().optional(),
+  type: productTypeSchema.optional(),
+  parentId: z8.string().uuid().nullable().optional(),
+  order: z8.number().int().optional()
+});
+var productListSchema = z8.array(productSchema);
+// ../../packages/shared/src/schemas/roadmap.ts
+import { z as z10 } from "zod";
+
+// ../../packages/shared/src/schemas/story.ts
+import { z as z9 } from "zod";
+var epicSchema = z9.object({
+  id: z9.string().uuid(),
+  roadmapItemId: z9.string().uuid(),
+  organizationId: z9.string(),
+  title: z9.string(),
+  description: z9.string().nullable(),
+  order: z9.number().int(),
+  createdAt: z9.string(),
+  updatedAt: z9.string(),
+  deletedAt: z9.string().nullable()
+});
+var storySchema = z9.object({
+  id: z9.string().uuid(),
+  roadmapItemId: z9.string().uuid(),
+  epicId: z9.string().uuid().nullable(),
+  organizationId: z9.string(),
+  title: z9.string(),
+  description: z9.string().nullable(),
+  order: z9.number().int(),
+  createdAt: z9.string(),
+  updatedAt: z9.string(),
+  deletedAt: z9.string().nullable()
+});
+var epicWithStoriesSchema = epicSchema.extend({
+  stories: z9.array(storySchema)
+});
+var createEpicSchema = z9.object({
+  title: z9.string().min(1),
+  description: z9.string().nullable().optional()
+});
+var createStorySchema = z9.object({
+  title: z9.string().min(1),
+  description: z9.string().nullable().optional()
+});
+var saveStoriesInputSchema = z9.object({
+  epics: z9.array(z9.object({
+    title: z9.string().min(1),
+    description: z9.string().nullable().optional(),
+    stories: z9.array(z9.object({
+      title: z9.string().min(1),
+      description: z9.string().nullable().optional()
     })).optional().default([])
   })).optional().default([]),
-  stories: z7.array(z7.object({
-    title: z7.string().min(1),
-    description: z7.string().nullable().optional()
+  stories: z9.array(z9.object({
+    title: z9.string().min(1),
+    description: z9.string().nullable().optional()
   })).optional().default([])
 });
-var updateEpicSchema = z7.object({
-  title: z7.string().min(1).optional(),
-  description: z7.string().nullable().optional()
+var updateEpicSchema = z9.object({
+  title: z9.string().min(1).optional(),
+  description: z9.string().nullable().optional()
 });
-var updateStorySchema = z7.object({
-  title: z7.string().min(1).optional(),
-  description: z7.string().nullable().optional(),
-  epicId: z7.string().uuid().nullable().optional()
+var updateStorySchema = z9.object({
+  title: z9.string().min(1).optional(),
+  description: z9.string().nullable().optional(),
+  epicId: z9.string().uuid().nullable().optional()
 });
-var reorderStoriesSchema = z7.object({
-  epicOrder: z7.array(z7.string().uuid()).optional(),
-  storyOrder: z7.record(z7.string(), z7.array(z7.string().uuid())).optional(),
-  standaloneOrder: z7.array(z7.string().uuid()).optional()
+var reorderStoriesSchema = z9.object({
+  epicOrder: z9.array(z9.string().uuid()).optional(),
+  storyOrder: z9.record(z9.string(), z9.array(z9.string().uuid())).optional(),
+  standaloneOrder: z9.array(z9.string().uuid()).optional()
 });
 
 // ../../packages/shared/src/schemas/roadmap.ts
-var flexibleDateSchema = z8.object({
-  value: z8.string(),
+var flexibleDateSchema = z10.object({
+  value: z10.string(),
   granularity: dateGranularitySchema
 });
-var labelSchema = z8.object({
-  id: z8.string().uuid(),
-  type: z8.enum(["category", "location", "label"]),
-  name: z8.string(),
-  color: z8.string().nullable(),
-  address: z8.string().nullable()
+var labelSchema = z10.object({
+  id: z10.string().uuid(),
+  type: z10.enum(["category", "location", "label"]),
+  name: z10.string(),
+  color: z10.string().nullable(),
+  address: z10.string().nullable()
 });
-var appSchema = z8.object({
-  id: z8.string().uuid(),
-  name: z8.string()
+var appSchema = z10.object({
+  id: z10.string().uuid(),
+  name: z10.string()
 });
-var roadmapSchema = z8.object({
-  id: z8.string().uuid(),
-  organizationId: z8.string(),
-  title: z8.string(),
+var roadmapSchema = z10.object({
+  id: z10.string().uuid(),
+  organizationId: z10.string(),
+  title: z10.string(),
   horizon: horizonSchema.nullable(),
   status: roadmapStatusSchema.nullable(),
   value: effortSchema.nullable(),
   effort: effortSchema.nullable(),
-  order: z8.number().int(),
-  estimatedSeconds: z8.number().int().nullable(),
+  order: z10.number().int(),
+  estimatedSeconds: z10.number().int().nullable(),
   date: flexibleDateSchema.nullable(),
   target: flexibleDateSchema.nullable(),
-  completedAt: z8.string().nullable(),
-  createdAt: z8.string(),
-  createdBy: z8.string(),
-  prompt: z8.string().nullable(),
-  labels: z8.array(labelSchema),
-  apps: z8.array(appSchema)
-});
-var createRoadmapSchema = z8.object({
-  title: z8.string().min(1),
+  completedAt: z10.string().nullable(),
+  createdAt: z10.string(),
+  createdBy: z10.string(),
+  prompt: z10.string().nullable(),
+  labels: z10.array(labelSchema),
+  apps: z10.array(appSchema)
+});
+var createRoadmapSchema = z10.object({
+  title: z10.string().min(1),
   status: roadmapStatusSchema.optional(),
   horizon: horizonSchema.optional(),
   value: effortSchema.nullable().optional(),
   effort: effortSchema.nullable().optional(),
-  estimatedSeconds: z8.number().int().nullable().optional(),
+  estimatedSeconds: z10.number().int().nullable().optional(),
   date: flexibleDateSchema.nullable().optional(),
   target: flexibleDateSchema.nullable().optional(),
-  prompt: z8.string().nullable().optional(),
-  brainstormNotes: z8.string().nullable().optional()
+  prompt: z10.string().nullable().optional(),
+  brainstormNotes: z10.string().nullable().optional()
 });
-var updateRoadmapSchema = z8.object({
-  title: z8.string().min(1).optional(),
+var updateRoadmapSchema = z10.object({
+  title: z10.string().min(1).optional(),
   status: roadmapStatusSchema.optional(),
   horizon: horizonSchema.optional(),
   value: effortSchema.nullable().optional(),
   effort: effortSchema.nullable().optional(),
-  order: z8.number().int().optional(),
-  estimatedSeconds: z8.number().int().nullable().optional(),
+  order: z10.number().int().optional(),
+  estimatedSeconds: z10.number().int().nullable().optional(),
   date: flexibleDateSchema.nullable().optional(),
   target: flexibleDateSchema.nullable().optional(),
-  prompt: z8.string().nullable().optional(),
-  brainstormNotes: z8.string().nullable().optional()
+  prompt: z10.string().nullable().optional(),
+  brainstormNotes: z10.string().nullable().optional()
 });
-var prdOutcomeSchema = z8.object({
-  id: z8.string().uuid(),
-  description: z8.string(),
+var prdOutcomeSchema = z10.object({
+  id: z10.string().uuid(),
+  description: z10.string(),
   status: prdStatusSchema,
-  order: z8.number().int(),
-  completedAt: z8.string().nullable()
+  order: z10.number().int(),
+  completedAt: z10.string().nullable()
 });
-var prdSchema = z8.object({
-  id: z8.string().uuid(),
-  what: z8.string().nullable(),
-  why: z8.string().nullable(),
-  outcomes: z8.array(prdOutcomeSchema)
+var prdSchema = z10.object({
+  id: z10.string().uuid(),
+  what: z10.string().nullable(),
+  why: z10.string().nullable(),
+  outcomes: z10.array(prdOutcomeSchema)
 });
-var savePrdInputSchema = z8.object({
-  what: z8.string().nullable(),
-  why: z8.string().nullable(),
+var savePrdInputSchema = z10.object({
+  what: z10.string().nullable(),
+  why: z10.string().nullable(),
   status: prdStatusSchema,
-  outcomes: z8.array(z8.object({
-    id: z8.string().uuid().optional(),
-    description: z8.string(),
-    order: z8.number().int().min(0)
+  outcomes: z10.array(z10.object({
+    id: z10.string().uuid().optional(),
+    description: z10.string(),
+    order: z10.number().int().min(0)
   }))
 });
-var brainstormMediaSchema = z8.object({
-  id: z8.string().uuid(),
-  mediaUrl: z8.string(),
+var brainstormMediaSchema = z10.object({
+  id: z10.string().uuid(),
+  mediaUrl: z10.string(),
   mediaType: brainstormMediaTypeSchema,
-  description: z8.string().nullable(),
-  order: z8.number().int(),
-  createdAt: z8.string()
+  description: z10.string().nullable(),
+  order: z10.number().int(),
+  createdAt: z10.string()
 });
-var wireframeSchema = z8.object({
-  id: z8.string().uuid(),
-  description: z8.string().nullable(),
-  imageUrl: z8.string().nullable(),
-  order: z8.number().int()
+var wireframeSchema = z10.object({
+  id: z10.string().uuid(),
+  description: z10.string().nullable(),
+  imageUrl: z10.string().nullable(),
+  order: z10.number().int()
 });
-var prototypeSchema = z8.object({
-  id: z8.string().uuid(),
-  publicUrl: z8.string().url(),
-  expiresAt: z8.string().datetime(),
-  fileCount: z8.number().int().positive(),
-  entryPoint: z8.string(),
-  createdAt: z8.string().datetime()
+var prototypeSchema = z10.object({
+  id: z10.string().uuid(),
+  publicUrl: z10.string().url(),
+  expiresAt: z10.string().datetime(),
+  fileCount: z10.number().int().positive(),
+  entryPoint: z10.string(),
+  createdAt: z10.string().datetime()
 });
-var featureLinkSchema = z8.object({
-  id: z8.string().uuid(),
-  featureId: z8.string().uuid(),
-  feature: z8.object({
-    id: z8.string().uuid(),
-    name: z8.string(),
-    type: z8.enum(["area", "feature"])
+var featureLinkSchema = z10.object({
+  id: z10.string().uuid(),
+  featureId: z10.string().uuid(),
+  feature: z10.object({
+    id: z10.string().uuid(),
+    name: z10.string(),
+    type: z10.enum(["area", "feature"])
   }),
-  createdAt: z8.string()
+  createdAt: z10.string()
 });
-var phaseDesignSchema = z8.object({
-  id: z8.string().uuid(),
-  description: z8.string().nullable()
+var phaseDesignSchema = z10.object({
+  id: z10.string().uuid(),
+  description: z10.string().nullable()
 });
-var phasePlanSchema = z8.object({
-  id: z8.string().uuid(),
-  description: z8.string().nullable()
+var phasePlanSchema = z10.object({
+  id: z10.string().uuid(),
+  description: z10.string().nullable()
 });
-var phaseBuildSchema = z8.object({
-  id: z8.string().uuid(),
-  description: z8.string().nullable(),
-  prompt: z8.string().nullable()
+var phaseBuildSchema = z10.object({
+  id: z10.string().uuid(),
+  description: z10.string().nullable(),
+  prompt: z10.string().nullable()
 });
-var phaseReleaseSchema = z8.object({
-  id: z8.string().uuid(),
-  description: z8.string().nullable()
+var phaseReleaseSchema = z10.object({
+  id: z10.string().uuid(),
+  description: z10.string().nullable()
 });
 var roadmapDetailSchema = roadmapSchema.extend({
   prd: prdSchema.nullable(),
-  wireframes: z8.array(wireframeSchema),
-  prototypes: z8.array(prototypeSchema),
-  brainstormMedia: z8.array(brainstormMediaSchema),
-  brainstormNotes: z8.string().nullable(),
-  featureLinks: z8.array(featureLinkSchema),
-  epics: z8.array(epicWithStoriesSchema),
-  stories: z8.array(storySchema),
+  wireframes: z10.array(wireframeSchema),
+  prototypes: z10.array(prototypeSchema),
+  brainstormMedia: z10.array(brainstormMediaSchema),
+  brainstormNotes: z10.string().nullable(),
+  featureLinks: z10.array(featureLinkSchema),
+  epics: z10.array(epicWithStoriesSchema),
+  stories: z10.array(storySchema),
   design: phaseDesignSchema.nullable(),
   plan: phasePlanSchema.nullable(),
   build: phaseBuildSchema.nullable(),
-  release: phaseReleaseSchema.nullable()
+  release: phaseReleaseSchema.nullable(),
+  exports: z10.array(exportSchema)
 });
-var roadmapListSchema = z8.array(roadmapSchema);
+var roadmapListSchema = z10.array(roadmapSchema);
 // ../../packages/shared/src/schemas/scenario.ts
-import { z as z9 } from "zod";
-var scenarioSchema = z9.object({
-  id: z9.string().uuid(),
-  title: z9.string().min(1),
-  given: z9.string().nullable(),
-  when: z9.string().nullable(),
-  then: z9.string().nullable(),
-  order: z9.number().int(),
-  createdAt: z9.string().datetime(),
-  updatedAt: z9.string().datetime()
+import { z as z11 } from "zod";
+var scenarioSchema = z11.object({
+  id: z11.string().uuid(),
+  title: z11.string().min(1),
+  given: z11.string().nullable(),
+  when: z11.string().nullable(),
+  then: z11.string().nullable(),
+  order: z11.number().int(),
+  createdAt: z11.string().datetime(),
+  updatedAt: z11.string().datetime()
 });
-var createScenarioSchema = z9.object({
-  title: z9.string().min(1),
-  given: z9.string().nullable().optional(),
-  when: z9.string().nullable().optional(),
-  then: z9.string().nullable().optional(),
-  roadmapId: z9.string().uuid()
+var createScenarioSchema = z11.object({
+  title: z11.string().min(1),
+  given: z11.string().nullable().optional(),
+  when: z11.string().nullable().optional(),
+  then: z11.string().nullable().optional(),
+  roadmapId: z11.string().uuid()
 });
-var updateScenarioSchema = z9.object({
-  title: z9.string().min(1).optional(),
-  given: z9.string().nullable().optional(),
-  when: z9.string().nullable().optional(),
-  then: z9.string().nullable().optional(),
-  order: z9.number().int().optional()
+var updateScenarioSchema = z11.object({
+  title: z11.string().min(1).optional(),
+  given: z11.string().nullable().optional(),
+  when: z11.string().nullable().optional(),
+  then: z11.string().nullable().optional(),
+  order: z11.number().int().optional()
+});
+var scenarioListSchema = z11.array(scenarioSchema);
+// ../../packages/shared/src/schemas/slide.ts
+import { z as z12 } from "zod";
+var slideContentSchema = z12.object({
+  body: z12.string().optional()
+});
+var slideSchema = z12.object({
+  id: z12.string().uuid(),
+  variantId: z12.string().uuid(),
+  title: z12.string(),
+  content: slideContentSchema.nullable(),
+  speakerNotes: z12.string().nullable(),
+  order: z12.number().int(),
+  createdAt: z12.string(),
+  createdBy: z12.string(),
+  updatedAt: z12.string().nullable()
+});
+var createSlideSchema = z12.object({
+  title: z12.string().optional(),
+  content: slideContentSchema.nullable().optional(),
+  speakerNotes: z12.string().nullable().optional()
+});
+var updateSlideSchema = z12.object({
+  title: z12.string().optional(),
+  content: slideContentSchema.nullable().optional(),
+  speakerNotes: z12.string().nullable().optional()
 });
-var scenarioListSchema = z9.array(scenarioSchema);
+var slideListSchema = z12.array(slideSchema);
 // ../../packages/shared/src/schemas/status-update.ts
-import { z as z10 } from "zod";
-var statusUpdateItemSchema = z10.object({
-  id: z10.string().uuid(),
-  roadmapItemId: z10.string().uuid(),
-  titleAtSnapshot: z10.string(),
-  statusAtSnapshot: z10.string(),
-  designWalkthroughUrl: z10.string().nullable(),
-  releaseWalkthroughUrl: z10.string().nullable()
+import { z as z13 } from "zod";
+var statusUpdateItemSchema = z13.object({
+  id: z13.string().uuid(),
+  roadmapItemId: z13.string().uuid(),
+  titleAtSnapshot: z13.string(),
+  statusAtSnapshot: z13.string(),
+  designWalkthroughUrl: z13.string().nullable(),
+  releaseWalkthroughUrl: z13.string().nullable()
 });
-var statusUpdateSchema = z10.object({
-  id: z10.string().uuid(),
-  title: z10.string().nullable(),
-  startDate: z10.string(),
-  endDate: z10.string(),
-  content: z10.string(),
-  createdAt: z10.string(),
-  items: z10.array(statusUpdateItemSchema).optional()
+var statusUpdateSchema = z13.object({
+  id: z13.string().uuid(),
+  title: z13.string().nullable(),
+  startDate: z13.string(),
+  endDate: z13.string(),
+  content: z13.string(),
+  createdAt: z13.string(),
+  items: z13.array(statusUpdateItemSchema).optional()
 });
-var statusUpdateListSchema = z10.array(statusUpdateSchema);
+var statusUpdateListSchema = z13.array(statusUpdateSchema);
+// ../../packages/shared/src/schemas/variant.ts
+import { z as z14 } from "zod";
+var variantSchema = z14.object({
+  id: z14.string().uuid(),
+  presentationId: z14.string().uuid(),
+  name: z14.string(),
+  audienceId: z14.string().uuid().nullable(),
+  isDefault: z14.boolean(),
+  order: z14.number().int(),
+  createdAt: z14.string(),
+  createdBy: z14.string(),
+  updatedAt: z14.string().nullable()
+});
+var createVariantSchema = z14.object({
+  name: z14.string().min(1),
+  audienceId: z14.string().uuid().nullable().optional()
+});
+var updateVariantSchema = z14.object({
+  name: z14.string().min(1).optional(),
+  audienceId: z14.string().uuid().nullable().optional()
+});
+var variantListSchema = z14.array(variantSchema);
 // src/tools/index.ts
-import { z as z11 } from "zod";
+import { z as z15 } from "zod";
 
 // src/auth.ts
 function getCredentials() {
@@ -971,6 +1081,160 @@ class ApiClient {
       throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
     }
   }
+  async searchExports(params) {
+    const searchParams = new URLSearchParams;
+    if (params?.roadmapId)
+      searchParams.set("roadmapId", params.roadmapId);
+    if (params?.externalSystem)
+      searchParams.set("externalSystem", params.externalSystem);
+    if (params?.localEntityType)
+      searchParams.set("localEntityType", params.localEntityType);
+    if (params?.localEntityId)
+      searchParams.set("localEntityId", params.localEntityId);
+    if (params?.limit)
+      searchParams.set("limit", String(params.limit));
+    if (params?.offset)
+      searchParams.set("offset", String(params.offset));
+    const queryString = searchParams.toString();
+    const path = queryString ? `/v1/exports?${queryString}` : "/v1/exports";
+    return await this.request(path);
+  }
+  async getExport(id) {
+    const response = await this.request(`/v1/exports/${id}`);
+    return response.data;
+  }
+  async createExport(data) {
+    const response = await this.request("/v1/exports", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateExport(id, data) {
+    const response = await this.request(`/v1/exports/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteExport(id) {
+    await this.request(`/v1/exports/${id}`, { method: "DELETE" });
+  }
+  async listPresentations() {
+    const response = await this.request("/v1/presentations");
+    return { items: response.data, total: response.data.length };
+  }
+  async getPresentation(id) {
+    const response = await this.request(`/v1/presentations/${id}`);
+    return response.data;
+  }
+  async createPresentation(data) {
+    const response = await this.request("/v1/presentations", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updatePresentation(id, data) {
+    const response = await this.request(`/v1/presentations/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deletePresentation(id) {
+    await this.request(`/v1/presentations/${id}`, { method: "DELETE" });
+  }
+  async reorderPresentations(items) {
+    await this.request("/v1/presentations/reorder", {
+      method: "POST",
+      body: JSON.stringify({ items })
+    });
+  }
+  async listVariants(presentationId) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants`);
+    return { items: response.data, total: response.data.length };
+  }
+  async getVariant(presentationId, variantId) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}`);
+    return response.data;
+  }
+  async createVariant(presentationId, data) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateVariant(presentationId, variantId, data) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteVariant(presentationId, variantId) {
+    await this.request(`/v1/presentations/${presentationId}/variants/${variantId}`, {
+      method: "DELETE"
+    });
+  }
+  async reorderVariants(presentationId, items) {
+    await this.request(`/v1/presentations/${presentationId}/variants/reorder`, {
+      method: "POST",
+      body: JSON.stringify({ items })
+    });
+  }
+  async cloneVariant(presentationId, variantId) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/clone`, { method: "POST" });
+    return response.data;
+  }
+  async setDefaultVariant(presentationId, variantId) {
+    await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/set-default`, {
+      method: "POST"
+    });
+  }
+  async listSlides(presentationId, variantId) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides`);
+    return { items: response.data, total: response.data.length };
+  }
+  async getSlide(presentationId, variantId, slideId) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/${slideId}`);
+    return response.data;
+  }
+  async createSlide(presentationId, variantId, data) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateSlide(presentationId, variantId, slideId, data) {
+    const response = await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/${slideId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteSlide(presentationId, variantId, slideId) {
+    await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/${slideId}`, { method: "DELETE" });
+  }
+  async reorderSlides(presentationId, variantId, items) {
+    await this.request(`/v1/presentations/${presentationId}/variants/${variantId}/slides/reorder`, {
+      method: "POST",
+      body: JSON.stringify({ items })
+    });
+  }
+  async getVariantPresentationId(variantId) {
+    const presentations = await this.listPresentations();
+    for (const presentation2 of presentations.items) {
+      const variants = await this.listVariants(presentation2.id);
+      const found = variants.items.find((v) => v.id === variantId);
+      if (found) {
+        return presentation2.id;
+      }
+    }
+    return null;
+  }
 }
 var client = null;
 function getApiClient() {
@@ -996,6 +1260,7 @@ function inferContentType(filename) {
   return ext ? mapping[ext] ?? null : null;
 }
 function registerAllTools(server) {
+  registerGetWorkflows(server);
   registerSearchRoadmaps(server);
   registerGetRoadmap(server);
   registerSearchFeatures(server);
@@ -1054,26 +1319,79 @@ function registerAllTools(server) {
   registerUploadDesignWalkthrough(server);
   registerUploadReleaseWalkthrough(server);
   registerPublishPrototype(server);
+  registerSearchExports(server);
+  registerGetExport(server);
+  registerCreateExport(server);
+  registerUpdateExport(server);
+  registerDeleteExport(server);
+  registerListPresentations(server);
+  registerGetPresentation(server);
+  registerCreatePresentation(server);
+  registerUpdatePresentation(server);
+  registerDeletePresentation(server);
+  registerReorderPresentations(server);
+  registerListVariants(server);
+  registerGetVariant(server);
+  registerCreateVariant(server);
+  registerUpdateVariant(server);
+  registerDeleteVariant(server);
+  registerReorderVariants(server);
+  registerCloneVariant(server);
+  registerSetDefaultVariant(server);
+  registerListSlides(server);
+  registerGetSlide(server);
+  registerCreateSlide(server);
+  registerUpdateSlide(server);
+  registerDeleteSlide(server);
+  registerReorderSlides(server);
+}
+function registerGetWorkflows(server) {
+  server.registerTool("get_workflows", {
+    description: "Get all workflow definitions with phases and steps. Use this to know valid phases/steps when updating roadmap items.",
+    inputSchema: {}
+  }, async () => {
+    const client2 = getApiClient();
+    const response = await client2.get("/v1/workflows");
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response, null, 2)
+        }
+      ]
+    };
+  });
 }
 function registerSearchRoadmaps(server) {
   server.registerTool("search_roadmaps", {
     description: "Search for roadmap items by title, status, or horizon. Returns a list of matching roadmap items with basic info.",
     inputSchema: {
-      query: z11.string().optional().describe("Search query to match against title or description"),
+      query: z15.string().optional().describe("Search query to match against title or description"),
       status: roadmapStatusSchema.optional().describe("Filter by status"),
       horizon: horizonSchema.optional().describe("Filter by planning horizon"),
-      limit: z11.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
-      offset: z11.number().int().min(0).optional().describe("Number of items to skip (default 0)")
+      phase: z15.string().optional().describe("Filter by phase"),
+      phaseStep: z15.string().optional().describe("Filter by phase step"),
+      limit: z15.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
+      offset: z15.number().int().min(0).optional().describe("Number of items to skip (default 0)")
     }
   }, async ({
     query,
     status,
     horizon,
+    phase,
+    phaseStep,
     limit,
     offset
   }) => {
     const client2 = getApiClient();
-    const response = await client2.listRoadmaps({ limit, offset, horizon, query });
+    const response = await client2.listRoadmaps({
+      limit,
+      offset,
+      horizon,
+      query,
+      phase,
+      phaseStep
+    });
     let roadmaps = response.items;
     if (status) {
       roadmaps = roadmaps.filter((r) => r.status === status);
@@ -1088,6 +1406,8 @@ function registerSearchRoadmaps(server) {
               title: r.title,
               status: r.status,
               horizon: r.horizon,
+              phase: r.phase,
+              phaseStep: r.phaseStep,
               value: r.value,
               effort: r.effort,
               order: r.order
@@ -1103,7 +1423,7 @@ function registerGetRoadmap(server) {
   server.registerTool("get_roadmap", {
     description: "Get full details of a roadmap item including PRD, wireframes, brainstorm media, linked features, epics, and stories.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the roadmap item")
+      id: z15.string().describe("The UUID of the roadmap item")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -1157,7 +1477,7 @@ function registerSearchFeatures(server) {
   server.registerTool("search_features", {
     description: "Search for features and feature areas by name. Returns a list of matching features with basic info.",
     inputSchema: {
-      query: z11.string().optional().describe("Search query to match against name"),
+      query: z15.string().optional().describe("Search query to match against name"),
       type: featureTypeSchema.optional().describe("Filter by type (feature or area)")
     }
   }, async ({ query, type }) => {
@@ -1189,7 +1509,7 @@ function registerGetFeature(server) {
   server.registerTool("get_feature", {
     description: "Get full details of a feature including outcomes, child features, and linked roadmap items.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the feature")
+      id: z15.string().describe("The UUID of the feature")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -1228,7 +1548,7 @@ function registerSearchIdeas(server) {
   server.registerTool("search_ideas", {
     description: "Search for ideas by title or status. Returns a list of matching ideas with basic info.",
     inputSchema: {
-      query: z11.string().optional().describe("Search query to match against title or description"),
+      query: z15.string().optional().describe("Search query to match against title or description"),
       status: ideaStatusSchema.optional().describe("Filter by status")
     }
   }, async ({ query, status }) => {
@@ -1328,9 +1648,9 @@ function registerCaptureIdea(server) {
   server.registerTool("capture_idea", {
     description: "Quickly capture a new idea. Ideas are suggestions that can later be reviewed and potentially converted to roadmap items.",
     inputSchema: {
-      title: z11.string().describe("Title of the idea"),
-      description: z11.string().optional().describe("Detailed description of the idea"),
-      source: z11.string().optional().describe('Source of the idea (defaults to "claude-code")')
+      title: z15.string().describe("Title of the idea"),
+      description: z15.string().optional().describe("Detailed description of the idea"),
+      source: z15.string().optional().describe('Source of the idea (defaults to "claude-code")')
     }
   }, async ({
     title,
@@ -1367,19 +1687,23 @@ function registerCreateRoadmapItem(server) {
   server.registerTool("create_roadmap_item", {
     description: "Create a new roadmap item. Use this to add planned work to the roadmap.",
     inputSchema: {
-      title: z11.string().describe("Title of the roadmap item"),
+      title: z15.string().describe("Title of the roadmap item"),
       status: roadmapStatusSchema.optional().describe('Status (defaults to "not_started")'),
       horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
-      initiativeId: z11.string().optional().describe("UUID of initiative to link this item to on creation"),
+      phase: z15.string().optional().describe('Initial phase key (e.g., "brainstorm", "prd", "design")'),
+      phaseStep: z15.string().optional().describe('Initial step within phase (e.g., "not_started", "drafting")'),
+      initiativeId: z15.string().optional().describe("UUID of initiative to link this item to on creation"),
       dateGranularity: dateGranularitySchema2.optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
-      dateValue: z11.string().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
+      dateValue: z15.string().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
       targetGranularity: dateGranularitySchema2.optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
-      targetValue: z11.string().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
+      targetValue: z15.string().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
     }
   }, async ({
     title,
     status,
     horizon,
+    phase,
+    phaseStep,
     initiativeId,
     dateGranularity,
     dateValue,
@@ -1392,6 +1716,10 @@ function registerCreateRoadmapItem(server) {
       status: status ?? "not_started",
       horizon: horizon ?? "inbox"
     };
+    if (phase)
+      createData.phase = phase;
+    if (phaseStep)
+      createData.phaseStep = phaseStep;
     if (initiativeId) {
       createData.initiativeId = initiativeId;
     }
@@ -1419,6 +1747,8 @@ function registerCreateRoadmapItem(server) {
               title: roadmap2.title,
               status: roadmap2.status,
               horizon: roadmap2.horizon,
+              phase: roadmap2.phase,
+              phaseStep: roadmap2.phaseStep,
               date: roadmap2.date,
               target: roadmap2.target
             }
@@ -1428,34 +1758,38 @@ function registerCreateRoadmapItem(server) {
     };
   });
 }
-var effortSizeSchema = z11.enum(["xs", "s", "m", "l", "xl"]);
+var effortSizeSchema = z15.enum(["xs", "s", "m", "l", "xl"]);
 function registerUpdateRoadmapItem(server) {
   server.registerTool("update_roadmap_item", {
-    description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, initiative link, target date, or brainstorm notes.",
+    description: "Update an existing roadmap item. Can update title, status, horizon, value, effort, order, prompt, initiative link, target date, phase, phaseStep, or brainstorm notes.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the roadmap item to update"),
-      title: z11.string().optional().describe("New title"),
+      id: z15.string().describe("The UUID of the roadmap item to update"),
+      title: z15.string().optional().describe("New title"),
       status: roadmapStatusSchema.optional().describe("New status"),
       horizon: horizonSchema.optional().describe("New planning horizon"),
-      value: z11.number().int().min(1).max(3).nullable().optional().describe("Value rating (1-3 stars, where 3 is highest value)"),
+      phase: z15.string().optional().describe('Current phase key (e.g., "prd", "design", "build")'),
+      phaseStep: z15.string().optional().describe('Current step within phase (e.g., "drafting", "needs_review", "approved")'),
+      value: z15.number().int().min(1).max(3).nullable().optional().describe("Value rating (1-3 stars, where 3 is highest value)"),
       effort: effortSizeSchema.nullable().optional().describe("Effort estimate (xs=extra small, s=small, m=medium, l=large, xl=extra large)"),
-      order: z11.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)"),
-      initiativeId: z11.string().nullable().optional().describe("UUID to link item to initiative, or null to unlink from any initiative"),
-      designDescription: z11.string().nullable().optional().describe("Description for the Design phase"),
-      planDescription: z11.string().nullable().optional().describe("Description for the Planning phase"),
-      buildDescription: z11.string().nullable().optional().describe("Description for the Build phase"),
-      releaseDescription: z11.string().nullable().optional().describe("Description for the Release phase"),
-      prompt: z11.string().nullable().optional().describe("Build prompt for the roadmap item"),
+      order: z15.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)"),
+      initiativeId: z15.string().nullable().optional().describe("UUID to link item to initiative, or null to unlink from any initiative"),
+      designDescription: z15.string().nullable().optional().describe("Description for the Design phase"),
+      planDescription: z15.string().nullable().optional().describe("Description for the Planning phase"),
+      buildDescription: z15.string().nullable().optional().describe("Description for the Build phase"),
+      releaseDescription: z15.string().nullable().optional().describe("Description for the Release phase"),
+      prompt: z15.string().nullable().optional().describe("Build prompt for the roadmap item"),
       dateGranularity: dateGranularitySchema2.nullable().optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
-      dateValue: z11.string().nullable().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
+      dateValue: z15.string().nullable().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
       targetGranularity: dateGranularitySchema2.nullable().optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
-      targetValue: z11.string().nullable().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
+      targetValue: z15.string().nullable().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
     }
   }, async ({
     id,
     title,
     status,
     horizon,
+    phase,
+    phaseStep,
     value,
     effort,
     order,
@@ -1478,6 +1812,10 @@ function registerUpdateRoadmapItem(server) {
       updates.status = status;
     if (horizon !== undefined)
       updates.horizon = horizon;
+    if (phase !== undefined)
+      updates.phase = phase;
+    if (phaseStep !== undefined)
+      updates.phaseStep = phaseStep;
     if (value !== undefined)
       updates.value = value;
     if (effort !== undefined)
@@ -1535,6 +1873,8 @@ function registerUpdateRoadmapItem(server) {
               title: roadmap2.title,
               status: roadmap2.status,
               horizon: roadmap2.horizon,
+              phase: roadmap2.phase,
+              phaseStep: roadmap2.phaseStep,
               value: roadmap2.value,
               effort: roadmap2.effort,
               order: roadmap2.order,
@@ -1552,12 +1892,12 @@ function registerAddFeature(server) {
   server.registerTool("add_feature", {
     description: "Create a new feature with optional outcomes. Features represent capabilities or functionality areas.",
     inputSchema: {
-      name: z11.string().describe("Name of the feature"),
-      description: z11.string().optional().describe("Description of the feature"),
+      name: z15.string().describe("Name of the feature"),
+      description: z15.string().optional().describe("Description of the feature"),
       type: featureTypeSchema.optional().describe('Type - "feature" for specific functionality, "area" for grouping (defaults to "feature")'),
-      parentId: z11.string().optional().describe("UUID of parent feature/area to nest under"),
-      outcomes: z11.array(z11.string()).optional().describe("List of expected outcomes for this feature"),
-      linkToRoadmapId: z11.string().optional().describe("UUID of roadmap item to link this feature to")
+      parentId: z15.string().optional().describe("UUID of parent feature/area to nest under"),
+      outcomes: z15.array(z15.string()).optional().describe("List of expected outcomes for this feature"),
+      linkToRoadmapId: z15.string().optional().describe("UUID of roadmap item to link this feature to")
     }
   }, async ({
     name,
@@ -1604,10 +1944,10 @@ function registerSavePrd(server) {
   server.registerTool("save_prd", {
     description: "Save or update the PRD (Product Requirements Document) content for a roadmap item. Content should be markdown.",
     inputSchema: {
-      roadmapId: z11.string().describe("The UUID of the roadmap item"),
-      what: z11.string().nullable().describe("What is being built - the feature description"),
-      why: z11.string().nullable().describe("Why this is being built - the business justification"),
-      outcomes: z11.array(z11.string()).optional().describe("List of expected outcomes/success criteria")
+      roadmapId: z15.string().describe("The UUID of the roadmap item"),
+      what: z15.string().nullable().describe("What is being built - the feature description"),
+      why: z15.string().nullable().describe("Why this is being built - the business justification"),
+      outcomes: z15.array(z15.string()).optional().describe("List of expected outcomes/success criteria")
     }
   }, async ({
     roadmapId,
@@ -1645,8 +1985,8 @@ function registerUpdateBrainstormNotes(server) {
   server.registerTool("update_brainstorm_notes", {
     description: "Update the brainstorm notes for a roadmap item. Use this to capture ideas, questions, and research notes.",
     inputSchema: {
-      roadmapId: z11.string().describe("The UUID of the roadmap item"),
-      notes: z11.string().describe("The brainstorm notes content")
+      roadmapId: z15.string().describe("The UUID of the roadmap item"),
+      notes: z15.string().describe("The brainstorm notes content")
     }
   }, async ({ roadmapId, notes }) => {
     const client2 = getApiClient();
@@ -1675,7 +2015,7 @@ function registerDeleteRoadmapItem(server) {
   server.registerTool("delete_roadmap_item", {
     description: "Delete a roadmap item. This is a soft delete - the item can potentially be recovered.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the roadmap item to delete")
+      id: z15.string().describe("The UUID of the roadmap item to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -1697,9 +2037,9 @@ function registerReorderRoadmaps(server) {
   server.registerTool("reorder_roadmaps", {
     description: "Bulk reorder roadmap items by setting their order values. Use this to prioritize and organize the roadmap. Lower order values appear first.",
     inputSchema: {
-      items: z11.array(z11.object({
-        id: z11.string().describe("The UUID of the roadmap item"),
-        order: z11.number().int().min(0).describe("The new order value (0-based, lower = higher priority)")
+      items: z15.array(z15.object({
+        id: z15.string().describe("The UUID of the roadmap item"),
+        order: z15.number().int().min(0).describe("The new order value (0-based, lower = higher priority)")
       })).describe("Array of roadmap items with their new order values")
     }
   }, async ({ items }) => {
@@ -1723,10 +2063,10 @@ function registerUpdateFeature(server) {
   server.registerTool("update_feature", {
     description: "Update an existing feature. Can update name, type, or parent.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the feature to update"),
-      name: z11.string().optional().describe("New name for the feature"),
+      id: z15.string().describe("The UUID of the feature to update"),
+      name: z15.string().optional().describe("New name for the feature"),
       type: featureTypeSchema.optional().describe('New type - "feature" or "area"'),
-      parentId: z11.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
+      parentId: z15.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
     }
   }, async ({
     id,
@@ -1765,7 +2105,7 @@ function registerDeleteFeature(server) {
   server.registerTool("delete_feature", {
     description: "Delete a feature. This is a soft delete that also deletes all child features.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the feature to delete")
+      id: z15.string().describe("The UUID of the feature to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -1787,7 +2127,7 @@ function registerGetIdea(server) {
   server.registerTool("get_idea", {
     description: "Get full details of a single idea by ID.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the idea")
+      id: z15.string().describe("The UUID of the idea")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -1816,12 +2156,12 @@ function registerUpdateIdea(server) {
   server.registerTool("update_idea", {
     description: "Update an existing idea. Can update title, description, status, value, or effort.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the idea to update"),
-      title: z11.string().optional().describe("New title"),
-      description: z11.string().nullable().optional().describe("New description"),
+      id: z15.string().describe("The UUID of the idea to update"),
+      title: z15.string().optional().describe("New title"),
+      description: z15.string().nullable().optional().describe("New description"),
       status: ideaStatusSchema.optional().describe("New status"),
-      value: z11.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated value"),
-      effort: z11.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated effort")
+      value: z15.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated value"),
+      effort: z15.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated effort")
     }
   }, async ({
     id,
@@ -1868,7 +2208,7 @@ function registerDeleteIdea(server) {
   server.registerTool("delete_idea", {
     description: "Delete an idea. This is a soft delete.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the idea to delete")
+      id: z15.string().describe("The UUID of the idea to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -1907,8 +2247,8 @@ function registerUpdateStrategy(server) {
   server.registerTool("update_strategy", {
     description: "Update the organization strategy. Can update vision, mission, or both. Use this to set or refine the high-level direction.",
     inputSchema: {
-      vision: z11.string().nullable().optional().describe("The vision statement - where the product is headed"),
-      mission: z11.string().nullable().optional().describe("The mission statement - why the product exists")
+      vision: z15.string().nullable().optional().describe("The vision statement - where the product is headed"),
+      mission: z15.string().nullable().optional().describe("The mission statement - why the product exists")
     }
   }, async ({ vision, mission }) => {
     const client2 = getApiClient();
@@ -1956,8 +2296,8 @@ function registerCreateScenario(server) {
   server.registerTool("create_scenario", {
     description: "Create a new user scenario. Scenarios describe user workflows and how they accomplish goals.",
     inputSchema: {
-      title: z11.string().describe('Title of the scenario (e.g., "User creates their first roadmap")'),
-      description: z11.string().nullable().optional().describe("Detailed description of the scenario workflow")
+      title: z15.string().describe('Title of the scenario (e.g., "User creates their first roadmap")'),
+      description: z15.string().nullable().optional().describe("Detailed description of the scenario workflow")
     }
   }, async ({ title, description }) => {
     const client2 = getApiClient();
@@ -1986,9 +2326,9 @@ function registerUpdateScenario(server) {
   server.registerTool("update_scenario", {
     description: "Update an existing scenario.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the scenario to update"),
-      title: z11.string().optional().describe("New title"),
-      description: z11.string().nullable().optional().describe("New description")
+      id: z15.string().describe("The UUID of the scenario to update"),
+      title: z15.string().optional().describe("New title"),
+      description: z15.string().nullable().optional().describe("New description")
     }
   }, async ({
     id,
@@ -2023,7 +2363,7 @@ function registerDeleteScenario(server) {
   server.registerTool("delete_scenario", {
     description: "Delete a scenario. This is a soft delete.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the scenario to delete")
+      id: z15.string().describe("The UUID of the scenario to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -2038,7 +2378,7 @@ function registerDeleteScenario(server) {
     };
   });
 }
-var productTypeSchema2 = z11.enum([
+var productTypeSchema2 = z15.enum([
   "brand",
   "product",
   "app",
@@ -2051,8 +2391,8 @@ function registerCreateProduct(server) {
     description: "Create a new product, app, brand, or service. Products represent what the organization builds and offers.",
     inputSchema: {
       type: productTypeSchema2.describe("Type of product"),
-      name: z11.string().describe("Name of the product"),
-      parentId: z11.string().nullable().optional().describe("UUID of parent product to nest under")
+      name: z15.string().describe("Name of the product"),
+      parentId: z15.string().nullable().optional().describe("UUID of parent product to nest under")
     }
   }, async ({
     type,
@@ -2087,9 +2427,9 @@ function registerUpdateProduct(server) {
   server.registerTool("update_product", {
     description: "Update an existing product.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the product to update"),
-      name: z11.string().optional().describe("New name"),
-      parentId: z11.string().nullable().optional().describe("New parent product UUID, or null to move to root")
+      id: z15.string().describe("The UUID of the product to update"),
+      name: z15.string().optional().describe("New name"),
+      parentId: z15.string().nullable().optional().describe("New parent product UUID, or null to move to root")
     }
   }, async ({ id, name, parentId }) => {
     const client2 = getApiClient();
@@ -2121,7 +2461,7 @@ function registerDeleteProduct(server) {
   server.registerTool("delete_product", {
     description: "Delete a product. This is a soft delete that also deletes all child products.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the product to delete")
+      id: z15.string().describe("The UUID of the product to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -2144,7 +2484,7 @@ function registerGetProduct(server) {
   server.registerTool("get_product", {
     description: "Get full details of a product by ID, including its documentation (design system and ADRs).",
     inputSchema: {
-      id: z11.string().describe("The UUID of the product")
+      id: z15.string().describe("The UUID of the product")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -2181,7 +2521,7 @@ function registerSearchProducts(server) {
   server.registerTool("search_products", {
     description: "Search for products by name. Returns a list of matching products with basic info.",
     inputSchema: {
-      query: z11.string().optional().describe("Search query to match against product name"),
+      query: z15.string().optional().describe("Search query to match against product name"),
       type: productTypeSchema2.optional().describe("Filter by product type")
     }
   }, async ({ query, type }) => {
@@ -2216,7 +2556,7 @@ function registerGetProductDocumentation(server) {
   server.registerTool("get_product_documentation", {
     description: "Get the documentation (design system and ADRs) for a product. Use this to read existing documentation before updating.",
     inputSchema: {
-      productId: z11.string().describe("The UUID of the product")
+      productId: z15.string().describe("The UUID of the product")
     }
   }, async ({ productId }) => {
     const client2 = getApiClient();
@@ -2244,9 +2584,9 @@ function registerUpdateProductDocumentation(server) {
   server.registerTool("update_product_documentation", {
     description: "Update the documentation for a product. Use this to keep design system and ADRs up to date. Creates documentation if it does not exist.",
     inputSchema: {
-      productId: z11.string().describe("The UUID of the product"),
-      designSystem: z11.string().nullable().optional().describe("Design system documentation - colors, typography, spacing, components. Pass null to clear."),
-      adrs: z11.string().nullable().optional().describe("Architecture Decision Records - document key technical decisions. Pass null to clear.")
+      productId: z15.string().describe("The UUID of the product"),
+      designSystem: z15.string().nullable().optional().describe("Design system documentation - colors, typography, spacing, components. Pass null to clear."),
+      adrs: z15.string().nullable().optional().describe("Architecture Decision Records - document key technical decisions. Pass null to clear.")
     }
   }, async ({
     productId,
@@ -2283,8 +2623,8 @@ function registerCreateAudience(server) {
   server.registerTool("create_audience", {
     description: "Create a new audience member. Audiences represent who the product serves.",
     inputSchema: {
-      name: z11.string().describe('Name of the audience (e.g., "Product Manager", "End User")'),
-      description: z11.string().nullable().optional().describe("Description of the audience")
+      name: z15.string().describe('Name of the audience (e.g., "Product Manager", "End User")'),
+      description: z15.string().nullable().optional().describe("Description of the audience")
     }
   }, async ({ name, description }) => {
     const client2 = getApiClient();
@@ -2313,9 +2653,9 @@ function registerUpdateAudience(server) {
   server.registerTool("update_audience", {
     description: "Update an existing audience member.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the audience to update"),
-      name: z11.string().optional().describe("New name"),
-      description: z11.string().nullable().optional().describe("New description")
+      id: z15.string().describe("The UUID of the audience to update"),
+      name: z15.string().optional().describe("New name"),
+      description: z15.string().nullable().optional().describe("New description")
     }
   }, async ({
     id,
@@ -2350,7 +2690,7 @@ function registerDeleteAudience(server) {
   server.registerTool("delete_audience", {
     description: "Delete an audience member. This is a soft delete.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the audience to delete")
+      id: z15.string().describe("The UUID of the audience to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -2392,9 +2732,9 @@ function registerGetHistory(server) {
   server.registerTool("get_history", {
     description: "Get raw history events for a date range. Returns full event details including payloads. " + "Use entityType or entityId filters to narrow results. For status reports, prefer " + "get_history_summary to avoid context overflow.",
     inputSchema: {
-      startDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
-      endDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format"),
-      entityType: z11.enum([
+      startDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
+      endDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format"),
+      entityType: z15.enum([
         "roadmap",
         "feature",
         "idea",
@@ -2426,8 +2766,8 @@ function registerGetHistorySummary(server) {
   server.registerTool("get_history_summary", {
     description: "Get a summary of history events for a date range. Returns counts by entity type, " + "list of changed entities with titles, and total event count. Use this for status " + "report generation instead of get_history to avoid context overflow.",
     inputSchema: {
-      startDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
-      endDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format")
+      startDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Start date in YYYY-MM-DD format"),
+      endDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("End date in YYYY-MM-DD format")
     }
   }, async ({ startDate, endDate }) => {
     const client2 = getApiClient();
@@ -2446,13 +2786,13 @@ function registerCreateStatusUpdate(server) {
   server.registerTool("create_status_update", {
     description: "Create a new status report. Use this after generating the report content from history events.",
     inputSchema: {
-      startDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period start date in YYYY-MM-DD format"),
-      endDate: z11.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period end date in YYYY-MM-DD format"),
-      content: z11.string().describe("The markdown content of the status report"),
-      title: z11.string().optional().describe("Optional title for the report"),
-      items: z11.array(z11.object({
-        roadmapItemId: z11.string().describe("UUID of the roadmap item"),
-        status: z11.string().describe("Status of the item at report creation time")
+      startDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period start date in YYYY-MM-DD format"),
+      endDate: z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Report period end date in YYYY-MM-DD format"),
+      content: z15.string().describe("The markdown content of the status report"),
+      title: z15.string().optional().describe("Optional title for the report"),
+      items: z15.array(z15.object({
+        roadmapItemId: z15.string().describe("UUID of the roadmap item"),
+        status: z15.string().describe("Status of the item at report creation time")
       })).optional().describe("Roadmap items to include in the report snapshot")
     }
   }, async ({
@@ -2493,18 +2833,18 @@ function registerSaveStories(server) {
   server.registerTool("save_stories", {
     description: "Save epics and stories for a roadmap item. Replaces all existing epics/stories. Use this to set the complete list of epics and stories for a roadmap.",
     inputSchema: {
-      roadmapId: z11.string().uuid().describe("The UUID of the roadmap item"),
-      epics: z11.array(z11.object({
-        title: z11.string().min(1).describe("Title of the epic"),
-        description: z11.string().nullable().optional().describe("Description of the epic"),
-        stories: z11.array(z11.object({
-          title: z11.string().min(1).describe("Title of the story"),
-          description: z11.string().nullable().optional().describe("Description of the story")
+      roadmapId: z15.string().uuid().describe("The UUID of the roadmap item"),
+      epics: z15.array(z15.object({
+        title: z15.string().min(1).describe("Title of the epic"),
+        description: z15.string().nullable().optional().describe("Description of the epic"),
+        stories: z15.array(z15.object({
+          title: z15.string().min(1).describe("Title of the story"),
+          description: z15.string().nullable().optional().describe("Description of the story")
         })).optional().describe("Stories within this epic")
       })).optional().describe("List of epics with their nested stories"),
-      stories: z11.array(z11.object({
-        title: z11.string().min(1).describe("Title of the story"),
-        description: z11.string().nullable().optional().describe("Description of the story")
+      stories: z15.array(z15.object({
+        title: z15.string().min(1).describe("Title of the story"),
+        description: z15.string().nullable().optional().describe("Description of the story")
       })).optional().describe("List of standalone stories (not part of any epic)")
     }
   }, async ({
@@ -2536,10 +2876,10 @@ function registerUploadWireframe(server) {
   server.registerTool("upload_wireframe", {
     description: "Upload an image to a roadmap item's wireframes. Returns a curl command to execute for the upload, then creates the wireframe record. After running the curl command, the wireframe will be visible in the web app.",
     inputSchema: {
-      roadmapId: z11.string().describe("The UUID of the roadmap item"),
-      filePath: z11.string().describe("Absolute path to the image file on disk"),
-      description: z11.string().optional().describe("Optional description of the wireframe"),
-      outcomeIds: z11.array(z11.string()).optional().describe("Optional array of PRD outcome IDs this wireframe addresses")
+      roadmapId: z15.string().describe("The UUID of the roadmap item"),
+      filePath: z15.string().describe("Absolute path to the image file on disk"),
+      description: z15.string().optional().describe("Optional description of the wireframe"),
+      outcomeIds: z15.array(z15.string()).optional().describe("Optional array of PRD outcome IDs this wireframe addresses")
     }
   }, async ({
     roadmapId,
@@ -2593,9 +2933,9 @@ function registerUpdateWireframe(server) {
   server.registerTool("update_wireframe", {
     description: "Update a wireframe's description or outcome tags.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the wireframe"),
-      description: z11.string().nullable().optional().describe("New description for the wireframe"),
-      outcomeIds: z11.array(z11.string()).optional().describe("Array of PRD outcome IDs this wireframe addresses (replaces existing)")
+      id: z15.string().describe("The UUID of the wireframe"),
+      description: z15.string().nullable().optional().describe("New description for the wireframe"),
+      outcomeIds: z15.array(z15.string()).optional().describe("Array of PRD outcome IDs this wireframe addresses (replaces existing)")
     }
   }, async ({
     id,
@@ -2631,7 +2971,7 @@ function registerDeleteWireframe(server) {
   server.registerTool("delete_wireframe", {
     description: "Delete a wireframe (soft delete).",
     inputSchema: {
-      id: z11.string().describe("The UUID of the wireframe to delete")
+      id: z15.string().describe("The UUID of the wireframe to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -2650,9 +2990,9 @@ function registerUploadBrainstormMedia(server) {
   server.registerTool("upload_brainstorm_media", {
     description: "Upload an image or video to a roadmap item's brainstorming section. Returns a curl command to execute for the upload.",
     inputSchema: {
-      roadmapId: z11.string().describe("The UUID of the roadmap item"),
-      filePath: z11.string().describe("Absolute path to the image or video file on disk"),
-      description: z11.string().optional().describe("Optional description of the media")
+      roadmapId: z15.string().describe("The UUID of the roadmap item"),
+      filePath: z15.string().describe("Absolute path to the image or video file on disk"),
+      description: z15.string().optional().describe("Optional description of the media")
     }
   }, async ({
     roadmapId,
@@ -2704,8 +3044,8 @@ function registerUpdateBrainstormMedia(server) {
   server.registerTool("update_brainstorm_media", {
     description: "Update a brainstorm media item's description.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the brainstorm media"),
-      description: z11.string().nullable().describe("New description for the media")
+      id: z15.string().describe("The UUID of the brainstorm media"),
+      description: z15.string().nullable().describe("New description for the media")
     }
   }, async ({ id, description }) => {
     const client2 = getApiClient();
@@ -2729,7 +3069,7 @@ function registerDeleteBrainstormMedia(server) {
   server.registerTool("delete_brainstorm_media", {
     description: "Delete a brainstorm media item (soft delete).",
     inputSchema: {
-      id: z11.string().describe("The UUID of the brainstorm media to delete")
+      id: z15.string().describe("The UUID of the brainstorm media to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -2748,9 +3088,9 @@ function registerUploadProductDesignMedia(server) {
   server.registerTool("upload_product_design_media", {
     description: "Upload an image or video to a product's design media section. Returns a curl command to execute for the upload.",
     inputSchema: {
-      productId: z11.string().describe("The UUID of the product"),
-      filePath: z11.string().describe("Absolute path to the image or video file on disk"),
-      description: z11.string().optional().describe("Optional description of the media")
+      productId: z15.string().describe("The UUID of the product"),
+      filePath: z15.string().describe("Absolute path to the image or video file on disk"),
+      description: z15.string().optional().describe("Optional description of the media")
     }
   }, async ({
     productId,
@@ -2803,9 +3143,9 @@ function registerUpdateProductDesignMedia(server) {
   server.registerTool("update_product_design_media", {
     description: "Update a product design media item's description.",
     inputSchema: {
-      productId: z11.string().describe("The UUID of the product"),
-      mediaId: z11.string().describe("The UUID of the design media"),
-      description: z11.string().nullable().describe("New description for the media")
+      productId: z15.string().describe("The UUID of the product"),
+      mediaId: z15.string().describe("The UUID of the design media"),
+      description: z15.string().nullable().describe("New description for the media")
     }
   }, async ({
     productId,
@@ -2833,8 +3173,8 @@ function registerDeleteProductDesignMedia(server) {
   server.registerTool("delete_product_design_media", {
     description: "Delete a product design media item (soft delete).",
     inputSchema: {
-      productId: z11.string().describe("The UUID of the product"),
-      mediaId: z11.string().describe("The UUID of the design media to delete")
+      productId: z15.string().describe("The UUID of the product"),
+      mediaId: z15.string().describe("The UUID of the design media to delete")
     }
   }, async ({ productId, mediaId }) => {
     const client2 = getApiClient();
@@ -2856,8 +3196,8 @@ function registerUploadDesignWalkthrough(server) {
   server.registerTool("upload_design_walkthrough", {
     description: "Upload a walkthrough video to a roadmap item's design phase. Returns a curl command to execute for the upload.",
     inputSchema: {
-      roadmapId: z11.string().describe("The UUID of the roadmap item"),
-      filePath: z11.string().describe("Absolute path to the video file on disk")
+      roadmapId: z15.string().describe("The UUID of the roadmap item"),
+      filePath: z15.string().describe("Absolute path to the video file on disk")
     }
   }, async ({ roadmapId, filePath }) => {
     const client2 = getApiClient();
@@ -2899,8 +3239,8 @@ function registerUploadReleaseWalkthrough(server) {
   server.registerTool("upload_release_walkthrough", {
     description: "Upload a walkthrough video to a roadmap item's release phase. Returns a curl command to execute for the upload.",
     inputSchema: {
-      roadmapId: z11.string().describe("The UUID of the roadmap item"),
-      filePath: z11.string().describe("Absolute path to the video file on disk")
+      roadmapId: z15.string().describe("The UUID of the roadmap item"),
+      filePath: z15.string().describe("Absolute path to the video file on disk")
     }
   }, async ({ roadmapId, filePath }) => {
     const client2 = getApiClient();
@@ -2958,9 +3298,9 @@ function registerPublishPrototype(server) {
   server.registerTool("publish_prototype", {
     description: "Publish a local prototype folder to a shareable URL. Uploads all files from the folder and returns a time-limited shareable link.",
     inputSchema: {
-      roadmapId: z11.string().uuid().describe("The UUID of the roadmap item to attach the prototype to"),
-      folderPath: z11.string().describe("Absolute path to the local mockup folder"),
-      entryPoint: z11.string().default("index.html").describe("Main HTML file to open (defaults to index.html)")
+      roadmapId: z15.string().uuid().describe("The UUID of the roadmap item to attach the prototype to"),
+      folderPath: z15.string().describe("Absolute path to the local mockup folder"),
+      entryPoint: z15.string().default("index.html").describe("Main HTML file to open (defaults to index.html)")
     }
   }, async ({
     roadmapId,
@@ -3115,15 +3455,15 @@ Expires: ${expiryDate}`
     };
   });
 }
-var dateGranularitySchema2 = z11.enum(["day", "month", "quarter", "half-year", "year"]);
+var dateGranularitySchema2 = z15.enum(["day", "month", "quarter", "half-year", "year"]);
 function registerSearchInitiatives(server) {
   server.registerTool("search_initiatives", {
     description: "Search for initiatives by title or filter by horizon. Returns a list of matching initiatives with item counts.",
     inputSchema: {
-      query: z11.string().optional().describe("Search query to match against title or description"),
+      query: z15.string().optional().describe("Search query to match against title or description"),
       horizon: horizonSchema.optional().describe("Filter by planning horizon"),
-      limit: z11.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
-      offset: z11.number().int().min(0).optional().describe("Number of items to skip (default 0)")
+      limit: z15.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
+      offset: z15.number().int().min(0).optional().describe("Number of items to skip (default 0)")
     }
   }, async ({
     query,
@@ -3173,7 +3513,7 @@ function registerGetInitiative(server) {
   server.registerTool("get_initiative", {
     description: "Get full details of an initiative including all linked roadmap items.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the initiative")
+      id: z15.string().describe("The UUID of the initiative")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -3192,12 +3532,12 @@ function registerCreateInitiative(server) {
   server.registerTool("create_initiative", {
     description: "Create a new initiative. Initiatives group related roadmap items for cross-functional coordination.",
     inputSchema: {
-      title: z11.string().describe("Title of the initiative"),
-      description: z11.string().optional().describe("Description of the initiative (markdown)"),
+      title: z15.string().describe("Title of the initiative"),
+      description: z15.string().optional().describe("Description of the initiative (markdown)"),
       horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")'),
       dateGranularity: dateGranularitySchema2.optional().describe("Target date granularity: day, month, quarter, half-year, or year"),
-      dateValue: z11.string().optional().describe('Target date value matching granularity (e.g., "2024-Q1", "2024-03")'),
-      targetDate: z11.string().optional().describe("Target date in YYYY-MM-DD format")
+      dateValue: z15.string().optional().describe('Target date value matching granularity (e.g., "2024-Q1", "2024-03")'),
+      targetDate: z15.string().optional().describe("Target date in YYYY-MM-DD format")
     }
   }, async ({
     title,
@@ -3241,14 +3581,14 @@ function registerUpdateInitiative(server) {
   server.registerTool("update_initiative", {
     description: "Update an existing initiative.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the initiative to update"),
-      title: z11.string().optional().describe("New title"),
-      description: z11.string().nullable().optional().describe("New description (null to clear)"),
+      id: z15.string().describe("The UUID of the initiative to update"),
+      title: z15.string().optional().describe("New title"),
+      description: z15.string().nullable().optional().describe("New description (null to clear)"),
       horizon: horizonSchema.optional().describe("New planning horizon"),
       dateGranularity: dateGranularitySchema2.nullable().optional().describe("New target date granularity (null to clear)"),
-      dateValue: z11.string().nullable().optional().describe("New target date value (null to clear)"),
-      targetDate: z11.string().nullable().optional().describe("New target date in YYYY-MM-DD format (null to clear)"),
-      order: z11.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)")
+      dateValue: z15.string().nullable().optional().describe("New target date value (null to clear)"),
+      targetDate: z15.string().nullable().optional().describe("New target date in YYYY-MM-DD format (null to clear)"),
+      order: z15.number().int().min(0).optional().describe("Sort order for prioritization (lower numbers appear first)")
     }
   }, async ({
     id,
@@ -3303,7 +3643,7 @@ function registerDeleteInitiative(server) {
   server.registerTool("delete_initiative", {
     description: "Delete an initiative. This is a soft delete that also unlinks all roadmap items from the initiative.",
     inputSchema: {
-      id: z11.string().describe("The UUID of the initiative to delete")
+      id: z15.string().describe("The UUID of the initiative to delete")
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
@@ -3322,9 +3662,9 @@ function registerReorderInitiatives(server) {
   server.registerTool("reorder_initiatives", {
     description: "Bulk reorder initiatives by setting their order values. Lower order values appear first.",
     inputSchema: {
-      items: z11.array(z11.object({
-        id: z11.string().describe("The UUID of the initiative"),
-        order: z11.number().int().min(0).describe("The new order value (0-based)")
+      items: z15.array(z15.object({
+        id: z15.string().describe("The UUID of the initiative"),
+        order: z15.number().int().min(0).describe("The new order value (0-based)")
       })).describe("Array of initiatives with their new order values")
     }
   }, async ({ items }) => {
@@ -3340,6 +3680,703 @@ function registerReorderInitiatives(server) {
     };
   });
 }
+function registerSearchExports(server) {
+  server.registerTool("search_exports", {
+    description: "Search for export records by roadmap, external system, or entity. Returns a list of matching exports with pagination.",
+    inputSchema: {
+      roadmapId: z15.string().uuid().optional().describe("Filter by roadmap item ID"),
+      externalSystem: z15.enum(["linear", "notion", "jira", "github"]).optional().describe("Filter by external system"),
+      localEntityType: z15.enum(["roadmap", "prd", "epic", "story", "design"]).optional().describe("Filter by local entity type"),
+      localEntityId: z15.string().uuid().optional().describe("Filter by local entity ID"),
+      limit: z15.number().int().min(1).max(100).optional().describe("Max items to return (default 10)"),
+      offset: z15.number().int().min(0).optional().describe("Number of items to skip (default 0)")
+    }
+  }, async ({
+    roadmapId,
+    externalSystem,
+    localEntityType,
+    localEntityId,
+    limit,
+    offset
+  }) => {
+    const client2 = getApiClient();
+    const response = await client2.searchExports({
+      roadmapId,
+      externalSystem,
+      localEntityType,
+      localEntityId,
+      limit,
+      offset
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            exports: response.data,
+            total: response.meta.total,
+            hasMore: response.meta.has_more
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetExport(server) {
+  server.registerTool("get_export", {
+    description: "Get full details of a single export record by ID.",
+    inputSchema: {
+      id: z15.string().uuid().describe("The UUID of the export record")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    const exportRecord = await client2.getExport(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(exportRecord, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCreateExport(server) {
+  server.registerTool("create_export", {
+    description: "Record a new export (with upsert). If an export with the same roadmap, entity, and external system already exists, it will be updated.",
+    inputSchema: {
+      roadmapId: z15.string().uuid().describe("The UUID of the roadmap item"),
+      localEntityType: z15.enum(["roadmap", "prd", "epic", "story", "design"]).describe("Type of local entity being exported"),
+      localEntityId: z15.string().uuid().describe("The UUID of the local entity"),
+      externalSystem: z15.enum(["linear", "notion", "jira", "github"]).describe("External system where the entity was exported"),
+      externalObjectType: z15.string().min(1).describe('Type of object in the external system (e.g., "issue", "page", "project")'),
+      externalId: z15.string().min(1).describe("ID of the object in the external system"),
+      externalUrl: z15.string().url().optional().describe("URL to the object in the external system"),
+      metadata: z15.record(z15.unknown()).optional().describe("Additional metadata about the export")
+    }
+  }, async ({
+    roadmapId,
+    localEntityType,
+    localEntityId,
+    externalSystem,
+    externalObjectType,
+    externalId,
+    externalUrl,
+    metadata
+  }) => {
+    const client2 = getApiClient();
+    const exportRecord = await client2.createExport({
+      roadmapId,
+      localEntityType,
+      localEntityId,
+      externalSystem,
+      externalObjectType,
+      externalId,
+      externalUrl,
+      metadata
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, export: exportRecord }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateExport(server) {
+  server.registerTool("update_export", {
+    description: "Update an export record. Can update the external URL or metadata.",
+    inputSchema: {
+      id: z15.string().uuid().describe("The UUID of the export record to update"),
+      externalUrl: z15.string().url().nullable().optional().describe("New URL to the object in the external system"),
+      metadata: z15.record(z15.unknown()).optional().describe("New metadata to replace existing metadata")
+    }
+  }, async ({
+    id,
+    externalUrl,
+    metadata
+  }) => {
+    const client2 = getApiClient();
+    const exportRecord = await client2.updateExport(id, { externalUrl, metadata });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, export: exportRecord }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteExport(server) {
+  server.registerTool("delete_export", {
+    description: "Delete an export record. This is a soft delete.",
+    inputSchema: {
+      id: z15.string().uuid().describe("The UUID of the export record to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteExport(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: id }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerListPresentations(server) {
+  server.registerTool("list_presentations", {
+    description: "List all presentations.",
+    inputSchema: {}
+  }, async () => {
+    const client2 = getApiClient();
+    const result = await client2.listPresentations();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetPresentation(server) {
+  server.registerTool("get_presentation", {
+    description: "Get presentation with variants and slides.",
+    inputSchema: {
+      id: z15.string().describe("The UUID of the presentation")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    const presentation2 = await client2.getPresentation(id);
+    const variantsResult = await client2.listVariants(id);
+    const variantsWithSlides = await Promise.all(variantsResult.items.map(async (variant2) => {
+      const slidesResult = await client2.listSlides(id, variant2.id);
+      return {
+        ...variant2,
+        slides: slidesResult.items
+      };
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            ...presentation2,
+            variants: variantsWithSlides
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCreatePresentation(server) {
+  server.registerTool("create_presentation", {
+    description: "Create a new presentation.",
+    inputSchema: {
+      title: z15.string().describe("Title of the presentation"),
+      description: z15.string().nullable().optional().describe("Description of the presentation")
+    }
+  }, async ({ title, description }) => {
+    const client2 = getApiClient();
+    const presentation2 = await client2.createPresentation({
+      title,
+      description: description ?? null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(presentation2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdatePresentation(server) {
+  server.registerTool("update_presentation", {
+    description: "Update an existing presentation.",
+    inputSchema: {
+      id: z15.string().describe("The UUID of the presentation to update"),
+      title: z15.string().optional().describe("New title"),
+      description: z15.string().nullable().optional().describe("New description")
+    }
+  }, async ({
+    id,
+    title,
+    description
+  }) => {
+    const client2 = getApiClient();
+    const data = {};
+    if (title !== undefined)
+      data.title = title;
+    if (description !== undefined)
+      data.description = description;
+    const presentation2 = await client2.updatePresentation(id, data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(presentation2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeletePresentation(server) {
+  server.registerTool("delete_presentation", {
+    description: "Delete a presentation.",
+    inputSchema: {
+      id: z15.string().describe("The UUID of the presentation to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deletePresentation(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: id }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerReorderPresentations(server) {
+  server.registerTool("reorder_presentations", {
+    description: "Reorder presentations by setting their order values. Lower order values appear first.",
+    inputSchema: {
+      items: z15.array(z15.object({
+        id: z15.string().describe("The UUID of the presentation"),
+        order: z15.number().int().min(0).describe("The new order value (0-based)")
+      })).describe("Array of presentations with their new order values")
+    }
+  }, async ({ items }) => {
+    const client2 = getApiClient();
+    await client2.reorderPresentations(items);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerListVariants(server) {
+  server.registerTool("list_variants", {
+    description: "List all variants for a presentation.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation")
+    }
+  }, async ({ presentationId }) => {
+    const client2 = getApiClient();
+    const result = await client2.listVariants(presentationId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetVariant(server) {
+  server.registerTool("get_variant", {
+    description: "Get variant with its slides.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      variantId: z15.string().describe("The UUID of the variant")
+    }
+  }, async ({ presentationId, variantId }) => {
+    const client2 = getApiClient();
+    const variant2 = await client2.getVariant(presentationId, variantId);
+    const slidesResult = await client2.listSlides(presentationId, variantId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            ...variant2,
+            slides: slidesResult.items
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCreateVariant(server) {
+  server.registerTool("create_variant", {
+    description: "Create a new variant for a presentation.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      name: z15.string().describe("Name of the variant"),
+      audienceId: z15.string().nullable().optional().describe("The UUID of the target audience")
+    }
+  }, async ({
+    presentationId,
+    name,
+    audienceId
+  }) => {
+    const client2 = getApiClient();
+    const variant2 = await client2.createVariant(presentationId, {
+      name,
+      audienceId: audienceId ?? null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(variant2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateVariant(server) {
+  server.registerTool("update_variant", {
+    description: "Update an existing variant.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      variantId: z15.string().describe("The UUID of the variant to update"),
+      name: z15.string().optional().describe("New name"),
+      audienceId: z15.string().nullable().optional().describe("New target audience UUID")
+    }
+  }, async ({
+    presentationId,
+    variantId,
+    name,
+    audienceId
+  }) => {
+    const client2 = getApiClient();
+    const data = {};
+    if (name !== undefined)
+      data.name = name;
+    if (audienceId !== undefined)
+      data.audienceId = audienceId;
+    const variant2 = await client2.updateVariant(presentationId, variantId, data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(variant2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteVariant(server) {
+  server.registerTool("delete_variant", {
+    description: "Delete a variant.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      variantId: z15.string().describe("The UUID of the variant to delete")
+    }
+  }, async ({ presentationId, variantId }) => {
+    const client2 = getApiClient();
+    await client2.deleteVariant(presentationId, variantId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: variantId }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerReorderVariants(server) {
+  server.registerTool("reorder_variants", {
+    description: "Reorder variants by setting their order values. Lower order values appear first.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      items: z15.array(z15.object({
+        id: z15.string().describe("The UUID of the variant"),
+        order: z15.number().int().min(0).describe("The new order value (0-based)")
+      })).describe("Array of variants with their new order values")
+    }
+  }, async ({
+    presentationId,
+    items
+  }) => {
+    const client2 = getApiClient();
+    await client2.reorderVariants(presentationId, items);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCloneVariant(server) {
+  server.registerTool("clone_variant", {
+    description: "Clone a variant with all its slides.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      variantId: z15.string().describe("The UUID of the variant to clone")
+    }
+  }, async ({ presentationId, variantId }) => {
+    const client2 = getApiClient();
+    const clonedVariant = await client2.cloneVariant(presentationId, variantId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(clonedVariant, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerSetDefaultVariant(server) {
+  server.registerTool("set_default_variant", {
+    description: "Set a variant as the default for the presentation.",
+    inputSchema: {
+      presentationId: z15.string().describe("The UUID of the presentation"),
+      variantId: z15.string().describe("The UUID of the variant to set as default")
+    }
+  }, async ({ presentationId, variantId }) => {
+    const client2 = getApiClient();
+    await client2.setDefaultVariant(presentationId, variantId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, variantId }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerListSlides(server) {
+  server.registerTool("list_slides", {
+    description: "List all slides in a variant.",
+    inputSchema: {
+      variantId: z15.string().describe("The UUID of the variant")
+    }
+  }, async ({ variantId }) => {
+    const client2 = getApiClient();
+    const presentationId = await client2.getVariantPresentationId(variantId);
+    if (!presentationId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Variant not found" }, null, 2)
+          }
+        ]
+      };
+    }
+    const result = await client2.listSlides(presentationId, variantId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetSlide(server) {
+  server.registerTool("get_slide", {
+    description: "Get a slide by ID.",
+    inputSchema: {
+      variantId: z15.string().describe("The UUID of the variant"),
+      slideId: z15.string().describe("The UUID of the slide")
+    }
+  }, async ({ variantId, slideId }) => {
+    const client2 = getApiClient();
+    const presentationId = await client2.getVariantPresentationId(variantId);
+    if (!presentationId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Variant not found" }, null, 2)
+          }
+        ]
+      };
+    }
+    const slide2 = await client2.getSlide(presentationId, variantId, slideId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(slide2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCreateSlide(server) {
+  server.registerTool("create_slide", {
+    description: "Create a new slide in a variant.",
+    inputSchema: {
+      variantId: z15.string().describe("The UUID of the variant"),
+      title: z15.string().optional().describe("Title of the slide"),
+      content: z15.object({ body: z15.string().optional() }).nullable().optional().describe("Slide content with markdown body"),
+      speakerNotes: z15.string().nullable().optional().describe("Speaker notes for the slide")
+    }
+  }, async ({
+    variantId,
+    title,
+    content,
+    speakerNotes
+  }) => {
+    const client2 = getApiClient();
+    const presentationId = await client2.getVariantPresentationId(variantId);
+    if (!presentationId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Variant not found" }, null, 2)
+          }
+        ]
+      };
+    }
+    const slide2 = await client2.createSlide(presentationId, variantId, {
+      title,
+      content,
+      speakerNotes
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(slide2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateSlide(server) {
+  server.registerTool("update_slide", {
+    description: "Update an existing slide.",
+    inputSchema: {
+      variantId: z15.string().describe("The UUID of the variant"),
+      slideId: z15.string().describe("The UUID of the slide to update"),
+      title: z15.string().optional().describe("New title"),
+      content: z15.object({ body: z15.string().optional() }).nullable().optional().describe("New slide content with markdown body"),
+      speakerNotes: z15.string().nullable().optional().describe("New speaker notes")
+    }
+  }, async ({
+    variantId,
+    slideId,
+    title,
+    content,
+    speakerNotes
+  }) => {
+    const client2 = getApiClient();
+    const presentationId = await client2.getVariantPresentationId(variantId);
+    if (!presentationId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Variant not found" }, null, 2)
+          }
+        ]
+      };
+    }
+    const data = {};
+    if (title !== undefined)
+      data.title = title;
+    if (content !== undefined)
+      data.content = content;
+    if (speakerNotes !== undefined)
+      data.speakerNotes = speakerNotes;
+    const slide2 = await client2.updateSlide(presentationId, variantId, slideId, data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(slide2, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteSlide(server) {
+  server.registerTool("delete_slide", {
+    description: "Delete a slide (soft delete).",
+    inputSchema: {
+      variantId: z15.string().describe("The UUID of the variant"),
+      slideId: z15.string().describe("The UUID of the slide to delete")
+    }
+  }, async ({ variantId, slideId }) => {
+    const client2 = getApiClient();
+    const presentationId = await client2.getVariantPresentationId(variantId);
+    if (!presentationId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Variant not found" }, null, 2)
+          }
+        ]
+      };
+    }
+    await client2.deleteSlide(presentationId, variantId, slideId);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, deleted: slideId }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerReorderSlides(server) {
+  server.registerTool("reorder_slides", {
+    description: "Reorder slides by setting their order values. Lower order values appear first.",
+    inputSchema: {
+      variantId: z15.string().describe("The UUID of the variant"),
+      items: z15.array(z15.object({
+        id: z15.string().describe("The UUID of the slide"),
+        order: z15.number().int().min(0).describe("The new order value (0-based)")
+      })).describe("Array of slides with their new order values")
+    }
+  }, async ({
+    variantId,
+    items
+  }) => {
+    const client2 = getApiClient();
+    const presentationId = await client2.getVariantPresentationId(variantId);
+    if (!presentationId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "Variant not found" }, null, 2)
+          }
+        ]
+      };
+    }
+    await client2.reorderSlides(presentationId, variantId, items);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, reordered: items.length }, null, 2)
+        }
+      ]
+    };
+  });
+}
 
 // src/index.ts
 async function main() {