@burdenoff/mcp-libs 2026.627.4 → 2026.627.5

package/dist/modules/theculturepost/index.cjs

@@ -0,0 +1,1587 @@
+'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/theculturepost/tools/stories.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/theculturepost/operations.ts
+var STORY_FIELDS = `
+  id slug title summary body format status readingMins languages tags
+  topicId authorId editorId publishedAt workspaceId createdAt updatedAt
+  cover { id }
+`;
+var TOPIC_FIELDS = `
+  id slug name description category tradition isFeatured
+  workspaceId createdAt updatedAt
+`;
+var CITATION_FIELDS = `
+  id storyId title author publisher publishedOn url excerpt provenance
+  sourceType verification workspaceId createdAt updatedAt
+  sourceFile { id }
+`;
+var ARCHIVE_ITEM_FIELDS = `
+  id title description kind accessLevel collectionId languages tags origin
+  provenance datedAt workspaceId createdAt updatedAt
+  file { id }
+`;
+var COLLECTION_FIELDS = `
+  id slug name description tradition itemCount
+  workspaceId createdAt updatedAt
+  cover { id }
+`;
+var ORAL_HISTORY_FIELDS = `
+  id title narratorName language summary transcript durationSecs recordedAt
+  collectionId accessLevel workspaceId createdAt updatedAt
+  recording { id }
+`;
+var DISCUSSION_FIELDS = `
+  id title prompt storyId isInterfaith isLocked status replyCount tags
+  openedById workspaceId createdAt updatedAt
+`;
+var REPLY_FIELDS = `
+  id discussionId body perspective status authorId
+  workspaceId createdAt updatedAt
+`;
+var PAGE_INFO = `
+  pageInfo { cursor hasMore }
+`;
+var GET_STORY = `
+  query TheculturepostGetStory($id: ID!) {
+    tcpStory(id: $id) {
+      ${STORY_FIELDS}
+      topic { id name slug category }
+      citations { id title sourceType verification url }
+    }
+  }
+`;
+var LIST_STORIES = `
+  query TheculturepostListStories(
+    $pagination: PaginationInput
+    $status: TcpStoryStatus
+    $topicId: ID
+  ) {
+    tcpListStories(pagination: $pagination, status: $status, topicId: $topicId) {
+      items { ${STORY_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_STORY = `
+  mutation TheculturepostCreateStory($input: TcpCreateStoryInput!) {
+    tcpCreateStory(input: $input) { ${STORY_FIELDS} }
+  }
+`;
+var UPDATE_STORY = `
+  mutation TheculturepostUpdateStory($id: ID!, $input: TcpUpdateStoryInput!) {
+    tcpUpdateStory(id: $id, input: $input) { ${STORY_FIELDS} }
+  }
+`;
+var TRANSITION_STORY = `
+  mutation TheculturepostTransitionStory($id: ID!, $status: TcpStoryStatus!) {
+    tcpTransitionStory(id: $id, status: $status) { ${STORY_FIELDS} }
+  }
+`;
+var GET_TOPIC = `
+  query TheculturepostGetTopic($id: ID!) {
+    tcpTopic(id: $id) {
+      ${TOPIC_FIELDS}
+      stories { id title slug status }
+    }
+  }
+`;
+var LIST_TOPICS = `
+  query TheculturepostListTopics(
+    $category: TcpTopicCategory
+    $pagination: PaginationInput
+  ) {
+    tcpListTopics(category: $category, pagination: $pagination) {
+      items { ${TOPIC_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_TOPIC = `
+  mutation TheculturepostCreateTopic($input: TcpCreateTopicInput!) {
+    tcpCreateTopic(input: $input) { ${TOPIC_FIELDS} }
+  }
+`;
+var UPDATE_TOPIC = `
+  mutation TheculturepostUpdateTopic($id: ID!, $input: TcpUpdateTopicInput!) {
+    tcpUpdateTopic(id: $id, input: $input) { ${TOPIC_FIELDS} }
+  }
+`;
+var ARCHIVE_TOPIC = `
+  mutation TheculturepostArchiveTopic($id: ID!) {
+    tcpArchiveTopic(id: $id)
+  }
+`;
+var LIST_CITATIONS = `
+  query TheculturepostListCitations($storyId: ID!) {
+    tcpListCitations(storyId: $storyId) { ${CITATION_FIELDS} }
+  }
+`;
+var ADD_CITATION = `
+  mutation TheculturepostAddCitation($input: TcpCreateCitationInput!) {
+    tcpAddCitation(input: $input) { ${CITATION_FIELDS} }
+  }
+`;
+var VERIFY_CITATION = `
+  mutation TheculturepostVerifyCitation(
+    $id: ID!
+    $verification: TcpVerificationStatus!
+  ) {
+    tcpVerifyCitation(id: $id, verification: $verification) { ${CITATION_FIELDS} }
+  }
+`;
+var GET_ARCHIVE_ITEM = `
+  query TheculturepostGetArchiveItem($id: ID!) {
+    tcpArchiveItem(id: $id) {
+      ${ARCHIVE_ITEM_FIELDS}
+      collection { id name slug }
+    }
+  }
+`;
+var LIST_ARCHIVE_ITEMS = `
+  query TheculturepostListArchiveItems(
+    $accessLevel: TcpAccessLevel
+    $collectionId: ID
+    $kind: TcpArchiveItemKind
+    $pagination: PaginationInput
+  ) {
+    tcpListArchiveItems(
+      accessLevel: $accessLevel
+      collectionId: $collectionId
+      kind: $kind
+      pagination: $pagination
+    ) {
+      items { ${ARCHIVE_ITEM_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_ARCHIVE_ITEM = `
+  mutation TheculturepostCreateArchiveItem($input: TcpCreateArchiveItemInput!) {
+    tcpCreateArchiveItem(input: $input) { ${ARCHIVE_ITEM_FIELDS} }
+  }
+`;
+var UPDATE_ARCHIVE_ITEM = `
+  mutation TheculturepostUpdateArchiveItem(
+    $id: ID!
+    $input: TcpUpdateArchiveItemInput!
+  ) {
+    tcpUpdateArchiveItem(id: $id, input: $input) { ${ARCHIVE_ITEM_FIELDS} }
+  }
+`;
+var ARCHIVE_ARCHIVE_ITEM = `
+  mutation TheculturepostArchiveArchiveItem($id: ID!) {
+    tcpArchiveArchiveItem(id: $id)
+  }
+`;
+var GET_COLLECTION = `
+  query TheculturepostGetCollection($id: ID!) {
+    tcpCollection(id: $id) {
+      ${COLLECTION_FIELDS}
+      items { id title kind accessLevel }
+      oralHistories { id title narratorName }
+    }
+  }
+`;
+var LIST_COLLECTIONS = `
+  query TheculturepostListCollections($pagination: PaginationInput) {
+    tcpListCollections(pagination: $pagination) { ${COLLECTION_FIELDS} }
+  }
+`;
+var CREATE_COLLECTION = `
+  mutation TheculturepostCreateCollection($input: TcpCreateCollectionInput!) {
+    tcpCreateCollection(input: $input) { ${COLLECTION_FIELDS} }
+  }
+`;
+var LIST_ORAL_HISTORIES = `
+  query TheculturepostListOralHistories($collectionId: ID) {
+    tcpListOralHistories(collectionId: $collectionId) { ${ORAL_HISTORY_FIELDS} }
+  }
+`;
+var RECORD_ORAL_HISTORY = `
+  mutation TheculturepostRecordOralHistory($input: TcpCreateOralHistoryInput!) {
+    tcpRecordOralHistory(input: $input) { ${ORAL_HISTORY_FIELDS} }
+  }
+`;
+var GET_DISCUSSION = `
+  query TheculturepostGetDiscussion($id: ID!) {
+    tcpDiscussion(id: $id) {
+      ${DISCUSSION_FIELDS}
+      replies { id body perspective status authorId }
+    }
+  }
+`;
+var LIST_DISCUSSIONS = `
+  query TheculturepostListDiscussions(
+    $pagination: PaginationInput
+    $status: TcpModerationStatus
+    $storyId: ID
+  ) {
+    tcpListDiscussions(pagination: $pagination, status: $status, storyId: $storyId) {
+      items { ${DISCUSSION_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var OPEN_DISCUSSION = `
+  mutation TheculturepostOpenDiscussion($input: TcpCreateDiscussionInput!) {
+    tcpOpenDiscussion(input: $input) { ${DISCUSSION_FIELDS} }
+  }
+`;
+var LOCK_DISCUSSION = `
+  mutation TheculturepostLockDiscussion($id: ID!) {
+    tcpLockDiscussion(id: $id) { ${DISCUSSION_FIELDS} }
+  }
+`;
+var LIST_REPLIES = `
+  query TheculturepostListReplies($discussionId: ID!, $status: TcpModerationStatus) {
+    tcpListReplies(discussionId: $discussionId, status: $status) { ${REPLY_FIELDS} }
+  }
+`;
+var POST_REPLY = `
+  mutation TheculturepostPostReply($input: TcpCreateReplyInput!) {
+    tcpPostReply(input: $input) { ${REPLY_FIELDS} }
+  }
+`;
+var MODERATE_REPLY = `
+  mutation TheculturepostModerateReply($id: ID!, $status: TcpModerationStatus!) {
+    tcpModerateReply(id: $id, status: $status) { ${REPLY_FIELDS} }
+  }
+`;
+var HEALTH = `
+  query TheculturepostHealth {
+    tcpHealth
+  }
+`;
+var AccessLevelEnum = zod.z.enum(["COMMUNITY", "EMBARGOED", "PUBLIC", "RESTRICTED"]).describe("Visibility/access level of an archive item or oral history");
+var ArchiveItemKindEnum = zod.z.enum(["AUDIO", "DOCUMENT", "MANUSCRIPT", "MAP", "OBJECT", "PHOTOGRAPH", "VIDEO"]).describe("Kind of cultural artifact in the archive");
+var ModerationStatusEnum = zod.z.enum(["APPROVED", "FLAGGED", "PENDING", "REMOVED"]).describe("Moderation status of a discussion or reply");
+var SourceTypeEnum = zod.z.enum([
+  "ACADEMIC",
+  "ARCHIVAL_RECORD",
+  "ARTIFACT",
+  "BOOK",
+  "INTERVIEW",
+  "PERIODICAL",
+  "PRIMARY_DOCUMENT",
+  "WEB"
+]).describe("Type of cited source backing a story claim");
+var StoryFormatEnum = zod.z.enum(["ARTICLE", "ESSAY", "EXPLAINER", "ORAL_HISTORY", "PHOTO_STORY", "TIMELINE"]).describe("Editorial format of a story");
+var StoryStatusEnum = zod.z.enum(["ARCHIVED", "DRAFT", "IDEA", "IN_REVIEW", "PUBLISHED"]).describe("Editorial lifecycle status of a story");
+var TopicCategoryEnum = zod.z.enum([
+  "CULTURE_AND_IDENTITY",
+  "FESTIVALS_AND_RITUALS",
+  "HERITAGE_AND_ARCHIVES",
+  "HISTORY",
+  "MIGRATION_AND_DIASPORA",
+  "ORAL_HISTORIES",
+  "PHILOSOPHY_AND_THOUGHT",
+  "RELIGION_AND_FAITH",
+  "VALUES_AND_ETHICS"
+]).describe("Thematic category of a topic");
+var VerificationStatusEnum = zod.z.enum(["CORROBORATED", "DISPUTED", "RETRACTED", "UNVERIFIED"]).describe("Verification status of a citation");
+var paginationShape = {
+  cursor: zod.z.string().optional().describe("Opaque cursor for keyset pagination"),
+  limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+  offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+};
+function buildPagination(args) {
+  const pagination = {};
+  if (args.cursor !== void 0) pagination.cursor = args.cursor;
+  if (args.limit !== void 0) pagination.limit = args.limit;
+  if (args.offset !== void 0) pagination.offset = args.offset;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/theculturepost/tools/stories.ts
+function registerStoryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "stories_get")),
+    {
+      title: "Get Story",
+      description: "Fetch a single TheCulturePost story by ID, including its topic and citations.",
+      inputSchema: { id: zod.z.string().describe("Story ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_STORY, { id });
+        if (!data.tcpStory) return errorResult(`Story ${id} not found`);
+        return jsonResult(data.tcpStory);
+      } catch (error) {
+        ctx.logger.error("theculturepost stories_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get story: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "stories_list")),
+    {
+      title: "List Stories",
+      description: "List stories in the bound workspace, optionally filtered by editorial status and/or topic. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        status: StoryStatusEnum.optional().describe("Filter by editorial status"),
+        topicId: zod.z.string().optional().describe("Filter by topic ID"),
+        ...paginationShape
+      }
+    },
+    async ({ status, topicId, cursor, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_STORIES, {
+          status,
+          topicId,
+          pagination: buildPagination({ cursor, limit, offset })
+        });
+        return jsonResult(data.tcpListStories);
+      } catch (error) {
+        ctx.logger.error("theculturepost stories_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list stories: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "stories_create")),
+    {
+      title: "Create Story",
+      description: "Draft a new story. `slug` must be unique within the workspace. Stories start in DRAFT (or IDEA) and advance via stories_transition.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Story headline"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        topicId: zod.z.string().optional().describe("Owning topic ID"),
+        summary: zod.z.string().optional().describe("Short standfirst / dek"),
+        body: zod.z.string().optional().describe("Story body (markdown/rich text)"),
+        format: StoryFormatEnum.optional().describe("Editorial format (default ARTICLE)"),
+        languages: zod.z.array(zod.z.string()).optional().describe("ISO language codes the story is in"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags"),
+        readingMins: zod.z.number().int().optional().describe("Estimated reading time in minutes"),
+        authorId: zod.z.string().optional().describe("Author user ID"),
+        editorId: zod.z.string().optional().describe("Editor user ID"),
+        coverFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the hero image")
+      }
+    },
+    async ({
+      title,
+      slug,
+      topicId,
+      summary,
+      body,
+      format,
+      languages,
+      tags,
+      readingMins,
+      authorId,
+      editorId,
+      coverFileId
+    }) => {
+      try {
+        const input = { title, slug };
+        if (topicId !== void 0) input.topicId = topicId;
+        if (summary !== void 0) input.summary = summary;
+        if (body !== void 0) input.body = body;
+        if (format !== void 0) input.format = format;
+        if (languages !== void 0) input.languages = languages;
+        if (tags !== void 0) input.tags = tags;
+        if (readingMins !== void 0) input.readingMins = readingMins;
+        if (authorId !== void 0) input.authorId = authorId;
+        if (editorId !== void 0) input.editorId = editorId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        const data = await ctx.gql.workspace.request(CREATE_STORY, { input });
+        return jsonResult(data.tcpCreateStory);
+      } catch (error) {
+        ctx.logger.error("theculturepost stories_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create story: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "stories_update")),
+    {
+      title: "Update Story",
+      description: "Update a story\u2019s editorial fields. At least one mutable field must be provided. Use stories_transition to change `status`.",
+      inputSchema: {
+        id: zod.z.string().describe("Story ID"),
+        title: zod.z.string().optional().describe("Updated headline"),
+        summary: zod.z.string().optional().describe("Updated standfirst / dek"),
+        body: zod.z.string().optional().describe("Updated body"),
+        format: StoryFormatEnum.optional().describe("Updated editorial format"),
+        languages: zod.z.array(zod.z.string()).optional().describe("Updated language codes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        readingMins: zod.z.number().int().optional().describe("Updated reading time"),
+        topicId: zod.z.string().optional().describe("Reassign to a topic"),
+        authorId: zod.z.string().optional().describe("Updated author user ID"),
+        editorId: zod.z.string().optional().describe("Updated editor user ID"),
+        coverFileId: zod.z.string().optional().describe("Updated hero-image File ID")
+      }
+    },
+    async ({
+      id,
+      title,
+      summary,
+      body,
+      format,
+      languages,
+      tags,
+      readingMins,
+      topicId,
+      authorId,
+      editorId,
+      coverFileId
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (summary !== void 0) input.summary = summary;
+        if (body !== void 0) input.body = body;
+        if (format !== void 0) input.format = format;
+        if (languages !== void 0) input.languages = languages;
+        if (tags !== void 0) input.tags = tags;
+        if (readingMins !== void 0) input.readingMins = readingMins;
+        if (topicId !== void 0) input.topicId = topicId;
+        if (authorId !== void 0) input.authorId = authorId;
+        if (editorId !== void 0) input.editorId = editorId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/summary/body/format/languages/tags/readingMins/topicId/authorId/editorId/coverFileId"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_STORY, { id, input });
+        return jsonResult(data.tcpUpdateStory);
+      } catch (error) {
+        ctx.logger.error("theculturepost stories_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update story: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "stories_transition")),
+    {
+      title: "Transition Story",
+      description: "Advance a story through its editorial lifecycle (validated transitions): IDEA \u2192 DRAFT \u2192 IN_REVIEW \u2192 PUBLISHED \u2192 ARCHIVED.",
+      inputSchema: {
+        id: zod.z.string().describe("Story ID"),
+        status: StoryStatusEnum.describe("Target editorial status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_STORY, { id, status });
+        return jsonResult(data.tcpTransitionStory);
+      } catch (error) {
+        ctx.logger.error("theculturepost stories_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition story: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTopicTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topics_get")),
+    {
+      title: "Get Topic",
+      description: "Fetch a single topic by ID, including its stories.",
+      inputSchema: { id: zod.z.string().describe("Topic ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_TOPIC, { id });
+        if (!data.tcpTopic) return errorResult(`Topic ${id} not found`);
+        return jsonResult(data.tcpTopic);
+      } catch (error) {
+        ctx.logger.error("theculturepost topics_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get topic: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topics_list")),
+    {
+      title: "List Topics",
+      description: "List topics in the bound workspace, optionally filtered by category. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        category: TopicCategoryEnum.optional().describe("Filter by thematic category"),
+        ...paginationShape
+      }
+    },
+    async ({ category, cursor, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TOPICS, {
+          category,
+          pagination: buildPagination({ cursor, limit, offset })
+        });
+        return jsonResult(data.tcpListTopics);
+      } catch (error) {
+        ctx.logger.error("theculturepost topics_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list topics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topics_create")),
+    {
+      title: "Create Topic",
+      description: "Create a new topic. `slug` must be unique within the workspace. Default category is CULTURE_AND_IDENTITY.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Topic display name"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        category: TopicCategoryEnum.optional().describe(
+          "Thematic category (default CULTURE_AND_IDENTITY)"
+        ),
+        description: zod.z.string().optional().describe("Topic description"),
+        tradition: zod.z.string().optional().describe("Associated cultural/religious tradition"),
+        isFeatured: zod.z.boolean().optional().describe("Pin to the featured rail (default false)")
+      }
+    },
+    async ({ name, slug, category, description, tradition, isFeatured }) => {
+      try {
+        const input = { name, slug };
+        if (category !== void 0) input.category = category;
+        if (description !== void 0) input.description = description;
+        if (tradition !== void 0) input.tradition = tradition;
+        if (isFeatured !== void 0) input.isFeatured = isFeatured;
+        const data = await ctx.gql.workspace.request(CREATE_TOPIC, { input });
+        return jsonResult(data.tcpCreateTopic);
+      } catch (error) {
+        ctx.logger.error("theculturepost topics_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create topic: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topics_update")),
+    {
+      title: "Update Topic",
+      description: "Update a topic. At least one mutable field must be provided. (Slug is immutable.)",
+      inputSchema: {
+        id: zod.z.string().describe("Topic ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        category: TopicCategoryEnum.optional().describe("Updated thematic category"),
+        tradition: zod.z.string().optional().describe("Updated associated tradition"),
+        isFeatured: zod.z.boolean().optional().describe("Updated featured flag")
+      }
+    },
+    async ({ id, name, description, category, tradition, isFeatured }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (category !== void 0) input.category = category;
+        if (tradition !== void 0) input.tradition = tradition;
+        if (isFeatured !== void 0) input.isFeatured = isFeatured;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/category/tradition/isFeatured"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_TOPIC, { id, input });
+        return jsonResult(data.tcpUpdateTopic);
+      } catch (error) {
+        ctx.logger.error("theculturepost topics_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update topic: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "topics_archive")),
+    {
+      title: "Archive Topic",
+      description: "Archive (soft-delete) a topic. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Topic ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_TOPIC,
+          { id }
+        );
+        return jsonResult({ archived: data.tcpArchiveTopic, id });
+      } catch (error) {
+        ctx.logger.error("theculturepost topics_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive topic: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCitationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "citations_list")),
+    {
+      title: "List Citations",
+      description: "List the citations backing a given story.",
+      inputSchema: { storyId: zod.z.string().describe("Story ID") }
+    },
+    async ({ storyId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CITATIONS, { storyId });
+        return jsonResult(data.tcpListCitations);
+      } catch (error) {
+        ctx.logger.error("theculturepost citations_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list citations: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "citations_add")),
+    {
+      title: "Add Citation",
+      description: "Attach a citation to a story. New citations default to UNVERIFIED; use citations_verify to corroborate.",
+      inputSchema: {
+        storyId: zod.z.string().min(1).describe("Story the citation supports"),
+        title: zod.z.string().min(1).describe("Title of the cited work"),
+        sourceType: SourceTypeEnum.optional().describe("Type of source (default WEB)"),
+        author: zod.z.string().optional().describe("Author of the cited work"),
+        publisher: zod.z.string().optional().describe("Publisher / outlet"),
+        publishedOn: zod.z.string().optional().describe("Publication date (ISO 8601)"),
+        url: zod.z.string().optional().describe("Canonical URL of the source"),
+        excerpt: zod.z.string().optional().describe("Quoted excerpt supporting the claim"),
+        provenance: zod.z.string().optional().describe("Provenance / chain-of-custody note"),
+        sourceFileId: zod.z.string().optional().describe("wspace-files-svc File ID for a scan")
+      }
+    },
+    async ({
+      storyId,
+      title,
+      sourceType,
+      author,
+      publisher,
+      publishedOn,
+      url,
+      excerpt,
+      provenance,
+      sourceFileId
+    }) => {
+      try {
+        const input = { storyId, title };
+        if (sourceType !== void 0) input.sourceType = sourceType;
+        if (author !== void 0) input.author = author;
+        if (publisher !== void 0) input.publisher = publisher;
+        if (publishedOn !== void 0) input.publishedOn = publishedOn;
+        if (url !== void 0) input.url = url;
+        if (excerpt !== void 0) input.excerpt = excerpt;
+        if (provenance !== void 0) input.provenance = provenance;
+        if (sourceFileId !== void 0) input.sourceFileId = sourceFileId;
+        const data = await ctx.gql.workspace.request(ADD_CITATION, { input });
+        return jsonResult(data.tcpAddCitation);
+      } catch (error) {
+        ctx.logger.error("theculturepost citations_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add citation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "citations_verify")),
+    {
+      title: "Verify Citation",
+      description: "Set the verification status of a citation (CORROBORATED / DISPUTED / RETRACTED / UNVERIFIED).",
+      inputSchema: {
+        id: zod.z.string().describe("Citation ID"),
+        verification: VerificationStatusEnum.describe("New verification status")
+      }
+    },
+    async ({ id, verification }) => {
+      try {
+        const data = await ctx.gql.workspace.request(VERIFY_CITATION, { id, verification });
+        return jsonResult(data.tcpVerifyCitation);
+      } catch (error) {
+        ctx.logger.error("theculturepost citations_verify failed", { error: String(error) });
+        return errorResult(
+          `Failed to verify citation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerArchiveTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "archive_get")),
+    {
+      title: "Get Archive Item",
+      description: "Fetch a single archive item (cultural artifact) by ID, including its parent collection.",
+      inputSchema: { id: zod.z.string().describe("Archive item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ARCHIVE_ITEM, { id });
+        if (!data.tcpArchiveItem) return errorResult(`Archive item ${id} not found`);
+        return jsonResult(data.tcpArchiveItem);
+      } catch (error) {
+        ctx.logger.error("theculturepost archive_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get archive item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "archive_list")),
+    {
+      title: "List Archive Items",
+      description: "List archive items, optionally filtered by access level, collection, and/or kind. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        accessLevel: AccessLevelEnum.optional().describe("Filter by access level"),
+        collectionId: zod.z.string().optional().describe("Filter by parent collection ID"),
+        kind: ArchiveItemKindEnum.optional().describe("Filter by artifact kind"),
+        ...paginationShape
+      }
+    },
+    async ({ accessLevel, collectionId, kind, cursor, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ARCHIVE_ITEMS, {
+          accessLevel,
+          collectionId,
+          kind,
+          pagination: buildPagination({ cursor, limit, offset })
+        });
+        return jsonResult(data.tcpListArchiveItems);
+      } catch (error) {
+        ctx.logger.error("theculturepost archive_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list archive items: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "archive_create")),
+    {
+      title: "Create Archive Item",
+      description: "Add a cultural artifact to the archive. Default kind is DOCUMENT and default access level is PUBLIC. Reference the binary via `fileId` (wspace-files-svc).",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Artifact title"),
+        kind: ArchiveItemKindEnum.optional().describe("Artifact kind (default DOCUMENT)"),
+        accessLevel: AccessLevelEnum.optional().describe("Access level (default PUBLIC)"),
+        description: zod.z.string().optional().describe("Artifact description"),
+        collectionId: zod.z.string().optional().describe("Parent collection ID"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID for the binary"),
+        languages: zod.z.array(zod.z.string()).optional().describe("Languages present in the artifact"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags"),
+        origin: zod.z.string().optional().describe("Geographic / cultural origin"),
+        provenance: zod.z.string().optional().describe("Provenance / chain-of-custody note"),
+        datedAt: zod.z.string().optional().describe("Date the artifact is from (ISO 8601)")
+      }
+    },
+    async ({
+      title,
+      kind,
+      accessLevel,
+      description,
+      collectionId,
+      fileId,
+      languages,
+      tags,
+      origin,
+      provenance,
+      datedAt
+    }) => {
+      try {
+        const input = { title };
+        if (kind !== void 0) input.kind = kind;
+        if (accessLevel !== void 0) input.accessLevel = accessLevel;
+        if (description !== void 0) input.description = description;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (languages !== void 0) input.languages = languages;
+        if (tags !== void 0) input.tags = tags;
+        if (origin !== void 0) input.origin = origin;
+        if (provenance !== void 0) input.provenance = provenance;
+        if (datedAt !== void 0) input.datedAt = datedAt;
+        const data = await ctx.gql.workspace.request(CREATE_ARCHIVE_ITEM, { input });
+        return jsonResult(data.tcpCreateArchiveItem);
+      } catch (error) {
+        ctx.logger.error("theculturepost archive_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create archive item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "archive_update")),
+    {
+      title: "Update Archive Item",
+      description: "Update an archive item. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Archive item ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        kind: ArchiveItemKindEnum.optional().describe("Updated artifact kind"),
+        accessLevel: AccessLevelEnum.optional().describe("Updated access level"),
+        description: zod.z.string().optional().describe("Updated description"),
+        collectionId: zod.z.string().optional().describe("Reassign to a collection"),
+        fileId: zod.z.string().optional().describe("Updated binary File ID"),
+        languages: zod.z.array(zod.z.string()).optional().describe("Updated languages"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        origin: zod.z.string().optional().describe("Updated origin"),
+        provenance: zod.z.string().optional().describe("Updated provenance"),
+        datedAt: zod.z.string().optional().describe("Updated artifact date (ISO 8601)")
+      }
+    },
+    async ({
+      id,
+      title,
+      kind,
+      accessLevel,
+      description,
+      collectionId,
+      fileId,
+      languages,
+      tags,
+      origin,
+      provenance,
+      datedAt
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (kind !== void 0) input.kind = kind;
+        if (accessLevel !== void 0) input.accessLevel = accessLevel;
+        if (description !== void 0) input.description = description;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (languages !== void 0) input.languages = languages;
+        if (tags !== void 0) input.tags = tags;
+        if (origin !== void 0) input.origin = origin;
+        if (provenance !== void 0) input.provenance = provenance;
+        if (datedAt !== void 0) input.datedAt = datedAt;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/kind/accessLevel/description/collectionId/fileId/languages/tags/origin/provenance/datedAt"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_ARCHIVE_ITEM, { id, input });
+        return jsonResult(data.tcpUpdateArchiveItem);
+      } catch (error) {
+        ctx.logger.error("theculturepost archive_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update archive item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "archive_archive")),
+    {
+      title: "Archive Archive Item",
+      description: "Archive (soft-delete) an archive item. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Archive item ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_ARCHIVE_ITEM,
+          { id }
+        );
+        return jsonResult({ archived: data.tcpArchiveArchiveItem, id });
+      } catch (error) {
+        ctx.logger.error("theculturepost archive_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive archive item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCollectionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "collections_get")),
+    {
+      title: "Get Collection",
+      description: "Fetch a single collection by ID, including its archive items and oral histories.",
+      inputSchema: { id: zod.z.string().describe("Collection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_COLLECTION, { id });
+        if (!data.tcpCollection) return errorResult(`Collection ${id} not found`);
+        return jsonResult(data.tcpCollection);
+      } catch (error) {
+        ctx.logger.error("theculturepost 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 the curated collections in the bound workspace.",
+      inputSchema: { ...paginationShape }
+    },
+    async ({ cursor, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COLLECTIONS, {
+          pagination: buildPagination({ cursor, limit, offset })
+        });
+        return jsonResult(data.tcpListCollections);
+      } catch (error) {
+        ctx.logger.error("theculturepost 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: {
+        name: zod.z.string().min(1).describe("Collection display name"),
+        slug: zod.z.string().min(1).describe("URL slug, unique within the workspace"),
+        description: zod.z.string().optional().describe("Collection description"),
+        tradition: zod.z.string().optional().describe("Associated cultural/religious tradition"),
+        coverFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the cover image")
+      }
+    },
+    async ({ name, slug, description, tradition, coverFileId }) => {
+      try {
+        const input = { name, slug };
+        if (description !== void 0) input.description = description;
+        if (tradition !== void 0) input.tradition = tradition;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        const data = await ctx.gql.workspace.request(CREATE_COLLECTION, { input });
+        return jsonResult(data.tcpCreateCollection);
+      } catch (error) {
+        ctx.logger.error("theculturepost collections_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create collection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerOralHistoryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "oralhistories_list")),
+    {
+      title: "List Oral Histories",
+      description: "List recorded oral histories, optionally scoped to a single collection.",
+      inputSchema: {
+        collectionId: zod.z.string().optional().describe("Filter by parent collection ID")
+      }
+    },
+    async ({ collectionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ORAL_HISTORIES, { collectionId });
+        return jsonResult(data.tcpListOralHistories);
+      } catch (error) {
+        ctx.logger.error("theculturepost oralhistories_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list oral histories: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "oralhistories_record")),
+    {
+      title: "Record Oral History",
+      description: "Register a recorded oral history. Default access level is COMMUNITY. Reference the recording via `recordingFileId` (wspace-files-svc, audio/video).",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Oral-history title"),
+        accessLevel: AccessLevelEnum.optional().describe("Access level (default COMMUNITY)"),
+        collectionId: zod.z.string().optional().describe("Parent collection ID"),
+        narratorName: zod.z.string().optional().describe("Name of the narrator/storyteller"),
+        language: zod.z.string().optional().describe("Language of the recording"),
+        summary: zod.z.string().optional().describe("Short summary"),
+        transcript: zod.z.string().optional().describe("Full transcript text"),
+        durationSecs: zod.z.number().int().optional().describe("Recording duration in seconds"),
+        recordedAt: zod.z.string().optional().describe("Date recorded (ISO 8601)"),
+        recordingFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the recording")
+      }
+    },
+    async ({
+      title,
+      accessLevel,
+      collectionId,
+      narratorName,
+      language,
+      summary,
+      transcript,
+      durationSecs,
+      recordedAt,
+      recordingFileId
+    }) => {
+      try {
+        const input = { title };
+        if (accessLevel !== void 0) input.accessLevel = accessLevel;
+        if (collectionId !== void 0) input.collectionId = collectionId;
+        if (narratorName !== void 0) input.narratorName = narratorName;
+        if (language !== void 0) input.language = language;
+        if (summary !== void 0) input.summary = summary;
+        if (transcript !== void 0) input.transcript = transcript;
+        if (durationSecs !== void 0) input.durationSecs = durationSecs;
+        if (recordedAt !== void 0) input.recordedAt = recordedAt;
+        if (recordingFileId !== void 0) input.recordingFileId = recordingFileId;
+        const data = await ctx.gql.workspace.request(RECORD_ORAL_HISTORY, { input });
+        return jsonResult(data.tcpRecordOralHistory);
+      } catch (error) {
+        ctx.logger.error("theculturepost oralhistories_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record oral history: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerDiscussionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "discussions_get")),
+    {
+      title: "Get Discussion",
+      description: "Fetch a single discussion by ID, including its replies.",
+      inputSchema: { id: zod.z.string().describe("Discussion ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_DISCUSSION, { id });
+        if (!data.tcpDiscussion) return errorResult(`Discussion ${id} not found`);
+        return jsonResult(data.tcpDiscussion);
+      } catch (error) {
+        ctx.logger.error("theculturepost discussions_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get discussion: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "discussions_list")),
+    {
+      title: "List Discussions",
+      description: "List discussions, optionally filtered by moderation status and/or related story. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        status: ModerationStatusEnum.optional().describe("Filter by moderation status"),
+        storyId: zod.z.string().optional().describe("Filter by related story ID"),
+        ...paginationShape
+      }
+    },
+    async ({ status, storyId, cursor, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DISCUSSIONS, {
+          status,
+          storyId,
+          pagination: buildPagination({ cursor, limit, offset })
+        });
+        return jsonResult(data.tcpListDiscussions);
+      } catch (error) {
+        ctx.logger.error("theculturepost discussions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list discussions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "discussions_open")),
+    {
+      title: "Open Discussion",
+      description: "Open a new community discussion, optionally tied to a story and flagged interfaith.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Discussion title"),
+        prompt: zod.z.string().optional().describe("Opening prompt / framing question"),
+        storyId: zod.z.string().optional().describe("Related story ID"),
+        isInterfaith: zod.z.boolean().optional().describe("Flag as an interfaith dialogue (default false)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ title, prompt, storyId, isInterfaith, tags }) => {
+      try {
+        const input = { title };
+        if (prompt !== void 0) input.prompt = prompt;
+        if (storyId !== void 0) input.storyId = storyId;
+        if (isInterfaith !== void 0) input.isInterfaith = isInterfaith;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(OPEN_DISCUSSION, { input });
+        return jsonResult(data.tcpOpenDiscussion);
+      } catch (error) {
+        ctx.logger.error("theculturepost discussions_open failed", { error: String(error) });
+        return errorResult(
+          `Failed to open discussion: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "discussions_lock")),
+    {
+      title: "Lock Discussion",
+      description: "Lock a discussion thread to prevent further replies.",
+      inputSchema: { id: zod.z.string().describe("Discussion ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LOCK_DISCUSSION, { id });
+        return jsonResult(data.tcpLockDiscussion);
+      } catch (error) {
+        ctx.logger.error("theculturepost discussions_lock failed", { error: String(error) });
+        return errorResult(
+          `Failed to lock discussion: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReplyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "replies_list")),
+    {
+      title: "List Replies",
+      description: "List the replies on a discussion, optionally filtered by moderation status.",
+      inputSchema: {
+        discussionId: zod.z.string().describe("Discussion ID"),
+        status: ModerationStatusEnum.optional().describe("Filter by moderation status")
+      }
+    },
+    async ({ discussionId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REPLIES, { discussionId, status });
+        return jsonResult(data.tcpListReplies);
+      } catch (error) {
+        ctx.logger.error("theculturepost replies_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list replies: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "replies_post")),
+    {
+      title: "Post Reply",
+      description: "Post a reply to a discussion. Optionally label the contributor\u2019s `perspective` (e.g. a tradition or viewpoint).",
+      inputSchema: {
+        discussionId: zod.z.string().min(1).describe("Discussion being replied to"),
+        body: zod.z.string().min(1).describe("Reply body text"),
+        perspective: zod.z.string().optional().describe("Optional viewpoint/tradition label")
+      }
+    },
+    async ({ discussionId, body, perspective }) => {
+      try {
+        const input = { discussionId, body };
+        if (perspective !== void 0) input.perspective = perspective;
+        const data = await ctx.gql.workspace.request(POST_REPLY, { input });
+        return jsonResult(data.tcpPostReply);
+      } catch (error) {
+        ctx.logger.error("theculturepost replies_post failed", { error: String(error) });
+        return errorResult(
+          `Failed to post reply: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "replies_moderate")),
+    {
+      title: "Moderate Reply",
+      description: "Moderate a reply \u2014 set its status to APPROVED, FLAGGED, PENDING, or REMOVED.",
+      inputSchema: {
+        id: zod.z.string().describe("Reply ID"),
+        status: ModerationStatusEnum.describe("New moderation status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MODERATE_REPLY, { id, status });
+        return jsonResult(data.tcpModerateReply);
+      } catch (error) {
+        ctx.logger.error("theculturepost replies_moderate failed", { error: String(error) });
+        return errorResult(
+          `Failed to moderate reply: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/theculturepost/tools/system.ts
+function registerSystemTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "TheCulturePost Health Check",
+      description: "Public health probe for the TheCulturePost subgraph (tcpHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.tcpHealth });
+      } catch (error) {
+        ctx.logger.error("theculturepost health failed", { error: String(error) });
+        return errorResult(
+          `TheCulturePost health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/theculturepost/resources.ts
+function registerTheculturepostResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const storiesUri = track(mcpResourceUri(ctx.productName, "stories"));
+  const topicsUri = track(mcpResourceUri(ctx.productName, "topics"));
+  const collectionsUri = track(mcpResourceUri(ctx.productName, "collections"));
+  server.registerResource(
+    "theculturepost-schema",
+    schemaUri,
+    {
+      title: "TheCulturePost Domain Schema",
+      description: "Overview of the TheCulturePost domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# TheCulturePost Domain (Overview)
+
+Culture / religion / values / history platform \u2014 well-sourced stories, topic
+timelines, citable archives + oral histories, respectful community discussion.
+
+## Entities
+- TcpStory \u2014 an editorial story (has citations, belongs to a topic)
+- TcpTopic \u2014 a thematic hub grouping stories
+- TcpCitation \u2014 a cited source backing a story claim
+- TcpArchiveItem \u2014 a cultural artifact (binary referenced via wspace-files-svc File)
+- TcpCollection \u2014 a curated grouping of archive items + oral histories
+- TcpOralHistory \u2014 recorded first-person testimony (recording via File)
+- TcpDiscussion \u2014 a respectful community thread (optionally tied to a story)
+- TcpReply \u2014 a moderated contribution to a discussion
+
+## Enums
+- TcpStoryStatus: IDEA, DRAFT, IN_REVIEW, PUBLISHED, ARCHIVED
+- TcpStoryFormat: ARTICLE, ESSAY, EXPLAINER, ORAL_HISTORY, PHOTO_STORY, TIMELINE
+- TcpTopicCategory: CULTURE_AND_IDENTITY, FESTIVALS_AND_RITUALS, HERITAGE_AND_ARCHIVES, HISTORY, MIGRATION_AND_DIASPORA, ORAL_HISTORIES, PHILOSOPHY_AND_THOUGHT, RELIGION_AND_FAITH, VALUES_AND_ETHICS
+- TcpSourceType: ACADEMIC, ARCHIVAL_RECORD, ARTIFACT, BOOK, INTERVIEW, PERIODICAL, PRIMARY_DOCUMENT, WEB
+- TcpVerificationStatus: UNVERIFIED, CORROBORATED, DISPUTED, RETRACTED
+- TcpArchiveItemKind: AUDIO, DOCUMENT, MANUSCRIPT, MAP, OBJECT, PHOTOGRAPH, VIDEO
+- TcpAccessLevel: PUBLIC, COMMUNITY, RESTRICTED, EMBARGOED
+- TcpModerationStatus: PENDING, APPROVED, FLAGGED, REMOVED
+
+## Tool groups
+stories, topics, citations, archive, collections, oralhistories, discussions, replies, 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(
+    "theculturepost-stories",
+    storiesUri,
+    {
+      title: "TheCulturePost Stories",
+      description: "The first page of stories in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${storiesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_STORIES, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: storiesUri,
+              text: JSON.stringify(data.tcpListStories, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: storiesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "theculturepost-topics",
+    topicsUri,
+    {
+      title: "TheCulturePost Topic Directory",
+      description: "The first page of topics in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${topicsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TOPICS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: topicsUri,
+              text: JSON.stringify(data.tcpListTopics, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: topicsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "theculturepost-collections",
+    collectionsUri,
+    {
+      title: "TheCulturePost Collection Directory",
+      description: "The curated collections in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${collectionsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_COLLECTIONS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: collectionsUri,
+              text: JSON.stringify(data.tcpListCollections, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: collectionsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerTheculturepostPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const publishingName = track(mcpPromptName(p, "story-publishing"));
+  const archiveName = track(mcpPromptName(p, "archive-curation"));
+  server.registerPrompt(
+    publishingName,
+    {
+      title: "Story Publishing",
+      description: "Guide for taking a TheCulturePost story from idea to publication: pick/create a topic, draft the story, attach + verify citations, then transition through the editorial lifecycle.",
+      argsSchema: {
+        title: zod.z.string().optional().describe("Story headline"),
+        topicId: zod.z.string().optional().describe("Owning topic ID, if known")
+      }
+    },
+    ({ title, topicId }) => {
+      ctx.logger.debug(`Prompt ${publishingName} called`, { title, topicId });
+      const titleNote = title ? `Use the headline "${title}".` : "Ask the user for the story headline.";
+      const topicNote = topicId ? `File the story under topic ${topicId}.` : `First find or create a topic with ${p}_topics_list / ${p}_topics_create.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me publish a well-sourced TheCulturePost story. ${titleNote}
+
+1. **Topic**: ${topicNote}
+2. **Draft**: Use ${p}_stories_create. Provide a unique slug, a summary, a format (ARTICLE/ESSAY/EXPLAINER/PHOTO_STORY/TIMELINE/ORAL_HISTORY), and the body. It starts in DRAFT.
+3. **Cite**: For every factual claim, attach a source with ${p}_citations_add (set a sourceType and url/excerpt). Sourcing is non-negotiable here.
+4. **Verify**: Use ${p}_citations_verify to mark each citation CORROBORATED (or DISPUTED/RETRACTED). Review with ${p}_citations_list.
+5. **Review \u2192 Publish**: Use ${p}_stories_transition to move DRAFT \u2192 IN_REVIEW, then \u2192 PUBLISHED once citations check out.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    archiveName,
+    {
+      title: "Archive Curation",
+      description: "Workflow for curating a cultural archive: create a collection, add archive items and oral histories, then open a respectful community discussion.",
+      argsSchema: {
+        collectionId: zod.z.string().optional().describe("Collection ID to curate, if it exists")
+      }
+    },
+    ({ collectionId }) => {
+      ctx.logger.debug(`Prompt ${archiveName} called`, { collectionId });
+      const collectionNote = collectionId ? `Curate collection "${collectionId}".` : `First create a collection with ${p}_collections_create (unique slug).`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me curate a TheCulturePost archive collection. ${collectionNote}
+
+1. **Collection**: Use ${p}_collections_create (or ${p}_collections_get to inspect an existing one).
+2. **Archive Items**: Use ${p}_archive_create for each artifact \u2014 set a kind (PHOTOGRAPH/MANUSCRIPT/MAP/OBJECT/AUDIO/VIDEO/DOCUMENT), an accessLevel, provenance/origin, and reference the binary via fileId. List with ${p}_archive_list filtered by collectionId.
+3. **Oral Histories**: Use ${p}_oralhistories_record for recorded testimony (narratorName, language, transcript, recordingFileId). Review with ${p}_oralhistories_list.
+4. **Discussion**: Use ${p}_discussions_open to invite respectful community dialogue around the collection or a related story; moderate replies with ${p}_replies_moderate.
+
+Summarize what was added after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/theculturepost/index.ts
+var theculturepostModule = {
+  id: "theculturepost",
+  version: "0.0.1",
+  displayName: "TheCulturePost",
+  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;
+    };
+    registerStoryTools(server, ctx, trackTool);
+    registerTopicTools(server, ctx, trackTool);
+    registerCitationTools(server, ctx, trackTool);
+    registerArchiveTools(server, ctx, trackTool);
+    registerCollectionTools(server, ctx, trackTool);
+    registerOralHistoryTools(server, ctx, trackTool);
+    registerDiscussionTools(server, ctx, trackTool);
+    registerReplyTools(server, ctx, trackTool);
+    registerSystemTools(server, ctx, trackTool);
+    registerTheculturepostResources(server, ctx, trackResource);
+    registerTheculturepostPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var theculturepost_default = theculturepostModule;
+
+module.exports = theculturepost_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map