@ourroadmaps/mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -19504,7 +19504,6 @@ class StdioServerTransport {
     });
   }
 }
-
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -23478,6 +23477,339 @@ var coerce = {
   date: (arg) => ZodDate2.create({ ...arg, coerce: true })
 };
 var NEVER2 = INVALID2;
+// ../../packages/shared/src/schemas/constants.ts
+var HORIZONS = [
+  "inbox",
+  "now",
+  "next",
+  "later",
+  "someday",
+  "icebox",
+  "done",
+  "cancelled"
+];
+var horizonSchema = exports_external.enum(HORIZONS);
+var ROADMAP_STATUSES = [
+  "not_started",
+  "planning",
+  "needs_review",
+  "approved",
+  "in_progress",
+  "done",
+  "cancelled"
+];
+var roadmapStatusSchema = exports_external.enum(ROADMAP_STATUSES);
+var EFFORT_SIZES = ["xs", "s", "m", "l", "xl"];
+var effortSchema = exports_external.enum(EFFORT_SIZES);
+var DATE_GRANULARITIES = ["day", "month", "quarter", "half-year", "year"];
+var dateGranularitySchema = exports_external.enum(DATE_GRANULARITIES);
+var PRD_STATUSES = ["draft", "completed"];
+var prdStatusSchema = exports_external.enum(PRD_STATUSES);
+var IDEA_STATUSES = ["new", "under-review", "planned", "declined", "done"];
+var ideaStatusSchema = exports_external.enum(IDEA_STATUSES);
+var FEATURE_TYPES = ["area", "feature"];
+var featureTypeSchema = exports_external.enum(FEATURE_TYPES);
+var PRODUCT_TYPES = [
+  "brand",
+  "product",
+  "app",
+  "marketing_site",
+  "landing_page",
+  "service"
+];
+var productTypeSchema = exports_external.enum(PRODUCT_TYPES);
+var AUDIENCE_TYPES = ["stakeholder", "user_persona"];
+var audienceTypeSchema = exports_external.enum(AUDIENCE_TYPES);
+var BRAINSTORM_MEDIA_TYPES = ["image", "video"];
+var brainstormMediaTypeSchema = exports_external.enum(BRAINSTORM_MEDIA_TYPES);
+
+// ../../packages/shared/src/schemas/audience.ts
+var audienceSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  organizationId: exports_external.string(),
+  type: audienceTypeSchema,
+  role: exports_external.string().nullable(),
+  likes: exports_external.string().nullable(),
+  dislikes: exports_external.string().nullable(),
+  priorities: exports_external.string().nullable(),
+  order: exports_external.number().int(),
+  deletedAt: exports_external.string().nullable(),
+  createdAt: exports_external.string()
+});
+var createAudienceSchema = exports_external.object({
+  type: audienceTypeSchema,
+  role: exports_external.string().min(1),
+  likes: exports_external.string().nullable().optional(),
+  dislikes: exports_external.string().nullable().optional(),
+  priorities: exports_external.string().nullable().optional()
+});
+var updateAudienceSchema = exports_external.object({
+  type: audienceTypeSchema.optional(),
+  role: exports_external.string().min(1).optional(),
+  likes: exports_external.string().nullable().optional(),
+  dislikes: exports_external.string().nullable().optional(),
+  priorities: exports_external.string().nullable().optional(),
+  order: exports_external.number().int().optional()
+});
+var audienceListSchema = exports_external.array(audienceSchema);
+// ../../packages/shared/src/schemas/context.ts
+var domainContextSchema = exports_external.object({
+  definitions: exports_external.record(exports_external.string(), exports_external.string()),
+  schemas: exports_external.record(exports_external.string(), exports_external.array(exports_external.string()))
+});
+// ../../packages/shared/src/schemas/feature.ts
+var featureOutcomeSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  description: exports_external.string(),
+  order: exports_external.number().int(),
+  createdAt: exports_external.string(),
+  updatedAt: exports_external.string()
+});
+var featureSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  organizationId: exports_external.string(),
+  type: featureTypeSchema,
+  name: exports_external.string(),
+  parentId: exports_external.string().uuid().nullable(),
+  order: exports_external.number().int(),
+  isExpanded: exports_external.boolean(),
+  deletedAt: exports_external.string().nullable(),
+  createdAt: exports_external.string(),
+  createdBy: exports_external.string()
+});
+var roadmapLinkSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  roadmapId: exports_external.string().uuid(),
+  roadmap: exports_external.object({
+    id: exports_external.string().uuid(),
+    title: exports_external.string(),
+    status: exports_external.string(),
+    horizon: exports_external.string()
+  }),
+  createdAt: exports_external.string()
+});
+var featureWithRelationsSchema = featureSchema.extend({
+  outcomes: exports_external.array(featureOutcomeSchema),
+  roadmapLinks: exports_external.array(roadmapLinkSchema),
+  children: exports_external.array(featureSchema).optional()
+});
+var createFeatureSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  description: exports_external.string().nullable().optional(),
+  type: featureTypeSchema.optional(),
+  parentId: exports_external.string().uuid().nullable().optional()
+});
+var updateFeatureSchema = exports_external.object({
+  name: exports_external.string().min(1).optional(),
+  description: exports_external.string().nullable().optional(),
+  type: featureTypeSchema.optional(),
+  parentId: exports_external.string().uuid().nullable().optional(),
+  order: exports_external.number().int().optional()
+});
+var saveFeatureOutcomesSchema = exports_external.object({
+  outcomes: exports_external.array(exports_external.object({
+    id: exports_external.string().uuid().optional(),
+    description: exports_external.string()
+  }))
+});
+var featureListSchema = exports_external.array(featureSchema);
+// ../../packages/shared/src/schemas/idea.ts
+var ideaSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  organizationId: exports_external.string(),
+  title: exports_external.string(),
+  description: exports_external.string().nullable(),
+  status: ideaStatusSchema,
+  source: exports_external.string().nullable(),
+  submittedBy: exports_external.string().nullable(),
+  value: effortSchema.nullable(),
+  effort: effortSchema.nullable(),
+  order: exports_external.number().int(),
+  createdAt: exports_external.string(),
+  createdBy: exports_external.string()
+});
+var createIdeaSchema = exports_external.object({
+  title: exports_external.string().min(1),
+  description: exports_external.string().nullable().optional(),
+  status: ideaStatusSchema.optional(),
+  effort: effortSchema.nullable().optional(),
+  source: exports_external.string().nullable().optional()
+});
+var updateIdeaSchema = exports_external.object({
+  title: exports_external.string().min(1).optional(),
+  description: exports_external.string().nullable().optional(),
+  status: ideaStatusSchema.optional(),
+  effort: effortSchema.nullable().optional(),
+  source: exports_external.string().nullable().optional(),
+  order: exports_external.number().int().optional()
+});
+var ideaListSchema = exports_external.array(ideaSchema);
+// ../../packages/shared/src/schemas/product.ts
+var productSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  organizationId: exports_external.string(),
+  parentId: exports_external.string().uuid().nullable(),
+  type: productTypeSchema,
+  name: exports_external.string(),
+  order: exports_external.number().int(),
+  isExpanded: exports_external.boolean(),
+  deletedAt: exports_external.string().nullable(),
+  createdAt: exports_external.string()
+});
+var createProductSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  description: exports_external.string().nullable().optional(),
+  type: productTypeSchema,
+  parentId: exports_external.string().uuid().nullable().optional()
+});
+var updateProductSchema = exports_external.object({
+  name: exports_external.string().min(1).optional(),
+  description: exports_external.string().nullable().optional(),
+  type: productTypeSchema.optional(),
+  parentId: exports_external.string().uuid().nullable().optional(),
+  order: exports_external.number().int().optional()
+});
+var productListSchema = exports_external.array(productSchema);
+// ../../packages/shared/src/schemas/roadmap.ts
+var flexibleDateSchema = exports_external.object({
+  value: exports_external.string(),
+  granularity: dateGranularitySchema
+});
+var labelSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  type: exports_external.enum(["category", "location", "label"]),
+  name: exports_external.string(),
+  color: exports_external.string().nullable(),
+  address: exports_external.string().nullable()
+});
+var appSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  name: exports_external.string()
+});
+var roadmapSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  organizationId: exports_external.string(),
+  title: exports_external.string(),
+  horizon: horizonSchema.nullable(),
+  status: roadmapStatusSchema.nullable(),
+  value: effortSchema.nullable(),
+  effort: effortSchema.nullable(),
+  order: exports_external.number().int(),
+  estimatedSeconds: exports_external.number().int().nullable(),
+  date: flexibleDateSchema.nullable(),
+  target: flexibleDateSchema.nullable(),
+  completedAt: exports_external.string().nullable(),
+  createdAt: exports_external.string(),
+  createdBy: exports_external.string(),
+  prompt: exports_external.string().nullable(),
+  labels: exports_external.array(labelSchema),
+  apps: exports_external.array(appSchema)
+});
+var createRoadmapSchema = exports_external.object({
+  title: exports_external.string().min(1),
+  status: roadmapStatusSchema.optional(),
+  horizon: horizonSchema.optional(),
+  value: effortSchema.nullable().optional(),
+  effort: effortSchema.nullable().optional(),
+  estimatedSeconds: exports_external.number().int().nullable().optional(),
+  date: flexibleDateSchema.nullable().optional(),
+  target: flexibleDateSchema.nullable().optional(),
+  prompt: exports_external.string().nullable().optional(),
+  brainstormNotes: exports_external.string().nullable().optional()
+});
+var updateRoadmapSchema = exports_external.object({
+  title: exports_external.string().min(1).optional(),
+  status: roadmapStatusSchema.optional(),
+  horizon: horizonSchema.optional(),
+  value: effortSchema.nullable().optional(),
+  effort: effortSchema.nullable().optional(),
+  order: exports_external.number().int().optional(),
+  estimatedSeconds: exports_external.number().int().nullable().optional(),
+  date: flexibleDateSchema.nullable().optional(),
+  target: flexibleDateSchema.nullable().optional(),
+  prompt: exports_external.string().nullable().optional(),
+  brainstormNotes: exports_external.string().nullable().optional()
+});
+var prdOutcomeSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  description: exports_external.string(),
+  status: prdStatusSchema,
+  order: exports_external.number().int(),
+  completedAt: exports_external.string().nullable()
+});
+var prdSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  what: exports_external.string().nullable(),
+  why: exports_external.string().nullable(),
+  outcomes: exports_external.array(prdOutcomeSchema)
+});
+var savePrdInputSchema = exports_external.object({
+  what: exports_external.string().nullable(),
+  why: exports_external.string().nullable(),
+  outcomes: exports_external.array(exports_external.object({
+    id: exports_external.string().uuid().optional(),
+    description: exports_external.string(),
+    status: prdStatusSchema.optional()
+  })).optional()
+});
+var brainstormMediaSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  mediaUrl: exports_external.string(),
+  mediaType: brainstormMediaTypeSchema,
+  description: exports_external.string().nullable(),
+  order: exports_external.number().int(),
+  createdAt: exports_external.string()
+});
+var wireframeSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  description: exports_external.string().nullable(),
+  imageUrl: exports_external.string().nullable(),
+  order: exports_external.number().int()
+});
+var featureLinkSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  featureId: exports_external.string().uuid(),
+  feature: exports_external.object({
+    id: exports_external.string().uuid(),
+    name: exports_external.string(),
+    type: exports_external.enum(["area", "feature"])
+  }),
+  createdAt: exports_external.string()
+});
+var roadmapDetailSchema = roadmapSchema.extend({
+  prd: prdSchema.nullable(),
+  wireframes: exports_external.array(wireframeSchema),
+  brainstormMedia: exports_external.array(brainstormMediaSchema),
+  brainstormNotes: exports_external.string().nullable(),
+  featureLinks: exports_external.array(featureLinkSchema)
+});
+var roadmapListSchema = exports_external.array(roadmapSchema);
+// ../../packages/shared/src/schemas/scenario.ts
+var scenarioSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  title: exports_external.string().min(1),
+  given: exports_external.string().nullable(),
+  when: exports_external.string().nullable(),
+  then: exports_external.string().nullable(),
+  order: exports_external.number().int(),
+  createdAt: exports_external.string().datetime(),
+  updatedAt: exports_external.string().datetime()
+});
+var createScenarioSchema = exports_external.object({
+  title: exports_external.string().min(1),
+  given: exports_external.string().nullable().optional(),
+  when: exports_external.string().nullable().optional(),
+  then: exports_external.string().nullable().optional(),
+  roadmapId: exports_external.string().uuid()
+});
+var updateScenarioSchema = exports_external.object({
+  title: exports_external.string().min(1).optional(),
+  given: exports_external.string().nullable().optional(),
+  when: exports_external.string().nullable().optional(),
+  then: exports_external.string().nullable().optional(),
+  order: exports_external.number().int().optional()
+});
+var scenarioListSchema = exports_external.array(scenarioSchema);
 // src/auth.ts
 function getCredentials() {
   const apiKey = process.env.ROADMAPS_API_KEY;
@@ -23541,6 +23873,11 @@ class ApiClient {
     });
     return response.data;
   }
+  async deleteRoadmap(id) {
+    await this.request(`/v1/roadmaps/${id}`, {
+      method: "DELETE"
+    });
+  }
   async savePrd(roadmapId, data) {
     const response = await this.request(`/v1/roadmaps/${roadmapId}/prd`, {
       method: "POST",
@@ -23563,6 +23900,18 @@ class ApiClient {
     });
     return response.data;
   }
+  async updateFeature(id, data) {
+    const response = await this.request(`/v1/features/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteFeature(id) {
+    await this.request(`/v1/features/${id}`, {
+      method: "DELETE"
+    });
+  }
   async addFeatureOutcome(featureId, content) {
     await this.request(`/v1/features/${featureId}/outcomes`, {
       method: "POST",
@@ -23590,14 +23939,99 @@ class ApiClient {
     });
     return response.data;
   }
+  async updateIdea(id, data) {
+    const response = await this.request(`/v1/ideas/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteIdea(id) {
+    await this.request(`/v1/ideas/${id}`, {
+      method: "DELETE"
+    });
+  }
   async listProducts() {
     const response = await this.request("/v1/products");
     return response.data;
   }
+  async createProduct(data) {
+    const response = await this.request("/v1/products", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateProduct(id, data) {
+    const response = await this.request(`/v1/products/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteProduct(id) {
+    const response = await this.request(`/v1/products/${id}`, {
+      method: "DELETE"
+    });
+    return response.data;
+  }
   async listAudiences() {
     const response = await this.request("/v1/audiences");
     return response.data;
   }
+  async createAudience(data) {
+    const response = await this.request("/v1/audiences", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateAudience(id, data) {
+    const response = await this.request(`/v1/audiences/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteAudience(id) {
+    await this.request(`/v1/audiences/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async getStrategy() {
+    const response = await this.request("/v1/strategy");
+    return response.data;
+  }
+  async updateStrategy(data) {
+    const response = await this.request("/v1/strategy", {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async listScenarios() {
+    const response = await this.request("/v1/scenarios");
+    return response.data;
+  }
+  async createScenario(data) {
+    const response = await this.request("/v1/scenarios", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async updateScenario(id, data) {
+    const response = await this.request(`/v1/scenarios/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    return response.data;
+  }
+  async deleteScenario(id) {
+    await this.request(`/v1/scenarios/${id}`, {
+      method: "DELETE"
+    });
+  }
 }
 var client = null;
 function getApiClient() {
@@ -23615,27 +24049,49 @@ function registerAllTools(server) {
   registerGetFeature(server);
   registerSearchIdeas(server);
   registerGetContext(server);
+  registerGetStrategy(server);
+  registerListScenarios(server);
   registerCaptureIdea(server);
   registerCreateRoadmapItem(server);
   registerUpdateRoadmapItem(server);
+  registerDeleteRoadmapItem(server);
   registerAddFeature(server);
+  registerUpdateFeature(server);
+  registerDeleteFeature(server);
   registerSavePrd(server);
   registerUpdateBrainstormNotes(server);
+  registerGetIdea(server);
+  registerUpdateIdea(server);
+  registerDeleteIdea(server);
+  registerUpdateStrategy(server);
+  registerCreateScenario(server);
+  registerUpdateScenario(server);
+  registerDeleteScenario(server);
+  registerCreateProduct(server);
+  registerUpdateProduct(server);
+  registerDeleteProduct(server);
+  registerCreateAudience(server);
+  registerUpdateAudience(server);
+  registerDeleteAudience(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: exports_external.string().optional().describe("Search query to match against title or description"),
-      status: exports_external.enum(["brainstorming", "ready", "in_progress", "shipped", "wont_do"]).optional().describe("Filter by status"),
-      horizon: exports_external.enum(["now", "next", "later", "none"]).optional().describe("Filter by planning horizon")
-    }
-  }, async ({ query, status, horizon }) => {
+      status: roadmapStatusSchema.optional().describe("Filter by status"),
+      horizon: horizonSchema.optional().describe("Filter by planning horizon")
+    }
+  }, async ({
+    query,
+    status,
+    horizon
+  }) => {
     const client2 = getApiClient();
     let roadmaps = await client2.listRoadmaps();
     if (query) {
       const q = query.toLowerCase();
-      roadmaps = roadmaps.filter((r) => r.title.toLowerCase().includes(q) || r.description?.toLowerCase().includes(q));
+      roadmaps = roadmaps.filter((r) => r.title.toLowerCase().includes(q));
     }
     if (status) {
       roadmaps = roadmaps.filter((r) => r.status === status);
@@ -23650,10 +24106,8 @@ function registerSearchRoadmaps(server) {
           text: JSON.stringify(roadmaps.map((r) => ({
             id: r.id,
             title: r.title,
-            description: r.description,
             status: r.status,
-            horizon: r.horizon,
-            commitment: r.commitment
+            horizon: r.horizon
           })), null, 2)
         }
       ]
@@ -23668,38 +24122,36 @@ function registerGetRoadmap(server) {
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
-    const roadmap = await client2.getRoadmap(id);
+    const roadmap2 = await client2.getRoadmap(id);
     return {
       content: [
         {
           type: "text",
           text: JSON.stringify({
-            id: roadmap.id,
-            title: roadmap.title,
-            description: roadmap.description,
-            status: roadmap.status,
-            horizon: roadmap.horizon,
-            commitment: roadmap.commitment,
-            prdContent: roadmap.prdContent,
-            brainstormNotes: roadmap.brainstormNotes,
-            wireframes: roadmap.wireframes?.map((w) => ({
+            id: roadmap2.id,
+            title: roadmap2.title,
+            status: roadmap2.status,
+            horizon: roadmap2.horizon,
+            prd: roadmap2.prd,
+            brainstormNotes: roadmap2.brainstormNotes,
+            wireframes: roadmap2.wireframes?.map((w) => ({
               id: w.id,
               imageUrl: w.imageUrl,
               description: w.description
             })),
-            brainstormMedia: roadmap.brainstormMedia?.map((m) => ({
+            brainstormMedia: roadmap2.brainstormMedia?.map((m) => ({
               id: m.id,
-              mediaUrl: m.mediaUrl,
-              mediaType: m.mediaType,
+              url: m.mediaUrl,
+              type: m.mediaType,
               description: m.description
             })),
-            features: roadmap.features,
-            scenarios: roadmap.scenarios?.map((s) => ({
-              id: s.id,
-              content: s.content
+            featureLinks: roadmap2.featureLinks?.map((l) => ({
+              id: l.id,
+              featureId: l.featureId,
+              featureName: l.feature.name,
+              featureType: l.feature.type
             })),
-            createdAt: roadmap.createdAt,
-            updatedAt: roadmap.updatedAt
+            createdAt: roadmap2.createdAt
           }, null, 2)
         }
       ]
@@ -23710,15 +24162,15 @@ 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: exports_external.string().optional().describe("Search query to match against name or description"),
-      type: exports_external.enum(["feature", "area"]).optional().describe("Filter by type (feature or area)")
+      query: exports_external.string().optional().describe("Search query to match against name"),
+      type: featureTypeSchema.optional().describe("Filter by type (feature or area)")
     }
   }, async ({ query, type }) => {
     const client2 = getApiClient();
     let features = await client2.listFeatures();
     if (query) {
       const q = query.toLowerCase();
-      features = features.filter((f) => f.name.toLowerCase().includes(q) || f.description?.toLowerCase().includes(q));
+      features = features.filter((f) => f.name.toLowerCase().includes(q));
     }
     if (type) {
       features = features.filter((f) => f.type === type);
@@ -23730,7 +24182,6 @@ function registerSearchFeatures(server) {
           text: JSON.stringify(features.map((f) => ({
             id: f.id,
             name: f.name,
-            description: f.description,
             type: f.type,
             parentId: f.parentId
           })), null, 2)
@@ -23747,29 +24198,31 @@ function registerGetFeature(server) {
     }
   }, async ({ id }) => {
     const client2 = getApiClient();
-    const feature = await client2.getFeature(id);
+    const feature2 = await client2.getFeature(id);
     return {
       content: [
         {
           type: "text",
           text: JSON.stringify({
-            id: feature.id,
-            name: feature.name,
-            description: feature.description,
-            type: feature.type,
-            parentId: feature.parentId,
-            outcomes: feature.outcomes?.map((o) => ({
+            id: feature2.id,
+            name: feature2.name,
+            type: feature2.type,
+            parentId: feature2.parentId,
+            outcomes: feature2.outcomes?.map((o) => ({
               id: o.id,
-              content: o.content
+              description: o.description
             })),
-            children: feature.children?.map((c) => ({
+            children: feature2.children?.map((c) => ({
               id: c.id,
               name: c.name,
               type: c.type
             })),
-            roadmapItems: feature.roadmapItems,
-            createdAt: feature.createdAt,
-            updatedAt: feature.updatedAt
+            roadmapLinks: feature2.roadmapLinks?.map((l) => ({
+              id: l.id,
+              roadmapId: l.roadmapId,
+              roadmapTitle: l.roadmap.title
+            })),
+            createdAt: feature2.createdAt
           }, null, 2)
         }
       ]
@@ -23781,7 +24234,7 @@ function registerSearchIdeas(server) {
     description: "Search for ideas by title or status. Returns a list of matching ideas with basic info.",
     inputSchema: {
       query: exports_external.string().optional().describe("Search query to match against title or description"),
-      status: exports_external.enum(["new", "reviewing", "accepted", "rejected"]).optional().describe("Filter by status")
+      status: ideaStatusSchema.optional().describe("Filter by status")
     }
   }, async ({ query, status }) => {
     const client2 = getApiClient();
@@ -23811,29 +24264,67 @@ function registerSearchIdeas(server) {
 }
 function registerGetContext(server) {
   server.registerTool("get_context", {
-    description: "Get organizational context including products and target audiences. Useful for understanding what the company builds and who they serve.",
+    description: `Get comprehensive organizational context in a single call. Returns:
+- Strategy: Vision and mission statements that guide product direction
+- Products: What the organization builds (brands, products, apps, services) with hierarchy
+- Audiences: Who the product serves (stakeholders and user personas) with their preferences
+- Scenarios: User workflows and how they accomplish goals
+- Roadmap Summary: Count of items by status and horizon for planning overview
+
+Use this as your FIRST call when starting work on a roadmap to understand the full context.`,
     inputSchema: {}
   }, async () => {
     const client2 = getApiClient();
-    const [products, audiences] = await Promise.all([
+    const [strategy, products, audiences, scenarios, roadmaps] = await Promise.all([
+      client2.getStrategy(),
       client2.listProducts(),
-      client2.listAudiences()
+      client2.listAudiences(),
+      client2.listScenarios(),
+      client2.listRoadmaps()
     ]);
+    const statusCounts = {};
+    const horizonCounts = {};
+    for (const r of roadmaps) {
+      const status = r.status ?? "unknown";
+      const horizon = r.horizon ?? "unknown";
+      statusCounts[status] = (statusCounts[status] || 0) + 1;
+      horizonCounts[horizon] = (horizonCounts[horizon] || 0) + 1;
+    }
     return {
       content: [
         {
           type: "text",
           text: JSON.stringify({
+            strategy: {
+              vision: strategy.vision,
+              mission: strategy.mission
+            },
             products: products.map((p) => ({
               id: p.id,
+              type: p.type,
               name: p.name,
-              description: p.description
+              parentId: p.parentId
             })),
             audiences: audiences.map((a) => ({
               id: a.id,
-              name: a.name,
-              description: a.description
-            }))
+              type: a.type,
+              role: a.role,
+              likes: a.likes,
+              dislikes: a.dislikes,
+              priorities: a.priorities
+            })),
+            scenarios: scenarios.map((s) => ({
+              id: s.id,
+              title: s.title,
+              given: s.given,
+              when: s.when,
+              then: s.then
+            })),
+            roadmapSummary: {
+              total: roadmaps.length,
+              byStatus: statusCounts,
+              byHorizon: horizonCounts
+            }
           }, null, 2)
         }
       ]
@@ -23848,12 +24339,16 @@ function registerCaptureIdea(server) {
       description: exports_external.string().optional().describe("Detailed description of the idea"),
       source: exports_external.string().optional().describe('Source of the idea (defaults to "claude-code")')
     }
-  }, async ({ title, description, source }) => {
+  }, async ({
+    title,
+    description,
+    source
+  }) => {
     const client2 = getApiClient();
-    const idea = await client2.createIdea({
+    const idea2 = await client2.createIdea({
       title,
-      description,
-      source: source || "claude-code",
+      description: description ?? null,
+      source: source ?? "claude-code",
       status: "new"
     });
     return {
@@ -23863,11 +24358,11 @@ function registerCaptureIdea(server) {
           text: JSON.stringify({
             success: true,
             idea: {
-              id: idea.id,
-              title: idea.title,
-              description: idea.description,
-              status: idea.status,
-              source: idea.source
+              id: idea2.id,
+              title: idea2.title,
+              description: idea2.description,
+              status: idea2.status,
+              source: idea2.source
             }
           }, null, 2)
         }
@@ -23880,23 +24375,19 @@ function registerCreateRoadmapItem(server) {
     description: "Create a new roadmap item. Use this to add planned work to the roadmap.",
     inputSchema: {
       title: exports_external.string().describe("Title of the roadmap item"),
-      status: exports_external.enum([
-        "not_started",
-        "planning",
-        "needs_review",
-        "approved",
-        "in_progress",
-        "done",
-        "cancelled"
-      ]).optional().describe('Status (defaults to "not_started")'),
-      horizon: exports_external.enum(["inbox", "now", "next", "later", "someday", "icebox", "done", "cancelled"]).optional().describe('Planning horizon (defaults to "inbox")')
-    }
-  }, async ({ title, status, horizon }) => {
+      status: roadmapStatusSchema.optional().describe('Status (defaults to "not_started")'),
+      horizon: horizonSchema.optional().describe('Planning horizon (defaults to "inbox")')
+    }
+  }, async ({
+    title,
+    status,
+    horizon
+  }) => {
     const client2 = getApiClient();
-    const roadmap = await client2.createRoadmap({
+    const roadmap2 = await client2.createRoadmap({
       title,
-      status: status || "not_started",
-      horizon: horizon || "inbox"
+      status: status ?? "not_started",
+      horizon: horizon ?? "inbox"
     });
     return {
       content: [
@@ -23905,10 +24396,10 @@ function registerCreateRoadmapItem(server) {
           text: JSON.stringify({
             success: true,
             roadmap: {
-              id: roadmap.id,
-              title: roadmap.title,
-              status: roadmap.status,
-              horizon: roadmap.horizon
+              id: roadmap2.id,
+              title: roadmap2.title,
+              status: roadmap2.status,
+              horizon: roadmap2.horizon
             }
           }, null, 2)
         }
@@ -23922,18 +24413,15 @@ function registerUpdateRoadmapItem(server) {
     inputSchema: {
       id: exports_external.string().describe("The UUID of the roadmap item to update"),
       title: exports_external.string().optional().describe("New title"),
-      status: exports_external.enum([
-        "not_started",
-        "planning",
-        "needs_review",
-        "approved",
-        "in_progress",
-        "done",
-        "cancelled"
-      ]).optional().describe("New status"),
-      horizon: exports_external.enum(["inbox", "now", "next", "later", "someday", "icebox", "done", "cancelled"]).optional().describe("New planning horizon")
-    }
-  }, async ({ id, title, status, horizon }) => {
+      status: roadmapStatusSchema.optional().describe("New status"),
+      horizon: horizonSchema.optional().describe("New planning horizon")
+    }
+  }, async ({
+    id,
+    title,
+    status,
+    horizon
+  }) => {
     const client2 = getApiClient();
     const updates = {};
     if (title !== undefined)
@@ -23942,7 +24430,7 @@ function registerUpdateRoadmapItem(server) {
       updates.status = status;
     if (horizon !== undefined)
       updates.horizon = horizon;
-    const roadmap = await client2.updateRoadmap(id, updates);
+    const roadmap2 = await client2.updateRoadmap(id, updates);
     return {
       content: [
         {
@@ -23950,10 +24438,10 @@ function registerUpdateRoadmapItem(server) {
           text: JSON.stringify({
             success: true,
             roadmap: {
-              id: roadmap.id,
-              title: roadmap.title,
-              status: roadmap.status,
-              horizon: roadmap.horizon
+              id: roadmap2.id,
+              title: roadmap2.title,
+              status: roadmap2.status,
+              horizon: roadmap2.horizon
             }
           }, null, 2)
         }
@@ -23967,26 +24455,33 @@ function registerAddFeature(server) {
     inputSchema: {
       name: exports_external.string().describe("Name of the feature"),
       description: exports_external.string().optional().describe("Description of the feature"),
-      type: exports_external.enum(["feature", "area"]).optional().describe('Type - "feature" for specific functionality, "area" for grouping (defaults to "feature")'),
+      type: featureTypeSchema.optional().describe('Type - "feature" for specific functionality, "area" for grouping (defaults to "feature")'),
       parentId: exports_external.string().optional().describe("UUID of parent feature/area to nest under"),
       outcomes: exports_external.array(exports_external.string()).optional().describe("List of expected outcomes for this feature"),
       linkToRoadmapId: exports_external.string().optional().describe("UUID of roadmap item to link this feature to")
     }
-  }, async ({ name, description, type, parentId, outcomes, linkToRoadmapId }) => {
+  }, async ({
+    name,
+    description,
+    type,
+    parentId,
+    outcomes,
+    linkToRoadmapId
+  }) => {
     const client2 = getApiClient();
-    const feature = await client2.createFeature({
+    const feature2 = await client2.createFeature({
       name,
-      description,
-      type: type || "feature",
-      parentId
+      description: description ?? null,
+      type: type ?? "feature",
+      parentId: parentId ?? null
     });
     if (outcomes && outcomes.length > 0) {
       for (const outcome of outcomes) {
-        await client2.addFeatureOutcome(feature.id, outcome);
+        await client2.addFeatureOutcome(feature2.id, outcome);
       }
     }
     if (linkToRoadmapId) {
-      await client2.linkFeatureToRoadmap(feature.id, linkToRoadmapId);
+      await client2.linkFeatureToRoadmap(feature2.id, linkToRoadmapId);
     }
     return {
       content: [
@@ -23995,13 +24490,12 @@ function registerAddFeature(server) {
           text: JSON.stringify({
             success: true,
             feature: {
-              id: feature.id,
-              name: feature.name,
-              description: feature.description,
-              type: feature.type,
-              parentId: feature.parentId,
-              outcomesAdded: outcomes?.length || 0,
-              linkedToRoadmap: linkToRoadmapId || null
+              id: feature2.id,
+              name: feature2.name,
+              type: feature2.type,
+              parentId: feature2.parentId,
+              outcomesAdded: outcomes?.length ?? 0,
+              linkedToRoadmap: linkToRoadmapId ?? null
             }
           }, null, 2)
         }
@@ -24018,13 +24512,17 @@ function registerSavePrd(server) {
       why: exports_external.string().nullable().describe("Why this is being built - the business justification"),
       outcomes: exports_external.array(exports_external.string()).optional().describe("List of expected outcomes/success criteria")
     }
-  }, async ({ roadmapId, what, why, outcomes }) => {
+  }, async ({
+    roadmapId,
+    what,
+    why,
+    outcomes
+  }) => {
     const client2 = getApiClient();
     const prd = await client2.savePrd(roadmapId, {
-      what: what || null,
-      why: why || null,
-      status: "draft",
-      outcomes: (outcomes || []).map((desc, idx) => ({ description: desc, order: idx }))
+      what: what ?? null,
+      why: why ?? null,
+      outcomes: (outcomes ?? []).map((desc) => ({ description: desc }))
     });
     return {
       content: [
@@ -24054,7 +24552,7 @@ function registerUpdateBrainstormNotes(server) {
     }
   }, async ({ roadmapId, notes }) => {
     const client2 = getApiClient();
-    const roadmap = await client2.updateRoadmap(roadmapId, {
+    const roadmap2 = await client2.updateRoadmap(roadmapId, {
       brainstormNotes: notes
     });
     return {
@@ -24064,9 +24562,430 @@ function registerUpdateBrainstormNotes(server) {
           text: JSON.stringify({
             success: true,
             roadmap: {
-              id: roadmap.id,
-              title: roadmap.title,
-              brainstormNotesLength: roadmap.brainstormNotes?.length || 0
+              id: roadmap2.id,
+              title: roadmap2.title,
+              notesUpdated: true,
+              notesLength: notes.length
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+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: exports_external.string().describe("The UUID of the roadmap item to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteRoadmap(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: `Roadmap item ${id} has been deleted`
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateFeature(server) {
+  server.registerTool("update_feature", {
+    description: "Update an existing feature. Can update name, type, or parent.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the feature to update"),
+      name: exports_external.string().optional().describe("New name for the feature"),
+      type: featureTypeSchema.optional().describe('New type - "feature" or "area"'),
+      parentId: exports_external.string().nullable().optional().describe("New parent feature/area UUID, or null to move to root")
+    }
+  }, async ({
+    id,
+    name,
+    type,
+    parentId
+  }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (name !== undefined)
+      updates.name = name;
+    if (type !== undefined)
+      updates.type = type;
+    if (parentId !== undefined)
+      updates.parentId = parentId;
+    const feature2 = await client2.updateFeature(id, updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            feature: {
+              id: feature2.id,
+              name: feature2.name,
+              type: feature2.type,
+              parentId: feature2.parentId
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteFeature(server) {
+  server.registerTool("delete_feature", {
+    description: "Delete a feature. This is a soft delete that also deletes all child features.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the feature to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteFeature(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: `Feature ${id} has been deleted`
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetIdea(server) {
+  server.registerTool("get_idea", {
+    description: "Get full details of a single idea by ID.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the idea")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    const idea2 = await client2.getIdea(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: idea2.id,
+            title: idea2.title,
+            description: idea2.description,
+            status: idea2.status,
+            source: idea2.source,
+            submittedBy: idea2.submittedBy,
+            value: idea2.value,
+            effort: idea2.effort,
+            createdAt: idea2.createdAt
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateIdea(server) {
+  server.registerTool("update_idea", {
+    description: "Update an existing idea. Can update title, description, status, value, or effort.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the idea to update"),
+      title: exports_external.string().optional().describe("New title"),
+      description: exports_external.string().nullable().optional().describe("New description"),
+      status: ideaStatusSchema.optional().describe("New status"),
+      value: exports_external.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated value"),
+      effort: exports_external.enum(["xs", "s", "m", "l", "xl"]).nullable().optional().describe("Estimated effort")
+    }
+  }, async ({
+    id,
+    title,
+    description,
+    status,
+    value,
+    effort
+  }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (title !== undefined)
+      updates.title = title;
+    if (description !== undefined)
+      updates.description = description;
+    if (status !== undefined)
+      updates.status = status;
+    if (value !== undefined)
+      updates.value = value;
+    if (effort !== undefined)
+      updates.effort = effort;
+    const idea2 = await client2.updateIdea(id, updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            idea: {
+              id: idea2.id,
+              title: idea2.title,
+              description: idea2.description,
+              status: idea2.status,
+              value: idea2.value,
+              effort: idea2.effort
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteIdea(server) {
+  server.registerTool("delete_idea", {
+    description: "Delete an idea. This is a soft delete.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the idea to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteIdea(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: `Idea ${id} has been deleted`
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerGetStrategy(server) {
+  server.registerTool("get_strategy", {
+    description: "Get the organization strategy including vision and mission statements. Use this to understand the high-level direction and purpose of the product.",
+    inputSchema: {}
+  }, async () => {
+    const client2 = getApiClient();
+    const strategy = await client2.getStrategy();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(strategy, null, 2)
+        }
+      ]
+    };
+  });
+}
+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: exports_external.string().nullable().optional().describe("The vision statement - where the product is headed"),
+      mission: exports_external.string().nullable().optional().describe("The mission statement - why the product exists")
+    }
+  }, async ({ vision, mission }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (vision !== undefined)
+      updates.vision = vision;
+    if (mission !== undefined)
+      updates.mission = mission;
+    const strategy = await client2.updateStrategy(updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, strategy }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerListScenarios(server) {
+  server.registerTool("list_scenarios", {
+    description: "List all user scenarios. Scenarios describe how users interact with the product to accomplish goals using Given/When/Then format.",
+    inputSchema: {}
+  }, async () => {
+    const client2 = getApiClient();
+    const scenarios = await client2.listScenarios();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(scenarios.map((s) => ({
+            id: s.id,
+            title: s.title,
+            given: s.given,
+            when: s.when,
+            then: s.then,
+            order: s.order
+          })), null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerCreateScenario(server) {
+  server.registerTool("create_scenario", {
+    description: "Create a new user scenario. Scenarios describe user workflows and how they accomplish goals.",
+    inputSchema: {
+      title: exports_external.string().describe('Title of the scenario (e.g., "User creates their first roadmap")'),
+      description: exports_external.string().nullable().optional().describe("Detailed description of the scenario workflow")
+    }
+  }, async ({ title, description }) => {
+    const client2 = getApiClient();
+    const scenario2 = await client2.createScenario({
+      title,
+      description: description ?? null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            scenario: {
+              id: scenario2.id,
+              title: scenario2.title,
+              description: scenario2.description ?? scenario2.given
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateScenario(server) {
+  server.registerTool("update_scenario", {
+    description: "Update an existing scenario.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the scenario to update"),
+      title: exports_external.string().optional().describe("New title"),
+      description: exports_external.string().nullable().optional().describe("New description")
+    }
+  }, async ({
+    id,
+    title,
+    description
+  }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (title !== undefined)
+      updates.title = title;
+    if (description !== undefined)
+      updates.description = description;
+    const scenario2 = await client2.updateScenario(id, updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            scenario: {
+              id: scenario2.id,
+              title: scenario2.title,
+              description: scenario2.description ?? scenario2.given
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteScenario(server) {
+  server.registerTool("delete_scenario", {
+    description: "Delete a scenario. This is a soft delete.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the scenario to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteScenario(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, message: `Scenario ${id} has been deleted` }, null, 2)
+        }
+      ]
+    };
+  });
+}
+var productTypeSchema2 = exports_external.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: exports_external.string().describe("Name of the product"),
+      parentId: exports_external.string().nullable().optional().describe("UUID of parent product to nest under")
+    }
+  }, async ({
+    type,
+    name,
+    parentId
+  }) => {
+    const client2 = getApiClient();
+    const product2 = await client2.createProduct({
+      type,
+      name,
+      parentId: parentId ?? null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            product: {
+              id: product2.id,
+              type: product2.type,
+              name: product2.name,
+              parentId: product2.parentId
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateProduct(server) {
+  server.registerTool("update_product", {
+    description: "Update an existing product.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the product to update"),
+      name: exports_external.string().optional().describe("New name"),
+      parentId: exports_external.string().nullable().optional().describe("New parent product UUID, or null to move to root")
+    }
+  }, async ({ id, name, parentId }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (name !== undefined)
+      updates.name = name;
+    if (parentId !== undefined)
+      updates.parentId = parentId;
+    const product2 = await client2.updateProduct(id, updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            product: {
+              id: product2.id,
+              type: product2.type,
+              name: product2.name,
+              parentId: product2.parentId
             }
           }, null, 2)
         }
@@ -24074,6 +24993,146 @@ function registerUpdateBrainstormNotes(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: exports_external.string().describe("The UUID of the product to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    const result = await client2.deleteProduct(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: `Product and ${result.deletedCount - 1} children have been deleted`,
+            deletedCount: result.deletedCount
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+var audienceTypeSchema2 = exports_external.enum(["stakeholder", "user_persona"]);
+function registerCreateAudience(server) {
+  server.registerTool("create_audience", {
+    description: "Create a new audience member - either a stakeholder or user persona. Audiences represent who the product serves.",
+    inputSchema: {
+      type: audienceTypeSchema2.describe("Type of audience - stakeholder or user_persona"),
+      role: exports_external.string().describe('Role or title of the audience (e.g., "Product Manager", "End User")'),
+      likes: exports_external.string().nullable().optional().describe("What this audience likes or values"),
+      dislikes: exports_external.string().nullable().optional().describe("What this audience dislikes or avoids"),
+      priorities: exports_external.string().nullable().optional().describe("Key priorities for this audience")
+    }
+  }, async ({
+    type,
+    role,
+    likes,
+    dislikes,
+    priorities
+  }) => {
+    const client2 = getApiClient();
+    const audience2 = await client2.createAudience({
+      type,
+      role,
+      likes: likes ?? null,
+      dislikes: dislikes ?? null,
+      priorities: priorities ?? null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            audience: {
+              id: audience2.id,
+              type: audience2.type,
+              role: audience2.role,
+              likes: audience2.likes,
+              dislikes: audience2.dislikes,
+              priorities: audience2.priorities
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerUpdateAudience(server) {
+  server.registerTool("update_audience", {
+    description: "Update an existing audience member.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the audience to update"),
+      type: audienceTypeSchema2.optional().describe("New type"),
+      role: exports_external.string().optional().describe("New role"),
+      likes: exports_external.string().nullable().optional().describe("New likes"),
+      dislikes: exports_external.string().nullable().optional().describe("New dislikes"),
+      priorities: exports_external.string().nullable().optional().describe("New priorities")
+    }
+  }, async ({
+    id,
+    type,
+    role,
+    likes,
+    dislikes,
+    priorities
+  }) => {
+    const client2 = getApiClient();
+    const updates = {};
+    if (type !== undefined)
+      updates.type = type;
+    if (role !== undefined)
+      updates.role = role;
+    if (likes !== undefined)
+      updates.likes = likes;
+    if (dislikes !== undefined)
+      updates.dislikes = dislikes;
+    if (priorities !== undefined)
+      updates.priorities = priorities;
+    const audience2 = await client2.updateAudience(id, updates);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            audience: {
+              id: audience2.id,
+              type: audience2.type,
+              role: audience2.role,
+              likes: audience2.likes,
+              dislikes: audience2.dislikes,
+              priorities: audience2.priorities
+            }
+          }, null, 2)
+        }
+      ]
+    };
+  });
+}
+function registerDeleteAudience(server) {
+  server.registerTool("delete_audience", {
+    description: "Delete an audience member. This is a soft delete.",
+    inputSchema: {
+      id: exports_external.string().describe("The UUID of the audience to delete")
+    }
+  }, async ({ id }) => {
+    const client2 = getApiClient();
+    await client2.deleteAudience(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, message: `Audience ${id} has been deleted` }, null, 2)
+        }
+      ]
+    };
+  });
+}
 
 // src/index.ts
 async function main() {