@burdenoff/mcp-libs 2026.628.1 → 2026.629.1

package/dist/modules/coolandlovely/index.js

@@ -0,0 +1,1874 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/coolandlovely/operations.ts
+var BRAND_FIELDS = `
+  id name handle tagline bio status aesthetics tags isFeatured websiteUrl
+  workspaceId createdAt updatedAt logo { id } cover { id }
+`;
+var COLLECTION_FIELDS = `
+  id name description brandId season status tags publishAt endAt
+  workspaceId createdAt updatedAt cover { id }
+`;
+var STYLE_ITEM_FIELDS = `
+  id name description brandId collectionId category status sku price currency
+  colours materials sizes tags workspaceId createdAt updatedAt image { id }
+`;
+var LOOK_ITEM_FIELDS = `
+  id lookId styleItemId position styling workspaceId createdAt updatedAt
+`;
+var LOOK_FIELDS = `
+  id title caption authorId occasion visibility tags isFeatured likeCount
+  saveCount collaborationId publishedAt workspaceId createdAt updatedAt
+  image { id } items { ${LOOK_ITEM_FIELDS} }
+`;
+var LOOKBOOK_ENTRY_FIELDS = `
+  id lookbookId lookId styleItemId position note workspaceId createdAt updatedAt
+`;
+var LOOKBOOK_FIELDS = `
+  id name description ownerId profileId visibility tags workspaceId
+  createdAt updatedAt cover { id } entries { ${LOOKBOOK_ENTRY_FIELDS} }
+`;
+var COLLABORATION_FIELDS = `
+  id title brief brandId creatorId collectionId role status compensation currency
+  tags startDate endDate publishedAt workspaceId createdAt updatedAt
+`;
+var WARDROBE_ITEM_FIELDS = `
+  id name brandName category colour size source notes profileId styleItemId tags
+  timesWorn lastWornAt workspaceId createdAt updatedAt image { id }
+`;
+var STYLE_PROFILE_FIELDS = `
+  id ownerId displayName bio palette stylePreferences favouriteBrands sizes
+  visibility workspaceId createdAt updatedAt
+`;
+var GET_BRAND = `
+  query CoolandlovelyGetBrand($id: ID!) {
+    cooBrand(id: $id) {
+      ${BRAND_FIELDS}
+      collections { id name status season }
+      items { id name status price currency }
+    }
+  }
+`;
+var LIST_BRANDS = `
+  query CoolandlovelyListBrands(
+    $featured: Boolean
+    $status: CooBrandStatus
+    $pagination: PaginationInput
+  ) {
+    cooListBrands(featured: $featured, status: $status, pagination: $pagination) {
+      items { ${BRAND_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_BRAND = `
+  mutation CoolandlovelyCreateBrand($input: CooCreateBrandInput!) {
+    cooCreateBrand(input: $input) {
+      ${BRAND_FIELDS}
+    }
+  }
+`;
+var UPDATE_BRAND = `
+  mutation CoolandlovelyUpdateBrand($id: ID!, $input: CooUpdateBrandInput!) {
+    cooUpdateBrand(id: $id, input: $input) {
+      ${BRAND_FIELDS}
+    }
+  }
+`;
+var TRANSITION_BRAND = `
+  mutation CoolandlovelyTransitionBrand($id: ID!, $status: CooBrandStatus!) {
+    cooTransitionBrand(id: $id, status: $status) {
+      ${BRAND_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_BRAND = `
+  mutation CoolandlovelyArchiveBrand($id: ID!) {
+    cooArchiveBrand(id: $id)
+  }
+`;
+var GET_COLLECTION = `
+  query CoolandlovelyGetCollection($id: ID!) {
+    cooCollection(id: $id) {
+      ${COLLECTION_FIELDS}
+      items { id name status price currency }
+    }
+  }
+`;
+var LIST_COLLECTIONS = `
+  query CoolandlovelyListCollections($brandId: ID, $status: CooCollectionStatus) {
+    cooListCollections(brandId: $brandId, status: $status) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var CREATE_COLLECTION = `
+  mutation CoolandlovelyCreateCollection($input: CooCreateCollectionInput!) {
+    cooCreateCollection(input: $input) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var UPDATE_COLLECTION = `
+  mutation CoolandlovelyUpdateCollection($id: ID!, $input: CooUpdateCollectionInput!) {
+    cooUpdateCollection(id: $id, input: $input) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var PUBLISH_COLLECTION = `
+  mutation CoolandlovelyPublishCollection($id: ID!) {
+    cooPublishCollection(id: $id) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var GET_STYLE_ITEM = `
+  query CoolandlovelyGetStyleItem($id: ID!) {
+    cooStyleItem(id: $id) {
+      ${STYLE_ITEM_FIELDS}
+    }
+  }
+`;
+var LIST_STYLE_ITEMS = `
+  query CoolandlovelyListStyleItems(
+    $brandId: ID
+    $category: CooStyleCategory
+    $collectionId: ID
+    $status: CooStyleItemStatus
+    $pagination: PaginationInput
+  ) {
+    cooListStyleItems(
+      brandId: $brandId
+      category: $category
+      collectionId: $collectionId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${STYLE_ITEM_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_STYLE_ITEM = `
+  mutation CoolandlovelyCreateStyleItem($input: CooCreateStyleItemInput!) {
+    cooCreateStyleItem(input: $input) {
+      ${STYLE_ITEM_FIELDS}
+    }
+  }
+`;
+var UPDATE_STYLE_ITEM = `
+  mutation CoolandlovelyUpdateStyleItem($id: ID!, $input: CooUpdateStyleItemInput!) {
+    cooUpdateStyleItem(id: $id, input: $input) {
+      ${STYLE_ITEM_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_STYLE_ITEM = `
+  mutation CoolandlovelyArchiveStyleItem($id: ID!) {
+    cooArchiveStyleItem(id: $id)
+  }
+`;
+var GET_LOOK = `
+  query CoolandlovelyGetLook($id: ID!) {
+    cooLook(id: $id) {
+      ${LOOK_FIELDS}
+    }
+  }
+`;
+var LIST_LOOKS = `
+  query CoolandlovelyListLooks(
+    $authorId: ID
+    $featured: Boolean
+    $occasion: CooLookOccasion
+    $pagination: PaginationInput
+  ) {
+    cooListLooks(
+      authorId: $authorId
+      featured: $featured
+      occasion: $occasion
+      pagination: $pagination
+    ) {
+      items { ${LOOK_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_LOOK = `
+  mutation CoolandlovelyCreateLook($input: CooCreateLookInput!) {
+    cooCreateLook(input: $input) {
+      ${LOOK_FIELDS}
+    }
+  }
+`;
+var UPDATE_LOOK = `
+  mutation CoolandlovelyUpdateLook($id: ID!, $input: CooUpdateLookInput!) {
+    cooUpdateLook(id: $id, input: $input) {
+      ${LOOK_FIELDS}
+    }
+  }
+`;
+var PUBLISH_LOOK = `
+  mutation CoolandlovelyPublishLook($id: ID!) {
+    cooPublishLook(id: $id) {
+      ${LOOK_FIELDS}
+    }
+  }
+`;
+var LIKE_LOOK = `
+  mutation CoolandlovelyLikeLook($id: ID!) {
+    cooLikeLook(id: $id) {
+      ${LOOK_FIELDS}
+    }
+  }
+`;
+var DELETE_LOOK = `
+  mutation CoolandlovelyDeleteLook($id: ID!) {
+    cooDeleteLook(id: $id)
+  }
+`;
+var GET_LOOKBOOK = `
+  query CoolandlovelyGetLookbook($id: ID!) {
+    cooLookbook(id: $id) {
+      ${LOOKBOOK_FIELDS}
+    }
+  }
+`;
+var LIST_LOOKBOOKS = `
+  query CoolandlovelyListLookbooks($ownerId: ID) {
+    cooListLookbooks(ownerId: $ownerId) {
+      ${LOOKBOOK_FIELDS}
+    }
+  }
+`;
+var CREATE_LOOKBOOK = `
+  mutation CoolandlovelyCreateLookbook($input: CooCreateLookbookInput!) {
+    cooCreateLookbook(input: $input) {
+      ${LOOKBOOK_FIELDS}
+    }
+  }
+`;
+var ADD_LOOKBOOK_ENTRY = `
+  mutation CoolandlovelyAddLookbookEntry($input: CooAddLookbookEntryInput!) {
+    cooAddLookbookEntry(input: $input) {
+      ${LOOKBOOK_ENTRY_FIELDS}
+    }
+  }
+`;
+var REMOVE_LOOKBOOK_ENTRY = `
+  mutation CoolandlovelyRemoveLookbookEntry($id: ID!) {
+    cooRemoveLookbookEntry(id: $id)
+  }
+`;
+var GET_COLLABORATION = `
+  query CoolandlovelyGetCollaboration($id: ID!) {
+    cooCollaboration(id: $id) {
+      ${COLLABORATION_FIELDS}
+      brand { id name handle status }
+      looks { id title visibility }
+    }
+  }
+`;
+var LIST_COLLABORATIONS = `
+  query CoolandlovelyListCollaborations(
+    $brandId: ID
+    $creatorId: ID
+    $status: CooCollaborationStatus
+  ) {
+    cooListCollaborations(brandId: $brandId, creatorId: $creatorId, status: $status) {
+      ${COLLABORATION_FIELDS}
+    }
+  }
+`;
+var CREATE_COLLABORATION = `
+  mutation CoolandlovelyCreateCollaboration($input: CooCreateCollaborationInput!) {
+    cooCreateCollaboration(input: $input) {
+      ${COLLABORATION_FIELDS}
+    }
+  }
+`;
+var TRANSITION_COLLABORATION = `
+  mutation CoolandlovelyTransitionCollaboration(
+    $id: ID!
+    $status: CooCollaborationStatus!
+  ) {
+    cooTransitionCollaboration(id: $id, status: $status) {
+      ${COLLABORATION_FIELDS}
+    }
+  }
+`;
+var LIST_WARDROBE_ITEMS = `
+  query CoolandlovelyListWardrobeItems(
+    $category: CooStyleCategory
+    $source: CooWardrobeSource
+  ) {
+    cooListWardrobeItems(category: $category, source: $source) {
+      ${WARDROBE_ITEM_FIELDS}
+    }
+  }
+`;
+var CREATE_WARDROBE_ITEM = `
+  mutation CoolandlovelyCreateWardrobeItem($input: CooCreateWardrobeItemInput!) {
+    cooCreateWardrobeItem(input: $input) {
+      ${WARDROBE_ITEM_FIELDS}
+    }
+  }
+`;
+var UPDATE_WARDROBE_ITEM = `
+  mutation CoolandlovelyUpdateWardrobeItem(
+    $id: ID!
+    $input: CooUpdateWardrobeItemInput!
+  ) {
+    cooUpdateWardrobeItem(id: $id, input: $input) {
+      ${WARDROBE_ITEM_FIELDS}
+    }
+  }
+`;
+var LOG_WARDROBE_WEAR = `
+  mutation CoolandlovelyLogWardrobeWear($id: ID!) {
+    cooLogWardrobeWear(id: $id) {
+      ${WARDROBE_ITEM_FIELDS}
+    }
+  }
+`;
+var REMOVE_WARDROBE_ITEM = `
+  mutation CoolandlovelyRemoveWardrobeItem($id: ID!) {
+    cooRemoveWardrobeItem(id: $id)
+  }
+`;
+var MY_STYLE_PROFILE = `
+  query CoolandlovelyMyStyleProfile {
+    cooMyStyleProfile {
+      ${STYLE_PROFILE_FIELDS}
+      lookbooks { id name visibility }
+      wardrobeItems { id name category }
+    }
+  }
+`;
+var UPSERT_STYLE_PROFILE = `
+  mutation CoolandlovelyUpsertStyleProfile($input: CooUpsertStyleProfileInput!) {
+    cooUpsertStyleProfile(input: $input) {
+      ${STYLE_PROFILE_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query CoolandlovelyHealth {
+    cooHealth
+  }
+`;
+var BrandStatusEnum = z.enum(["ARCHIVED", "DRAFT", "PENDING_REVIEW", "PUBLISHED", "SUSPENDED"]).describe("Lifecycle/moderation status of a brand storefront");
+var CollaborationStatusEnum = z.enum(["ACCEPTED", "CANCELLED", "DECLINED", "IN_PROGRESS", "PROPOSED", "PUBLISHED"]).describe("Lifecycle status of a brand\u2194creator collaboration");
+var CollaboratorRoleEnum = z.enum(["BRAND", "CREATOR", "PHOTOGRAPHER", "STYLIST"]).describe("Role a participant plays in a collaboration");
+var CollectionStatusEnum = z.enum(["ARCHIVED", "DRAFT", "ENDED", "LIVE", "SCHEDULED"]).describe("Lifecycle status of a seasonal collection");
+var LookOccasionEnum = z.enum(["ACTIVE", "EVENING", "EVERYDAY", "OTHER", "PARTY", "VACATION", "WEDDING_GUEST", "WORK"]).describe("The occasion a styled look is intended for");
+var SeasonEnum = z.enum(["ALL_SEASON", "AUTUMN", "RESORT", "SPRING", "SUMMER", "WINTER"]).describe("Fashion season of a collection");
+var StyleCategoryEnum = z.enum([
+  "ACCESSORIES",
+  "BAGS",
+  "BEAUTY",
+  "BOTTOMS",
+  "DRESSES",
+  "FOOTWEAR",
+  "JEWELLERY",
+  "OTHER",
+  "OUTERWEAR",
+  "TOPS"
+]).describe("Top-level fashion category for a style/wardrobe item");
+var StyleItemStatusEnum = z.enum(["ACTIVE", "DRAFT", "OUT_OF_STOCK", "RETIRED"]).describe("Availability/lifecycle status of a catalog style item");
+var VisibilityEnum = z.enum(["FOLLOWERS", "PRIVATE", "PUBLIC"]).describe("Who can see a look, lookbook, or style profile");
+var WardrobeSourceEnum = z.enum(["GIFTED", "OWNED", "PURCHASED_ON_PLATFORM", "WISHLIST"]).describe("How a shopper acquired a wardrobe piece");
+var JsonObject = z.record(z.string(), z.unknown());
+var LookItemInput = z.object({
+  styleItemId: z.string().min(1).describe("Style item placed in the look"),
+  position: z.number().int().optional().describe("Ordering position within the look"),
+  styling: z.string().optional().describe("Styling note for this piece")
+}).describe("A style item placed within a look");
+
+// src/modules/coolandlovely/tools/brands.ts
+function registerBrandTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "brands_get")),
+    {
+      title: "Get Brand",
+      description: "Fetch a single Coolandlovely brand storefront by ID, including its collections and catalog items.",
+      inputSchema: { id: z.string().describe("Brand ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_BRAND, { id });
+        if (!data.cooBrand) return errorResult(`Brand ${id} not found`);
+        return jsonResult(data.cooBrand);
+      } catch (error) {
+        ctx.logger.error("coolandlovely brands_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get brand: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "brands_list")),
+    {
+      title: "List Brands",
+      description: "List brand storefronts in the bound workspace with optional featured/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        featured: z.boolean().optional().describe("Only featured storefronts"),
+        status: BrandStatusEnum.optional().describe("Filter by lifecycle status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ featured, status, limit, offset, cursor }) => {
+      try {
+        const pagination = { limit: limit ?? 50, offset: offset ?? 0 };
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_BRANDS, { featured, status, pagination });
+        return jsonResult(data.cooListBrands);
+      } catch (error) {
+        ctx.logger.error("coolandlovely brands_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list brands: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "brands_create")),
+    {
+      title: "Create Brand",
+      description: "Create a new brand storefront. `handle` must be unique within the workspace. Reference logo/cover images by wspace-files-svc File IDs.",
+      inputSchema: {
+        name: z.string().min(1).describe("Brand display name"),
+        handle: z.string().min(1).describe("URL handle, unique within the workspace"),
+        tagline: z.string().optional().describe("Short brand tagline"),
+        bio: z.string().optional().describe("Longer brand bio/description"),
+        aesthetics: z.array(z.string()).optional().describe("Aesthetic keywords"),
+        tags: z.array(z.string()).optional().describe("Discovery tags"),
+        websiteUrl: z.string().optional().describe("External website URL"),
+        logoFileId: z.string().optional().describe("wspace-files-svc File ID for the logo"),
+        coverFileId: z.string().optional().describe("wspace-files-svc File ID for the cover")
+      }
+    },
+    async ({
+      name,
+      handle,
+      tagline,
+      bio,
+      aesthetics,
+      tags,
+      websiteUrl,
+      logoFileId,
+      coverFileId
+    }) => {
+      try {
+        const input = { name, handle };
+        if (tagline !== void 0) input.tagline = tagline;
+        if (bio !== void 0) input.bio = bio;
+        if (aesthetics !== void 0) input.aesthetics = aesthetics;
+        if (tags !== void 0) input.tags = tags;
+        if (websiteUrl !== void 0) input.websiteUrl = websiteUrl;
+        if (logoFileId !== void 0) input.logoFileId = logoFileId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        const data = await ctx.gql.workspace.request(CREATE_BRAND, { input });
+        return jsonResult(data.cooCreateBrand);
+      } catch (error) {
+        ctx.logger.error("coolandlovely brands_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create brand: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "brands_update")),
+    {
+      title: "Update Brand",
+      description: "Update a brand storefront. At least one mutable field must be provided. Use `isFeatured` to feature the storefront.",
+      inputSchema: {
+        id: z.string().describe("Brand ID"),
+        name: z.string().optional().describe("Updated display name"),
+        tagline: z.string().optional().describe("Updated tagline"),
+        bio: z.string().optional().describe("Updated bio"),
+        aesthetics: z.array(z.string()).optional().describe("Updated aesthetic keywords"),
+        tags: z.array(z.string()).optional().describe("Updated tags"),
+        websiteUrl: z.string().optional().describe("Updated website URL"),
+        isFeatured: z.boolean().optional().describe("Toggle featured status"),
+        logoFileId: z.string().optional().describe("Updated logo File ID"),
+        coverFileId: z.string().optional().describe("Updated cover File ID")
+      }
+    },
+    async ({
+      id,
+      name,
+      tagline,
+      bio,
+      aesthetics,
+      tags,
+      websiteUrl,
+      isFeatured,
+      logoFileId,
+      coverFileId
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (tagline !== void 0) input.tagline = tagline;
+        if (bio !== void 0) input.bio = bio;
+        if (aesthetics !== void 0) input.aesthetics = aesthetics;
+        if (tags !== void 0) input.tags = tags;
+        if (websiteUrl !== void 0) input.websiteUrl = websiteUrl;
+        if (isFeatured !== void 0) input.isFeatured = isFeatured;
+        if (logoFileId !== void 0) input.logoFileId = logoFileId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable brand field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_BRAND, { id, input });
+        return jsonResult(data.cooUpdateBrand);
+      } catch (error) {
+        ctx.logger.error("coolandlovely brands_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update brand: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "brands_transition")),
+    {
+      title: "Transition Brand",
+      description: "Advance a brand storefront through its publish lifecycle with a validated status transition (DRAFT \u2192 PENDING_REVIEW \u2192 PUBLISHED, SUSPENDED, ARCHIVED).",
+      inputSchema: {
+        id: z.string().describe("Brand ID"),
+        status: BrandStatusEnum.describe("Target lifecycle status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_BRAND, { id, status });
+        return jsonResult(data.cooTransitionBrand);
+      } catch (error) {
+        ctx.logger.error("coolandlovely brands_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition brand: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "brands_archive")),
+    {
+      title: "Archive Brand",
+      description: "Archive a brand storefront (soft delete). Returns true on success.",
+      inputSchema: { id: z.string().describe("Brand ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_BRAND,
+          { id }
+        );
+        return jsonResult({ archived: data.cooArchiveBrand });
+      } catch (error) {
+        ctx.logger.error("coolandlovely brands_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive brand: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCollectionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_get")),
+    {
+      title: "Get Collection",
+      description: "Fetch a single seasonal collection by ID, including its style items.",
+      inputSchema: { id: z.string().describe("Collection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_COLLECTION, { id });
+        if (!data.cooCollection) return errorResult(`Collection ${id} not found`);
+        return jsonResult(data.cooCollection);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collections_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_list")),
+    {
+      title: "List Collections",
+      description: "List seasonal collections, optionally filtered by brand and/or status.",
+      inputSchema: {
+        brandId: z.string().optional().describe("Filter by brand ID"),
+        status: CollectionStatusEnum.optional().describe("Filter by collection status")
+      }
+    },
+    async ({ brandId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COLLECTIONS, { brandId, status });
+        return jsonResult(data.cooListCollections);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collections_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list collections: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_create")),
+    {
+      title: "Create Collection",
+      description: "Create a seasonal collection for a brand. Set `publishAt`/`endAt` (ISO-8601) to schedule the drop.",
+      inputSchema: {
+        brandId: z.string().min(1).describe("Owning brand ID"),
+        name: z.string().min(1).describe("Collection name"),
+        description: z.string().optional().describe("Collection description"),
+        season: SeasonEnum.optional().describe("Fashion season (default ALL_SEASON)"),
+        publishAt: z.string().optional().describe("Scheduled publish time (ISO-8601 DateTime)"),
+        endAt: z.string().optional().describe("Scheduled end time (ISO-8601 DateTime)"),
+        coverFileId: z.string().optional().describe("wspace-files-svc File ID for the cover"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ brandId, name, description, season, publishAt, endAt, coverFileId, tags }) => {
+      try {
+        const input = { brandId, name };
+        if (description !== void 0) input.description = description;
+        if (season !== void 0) input.season = season;
+        if (publishAt !== void 0) input.publishAt = publishAt;
+        if (endAt !== void 0) input.endAt = endAt;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_COLLECTION, { input });
+        return jsonResult(data.cooCreateCollection);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collections_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_update")),
+    {
+      title: "Update Collection",
+      description: "Update a seasonal collection. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Collection ID"),
+        name: z.string().optional().describe("Updated name"),
+        description: z.string().optional().describe("Updated description"),
+        season: SeasonEnum.optional().describe("Updated season"),
+        publishAt: z.string().optional().describe("Updated publish time (ISO-8601)"),
+        endAt: z.string().optional().describe("Updated end time (ISO-8601)"),
+        coverFileId: z.string().optional().describe("Updated cover File ID"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, description, season, publishAt, endAt, coverFileId, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (season !== void 0) input.season = season;
+        if (publishAt !== void 0) input.publishAt = publishAt;
+        if (endAt !== void 0) input.endAt = endAt;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one mutable collection field"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_COLLECTION, { id, input });
+        return jsonResult(data.cooUpdateCollection);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collections_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_publish")),
+    {
+      title: "Publish Collection",
+      description: "Publish a collection so it goes LIVE.",
+      inputSchema: { id: z.string().describe("Collection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_COLLECTION, { id });
+        return jsonResult(data.cooPublishCollection);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collections_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerStyleItemTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "style_items_get")),
+    {
+      title: "Get Style Item",
+      description: "Fetch a single catalog style item by ID.",
+      inputSchema: { id: z.string().describe("Style item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_STYLE_ITEM, { id });
+        if (!data.cooStyleItem) return errorResult(`Style item ${id} not found`);
+        return jsonResult(data.cooStyleItem);
+      } catch (error) {
+        ctx.logger.error("coolandlovely style_items_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get style item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "style_items_list")),
+    {
+      title: "List Style Items",
+      description: "List catalog style items with optional brand/category/collection/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        brandId: z.string().optional().describe("Filter by brand ID"),
+        category: StyleCategoryEnum.optional().describe("Filter by fashion category"),
+        collectionId: z.string().optional().describe("Filter by collection ID"),
+        status: StyleItemStatusEnum.optional().describe("Filter by item status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ brandId, category, collectionId, status, limit, offset, cursor }) => {
+      try {
+        const pagination = { limit: limit ?? 50, offset: offset ?? 0 };
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_STYLE_ITEMS, { brandId, category, collectionId, status, pagination });
+        return jsonResult(data.cooListStyleItems);
+      } catch (error) {
+        ctx.logger.error("coolandlovely style_items_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list style items: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "style_items_create")),
+    {
+      title: "Create Style Item",
+      description: "Create a catalog style item for a brand. Optionally attach it to a collection and set price/currency, materials, colours, and sizes.",
+      inputSchema: {
+        brandId: z.string().min(1).describe("Owning brand ID"),
+        name: z.string().min(1).describe("Item display name"),
+        category: StyleCategoryEnum.optional().describe("Fashion category (default OTHER)"),
+        collectionId: z.string().optional().describe("Collection to attach the item to"),
+        description: z.string().optional().describe("Item description"),
+        sku: z.string().optional().describe("Stock-keeping unit"),
+        price: z.number().optional().describe("Price"),
+        currency: z.string().optional().describe('ISO currency code (e.g. "USD")'),
+        colours: z.array(z.string()).optional().describe("Available colours"),
+        materials: z.array(z.string()).optional().describe("Materials/fabric composition"),
+        sizes: z.array(z.string()).optional().describe("Available sizes"),
+        imageFileId: z.string().optional().describe("wspace-files-svc File ID for the item image"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      brandId,
+      name,
+      category,
+      collectionId,
+      description,
+      sku,
+      price,
+      currency,
+      colours,
+      materials,
+      sizes,
+      imageFileId,
+      tags
+    }) => {
+      try {
+        const input = { brandId, name };
+        if (category !== void 0) input.category = category;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (description !== void 0) input.description = description;
+        if (sku !== void 0) input.sku = sku;
+        if (price !== void 0) input.price = price;
+        if (currency !== void 0) input.currency = currency;
+        if (colours !== void 0) input.colours = colours;
+        if (materials !== void 0) input.materials = materials;
+        if (sizes !== void 0) input.sizes = sizes;
+        if (imageFileId !== void 0) input.imageFileId = imageFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_STYLE_ITEM, { input });
+        return jsonResult(data.cooCreateStyleItem);
+      } catch (error) {
+        ctx.logger.error("coolandlovely style_items_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create style item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "style_items_update")),
+    {
+      title: "Update Style Item",
+      description: "Update a catalog style item. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Style item ID"),
+        name: z.string().optional().describe("Updated name"),
+        category: StyleCategoryEnum.optional().describe("Updated category"),
+        collectionId: z.string().optional().describe("Updated collection ID"),
+        description: z.string().optional().describe("Updated description"),
+        sku: z.string().optional().describe("Updated SKU"),
+        price: z.number().optional().describe("Updated price"),
+        currency: z.string().optional().describe("Updated currency code"),
+        colours: z.array(z.string()).optional().describe("Updated colours"),
+        materials: z.array(z.string()).optional().describe("Updated materials"),
+        sizes: z.array(z.string()).optional().describe("Updated sizes"),
+        imageFileId: z.string().optional().describe("Updated image File ID"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      category,
+      collectionId,
+      description,
+      sku,
+      price,
+      currency,
+      colours,
+      materials,
+      sizes,
+      imageFileId,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (category !== void 0) input.category = category;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (description !== void 0) input.description = description;
+        if (sku !== void 0) input.sku = sku;
+        if (price !== void 0) input.price = price;
+        if (currency !== void 0) input.currency = currency;
+        if (colours !== void 0) input.colours = colours;
+        if (materials !== void 0) input.materials = materials;
+        if (sizes !== void 0) input.sizes = sizes;
+        if (imageFileId !== void 0) input.imageFileId = imageFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one mutable style-item field"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_STYLE_ITEM, { id, input });
+        return jsonResult(data.cooUpdateStyleItem);
+      } catch (error) {
+        ctx.logger.error("coolandlovely style_items_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update style item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "style_items_archive")),
+    {
+      title: "Archive Style Item",
+      description: "Archive (retire) a catalog style item. Returns true on success.",
+      inputSchema: { id: z.string().describe("Style item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_STYLE_ITEM,
+          { id }
+        );
+        return jsonResult({ archived: data.cooArchiveStyleItem });
+      } catch (error) {
+        ctx.logger.error("coolandlovely style_items_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive style item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerLookTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_get")),
+    {
+      title: "Get Look",
+      description: "Fetch a single styled look by ID, including its line items.",
+      inputSchema: { id: z.string().describe("Look ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_LOOK, { id });
+        if (!data.cooLook) return errorResult(`Look ${id} not found`);
+        return jsonResult(data.cooLook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get look: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_list")),
+    {
+      title: "List Looks",
+      description: "List styled looks with optional author/featured/occasion filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        authorId: z.string().optional().describe("Filter by author user ID"),
+        featured: z.boolean().optional().describe("Only featured looks"),
+        occasion: LookOccasionEnum.optional().describe("Filter by occasion"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ authorId, featured, occasion, limit, offset, cursor }) => {
+      try {
+        const pagination = { limit: limit ?? 50, offset: offset ?? 0 };
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_LOOKS, { authorId, featured, occasion, pagination });
+        return jsonResult(data.cooListLooks);
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list looks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_create")),
+    {
+      title: "Create Look",
+      description: "Create a styled look. Attach style items via `items` (each references a styleItemId with optional position/styling).",
+      inputSchema: {
+        title: z.string().min(1).describe("Look title"),
+        caption: z.string().optional().describe("Look caption/description"),
+        occasion: LookOccasionEnum.optional().describe("Occasion (default EVERYDAY)"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default PUBLIC)"),
+        collaborationId: z.string().optional().describe("Related collaboration ID"),
+        imageFileId: z.string().optional().describe("wspace-files-svc File ID for the look photo"),
+        items: z.array(LookItemInput).optional().describe("Style items placed in the look"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ title, caption, occasion, visibility, collaborationId, imageFileId, items, tags }) => {
+      try {
+        const input = { title };
+        if (caption !== void 0) input.caption = caption;
+        if (occasion !== void 0) input.occasion = occasion;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (collaborationId !== void 0) input.collaborationId = collaborationId;
+        if (imageFileId !== void 0) input.imageFileId = imageFileId;
+        if (items !== void 0) input.items = items;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_LOOK, { input });
+        return jsonResult(data.cooCreateLook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create look: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_update")),
+    {
+      title: "Update Look",
+      description: "Update a styled look. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Look ID"),
+        title: z.string().optional().describe("Updated title"),
+        caption: z.string().optional().describe("Updated caption"),
+        occasion: LookOccasionEnum.optional().describe("Updated occasion"),
+        visibility: VisibilityEnum.optional().describe("Updated visibility"),
+        imageFileId: z.string().optional().describe("Updated look photo File ID"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, title, caption, occasion, visibility, imageFileId, tags }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (caption !== void 0) input.caption = caption;
+        if (occasion !== void 0) input.occasion = occasion;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (imageFileId !== void 0) input.imageFileId = imageFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable look field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_LOOK, { id, input });
+        return jsonResult(data.cooUpdateLook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update look: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_publish")),
+    {
+      title: "Publish Look",
+      description: "Publish a look so it becomes visible per its visibility setting.",
+      inputSchema: { id: z.string().describe("Look ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_LOOK, { id });
+        return jsonResult(data.cooPublishLook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish look: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_like")),
+    {
+      title: "Like Look",
+      description: "Like a published look (increments its likeCount).",
+      inputSchema: { id: z.string().describe("Look ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIKE_LOOK, { id });
+        return jsonResult(data.cooLikeLook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_like failed", { error: String(error) });
+        return errorResult(
+          `Failed to like look: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "looks_delete")),
+    {
+      title: "Delete Look",
+      description: "Delete a styled look. Returns true on success.",
+      inputSchema: { id: z.string().describe("Look ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_LOOK, {
+          id
+        });
+        return jsonResult({ deleted: data.cooDeleteLook });
+      } catch (error) {
+        ctx.logger.error("coolandlovely looks_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete look: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerLookbookTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lookbooks_get")),
+    {
+      title: "Get Lookbook",
+      description: "Fetch a single lookbook by ID, including its entries.",
+      inputSchema: { id: z.string().describe("Lookbook ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_LOOKBOOK, { id });
+        if (!data.cooLookbook) return errorResult(`Lookbook ${id} not found`);
+        return jsonResult(data.cooLookbook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely lookbooks_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get lookbook: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lookbooks_list")),
+    {
+      title: "List Lookbooks",
+      description: "List lookbooks, optionally filtered by owner.",
+      inputSchema: {
+        ownerId: z.string().optional().describe("Filter by owner user ID")
+      }
+    },
+    async ({ ownerId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_LOOKBOOKS, { ownerId });
+        return jsonResult(data.cooListLookbooks);
+      } catch (error) {
+        ctx.logger.error("coolandlovely lookbooks_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list lookbooks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lookbooks_create")),
+    {
+      title: "Create Lookbook",
+      description: "Create a curated lookbook board. `visibility` defaults to PRIVATE.",
+      inputSchema: {
+        name: z.string().min(1).describe("Lookbook name"),
+        description: z.string().optional().describe("Lookbook description"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default PRIVATE)"),
+        coverFileId: z.string().optional().describe("wspace-files-svc File ID for the cover"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, description, visibility, coverFileId, tags }) => {
+      try {
+        const input = { name };
+        if (description !== void 0) input.description = description;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_LOOKBOOK, { input });
+        return jsonResult(data.cooCreateLookbook);
+      } catch (error) {
+        ctx.logger.error("coolandlovely lookbooks_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create lookbook: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lookbooks_add_entry")),
+    {
+      title: "Add Lookbook Entry",
+      description: "Add an entry to a lookbook \u2014 reference either a look (`lookId`) or a style item (`styleItemId`), with an optional position and note.",
+      inputSchema: {
+        lookbookId: z.string().min(1).describe("Target lookbook ID"),
+        lookId: z.string().optional().describe("Look to add (mutually exclusive with styleItemId)"),
+        styleItemId: z.string().optional().describe("Style item to add (mutually exclusive with lookId)"),
+        position: z.number().int().optional().describe("Ordering position within the lookbook"),
+        note: z.string().optional().describe("Curator note for the entry")
+      }
+    },
+    async ({ lookbookId, lookId, styleItemId, position, note }) => {
+      try {
+        const input = { lookbookId };
+        if (lookId !== void 0) input.lookId = lookId;
+        if (styleItemId !== void 0) input.styleItemId = styleItemId;
+        if (position !== void 0) input.position = position;
+        if (note !== void 0) input.note = note;
+        const data = await ctx.gql.workspace.request(ADD_LOOKBOOK_ENTRY, { input });
+        return jsonResult(data.cooAddLookbookEntry);
+      } catch (error) {
+        ctx.logger.error("coolandlovely lookbooks_add_entry failed", { error: String(error) });
+        return errorResult(
+          `Failed to add lookbook entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lookbooks_remove_entry")),
+    {
+      title: "Remove Lookbook Entry",
+      description: "Remove an entry from a lookbook by entry ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Lookbook entry ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_LOOKBOOK_ENTRY,
+          { id }
+        );
+        return jsonResult({ removed: data.cooRemoveLookbookEntry });
+      } catch (error) {
+        ctx.logger.error("coolandlovely lookbooks_remove_entry failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove lookbook entry: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCollaborationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collaborations_get")),
+    {
+      title: "Get Collaboration",
+      description: "Fetch a single collaboration by ID, including its brand and resulting looks.",
+      inputSchema: { id: z.string().describe("Collaboration ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_COLLABORATION, { id });
+        if (!data.cooCollaboration) return errorResult(`Collaboration ${id} not found`);
+        return jsonResult(data.cooCollaboration);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collaborations_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get collaboration: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collaborations_list")),
+    {
+      title: "List Collaborations",
+      description: "List collaborations, optionally filtered by brand, creator, and/or status.",
+      inputSchema: {
+        brandId: z.string().optional().describe("Filter by brand ID"),
+        creatorId: z.string().optional().describe("Filter by creator user ID"),
+        status: CollaborationStatusEnum.optional().describe("Filter by collaboration status")
+      }
+    },
+    async ({ brandId, creatorId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COLLABORATIONS, { brandId, creatorId, status });
+        return jsonResult(data.cooListCollaborations);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collaborations_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list collaborations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collaborations_create")),
+    {
+      title: "Create Collaboration",
+      description: "Propose a brand \u2194 creator collaboration. `role` defaults to CREATOR. Optionally set compensation/currency, a collection, and start/end dates (ISO-8601).",
+      inputSchema: {
+        brandId: z.string().min(1).describe("Brand ID"),
+        creatorId: z.string().min(1).describe("Creator user ID"),
+        title: z.string().min(1).describe("Collaboration title"),
+        role: CollaboratorRoleEnum.optional().describe("Collaborator role (default CREATOR)"),
+        brief: z.string().optional().describe("Collaboration brief"),
+        collectionId: z.string().optional().describe("Related collection ID"),
+        compensation: z.number().optional().describe("Compensation amount"),
+        currency: z.string().optional().describe("ISO currency code"),
+        startDate: z.string().optional().describe("Start date (ISO-8601 DateTime)"),
+        endDate: z.string().optional().describe("End date (ISO-8601 DateTime)"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      brandId,
+      creatorId,
+      title,
+      role,
+      brief,
+      collectionId,
+      compensation,
+      currency,
+      startDate,
+      endDate,
+      tags
+    }) => {
+      try {
+        const input = { brandId, creatorId, title };
+        if (role !== void 0) input.role = role;
+        if (brief !== void 0) input.brief = brief;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (compensation !== void 0) input.compensation = compensation;
+        if (currency !== void 0) input.currency = currency;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_COLLABORATION, { input });
+        return jsonResult(data.cooCreateCollaboration);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collaborations_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create collaboration: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collaborations_transition")),
+    {
+      title: "Transition Collaboration",
+      description: "Advance a collaboration through its lifecycle with a validated status transition (PROPOSED \u2192 ACCEPTED/DECLINED \u2192 IN_PROGRESS \u2192 PUBLISHED, or CANCELLED).",
+      inputSchema: {
+        id: z.string().describe("Collaboration ID"),
+        status: CollaborationStatusEnum.describe("Target lifecycle status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_COLLABORATION, { id, status });
+        return jsonResult(data.cooTransitionCollaboration);
+      } catch (error) {
+        ctx.logger.error("coolandlovely collaborations_transition failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to transition collaboration: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerWardrobeTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "wardrobe_list")),
+    {
+      title: "List Wardrobe Items",
+      description: "List the calling shopper's own wardrobe items, optionally filtered by category and/or source.",
+      inputSchema: {
+        category: StyleCategoryEnum.optional().describe("Filter by category"),
+        source: WardrobeSourceEnum.optional().describe("Filter by how the piece was acquired")
+      }
+    },
+    async ({ category, source }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WARDROBE_ITEMS, { category, source });
+        return jsonResult(data.cooListWardrobeItems);
+      } catch (error) {
+        ctx.logger.error("coolandlovely wardrobe_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list wardrobe items: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "wardrobe_create")),
+    {
+      title: "Create Wardrobe Item",
+      description: "Add a piece to the shopper's wardrobe. Optionally link it to a catalog style item via `styleItemId`.",
+      inputSchema: {
+        name: z.string().min(1).describe("Item name"),
+        category: StyleCategoryEnum.optional().describe("Category (default OTHER)"),
+        source: WardrobeSourceEnum.optional().describe("How it was acquired (default OWNED)"),
+        brandName: z.string().optional().describe("Free-text brand name"),
+        colour: z.string().optional().describe("Colour"),
+        size: z.string().optional().describe("Size"),
+        notes: z.string().optional().describe("Personal notes"),
+        styleItemId: z.string().optional().describe("Linked catalog style item ID"),
+        imageFileId: z.string().optional().describe("wspace-files-svc File ID for the shopper's photo"),
+        tags: z.array(z.string()).optional().describe("Personal tags")
+      }
+    },
+    async ({
+      name,
+      category,
+      source,
+      brandName,
+      colour,
+      size,
+      notes,
+      styleItemId,
+      imageFileId,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (category !== void 0) input.category = category;
+        if (source !== void 0) input.source = source;
+        if (brandName !== void 0) input.brandName = brandName;
+        if (colour !== void 0) input.colour = colour;
+        if (size !== void 0) input.size = size;
+        if (notes !== void 0) input.notes = notes;
+        if (styleItemId !== void 0) input.styleItemId = styleItemId;
+        if (imageFileId !== void 0) input.imageFileId = imageFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_WARDROBE_ITEM, { input });
+        return jsonResult(data.cooCreateWardrobeItem);
+      } catch (error) {
+        ctx.logger.error("coolandlovely wardrobe_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create wardrobe item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "wardrobe_update")),
+    {
+      title: "Update Wardrobe Item",
+      description: "Update a wardrobe item. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Wardrobe item ID"),
+        name: z.string().optional().describe("Updated name"),
+        category: StyleCategoryEnum.optional().describe("Updated category"),
+        source: WardrobeSourceEnum.optional().describe("Updated source"),
+        brandName: z.string().optional().describe("Updated brand name"),
+        colour: z.string().optional().describe("Updated colour"),
+        size: z.string().optional().describe("Updated size"),
+        notes: z.string().optional().describe("Updated notes"),
+        imageFileId: z.string().optional().describe("Updated photo File ID"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, category, source, brandName, colour, size, notes, imageFileId, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (category !== void 0) input.category = category;
+        if (source !== void 0) input.source = source;
+        if (brandName !== void 0) input.brandName = brandName;
+        if (colour !== void 0) input.colour = colour;
+        if (size !== void 0) input.size = size;
+        if (notes !== void 0) input.notes = notes;
+        if (imageFileId !== void 0) input.imageFileId = imageFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable wardrobe field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_WARDROBE_ITEM, { id, input });
+        return jsonResult(data.cooUpdateWardrobeItem);
+      } catch (error) {
+        ctx.logger.error("coolandlovely wardrobe_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update wardrobe item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "wardrobe_log_wear")),
+    {
+      title: "Log Wardrobe Wear",
+      description: "Log that the shopper wore a wardrobe piece (increments timesWorn).",
+      inputSchema: { id: z.string().describe("Wardrobe item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LOG_WARDROBE_WEAR, { id });
+        return jsonResult(data.cooLogWardrobeWear);
+      } catch (error) {
+        ctx.logger.error("coolandlovely wardrobe_log_wear failed", { error: String(error) });
+        return errorResult(
+          `Failed to log wardrobe wear: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "wardrobe_remove")),
+    {
+      title: "Remove Wardrobe Item",
+      description: "Remove a wardrobe item. Returns true on success.",
+      inputSchema: { id: z.string().describe("Wardrobe item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_WARDROBE_ITEM,
+          { id }
+        );
+        return jsonResult({ removed: data.cooRemoveWardrobeItem });
+      } catch (error) {
+        ctx.logger.error("coolandlovely wardrobe_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove wardrobe item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProfileTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profile_get")),
+    {
+      title: "Get My Style Profile",
+      description: "Fetch the calling shopper's own style profile (workspace-scoped), including lookbooks and wardrobe items.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(MY_STYLE_PROFILE, {});
+        if (!data.cooMyStyleProfile)
+          return errorResult("No style profile exists yet for this shopper");
+        return jsonResult(data.cooMyStyleProfile);
+      } catch (error) {
+        ctx.logger.error("coolandlovely profile_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get style profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "profile_upsert")),
+    {
+      title: "Upsert My Style Profile",
+      description: "Create or update the calling shopper's style profile (one per workspace). `sizes` is free-form JSON (e.g. { top: 'M', shoe: '8' }).",
+      inputSchema: {
+        displayName: z.string().optional().describe("Public display name"),
+        bio: z.string().optional().describe("Profile bio"),
+        palette: z.array(z.string()).optional().describe("Preferred colour palette"),
+        stylePreferences: z.array(z.string()).optional().describe("Style preference keywords"),
+        favouriteBrands: z.array(z.string()).optional().describe("Favourite brand names"),
+        sizes: JsonObject.optional().describe("Size profile JSON (e.g. { top, bottom, shoe })"),
+        visibility: VisibilityEnum.optional().describe("Profile visibility (default PRIVATE)")
+      }
+    },
+    async ({ displayName, bio, palette, stylePreferences, favouriteBrands, sizes, visibility }) => {
+      try {
+        const input = {};
+        if (displayName !== void 0) input.displayName = displayName;
+        if (bio !== void 0) input.bio = bio;
+        if (palette !== void 0) input.palette = palette;
+        if (stylePreferences !== void 0) input.stylePreferences = stylePreferences;
+        if (favouriteBrands !== void 0) input.favouriteBrands = favouriteBrands;
+        if (sizes !== void 0) input.sizes = sizes;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(UPSERT_STYLE_PROFILE, { input });
+        return jsonResult(data.cooUpsertStyleProfile);
+      } catch (error) {
+        ctx.logger.error("coolandlovely profile_upsert failed", { error: String(error) });
+        return errorResult(
+          `Failed to upsert style profile: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/coolandlovely/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Coolandlovely Health Check",
+      description: "Public liveness/identity probe for the Coolandlovely subgraph (cooHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.cooHealth });
+      } catch (error) {
+        ctx.logger.error("coolandlovely health failed", { error: String(error) });
+        return errorResult(
+          `Coolandlovely health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/coolandlovely/resources.ts
+function registerCoolandlovelyResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const brandsUri = track(mcpResourceUri(ctx.productName, "brands"));
+  const looksUri = track(mcpResourceUri(ctx.productName, "looks"));
+  const styleItemsUri = track(mcpResourceUri(ctx.productName, "style-items"));
+  server.registerResource(
+    "coolandlovely-schema",
+    schemaUri,
+    {
+      title: "Coolandlovely Domain Schema",
+      description: "Overview of the Coolandlovely fashion & lifestyle domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Coolandlovely Domain (Overview)
+
+Fashion & lifestyle platform \u2014 brand storefronts, seasonal collections,
+catalog items, styled looks, lookbooks, creator collaborations, and personal
+wardrobes/style profiles.
+
+## Entities
+- CooBrand \u2014 a brand storefront (collections, style items)
+- CooCollection \u2014 a seasonal collection within a brand
+- CooStyleItem \u2014 a catalog item (product) within a brand/collection
+- CooLook (+CooLookItem) \u2014 a styled look + the items placed in it
+- CooLookbook (+CooLookbookEntry) \u2014 a curated board of looks/items
+- CooCollaboration \u2014 a brand \u2194 creator partnership
+- CooWardrobeItem \u2014 a shopper's personal closet piece
+- CooStyleProfile \u2014 the calling shopper's style profile (one per workspace)
+
+## Enums
+- CooBrandStatus: DRAFT, PENDING_REVIEW, PUBLISHED, SUSPENDED, ARCHIVED
+- CooCollectionStatus: DRAFT, SCHEDULED, LIVE, ENDED, ARCHIVED
+- CooStyleItemStatus: DRAFT, ACTIVE, OUT_OF_STOCK, RETIRED
+- CooStyleCategory: TOPS, BOTTOMS, DRESSES, OUTERWEAR, FOOTWEAR, BAGS, ACCESSORIES, JEWELLERY, BEAUTY, OTHER
+- CooSeason: ALL_SEASON, SPRING, SUMMER, AUTUMN, WINTER, RESORT
+- CooLookOccasion: EVERYDAY, WORK, EVENING, PARTY, WEDDING_GUEST, VACATION, ACTIVE, OTHER
+- CooVisibility: PUBLIC, FOLLOWERS, PRIVATE
+- CooCollaborationStatus: PROPOSED, ACCEPTED, DECLINED, IN_PROGRESS, PUBLISHED, CANCELLED
+- CooCollaboratorRole: BRAND, CREATOR, STYLIST, PHOTOGRAPHER
+- CooWardrobeSource: OWNED, PURCHASED_ON_PLATFORM, GIFTED, WISHLIST
+
+## Tool groups
+brands, collections, style_items, looks, lookbooks, collaborations, wardrobe, profile.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "coolandlovely-brands",
+    brandsUri,
+    {
+      title: "Coolandlovely Brand Directory",
+      description: "The first 50 brand storefronts in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${brandsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_BRANDS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: brandsUri,
+              text: JSON.stringify(data.cooListBrands, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: brandsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "coolandlovely-looks",
+    looksUri,
+    {
+      title: "Coolandlovely Looks Feed",
+      description: "The first 50 styled looks in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${looksUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_LOOKS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: looksUri,
+              text: JSON.stringify(data.cooListLooks, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: looksUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "coolandlovely-style-items",
+    styleItemsUri,
+    {
+      title: "Coolandlovely Catalog",
+      description: "The first 50 catalog style items in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${styleItemsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_STYLE_ITEMS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: styleItemsUri,
+              text: JSON.stringify(data.cooListStyleItems, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: styleItemsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerCoolandlovelyPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "brand-onboarding"));
+  const stylingName = track(mcpPromptName(p, "styling-workflow"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Brand Onboarding",
+      description: "Guide for onboarding a new Coolandlovely brand storefront end to end: create the brand, open a seasonal collection, add catalog style items, and publish.",
+      argsSchema: {
+        name: z.string().optional().describe("Brand name"),
+        season: z.string().optional().describe("Launch season")
+      }
+    },
+    ({ name, season }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { name, season });
+      const nameNote = name ? `Use the brand name "${name}".` : "Ask the user for the brand name.";
+      const seasonNote = season ? `Use season ${season}.` : "Help the user pick a CooSeason.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard a new Coolandlovely brand storefront.
+
+1. **Create Brand**: Use ${p}_brands_create. ${nameNote} Provide a unique handle, plus optional tagline/bio/aesthetics and logo/cover File IDs.
+2. **Open Collection**: Use ${p}_collections_create for the new brandId. ${seasonNote} Set publishAt/endAt to schedule the drop.
+3. **Add Style Items**: Use ${p}_style_items_create for each catalog piece \u2014 set category, price/currency, colours/materials/sizes, and attach the collectionId.
+4. **Verify Catalog**: Use ${p}_style_items_list filtered by the new brandId.
+5. **Publish**: Use ${p}_collections_publish to take the collection LIVE, then ${p}_brands_transition with status=PUBLISHED.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    stylingName,
+    {
+      title: "Styling Workflow",
+      description: "Guide a shopper's styling journey: set up a style profile, build the wardrobe, create looks, and curate lookbooks.",
+      argsSchema: {
+        occasion: z.string().optional().describe("Target occasion for the look")
+      }
+    },
+    ({ occasion }) => {
+      ctx.logger.debug(`Prompt ${stylingName} called`, { occasion });
+      const occasionNote = occasion ? `Style for the ${occasion} occasion.` : `Ask the shopper which CooLookOccasion they're styling for.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run a Coolandlovely styling workflow. ${occasionNote}
+
+1. **Style Profile**: Use ${p}_profile_get to load the shopper's profile; if missing, create it with ${p}_profile_upsert (palette, stylePreferences, sizes).
+2. **Wardrobe**: Use ${p}_wardrobe_list to review owned pieces; add new ones with ${p}_wardrobe_create.
+3. **Discover Items**: Use ${p}_style_items_list (and ${p}_brands_list) to find catalog pieces that fit the profile/occasion.
+4. **Create Look**: Use ${p}_looks_create with the chosen items, then ${p}_looks_publish.
+5. **Curate Lookbook**: Use ${p}_lookbooks_create and ${p}_lookbooks_add_entry to save looks/items to a board.
+6. **Log Wear**: When the shopper wears a piece, use ${p}_wardrobe_log_wear.
+
+Summarize the styled look and saved lookbook after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/coolandlovely/index.ts
+var coolandlovelyModule = {
+  id: "coolandlovely",
+  version: "0.0.1",
+  displayName: "Coolandlovely",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerBrandTools(server, ctx, trackTool);
+    registerCollectionTools(server, ctx, trackTool);
+    registerStyleItemTools(server, ctx, trackTool);
+    registerLookTools(server, ctx, trackTool);
+    registerLookbookTools(server, ctx, trackTool);
+    registerCollaborationTools(server, ctx, trackTool);
+    registerWardrobeTools(server, ctx, trackTool);
+    registerProfileTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerCoolandlovelyResources(server, ctx, trackResource);
+    registerCoolandlovelyPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var coolandlovely_default = coolandlovelyModule;
+
+export { coolandlovely_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map