@burdenoff/mcp-libs 2026.627.6 → 2026.629.1

package/dist/modules/hookmovies/index.cjs

@@ -0,0 +1,2024 @@
+'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/hookmovies/tools/titles.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/hookmovies/operations.ts
+var PAGE_INFO = `pageInfo { cursor hasMore }`;
+var TITLE_FIELDS = `
+  id title slug type status synopsis genres tags originalLanguage originCountry
+  releaseDate releaseYear runtimeMinutes certification aiDisclosure externalIds
+  studioId workspaceId createdAt updatedAt
+`;
+var STUDIO_FIELDS = `
+  id name slug description country websiteUrl isVerified tags
+  workspaceId createdAt updatedAt
+`;
+var PERSON_FIELDS = `
+  id name biography knownFor primaryLanguage portfolioRef tags
+  workspaceId createdAt updatedAt
+`;
+var CREDIT_FIELDS = `
+  id titleId personId role characterName billingOrder
+  workspaceId createdAt updatedAt
+`;
+var SEASON_FIELDS = `
+  id titleId number name synopsis airDate workspaceId createdAt updatedAt
+`;
+var EPISODE_FIELDS = `
+  id titleId seasonId number name synopsis runtimeMinutes airDate
+  file { id } workspaceId createdAt updatedAt
+`;
+var PRODUCTION_FIELDS = `
+  id title status logline synopsis tags studioId producerId currency
+  budgetMinorUnits startDate endDate resultingTitleId artistrybaseProjectRef
+  workspaceId createdAt updatedAt
+`;
+var AUDITION_FIELDS = `
+  id productionId roleName description status isMinorRole language location
+  currency payMinorUnits submissionDeadline workspaceId createdAt updatedAt
+`;
+var APPLICATION_FIELDS = `
+  id auditionId applicantId coverNote status score selfTape { id }
+  workspaceId createdAt updatedAt
+`;
+var REVIEW_FIELDS = `
+  id titleId authorId score body aspectScores hasSpoilers verifiedWatch
+  helpfulCount status workspaceId createdAt updatedAt
+`;
+var RIGHTS_WINDOW_FIELDS = `
+  id titleId licenseeId modes territories exclusive priceMinorUnits currency
+  startsAt endsAt status contractFileId workspaceId createdAt updatedAt
+`;
+var ENTITLEMENT_FIELDS = `
+  id titleId userId mode source status territory expiresAt
+  workspaceId createdAt updatedAt
+`;
+var LIST_FIELDS = `
+  id name description kind visibility itemCount items ownerId
+  workspaceId createdAt updatedAt
+`;
+var WATCH_PROGRESS_FIELDS = `
+  id titleId episodeId userId positionSeconds completed lastDevice
+  workspaceId createdAt updatedAt
+`;
+var GET_TITLE = `
+  query HookmoviesGetTitle($id: ID!) {
+    hokTitle(id: $id) {
+      ${TITLE_FIELDS}
+      studio { id name slug }
+      credits { ${CREDIT_FIELDS} }
+      seasons { ${SEASON_FIELDS} }
+      episodes { ${EPISODE_FIELDS} }
+    }
+  }
+`;
+var LIST_TITLES = `
+  query HookmoviesListTitles(
+    $pagination: PaginationInput
+    $status: HokTitleStatus
+    $studioId: ID
+    $type: HokTitleType
+  ) {
+    hokListTitles(pagination: $pagination, status: $status, studioId: $studioId, type: $type) {
+      items { ${TITLE_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_TITLE = `
+  mutation HookmoviesCreateTitle($input: HokCreateTitleInput!) {
+    hokCreateTitle(input: $input) {
+      ${TITLE_FIELDS}
+    }
+  }
+`;
+var UPDATE_TITLE = `
+  mutation HookmoviesUpdateTitle($id: ID!, $input: HokUpdateTitleInput!) {
+    hokUpdateTitle(id: $id, input: $input) {
+      ${TITLE_FIELDS}
+    }
+  }
+`;
+var TRANSITION_TITLE = `
+  mutation HookmoviesTransitionTitle($id: ID!, $status: HokTitleStatus!) {
+    hokTransitionTitle(id: $id, status: $status) {
+      ${TITLE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_TITLE = `
+  mutation HookmoviesArchiveTitle($id: ID!) {
+    hokArchiveTitle(id: $id)
+  }
+`;
+var LIST_STUDIOS = `
+  query HookmoviesListStudios($pagination: PaginationInput) {
+    hokListStudios(pagination: $pagination) {
+      items { ${STUDIO_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_STUDIO = `
+  mutation HookmoviesCreateStudio($input: HokCreateStudioInput!) {
+    hokCreateStudio(input: $input) {
+      ${STUDIO_FIELDS}
+    }
+  }
+`;
+var LIST_PEOPLE = `
+  query HookmoviesListPeople($pagination: PaginationInput) {
+    hokListPeople(pagination: $pagination) {
+      items {
+        ${PERSON_FIELDS}
+        credits { ${CREDIT_FIELDS} }
+      }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_PERSON = `
+  mutation HookmoviesCreatePerson($input: HokCreatePersonInput!) {
+    hokCreatePerson(input: $input) {
+      ${PERSON_FIELDS}
+    }
+  }
+`;
+var ADD_CREDIT = `
+  mutation HookmoviesAddCredit($input: HokCreateCreditInput!) {
+    hokAddCredit(input: $input) {
+      ${CREDIT_FIELDS}
+      person { id name }
+    }
+  }
+`;
+var CREATE_SEASON = `
+  mutation HookmoviesCreateSeason($input: HokCreateSeasonInput!) {
+    hokCreateSeason(input: $input) {
+      ${SEASON_FIELDS}
+    }
+  }
+`;
+var LIST_EPISODES = `
+  query HookmoviesListEpisodes($titleId: ID!) {
+    hokListEpisodes(titleId: $titleId) {
+      ${EPISODE_FIELDS}
+    }
+  }
+`;
+var CREATE_EPISODE = `
+  mutation HookmoviesCreateEpisode($input: HokCreateEpisodeInput!) {
+    hokCreateEpisode(input: $input) {
+      ${EPISODE_FIELDS}
+    }
+  }
+`;
+var GET_PRODUCTION = `
+  query HookmoviesGetProduction($id: ID!) {
+    hokProduction(id: $id) {
+      ${PRODUCTION_FIELDS}
+      auditions { ${AUDITION_FIELDS} }
+    }
+  }
+`;
+var LIST_PRODUCTIONS = `
+  query HookmoviesListProductions(
+    $pagination: PaginationInput
+    $status: HokProductionStatus
+    $studioId: ID
+  ) {
+    hokListProductions(pagination: $pagination, status: $status, studioId: $studioId) {
+      items { ${PRODUCTION_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_PRODUCTION = `
+  mutation HookmoviesCreateProduction($input: HokCreateProductionInput!) {
+    hokCreateProduction(input: $input) {
+      ${PRODUCTION_FIELDS}
+    }
+  }
+`;
+var TRANSITION_PRODUCTION = `
+  mutation HookmoviesTransitionProduction($id: ID!, $status: HokProductionStatus!) {
+    hokTransitionProduction(id: $id, status: $status) {
+      ${PRODUCTION_FIELDS}
+    }
+  }
+`;
+var LIST_AUDITIONS = `
+  query HookmoviesListAuditions(
+    $pagination: PaginationInput
+    $productionId: ID
+    $status: HokAuditionStatus
+  ) {
+    hokListAuditions(pagination: $pagination, productionId: $productionId, status: $status) {
+      items { ${AUDITION_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_AUDITION = `
+  mutation HookmoviesCreateAudition($input: HokCreateAuditionInput!) {
+    hokCreateAudition(input: $input) {
+      ${AUDITION_FIELDS}
+    }
+  }
+`;
+var CLOSE_AUDITION = `
+  mutation HookmoviesCloseAudition($id: ID!) {
+    hokCloseAudition(id: $id) {
+      ${AUDITION_FIELDS}
+    }
+  }
+`;
+var LIST_APPLICATIONS = `
+  query HookmoviesListApplications($auditionId: ID!) {
+    hokListApplications(auditionId: $auditionId) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var APPLY_TO_AUDITION = `
+  mutation HookmoviesApplyToAudition($input: HokApplyToAuditionInput!) {
+    hokApplyToAudition(input: $input) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var SCORE_APPLICATION = `
+  mutation HookmoviesScoreApplication($id: ID!, $score: Int!) {
+    hokScoreApplication(id: $id, score: $score) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var LIST_REVIEWS = `
+  query HookmoviesListReviews(
+    $pagination: PaginationInput
+    $status: HokReviewStatus
+    $titleId: ID
+  ) {
+    hokListReviews(pagination: $pagination, status: $status, titleId: $titleId) {
+      items { ${REVIEW_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_REVIEW = `
+  mutation HookmoviesCreateReview($input: HokCreateReviewInput!) {
+    hokCreateReview(input: $input) {
+      ${REVIEW_FIELDS}
+    }
+  }
+`;
+var DELETE_REVIEW = `
+  mutation HookmoviesDeleteReview($id: ID!) {
+    hokDeleteReview(id: $id)
+  }
+`;
+var LIST_RIGHTS_WINDOWS = `
+  query HookmoviesListRightsWindows(
+    $pagination: PaginationInput
+    $status: HokRightsWindowStatus
+    $titleId: ID
+  ) {
+    hokListRightsWindows(pagination: $pagination, status: $status, titleId: $titleId) {
+      items { ${RIGHTS_WINDOW_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_RIGHTS_WINDOW = `
+  mutation HookmoviesCreateRightsWindow($input: HokCreateRightsWindowInput!) {
+    hokCreateRightsWindow(input: $input) {
+      ${RIGHTS_WINDOW_FIELDS}
+    }
+  }
+`;
+var TRANSITION_RIGHTS_WINDOW = `
+  mutation HookmoviesTransitionRightsWindow($id: ID!, $status: HokRightsWindowStatus!) {
+    hokTransitionRightsWindow(id: $id, status: $status) {
+      ${RIGHTS_WINDOW_FIELDS}
+    }
+  }
+`;
+var GRANT_ENTITLEMENT = `
+  mutation HookmoviesGrantEntitlement($input: HokGrantEntitlementInput!) {
+    hokGrantEntitlement(input: $input) {
+      ${ENTITLEMENT_FIELDS}
+    }
+  }
+`;
+var REVOKE_ENTITLEMENT = `
+  mutation HookmoviesRevokeEntitlement($id: ID!) {
+    hokRevokeEntitlement(id: $id)
+  }
+`;
+var MY_ENTITLEMENTS = `
+  query HookmoviesMyEntitlements($titleId: ID) {
+    hokMyEntitlements(titleId: $titleId) {
+      ${ENTITLEMENT_FIELDS}
+    }
+  }
+`;
+var CHECK_ENTITLEMENT = `
+  query HookmoviesCheckEntitlement($titleId: ID!) {
+    hokCheckEntitlement(titleId: $titleId) {
+      entitled
+      modes
+    }
+  }
+`;
+var GET_LIST = `
+  query HookmoviesGetList($id: ID!) {
+    hokList(id: $id) {
+      ${LIST_FIELDS}
+    }
+  }
+`;
+var MY_LISTS = `
+  query HookmoviesMyLists($kind: HokListKind, $pagination: PaginationInput) {
+    hokMyLists(kind: $kind, pagination: $pagination) {
+      items { ${LIST_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_LIST = `
+  mutation HookmoviesCreateList($input: HokCreateListInput!) {
+    hokCreateList(input: $input) {
+      ${LIST_FIELDS}
+    }
+  }
+`;
+var UPDATE_LIST = `
+  mutation HookmoviesUpdateList($id: ID!, $input: HokUpdateListInput!) {
+    hokUpdateList(id: $id, input: $input) {
+      ${LIST_FIELDS}
+    }
+  }
+`;
+var DELETE_LIST = `
+  mutation HookmoviesDeleteList($id: ID!) {
+    hokDeleteList(id: $id)
+  }
+`;
+var RECORD_PROGRESS = `
+  mutation HookmoviesRecordProgress($input: HokRecordProgressInput!) {
+    hokRecordProgress(input: $input) {
+      ${WATCH_PROGRESS_FIELDS}
+    }
+  }
+`;
+var MY_WATCH_PROGRESS = `
+  query HookmoviesMyWatchProgress($titleId: ID) {
+    hokMyWatchProgress(titleId: $titleId) {
+      ${WATCH_PROGRESS_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query HookmoviesHealth {
+    hokHealth
+  }
+`;
+var TitleTypeEnum = zod.z.enum([
+  "ANIME",
+  "COLLECTION",
+  "DOCUMENTARY",
+  "FAST_CHANNEL",
+  "LIVE_EVENT",
+  "LONG_FORM",
+  "MOVIE",
+  "SERIES",
+  "SHORT_FILM",
+  "SHORT_FORM",
+  "TRAILER"
+]).describe("Kind of catalog title");
+var TitleStatusEnum = zod.z.enum(["ARCHIVED", "DRAFT", "IN_REVIEW", "PUBLISHED", "SCHEDULED", "UNPUBLISHED"]).describe("Publication lifecycle status of a title");
+var CreditRoleEnum = zod.z.enum([
+  "ACTOR",
+  "CINEMATOGRAPHER",
+  "COMPOSER",
+  "CREW",
+  "DIRECTOR",
+  "EDITOR",
+  "PRODUCER",
+  "VOICE_ACTOR",
+  "WRITER"
+]).describe("Role of a person credited on a title");
+var ProductionStatusEnum = zod.z.enum(["DEVELOPMENT", "GREENLIT", "IN_PRODUCTION", "POST_PRODUCTION", "RELEASED", "SHELVED"]).describe("Lifecycle status of a production");
+var AuditionStatusEnum = zod.z.enum(["CALLBACKS", "CANCELLED", "CLOSED", "OPEN", "REVIEWING"]).describe("Lifecycle status of an audition");
+zod.z.enum(["CALLBACK", "OFFERED", "REJECTED", "SHORTLISTED", "SUBMITTED", "WITHDRAWN"]).describe("Status of an audition application");
+var ReviewStatusEnum = zod.z.enum(["HIDDEN", "PENDING", "PUBLISHED", "REMOVED"]).describe("Moderation status of a review");
+var RightsWindowStatusEnum = zod.z.enum(["ACTIVE", "DRAFT", "EXPIRED", "PENDING", "REVOKED"]).describe("Lifecycle status of a rights window");
+var MonetizationModeEnum = zod.z.enum(["FAST", "FREE_AVOD", "PPV", "SVOD", "TVOD_BUY", "TVOD_RENT"]).describe("Monetization / distribution mode for a title");
+var EntitlementSourceEnum = zod.z.enum(["FREE", "PROMO", "PURCHASE", "RENTAL", "SUBSCRIPTION"]).describe("How an entitlement was acquired");
+var ListKindEnum = zod.z.enum(["PLAYLIST", "WATCHLIST"]).describe("Whether a user list is a PLAYLIST or a WATCHLIST");
+var ListVisibilityEnum = zod.z.enum(["PRIVATE", "PUBLIC", "UNLISTED"]).describe("Visibility of a user list");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+var JsonValue = zod.z.union([JsonObject, zod.z.array(zod.z.unknown())]).describe("Arbitrary JSON value (object or array)");
+
+// src/modules/hookmovies/tools/titles.ts
+function registerTitleTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "titles_get")),
+    {
+      title: "Get Title",
+      description: "Fetch a single HookMovies title by ID, including its studio, credits, seasons, and episodes.",
+      inputSchema: { id: zod.z.string().describe("Title ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_TITLE, { id });
+        if (!data.hokTitle) return errorResult(`Title ${id} not found`);
+        return jsonResult(data.hokTitle);
+      } catch (error) {
+        ctx.logger.error("hookmovies titles_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get title: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "titles_list")),
+    {
+      title: "List Titles",
+      description: "List catalog titles in the bound workspace, optionally filtered by status, studio, and/or title type, with pagination.",
+      inputSchema: {
+        status: TitleStatusEnum.optional().describe("Filter by publication status"),
+        studioId: zod.z.string().optional().describe("Filter by owning studio ID"),
+        type: TitleTypeEnum.optional().describe("Filter by title type"),
+        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, studioId, type, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TITLES, {
+          status,
+          studioId,
+          type,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListTitles);
+      } catch (error) {
+        ctx.logger.error("hookmovies titles_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list titles: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "titles_create")),
+    {
+      title: "Create Title",
+      description: "Create a catalog title (movie/series/etc.). `title` is required; defaults: type=MOVIE, aiDisclosure=false. Optionally attach to a studio.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Display title"),
+        type: TitleTypeEnum.optional().describe("Title type (default MOVIE)"),
+        slug: zod.z.string().optional().describe("URL slug, unique within the workspace"),
+        synopsis: zod.z.string().optional().describe("Synopsis / description"),
+        genres: zod.z.array(zod.z.string()).optional().describe("Genre tags"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags"),
+        originalLanguage: zod.z.string().optional().describe("Original language code"),
+        originCountry: zod.z.string().optional().describe("Country of origin code"),
+        releaseDate: zod.z.string().optional().describe("Release date (ISO-8601 DateTime)"),
+        releaseYear: zod.z.number().int().optional().describe("Release year"),
+        runtimeMinutes: zod.z.number().int().optional().describe("Runtime in minutes"),
+        certification: zod.z.string().optional().describe("Content certification / rating"),
+        aiDisclosure: zod.z.boolean().optional().describe("Whether AI involvement is disclosed"),
+        studioId: zod.z.string().optional().describe("Owning studio ID")
+      }
+    },
+    async ({
+      title,
+      type,
+      slug,
+      synopsis,
+      genres,
+      tags,
+      originalLanguage,
+      originCountry,
+      releaseDate,
+      releaseYear,
+      runtimeMinutes,
+      certification,
+      aiDisclosure,
+      studioId
+    }) => {
+      try {
+        const input = { title };
+        if (type !== void 0) input.type = type;
+        if (slug !== void 0) input.slug = slug;
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (genres !== void 0) input.genres = genres;
+        if (tags !== void 0) input.tags = tags;
+        if (originalLanguage !== void 0) input.originalLanguage = originalLanguage;
+        if (originCountry !== void 0) input.originCountry = originCountry;
+        if (releaseDate !== void 0) input.releaseDate = releaseDate;
+        if (releaseYear !== void 0) input.releaseYear = releaseYear;
+        if (runtimeMinutes !== void 0) input.runtimeMinutes = runtimeMinutes;
+        if (certification !== void 0) input.certification = certification;
+        if (aiDisclosure !== void 0) input.aiDisclosure = aiDisclosure;
+        if (studioId !== void 0) input.studioId = studioId;
+        const data = await ctx.gql.workspace.request(CREATE_TITLE, { input });
+        return jsonResult(data.hokCreateTitle);
+      } catch (error) {
+        ctx.logger.error("hookmovies titles_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create title: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "titles_update")),
+    {
+      title: "Update Title",
+      description: "Update a catalog title. At least one mutable field must be provided. Use titles_transition for status changes and titles_archive to archive.",
+      inputSchema: {
+        id: zod.z.string().describe("Title ID"),
+        title: zod.z.string().optional().describe("Updated display title"),
+        type: TitleTypeEnum.optional().describe("Updated title type"),
+        slug: zod.z.string().optional().describe("Updated URL slug"),
+        synopsis: zod.z.string().optional().describe("Updated synopsis"),
+        genres: zod.z.array(zod.z.string()).optional().describe("Updated genres"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        originalLanguage: zod.z.string().optional().describe("Updated original language"),
+        originCountry: zod.z.string().optional().describe("Updated origin country"),
+        releaseDate: zod.z.string().optional().describe("Updated release date (ISO-8601 DateTime)"),
+        releaseYear: zod.z.number().int().optional().describe("Updated release year"),
+        runtimeMinutes: zod.z.number().int().optional().describe("Updated runtime in minutes"),
+        certification: zod.z.string().optional().describe("Updated certification"),
+        aiDisclosure: zod.z.boolean().optional().describe("Updated AI-disclosure flag"),
+        studioId: zod.z.string().optional().describe("Updated owning studio ID")
+      }
+    },
+    async ({
+      id,
+      title,
+      type,
+      slug,
+      synopsis,
+      genres,
+      tags,
+      originalLanguage,
+      originCountry,
+      releaseDate,
+      releaseYear,
+      runtimeMinutes,
+      certification,
+      aiDisclosure,
+      studioId
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (type !== void 0) input.type = type;
+        if (slug !== void 0) input.slug = slug;
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (genres !== void 0) input.genres = genres;
+        if (tags !== void 0) input.tags = tags;
+        if (originalLanguage !== void 0) input.originalLanguage = originalLanguage;
+        if (originCountry !== void 0) input.originCountry = originCountry;
+        if (releaseDate !== void 0) input.releaseDate = releaseDate;
+        if (releaseYear !== void 0) input.releaseYear = releaseYear;
+        if (runtimeMinutes !== void 0) input.runtimeMinutes = runtimeMinutes;
+        if (certification !== void 0) input.certification = certification;
+        if (aiDisclosure !== void 0) input.aiDisclosure = aiDisclosure;
+        if (studioId !== void 0) input.studioId = studioId;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable title field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_TITLE, { id, input });
+        return jsonResult(data.hokUpdateTitle);
+      } catch (error) {
+        ctx.logger.error("hookmovies titles_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update title: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "titles_transition")),
+    {
+      title: "Transition Title",
+      description: "Move a title through its publication lifecycle (validated transitions), e.g. DRAFT \u2192 IN_REVIEW \u2192 SCHEDULED \u2192 PUBLISHED \u2192 UNPUBLISHED.",
+      inputSchema: {
+        id: zod.z.string().describe("Title ID"),
+        status: TitleStatusEnum.describe("Target publication status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_TITLE, { id, status });
+        return jsonResult(data.hokTransitionTitle);
+      } catch (error) {
+        ctx.logger.error("hookmovies titles_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition title: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "titles_archive")),
+    {
+      title: "Archive Title",
+      description: "Archive (soft-delete) a catalog title. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Title ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_TITLE,
+          { id }
+        );
+        return jsonResult({ archived: data.hokArchiveTitle });
+      } catch (error) {
+        ctx.logger.error("hookmovies titles_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive title: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerStudioTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "studios_list")),
+    {
+      title: "List Studios",
+      description: "List studios/distributors in the bound workspace, with pagination.",
+      inputSchema: {
+        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 ({ limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_STUDIOS, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListStudios);
+      } catch (error) {
+        ctx.logger.error("hookmovies studios_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list studios: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "studios_create")),
+    {
+      title: "Create Studio",
+      description: "Create a studio/distributor. `name` is required.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Studio display name"),
+        slug: zod.z.string().optional().describe("URL slug, unique within the workspace"),
+        description: zod.z.string().optional().describe("Studio description"),
+        country: zod.z.string().optional().describe("Country code"),
+        websiteUrl: zod.z.string().optional().describe("Studio website URL"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, slug, description, country, websiteUrl, tags }) => {
+      try {
+        const input = { name };
+        if (slug !== void 0) input.slug = slug;
+        if (description !== void 0) input.description = description;
+        if (country !== void 0) input.country = country;
+        if (websiteUrl !== void 0) input.websiteUrl = websiteUrl;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_STUDIO, { input });
+        return jsonResult(data.hokCreateStudio);
+      } catch (error) {
+        ctx.logger.error("hookmovies studios_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create studio: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPeopleTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "people_list")),
+    {
+      title: "List People",
+      description: "List talent (cast/crew) in the bound workspace, including each person\u2019s credits, with pagination.",
+      inputSchema: {
+        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 ({ limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PEOPLE, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListPeople);
+      } catch (error) {
+        ctx.logger.error("hookmovies people_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list people: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "people_create")),
+    {
+      title: "Create Person",
+      description: "Create a talent (cast/crew) record. `name` is required.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Person display name"),
+        biography: zod.z.string().optional().describe("Short biography"),
+        knownFor: zod.z.string().optional().describe("Notable work / known-for blurb"),
+        primaryLanguage: zod.z.string().optional().describe("Primary working language"),
+        portfolioRef: zod.z.string().optional().describe("Stable Artistrybase portfolio id (reference only)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, biography, knownFor, primaryLanguage, portfolioRef, tags }) => {
+      try {
+        const input = { name };
+        if (biography !== void 0) input.biography = biography;
+        if (knownFor !== void 0) input.knownFor = knownFor;
+        if (primaryLanguage !== void 0) input.primaryLanguage = primaryLanguage;
+        if (portfolioRef !== void 0) input.portfolioRef = portfolioRef;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PERSON, { input });
+        return jsonResult(data.hokCreatePerson);
+      } catch (error) {
+        ctx.logger.error("hookmovies people_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create person: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "credits_add")),
+    {
+      title: "Add Credit",
+      description: "Credit a person on a title with a role (default ACTOR). Optionally set the character name and billing order.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Title the credit is on"),
+        personId: zod.z.string().min(1).describe("Person being credited"),
+        role: CreditRoleEnum.optional().describe("Credited role (default ACTOR)"),
+        characterName: zod.z.string().optional().describe("Character name (for ACTOR/VOICE_ACTOR)"),
+        billingOrder: zod.z.number().int().optional().describe("Billing order (lower = higher billing)")
+      }
+    },
+    async ({ titleId, personId, role, characterName, billingOrder }) => {
+      try {
+        const input = { titleId, personId };
+        if (role !== void 0) input.role = role;
+        if (characterName !== void 0) input.characterName = characterName;
+        if (billingOrder !== void 0) input.billingOrder = billingOrder;
+        const data = await ctx.gql.workspace.request(ADD_CREDIT, { input });
+        return jsonResult(data.hokAddCredit);
+      } catch (error) {
+        ctx.logger.error("hookmovies credits_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add credit: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEpisodeTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "seasons_create")),
+    {
+      title: "Create Season",
+      description: "Create a season under a title. `titleId` and `number` are required; name/synopsis/airDate are optional.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Parent title ID"),
+        number: zod.z.number().int().describe("Season number"),
+        name: zod.z.string().optional().describe("Season name"),
+        synopsis: zod.z.string().optional().describe("Season synopsis"),
+        airDate: zod.z.string().optional().describe("Air date (ISO-8601 DateTime)")
+      }
+    },
+    async ({ titleId, number, name, synopsis, airDate }) => {
+      try {
+        const input = { titleId, number };
+        if (name !== void 0) input.name = name;
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (airDate !== void 0) input.airDate = airDate;
+        const data = await ctx.gql.workspace.request(CREATE_SEASON, { input });
+        return jsonResult(data.hokCreateSeason);
+      } catch (error) {
+        ctx.logger.error("hookmovies seasons_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create season: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "episodes_list")),
+    {
+      title: "List Episodes",
+      description: "List all episodes for a title (across seasons).",
+      inputSchema: { titleId: zod.z.string().describe("Title ID") }
+    },
+    async ({ titleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EPISODES, { titleId });
+        return jsonResult(data.hokListEpisodes);
+      } catch (error) {
+        ctx.logger.error("hookmovies episodes_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list episodes: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "episodes_create")),
+    {
+      title: "Create Episode",
+      description: "Create an episode under a title (and optionally a season). `titleId`, `name`, and `number` are required. Set `fileId` to attach the master/mezzanine file.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Parent title ID"),
+        name: zod.z.string().min(1).describe("Episode name"),
+        number: zod.z.number().int().describe("Episode number within the season"),
+        seasonId: zod.z.string().optional().describe("Parent season ID"),
+        synopsis: zod.z.string().optional().describe("Episode synopsis"),
+        runtimeMinutes: zod.z.number().int().optional().describe("Runtime in minutes"),
+        airDate: zod.z.string().optional().describe("Air date (ISO-8601 DateTime)"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID (master/mezzanine)")
+      }
+    },
+    async ({ titleId, name, number, seasonId, synopsis, runtimeMinutes, airDate, fileId }) => {
+      try {
+        const input = { titleId, name, number };
+        if (seasonId !== void 0) input.seasonId = seasonId;
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (runtimeMinutes !== void 0) input.runtimeMinutes = runtimeMinutes;
+        if (airDate !== void 0) input.airDate = airDate;
+        if (fileId !== void 0) input.fileId = fileId;
+        const data = await ctx.gql.workspace.request(CREATE_EPISODE, { input });
+        return jsonResult(data.hokCreateEpisode);
+      } catch (error) {
+        ctx.logger.error("hookmovies episodes_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create episode: ${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 auditions.",
+      inputSchema: { id: zod.z.string().describe("Production ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PRODUCTION, { id });
+        if (!data.hokProduction) return errorResult(`Production ${id} not found`);
+        return jsonResult(data.hokProduction);
+      } catch (error) {
+        ctx.logger.error("hookmovies 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 in the bound workspace, optionally filtered by status and/or studio, with pagination.",
+      inputSchema: {
+        status: ProductionStatusEnum.optional().describe("Filter by production status"),
+        studioId: zod.z.string().optional().describe("Filter by studio ID"),
+        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, studioId, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PRODUCTIONS, {
+          status,
+          studioId,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListProductions);
+      } catch (error) {
+        ctx.logger.error("hookmovies 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: 'Open a new production. `title` is required. Budget is expressed in minor units as a string (e.g. "150000000" for \u20B915,00,000.00).',
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Production title"),
+        logline: zod.z.string().optional().describe("One-line logline"),
+        synopsis: zod.z.string().optional().describe("Synopsis"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Discovery tags"),
+        studioId: zod.z.string().optional().describe("Producing studio ID"),
+        producerId: zod.z.string().optional().describe("Lead producer user ID"),
+        currency: zod.z.string().optional().describe("Budget currency code"),
+        budgetMinorUnits: zod.z.string().optional().describe("Budget in minor units (string)"),
+        startDate: zod.z.string().optional().describe("Start date (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("End date (ISO-8601 DateTime)"),
+        artistrybaseProjectRef: zod.z.string().optional().describe("Stable Artistrybase project id this production is promoted from")
+      }
+    },
+    async ({
+      title,
+      logline,
+      synopsis,
+      tags,
+      studioId,
+      producerId,
+      currency,
+      budgetMinorUnits,
+      startDate,
+      endDate,
+      artistrybaseProjectRef
+    }) => {
+      try {
+        const input = { title };
+        if (logline !== void 0) input.logline = logline;
+        if (synopsis !== void 0) input.synopsis = synopsis;
+        if (tags !== void 0) input.tags = tags;
+        if (studioId !== void 0) input.studioId = studioId;
+        if (producerId !== void 0) input.producerId = producerId;
+        if (currency !== void 0) input.currency = currency;
+        if (budgetMinorUnits !== void 0) input.budgetMinorUnits = budgetMinorUnits;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (artistrybaseProjectRef !== void 0)
+          input.artistrybaseProjectRef = artistrybaseProjectRef;
+        const data = await ctx.gql.workspace.request(CREATE_PRODUCTION, { input });
+        return jsonResult(data.hokCreateProduction);
+      } catch (error) {
+        ctx.logger.error("hookmovies 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_transition")),
+    {
+      title: "Transition Production",
+      description: "Advance a production through its lifecycle (validated transitions): DEVELOPMENT \u2192 GREENLIT \u2192 IN_PRODUCTION \u2192 POST_PRODUCTION \u2192 RELEASED (or SHELVED).",
+      inputSchema: {
+        id: zod.z.string().describe("Production ID"),
+        status: ProductionStatusEnum.describe("Target production status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_PRODUCTION, { id, status });
+        return jsonResult(data.hokTransitionProduction);
+      } catch (error) {
+        ctx.logger.error("hookmovies productions_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition production: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerAuditionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "auditions_list")),
+    {
+      title: "List Auditions",
+      description: "List auditions in the bound workspace, optionally filtered by production and/or status, with pagination.",
+      inputSchema: {
+        productionId: zod.z.string().optional().describe("Filter by production ID"),
+        status: AuditionStatusEnum.optional().describe("Filter by audition 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 ({ productionId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_AUDITIONS, {
+          productionId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListAuditions);
+      } catch (error) {
+        ctx.logger.error("hookmovies auditions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list auditions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "auditions_create")),
+    {
+      title: "Create Audition",
+      description: "Open an audition/casting call for a role on a production. `productionId` and `roleName` are required. `payMinorUnits` is a minor-units string.",
+      inputSchema: {
+        productionId: zod.z.string().min(1).describe("Production the audition belongs to"),
+        roleName: zod.z.string().min(1).describe("Role being cast"),
+        description: zod.z.string().optional().describe("Audition / role description"),
+        isMinorRole: zod.z.boolean().optional().describe("Whether this is a minor role (default false)"),
+        language: zod.z.string().optional().describe("Required language"),
+        location: zod.z.string().optional().describe("Audition location"),
+        currency: zod.z.string().optional().describe("Pay currency code"),
+        payMinorUnits: zod.z.string().optional().describe("Pay in minor units (string)"),
+        submissionDeadline: zod.z.string().optional().describe("Submission deadline (ISO-8601 DateTime)")
+      }
+    },
+    async ({
+      productionId,
+      roleName,
+      description,
+      isMinorRole,
+      language,
+      location,
+      currency,
+      payMinorUnits,
+      submissionDeadline
+    }) => {
+      try {
+        const input = { productionId, roleName };
+        if (description !== void 0) input.description = description;
+        if (isMinorRole !== void 0) input.isMinorRole = isMinorRole;
+        if (language !== void 0) input.language = language;
+        if (location !== void 0) input.location = location;
+        if (currency !== void 0) input.currency = currency;
+        if (payMinorUnits !== void 0) input.payMinorUnits = payMinorUnits;
+        if (submissionDeadline !== void 0) input.submissionDeadline = submissionDeadline;
+        const data = await ctx.gql.workspace.request(CREATE_AUDITION, { input });
+        return jsonResult(data.hokCreateAudition);
+      } catch (error) {
+        ctx.logger.error("hookmovies auditions_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create audition: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "auditions_close")),
+    {
+      title: "Close Audition",
+      description: "Close an open audition (no further submissions accepted).",
+      inputSchema: { id: zod.z.string().describe("Audition ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CLOSE_AUDITION, { id });
+        return jsonResult(data.hokCloseAudition);
+      } catch (error) {
+        ctx.logger.error("hookmovies auditions_close failed", { error: String(error) });
+        return errorResult(
+          `Failed to close audition: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_list")),
+    {
+      title: "List Applications",
+      description: "List the applications submitted to a given audition (casting-team view).",
+      inputSchema: { auditionId: zod.z.string().describe("Audition ID") }
+    },
+    async ({ auditionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_APPLICATIONS, { auditionId });
+        return jsonResult(data.hokListApplications);
+      } catch (error) {
+        ctx.logger.error("hookmovies applications_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list applications: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_apply")),
+    {
+      title: "Apply to Audition",
+      description: "Apply to an audition as the calling user (self-scoped). Optionally include a cover note and a self-tape file (selfTapeFileId references a wspace-files-svc File).",
+      inputSchema: {
+        auditionId: zod.z.string().min(1).describe("Audition to apply to"),
+        coverNote: zod.z.string().optional().describe("Cover note / pitch"),
+        selfTapeFileId: zod.z.string().optional().describe("wspace-files-svc File ID of the self-tape")
+      }
+    },
+    async ({ auditionId, coverNote, selfTapeFileId }) => {
+      try {
+        const input = { auditionId };
+        if (coverNote !== void 0) input.coverNote = coverNote;
+        if (selfTapeFileId !== void 0) input.selfTapeFileId = selfTapeFileId;
+        const data = await ctx.gql.workspace.request(APPLY_TO_AUDITION, { input });
+        return jsonResult(data.hokApplyToAudition);
+      } catch (error) {
+        ctx.logger.error("hookmovies applications_apply failed", { error: String(error) });
+        return errorResult(
+          `Failed to apply to audition: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_score")),
+    {
+      title: "Score Application",
+      description: "Score an applicant (casting-team action; workspace-scoped).",
+      inputSchema: {
+        id: zod.z.string().describe("Application ID"),
+        score: zod.z.number().int().describe("Score to assign the applicant")
+      }
+    },
+    async ({ id, score }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SCORE_APPLICATION, { id, score });
+        return jsonResult(data.hokScoreApplication);
+      } catch (error) {
+        ctx.logger.error("hookmovies applications_score failed", { error: String(error) });
+        return errorResult(
+          `Failed to score application: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReviewTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_list")),
+    {
+      title: "List Reviews",
+      description: "List reviews in the bound workspace, optionally filtered by title and/or moderation status, with pagination.",
+      inputSchema: {
+        titleId: zod.z.string().optional().describe("Filter by title ID"),
+        status: ReviewStatusEnum.optional().describe("Filter by moderation 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 ({ titleId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REVIEWS, {
+          titleId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListReviews);
+      } catch (error) {
+        ctx.logger.error("hookmovies reviews_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list reviews: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_create")),
+    {
+      title: "Create Review",
+      description: "Create a review for a title as the calling user (self-scoped). `score` and `titleId` are required.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Title being reviewed"),
+        score: zod.z.number().int().describe("Score for the title (e.g. 1\u201310)"),
+        body: zod.z.string().optional().describe("Free-text review body"),
+        hasSpoilers: zod.z.boolean().optional().describe("Whether the review has spoilers (default false)"),
+        aspectScores: JsonObject.optional().describe(
+          "Per-aspect scores JSON (e.g. { acting, story })"
+        )
+      }
+    },
+    async ({ titleId, score, body, hasSpoilers, aspectScores }) => {
+      try {
+        const input = { titleId, score };
+        if (body !== void 0) input.body = body;
+        if (hasSpoilers !== void 0) input.hasSpoilers = hasSpoilers;
+        if (aspectScores !== void 0) input.aspectScores = aspectScores;
+        const data = await ctx.gql.workspace.request(CREATE_REVIEW, { input });
+        return jsonResult(data.hokCreateReview);
+      } catch (error) {
+        ctx.logger.error("hookmovies reviews_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create review: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_delete")),
+    {
+      title: "Delete Review",
+      description: "Delete the calling user\u2019s own review (self-scoped). Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Review ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_REVIEW,
+          { id }
+        );
+        return jsonResult({ deleted: data.hokDeleteReview });
+      } catch (error) {
+        ctx.logger.error("hookmovies reviews_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete review: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRightsTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "rights_list")),
+    {
+      title: "List Rights Windows",
+      description: "List rights/licensing windows in the bound workspace, optionally filtered by title and/or status, with pagination.",
+      inputSchema: {
+        titleId: zod.z.string().optional().describe("Filter by title ID"),
+        status: RightsWindowStatusEnum.optional().describe("Filter by rights-window 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 ({ titleId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RIGHTS_WINDOWS, {
+          titleId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokListRightsWindows);
+      } catch (error) {
+        ctx.logger.error("hookmovies rights_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list rights windows: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "rights_create")),
+    {
+      title: "Create Rights Window",
+      description: "Create a rights/licensing window for a title. `titleId` and at least one monetization `mode` are required. `priceMinorUnits` is a JSON map of per-mode prices.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Title the window applies to"),
+        modes: zod.z.array(MonetizationModeEnum).min(1).describe("Monetization modes covered by this window"),
+        territories: zod.z.array(zod.z.string()).optional().describe("ISO territory codes (default global)"),
+        exclusive: zod.z.boolean().optional().describe("Whether the license is exclusive (default false)"),
+        licenseeId: zod.z.string().optional().describe("Licensee ID (for licensed-out windows)"),
+        currency: zod.z.string().optional().describe("Price currency code"),
+        priceMinorUnits: JsonObject.optional().describe("Per-mode price map JSON (minor units)"),
+        startsAt: zod.z.string().optional().describe("Window start (ISO-8601 DateTime)"),
+        endsAt: zod.z.string().optional().describe("Window end (ISO-8601 DateTime)"),
+        contractFileId: zod.z.string().optional().describe("wspace-files-svc File ID of the contract")
+      }
+    },
+    async ({
+      titleId,
+      modes,
+      territories,
+      exclusive,
+      licenseeId,
+      currency,
+      priceMinorUnits,
+      startsAt,
+      endsAt,
+      contractFileId
+    }) => {
+      try {
+        const input = { titleId, modes };
+        if (territories !== void 0) input.territories = territories;
+        if (exclusive !== void 0) input.exclusive = exclusive;
+        if (licenseeId !== void 0) input.licenseeId = licenseeId;
+        if (currency !== void 0) input.currency = currency;
+        if (priceMinorUnits !== void 0) input.priceMinorUnits = priceMinorUnits;
+        if (startsAt !== void 0) input.startsAt = startsAt;
+        if (endsAt !== void 0) input.endsAt = endsAt;
+        if (contractFileId !== void 0) input.contractFileId = contractFileId;
+        const data = await ctx.gql.workspace.request(CREATE_RIGHTS_WINDOW, { input });
+        return jsonResult(data.hokCreateRightsWindow);
+      } catch (error) {
+        ctx.logger.error("hookmovies rights_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create rights window: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "rights_transition")),
+    {
+      title: "Transition Rights Window",
+      description: "Move a rights window through its lifecycle (validated transitions): DRAFT \u2192 PENDING \u2192 ACTIVE \u2192 EXPIRED (or REVOKED).",
+      inputSchema: {
+        id: zod.z.string().describe("Rights window ID"),
+        status: RightsWindowStatusEnum.describe("Target rights-window status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_RIGHTS_WINDOW, { id, status });
+        return jsonResult(data.hokTransitionRightsWindow);
+      } catch (error) {
+        ctx.logger.error("hookmovies rights_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition rights window: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEntitlementTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entitlements_grant")),
+    {
+      title: "Grant Entitlement",
+      description: "Grant a user access to a title (workspace-scoped admin action). `titleId`, `userId`, and `mode` are required; default source is SUBSCRIPTION.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Title to grant access to"),
+        userId: zod.z.string().min(1).describe("User receiving the entitlement"),
+        mode: MonetizationModeEnum.describe("Monetization mode the entitlement covers"),
+        source: EntitlementSourceEnum.optional().describe(
+          "How it was acquired (default SUBSCRIPTION)"
+        ),
+        territory: zod.z.string().optional().describe("Territory the entitlement is valid in"),
+        expiresAt: zod.z.string().optional().describe("Expiry timestamp (ISO-8601 DateTime)")
+      }
+    },
+    async ({ titleId, userId, mode, source, territory, expiresAt }) => {
+      try {
+        const input = { titleId, userId, mode };
+        if (source !== void 0) input.source = source;
+        if (territory !== void 0) input.territory = territory;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(GRANT_ENTITLEMENT, { input });
+        return jsonResult(data.hokGrantEntitlement);
+      } catch (error) {
+        ctx.logger.error("hookmovies entitlements_grant failed", { error: String(error) });
+        return errorResult(
+          `Failed to grant entitlement: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entitlements_revoke")),
+    {
+      title: "Revoke Entitlement",
+      description: "Revoke an existing entitlement by ID (workspace-scoped admin action). Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Entitlement ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REVOKE_ENTITLEMENT,
+          { id }
+        );
+        return jsonResult({ revoked: data.hokRevokeEntitlement });
+      } catch (error) {
+        ctx.logger.error("hookmovies entitlements_revoke failed", { error: String(error) });
+        return errorResult(
+          `Failed to revoke entitlement: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entitlements_my")),
+    {
+      title: "My Entitlements",
+      description: "List the calling user\u2019s own entitlements (self-scoped), optionally filtered to a single title.",
+      inputSchema: {
+        titleId: zod.z.string().optional().describe("Filter to entitlements for a single title")
+      }
+    },
+    async ({ titleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MY_ENTITLEMENTS, { titleId });
+        return jsonResult(data.hokMyEntitlements);
+      } catch (error) {
+        ctx.logger.error("hookmovies entitlements_my failed", { error: String(error) });
+        return errorResult(
+          `Failed to list my entitlements: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entitlements_check")),
+    {
+      title: "Check Entitlement",
+      description: "Check whether the calling user can watch a title now (self-scoped). Returns whether entitled and the covered monetization modes.",
+      inputSchema: { titleId: zod.z.string().describe("Title ID to check") }
+    },
+    async ({ titleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CHECK_ENTITLEMENT, { titleId });
+        return jsonResult(data.hokCheckEntitlement);
+      } catch (error) {
+        ctx.logger.error("hookmovies entitlements_check failed", { error: String(error) });
+        return errorResult(
+          `Failed to check entitlement: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerListTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lists_get")),
+    {
+      title: "Get List",
+      description: "Fetch a single user list (watchlist/playlist) by ID.",
+      inputSchema: { id: zod.z.string().describe("List ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_LIST, { id });
+        if (!data.hokList) return errorResult(`List ${id} not found`);
+        return jsonResult(data.hokList);
+      } catch (error) {
+        ctx.logger.error("hookmovies lists_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get list: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lists_my")),
+    {
+      title: "My Lists",
+      description: "List the calling user\u2019s own lists (self-scoped), optionally filtered by kind, with pagination.",
+      inputSchema: {
+        kind: ListKindEnum.optional().describe("Filter by list kind (PLAYLIST/WATCHLIST)"),
+        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 ({ kind, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MY_LISTS, {
+          kind,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.hokMyLists);
+      } catch (error) {
+        ctx.logger.error("hookmovies lists_my failed", { error: String(error) });
+        return errorResult(
+          `Failed to list my lists: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lists_create")),
+    {
+      title: "Create List",
+      description: "Create a list owned by the calling user (self-scoped). `name` is required; defaults: kind=PLAYLIST, visibility=PRIVATE.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("List name"),
+        kind: ListKindEnum.optional().describe("List kind (default PLAYLIST)"),
+        visibility: ListVisibilityEnum.optional().describe("Visibility (default PRIVATE)"),
+        description: zod.z.string().optional().describe("List description"),
+        items: JsonValue.optional().describe("Initial list items JSON (e.g. [{ titleId }])")
+      }
+    },
+    async ({ name, kind, visibility, description, items }) => {
+      try {
+        const input = { name };
+        if (kind !== void 0) input.kind = kind;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (description !== void 0) input.description = description;
+        if (items !== void 0) input.items = items;
+        const data = await ctx.gql.workspace.request(CREATE_LIST, { input });
+        return jsonResult(data.hokCreateList);
+      } catch (error) {
+        ctx.logger.error("hookmovies lists_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create list: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lists_update")),
+    {
+      title: "Update List",
+      description: "Update the calling user\u2019s own list (self-scoped). At least one mutable field must be provided. Set `items` to replace the list contents.",
+      inputSchema: {
+        id: zod.z.string().describe("List ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        visibility: ListVisibilityEnum.optional().describe("Updated visibility"),
+        items: JsonValue.optional().describe("Replacement list items JSON")
+      }
+    },
+    async ({ id, name, description, visibility, items }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (items !== void 0) input.items = items;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/visibility/items"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_LIST, { id, input });
+        return jsonResult(data.hokUpdateList);
+      } catch (error) {
+        ctx.logger.error("hookmovies lists_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update list: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lists_delete")),
+    {
+      title: "Delete List",
+      description: "Delete the calling user\u2019s own list (self-scoped). Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("List ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_LIST, {
+          id
+        });
+        return jsonResult({ deleted: data.hokDeleteList });
+      } catch (error) {
+        ctx.logger.error("hookmovies lists_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete list: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProgressTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "progress_record")),
+    {
+      title: "Record Watch Progress",
+      description: "Upsert the calling user\u2019s watch progress for a title/episode (self-scoped). `titleId` and `positionSeconds` are required; set `completed` when finished.",
+      inputSchema: {
+        titleId: zod.z.string().min(1).describe("Title being watched"),
+        positionSeconds: zod.z.number().int().describe("Current playback position in seconds"),
+        episodeId: zod.z.string().optional().describe("Episode ID (for episodic titles)"),
+        completed: zod.z.boolean().optional().describe("Whether playback is complete (default false)"),
+        lastDevice: zod.z.string().optional().describe("Identifier of the device last used")
+      }
+    },
+    async ({ titleId, positionSeconds, episodeId, completed, lastDevice }) => {
+      try {
+        const input = { titleId, positionSeconds };
+        if (episodeId !== void 0) input.episodeId = episodeId;
+        if (completed !== void 0) input.completed = completed;
+        if (lastDevice !== void 0) input.lastDevice = lastDevice;
+        const data = await ctx.gql.workspace.request(RECORD_PROGRESS, { input });
+        return jsonResult(data.hokRecordProgress);
+      } catch (error) {
+        ctx.logger.error("hookmovies progress_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record watch progress: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "progress_my")),
+    {
+      title: "My Watch Progress",
+      description: "List the calling user\u2019s continue-watching / progress entries (self-scoped), optionally filtered to a single title.",
+      inputSchema: {
+        titleId: zod.z.string().optional().describe("Filter to progress for a single title")
+      }
+    },
+    async ({ titleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MY_WATCH_PROGRESS, { titleId });
+        return jsonResult(data.hokMyWatchProgress);
+      } catch (error) {
+        ctx.logger.error("hookmovies progress_my failed", { error: String(error) });
+        return errorResult(
+          `Failed to list my watch progress: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/hookmovies/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "HookMovies Health Check",
+      description: "Public health probe for the HookMovies subgraph (hokHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.hokHealth });
+      } catch (error) {
+        ctx.logger.error("hookmovies health failed", { error: String(error) });
+        return errorResult(
+          `HookMovies health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/hookmovies/resources.ts
+function registerHookmoviesResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const catalogUri = track(mcpResourceUri(ctx.productName, "catalog"));
+  const productionsUri = track(mcpResourceUri(ctx.productName, "productions"));
+  const studiosUri = track(mcpResourceUri(ctx.productName, "studios"));
+  server.registerResource(
+    "hookmovies-schema",
+    schemaUri,
+    {
+      title: "HookMovies Domain Schema",
+      description: "Overview of the HookMovies streaming + production domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# HookMovies Domain (Overview)
+
+Multi-language global streaming + production network.
+
+## Entities
+- HokTitle (+HokSeason, HokEpisode, HokCredit) \u2014 catalog title and its structure
+- HokStudio \u2014 studio / distributor
+- HokPerson \u2014 talent (cast/crew), linked to titles via HokCredit
+- HokProduction \u2014 a production on the slate (can yield a Title)
+- HokAudition (+HokApplication) \u2014 casting call and its applications
+- HokReview \u2014 viewer rating + moderation
+- HokRightsWindow \u2014 licensing window (modes/territories/time)
+- HokEntitlement (+HokEntitlementCheck) \u2014 viewer access grants
+- HokList \u2014 user watchlist / playlist (self-scoped)
+- HokWatchProgress \u2014 continue-watching entries (self-scoped)
+
+## Enums
+- TitleType: ANIME, COLLECTION, DOCUMENTARY, FAST_CHANNEL, LIVE_EVENT, LONG_FORM, MOVIE, SERIES, SHORT_FILM, SHORT_FORM, TRAILER
+- TitleStatus: ARCHIVED, DRAFT, IN_REVIEW, PUBLISHED, SCHEDULED, UNPUBLISHED
+- CreditRole: ACTOR, CINEMATOGRAPHER, COMPOSER, CREW, DIRECTOR, EDITOR, PRODUCER, VOICE_ACTOR, WRITER
+- ProductionStatus: DEVELOPMENT, GREENLIT, IN_PRODUCTION, POST_PRODUCTION, RELEASED, SHELVED
+- AuditionStatus: CALLBACKS, CANCELLED, CLOSED, OPEN, REVIEWING
+- ApplicationStatus: CALLBACK, OFFERED, REJECTED, SHORTLISTED, SUBMITTED, WITHDRAWN
+- ReviewStatus: HIDDEN, PENDING, PUBLISHED, REMOVED
+- RightsWindowStatus: ACTIVE, DRAFT, EXPIRED, PENDING, REVOKED
+- MonetizationMode: FAST, FREE_AVOD, PPV, SVOD, TVOD_BUY, TVOD_RENT
+- EntitlementSource: FREE, PROMO, PURCHASE, RENTAL, SUBSCRIPTION
+- ListKind: PLAYLIST, WATCHLIST
+- ListVisibility: PRIVATE, PUBLIC, UNLISTED
+
+## Tool groups
+titles, studios, people (+credits), episodes (+seasons), productions,
+auditions (+applications), reviews, rights, entitlements, lists, progress, health.
+All run against the WORKSPACE gateway (workspace-scoped) except the public
+health probe and the self-scoped viewer surfaces (lists, progress,
+entitlements_my/check, applications_apply, reviews_create/delete).
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "hookmovies-catalog",
+    catalogUri,
+    {
+      title: "HookMovies Catalog",
+      description: "The first 50 titles in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${catalogUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TITLES, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: catalogUri,
+              text: JSON.stringify(data.hokListTitles, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: catalogUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "hookmovies-productions",
+    productionsUri,
+    {
+      title: "HookMovies Production Slate",
+      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.hokListProductions, 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(
+    "hookmovies-studios",
+    studiosUri,
+    {
+      title: "HookMovies Studio Directory",
+      description: "The first 50 studios in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${studiosUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_STUDIOS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: studiosUri,
+              text: JSON.stringify(data.hokListStudios, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: studiosUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerHookmoviesPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const releaseName = track(mcpPromptName(p, "title-release"));
+  const castingName = track(mcpPromptName(p, "casting-ops"));
+  server.registerPrompt(
+    releaseName,
+    {
+      title: "Title Release",
+      description: "Guide for cataloguing a HookMovies title end to end: create the studio (if needed) and title, add credits, structure seasons/episodes, declare rights, and publish.",
+      argsSchema: {
+        title: zod.z.string().optional().describe("Title name"),
+        type: zod.z.string().optional().describe("Title type (MOVIE, SERIES, etc.)")
+      }
+    },
+    ({ title, type }) => {
+      ctx.logger.debug(`Prompt ${releaseName} called`, { title, type });
+      const titleNote = title ? `Use the title "${title}".` : "Ask the user for the title name.";
+      const typeNote = type ? `Use type ${type}.` : "Help the user pick a TitleType.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me catalogue and release a HookMovies title.
+
+1. **Studio (optional)**: If the title needs a new studio, use ${p}_studios_create, else find one with ${p}_studios_list.
+2. **Create Title**: Use ${p}_titles_create. ${titleNote} ${typeNote} Set genres, synopsis, releaseYear, and (optionally) studioId.
+3. **Add Credits**: For each cast/crew member, ensure the person exists (${p}_people_create or ${p}_people_list) then credit them with ${p}_credits_add (role, characterName, billingOrder).
+4. **Structure (SERIES only)**: Use ${p}_seasons_create per season and ${p}_episodes_create per episode (attach a fileId for the master). Verify with ${p}_episodes_list.
+5. **Rights**: Use ${p}_rights_create to declare monetization modes + territories, then ${p}_rights_transition to ACTIVE.
+6. **Publish**: Use ${p}_titles_transition to move the title DRAFT \u2192 IN_REVIEW \u2192 PUBLISHED (or SCHEDULED).
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    castingName,
+    {
+      title: "Casting Operations",
+      description: "Workflow for running casting on a production: open auditions, triage applications, score applicants, and close out roles.",
+      argsSchema: {
+        productionId: zod.z.string().optional().describe("Production ID to cast")
+      }
+    },
+    ({ productionId }) => {
+      ctx.logger.debug(`Prompt ${castingName} called`, { productionId });
+      const prodNote = productionId ? `Operate production "${productionId}".` : `First list productions with ${p}_productions_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run HookMovies casting operations. ${prodNote}
+
+1. **Open Auditions**: Use ${p}_auditions_create for each role (roleName, pay, deadline). Review open ones with ${p}_auditions_list filtered by productionId and status=OPEN.
+2. **Triage Applications**: For each audition use ${p}_applications_list to review submissions and self-tapes.
+3. **Score Applicants**: Use ${p}_applications_score to rate promising applicants and shortlist/callback.
+4. **Close Roles**: When casting is decided, use ${p}_auditions_close to stop further submissions.
+5. **Advance Production**: Once cast, use ${p}_productions_transition to move the production forward (e.g. GREENLIT \u2192 IN_PRODUCTION).
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/hookmovies/index.ts
+var hookmoviesModule = {
+  id: "hookmovies",
+  version: "0.0.1",
+  displayName: "HookMovies",
+  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;
+    };
+    registerTitleTools(server, ctx, trackTool);
+    registerStudioTools(server, ctx, trackTool);
+    registerPeopleTools(server, ctx, trackTool);
+    registerEpisodeTools(server, ctx, trackTool);
+    registerProductionTools(server, ctx, trackTool);
+    registerAuditionTools(server, ctx, trackTool);
+    registerReviewTools(server, ctx, trackTool);
+    registerRightsTools(server, ctx, trackTool);
+    registerEntitlementTools(server, ctx, trackTool);
+    registerListTools(server, ctx, trackTool);
+    registerProgressTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerHookmoviesResources(server, ctx, trackResource);
+    registerHookmoviesPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var hookmovies_default = hookmoviesModule;
+
+module.exports = hookmovies_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map