@ourroadmaps/mcp 0.28.1 → 0.30.0

package/dist/index.js

@@ -21,29 +21,282 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-// ../../packages/shared/src/schemas/audience.ts
+
+// ../../packages/shared/src/blocknote-markdown.ts
+var LIST_BLOCK_TYPES = new Set(["bulletListItem", "numberedListItem", "checkListItem"]);
+function contentToMarkdown(content) {
+  if (content == null)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  if (content.length === 0)
+    return "";
+  try {
+    return convertBlocks(content, 0);
+  } catch {
+    try {
+      return extractPlainText(content);
+    } catch {
+      return "";
+    }
+  }
+}
+function getPreviousBlockType(blocks, currentIndex) {
+  for (let i = currentIndex - 1;i >= 0; i--) {
+    const block = blocks[i];
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    const line = renderBlock(b, 0, 0);
+    if (line !== null)
+      return b.type || "";
+  }
+  return "";
+}
+function appendSeparator(parts, prevType, currentType) {
+  if (parts.length === 0)
+    return;
+  const bothList = LIST_BLOCK_TYPES.has(prevType) && LIST_BLOCK_TYPES.has(currentType);
+  parts.push(bothList ? `
+` : `
+
+`);
+}
+function appendChildren(parts, block, depth) {
+  const children = block.children;
+  if (!Array.isArray(children) || children.length === 0)
+    return;
+  const childOutput = convertBlocks(children, depth + 1);
+  if (childOutput) {
+    parts.push(`
+`);
+    parts.push(childOutput);
+  }
+}
+function convertBlocks(blocks, depth) {
+  const parts = [];
+  let numberedCounter = 0;
+  for (let i = 0;i < blocks.length; i++) {
+    const block = blocks[i];
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    const type = b.type || "";
+    numberedCounter = type === "numberedListItem" ? numberedCounter + 1 : 0;
+    const line = renderBlock(b, depth, numberedCounter);
+    if (line === null)
+      continue;
+    const prevType = getPreviousBlockType(blocks, i);
+    appendSeparator(parts, prevType, type);
+    parts.push(line);
+    appendChildren(parts, b, depth);
+  }
+  return parts.join("");
+}
+function renderBlock(block, depth, numberedCounter) {
+  const type = block.type || "";
+  const props = block.props || {};
+  const content = block.content;
+  const indent = "  ".repeat(depth);
+  switch (type) {
+    case "paragraph": {
+      const text = renderInlineContent(content);
+      if (!text)
+        return null;
+      return `${indent}${text}`;
+    }
+    case "heading": {
+      const level = props.level || 1;
+      const prefix = "#".repeat(Math.min(level, 6));
+      const text = renderInlineContent(content);
+      return `${indent}${prefix} ${text}`;
+    }
+    case "bulletListItem": {
+      const text = renderInlineContent(content);
+      return `${indent}- ${text}`;
+    }
+    case "numberedListItem": {
+      const text = renderInlineContent(content);
+      return `${indent}${numberedCounter}. ${text}`;
+    }
+    case "checkListItem": {
+      const checked = props.checked === true;
+      const marker = checked ? "[x]" : "[ ]";
+      const text = renderInlineContent(content);
+      return `${indent}- ${marker} ${text}`;
+    }
+    case "codeBlock": {
+      const language = props.language || "";
+      const text = renderInlineContent(content);
+      return `${indent}\`\`\`${language}
+${indent}${text}
+${indent}\`\`\``;
+    }
+    case "image": {
+      const url = props.url || "";
+      const caption = props.caption || "";
+      return `${indent}![${caption}](${url})`;
+    }
+    case "table":
+      return renderTable(content, indent);
+    case "divider":
+      return `${indent}---`;
+    default: {
+      const text = renderInlineContent(content);
+      if (!text)
+        return null;
+      return `${indent}${text}`;
+    }
+  }
+}
+function renderInlineContent(content) {
+  if (!content)
+    return "";
+  if (Array.isArray(content)) {
+    return content.map(renderInlineItem).join("");
+  }
+  return "";
+}
+function renderInlineItem(item) {
+  if (!item || typeof item !== "object")
+    return "";
+  const i = item;
+  const type = i.type;
+  if (type === "text") {
+    const text = i.text || "";
+    return applyStyles(text, i.styles);
+  }
+  if (type === "link") {
+    const href = i.href || "";
+    const linkContent = i.content;
+    const text = Array.isArray(linkContent) ? linkContent.map(renderInlineItem).join("") : "";
+    return `[${text}](${href})`;
+  }
+  return "";
+}
+function applyStyles(text, styles) {
+  if (!text)
+    return text;
+  if (!styles || typeof styles !== "object")
+    return text;
+  const s = styles;
+  let result = text;
+  if (s.code === true) {
+    result = `\`${result}\``;
+  }
+  if (s.bold === true && s.italic === true) {
+    result = `***${result}***`;
+  } else if (s.bold === true) {
+    result = `**${result}**`;
+  } else if (s.italic === true) {
+    result = `*${result}*`;
+  }
+  if (s.strike === true) {
+    result = `~~${result}~~`;
+  }
+  return result;
+}
+function renderTable(content, indent) {
+  if (!content || typeof content !== "object")
+    return null;
+  const tableContent = content;
+  const rows = tableContent.rows;
+  if (!Array.isArray(rows) || rows.length === 0)
+    return null;
+  const lines = [];
+  for (let rowIndex = 0;rowIndex < rows.length; rowIndex++) {
+    const row = rows[rowIndex];
+    const cells = row?.cells;
+    if (!Array.isArray(cells))
+      continue;
+    const cellTexts = cells.map((cell) => {
+      if (Array.isArray(cell)) {
+        return cell.map(renderInlineItem).join("");
+      }
+      return "";
+    });
+    lines.push(`${indent}| ${cellTexts.join(" | ")} |`);
+    if (rowIndex === 0) {
+      const separator = cellTexts.map(() => "---").join(" | ");
+      lines.push(`${indent}| ${separator} |`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function extractPlainText(obj) {
+  if (typeof obj === "string")
+    return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(extractPlainText).filter(Boolean).join(" ");
+  }
+  if (obj && typeof obj === "object") {
+    const record = obj;
+    if (typeof record.text === "string")
+      return record.text;
+    const parts = [];
+    for (const value of Object.values(record)) {
+      const text = extractPlainText(value);
+      if (text)
+        parts.push(text);
+    }
+    return parts.join(" ");
+  }
+  return "";
+}
+// ../../packages/shared/src/schemas/ai.ts
 import { z } from "zod";
-var audienceSchema = z.object({
-  id: z.string().uuid(),
+var TASK_TYPES = ["complex", "generation", "fast"];
+var taskTypeSchema = z.enum(TASK_TYPES);
+var AI_MODEL_NAMES = ["sonnet", "haiku", "opus"];
+var aiModelNameSchema = z.enum(AI_MODEL_NAMES);
+var aiCallLogSchema = z.object({
+  id: z.string(),
   organizationId: z.string(),
-  name: z.string(),
-  description: z.string().nullable(),
-  order: z.number().int(),
-  createdAt: z.string(),
-  updatedAt: z.string().nullable()
+  userId: z.string(),
+  requestId: z.string().nullish(),
+  feature: z.string(),
+  model: z.string(),
+  provider: z.string(),
+  taskType: z.string().nullish(),
+  inputTokens: z.number().nullable(),
+  outputTokens: z.number().nullable(),
+  costCents: z.number().nullable(),
+  durationMs: z.number().nullable(),
+  stopReason: z.string().nullable(),
+  error: z.string().nullable(),
+  errorType: z.string().nullable(),
+  reason: z.string().nullable(),
+  correlationId: z.string().nullable(),
+  iteration: z.number().nullable(),
+  metadata: z.record(z.unknown()).nullable(),
+  createdAt: z.string()
+});
+// ../../packages/shared/src/schemas/audience.ts
+import { z as z2 } from "zod";
+var audienceSchema = z2.object({
+  id: z2.string().uuid(),
+  organizationId: z2.string(),
+  name: z2.string(),
+  description: z2.string().nullable(),
+  order: z2.number().int(),
+  createdAt: z2.string(),
+  updatedAt: z2.string().nullable()
 });
-var createAudienceSchema = z.object({
-  name: z.string().min(1),
-  description: z.string().nullable().optional()
+var createAudienceSchema = z2.object({
+  name: z2.string().min(1),
+  description: z2.string().nullable().optional()
 });
-var updateAudienceSchema = z.object({
-  name: z.string().min(1).optional(),
-  description: z.string().nullable().optional(),
-  order: z.number().int().optional()
+var updateAudienceSchema = z2.object({
+  name: z2.string().min(1).optional(),
+  description: z2.string().nullable().optional(),
+  order: z2.number().int().optional()
 });
-var audienceListSchema = z.array(audienceSchema);
+var audienceListSchema = z2.array(audienceSchema);
 // ../../packages/shared/src/schemas/constants.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var HORIZONS = [
   "inbox",
   "now",
@@ -54,7 +307,7 @@ var HORIZONS = [
   "done",
   "cancelled"
 ];
-var horizonSchema = z2.enum(HORIZONS);
+var horizonSchema = z3.enum(HORIZONS);
 var ROADMAP_STATUSES = [
   "not_started",
   "planning",
@@ -64,17 +317,17 @@ var ROADMAP_STATUSES = [
   "done",
   "cancelled"
 ];
-var roadmapStatusSchema = z2.enum(ROADMAP_STATUSES);
+var roadmapStatusSchema = z3.enum(ROADMAP_STATUSES);
 var EFFORT_SIZES = ["xs", "s", "m", "l", "xl"];
-var effortSchema = z2.enum(EFFORT_SIZES);
+var effortSchema = z3.enum(EFFORT_SIZES);
 var DATE_GRANULARITIES = ["day", "month", "quarter", "half-year", "year"];
-var dateGranularitySchema = z2.enum(DATE_GRANULARITIES);
+var dateGranularitySchema = z3.enum(DATE_GRANULARITIES);
 var PRD_STATUSES = ["draft", "completed"];
-var prdStatusSchema = z2.enum(PRD_STATUSES);
+var prdStatusSchema = z3.enum(PRD_STATUSES);
 var IDEA_STATUSES = ["new", "under-review", "planned", "declined", "done"];
-var ideaStatusSchema = z2.enum(IDEA_STATUSES);
+var ideaStatusSchema = z3.enum(IDEA_STATUSES);
 var FEATURE_TYPES = ["area", "feature"];
-var featureTypeSchema = z2.enum(FEATURE_TYPES);
+var featureTypeSchema = z3.enum(FEATURE_TYPES);
 var PRODUCT_TYPES = [
   "brand",
   "product",
@@ -83,439 +336,439 @@ var PRODUCT_TYPES = [
   "landing_page",
   "service"
 ];
-var productTypeSchema = z2.enum(PRODUCT_TYPES);
+var productTypeSchema = z3.enum(PRODUCT_TYPES);
 var AUDIENCE_TYPES = ["stakeholder", "user_persona"];
-var audienceTypeSchema = z2.enum(AUDIENCE_TYPES);
+var audienceTypeSchema = z3.enum(AUDIENCE_TYPES);
 var BRAINSTORM_MEDIA_TYPES = ["image", "video"];
-var brainstormMediaTypeSchema = z2.enum(BRAINSTORM_MEDIA_TYPES);
+var brainstormMediaTypeSchema = z3.enum(BRAINSTORM_MEDIA_TYPES);
 // ../../packages/shared/src/schemas/context.ts
-import { z as z3 } from "zod";
-var domainContextSchema = z3.object({
-  definitions: z3.record(z3.string(), z3.string()),
-  schemas: z3.record(z3.string(), z3.array(z3.string()))
+import { z as z4 } from "zod";
+var domainContextSchema = z4.object({
+  definitions: z4.record(z4.string(), z4.string()),
+  schemas: z4.record(z4.string(), z4.array(z4.string()))
 });
 // ../../packages/shared/src/schemas/export.ts
-import { z as z4 } from "zod";
-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(),
-  roadmapItemId: z4.string().uuid(),
+import { z as z5 } from "zod";
+var localEntityTypeSchema = z5.enum(["roadmap", "prd", "epic", "story", "design"]);
+var externalSystemSchema = z5.enum(["linear", "notion", "jira", "github"]);
+var exportSchema = z5.object({
+  id: z5.string().uuid(),
+  roadmapItemId: z5.string().uuid(),
   localEntityType: localEntityTypeSchema,
-  localEntityId: z4.string().uuid(),
+  localEntityId: z5.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()
+  externalObjectType: z5.string(),
+  externalId: z5.string(),
+  externalUrl: z5.string().nullable(),
+  metadata: z5.record(z5.unknown()).nullable(),
+  createdAt: z5.string(),
+  updatedAt: z5.string()
 });
-var createExportInputSchema = z4.object({
-  roadmapId: z4.string().uuid(),
+var createExportInputSchema = z5.object({
+  roadmapId: z5.string().uuid(),
   localEntityType: localEntityTypeSchema,
-  localEntityId: z4.string().uuid(),
+  localEntityId: z5.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()
+  externalObjectType: z5.string().min(1),
+  externalId: z5.string().min(1),
+  externalUrl: z5.string().url().optional(),
+  metadata: z5.record(z5.unknown()).optional()
 });
-var updateExportInputSchema = z4.object({
-  externalUrl: z4.string().url().nullable().optional(),
-  metadata: z4.record(z4.unknown()).optional()
+var updateExportInputSchema = z5.object({
+  externalUrl: z5.string().url().nullable().optional(),
+  metadata: z5.record(z5.unknown()).optional()
 });
-var searchExportsInputSchema = z4.object({
-  roadmapId: z4.string().uuid().optional(),
+var searchExportsInputSchema = z5.object({
+  roadmapId: z5.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()
+  localEntityId: z5.string().uuid().optional(),
+  limit: z5.number().int().min(1).max(100).optional(),
+  offset: z5.number().int().min(0).optional()
 });
 // ../../packages/shared/src/schemas/feature.ts
-import { z as z5 } from "zod";
-var featureOutcomeSchema = z5.object({
-  id: z5.string().uuid(),
-  description: z5.string(),
-  order: z5.number().int(),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
+import { z as z6 } from "zod";
+var featureOutcomeSchema = z6.object({
+  id: z6.string().uuid(),
+  description: z6.string(),
+  order: z6.number().int(),
+  createdAt: z6.string(),
+  updatedAt: z6.string()
 });
-var featureSchema = z5.object({
-  id: z5.string().uuid(),
-  organizationId: z5.string(),
+var featureSchema = z6.object({
+  id: z6.string().uuid(),
+  organizationId: z6.string(),
   type: featureTypeSchema,
-  name: z5.string(),
-  description: z5.string().nullable(),
-  parentId: z5.string().uuid().nullable(),
-  order: z5.number().int(),
-  isExpanded: z5.boolean(),
-  deletedAt: z5.string().nullable(),
-  createdAt: z5.string(),
-  createdBy: z5.string()
+  name: z6.string(),
+  description: z6.string().nullable(),
+  parentId: z6.string().uuid().nullable(),
+  order: z6.number().int(),
+  isExpanded: z6.boolean(),
+  deletedAt: z6.string().nullable(),
+  createdAt: z6.string(),
+  createdBy: z6.string()
 });
-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()
+var roadmapLinkSchema = z6.object({
+  id: z6.string().uuid(),
+  roadmapId: z6.string().uuid(),
+  roadmap: z6.object({
+    id: z6.string().uuid(),
+    title: z6.string(),
+    status: z6.string(),
+    horizon: z6.string()
   }),
-  createdAt: z5.string()
+  createdAt: z6.string()
 });
 var featureWithRelationsSchema = featureSchema.extend({
-  outcomes: z5.array(featureOutcomeSchema),
-  roadmapLinks: z5.array(roadmapLinkSchema),
-  children: z5.array(featureSchema).optional()
+  outcomes: z6.array(featureOutcomeSchema),
+  roadmapLinks: z6.array(roadmapLinkSchema),
+  children: z6.array(featureSchema).optional()
 });
-var createFeatureSchema = z5.object({
-  name: z5.string().min(1),
-  description: z5.string().nullable().optional(),
+var createFeatureSchema = z6.object({
+  name: z6.string().min(1),
+  description: z6.string().nullable().optional(),
   type: featureTypeSchema.optional(),
-  parentId: z5.string().uuid().nullable().optional()
+  parentId: z6.string().uuid().nullable().optional()
 });
-var updateFeatureSchema = z5.object({
-  name: z5.string().min(1).optional(),
-  description: z5.string().nullable().optional(),
+var updateFeatureSchema = z6.object({
+  name: z6.string().min(1).optional(),
+  description: z6.string().nullable().optional(),
   type: featureTypeSchema.optional(),
-  parentId: z5.string().uuid().nullable().optional(),
-  order: z5.number().int().optional()
+  parentId: z6.string().uuid().nullable().optional(),
+  order: z6.number().int().optional()
 });
-var saveFeatureOutcomesSchema = z5.object({
-  outcomes: z5.array(z5.object({
-    id: z5.string().uuid().optional(),
-    description: z5.string()
+var saveFeatureOutcomesSchema = z6.object({
+  outcomes: z6.array(z6.object({
+    id: z6.string().uuid().optional(),
+    description: z6.string()
   }))
 });
-var featureListSchema = z5.array(featureSchema);
+var featureListSchema = z6.array(featureSchema);
 // ../../packages/shared/src/schemas/idea.ts
-import { z as z6 } from "zod";
-var ideaSchema = z6.object({
-  id: z6.string().uuid(),
-  organizationId: 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(),
-  createdAt: z6.string(),
-  createdBy: z6.string()
-});
-var createIdeaSchema = z6.object({
-  title: z6.string().min(1),
-  description: z6.string().nullable().optional(),
-  status: ideaStatusSchema.optional(),
-  effort: effortSchema.nullable().optional(),
-  source: z6.string().nullable().optional()
-});
-var updateIdeaSchema = z6.object({
-  title: z6.string().min(1).optional(),
-  description: z6.string().nullable().optional(),
-  status: ideaStatusSchema.optional(),
-  effort: effortSchema.nullable().optional(),
-  source: z6.string().nullable().optional(),
-  order: z6.number().int().optional()
-});
-var ideaListSchema = z6.array(ideaSchema);
-// ../../packages/shared/src/schemas/presentation.ts
 import { z as z7 } from "zod";
-var presentationSchema = z7.object({
+var ideaSchema = z7.object({
   id: z7.string().uuid(),
   organizationId: z7.string(),
   title: z7.string(),
   description: z7.string().nullable(),
+  status: ideaStatusSchema,
+  source: z7.string().nullable(),
+  submittedBy: z7.string().nullable(),
+  value: effortSchema.nullable(),
+  effort: effortSchema.nullable(),
   order: z7.number().int(),
   createdAt: z7.string(),
-  createdBy: z7.string(),
-  updatedAt: z7.string().nullable()
+  createdBy: z7.string()
 });
-var createPresentationSchema = z7.object({
+var createIdeaSchema = z7.object({
   title: z7.string().min(1),
-  description: z7.string().nullable().optional()
+  description: z7.string().nullable().optional(),
+  status: ideaStatusSchema.optional(),
+  effort: effortSchema.nullable().optional(),
+  source: z7.string().nullable().optional()
 });
-var updatePresentationSchema = z7.object({
+var updateIdeaSchema = z7.object({
   title: z7.string().min(1).optional(),
-  description: z7.string().nullable().optional()
+  description: z7.string().nullable().optional(),
+  status: ideaStatusSchema.optional(),
+  effort: effortSchema.nullable().optional(),
+  source: z7.string().nullable().optional(),
+  order: z7.number().int().optional()
 });
-var presentationListSchema = z7.array(presentationSchema);
-// ../../packages/shared/src/schemas/product.ts
+var ideaListSchema = z7.array(ideaSchema);
+// ../../packages/shared/src/schemas/presentation.ts
 import { z as z8 } from "zod";
-var productSchema = z8.object({
+var presentationSchema = z8.object({
   id: z8.string().uuid(),
   organizationId: z8.string(),
-  parentId: z8.string().uuid().nullable(),
-  type: productTypeSchema,
-  name: z8.string(),
+  title: z8.string(),
+  description: z8.string().nullable(),
   order: z8.number().int(),
-  isExpanded: z8.boolean(),
-  deletedAt: z8.string().nullable(),
-  createdAt: z8.string()
+  createdAt: z8.string(),
+  createdBy: z8.string(),
+  updatedAt: z8.string().nullable()
+});
+var createPresentationSchema = z8.object({
+  title: z8.string().min(1),
+  description: z8.string().nullable().optional()
+});
+var updatePresentationSchema = z8.object({
+  title: z8.string().min(1).optional(),
+  description: z8.string().nullable().optional()
+});
+var presentationListSchema = z8.array(presentationSchema);
+// ../../packages/shared/src/schemas/product.ts
+import { z as z9 } from "zod";
+var productSchema = z9.object({
+  id: z9.string().uuid(),
+  organizationId: z9.string(),
+  parentId: z9.string().uuid().nullable(),
+  type: productTypeSchema,
+  name: z9.string(),
+  order: z9.number().int(),
+  isExpanded: z9.boolean(),
+  deletedAt: z9.string().nullable(),
+  createdAt: z9.string()
 });
-var createProductSchema = z8.object({
-  name: z8.string().min(1),
-  description: z8.string().nullable().optional(),
+var createProductSchema = z9.object({
+  name: z9.string().min(1),
+  description: z9.string().nullable().optional(),
   type: productTypeSchema,
-  parentId: z8.string().uuid().nullable().optional()
+  parentId: z9.string().uuid().nullable().optional()
 });
-var updateProductSchema = z8.object({
-  name: z8.string().min(1).optional(),
-  description: z8.string().nullable().optional(),
+var updateProductSchema = z9.object({
+  name: z9.string().min(1).optional(),
+  description: z9.string().nullable().optional(),
   type: productTypeSchema.optional(),
-  parentId: z8.string().uuid().nullable().optional(),
-  order: z8.number().int().optional()
+  parentId: z9.string().uuid().nullable().optional(),
+  order: z9.number().int().optional()
 });
-var productListSchema = z8.array(productSchema);
+var productListSchema = z9.array(productSchema);
 // ../../packages/shared/src/schemas/roadmap.ts
-import { z as z10 } from "zod";
+import { z as z11 } 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()
+import { z as z10 } from "zod";
+var epicSchema = z10.object({
+  id: z10.string().uuid(),
+  roadmapItemId: z10.string().uuid(),
+  organizationId: z10.string(),
+  title: z10.string(),
+  description: z10.string().nullable(),
+  order: z10.number().int(),
+  createdAt: z10.string(),
+  updatedAt: z10.string(),
+  deletedAt: z10.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 storySchema = z10.object({
+  id: z10.string().uuid(),
+  roadmapItemId: z10.string().uuid(),
+  epicId: z10.string().uuid().nullable(),
+  organizationId: z10.string(),
+  title: z10.string(),
+  description: z10.string().nullable(),
+  order: z10.number().int(),
+  createdAt: z10.string(),
+  updatedAt: z10.string(),
+  deletedAt: z10.string().nullable()
 });
 var epicWithStoriesSchema = epicSchema.extend({
-  stories: z9.array(storySchema)
+  stories: z10.array(storySchema)
 });
-var createEpicSchema = z9.object({
-  title: z9.string().min(1),
-  description: z9.string().nullable().optional()
+var createEpicSchema = z10.object({
+  title: z10.string().min(1),
+  description: z10.string().nullable().optional()
 });
-var createStorySchema = z9.object({
-  title: z9.string().min(1),
-  description: z9.string().nullable().optional()
+var createStorySchema = z10.object({
+  title: z10.string().min(1),
+  description: z10.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()
+var saveStoriesInputSchema = z10.object({
+  epics: z10.array(z10.object({
+    title: z10.string().min(1),
+    description: z10.string().nullable().optional(),
+    stories: z10.array(z10.object({
+      title: z10.string().min(1),
+      description: z10.string().nullable().optional()
     })).optional().default([])
   })).optional().default([]),
-  stories: z9.array(z9.object({
-    title: z9.string().min(1),
-    description: z9.string().nullable().optional()
+  stories: z10.array(z10.object({
+    title: z10.string().min(1),
+    description: z10.string().nullable().optional()
   })).optional().default([])
 });
-var updateEpicSchema = z9.object({
-  title: z9.string().min(1).optional(),
-  description: z9.string().nullable().optional()
+var updateEpicSchema = z10.object({
+  title: z10.string().min(1).optional(),
+  description: z10.string().nullable().optional()
 });
-var updateStorySchema = z9.object({
-  title: z9.string().min(1).optional(),
-  description: z9.string().nullable().optional(),
-  epicId: z9.string().uuid().nullable().optional()
+var updateStorySchema = z10.object({
+  title: z10.string().min(1).optional(),
+  description: z10.string().nullable().optional(),
+  epicId: z10.string().uuid().nullable().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()
+var reorderStoriesSchema = z10.object({
+  epicOrder: z10.array(z10.string().uuid()).optional(),
+  storyOrder: z10.record(z10.string(), z10.array(z10.string().uuid())).optional(),
+  standaloneOrder: z10.array(z10.string().uuid()).optional()
 });
 
 // ../../packages/shared/src/schemas/roadmap.ts
-var flexibleDateSchema = z10.object({
-  value: z10.string(),
+var flexibleDateSchema = z11.object({
+  value: z11.string(),
   granularity: dateGranularitySchema
 });
-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 labelSchema = z11.object({
+  id: z11.string().uuid(),
+  type: z11.enum(["category", "location", "label"]),
+  name: z11.string(),
+  color: z11.string().nullable(),
+  address: z11.string().nullable()
 });
-var appSchema = z10.object({
-  id: z10.string().uuid(),
-  name: z10.string()
+var appSchema = z11.object({
+  id: z11.string().uuid(),
+  name: z11.string()
 });
-var roadmapSchema = z10.object({
-  id: z10.string().uuid(),
-  organizationId: z10.string(),
-  title: z10.string(),
+var roadmapSchema = z11.object({
+  id: z11.string().uuid(),
+  organizationId: z11.string(),
+  title: z11.string(),
   horizon: horizonSchema.nullable(),
   status: roadmapStatusSchema.nullable(),
   value: effortSchema.nullable(),
   effort: effortSchema.nullable(),
-  order: z10.number().int(),
-  estimatedSeconds: z10.number().int().nullable(),
+  order: z11.number().int(),
+  estimatedSeconds: z11.number().int().nullable(),
   date: flexibleDateSchema.nullable(),
   target: flexibleDateSchema.nullable(),
-  completedAt: z10.string().nullable(),
-  createdAt: z10.string(),
-  createdBy: z10.string(),
-  prompt: z10.string().nullable(),
-  labels: z10.array(labelSchema),
-  apps: z10.array(appSchema)
+  completedAt: z11.string().nullable(),
+  createdAt: z11.string(),
+  createdBy: z11.string(),
+  prompt: z11.string().nullable(),
+  labels: z11.array(labelSchema),
+  apps: z11.array(appSchema)
 });
-var createRoadmapSchema = z10.object({
-  title: z10.string().min(1),
+var createRoadmapSchema = z11.object({
+  title: z11.string().min(1),
   status: roadmapStatusSchema.optional(),
   horizon: horizonSchema.optional(),
   value: effortSchema.nullable().optional(),
   effort: effortSchema.nullable().optional(),
-  estimatedSeconds: z10.number().int().nullable().optional(),
+  estimatedSeconds: z11.number().int().nullable().optional(),
   date: flexibleDateSchema.nullable().optional(),
   target: flexibleDateSchema.nullable().optional(),
-  prompt: z10.string().nullable().optional(),
-  brainstormNotes: z10.string().nullable().optional()
+  prompt: z11.string().nullable().optional(),
+  brainstormNotes: z11.string().nullable().optional()
 });
-var updateRoadmapSchema = z10.object({
-  title: z10.string().min(1).optional(),
+var updateRoadmapSchema = z11.object({
+  title: z11.string().min(1).optional(),
   status: roadmapStatusSchema.optional(),
   horizon: horizonSchema.optional(),
   value: effortSchema.nullable().optional(),
   effort: effortSchema.nullable().optional(),
-  order: z10.number().int().optional(),
-  estimatedSeconds: z10.number().int().nullable().optional(),
+  order: z11.number().int().optional(),
+  estimatedSeconds: z11.number().int().nullable().optional(),
   date: flexibleDateSchema.nullable().optional(),
   target: flexibleDateSchema.nullable().optional(),
-  prompt: z10.string().nullable().optional(),
-  brainstormNotes: z10.string().nullable().optional()
+  prompt: z11.string().nullable().optional(),
+  brainstormNotes: z11.string().nullable().optional()
 });
-var prdOutcomeSchema = z10.object({
-  id: z10.string().uuid(),
-  description: z10.string(),
+var prdOutcomeSchema = z11.object({
+  id: z11.string().uuid(),
+  description: z11.string(),
   status: prdStatusSchema,
-  order: z10.number().int(),
-  completedAt: z10.string().nullable()
+  order: z11.number().int(),
+  completedAt: z11.string().nullable()
 });
-var prdSchema = z10.object({
-  id: z10.string().uuid(),
-  what: z10.string().nullable(),
-  why: z10.string().nullable(),
-  outcomes: z10.array(prdOutcomeSchema)
+var prdSchema = z11.object({
+  id: z11.string().uuid(),
+  what: z11.string().nullable(),
+  why: z11.string().nullable(),
+  outcomes: z11.array(prdOutcomeSchema)
 });
-var savePrdInputSchema = z10.object({
-  what: z10.string().nullable(),
-  why: z10.string().nullable(),
+var savePrdInputSchema = z11.object({
+  what: z11.string().nullable(),
+  why: z11.string().nullable(),
   status: prdStatusSchema,
-  outcomes: z10.array(z10.object({
-    id: z10.string().uuid().optional(),
-    description: z10.string(),
-    order: z10.number().int().min(0)
+  outcomes: z11.array(z11.object({
+    id: z11.string().uuid().optional(),
+    description: z11.string(),
+    order: z11.number().int().min(0)
   }))
 });
-var brainstormMediaSchema = z10.object({
-  id: z10.string().uuid(),
-  mediaUrl: z10.string(),
+var brainstormMediaSchema = z11.object({
+  id: z11.string().uuid(),
+  mediaUrl: z11.string(),
   mediaType: brainstormMediaTypeSchema,
-  description: z10.string().nullable(),
-  order: z10.number().int(),
-  createdAt: z10.string()
+  description: z11.string().nullable(),
+  order: z11.number().int(),
+  createdAt: z11.string()
 });
-var wireframeSchema = z10.object({
-  id: z10.string().uuid(),
-  description: z10.string().nullable(),
-  imageUrl: z10.string().nullable(),
-  order: z10.number().int()
+var wireframeSchema = z11.object({
+  id: z11.string().uuid(),
+  description: z11.string().nullable(),
+  imageUrl: z11.string().nullable(),
+  order: z11.number().int()
 });
-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 prototypeSchema = z11.object({
+  id: z11.string().uuid(),
+  publicUrl: z11.string().url(),
+  expiresAt: z11.string().datetime(),
+  fileCount: z11.number().int().positive(),
+  entryPoint: z11.string(),
+  createdAt: z11.string().datetime()
 });
-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"])
+var featureLinkSchema = z11.object({
+  id: z11.string().uuid(),
+  featureId: z11.string().uuid(),
+  feature: z11.object({
+    id: z11.string().uuid(),
+    name: z11.string(),
+    type: z11.enum(["area", "feature"])
   }),
-  createdAt: z10.string()
+  createdAt: z11.string()
 });
-var phaseDesignSchema = z10.object({
-  id: z10.string().uuid(),
-  description: z10.string().nullable()
+var phaseDesignSchema = z11.object({
+  id: z11.string().uuid(),
+  description: z11.string().nullable()
 });
-var phasePlanSchema = z10.object({
-  id: z10.string().uuid(),
-  description: z10.string().nullable()
+var phasePlanSchema = z11.object({
+  id: z11.string().uuid(),
+  description: z11.string().nullable()
 });
-var phaseBuildSchema = z10.object({
-  id: z10.string().uuid(),
-  description: z10.string().nullable(),
-  prompt: z10.string().nullable()
+var phaseBuildSchema = z11.object({
+  id: z11.string().uuid(),
+  description: z11.string().nullable(),
+  prompt: z11.string().nullable()
 });
-var phaseReleaseSchema = z10.object({
-  id: z10.string().uuid(),
-  description: z10.string().nullable()
+var phaseReleaseSchema = z11.object({
+  id: z11.string().uuid(),
+  description: z11.string().nullable()
 });
 var roadmapDetailSchema = roadmapSchema.extend({
   prd: prdSchema.nullable(),
-  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),
+  wireframes: z11.array(wireframeSchema),
+  prototypes: z11.array(prototypeSchema),
+  brainstormMedia: z11.array(brainstormMediaSchema),
+  brainstormNotes: z11.string().nullable(),
+  featureLinks: z11.array(featureLinkSchema),
+  epics: z11.array(epicWithStoriesSchema),
+  stories: z11.array(storySchema),
   design: phaseDesignSchema.nullable(),
   plan: phasePlanSchema.nullable(),
   build: phaseBuildSchema.nullable(),
   release: phaseReleaseSchema.nullable(),
-  exports: z10.array(exportSchema)
+  exports: z11.array(exportSchema)
 });
-var roadmapListSchema = z10.array(roadmapSchema);
+var roadmapListSchema = z11.array(roadmapSchema);
 // ../../packages/shared/src/schemas/scenario.ts
-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()
+import { z as z12 } from "zod";
+var scenarioSchema = z12.object({
+  id: z12.string().uuid(),
+  title: z12.string().min(1),
+  given: z12.string().nullable(),
+  when: z12.string().nullable(),
+  then: z12.string().nullable(),
+  order: z12.number().int(),
+  createdAt: z12.string().datetime(),
+  updatedAt: z12.string().datetime()
 });
-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 createScenarioSchema = z12.object({
+  title: z12.string().min(1),
+  given: z12.string().nullable().optional(),
+  when: z12.string().nullable().optional(),
+  then: z12.string().nullable().optional(),
+  roadmapId: z12.string().uuid()
 });
-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 updateScenarioSchema = z12.object({
+  title: z12.string().min(1).optional(),
+  given: z12.string().nullable().optional(),
+  when: z12.string().nullable().optional(),
+  then: z12.string().nullable().optional(),
+  order: z12.number().int().optional()
 });
-var scenarioListSchema = z11.array(scenarioSchema);
+var scenarioListSchema = z12.array(scenarioSchema);
 // ../../packages/shared/src/schemas/slide.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var SLIDE_TYPES = [
   "title",
   "section_header",
@@ -530,151 +783,596 @@ var SLIDE_TYPES = [
   "mermaid",
   "paragraph"
 ];
-var slideTypeSchema = z12.enum(SLIDE_TYPES);
-var titleContentSchema = z12.object({
-  title: z12.string(),
-  subtitle: z12.string().optional()
+var slideTypeSchema = z13.enum(SLIDE_TYPES);
+var titleContentSchema = z13.object({
+  title: z13.string(),
+  subtitle: z13.string().optional()
 });
-var sectionHeaderContentSchema = z12.object({
-  title: z12.string(),
-  subtitle: z12.string().optional()
+var sectionHeaderContentSchema = z13.object({
+  title: z13.string(),
+  subtitle: z13.string().optional()
 });
-var bulletsContentSchema = z12.object({
-  title: z12.string().optional(),
-  items: z12.array(z12.string()).default([])
+var bulletsContentSchema = z13.object({
+  title: z13.string().optional(),
+  items: z13.array(z13.string()).default([])
 });
-var twoColumnContentSchema = z12.object({
-  title: z12.string().optional(),
-  left: z12.string().default(""),
-  right: z12.string().default("")
+var twoColumnContentSchema = z13.object({
+  title: z13.string().optional(),
+  left: z13.string().default(""),
+  right: z13.string().default("")
 });
-var comparisonContentSchema = z12.object({
-  leftLabel: z12.string().default(""),
-  leftContent: z12.string().default(""),
-  rightLabel: z12.string().default(""),
-  rightContent: z12.string().default("")
+var comparisonContentSchema = z13.object({
+  leftLabel: z13.string().default(""),
+  leftContent: z13.string().default(""),
+  rightLabel: z13.string().default(""),
+  rightContent: z13.string().default("")
 });
-var timelineStepSchema = z12.object({
-  title: z12.string(),
-  description: z12.string().optional()
+var timelineStepSchema = z13.object({
+  title: z13.string(),
+  description: z13.string().optional()
 });
-var timelineContentSchema = z12.object({
-  title: z12.string().optional(),
-  steps: z12.array(timelineStepSchema).default([])
+var timelineContentSchema = z13.object({
+  title: z13.string().optional(),
+  steps: z13.array(timelineStepSchema).default([])
 });
-var imageContentSchema = z12.object({
-  title: z12.string().optional(),
-  imageUrl: z12.string().optional(),
-  caption: z12.string().optional()
+var imageContentSchema = z13.object({
+  title: z13.string().optional(),
+  imageUrl: z13.string().optional(),
+  caption: z13.string().optional()
 });
-var quoteContentSchema = z12.object({
-  quote: z12.string().default(""),
-  attribution: z12.string().optional()
+var quoteContentSchema = z13.object({
+  quote: z13.string().default(""),
+  attribution: z13.string().optional()
 });
-var codeContentSchema = z12.object({
-  title: z12.string().optional(),
-  code: z12.string().default(""),
-  language: z12.string().optional(),
-  highlightLines: z12.array(z12.number()).optional()
+var codeContentSchema = z13.object({
+  title: z13.string().optional(),
+  code: z13.string().default(""),
+  language: z13.string().optional(),
+  highlightLines: z13.array(z13.number()).optional()
 });
-var thankYouContentSchema = z12.object({
-  title: z12.string().default("Thank You"),
-  subtitle: z12.string().optional(),
-  ctaText: z12.string().optional(),
-  ctaUrl: z12.string().optional()
+var thankYouContentSchema = z13.object({
+  title: z13.string().default("Thank You"),
+  subtitle: z13.string().optional(),
+  ctaText: z13.string().optional(),
+  ctaUrl: z13.string().optional()
 });
-var mermaidContentSchema = z12.object({
-  title: z12.string().optional(),
-  code: z12.string().default("")
+var mermaidContentSchema = z13.object({
+  title: z13.string().optional(),
+  code: z13.string().default("")
 });
-var paragraphContentSchema = z12.object({
-  title: z12.string().optional(),
-  body: z12.string().default("")
+var paragraphContentSchema = z13.object({
+  title: z13.string().optional(),
+  body: z13.string().default("")
 });
-var typedSlideContentSchema = z12.discriminatedUnion("type", [
-  z12.object({ type: z12.literal("title"), ...titleContentSchema.shape }),
-  z12.object({ type: z12.literal("section_header"), ...sectionHeaderContentSchema.shape }),
-  z12.object({ type: z12.literal("bullets"), ...bulletsContentSchema.shape }),
-  z12.object({ type: z12.literal("two_column"), ...twoColumnContentSchema.shape }),
-  z12.object({ type: z12.literal("comparison"), ...comparisonContentSchema.shape }),
-  z12.object({ type: z12.literal("timeline"), ...timelineContentSchema.shape }),
-  z12.object({ type: z12.literal("image"), ...imageContentSchema.shape }),
-  z12.object({ type: z12.literal("quote"), ...quoteContentSchema.shape }),
-  z12.object({ type: z12.literal("code"), ...codeContentSchema.shape }),
-  z12.object({ type: z12.literal("thank_you"), ...thankYouContentSchema.shape }),
-  z12.object({ type: z12.literal("mermaid"), ...mermaidContentSchema.shape }),
-  z12.object({ type: z12.literal("paragraph"), ...paragraphContentSchema.shape })
+var typedSlideContentSchema = z13.discriminatedUnion("type", [
+  z13.object({ type: z13.literal("title"), ...titleContentSchema.shape }),
+  z13.object({ type: z13.literal("section_header"), ...sectionHeaderContentSchema.shape }),
+  z13.object({ type: z13.literal("bullets"), ...bulletsContentSchema.shape }),
+  z13.object({ type: z13.literal("two_column"), ...twoColumnContentSchema.shape }),
+  z13.object({ type: z13.literal("comparison"), ...comparisonContentSchema.shape }),
+  z13.object({ type: z13.literal("timeline"), ...timelineContentSchema.shape }),
+  z13.object({ type: z13.literal("image"), ...imageContentSchema.shape }),
+  z13.object({ type: z13.literal("quote"), ...quoteContentSchema.shape }),
+  z13.object({ type: z13.literal("code"), ...codeContentSchema.shape }),
+  z13.object({ type: z13.literal("thank_you"), ...thankYouContentSchema.shape }),
+  z13.object({ type: z13.literal("mermaid"), ...mermaidContentSchema.shape }),
+  z13.object({ type: z13.literal("paragraph"), ...paragraphContentSchema.shape })
 ]);
-var slideContentSchema = z12.object({
-  body: z12.string().optional()
+var slideContentSchema = z13.object({
+  body: z13.string().optional()
 });
-var slideSchema = z12.object({
-  id: z12.string().uuid(),
-  variantId: z12.string().uuid(),
+var slideSchema = z13.object({
+  id: z13.string().uuid(),
+  variantId: z13.string().uuid(),
   slideType: slideTypeSchema,
-  title: z12.string(),
-  content: z12.unknown().nullable(),
-  speakerNotes: z12.string().nullable(),
-  order: z12.number().int(),
-  createdAt: z12.string(),
-  createdBy: z12.string(),
-  updatedAt: z12.string().nullable()
+  title: z13.string(),
+  content: z13.unknown().nullable(),
+  speakerNotes: z13.string().nullable(),
+  order: z13.number().int(),
+  createdAt: z13.string(),
+  createdBy: z13.string(),
+  updatedAt: z13.string().nullable()
 });
-var createSlideSchema = z12.object({
+var createSlideSchema = z13.object({
   slideType: slideTypeSchema,
-  content: z12.unknown().optional(),
-  speakerNotes: z12.string().nullable().optional()
+  content: z13.unknown().optional(),
+  speakerNotes: z13.string().nullable().optional()
 });
-var updateSlideSchema = z12.object({
-  content: z12.unknown().optional(),
-  speakerNotes: z12.string().nullable().optional()
+var updateSlideSchema = z13.object({
+  content: z13.unknown().optional(),
+  speakerNotes: z13.string().nullable().optional()
 });
-var slideListSchema = z12.array(slideSchema);
+var slideListSchema = z13.array(slideSchema);
 // ../../packages/shared/src/schemas/status-update.ts
-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 = 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 = z13.array(statusUpdateSchema);
-// ../../packages/shared/src/schemas/variant.ts
 import { z as z14 } from "zod";
-var variantSchema = z14.object({
+var statusUpdateItemSchema = 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(),
+  roadmapItemId: z14.string().uuid(),
+  titleAtSnapshot: z14.string(),
+  statusAtSnapshot: z14.string(),
+  designWalkthroughUrl: z14.string().nullable(),
+  releaseWalkthroughUrl: z14.string().nullable()
+});
+var statusUpdateSchema = z14.object({
+  id: z14.string().uuid(),
+  title: z14.string().nullable(),
+  startDate: z14.string(),
+  endDate: z14.string(),
+  content: z14.string(),
   createdAt: z14.string(),
-  createdBy: z14.string(),
-  updatedAt: z14.string().nullable()
+  items: z14.array(statusUpdateItemSchema).optional()
+});
+var statusUpdateListSchema = z14.array(statusUpdateSchema);
+// ../../packages/shared/src/schemas/tool-inputs.ts
+import { z as z15 } from "zod";
+var paginationFields = {
+  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)")
+};
+var idField = (entity) => z15.string().describe(`The UUID of the ${entity}`);
+var uuidField = (entity) => z15.string().uuid().describe(`The UUID of the ${entity}`);
+var orderItemsField = (entity) => z15.array(z15.object({
+  id: z15.string().describe(`The UUID of the ${entity}`),
+  order: z15.number().int().min(0).describe("The new order value (0-based)")
+})).describe(`Array of ${entity}s with their new order values`);
+var yyyyMmDdField = (description) => z15.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(description);
+var sizeSchema = z15.enum(["xs", "s", "m", "l", "xl"]);
+var searchRoadmapsInput = {
+  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"),
+  phase: z15.string().optional().describe("Filter by phase"),
+  phaseStep: z15.string().optional().describe("Filter by phase step"),
+  ...paginationFields
+};
+var getRoadmapInput = {
+  id: idField("roadmap item")
+};
+var createRoadmapItemInput = {
+  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")'),
+  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: dateGranularitySchema.optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
+  dateValue: z15.string().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
+  targetGranularity: dateGranularitySchema.optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
+  targetValue: z15.string().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
+};
+var updateRoadmapItemInput = {
+  id: idField("roadmap item to update"),
+  title: z15.string().optional().describe("New title"),
+  status: roadmapStatusSchema.optional().describe("New status"),
+  horizon: horizonSchema.optional().describe("New planning horizon"),
+  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: effortSchema.nullable().optional().describe("Effort estimate (xs=extra small, s=small, m=medium, l=large, xl=extra large)"),
+  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: dateGranularitySchema.nullable().optional().describe("Planned date granularity: day, month, quarter, half-year, or year"),
+  dateValue: z15.string().nullable().optional().describe('Planned date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)'),
+  targetGranularity: dateGranularitySchema.nullable().optional().describe("Deadline/target date granularity: day, month, quarter, half-year, or year"),
+  targetValue: z15.string().nullable().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
+};
+var deleteRoadmapItemInput = {
+  id: idField("roadmap item to delete")
+};
+var reorderRoadmapsInput = {
+  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")
+};
+var savePrdInput = {
+  roadmapId: idField("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")
+};
+var updateBrainstormNotesInput = {
+  roadmapId: idField("roadmap item"),
+  notes: z15.string().describe("The brainstorm notes content")
+};
+var searchFeaturesInput = {
+  query: z15.string().optional().describe("Search query to match against name"),
+  type: featureTypeSchema.optional().describe("Filter by type (feature or area)")
+};
+var getFeatureInput = {
+  id: idField("feature")
+};
+var addFeatureInput = {
+  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: 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")
+};
+var updateFeatureInput = {
+  id: idField("feature to update"),
+  name: z15.string().optional().describe("New name for the feature"),
+  type: featureTypeSchema.optional().describe('New type - "feature" or "area"'),
+  parentId: z15.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
+};
+var deleteFeatureInput = {
+  id: idField("feature to delete")
+};
+var searchIdeasInput = {
+  query: z15.string().optional().describe("Search query to match against title or description"),
+  status: ideaStatusSchema.optional().describe("Filter by status")
+};
+var getIdeaInput = {
+  id: idField("idea")
+};
+var captureIdeaInput = {
+  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")')
+};
+var updateIdeaInput = {
+  id: idField("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: sizeSchema.nullable().optional().describe("Estimated value"),
+  effort: sizeSchema.nullable().optional().describe("Estimated effort")
+};
+var deleteIdeaInput = {
+  id: idField("idea to delete")
+};
+var updateStrategyInput = {
+  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")
+};
+var createScenarioInput = {
+  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")
+};
+var updateScenarioInput = {
+  id: idField("scenario to update"),
+  title: z15.string().optional().describe("New title"),
+  description: z15.string().nullable().optional().describe("New description")
+};
+var deleteScenarioInput = {
+  id: idField("scenario to delete")
+};
+var searchProductsInput = {
+  query: z15.string().optional().describe("Search query to match against product name"),
+  type: productTypeSchema.optional().describe("Filter by product type")
+};
+var getProductInput = {
+  id: idField("product")
+};
+var createProductInput = {
+  type: productTypeSchema.describe("Type of product"),
+  name: z15.string().describe("Name of the product"),
+  parentId: z15.string().nullable().optional().describe("UUID of parent product to nest under")
+};
+var updateProductInput = {
+  id: idField("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")
+};
+var deleteProductInput = {
+  id: idField("product to delete")
+};
+var getProductDocumentationInput = {
+  productId: idField("product")
+};
+var updateProductDocumentationInput = {
+  productId: idField("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.")
+};
+var createAudienceInput = {
+  name: z15.string().describe('Name of the audience (e.g., "Product Manager", "End User")'),
+  description: z15.string().nullable().optional().describe("Description of the audience")
+};
+var updateAudienceInput = {
+  id: idField("audience to update"),
+  name: z15.string().optional().describe("New name"),
+  description: z15.string().nullable().optional().describe("New description")
+};
+var deleteAudienceInput = {
+  id: idField("audience to delete")
+};
+var getHistoryInput = {
+  startDate: yyyyMmDdField("Start date in YYYY-MM-DD format"),
+  endDate: yyyyMmDdField("End date in YYYY-MM-DD format"),
+  entityType: z15.enum([
+    "roadmap",
+    "feature",
+    "idea",
+    "prd",
+    "wireframe",
+    "product",
+    "audience",
+    "scenario"
+  ]).optional().describe("Filter to specific entity type")
+};
+var getHistorySummaryInput = {
+  startDate: yyyyMmDdField("Start date in YYYY-MM-DD format"),
+  endDate: yyyyMmDdField("End date in YYYY-MM-DD format")
+};
+var createStatusUpdateInput = {
+  startDate: yyyyMmDdField("Report period start date in YYYY-MM-DD format"),
+  endDate: yyyyMmDdField("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")
+};
+var saveStoriesInput = {
+  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: 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)")
+};
+var searchInitiativesInput = {
+  query: z15.string().optional().describe("Search query to match against title or description"),
+  horizon: horizonSchema.optional().describe("Filter by planning horizon"),
+  ...paginationFields
+};
+var getInitiativeInput = {
+  id: idField("initiative")
+};
+var createInitiativeInput = {
+  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: dateGranularitySchema.optional().describe("Target date granularity: day, month, quarter, half-year, or year"),
+  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")
+};
+var updateInitiativeInput = {
+  id: idField("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: dateGranularitySchema.nullable().optional().describe("New target date granularity (null to clear)"),
+  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)")
+};
+var deleteInitiativeInput = {
+  id: idField("initiative to delete")
+};
+var reorderInitiativesInput = {
+  items: orderItemsField("initiative")
+};
+var uploadWireframeInput = {
+  roadmapId: idField("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")
+};
+var updateWireframeInput = {
+  id: idField("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)")
+};
+var deleteWireframeInput = {
+  id: idField("wireframe to delete")
+};
+var uploadBrainstormMediaInput = {
+  roadmapId: idField("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")
+};
+var updateBrainstormMediaInput = {
+  id: idField("brainstorm media"),
+  description: z15.string().nullable().describe("New description for the media")
+};
+var deleteBrainstormMediaInput = {
+  id: idField("brainstorm media to delete")
+};
+var uploadProductDesignMediaInput = {
+  productId: idField("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")
+};
+var updateProductDesignMediaInput2 = {
+  productId: idField("product"),
+  mediaId: idField("design media"),
+  description: z15.string().nullable().describe("New description for the media")
+};
+var deleteProductDesignMediaInput = {
+  productId: idField("product"),
+  mediaId: idField("design media to delete")
+};
+var uploadDesignWalkthroughInput = {
+  roadmapId: idField("roadmap item"),
+  filePath: z15.string().describe("Absolute path to the video file on disk")
+};
+var uploadReleaseWalkthroughInput = {
+  roadmapId: idField("roadmap item"),
+  filePath: z15.string().describe("Absolute path to the video file on disk")
+};
+var publishPrototypeInput = {
+  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)")
+};
+var listPrototypesInput = {
+  roadmapId: z15.string().uuid().describe("The UUID of the roadmap item")
+};
+var createFeedbackSessionInput = {
+  prototypeId: uuidField("prototype to create a feedback session for"),
+  name: z15.string().describe('Name for this feedback session (e.g., "Round 1 Review")'),
+  expiresInDays: z15.number().int().min(1).max(90).optional().describe("Number of days until the session expires (default 7)")
+};
+var listFeedbackSessionsInput = {
+  prototypeId: uuidField("prototype")
+};
+var getFeedbackSummaryInput = {
+  prototypeId: uuidField("prototype"),
+  sessionId: uuidField("feedback session"),
+  filter: z15.enum(["all", "unresolved", "resolved"]).optional().describe("Filter comments by resolved status (default: unresolved)")
+};
+var getFeedbackDetailInput = {
+  prototypeId: uuidField("prototype"),
+  sessionId: uuidField("feedback session"),
+  commentId: z15.string().uuid().optional().describe("Optional: get detail for a single comment"),
+  filter: z15.enum(["all", "unresolved", "resolved"]).optional().describe("Filter comments by resolved status (default: all). Ignored if commentId is provided.")
+};
+var resolveFeedbackCommentInput = {
+  prototypeId: uuidField("prototype"),
+  sessionId: uuidField("feedback session"),
+  commentId: uuidField("comment to resolve/unresolve")
+};
+var searchExportsInput = {
+  roadmapId: z15.string().uuid().optional().describe("Filter by roadmap item ID"),
+  externalSystem: externalSystemSchema.optional().describe("Filter by external system"),
+  localEntityType: localEntityTypeSchema.optional().describe("Filter by local entity type"),
+  localEntityId: z15.string().uuid().optional().describe("Filter by local entity ID"),
+  ...paginationFields
+};
+var getExportInput = {
+  id: z15.string().uuid().describe("The UUID of the export record")
+};
+var createExportInput = {
+  roadmapId: z15.string().uuid().describe("The UUID of the roadmap item"),
+  localEntityType: localEntityTypeSchema.describe("Type of local entity being exported"),
+  localEntityId: z15.string().uuid().describe("The UUID of the local entity"),
+  externalSystem: externalSystemSchema.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")
+};
+var updateExportInput = {
+  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")
+};
+var deleteExportInput = {
+  id: z15.string().uuid().describe("The UUID of the export record to delete")
+};
+var getPresentationInput = {
+  id: idField("presentation")
+};
+var createPresentationInput = {
+  title: z15.string().describe("Title of the presentation"),
+  description: z15.string().nullable().optional().describe("Description of the presentation")
+};
+var updatePresentationInput = {
+  id: idField("presentation to update"),
+  title: z15.string().optional().describe("New title"),
+  description: z15.string().nullable().optional().describe("New description")
+};
+var deletePresentationInput = {
+  id: idField("presentation to delete")
+};
+var reorderPresentationsInput = {
+  items: orderItemsField("presentation")
+};
+var listVariantsInput = {
+  presentationId: idField("presentation")
+};
+var getVariantInput = {
+  presentationId: idField("presentation"),
+  variantId: idField("variant")
+};
+var createVariantInput = {
+  presentationId: idField("presentation"),
+  name: z15.string().describe("Name of the variant"),
+  audienceId: z15.string().nullable().optional().describe("The UUID of the target audience")
+};
+var updateVariantInput = {
+  presentationId: idField("presentation"),
+  variantId: idField("variant to update"),
+  name: z15.string().optional().describe("New name"),
+  audienceId: z15.string().nullable().optional().describe("New target audience UUID")
+};
+var deleteVariantInput = {
+  presentationId: idField("presentation"),
+  variantId: idField("variant to delete")
+};
+var reorderVariantsInput = {
+  presentationId: idField("presentation"),
+  items: orderItemsField("variant")
+};
+var cloneVariantInput = {
+  presentationId: idField("presentation"),
+  variantId: idField("variant to clone")
+};
+var setDefaultVariantInput = {
+  presentationId: idField("presentation"),
+  variantId: idField("variant to set as default")
+};
+var listSlidesInput = {
+  variantId: idField("variant")
+};
+var getSlideInput = {
+  variantId: idField("variant"),
+  slideId: idField("slide")
+};
+var createSlideInput = {
+  variantId: idField("variant"),
+  slideType: slideTypeSchema.default("bullets").describe("The type of slide to create"),
+  content: z15.record(z15.unknown()).optional().describe('Type-specific content object. For bullets: {title, items: ["..."]}. For title: {title, subtitle}. For two_column: {title, left, right}. For quote: {quote, attribution}. For mermaid: {title, code: "graph TD; A-->B"}. For paragraph: {title, body}. Etc.'),
+  speakerNotes: z15.string().nullable().optional().describe("Speaker notes for the slide")
+};
+var updateSlideInput = {
+  variantId: idField("variant"),
+  slideId: idField("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")
+};
+var deleteSlideInput = {
+  variantId: idField("variant"),
+  slideId: idField("slide to delete")
+};
+var reorderSlidesInput = {
+  variantId: idField("variant"),
+  items: orderItemsField("slide")
+};
+var uploadSlideImageInput = {
+  variantId: idField("variant"),
+  slideId: idField("slide to add the image to"),
+  filePath: z15.string().describe("Absolute path to the image file on disk")
+};
+// ../../packages/shared/src/schemas/variant.ts
+import { z as z16 } from "zod";
+var variantSchema = z16.object({
+  id: z16.string().uuid(),
+  presentationId: z16.string().uuid(),
+  name: z16.string(),
+  audienceId: z16.string().uuid().nullable(),
+  isDefault: z16.boolean(),
+  order: z16.number().int(),
+  createdAt: z16.string(),
+  createdBy: z16.string(),
+  updatedAt: z16.string().nullable()
 });
-var createVariantSchema = z14.object({
-  name: z14.string().min(1),
-  audienceId: z14.string().uuid().nullable().optional()
+var createVariantSchema = z16.object({
+  name: z16.string().min(1),
+  audienceId: z16.string().uuid().nullable().optional()
 });
-var updateVariantSchema = z14.object({
-  name: z14.string().min(1).optional(),
-  audienceId: z14.string().uuid().nullable().optional()
+var updateVariantSchema = z16.object({
+  name: z16.string().min(1).optional(),
+  audienceId: z16.string().uuid().nullable().optional()
 });
-var variantListSchema = z14.array(variantSchema);
-// src/tools/index.ts
-import { z as z15 } from "zod";
-
+var variantListSchema = z16.array(variantSchema);
 // src/auth.ts
 function getCredentials() {
   const apiKey = process.env.ROADMAPS_API_KEY;
@@ -1498,15 +2196,7 @@ function registerGetWorkflows(server) {
 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: 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"),
-      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)")
-    }
+    inputSchema: searchRoadmapsInput
   }, async ({
     query,
     status,
@@ -1555,9 +2245,7 @@ function registerSearchRoadmaps(server) {
 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: z15.string().describe("The UUID of the roadmap item")
-    }
+    inputSchema: getRoadmapInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const roadmap2 = await client2.getRoadmap(id);
@@ -1573,8 +2261,16 @@ function registerGetRoadmap(server) {
             value: roadmap2.value,
             effort: roadmap2.effort,
             order: roadmap2.order,
-            prd: roadmap2.prd,
-            brainstormNotes: roadmap2.brainstormNotes,
+            prd: roadmap2.prd ? {
+              ...roadmap2.prd,
+              what: contentToMarkdown(roadmap2.prd.what),
+              why: contentToMarkdown(roadmap2.prd.why),
+              outcomes: roadmap2.prd.outcomes?.map((o) => ({
+                ...o,
+                description: contentToMarkdown(o.description)
+              }))
+            } : null,
+            brainstormNotes: contentToMarkdown(roadmap2.brainstormNotes),
             wireframes: roadmap2.wireframes?.map((w) => ({
               id: w.id,
               imageUrl: w.imageUrl,
@@ -1594,10 +2290,10 @@ function registerGetRoadmap(server) {
             })),
             epics: roadmap2.epics,
             stories: roadmap2.stories,
-            designDescription: roadmap2.design?.description ?? null,
-            planDescription: roadmap2.plan?.description ?? null,
-            buildDescription: roadmap2.build?.description ?? null,
-            releaseDescription: roadmap2.release?.description ?? null,
+            designDescription: contentToMarkdown(roadmap2.design?.description),
+            planDescription: contentToMarkdown(roadmap2.plan?.description),
+            buildDescription: contentToMarkdown(roadmap2.build?.description),
+            releaseDescription: contentToMarkdown(roadmap2.release?.description),
             prompt: roadmap2.build?.prompt ?? roadmap2.prompt ?? null,
             createdAt: roadmap2.createdAt
           }, null, 2)
@@ -1609,10 +2305,7 @@ function registerGetRoadmap(server) {
 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: z15.string().optional().describe("Search query to match against name"),
-      type: featureTypeSchema.optional().describe("Filter by type (feature or area)")
-    }
+    inputSchema: searchFeaturesInput
   }, async ({ query, type }) => {
     const client2 = getApiClient();
     let features = await client2.listFeatures();
@@ -1641,9 +2334,7 @@ function registerSearchFeatures(server) {
 function registerGetFeature(server) {
   server.registerTool("get_feature", {
     description: "Get full details of a feature including outcomes, child features, and linked roadmap items.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the feature")
-    }
+    inputSchema: getFeatureInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const feature2 = await client2.getFeature(id);
@@ -1658,7 +2349,7 @@ function registerGetFeature(server) {
             parentId: feature2.parentId,
             outcomes: feature2.outcomes?.map((o) => ({
               id: o.id,
-              description: o.description
+              description: contentToMarkdown(o.description)
             })),
             children: feature2.children?.map((c) => ({
               id: c.id,
@@ -1680,10 +2371,7 @@ function registerGetFeature(server) {
 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: z15.string().optional().describe("Search query to match against title or description"),
-      status: ideaStatusSchema.optional().describe("Filter by status")
-    }
+    inputSchema: searchIdeasInput
   }, async ({ query, status }) => {
     const client2 = getApiClient();
     let ideas = await client2.listIdeas();
@@ -1701,7 +2389,7 @@ function registerSearchIdeas(server) {
           text: JSON.stringify(ideas.map((i) => ({
             id: i.id,
             title: i.title,
-            description: i.description,
+            description: contentToMarkdown(i.description),
             status: i.status,
             source: i.source
           })), null, 2)
@@ -1738,8 +2426,8 @@ Use this as your FIRST call when starting work on a roadmap to understand the fu
           type: "text",
           text: JSON.stringify({
             strategy: {
-              vision: strategy.vision,
-              mission: strategy.mission
+              vision: contentToMarkdown(strategy.vision),
+              mission: contentToMarkdown(strategy.mission)
             },
             products: products.map((p) => ({
               id: p.id,
@@ -1780,11 +2468,7 @@ Use this as your FIRST call when starting work on a roadmap to understand the fu
 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: 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")')
-    }
+    inputSchema: captureIdeaInput
   }, async ({
     title,
     description,
@@ -1819,18 +2503,7 @@ function registerCaptureIdea(server) {
 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: 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")'),
-      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: 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: z15.string().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
-    }
+    inputSchema: createRoadmapItemInput
   }, async ({
     title,
     status,
@@ -1891,31 +2564,10 @@ function registerCreateRoadmapItem(server) {
     };
   });
 }
-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, phase, phaseStep, or brainstorm notes.",
-    inputSchema: {
-      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"),
-      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: 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: 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: z15.string().nullable().optional().describe('Deadline/target date value matching granularity (e.g., "2024-03-15" for day, "2024-Q1" for quarter)')
-    }
+    inputSchema: updateRoadmapItemInput
   }, async ({
     id,
     title,
@@ -2024,14 +2676,7 @@ function registerUpdateRoadmapItem(server) {
 function registerAddFeature(server) {
   server.registerTool("add_feature", {
     description: "Create a new feature with optional outcomes. Features represent capabilities or functionality areas.",
-    inputSchema: {
-      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: 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")
-    }
+    inputSchema: addFeatureInput
   }, async ({
     name,
     description,
@@ -2076,12 +2721,7 @@ function registerAddFeature(server) {
 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: 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")
-    }
+    inputSchema: savePrdInput
   }, async ({
     roadmapId,
     what,
@@ -2117,10 +2757,7 @@ function registerSavePrd(server) {
 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: z15.string().describe("The UUID of the roadmap item"),
-      notes: z15.string().describe("The brainstorm notes content")
-    }
+    inputSchema: updateBrainstormNotesInput
   }, async ({ roadmapId, notes }) => {
     const client2 = getApiClient();
     const roadmap2 = await client2.updateRoadmap(roadmapId, {
@@ -2147,9 +2784,7 @@ function registerUpdateBrainstormNotes(server) {
 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: z15.string().describe("The UUID of the roadmap item to delete")
-    }
+    inputSchema: deleteRoadmapItemInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteRoadmap(id);
@@ -2169,12 +2804,7 @@ function registerDeleteRoadmapItem(server) {
 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: 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")
-    }
+    inputSchema: reorderRoadmapsInput
   }, async ({ items }) => {
     const client2 = getApiClient();
     const result = await client2.reorderRoadmaps(items);
@@ -2195,12 +2825,7 @@ function registerReorderRoadmaps(server) {
 function registerUpdateFeature(server) {
   server.registerTool("update_feature", {
     description: "Update an existing feature. Can update name, type, or parent.",
-    inputSchema: {
-      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: z15.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
-    }
+    inputSchema: updateFeatureInput
   }, async ({
     id,
     name,
@@ -2237,9 +2862,7 @@ function registerUpdateFeature(server) {
 function registerDeleteFeature(server) {
   server.registerTool("delete_feature", {
     description: "Delete a feature. This is a soft delete that also deletes all child features.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the feature to delete")
-    }
+    inputSchema: deleteFeatureInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteFeature(id);
@@ -2259,9 +2882,7 @@ function registerDeleteFeature(server) {
 function registerGetIdea(server) {
   server.registerTool("get_idea", {
     description: "Get full details of a single idea by ID.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the idea")
-    }
+    inputSchema: getIdeaInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const idea2 = await client2.getIdea(id);
@@ -2272,7 +2893,7 @@ function registerGetIdea(server) {
           text: JSON.stringify({
             id: idea2.id,
             title: idea2.title,
-            description: idea2.description,
+            description: contentToMarkdown(idea2.description),
             status: idea2.status,
             source: idea2.source,
             submittedBy: idea2.submittedBy,
@@ -2288,14 +2909,7 @@ function registerGetIdea(server) {
 function registerUpdateIdea(server) {
   server.registerTool("update_idea", {
     description: "Update an existing idea. Can update title, description, status, value, or effort.",
-    inputSchema: {
-      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: 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")
-    }
+    inputSchema: updateIdeaInput
   }, async ({
     id,
     title,
@@ -2340,9 +2954,7 @@ function registerUpdateIdea(server) {
 function registerDeleteIdea(server) {
   server.registerTool("delete_idea", {
     description: "Delete an idea. This is a soft delete.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the idea to delete")
-    }
+    inputSchema: deleteIdeaInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteIdea(id);
@@ -2370,7 +2982,10 @@ function registerGetStrategy(server) {
       content: [
         {
           type: "text",
-          text: JSON.stringify(strategy, null, 2)
+          text: JSON.stringify({
+            vision: contentToMarkdown(strategy.vision),
+            mission: contentToMarkdown(strategy.mission)
+          }, null, 2)
         }
       ]
     };
@@ -2379,10 +2994,7 @@ function registerGetStrategy(server) {
 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: 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")
-    }
+    inputSchema: updateStrategyInput
   }, async ({ vision, mission }) => {
     const client2 = getApiClient();
     const updates = {};
@@ -2428,10 +3040,7 @@ function registerListScenarios(server) {
 function registerCreateScenario(server) {
   server.registerTool("create_scenario", {
     description: "Create a new user scenario. Scenarios describe user workflows and how they accomplish goals.",
-    inputSchema: {
-      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")
-    }
+    inputSchema: createScenarioInput
   }, async ({ title, description }) => {
     const client2 = getApiClient();
     const scenario2 = await client2.createScenario({
@@ -2458,11 +3067,7 @@ function registerCreateScenario(server) {
 function registerUpdateScenario(server) {
   server.registerTool("update_scenario", {
     description: "Update an existing scenario.",
-    inputSchema: {
-      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")
-    }
+    inputSchema: updateScenarioInput
   }, async ({
     id,
     title,
@@ -2495,9 +3100,7 @@ function registerUpdateScenario(server) {
 function registerDeleteScenario(server) {
   server.registerTool("delete_scenario", {
     description: "Delete a scenario. This is a soft delete.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the scenario to delete")
-    }
+    inputSchema: deleteScenarioInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteScenario(id);
@@ -2511,22 +3114,10 @@ function registerDeleteScenario(server) {
     };
   });
 }
-var productTypeSchema2 = z15.enum([
-  "brand",
-  "product",
-  "app",
-  "marketing_site",
-  "landing_page",
-  "service"
-]);
 function registerCreateProduct(server) {
   server.registerTool("create_product", {
     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: z15.string().describe("Name of the product"),
-      parentId: z15.string().nullable().optional().describe("UUID of parent product to nest under")
-    }
+    inputSchema: createProductInput
   }, async ({
     type,
     name,
@@ -2559,11 +3150,7 @@ function registerCreateProduct(server) {
 function registerUpdateProduct(server) {
   server.registerTool("update_product", {
     description: "Update an existing product.",
-    inputSchema: {
-      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")
-    }
+    inputSchema: updateProductInput
   }, async ({ id, name, parentId }) => {
     const client2 = getApiClient();
     const updates = {};
@@ -2593,9 +3180,7 @@ function registerUpdateProduct(server) {
 function registerDeleteProduct(server) {
   server.registerTool("delete_product", {
     description: "Delete a product. This is a soft delete that also deletes all child products.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the product to delete")
-    }
+    inputSchema: deleteProductInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const result = await client2.deleteProduct(id);
@@ -2616,9 +3201,7 @@ function registerDeleteProduct(server) {
 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: z15.string().describe("The UUID of the product")
-    }
+    inputSchema: getProductInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const [product2, documentation] = await Promise.all([
@@ -2640,8 +3223,8 @@ function registerGetProduct(server) {
               createdAt: product2.createdAt
             },
             documentation: documentation ? {
-              designSystem: documentation.designSystem,
-              adrs: documentation.adrs,
+              designSystem: contentToMarkdown(documentation.designSystem),
+              adrs: contentToMarkdown(documentation.adrs),
               updatedAt: documentation.updatedAt
             } : null
           }, null, 2)
@@ -2653,10 +3236,7 @@ function registerGetProduct(server) {
 function registerSearchProducts(server) {
   server.registerTool("search_products", {
     description: "Search for products by name. Returns a list of matching products with basic info.",
-    inputSchema: {
-      query: z15.string().optional().describe("Search query to match against product name"),
-      type: productTypeSchema2.optional().describe("Filter by product type")
-    }
+    inputSchema: searchProductsInput
   }, async ({ query, type }) => {
     const client2 = getApiClient();
     let products = await client2.listProducts();
@@ -2688,9 +3268,7 @@ function registerSearchProducts(server) {
 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: z15.string().describe("The UUID of the product")
-    }
+    inputSchema: getProductDocumentationInput
   }, async ({ productId }) => {
     const client2 = getApiClient();
     const documentation = await client2.getProductDocumentation(productId);
@@ -2702,8 +3280,8 @@ function registerGetProductDocumentation(server) {
             productId,
             documentation: documentation ? {
               id: documentation.id,
-              designSystem: documentation.designSystem,
-              adrs: documentation.adrs,
+              designSystem: contentToMarkdown(documentation.designSystem),
+              adrs: contentToMarkdown(documentation.adrs),
               createdAt: documentation.createdAt,
               updatedAt: documentation.updatedAt
             } : null
@@ -2716,11 +3294,7 @@ function registerGetProductDocumentation(server) {
 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: 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.")
-    }
+    inputSchema: updateProductDocumentationInput
   }, async ({
     productId,
     designSystem,
@@ -2755,10 +3329,7 @@ function registerUpdateProductDocumentation(server) {
 function registerCreateAudience(server) {
   server.registerTool("create_audience", {
     description: "Create a new audience member. Audiences represent who the product serves.",
-    inputSchema: {
-      name: z15.string().describe('Name of the audience (e.g., "Product Manager", "End User")'),
-      description: z15.string().nullable().optional().describe("Description of the audience")
-    }
+    inputSchema: createAudienceInput
   }, async ({ name, description }) => {
     const client2 = getApiClient();
     const audience2 = await client2.createAudience({
@@ -2785,11 +3356,7 @@ function registerCreateAudience(server) {
 function registerUpdateAudience(server) {
   server.registerTool("update_audience", {
     description: "Update an existing audience member.",
-    inputSchema: {
-      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")
-    }
+    inputSchema: updateAudienceInput
   }, async ({
     id,
     name,
@@ -2822,9 +3389,7 @@ function registerUpdateAudience(server) {
 function registerDeleteAudience(server) {
   server.registerTool("delete_audience", {
     description: "Delete an audience member. This is a soft delete.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the audience to delete")
-    }
+    inputSchema: deleteAudienceInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteAudience(id);
@@ -2864,20 +3429,7 @@ function registerListStatusUpdates(server) {
 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: 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",
-        "prd",
-        "wireframe",
-        "product",
-        "audience",
-        "scenario"
-      ]).optional().describe("Filter to specific entity type")
-    }
+    inputSchema: getHistoryInput
   }, async ({
     startDate,
     endDate,
@@ -2898,10 +3450,7 @@ function registerGetHistory(server) {
 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: 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")
-    }
+    inputSchema: getHistorySummaryInput
   }, async ({ startDate, endDate }) => {
     const client2 = getApiClient();
     const summary = await client2.getHistorySummary({ startDate, endDate });
@@ -2918,16 +3467,7 @@ function registerGetHistorySummary(server) {
 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: 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")
-    }
+    inputSchema: createStatusUpdateInput
   }, async ({
     startDate,
     endDate,
@@ -2965,21 +3505,7 @@ function registerCreateStatusUpdate(server) {
 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: 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: 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)")
-    }
+    inputSchema: saveStoriesInput
   }, async ({
     roadmapId,
     epics,
@@ -3008,12 +3534,7 @@ function registerSaveStories(server) {
 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: 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")
-    }
+    inputSchema: uploadWireframeInput
   }, async ({
     roadmapId,
     filePath,
@@ -3065,11 +3586,7 @@ function registerUploadWireframe(server) {
 function registerUpdateWireframe(server) {
   server.registerTool("update_wireframe", {
     description: "Update a wireframe's description or outcome tags.",
-    inputSchema: {
-      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)")
-    }
+    inputSchema: updateWireframeInput
   }, async ({
     id,
     description,
@@ -3103,9 +3620,7 @@ function registerUpdateWireframe(server) {
 function registerDeleteWireframe(server) {
   server.registerTool("delete_wireframe", {
     description: "Delete a wireframe (soft delete).",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the wireframe to delete")
-    }
+    inputSchema: deleteWireframeInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteWireframe(id);
@@ -3122,11 +3637,7 @@ function registerDeleteWireframe(server) {
 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: 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")
-    }
+    inputSchema: uploadBrainstormMediaInput
   }, async ({
     roadmapId,
     filePath,
@@ -3176,10 +3687,7 @@ function registerUploadBrainstormMedia(server) {
 function registerUpdateBrainstormMedia(server) {
   server.registerTool("update_brainstorm_media", {
     description: "Update a brainstorm media item's description.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the brainstorm media"),
-      description: z15.string().nullable().describe("New description for the media")
-    }
+    inputSchema: updateBrainstormMediaInput
   }, async ({ id, description }) => {
     const client2 = getApiClient();
     const media = await client2.updateBrainstormMedia(id, { description });
@@ -3201,9 +3709,7 @@ function registerUpdateBrainstormMedia(server) {
 function registerDeleteBrainstormMedia(server) {
   server.registerTool("delete_brainstorm_media", {
     description: "Delete a brainstorm media item (soft delete).",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the brainstorm media to delete")
-    }
+    inputSchema: deleteBrainstormMediaInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteBrainstormMedia(id);
@@ -3220,11 +3726,7 @@ function registerDeleteBrainstormMedia(server) {
 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: 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")
-    }
+    inputSchema: uploadProductDesignMediaInput
   }, async ({
     productId,
     filePath,
@@ -3275,11 +3777,7 @@ function registerUploadProductDesignMedia(server) {
 function registerUpdateProductDesignMedia(server) {
   server.registerTool("update_product_design_media", {
     description: "Update a product design media item's description.",
-    inputSchema: {
-      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")
-    }
+    inputSchema: updateProductDesignMediaInput
   }, async ({
     productId,
     mediaId,
@@ -3305,10 +3803,7 @@ function registerUpdateProductDesignMedia(server) {
 function registerDeleteProductDesignMedia(server) {
   server.registerTool("delete_product_design_media", {
     description: "Delete a product design media item (soft delete).",
-    inputSchema: {
-      productId: z15.string().describe("The UUID of the product"),
-      mediaId: z15.string().describe("The UUID of the design media to delete")
-    }
+    inputSchema: deleteProductDesignMediaInput
   }, async ({ productId, mediaId }) => {
     const client2 = getApiClient();
     await client2.deleteProductDesignMedia(productId, mediaId);
@@ -3328,10 +3823,7 @@ function isVideoContentType(contentType) {
 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: z15.string().describe("The UUID of the roadmap item"),
-      filePath: z15.string().describe("Absolute path to the video file on disk")
-    }
+    inputSchema: uploadDesignWalkthroughInput
   }, async ({ roadmapId, filePath }) => {
     const client2 = getApiClient();
     const filename = filePath.split("/").pop() || "video.mp4";
@@ -3371,10 +3863,7 @@ function registerUploadDesignWalkthrough(server) {
 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: z15.string().describe("The UUID of the roadmap item"),
-      filePath: z15.string().describe("Absolute path to the video file on disk")
-    }
+    inputSchema: uploadReleaseWalkthroughInput
   }, async ({ roadmapId, filePath }) => {
     const client2 = getApiClient();
     const filename = filePath.split("/").pop() || "video.mp4";
@@ -3430,11 +3919,7 @@ function getPrototypeContentType(filename) {
 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: 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)")
-    }
+    inputSchema: publishPrototypeInput
   }, async ({
     roadmapId,
     folderPath,
@@ -3593,9 +4078,7 @@ Expires: ${expiryDate}`
 function registerListPrototypes(server) {
   server.registerTool("list_prototypes", {
     description: "List published prototypes for a roadmap item. Returns prototype IDs needed for creating feedback sessions.",
-    inputSchema: {
-      roadmapId: z15.string().uuid().describe("The UUID of the roadmap item")
-    }
+    inputSchema: listPrototypesInput
   }, async ({ roadmapId }) => {
     const client2 = getApiClient();
     const prototypes = await client2.listPrototypes(roadmapId);
@@ -3638,16 +4121,10 @@ ${lines.join(`
     };
   });
 }
-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: z15.string().optional().describe("Search query to match against title or description"),
-      horizon: horizonSchema.optional().describe("Filter by planning horizon"),
-      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)")
-    }
+    inputSchema: searchInitiativesInput
   }, async ({
     query,
     horizon,
@@ -3673,7 +4150,7 @@ function registerSearchInitiatives(server) {
             items: paginatedInitiatives.map((i) => ({
               id: i.id,
               title: i.title,
-              description: i.description,
+              description: contentToMarkdown(i.description),
               horizon: i.horizon,
               targetDate: i.targetDate,
               itemCount: i.itemCount,
@@ -3695,9 +4172,7 @@ function registerSearchInitiatives(server) {
 function registerGetInitiative(server) {
   server.registerTool("get_initiative", {
     description: "Get full details of an initiative including all linked roadmap items.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the initiative")
-    }
+    inputSchema: getInitiativeInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const result = await client2.getInitiative(id);
@@ -3705,7 +4180,13 @@ function registerGetInitiative(server) {
       content: [
         {
           type: "text",
-          text: JSON.stringify(result, null, 2)
+          text: JSON.stringify({
+            ...result,
+            initiative: {
+              ...result.initiative,
+              description: contentToMarkdown(result.initiative.description)
+            }
+          }, null, 2)
         }
       ]
     };
@@ -3714,14 +4195,7 @@ function registerGetInitiative(server) {
 function registerCreateInitiative(server) {
   server.registerTool("create_initiative", {
     description: "Create a new initiative. Initiatives group related roadmap items for cross-functional coordination.",
-    inputSchema: {
-      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: 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")
-    }
+    inputSchema: createInitiativeInput
   }, async ({
     title,
     description,
@@ -3763,16 +4237,7 @@ function registerCreateInitiative(server) {
 function registerUpdateInitiative(server) {
   server.registerTool("update_initiative", {
     description: "Update an existing initiative.",
-    inputSchema: {
-      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: 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)")
-    }
+    inputSchema: updateInitiativeInput
   }, async ({
     id,
     title,
@@ -3825,9 +4290,7 @@ function registerUpdateInitiative(server) {
 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: z15.string().describe("The UUID of the initiative to delete")
-    }
+    inputSchema: deleteInitiativeInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteInitiative(id);
@@ -3844,12 +4307,7 @@ function registerDeleteInitiative(server) {
 function registerReorderInitiatives(server) {
   server.registerTool("reorder_initiatives", {
     description: "Bulk reorder initiatives by setting their order values. Lower order values appear first.",
-    inputSchema: {
-      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")
-    }
+    inputSchema: reorderInitiativesInput
   }, async ({ items }) => {
     const client2 = getApiClient();
     await client2.reorderInitiatives(items);
@@ -3866,14 +4324,7 @@ 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)")
-    }
+    inputSchema: searchExportsInput
   }, async ({
     roadmapId,
     externalSystem,
@@ -3908,9 +4359,7 @@ function registerSearchExports(server) {
 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")
-    }
+    inputSchema: getExportInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const exportRecord = await client2.getExport(id);
@@ -3927,16 +4376,7 @@ function registerGetExport(server) {
 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")
-    }
+    inputSchema: createExportInput
   }, async ({
     roadmapId,
     localEntityType,
@@ -3971,11 +4411,7 @@ function registerCreateExport(server) {
 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")
-    }
+    inputSchema: updateExportInput
   }, async ({
     id,
     externalUrl,
@@ -3996,9 +4432,7 @@ function registerUpdateExport(server) {
 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")
-    }
+    inputSchema: deleteExportInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deleteExport(id);
@@ -4032,9 +4466,7 @@ function registerListPresentations(server) {
 function registerGetPresentation(server) {
   server.registerTool("get_presentation", {
     description: "Get presentation with variants and slides.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the presentation")
-    }
+    inputSchema: getPresentationInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     const presentation2 = await client2.getPresentation(id);
@@ -4062,10 +4494,7 @@ function registerGetPresentation(server) {
 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")
-    }
+    inputSchema: createPresentationInput
   }, async ({ title, description }) => {
     const client2 = getApiClient();
     const presentation2 = await client2.createPresentation({
@@ -4085,11 +4514,7 @@ function registerCreatePresentation(server) {
 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")
-    }
+    inputSchema: updatePresentationInput
   }, async ({
     id,
     title,
@@ -4115,9 +4540,7 @@ function registerUpdatePresentation(server) {
 function registerDeletePresentation(server) {
   server.registerTool("delete_presentation", {
     description: "Delete a presentation.",
-    inputSchema: {
-      id: z15.string().describe("The UUID of the presentation to delete")
-    }
+    inputSchema: deletePresentationInput
   }, async ({ id }) => {
     const client2 = getApiClient();
     await client2.deletePresentation(id);
@@ -4134,12 +4557,7 @@ function registerDeletePresentation(server) {
 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")
-    }
+    inputSchema: reorderPresentationsInput
   }, async ({ items }) => {
     const client2 = getApiClient();
     await client2.reorderPresentations(items);
@@ -4156,9 +4574,7 @@ function registerReorderPresentations(server) {
 function registerListVariants(server) {
   server.registerTool("list_variants", {
     description: "List all variants for a presentation.",
-    inputSchema: {
-      presentationId: z15.string().describe("The UUID of the presentation")
-    }
+    inputSchema: listVariantsInput
   }, async ({ presentationId }) => {
     const client2 = getApiClient();
     const result = await client2.listVariants(presentationId);
@@ -4175,10 +4591,7 @@ function registerListVariants(server) {
 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")
-    }
+    inputSchema: getVariantInput
   }, async ({ presentationId, variantId }) => {
     const client2 = getApiClient();
     const variant2 = await client2.getVariant(presentationId, variantId);
@@ -4199,11 +4612,7 @@ function registerGetVariant(server) {
 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")
-    }
+    inputSchema: createVariantInput
   }, async ({
     presentationId,
     name,
@@ -4227,12 +4636,7 @@ function registerCreateVariant(server) {
 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")
-    }
+    inputSchema: updateVariantInput
   }, async ({
     presentationId,
     variantId,
@@ -4259,10 +4663,7 @@ function registerUpdateVariant(server) {
 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")
-    }
+    inputSchema: deleteVariantInput
   }, async ({ presentationId, variantId }) => {
     const client2 = getApiClient();
     await client2.deleteVariant(presentationId, variantId);
@@ -4279,13 +4680,7 @@ function registerDeleteVariant(server) {
 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")
-    }
+    inputSchema: reorderVariantsInput
   }, async ({
     presentationId,
     items
@@ -4305,10 +4700,7 @@ function registerReorderVariants(server) {
 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")
-    }
+    inputSchema: cloneVariantInput
   }, async ({ presentationId, variantId }) => {
     const client2 = getApiClient();
     const clonedVariant = await client2.cloneVariant(presentationId, variantId);
@@ -4325,10 +4717,7 @@ function registerCloneVariant(server) {
 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")
-    }
+    inputSchema: setDefaultVariantInput
   }, async ({ presentationId, variantId }) => {
     const client2 = getApiClient();
     await client2.setDefaultVariant(presentationId, variantId);
@@ -4345,9 +4734,7 @@ function registerSetDefaultVariant(server) {
 function registerListSlides(server) {
   server.registerTool("list_slides", {
     description: "List all slides in a variant.",
-    inputSchema: {
-      variantId: z15.string().describe("The UUID of the variant")
-    }
+    inputSchema: listSlidesInput
   }, async ({ variantId }) => {
     const client2 = getApiClient();
     const presentationId = await client2.getVariantPresentationId(variantId);
@@ -4375,10 +4762,7 @@ function registerListSlides(server) {
 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")
-    }
+    inputSchema: getSlideInput
   }, async ({ variantId, slideId }) => {
     const client2 = getApiClient();
     const presentationId = await client2.getVariantPresentationId(variantId);
@@ -4406,25 +4790,7 @@ function registerGetSlide(server) {
 function registerCreateSlide(server) {
   server.registerTool("create_slide", {
     description: "Create a new slide in a variant. Slide types: title (title + subtitle), section_header (title + subtitle), bullets (title + items array), two_column (title + left/right text), comparison (leftLabel + leftContent + rightLabel + rightContent), timeline (title + steps array of {title, description}), image (title + imageUrl + caption), quote (quote + attribution), code (title + code + language), thank_you (title + subtitle), mermaid (title + code with mermaid diagram syntax), paragraph (title + body with markdown text).",
-    inputSchema: {
-      variantId: z15.string().describe("The UUID of the variant"),
-      slideType: z15.enum([
-        "title",
-        "section_header",
-        "bullets",
-        "two_column",
-        "comparison",
-        "timeline",
-        "image",
-        "quote",
-        "code",
-        "thank_you",
-        "mermaid",
-        "paragraph"
-      ]).default("bullets").describe("The type of slide to create"),
-      content: z15.record(z15.unknown()).optional().describe('Type-specific content object. For bullets: {title, items: ["..."]}. For title: {title, subtitle}. For two_column: {title, left, right}. For quote: {quote, attribution}. For mermaid: {title, code: "graph TD; A-->B"}. For paragraph: {title, body}. Etc.'),
-      speakerNotes: z15.string().nullable().optional().describe("Speaker notes for the slide")
-    }
+    inputSchema: createSlideInput
   }, async ({
     variantId,
     slideType,
@@ -4461,13 +4827,7 @@ function registerCreateSlide(server) {
 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")
-    }
+    inputSchema: updateSlideInput
   }, async ({
     variantId,
     slideId,
@@ -4508,10 +4868,7 @@ function registerUpdateSlide(server) {
 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")
-    }
+    inputSchema: deleteSlideInput
   }, async ({ variantId, slideId }) => {
     const client2 = getApiClient();
     const presentationId = await client2.getVariantPresentationId(variantId);
@@ -4539,13 +4896,7 @@ function registerDeleteSlide(server) {
 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")
-    }
+    inputSchema: reorderSlidesInput
   }, async ({
     variantId,
     items
@@ -4576,11 +4927,7 @@ function registerReorderSlides(server) {
 function registerUploadSlideImage(server) {
   server.registerTool("upload_slide_image", {
     description: 'Upload an image to a slide. Gets a presigned URL and returns a curl command to execute for the upload, then updates the slide content with the image URL. The slide must be of type "image".',
-    inputSchema: {
-      variantId: z15.string().describe("The UUID of the variant"),
-      slideId: z15.string().describe("The UUID of the slide to add the image to"),
-      filePath: z15.string().describe("Absolute path to the image file on disk")
-    }
+    inputSchema: uploadSlideImageInput
   }, async ({
     variantId,
     slideId,
@@ -4652,11 +4999,7 @@ function registerUploadSlideImage(server) {
 function registerCreateFeedbackSession(server) {
   server.registerTool("create_feedback_session", {
     description: "Create a feedback session for a prototype and get a shareable review link. Reviewers who open the link can optionally enter their name before leaving pin-based feedback.",
-    inputSchema: {
-      prototypeId: z15.string().uuid().describe("The UUID of the prototype to create a feedback session for"),
-      name: z15.string().describe('Name for this feedback session (e.g., "Round 1 Review")'),
-      expiresInDays: z15.number().int().min(1).max(90).optional().describe("Number of days until the session expires (default 7)")
-    }
+    inputSchema: createFeedbackSessionInput
   }, async ({
     prototypeId,
     name,
@@ -4703,9 +5046,7 @@ function registerCreateFeedbackSession(server) {
 function registerListFeedbackSessions(server) {
   server.registerTool("list_feedback_sessions", {
     description: "List all feedback sessions for a prototype with comment counts and status.",
-    inputSchema: {
-      prototypeId: z15.string().uuid().describe("The UUID of the prototype")
-    }
+    inputSchema: listFeedbackSessionsInput
   }, async ({ prototypeId }) => {
     const client2 = getApiClient();
     const sessions = await client2.listFeedbackSessions(prototypeId);
@@ -4754,11 +5095,7 @@ function formatCommentLine(c) {
 function registerGetFeedbackSummary(server) {
   server.registerTool("get_feedback_summary", {
     description: "Get a human-readable summary of feedback for a session, grouped by page. Shows pin numbers, reviewer names, comment text, and which element was pinned. Use this for a quick overview of feedback.",
-    inputSchema: {
-      prototypeId: z15.string().uuid().describe("The UUID of the prototype"),
-      sessionId: z15.string().uuid().describe("The UUID of the feedback session"),
-      filter: z15.enum(["all", "unresolved", "resolved"]).optional().describe("Filter comments by resolved status (default: unresolved)")
-    }
+    inputSchema: getFeedbackSummaryInput
   }, async ({
     prototypeId,
     sessionId,
@@ -4797,12 +5134,7 @@ function registerGetFeedbackSummary(server) {
 function registerGetFeedbackDetail(server) {
   server.registerTool("get_feedback_detail", {
     description: "Get full raw pin data for feedback comments, including CSS selectors, bounding boxes, parent/sibling DOM context, and coordinates. Use this when you need exact element information to make targeted code changes.",
-    inputSchema: {
-      prototypeId: z15.string().uuid().describe("The UUID of the prototype"),
-      sessionId: z15.string().uuid().describe("The UUID of the feedback session"),
-      commentId: z15.string().uuid().optional().describe("Optional: get detail for a single comment"),
-      filter: z15.enum(["all", "unresolved", "resolved"]).optional().describe("Filter comments by resolved status (default: all). Ignored if commentId is provided.")
-    }
+    inputSchema: getFeedbackDetailInput
   }, async ({
     prototypeId,
     sessionId,
@@ -4846,11 +5178,7 @@ function registerGetFeedbackDetail(server) {
 function registerResolveFeedbackComment(server) {
   server.registerTool("resolve_feedback_comment", {
     description: "Toggle the resolved status on a feedback comment. If currently unresolved, marks it as resolved. If already resolved, marks it as unresolved.",
-    inputSchema: {
-      prototypeId: z15.string().uuid().describe("The UUID of the prototype"),
-      sessionId: z15.string().uuid().describe("The UUID of the feedback session"),
-      commentId: z15.string().uuid().describe("The UUID of the comment to resolve/unresolve")
-    }
+    inputSchema: resolveFeedbackCommentInput
   }, async ({
     prototypeId,
     sessionId,