@burdenoff/mcp-libs 2026.627.2 → 2026.627.4

package/dist/modules/artistrybase/index.cjs

@@ -0,0 +1,2112 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/artistrybase/tools/library.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/artistrybase/operations.ts
+var WORK_FIELDS = `
+  id title summary medium status visibility productionId creatorId
+  coverFileId currentVersionId durationMs tags publishedAt
+  workspaceId createdAt updatedAt
+`;
+var WORK_VERSION_FIELDS = `
+  id workId versionNo label notes fileId checksum sizeBytes isPublished
+  workspaceId createdAt updatedAt
+`;
+var ASSET_FIELDS = `
+  id workId versionId kind fileId mimeType sizeBytes width height durationMs
+  workspaceId createdAt updatedAt
+`;
+var COLLECTION_FIELDS = `
+  id title slug description medium visibility tags coverFileId
+  workspaceId createdAt updatedAt
+`;
+var PRODUCTION_FIELDS = `
+  id title slug synopsis medium status ownerId tags startDate targetDate
+  releasedAt workspaceId createdAt updatedAt
+`;
+var PRODUCTION_MEMBER_FIELDS = `
+  id productionId memberId role title isLead workspaceId createdAt updatedAt
+`;
+var REFERENCE_FIELDS = `
+  id productionId title note url fileId tags workspaceId createdAt updatedAt
+`;
+var REVIEW_ROUND_FIELDS = `
+  id workId versionId round status title dueDate openedById closedAt
+  workspaceId createdAt updatedAt
+`;
+var FEEDBACK_FIELDS = `
+  id reviewRoundId authorId body anchorType anchorValue status
+  resolvedAt resolvedById workspaceId createdAt updatedAt
+`;
+var APPROVAL_FIELDS = `
+  id reviewRoundId approverId decision comment decidedAt
+  workspaceId createdAt updatedAt
+`;
+var RELEASE_FIELDS = `
+  id workId versionId channel status visibility notes scheduledFor
+  publishedAt workspaceId createdAt updatedAt
+`;
+var PORTFOLIO_FIELDS = `
+  id handle displayName bio avatarFileId bannerFileId links featuredWorkIds
+  followerCount ownerId visibility workspaceId createdAt updatedAt
+`;
+var FOLLOW_FIELDS = `
+  id portfolioId followerId notify workspaceId createdAt
+`;
+var LICENSE_FIELDS = `
+  id workId name model status priceAmount currency spdx terms attribution
+  workspaceId createdAt updatedAt
+`;
+var GET_WORK = `
+  query ArtistrybaseGetWork($id: ID!) {
+    artWork(id: $id) {
+      ${WORK_FIELDS}
+      assets { ${ASSET_FIELDS} }
+      versions { ${WORK_VERSION_FIELDS} }
+    }
+  }
+`;
+var LIST_WORKS = `
+  query ArtistrybaseListWorks(
+    $medium: ArtMedium
+    $status: ArtWorkStatus
+    $productionId: ID
+    $pagination: PaginationInput
+  ) {
+    artListWorks(
+      medium: $medium
+      status: $status
+      productionId: $productionId
+      pagination: $pagination
+    ) {
+      items { ${WORK_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_WORK = `
+  mutation ArtistrybaseCreateWork($input: ArtCreateWorkInput!) {
+    artCreateWork(input: $input) {
+      ${WORK_FIELDS}
+    }
+  }
+`;
+var UPDATE_WORK = `
+  mutation ArtistrybaseUpdateWork($id: ID!, $input: ArtUpdateWorkInput!) {
+    artUpdateWork(id: $id, input: $input) {
+      ${WORK_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_WORK = `
+  mutation ArtistrybaseArchiveWork($id: ID!) {
+    artArchiveWork(id: $id)
+  }
+`;
+var PUBLISH_WORK_VERSION = `
+  mutation ArtistrybasePublishWorkVersion($workId: ID!, $versionId: ID!) {
+    artPublishWorkVersion(workId: $workId, versionId: $versionId) {
+      ${WORK_FIELDS}
+    }
+  }
+`;
+var LIST_WORK_VERSIONS = `
+  query ArtistrybaseListWorkVersions($workId: ID!) {
+    artListWorkVersions(workId: $workId) {
+      ${WORK_VERSION_FIELDS}
+    }
+  }
+`;
+var ADD_WORK_VERSION = `
+  mutation ArtistrybaseAddWorkVersion($input: ArtCreateWorkVersionInput!) {
+    artAddWorkVersion(input: $input) {
+      ${WORK_VERSION_FIELDS}
+    }
+  }
+`;
+var LIST_ASSETS = `
+  query ArtistrybaseListAssets($workId: ID!) {
+    artListAssets(workId: $workId) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var ADD_ASSET = `
+  mutation ArtistrybaseAddAsset($input: ArtCreateAssetInput!) {
+    artAddAsset(input: $input) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var GET_COLLECTION = `
+  query ArtistrybaseGetCollection($id: ID!) {
+    artCollection(id: $id) {
+      ${COLLECTION_FIELDS}
+      works { ${WORK_FIELDS} }
+    }
+  }
+`;
+var LIST_COLLECTIONS = `
+  query ArtistrybaseListCollections(
+    $visibility: ArtVisibility
+    $pagination: PaginationInput
+  ) {
+    artListCollections(visibility: $visibility, pagination: $pagination) {
+      items { ${COLLECTION_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_COLLECTION = `
+  mutation ArtistrybaseCreateCollection($input: ArtCreateCollectionInput!) {
+    artCreateCollection(input: $input) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var UPDATE_COLLECTION = `
+  mutation ArtistrybaseUpdateCollection($id: ID!, $input: ArtUpdateCollectionInput!) {
+    artUpdateCollection(id: $id, input: $input) {
+      ${COLLECTION_FIELDS}
+    }
+  }
+`;
+var ADD_WORK_TO_COLLECTION = `
+  mutation ArtistrybaseAddWorkToCollection($collectionId: ID!, $workId: ID!) {
+    artAddWorkToCollection(collectionId: $collectionId, workId: $workId) {
+      ${COLLECTION_FIELDS}
+      works { id title medium status }
+    }
+  }
+`;
+var REMOVE_WORK_FROM_COLLECTION = `
+  mutation ArtistrybaseRemoveWorkFromCollection($collectionId: ID!, $workId: ID!) {
+    artRemoveWorkFromCollection(collectionId: $collectionId, workId: $workId) {
+      ${COLLECTION_FIELDS}
+      works { id title medium status }
+    }
+  }
+`;
+var GET_PRODUCTION = `
+  query ArtistrybaseGetProduction($id: ID!) {
+    artProduction(id: $id) {
+      ${PRODUCTION_FIELDS}
+      members { ${PRODUCTION_MEMBER_FIELDS} }
+      references { ${REFERENCE_FIELDS} }
+    }
+  }
+`;
+var LIST_PRODUCTIONS = `
+  query ArtistrybaseListProductions(
+    $status: ArtProductionStatus
+    $pagination: PaginationInput
+  ) {
+    artListProductions(status: $status, pagination: $pagination) {
+      items { ${PRODUCTION_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_PRODUCTION = `
+  mutation ArtistrybaseCreateProduction($input: ArtCreateProductionInput!) {
+    artCreateProduction(input: $input) {
+      ${PRODUCTION_FIELDS}
+    }
+  }
+`;
+var UPDATE_PRODUCTION = `
+  mutation ArtistrybaseUpdateProduction($id: ID!, $input: ArtUpdateProductionInput!) {
+    artUpdateProduction(id: $id, input: $input) {
+      ${PRODUCTION_FIELDS}
+    }
+  }
+`;
+var TRANSITION_PRODUCTION = `
+  mutation ArtistrybaseTransitionProduction($id: ID!, $status: ArtProductionStatus!) {
+    artTransitionProduction(id: $id, status: $status) {
+      ${PRODUCTION_FIELDS}
+    }
+  }
+`;
+var LIST_PRODUCTION_MEMBERS = `
+  query ArtistrybaseListProductionMembers($productionId: ID!) {
+    artListProductionMembers(productionId: $productionId) {
+      ${PRODUCTION_MEMBER_FIELDS}
+    }
+  }
+`;
+var ADD_PRODUCTION_MEMBER = `
+  mutation ArtistrybaseAddProductionMember($input: ArtAddProductionMemberInput!) {
+    artAddProductionMember(input: $input) {
+      ${PRODUCTION_MEMBER_FIELDS}
+    }
+  }
+`;
+var REMOVE_PRODUCTION_MEMBER = `
+  mutation ArtistrybaseRemoveProductionMember($id: ID!) {
+    artRemoveProductionMember(id: $id)
+  }
+`;
+var LIST_REFERENCES = `
+  query ArtistrybaseListReferences($productionId: ID!) {
+    artListReferences(productionId: $productionId) {
+      ${REFERENCE_FIELDS}
+    }
+  }
+`;
+var ADD_REFERENCE = `
+  mutation ArtistrybaseAddReference($input: ArtCreateReferenceInput!) {
+    artAddReference(input: $input) {
+      ${REFERENCE_FIELDS}
+    }
+  }
+`;
+var REMOVE_REFERENCE = `
+  mutation ArtistrybaseRemoveReference($id: ID!) {
+    artRemoveReference(id: $id)
+  }
+`;
+var GET_REVIEW_ROUND = `
+  query ArtistrybaseGetReviewRound($id: ID!) {
+    artReviewRound(id: $id) {
+      ${REVIEW_ROUND_FIELDS}
+      feedback { ${FEEDBACK_FIELDS} }
+      approvals { ${APPROVAL_FIELDS} }
+    }
+  }
+`;
+var LIST_REVIEW_ROUNDS = `
+  query ArtistrybaseListReviewRounds($workId: ID!, $status: ArtReviewStatus) {
+    artListReviewRounds(workId: $workId, status: $status) {
+      ${REVIEW_ROUND_FIELDS}
+    }
+  }
+`;
+var OPEN_REVIEW_ROUND = `
+  mutation ArtistrybaseOpenReviewRound($input: ArtOpenReviewRoundInput!) {
+    artOpenReviewRound(input: $input) {
+      ${REVIEW_ROUND_FIELDS}
+    }
+  }
+`;
+var TRANSITION_REVIEW_ROUND = `
+  mutation ArtistrybaseTransitionReviewRound($id: ID!, $status: ArtReviewStatus!) {
+    artTransitionReviewRound(id: $id, status: $status) {
+      ${REVIEW_ROUND_FIELDS}
+    }
+  }
+`;
+var ADD_FEEDBACK = `
+  mutation ArtistrybaseAddFeedback($input: ArtAddFeedbackInput!) {
+    artAddFeedback(input: $input) {
+      ${FEEDBACK_FIELDS}
+    }
+  }
+`;
+var RESOLVE_FEEDBACK = `
+  mutation ArtistrybaseResolveFeedback($id: ID!, $status: ArtFeedbackStatus!) {
+    artResolveFeedback(id: $id, status: $status) {
+      ${FEEDBACK_FIELDS}
+    }
+  }
+`;
+var RECORD_APPROVAL = `
+  mutation ArtistrybaseRecordApproval($input: ArtRecordApprovalInput!) {
+    artRecordApproval(input: $input) {
+      ${APPROVAL_FIELDS}
+    }
+  }
+`;
+var LIST_RELEASES = `
+  query ArtistrybaseListReleases($workId: ID!, $status: ArtReleaseStatus) {
+    artListReleases(workId: $workId, status: $status) {
+      ${RELEASE_FIELDS}
+    }
+  }
+`;
+var CREATE_RELEASE = `
+  mutation ArtistrybaseCreateRelease($input: ArtCreateReleaseInput!) {
+    artCreateRelease(input: $input) {
+      ${RELEASE_FIELDS}
+    }
+  }
+`;
+var PUBLISH_RELEASE = `
+  mutation ArtistrybasePublishRelease($id: ID!) {
+    artPublishRelease(id: $id) {
+      ${RELEASE_FIELDS}
+    }
+  }
+`;
+var GET_PORTFOLIO = `
+  query ArtistrybaseGetPortfolio($id: ID!) {
+    artPortfolio(id: $id) {
+      ${PORTFOLIO_FIELDS}
+    }
+  }
+`;
+var LIST_PORTFOLIOS = `
+  query ArtistrybaseListPortfolios(
+    $visibility: ArtVisibility
+    $pagination: PaginationInput
+  ) {
+    artListPortfolios(visibility: $visibility, pagination: $pagination) {
+      items { ${PORTFOLIO_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_PORTFOLIO = `
+  mutation ArtistrybaseCreatePortfolio($input: ArtCreatePortfolioInput!) {
+    artCreatePortfolio(input: $input) {
+      ${PORTFOLIO_FIELDS}
+    }
+  }
+`;
+var UPDATE_PORTFOLIO = `
+  mutation ArtistrybaseUpdatePortfolio($id: ID!, $input: ArtUpdatePortfolioInput!) {
+    artUpdatePortfolio(id: $id, input: $input) {
+      ${PORTFOLIO_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_PORTFOLIO = `
+  mutation ArtistrybaseArchivePortfolio($id: ID!) {
+    artArchivePortfolio(id: $id)
+  }
+`;
+var FOLLOW_PORTFOLIO = `
+  mutation ArtistrybaseFollowPortfolio($portfolioId: ID!, $notify: Boolean) {
+    artFollowPortfolio(portfolioId: $portfolioId, notify: $notify) {
+      ${FOLLOW_FIELDS}
+    }
+  }
+`;
+var UNFOLLOW_PORTFOLIO = `
+  mutation ArtistrybaseUnfollowPortfolio($portfolioId: ID!) {
+    artUnfollowPortfolio(portfolioId: $portfolioId)
+  }
+`;
+var LIST_LICENSES = `
+  query ArtistrybaseListLicenses($workId: ID!) {
+    artListLicenses(workId: $workId) {
+      ${LICENSE_FIELDS}
+    }
+  }
+`;
+var CREATE_LICENSE = `
+  mutation ArtistrybaseCreateLicense($input: ArtCreateLicenseInput!) {
+    artCreateLicense(input: $input) {
+      ${LICENSE_FIELDS}
+    }
+  }
+`;
+var UPDATE_LICENSE = `
+  mutation ArtistrybaseUpdateLicense($id: ID!, $input: ArtUpdateLicenseInput!) {
+    artUpdateLicense(id: $id, input: $input) {
+      ${LICENSE_FIELDS}
+    }
+  }
+`;
+var ACTIVATE_LICENSE = `
+  mutation ArtistrybaseActivateLicense($id: ID!) {
+    artActivateLicense(id: $id) {
+      ${LICENSE_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query ArtistrybaseHealth {
+    artHealth
+  }
+`;
+var MediumEnum = zod.z.enum(["ART", "AUDIO", "MIXED", "STORY", "VIDEO"]).describe("Creative medium of a work, collection, or production");
+var VisibilityEnum = zod.z.enum(["PRIVATE", "PUBLIC", "UNLISTED"]).describe("Visibility of a work, collection, portfolio, or release");
+var WorkStatusEnum = zod.z.enum(["APPROVED", "ARCHIVED", "DRAFT", "IN_REVIEW", "RELEASED"]).describe("Lifecycle status of a work");
+var AssetKindEnum = zod.z.enum(["ATTACHMENT", "CAPTION", "COVER", "MASTER", "PREVIEW", "SOURCE"]).describe("Kind of file asset attached to a work");
+var ProductionStatusEnum = zod.z.enum(["CANCELLED", "IN_PRODUCTION", "ON_HOLD", "PLANNING", "POST", "RELEASED", "REVIEW"]).describe("Lifecycle status of a production");
+var ProductionRoleEnum = zod.z.enum(["COLLABORATOR", "CREATOR", "EDITOR", "OWNER", "PRODUCER", "REVIEWER", "VIEWER"]).describe("Role of a member on a production team");
+var ReviewStatusEnum = zod.z.enum(["APPROVED", "CHANGES_REQUESTED", "CLOSED", "OPEN"]).describe("Lifecycle status of a review round");
+var FeedbackStatusEnum = zod.z.enum(["OPEN", "RESOLVED", "WONT_FIX"]).describe("Resolution status of a piece of feedback");
+var AnchorTypeEnum = zod.z.enum(["CHAPTER", "GENERAL", "PAGE", "PIN", "TIMECODE"]).describe("Where in-context feedback is anchored");
+var ApprovalDecisionEnum = zod.z.enum(["APPROVED", "PENDING", "REJECTED"]).describe("Decision recorded on a review round by an approver");
+var ReleaseStatusEnum = zod.z.enum(["FAILED", "PUBLISHED", "SCHEDULED", "UNPUBLISHED"]).describe("Lifecycle status of a release");
+var LicenseModelEnum = zod.z.enum(["FREE", "LICENSE", "MEMBERSHIP", "PURCHASE"]).describe("Commercial model of a license");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+
+// src/modules/artistrybase/tools/library.ts
+function registerLibraryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_get")),
+    {
+      title: "Get Work",
+      description: "Fetch a single creative work by ID, including its file assets and immutable version history.",
+      inputSchema: { id: zod.z.string().describe("Work ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_WORK, { id });
+        if (!data.artWork) return errorResult(`Work ${id} not found`);
+        return jsonResult(data.artWork);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get work: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_list")),
+    {
+      title: "List Works",
+      description: "List creative works in the bound workspace with optional medium/status/production filters and cursor/offset pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        medium: MediumEnum.optional().describe("Filter by medium"),
+        status: WorkStatusEnum.optional().describe("Filter by lifecycle status"),
+        productionId: zod.z.string().optional().describe("Filter to works of a production"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ medium, status, productionId, 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_WORKS, { medium, status, productionId, pagination });
+        return jsonResult(data.artListWorks);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list works: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_create")),
+    {
+      title: "Create Work",
+      description: "Create a new creative work (any medium). Title is required; the work starts in DRAFT/PRIVATE unless overridden.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Work title"),
+        medium: MediumEnum.optional().describe("Creative medium (default MIXED)"),
+        summary: zod.z.string().optional().describe("Short summary/description"),
+        productionId: zod.z.string().optional().describe("Owning production ID (optional)"),
+        coverFileId: zod.z.string().optional().describe("Cover image File ID (wspace-files-svc)"),
+        durationMs: zod.z.number().int().optional().describe("Duration in milliseconds (audio/video)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default PRIVATE)")
+      }
+    },
+    async ({ title, medium, summary, productionId, coverFileId, durationMs, tags, visibility }) => {
+      try {
+        const input = { title };
+        if (medium !== void 0) input.medium = medium;
+        if (summary !== void 0) input.summary = summary;
+        if (productionId !== void 0) input.productionId = productionId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (durationMs !== void 0) input.durationMs = durationMs;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(CREATE_WORK, { input });
+        return jsonResult(data.artCreateWork);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create work: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_update")),
+    {
+      title: "Update Work",
+      description: "Update a work. At least one mutable field must be provided. Use `visibility` to publish/unlist a work.",
+      inputSchema: {
+        id: zod.z.string().describe("Work ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        summary: zod.z.string().optional().describe("Updated summary"),
+        medium: MediumEnum.optional().describe("Updated medium"),
+        productionId: zod.z.string().optional().describe("Updated owning production ID"),
+        coverFileId: zod.z.string().optional().describe("Updated cover File ID"),
+        durationMs: zod.z.number().int().optional().describe("Updated duration in milliseconds"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        visibility: VisibilityEnum.optional().describe("Updated visibility")
+      }
+    },
+    async ({
+      id,
+      title,
+      summary,
+      medium,
+      productionId,
+      coverFileId,
+      durationMs,
+      tags,
+      visibility
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (summary !== void 0) input.summary = summary;
+        if (medium !== void 0) input.medium = medium;
+        if (productionId !== void 0) input.productionId = productionId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (durationMs !== void 0) input.durationMs = durationMs;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/summary/medium/productionId/coverFileId/durationMs/tags/visibility"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_WORK, { id, input });
+        return jsonResult(data.artUpdateWork);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update work: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_archive")),
+    {
+      title: "Archive Work",
+      description: "Archive a work (soft delete). Returns whether the archive succeeded.",
+      inputSchema: { id: zod.z.string().describe("Work ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_WORK,
+          { id }
+        );
+        return jsonResult({ ok: data.artArchiveWork });
+      } catch (error) {
+        ctx.logger.error("artistrybase works_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive work: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_publish_version")),
+    {
+      title: "Publish Work Version",
+      description: "Promote a version to be the work's published current version.",
+      inputSchema: {
+        workId: zod.z.string().describe("Work ID"),
+        versionId: zod.z.string().describe("Version ID to promote as current")
+      }
+    },
+    async ({ workId, versionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_WORK_VERSION, { workId, versionId });
+        return jsonResult(data.artPublishWorkVersion);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_publish_version failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish work version: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_list_versions")),
+    {
+      title: "List Work Versions",
+      description: "List a work's immutable revision history (ordered version snapshots).",
+      inputSchema: { workId: zod.z.string().describe("Work ID") }
+    },
+    async ({ workId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORK_VERSIONS, { workId });
+        return jsonResult(data.artListWorkVersions);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_list_versions failed", { error: String(error) });
+        return errorResult(
+          `Failed to list work versions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_add_version")),
+    {
+      title: "Add Work Version",
+      description: "Upload a new immutable revision of a work (auto-increments the version number).",
+      inputSchema: {
+        workId: zod.z.string().min(1).describe("Work ID"),
+        fileId: zod.z.string().optional().describe("Source File ID for this revision (wspace-files-svc)"),
+        label: zod.z.string().optional().describe("Human label for the version"),
+        notes: zod.z.string().optional().describe("Revision notes / changelog"),
+        checksum: zod.z.string().optional().describe("Content checksum")
+      }
+    },
+    async ({ workId, fileId, label, notes, checksum }) => {
+      try {
+        const input = { workId };
+        if (fileId !== void 0) input.fileId = fileId;
+        if (label !== void 0) input.label = label;
+        if (notes !== void 0) input.notes = notes;
+        if (checksum !== void 0) input.checksum = checksum;
+        const data = await ctx.gql.workspace.request(ADD_WORK_VERSION, { input });
+        return jsonResult(data.artAddWorkVersion);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_add_version failed", { error: String(error) });
+        return errorResult(
+          `Failed to add work version: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_list_assets")),
+    {
+      title: "List Work Assets",
+      description: "List the file assets attached to a work (masters, previews, captions, etc.).",
+      inputSchema: { workId: zod.z.string().describe("Work ID") }
+    },
+    async ({ workId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ASSETS, { workId });
+        return jsonResult(data.artListAssets);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_list_assets failed", { error: String(error) });
+        return errorResult(
+          `Failed to list assets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "works_add_asset")),
+    {
+      title: "Add Work Asset",
+      description: "Attach a file asset to a work. `fileId` references a wspace-files-svc File; `kind` defaults to SOURCE.",
+      inputSchema: {
+        workId: zod.z.string().min(1).describe("Work ID"),
+        fileId: zod.z.string().min(1).describe("Backing File ID (wspace-files-svc)"),
+        kind: AssetKindEnum.optional().describe("Asset kind (default SOURCE)"),
+        versionId: zod.z.string().optional().describe("Version this asset belongs to"),
+        mimeType: zod.z.string().optional().describe("MIME type"),
+        width: zod.z.number().int().optional().describe("Pixel width (image/video)"),
+        height: zod.z.number().int().optional().describe("Pixel height (image/video)"),
+        durationMs: zod.z.number().int().optional().describe("Duration in milliseconds (audio/video)")
+      }
+    },
+    async ({ workId, fileId, kind, versionId, mimeType, width, height, durationMs }) => {
+      try {
+        const input = { workId, fileId };
+        if (kind !== void 0) input.kind = kind;
+        if (versionId !== void 0) input.versionId = versionId;
+        if (mimeType !== void 0) input.mimeType = mimeType;
+        if (width !== void 0) input.width = width;
+        if (height !== void 0) input.height = height;
+        if (durationMs !== void 0) input.durationMs = durationMs;
+        const data = await ctx.gql.workspace.request(ADD_ASSET, { input });
+        return jsonResult(data.artAddAsset);
+      } catch (error) {
+        ctx.logger.error("artistrybase works_add_asset failed", { error: String(error) });
+        return errorResult(
+          `Failed to add asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_get")),
+    {
+      title: "Get Collection",
+      description: "Fetch a single collection by ID, including its member works.",
+      inputSchema: { id: zod.z.string().describe("Collection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_COLLECTION, { id });
+        if (!data.artCollection) return errorResult(`Collection ${id} not found`);
+        return jsonResult(data.artCollection);
+      } catch (error) {
+        ctx.logger.error("artistrybase 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 curated collections with optional visibility filter and cursor/offset pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        visibility: VisibilityEnum.optional().describe("Filter by visibility"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ visibility, 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_COLLECTIONS, { visibility, pagination });
+        return jsonResult(data.artListCollections);
+      } catch (error) {
+        ctx.logger.error("artistrybase 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 curated collection. `slug` must be unique within the workspace.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Collection title"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        description: zod.z.string().optional().describe("Collection description"),
+        medium: MediumEnum.optional().describe("Primary medium of the collection"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags"),
+        coverFileId: zod.z.string().optional().describe("Cover image File ID"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default PRIVATE)")
+      }
+    },
+    async ({ title, slug, description, medium, tags, coverFileId, visibility }) => {
+      try {
+        const input = { title, slug };
+        if (description !== void 0) input.description = description;
+        if (medium !== void 0) input.medium = medium;
+        if (tags !== void 0) input.tags = tags;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(CREATE_COLLECTION, { input });
+        return jsonResult(data.artCreateCollection);
+      } catch (error) {
+        ctx.logger.error("artistrybase 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 collection. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Collection ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        description: zod.z.string().optional().describe("Updated description"),
+        medium: MediumEnum.optional().describe("Updated medium"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        coverFileId: zod.z.string().optional().describe("Updated cover File ID"),
+        visibility: VisibilityEnum.optional().describe("Updated visibility")
+      }
+    },
+    async ({ id, title, description, medium, tags, coverFileId, visibility }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (description !== void 0) input.description = description;
+        if (medium !== void 0) input.medium = medium;
+        if (tags !== void 0) input.tags = tags;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/description/medium/tags/coverFileId/visibility"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_COLLECTION, { id, input });
+        return jsonResult(data.artUpdateCollection);
+      } catch (error) {
+        ctx.logger.error("artistrybase 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_add_work")),
+    {
+      title: "Add Work to Collection",
+      description: "Add a work to a collection. Returns the updated collection.",
+      inputSchema: {
+        collectionId: zod.z.string().describe("Collection ID"),
+        workId: zod.z.string().describe("Work ID to add")
+      }
+    },
+    async ({ collectionId, workId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ADD_WORK_TO_COLLECTION, { collectionId, workId });
+        return jsonResult(data.artAddWorkToCollection);
+      } catch (error) {
+        ctx.logger.error("artistrybase collections_add_work failed", { error: String(error) });
+        return errorResult(
+          `Failed to add work to collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_remove_work")),
+    {
+      title: "Remove Work from Collection",
+      description: "Remove a work from a collection. Returns the updated collection.",
+      inputSchema: {
+        collectionId: zod.z.string().describe("Collection ID"),
+        workId: zod.z.string().describe("Work ID to remove")
+      }
+    },
+    async ({ collectionId, workId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REMOVE_WORK_FROM_COLLECTION, { collectionId, workId });
+        return jsonResult(data.artRemoveWorkFromCollection);
+      } catch (error) {
+        ctx.logger.error("artistrybase collections_remove_work failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove work from collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProductionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_get")),
+    {
+      title: "Get Production",
+      description: "Fetch a single production by ID, including its team members and reference material.",
+      inputSchema: { id: zod.z.string().describe("Production ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PRODUCTION, { id });
+        if (!data.artProduction) return errorResult(`Production ${id} not found`);
+        return jsonResult(data.artProduction);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get production: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_list")),
+    {
+      title: "List Productions",
+      description: "List productions with optional status filter and cursor/offset pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        status: ProductionStatusEnum.optional().describe("Filter by lifecycle status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ 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_PRODUCTIONS, { status, pagination });
+        return jsonResult(data.artListProductions);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list productions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_create")),
+    {
+      title: "Create Production",
+      description: "Create a new production. `slug` must be unique within the workspace.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Production title"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        synopsis: zod.z.string().optional().describe("Synopsis / description"),
+        medium: MediumEnum.optional().describe("Primary medium (default MIXED)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags"),
+        startDate: zod.z.string().optional().describe("Start date (ISO 8601)"),
+        targetDate: zod.z.string().optional().describe("Target completion date (ISO 8601)")
+      }
+    },
+    async ({ title, slug, synopsis, medium, tags, startDate, targetDate }) => {
+      try {
+        const input = { title, slug };
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (medium !== void 0) input.medium = medium;
+        if (tags !== void 0) input.tags = tags;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (targetDate !== void 0) input.targetDate = targetDate;
+        const data = await ctx.gql.workspace.request(CREATE_PRODUCTION, { input });
+        return jsonResult(data.artCreateProduction);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create production: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_update")),
+    {
+      title: "Update Production",
+      description: "Update a production. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Production ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        synopsis: zod.z.string().optional().describe("Updated synopsis"),
+        medium: MediumEnum.optional().describe("Updated medium"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        startDate: zod.z.string().optional().describe("Updated start date (ISO 8601)"),
+        targetDate: zod.z.string().optional().describe("Updated target date (ISO 8601)")
+      }
+    },
+    async ({ id, title, synopsis, medium, tags, startDate, targetDate }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (medium !== void 0) input.medium = medium;
+        if (tags !== void 0) input.tags = tags;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (targetDate !== void 0) input.targetDate = targetDate;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/synopsis/medium/tags/startDate/targetDate"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PRODUCTION, { id, input });
+        return jsonResult(data.artUpdateProduction);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update production: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_transition")),
+    {
+      title: "Transition Production",
+      description: "Advance a production through its lifecycle (validated transitions: PLANNING \u2192 IN_PRODUCTION \u2192 REVIEW \u2192 POST \u2192 RELEASED, or ON_HOLD/CANCELLED).",
+      inputSchema: {
+        id: zod.z.string().describe("Production ID"),
+        status: ProductionStatusEnum.describe("Target lifecycle status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_PRODUCTION, { id, status });
+        return jsonResult(data.artTransitionProduction);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition production: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_list_members")),
+    {
+      title: "List Production Members",
+      description: "List the team members attached to a production.",
+      inputSchema: { productionId: zod.z.string().describe("Production ID") }
+    },
+    async ({ productionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PRODUCTION_MEMBERS, { productionId });
+        return jsonResult(data.artListProductionMembers);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_list_members failed", { error: String(error) });
+        return errorResult(
+          `Failed to list production members: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_add_member")),
+    {
+      title: "Add Production Member",
+      description: "Add a team member to a production with a role and optional title.",
+      inputSchema: {
+        productionId: zod.z.string().min(1).describe("Production ID"),
+        memberId: zod.z.string().min(1).describe("User ID of the team member (wspace-auth-svc)"),
+        role: ProductionRoleEnum.optional().describe("Member role (default COLLABORATOR)"),
+        title: zod.z.string().optional().describe("Credit/title on the production"),
+        isLead: zod.z.boolean().optional().describe("Whether the member is a lead (default false)")
+      }
+    },
+    async ({ productionId, memberId, role, title, isLead }) => {
+      try {
+        const input = { productionId, memberId };
+        if (role !== void 0) input.role = role;
+        if (title !== void 0) input.title = title;
+        if (isLead !== void 0) input.isLead = isLead;
+        const data = await ctx.gql.workspace.request(ADD_PRODUCTION_MEMBER, { input });
+        return jsonResult(data.artAddProductionMember);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_add_member failed", { error: String(error) });
+        return errorResult(
+          `Failed to add production member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_remove_member")),
+    {
+      title: "Remove Production Member",
+      description: "Remove a team member from a production. Returns whether removal succeeded.",
+      inputSchema: { id: zod.z.string().describe("Production member ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_PRODUCTION_MEMBER,
+          { id }
+        );
+        return jsonResult({ ok: data.artRemoveProductionMember });
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_remove_member failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove production member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_list_references")),
+    {
+      title: "List References",
+      description: "List reference material attached to a production (mood boards, links, files).",
+      inputSchema: { productionId: zod.z.string().describe("Production ID") }
+    },
+    async ({ productionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REFERENCES, { productionId });
+        return jsonResult(data.artListReferences);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_list_references failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to list references: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_add_reference")),
+    {
+      title: "Add Reference",
+      description: "Attach reference material to a production. Provide a title and optionally a URL and/or a File ID.",
+      inputSchema: {
+        productionId: zod.z.string().min(1).describe("Production ID"),
+        title: zod.z.string().min(1).describe("Reference title"),
+        note: zod.z.string().optional().describe("Note about the reference"),
+        url: zod.z.string().optional().describe("External URL"),
+        fileId: zod.z.string().optional().describe("Attached File ID (wspace-files-svc)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ productionId, title, note, url, fileId, tags }) => {
+      try {
+        const input = { productionId, title };
+        if (note !== void 0) input.note = note;
+        if (url !== void 0) input.url = url;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(ADD_REFERENCE, { input });
+        return jsonResult(data.artAddReference);
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_add_reference failed", { error: String(error) });
+        return errorResult(
+          `Failed to add reference: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "productions_remove_reference")),
+    {
+      title: "Remove Reference",
+      description: "Remove reference material from a production. Returns whether removal succeeded.",
+      inputSchema: { id: zod.z.string().describe("Reference ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_REFERENCE,
+          { id }
+        );
+        return jsonResult({ ok: data.artRemoveReference });
+      } catch (error) {
+        ctx.logger.error("artistrybase productions_remove_reference failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to remove reference: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReviewTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_get_round")),
+    {
+      title: "Get Review Round",
+      description: "Fetch a single review round by ID, including its in-context feedback and approvals.",
+      inputSchema: { id: zod.z.string().describe("Review round ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_REVIEW_ROUND, { id });
+        if (!data.artReviewRound) return errorResult(`Review round ${id} not found`);
+        return jsonResult(data.artReviewRound);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_get_round failed", { error: String(error) });
+        return errorResult(
+          `Failed to get review round: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_list_rounds")),
+    {
+      title: "List Review Rounds",
+      description: "List the review rounds for a work, optionally filtered by status.",
+      inputSchema: {
+        workId: zod.z.string().describe("Work ID"),
+        status: ReviewStatusEnum.optional().describe("Filter by review status")
+      }
+    },
+    async ({ workId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REVIEW_ROUNDS, { workId, status });
+        return jsonResult(data.artListReviewRounds);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_list_rounds failed", { error: String(error) });
+        return errorResult(
+          `Failed to list review rounds: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_open_round")),
+    {
+      title: "Open Review Round",
+      description: "Open a new review round on a work (optionally pinned to a specific version), with an optional title and due date.",
+      inputSchema: {
+        workId: zod.z.string().min(1).describe("Work ID"),
+        versionId: zod.z.string().optional().describe("Version to review (defaults to current)"),
+        title: zod.z.string().optional().describe("Round title"),
+        dueDate: zod.z.string().optional().describe("Due date (ISO 8601)")
+      }
+    },
+    async ({ workId, versionId, title, dueDate }) => {
+      try {
+        const input = { workId };
+        if (versionId !== void 0) input.versionId = versionId;
+        if (title !== void 0) input.title = title;
+        if (dueDate !== void 0) input.dueDate = dueDate;
+        const data = await ctx.gql.workspace.request(OPEN_REVIEW_ROUND, { input });
+        return jsonResult(data.artOpenReviewRound);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_open_round failed", { error: String(error) });
+        return errorResult(
+          `Failed to open review round: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_transition_round")),
+    {
+      title: "Transition Review Round",
+      description: "Advance a review round through its lifecycle (validated transitions: OPEN \u2192 CHANGES_REQUESTED/APPROVED \u2192 CLOSED).",
+      inputSchema: {
+        id: zod.z.string().describe("Review round ID"),
+        status: ReviewStatusEnum.describe("Target review status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_REVIEW_ROUND, { id, status });
+        return jsonResult(data.artTransitionReviewRound);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_transition_round failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition review round: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_add_feedback")),
+    {
+      title: "Add Feedback",
+      description: "Add a piece of in-context feedback to a review round. Anchor it to a timecode/page/chapter/pin via `anchorType` + `anchorValue` (defaults to GENERAL).",
+      inputSchema: {
+        reviewRoundId: zod.z.string().min(1).describe("Review round ID"),
+        body: zod.z.string().min(1).describe("Feedback body"),
+        anchorType: AnchorTypeEnum.optional().describe("Anchor type (default GENERAL)"),
+        anchorValue: zod.z.string().optional().describe('Anchor value (e.g. timecode "00:01:23", page number, pin coordinates)')
+      }
+    },
+    async ({ reviewRoundId, body, anchorType, anchorValue }) => {
+      try {
+        const input = { reviewRoundId, body };
+        if (anchorType !== void 0) input.anchorType = anchorType;
+        if (anchorValue !== void 0) input.anchorValue = anchorValue;
+        const data = await ctx.gql.workspace.request(ADD_FEEDBACK, { input });
+        return jsonResult(data.artAddFeedback);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_add_feedback failed", { error: String(error) });
+        return errorResult(
+          `Failed to add feedback: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_resolve_feedback")),
+    {
+      title: "Resolve Feedback",
+      description: "Set the resolution status of a piece of feedback (RESOLVED / WONT_FIX / OPEN).",
+      inputSchema: {
+        id: zod.z.string().describe("Feedback ID"),
+        status: FeedbackStatusEnum.describe("New feedback status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RESOLVE_FEEDBACK, { id, status });
+        return jsonResult(data.artResolveFeedback);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_resolve_feedback failed", { error: String(error) });
+        return errorResult(
+          `Failed to resolve feedback: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_record_approval")),
+    {
+      title: "Record Approval",
+      description: "Record an approval decision (APPROVED / REJECTED / PENDING) on a review round, with an optional comment.",
+      inputSchema: {
+        reviewRoundId: zod.z.string().min(1).describe("Review round ID"),
+        decision: ApprovalDecisionEnum.describe("Approval decision"),
+        comment: zod.z.string().optional().describe("Optional comment explaining the decision")
+      }
+    },
+    async ({ reviewRoundId, decision, comment }) => {
+      try {
+        const input = { reviewRoundId, decision };
+        if (comment !== void 0) input.comment = comment;
+        const data = await ctx.gql.workspace.request(RECORD_APPROVAL, { input });
+        return jsonResult(data.artRecordApproval);
+      } catch (error) {
+        ctx.logger.error("artistrybase reviews_record_approval failed", { error: String(error) });
+        return errorResult(
+          `Failed to record approval: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "releases_list")),
+    {
+      title: "List Releases",
+      description: "List the releases of a work, optionally filtered by status.",
+      inputSchema: {
+        workId: zod.z.string().describe("Work ID"),
+        status: ReleaseStatusEnum.optional().describe("Filter by release status")
+      }
+    },
+    async ({ workId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RELEASES, { workId, status });
+        return jsonResult(data.artListReleases);
+      } catch (error) {
+        ctx.logger.error("artistrybase releases_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list releases: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "releases_create")),
+    {
+      title: "Create Release",
+      description: "Create a release for a work (optionally pinned to a version), with an optional channel, visibility, notes, and a scheduled time.",
+      inputSchema: {
+        workId: zod.z.string().min(1).describe("Work ID"),
+        versionId: zod.z.string().optional().describe("Version to release (defaults to current)"),
+        channel: zod.z.string().optional().describe('Release channel (e.g. "store", "preview")'),
+        notes: zod.z.string().optional().describe("Release notes"),
+        scheduledFor: zod.z.string().optional().describe("Scheduled release time (ISO 8601)"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default PUBLIC)")
+      }
+    },
+    async ({ workId, versionId, channel, notes, scheduledFor, visibility }) => {
+      try {
+        const input = { workId };
+        if (versionId !== void 0) input.versionId = versionId;
+        if (channel !== void 0) input.channel = channel;
+        if (notes !== void 0) input.notes = notes;
+        if (scheduledFor !== void 0) input.scheduledFor = scheduledFor;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(CREATE_RELEASE, { input });
+        return jsonResult(data.artCreateRelease);
+      } catch (error) {
+        ctx.logger.error("artistrybase releases_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create release: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "releases_publish")),
+    {
+      title: "Publish Release",
+      description: "Publish a scheduled/draft release now.",
+      inputSchema: { id: zod.z.string().describe("Release ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_RELEASE, { id });
+        return jsonResult(data.artPublishRelease);
+      } catch (error) {
+        ctx.logger.error("artistrybase releases_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish release: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPortfolioTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_get")),
+    {
+      title: "Get Portfolio",
+      description: "Fetch a single public portfolio by ID.",
+      inputSchema: { id: zod.z.string().describe("Portfolio ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PORTFOLIO, { id });
+        if (!data.artPortfolio) return errorResult(`Portfolio ${id} not found`);
+        return jsonResult(data.artPortfolio);
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get portfolio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_list")),
+    {
+      title: "List Portfolios",
+      description: "List public portfolios with optional visibility filter and cursor/offset pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        visibility: VisibilityEnum.optional().describe("Filter by visibility"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ visibility, 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_PORTFOLIOS, { visibility, pagination });
+        return jsonResult(data.artListPortfolios);
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list portfolios: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_create")),
+    {
+      title: "Create Portfolio",
+      description: "Create a public portfolio. `handle` must be unique within the workspace; starts PUBLIC unless overridden.",
+      inputSchema: {
+        handle: zod.z.string().min(1).describe('Unique handle (e.g. "@anbu")'),
+        displayName: zod.z.string().min(1).describe("Display name"),
+        bio: zod.z.string().optional().describe("Short bio"),
+        avatarFileId: zod.z.string().optional().describe("Avatar image File ID"),
+        bannerFileId: zod.z.string().optional().describe("Banner image File ID"),
+        featuredWorkIds: zod.z.array(zod.z.string()).optional().describe("Featured work IDs"),
+        links: JsonObject.optional().describe("Social/external links JSON"),
+        ownerId: zod.z.string().optional().describe("Owner User ID (defaults to the calling actor)"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default PUBLIC)")
+      }
+    },
+    async ({
+      handle,
+      displayName,
+      bio,
+      avatarFileId,
+      bannerFileId,
+      featuredWorkIds,
+      links,
+      ownerId,
+      visibility
+    }) => {
+      try {
+        const input = { handle, displayName };
+        if (bio !== void 0) input.bio = bio;
+        if (avatarFileId !== void 0) input.avatarFileId = avatarFileId;
+        if (bannerFileId !== void 0) input.bannerFileId = bannerFileId;
+        if (featuredWorkIds !== void 0) input.featuredWorkIds = featuredWorkIds;
+        if (links !== void 0) input.links = links;
+        if (ownerId !== void 0) input.ownerId = ownerId;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(CREATE_PORTFOLIO, { input });
+        return jsonResult(data.artCreatePortfolio);
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create portfolio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_update")),
+    {
+      title: "Update Portfolio",
+      description: "Update a portfolio. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Portfolio ID"),
+        displayName: zod.z.string().optional().describe("Updated display name"),
+        bio: zod.z.string().optional().describe("Updated bio"),
+        avatarFileId: zod.z.string().optional().describe("Updated avatar File ID"),
+        bannerFileId: zod.z.string().optional().describe("Updated banner File ID"),
+        featuredWorkIds: zod.z.array(zod.z.string()).optional().describe("Updated featured work IDs"),
+        links: JsonObject.optional().describe("Updated links JSON"),
+        visibility: VisibilityEnum.optional().describe("Updated visibility")
+      }
+    },
+    async ({
+      id,
+      displayName,
+      bio,
+      avatarFileId,
+      bannerFileId,
+      featuredWorkIds,
+      links,
+      visibility
+    }) => {
+      try {
+        const input = {};
+        if (displayName !== void 0) input.displayName = displayName;
+        if (bio !== void 0) input.bio = bio;
+        if (avatarFileId !== void 0) input.avatarFileId = avatarFileId;
+        if (bannerFileId !== void 0) input.bannerFileId = bannerFileId;
+        if (featuredWorkIds !== void 0) input.featuredWorkIds = featuredWorkIds;
+        if (links !== void 0) input.links = links;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of displayName/bio/avatarFileId/bannerFileId/featuredWorkIds/links/visibility"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PORTFOLIO, { id, input });
+        return jsonResult(data.artUpdatePortfolio);
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update portfolio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_archive")),
+    {
+      title: "Archive Portfolio",
+      description: "Archive a portfolio (soft delete). Returns whether the archive succeeded.",
+      inputSchema: { id: zod.z.string().describe("Portfolio ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_PORTFOLIO,
+          { id }
+        );
+        return jsonResult({ ok: data.artArchivePortfolio });
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive portfolio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_follow")),
+    {
+      title: "Follow Portfolio",
+      description: "Follow a portfolio as the calling actor (self-scoped). `notify` toggles new-work notifications (default true).",
+      inputSchema: {
+        portfolioId: zod.z.string().describe("Portfolio ID to follow"),
+        notify: zod.z.boolean().optional().describe("Receive notifications (default true)")
+      }
+    },
+    async ({ portfolioId, notify }) => {
+      try {
+        const data = await ctx.gql.workspace.request(FOLLOW_PORTFOLIO, { portfolioId, notify });
+        return jsonResult(data.artFollowPortfolio);
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_follow failed", { error: String(error) });
+        return errorResult(
+          `Failed to follow portfolio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "portfolios_unfollow")),
+    {
+      title: "Unfollow Portfolio",
+      description: "Unfollow a portfolio as the calling actor (self-scoped). Returns whether the unfollow succeeded.",
+      inputSchema: { portfolioId: zod.z.string().describe("Portfolio ID to unfollow") }
+    },
+    async ({ portfolioId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          UNFOLLOW_PORTFOLIO,
+          { portfolioId }
+        );
+        return jsonResult({ ok: data.artUnfollowPortfolio });
+      } catch (error) {
+        ctx.logger.error("artistrybase portfolios_unfollow failed", { error: String(error) });
+        return errorResult(
+          `Failed to unfollow portfolio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "licenses_list")),
+    {
+      title: "List Licenses",
+      description: "List the license terms defined on a work.",
+      inputSchema: { workId: zod.z.string().describe("Work ID") }
+    },
+    async ({ workId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_LICENSES, { workId });
+        return jsonResult(data.artListLicenses);
+      } catch (error) {
+        ctx.logger.error("artistrybase licenses_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list licenses: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "licenses_create")),
+    {
+      title: "Create License",
+      description: "Create a license on a work. `model` defaults to FREE; set `priceAmount`/`currency` for PURCHASE/LICENSE/MEMBERSHIP models.",
+      inputSchema: {
+        workId: zod.z.string().min(1).describe("Work ID the license applies to"),
+        name: zod.z.string().min(1).describe("License name"),
+        model: LicenseModelEnum.optional().describe("Commercial model (default FREE)"),
+        priceAmount: zod.z.number().optional().describe("Price amount"),
+        currency: zod.z.string().optional().describe('ISO currency code (e.g. "USD")'),
+        spdx: zod.z.string().optional().describe('SPDX identifier (e.g. "CC-BY-4.0")'),
+        terms: zod.z.string().optional().describe("Full license terms text"),
+        attribution: zod.z.string().optional().describe("Required attribution string")
+      }
+    },
+    async ({ workId, name, model, priceAmount, currency, spdx, terms, attribution }) => {
+      try {
+        const input = { workId, name };
+        if (model !== void 0) input.model = model;
+        if (priceAmount !== void 0) input.priceAmount = priceAmount;
+        if (currency !== void 0) input.currency = currency;
+        if (spdx !== void 0) input.spdx = spdx;
+        if (terms !== void 0) input.terms = terms;
+        if (attribution !== void 0) input.attribution = attribution;
+        const data = await ctx.gql.workspace.request(CREATE_LICENSE, { input });
+        return jsonResult(data.artCreateLicense);
+      } catch (error) {
+        ctx.logger.error("artistrybase licenses_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create license: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "licenses_update")),
+    {
+      title: "Update License",
+      description: "Update a license. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("License ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        model: LicenseModelEnum.optional().describe("Updated commercial model"),
+        priceAmount: zod.z.number().optional().describe("Updated price amount"),
+        currency: zod.z.string().optional().describe("Updated currency code"),
+        spdx: zod.z.string().optional().describe("Updated SPDX identifier"),
+        terms: zod.z.string().optional().describe("Updated terms text"),
+        attribution: zod.z.string().optional().describe("Updated attribution string")
+      }
+    },
+    async ({ id, name, model, priceAmount, currency, spdx, terms, attribution }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (model !== void 0) input.model = model;
+        if (priceAmount !== void 0) input.priceAmount = priceAmount;
+        if (currency !== void 0) input.currency = currency;
+        if (spdx !== void 0) input.spdx = spdx;
+        if (terms !== void 0) input.terms = terms;
+        if (attribution !== void 0) input.attribution = attribution;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/model/priceAmount/currency/spdx/terms/attribution"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_LICENSE, { id, input });
+        return jsonResult(data.artUpdateLicense);
+      } catch (error) {
+        ctx.logger.error("artistrybase licenses_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update license: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "licenses_activate")),
+    {
+      title: "Activate License",
+      description: "Activate a draft license so it becomes purchasable/effective.",
+      inputSchema: { id: zod.z.string().describe("License ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ACTIVATE_LICENSE, { id });
+        return jsonResult(data.artActivateLicense);
+      } catch (error) {
+        ctx.logger.error("artistrybase licenses_activate failed", { error: String(error) });
+        return errorResult(
+          `Failed to activate license: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/artistrybase/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Artistrybase Health Check",
+      description: "Public health probe for the Artistrybase subgraph (artHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.artHealth });
+      } catch (error) {
+        ctx.logger.error("artistrybase health failed", { error: String(error) });
+        return errorResult(
+          `Artistrybase health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/artistrybase/resources.ts
+function registerArtistrybaseResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const worksUri = track(mcpResourceUri(ctx.productName, "works"));
+  const productionsUri = track(mcpResourceUri(ctx.productName, "productions"));
+  const portfoliosUri = track(mcpResourceUri(ctx.productName, "portfolios"));
+  server.registerResource(
+    "artistrybase-schema",
+    schemaUri,
+    {
+      title: "Artistrybase Domain Schema",
+      description: "Overview of the Artistrybase creative-platform domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Artistrybase Domain (Overview)
+
+Multi-medium creative platform (audio, video, stories, art) \u2014 the federated
+system of record for creative works, versions, collections, productions, the
+review/release pipeline, public portfolios, follows, and licensing.
+
+## Domains & entities
+- library: ArtWork (any medium), ArtWorkVersion (immutable history), ArtAsset (file assets), ArtCollection (curated)
+- production: ArtProduction (a film/album/graphic novel), ArtProductionMember (team), ArtReference (mood boards/links)
+- review: ArtReviewRound, ArtFeedback (timecode/chapter/pin anchors), ArtApproval, ArtRelease (draft\u2192released pipeline)
+- portfolio: ArtPortfolio (public, spans every medium), ArtFollow, ArtLicense (explicit terms on works)
+
+File blobs are never stored here \u2014 works/versions/assets reference a wspace-files-svc File by id via federation.
+
+## Enums
+- ArtMedium: ART, AUDIO, MIXED, STORY, VIDEO
+- ArtVisibility: PRIVATE, PUBLIC, UNLISTED
+- ArtWorkStatus: APPROVED, ARCHIVED, DRAFT, IN_REVIEW, RELEASED
+- ArtAssetKind: ATTACHMENT, CAPTION, COVER, MASTER, PREVIEW, SOURCE
+- ArtProductionStatus: CANCELLED, IN_PRODUCTION, ON_HOLD, PLANNING, POST, RELEASED, REVIEW
+- ArtProductionRole: COLLABORATOR, CREATOR, EDITOR, OWNER, PRODUCER, REVIEWER, VIEWER
+- ArtReviewStatus: APPROVED, CHANGES_REQUESTED, CLOSED, OPEN
+- ArtFeedbackStatus: OPEN, RESOLVED, WONT_FIX
+- ArtAnchorType: CHAPTER, GENERAL, PAGE, PIN, TIMECODE
+- ArtApprovalDecision: APPROVED, PENDING, REJECTED
+- ArtReleaseStatus: FAILED, PUBLISHED, SCHEDULED, UNPUBLISHED
+- ArtLicenseModel: FREE, LICENSE, MEMBERSHIP, PURCHASE
+
+## Tool groups
+library (works/versions/assets/collections), production (productions/members/references),
+review (review_rounds/feedback/approvals/releases), portfolio (portfolios/follows/licenses), health.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "artistrybase-works",
+    worksUri,
+    {
+      title: "Artistrybase Works",
+      description: "The first 50 creative works in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${worksUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORKS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: worksUri,
+              text: JSON.stringify(data.artListWorks, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: worksUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "artistrybase-productions",
+    productionsUri,
+    {
+      title: "Artistrybase Productions",
+      description: "The first 50 productions in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${productionsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PRODUCTIONS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: productionsUri,
+              text: JSON.stringify(data.artListProductions, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: productionsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "artistrybase-portfolios",
+    portfoliosUri,
+    {
+      title: "Artistrybase Portfolios",
+      description: "The first 50 public portfolios in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${portfoliosUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PORTFOLIOS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: portfoliosUri,
+              text: JSON.stringify(data.artListPortfolios, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: portfoliosUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerArtistrybasePrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const publishingName = track(mcpPromptName(p, "work-publishing"));
+  const productionName = track(mcpPromptName(p, "production-ops"));
+  server.registerPrompt(
+    publishingName,
+    {
+      title: "Work Publishing",
+      description: "Guide for taking a creative work from draft to released: create the work, upload a version, run a review round, record approval, then create and publish a release.",
+      argsSchema: {
+        title: zod.z.string().optional().describe("Work title"),
+        medium: zod.z.string().optional().describe("Creative medium (ART/AUDIO/STORY/VIDEO/MIXED)")
+      }
+    },
+    ({ title, medium }) => {
+      ctx.logger.debug(`Prompt ${publishingName} called`, { title, medium });
+      const titleNote = title ? `Use the work title "${title}".` : "Ask the user for the work title.";
+      const mediumNote = medium ? `Use medium ${medium}.` : "Help the user pick an ArtMedium.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me take an Artistrybase work from draft to released.
+
+1. **Create Work**: Use ${p}_works_create. ${titleNote} ${mediumNote} Optionally attach a coverFileId and tags.
+2. **Upload a Version**: Use ${p}_versions_add with the workId and a source fileId (from wspace-files-svc) to create an immutable revision.
+3. **Attach Assets**: Use ${p}_assets_add for masters/previews/captions as needed (kind=MASTER/PREVIEW/CAPTION).
+4. **Open Review**: Use ${p}_review_rounds_open for the work (optionally pin a versionId, set a dueDate).
+5. **Collect Feedback**: Use ${p}_feedback_add (anchorType=TIMECODE/PAGE/CHAPTER/PIN) and resolve with ${p}_feedback_resolve.
+6. **Record Approval**: Use ${p}_approvals_record (decision=APPROVED) on the review round, then ${p}_review_rounds_transition to CLOSED.
+7. **Publish Version**: Use ${p}_works_publish_version to promote the approved version as current.
+8. **Release**: Use ${p}_releases_create (set channel/visibility), then ${p}_releases_publish.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    productionName,
+    {
+      title: "Production Operations",
+      description: "Workflow for running a production: assemble the team, gather references, track works through the pipeline, and advance the production lifecycle.",
+      argsSchema: {
+        productionId: zod.z.string().optional().describe("Production ID to operate")
+      }
+    },
+    ({ productionId }) => {
+      ctx.logger.debug(`Prompt ${productionName} called`, { productionId });
+      const productionNote = productionId ? `Operate production "${productionId}".` : `First list productions with ${p}_productions_list and pick one (or create one with ${p}_productions_create).`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run Artistrybase production operations. ${productionNote}
+
+1. **Team**: Use ${p}_members_list to see the team; add collaborators with ${p}_members_add (role=EDITOR/PRODUCER/REVIEWER/...).
+2. **References**: Use ${p}_references_list and ${p}_references_add to gather mood boards, links, and reference files.
+3. **Works**: Use ${p}_works_list filtered by this productionId to track works; create new ones with ${p}_works_create (productionId set).
+4. **Review**: For works in IN_REVIEW, use ${p}_review_rounds_list and ${p}_review_rounds_get to triage open feedback.
+5. **Advance**: Use ${p}_productions_transition to move the production through PLANNING \u2192 IN_PRODUCTION \u2192 REVIEW \u2192 POST \u2192 RELEASED.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/artistrybase/index.ts
+var artistrybaseModule = {
+  id: "artistrybase",
+  version: "0.0.1",
+  displayName: "Artistrybase",
+  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;
+    };
+    registerLibraryTools(server, ctx, trackTool);
+    registerProductionTools(server, ctx, trackTool);
+    registerReviewTools(server, ctx, trackTool);
+    registerPortfolioTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerArtistrybaseResources(server, ctx, trackResource);
+    registerArtistrybasePrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var artistrybase_default = artistrybaseModule;
+
+module.exports = artistrybase_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map