@burdenoff/mcp-libs 2026.627.2 → 2026.627.4

package/dist/modules/collabkin/index.js

@@ -0,0 +1,1516 @@
+import { mcpToolName, jsonResult, errorResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/collabkin/operations.ts
+var TREE_FIELDS = `
+  id name surname description status tags workspaceId createdAt updatedAt
+  coverFile { id }
+`;
+var PERSON_FIELDS = `
+  id treeId givenName familyName maidenName nickname gender lifeStatus
+  birthDate birthPlace deathDate bio tags linkedUserId workspaceId
+  createdAt updatedAt
+  photoFile { id }
+`;
+var RELATIONSHIP_FIELDS = `
+  id treeId fromPersonId toPersonId type certainty startDate endDate notes
+  workspaceId createdAt updatedAt
+`;
+var MEMBERSHIP_FIELDS = `
+  id treeId memberUserId personId role status invitedById invitedAt acceptedAt
+  workspaceId createdAt updatedAt
+`;
+var COMMENT_FIELDS = `
+  id body memoryId storyId workspaceId createdAt updatedAt
+`;
+var MEMORY_FIELDS = `
+  id treeId title description kind place takenAt tags visibility personId
+  workspaceId createdAt updatedAt
+  file { id }
+`;
+var STORY_FIELDS = `
+  id treeId title body format narrator personId tags visibility
+  workspaceId createdAt updatedAt
+  recordingFile { id }
+`;
+var EVENT_FIELDS = `
+  id treeId personId type title description date place isApproximate
+  workspaceId createdAt updatedAt
+`;
+var PAGE_INFO = `pageInfo { cursor hasMore }`;
+var GET_FAMILY_TREE = `
+  query CollabkinGetFamilyTree($id: ID!) {
+    colFamilyTree(id: $id) {
+      ${TREE_FIELDS}
+      people { id givenName familyName lifeStatus }
+      memberships { id memberUserId role status }
+    }
+  }
+`;
+var LIST_FAMILY_TREES = `
+  query CollabkinListFamilyTrees($pagination: PaginationInput, $status: ColTreeStatus) {
+    colListFamilyTrees(pagination: $pagination, status: $status) {
+      items { ${TREE_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_FAMILY_TREE = `
+  mutation CollabkinCreateFamilyTree($input: ColCreateFamilyTreeInput!) {
+    colCreateFamilyTree(input: $input) {
+      ${TREE_FIELDS}
+    }
+  }
+`;
+var UPDATE_FAMILY_TREE = `
+  mutation CollabkinUpdateFamilyTree($id: ID!, $input: ColUpdateFamilyTreeInput!) {
+    colUpdateFamilyTree(id: $id, input: $input) {
+      ${TREE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_FAMILY_TREE = `
+  mutation CollabkinArchiveFamilyTree($id: ID!) {
+    colArchiveFamilyTree(id: $id)
+  }
+`;
+var GET_PERSON = `
+  query CollabkinGetPerson($id: ID!) {
+    colPerson(id: $id) {
+      ${PERSON_FIELDS}
+      relationships { ${RELATIONSHIP_FIELDS} }
+    }
+  }
+`;
+var LIST_PEOPLE = `
+  query CollabkinListPeople(
+    $treeId: ID
+    $lifeStatus: ColLifeStatus
+    $pagination: PaginationInput
+  ) {
+    colListPeople(treeId: $treeId, lifeStatus: $lifeStatus, pagination: $pagination) {
+      items { ${PERSON_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_PERSON = `
+  mutation CollabkinCreatePerson($input: ColCreatePersonInput!) {
+    colCreatePerson(input: $input) {
+      ${PERSON_FIELDS}
+    }
+  }
+`;
+var UPDATE_PERSON = `
+  mutation CollabkinUpdatePerson($id: ID!, $input: ColUpdatePersonInput!) {
+    colUpdatePerson(id: $id, input: $input) {
+      ${PERSON_FIELDS}
+    }
+  }
+`;
+var DELETE_PERSON = `
+  mutation CollabkinDeletePerson($id: ID!) {
+    colDeletePerson(id: $id)
+  }
+`;
+var LIST_RELATIONSHIPS = `
+  query CollabkinListRelationships($treeId: ID, $personId: ID) {
+    colListRelationships(treeId: $treeId, personId: $personId) {
+      ${RELATIONSHIP_FIELDS}
+      fromPerson { id givenName familyName }
+      toPerson { id givenName familyName }
+    }
+  }
+`;
+var CREATE_RELATIONSHIP = `
+  mutation CollabkinCreateRelationship($input: ColCreateRelationshipInput!) {
+    colCreateRelationship(input: $input) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var DELETE_RELATIONSHIP = `
+  mutation CollabkinDeleteRelationship($id: ID!) {
+    colDeleteRelationship(id: $id)
+  }
+`;
+var LIST_MEMBERSHIPS = `
+  query CollabkinListMemberships($treeId: ID!) {
+    colListMemberships(treeId: $treeId) {
+      ${MEMBERSHIP_FIELDS}
+    }
+  }
+`;
+var INVITE_MEMBER = `
+  mutation CollabkinInviteMember($input: ColInviteMemberInput!) {
+    colInviteMember(input: $input) {
+      ${MEMBERSHIP_FIELDS}
+    }
+  }
+`;
+var ACCEPT_MEMBERSHIP = `
+  mutation CollabkinAcceptMembership($id: ID!) {
+    colAcceptMembership(id: $id) {
+      ${MEMBERSHIP_FIELDS}
+    }
+  }
+`;
+var REMOVE_MEMBER = `
+  mutation CollabkinRemoveMember($id: ID!) {
+    colRemoveMember(id: $id)
+  }
+`;
+var GET_MEMORY = `
+  query CollabkinGetMemory($id: ID!) {
+    colMemory(id: $id) {
+      ${MEMORY_FIELDS}
+      comments { ${COMMENT_FIELDS} }
+    }
+  }
+`;
+var LIST_MEMORIES = `
+  query CollabkinListMemories(
+    $treeId: ID
+    $personId: ID
+    $kind: ColMemoryKind
+    $pagination: PaginationInput
+  ) {
+    colListMemories(
+      treeId: $treeId
+      personId: $personId
+      kind: $kind
+      pagination: $pagination
+    ) {
+      items { ${MEMORY_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_MEMORY = `
+  mutation CollabkinCreateMemory($input: ColCreateMemoryInput!) {
+    colCreateMemory(input: $input) {
+      ${MEMORY_FIELDS}
+    }
+  }
+`;
+var UPDATE_MEMORY = `
+  mutation CollabkinUpdateMemory($id: ID!, $input: ColUpdateMemoryInput!) {
+    colUpdateMemory(id: $id, input: $input) {
+      ${MEMORY_FIELDS}
+    }
+  }
+`;
+var DELETE_MEMORY = `
+  mutation CollabkinDeleteMemory($id: ID!) {
+    colDeleteMemory(id: $id)
+  }
+`;
+var GET_STORY = `
+  query CollabkinGetStory($id: ID!) {
+    colStory(id: $id) {
+      ${STORY_FIELDS}
+      comments { ${COMMENT_FIELDS} }
+    }
+  }
+`;
+var LIST_STORIES = `
+  query CollabkinListStories(
+    $treeId: ID
+    $personId: ID
+    $pagination: PaginationInput
+  ) {
+    colListStories(treeId: $treeId, personId: $personId, pagination: $pagination) {
+      items { ${STORY_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_STORY = `
+  mutation CollabkinCreateStory($input: ColCreateStoryInput!) {
+    colCreateStory(input: $input) {
+      ${STORY_FIELDS}
+    }
+  }
+`;
+var DELETE_STORY = `
+  mutation CollabkinDeleteStory($id: ID!) {
+    colDeleteStory(id: $id)
+  }
+`;
+var LIST_COMMENTS = `
+  query CollabkinListComments($memoryId: ID, $storyId: ID) {
+    colListComments(memoryId: $memoryId, storyId: $storyId) {
+      ${COMMENT_FIELDS}
+    }
+  }
+`;
+var ADD_COMMENT = `
+  mutation CollabkinAddComment($input: ColCreateCommentInput!) {
+    colAddComment(input: $input) {
+      ${COMMENT_FIELDS}
+    }
+  }
+`;
+var DELETE_COMMENT = `
+  mutation CollabkinDeleteComment($id: ID!) {
+    colDeleteComment(id: $id)
+  }
+`;
+var TIMELINE = `
+  query CollabkinTimeline($treeId: ID!, $personId: ID, $type: ColEventType) {
+    colTimeline(treeId: $treeId, personId: $personId, type: $type) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var CREATE_EVENT = `
+  mutation CollabkinCreateEvent($input: ColCreateEventInput!) {
+    colCreateEvent(input: $input) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var DELETE_EVENT = `
+  mutation CollabkinDeleteEvent($id: ID!) {
+    colDeleteEvent(id: $id)
+  }
+`;
+var HEALTH = `
+  query CollabkinHealth {
+    colHealth
+  }
+`;
+var TreeStatusEnum = z.enum(["ACTIVE", "ARCHIVED"]).describe("Lifecycle status of a family tree");
+var GenderEnum = z.enum(["FEMALE", "MALE", "OTHER", "UNKNOWN"]).describe("Gender of a person");
+var LifeStatusEnum = z.enum(["DECEASED", "LIVING", "UNKNOWN"]).describe("Whether a person is living, deceased, or unknown");
+var MemberRoleEnum = z.enum(["CONTRIBUTOR", "OWNER", "STEWARD", "VIEWER"]).describe("A member\u2019s role within a family tree");
+var MemoryKindEnum = z.enum(["ARTIFACT", "AUDIO", "DOCUMENT", "PHOTO", "VIDEO"]).describe("Media type of a memory");
+var VisibilityEnum = z.enum(["PRIVATE", "STEWARDS", "TREE"]).describe("Who can see a memory or story (PRIVATE, STEWARDS, or whole TREE)");
+var EventTypeEnum = z.enum([
+  "BIRTH",
+  "DEATH",
+  "DIVORCE",
+  "EDUCATION",
+  "IMMIGRATION",
+  "MARRIAGE",
+  "MILESTONE",
+  "MILITARY",
+  "OTHER",
+  "RESIDENCE"
+]).describe("Type of a timeline event");
+var RelationshipTypeEnum = z.enum([
+  "CHILD",
+  "GRANDCHILD",
+  "GRANDPARENT",
+  "GUARDIAN",
+  "PARENT",
+  "PARTNER",
+  "SIBLING",
+  "SPOUSE"
+]).describe("Kind of relationship between two people");
+var StoryFormatEnum = z.enum(["AUDIO", "VIDEO", "WRITTEN"]).describe("Format a story is recorded in");
+var CertaintyEnum = z.enum(["CONFIRMED", "DISPUTED", "PROBABLE", "UNVERIFIED"]).describe("Confidence level of a recorded relationship");
+function buildPagination(limit, offset, cursor) {
+  const pagination = {};
+  if (limit !== void 0) pagination.limit = limit;
+  if (offset !== void 0) pagination.offset = offset;
+  if (cursor !== void 0) pagination.cursor = cursor;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/collabkin/tools/trees.ts
+function registerTreeTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "trees_list")),
+    {
+      title: "List Family Trees",
+      description: "List the family trees in the bound workspace, optionally filtered by status (ACTIVE/ARCHIVED), with cursor/offset pagination.",
+      inputSchema: {
+        status: TreeStatusEnum.optional().describe("Filter by tree status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_FAMILY_TREES, {
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.colListFamilyTrees);
+      } catch (error) {
+        ctx.logger.error("collabkin trees_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list family trees: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "trees_get")),
+    {
+      title: "Get Family Tree",
+      description: "Fetch a single family tree by ID, including a summary of its people and memberships.",
+      inputSchema: { id: z.string().describe("Family tree ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_FAMILY_TREE, { id });
+        if (!data.colFamilyTree) return errorResult(`Family tree ${id} not found`);
+        return jsonResult(data.colFamilyTree);
+      } catch (error) {
+        ctx.logger.error("collabkin trees_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get family tree: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "trees_create")),
+    {
+      title: "Create Family Tree",
+      description: "Create a new family tree. Only `name` is required; `coverFileId` references a wspace-files-svc File.",
+      inputSchema: {
+        name: z.string().min(1).describe("Family tree name"),
+        surname: z.string().optional().describe("Primary family surname"),
+        description: z.string().optional().describe("Tree description"),
+        coverFileId: z.string().optional().describe("Cover image File ID (wspace-files-svc)"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ name, surname, description, coverFileId, tags }) => {
+      try {
+        const input = { name };
+        if (surname !== void 0) input.surname = surname;
+        if (description !== void 0) input.description = description;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_FAMILY_TREE, { input });
+        return jsonResult(data.colCreateFamilyTree);
+      } catch (error) {
+        ctx.logger.error("collabkin trees_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create family tree: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "trees_update")),
+    {
+      title: "Update Family Tree",
+      description: "Update a family tree. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Family tree ID"),
+        name: z.string().optional().describe("Updated name"),
+        surname: z.string().optional().describe("Updated surname"),
+        description: z.string().optional().describe("Updated description"),
+        coverFileId: z.string().optional().describe("Updated cover image File ID"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, surname, description, coverFileId, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (surname !== void 0) input.surname = surname;
+        if (description !== void 0) input.description = description;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/surname/description/coverFileId/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_FAMILY_TREE, { id, input });
+        return jsonResult(data.colUpdateFamilyTree);
+      } catch (error) {
+        ctx.logger.error("collabkin trees_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update family tree: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "trees_archive")),
+    {
+      title: "Archive Family Tree",
+      description: "Archive a family tree (soft delete \u2014 sets status to ARCHIVED).",
+      inputSchema: { id: z.string().describe("Family tree ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_FAMILY_TREE,
+          { id }
+        );
+        return jsonResult({ success: data.colArchiveFamilyTree, id });
+      } catch (error) {
+        ctx.logger.error("collabkin trees_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive family tree: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPersonTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "people_list")),
+    {
+      title: "List People",
+      description: "List people in a family tree, optionally filtered by tree and/or life status, with cursor/offset pagination.",
+      inputSchema: {
+        treeId: z.string().optional().describe("Filter by family tree ID"),
+        lifeStatus: LifeStatusEnum.optional().describe("Filter by life status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ treeId, lifeStatus, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PEOPLE, {
+          treeId,
+          lifeStatus,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.colListPeople);
+      } catch (error) {
+        ctx.logger.error("collabkin 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_get")),
+    {
+      title: "Get Person",
+      description: "Fetch a single person by ID, including their relationships.",
+      inputSchema: { id: z.string().describe("Person ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PERSON, { id });
+        if (!data.colPerson) return errorResult(`Person ${id} not found`);
+        return jsonResult(data.colPerson);
+      } catch (error) {
+        ctx.logger.error("collabkin people_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get person: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "people_create")),
+    {
+      title: "Create Person",
+      description: "Add a person to a family tree. `treeId` and `givenName` are required; `linkedUserId` links the person to a platform user, `photoFileId` references a wspace-files-svc File.",
+      inputSchema: {
+        treeId: z.string().min(1).describe("Owning family tree ID"),
+        givenName: z.string().min(1).describe("Given (first) name"),
+        familyName: z.string().optional().describe("Family (last) name"),
+        maidenName: z.string().optional().describe("Maiden name"),
+        nickname: z.string().optional().describe("Nickname"),
+        gender: GenderEnum.optional().describe("Gender (default UNKNOWN)"),
+        lifeStatus: LifeStatusEnum.optional().describe("Life status (default UNKNOWN)"),
+        birthDate: z.string().optional().describe("Birth date (ISO-8601 DateTime)"),
+        birthPlace: z.string().optional().describe("Birth place"),
+        deathDate: z.string().optional().describe("Death date (ISO-8601 DateTime)"),
+        bio: z.string().optional().describe("Biographical notes"),
+        linkedUserId: z.string().optional().describe("Linked platform user ID"),
+        photoFileId: z.string().optional().describe("Portrait photo File ID"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      treeId,
+      givenName,
+      familyName,
+      maidenName,
+      nickname,
+      gender,
+      lifeStatus,
+      birthDate,
+      birthPlace,
+      deathDate,
+      bio,
+      linkedUserId,
+      photoFileId,
+      tags
+    }) => {
+      try {
+        const input = { treeId, givenName };
+        if (familyName !== void 0) input.familyName = familyName;
+        if (maidenName !== void 0) input.maidenName = maidenName;
+        if (nickname !== void 0) input.nickname = nickname;
+        if (gender !== void 0) input.gender = gender;
+        if (lifeStatus !== void 0) input.lifeStatus = lifeStatus;
+        if (birthDate !== void 0) input.birthDate = birthDate;
+        if (birthPlace !== void 0) input.birthPlace = birthPlace;
+        if (deathDate !== void 0) input.deathDate = deathDate;
+        if (bio !== void 0) input.bio = bio;
+        if (linkedUserId !== void 0) input.linkedUserId = linkedUserId;
+        if (photoFileId !== void 0) input.photoFileId = photoFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PERSON, { input });
+        return jsonResult(data.colCreatePerson);
+      } catch (error) {
+        ctx.logger.error("collabkin 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, "people_update")),
+    {
+      title: "Update Person",
+      description: "Update a person. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Person ID"),
+        givenName: z.string().optional().describe("Updated given name"),
+        familyName: z.string().optional().describe("Updated family name"),
+        maidenName: z.string().optional().describe("Updated maiden name"),
+        nickname: z.string().optional().describe("Updated nickname"),
+        gender: GenderEnum.optional().describe("Updated gender"),
+        lifeStatus: LifeStatusEnum.optional().describe("Updated life status"),
+        birthDate: z.string().optional().describe("Updated birth date (ISO-8601 DateTime)"),
+        birthPlace: z.string().optional().describe("Updated birth place"),
+        deathDate: z.string().optional().describe("Updated death date (ISO-8601 DateTime)"),
+        bio: z.string().optional().describe("Updated biographical notes"),
+        linkedUserId: z.string().optional().describe("Updated linked platform user ID"),
+        photoFileId: z.string().optional().describe("Updated portrait photo File ID"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      givenName,
+      familyName,
+      maidenName,
+      nickname,
+      gender,
+      lifeStatus,
+      birthDate,
+      birthPlace,
+      deathDate,
+      bio,
+      linkedUserId,
+      photoFileId,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (givenName !== void 0) input.givenName = givenName;
+        if (familyName !== void 0) input.familyName = familyName;
+        if (maidenName !== void 0) input.maidenName = maidenName;
+        if (nickname !== void 0) input.nickname = nickname;
+        if (gender !== void 0) input.gender = gender;
+        if (lifeStatus !== void 0) input.lifeStatus = lifeStatus;
+        if (birthDate !== void 0) input.birthDate = birthDate;
+        if (birthPlace !== void 0) input.birthPlace = birthPlace;
+        if (deathDate !== void 0) input.deathDate = deathDate;
+        if (bio !== void 0) input.bio = bio;
+        if (linkedUserId !== void 0) input.linkedUserId = linkedUserId;
+        if (photoFileId !== void 0) input.photoFileId = photoFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable person field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PERSON, { id, input });
+        return jsonResult(data.colUpdatePerson);
+      } catch (error) {
+        ctx.logger.error("collabkin people_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update person: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "people_delete")),
+    {
+      title: "Delete Person",
+      description: "Delete a person from a family tree.",
+      inputSchema: { id: z.string().describe("Person ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_PERSON,
+          { id }
+        );
+        return jsonResult({ success: data.colDeletePerson, id });
+      } catch (error) {
+        ctx.logger.error("collabkin people_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete person: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRelationshipTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_list")),
+    {
+      title: "List Relationships",
+      description: "List relationships, optionally filtered by family tree and/or a specific person (relationships touching that person).",
+      inputSchema: {
+        treeId: z.string().optional().describe("Filter by family tree ID"),
+        personId: z.string().optional().describe("Filter to relationships involving this person")
+      }
+    },
+    async ({ treeId, personId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RELATIONSHIPS, { treeId, personId });
+        return jsonResult(data.colListRelationships);
+      } catch (error) {
+        ctx.logger.error("collabkin relationships_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list relationships: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_create")),
+    {
+      title: "Create Relationship",
+      description: "Create a relationship between two people in a family tree (e.g. PARENT, SPOUSE, SIBLING). `fromPersonId`, `toPersonId`, `treeId`, and `type` are required.",
+      inputSchema: {
+        treeId: z.string().min(1).describe("Owning family tree ID"),
+        fromPersonId: z.string().min(1).describe("Source person ID"),
+        toPersonId: z.string().min(1).describe("Target person ID"),
+        type: RelationshipTypeEnum.describe("Relationship type"),
+        certainty: CertaintyEnum.optional().describe("Confidence level (default CONFIRMED)"),
+        startDate: z.string().optional().describe("Relationship start (ISO-8601 DateTime)"),
+        endDate: z.string().optional().describe("Relationship end (ISO-8601 DateTime)"),
+        notes: z.string().optional().describe("Free-text notes")
+      }
+    },
+    async ({ treeId, fromPersonId, toPersonId, type, certainty, startDate, endDate, notes }) => {
+      try {
+        const input = { treeId, fromPersonId, toPersonId, type };
+        if (certainty !== void 0) input.certainty = certainty;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(CREATE_RELATIONSHIP, { input });
+        return jsonResult(data.colCreateRelationship);
+      } catch (error) {
+        ctx.logger.error("collabkin relationships_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_delete")),
+    {
+      title: "Delete Relationship",
+      description: "Delete a relationship between two people.",
+      inputSchema: { id: z.string().describe("Relationship ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_RELATIONSHIP,
+          { id }
+        );
+        return jsonResult({ success: data.colDeleteRelationship, id });
+      } catch (error) {
+        ctx.logger.error("collabkin relationships_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMembershipTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_list")),
+    {
+      title: "List Memberships",
+      description: "List the memberships (invited/active/declined/removed) for a family tree.",
+      inputSchema: { treeId: z.string().describe("Family tree ID") }
+    },
+    async ({ treeId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEMBERSHIPS, { treeId });
+        return jsonResult(data.colListMemberships);
+      } catch (error) {
+        ctx.logger.error("collabkin memberships_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list memberships: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_invite")),
+    {
+      title: "Invite Member",
+      description: "Invite a platform user to collaborate on a family tree. `treeId` and `memberUserId` are required; `personId` optionally links the member to a person record.",
+      inputSchema: {
+        treeId: z.string().min(1).describe("Family tree ID"),
+        memberUserId: z.string().min(1).describe("Invited platform user ID"),
+        personId: z.string().optional().describe("Linked person ID within the tree"),
+        role: MemberRoleEnum.optional().describe("Member role (default VIEWER)")
+      }
+    },
+    async ({ treeId, memberUserId, personId, role }) => {
+      try {
+        const input = { treeId, memberUserId };
+        if (personId !== void 0) input.personId = personId;
+        if (role !== void 0) input.role = role;
+        const data = await ctx.gql.workspace.request(INVITE_MEMBER, { input });
+        return jsonResult(data.colInviteMember);
+      } catch (error) {
+        ctx.logger.error("collabkin memberships_invite failed", { error: String(error) });
+        return errorResult(
+          `Failed to invite member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_accept")),
+    {
+      title: "Accept Membership",
+      description: "Accept a pending membership invitation (moves it to ACTIVE).",
+      inputSchema: { id: z.string().describe("Membership ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ACCEPT_MEMBERSHIP, { id });
+        return jsonResult(data.colAcceptMembership);
+      } catch (error) {
+        ctx.logger.error("collabkin memberships_accept failed", { error: String(error) });
+        return errorResult(
+          `Failed to accept membership: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memberships_remove")),
+    {
+      title: "Remove Member",
+      description: "Remove a member from a family tree (sets status to REMOVED).",
+      inputSchema: { id: z.string().describe("Membership ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_MEMBER,
+          { id }
+        );
+        return jsonResult({ success: data.colRemoveMember, id });
+      } catch (error) {
+        ctx.logger.error("collabkin memberships_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMemoryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memories_list")),
+    {
+      title: "List Memories",
+      description: "List memories, optionally filtered by tree, person, and/or media kind, with cursor/offset pagination.",
+      inputSchema: {
+        treeId: z.string().optional().describe("Filter by family tree ID"),
+        personId: z.string().optional().describe("Filter by associated person ID"),
+        kind: MemoryKindEnum.optional().describe("Filter by media kind"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ treeId, personId, kind, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEMORIES, {
+          treeId,
+          personId,
+          kind,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.colListMemories);
+      } catch (error) {
+        ctx.logger.error("collabkin memories_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list memories: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memories_get")),
+    {
+      title: "Get Memory",
+      description: "Fetch a single memory by ID, including its comments.",
+      inputSchema: { id: z.string().describe("Memory ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_MEMORY, { id });
+        if (!data.colMemory) return errorResult(`Memory ${id} not found`);
+        return jsonResult(data.colMemory);
+      } catch (error) {
+        ctx.logger.error("collabkin memories_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get memory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memories_create")),
+    {
+      title: "Create Memory",
+      description: "Add a memory (photo/video/document/artifact) to a family tree. `treeId` and `title` are required; `fileId` references a wspace-files-svc File.",
+      inputSchema: {
+        treeId: z.string().min(1).describe("Owning family tree ID"),
+        title: z.string().min(1).describe("Memory title"),
+        description: z.string().optional().describe("Memory description"),
+        kind: MemoryKindEnum.optional().describe("Media kind (default PHOTO)"),
+        fileId: z.string().optional().describe("Media File ID (wspace-files-svc)"),
+        personId: z.string().optional().describe("Associated person ID"),
+        place: z.string().optional().describe("Where the memory was captured"),
+        takenAt: z.string().optional().describe("When it was captured (ISO-8601 DateTime)"),
+        tags: z.array(z.string()).optional().describe("Discovery tags"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default TREE)")
+      }
+    },
+    async ({
+      treeId,
+      title,
+      description,
+      kind,
+      fileId,
+      personId,
+      place,
+      takenAt,
+      tags,
+      visibility
+    }) => {
+      try {
+        const input = { treeId, title };
+        if (description !== void 0) input.description = description;
+        if (kind !== void 0) input.kind = kind;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (personId !== void 0) input.personId = personId;
+        if (place !== void 0) input.place = place;
+        if (takenAt !== void 0) input.takenAt = takenAt;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(CREATE_MEMORY, { input });
+        return jsonResult(data.colCreateMemory);
+      } catch (error) {
+        ctx.logger.error("collabkin memories_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create memory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memories_update")),
+    {
+      title: "Update Memory",
+      description: "Update a memory. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Memory ID"),
+        title: z.string().optional().describe("Updated title"),
+        description: z.string().optional().describe("Updated description"),
+        kind: MemoryKindEnum.optional().describe("Updated media kind"),
+        fileId: z.string().optional().describe("Updated media File ID"),
+        personId: z.string().optional().describe("Updated associated person ID"),
+        place: z.string().optional().describe("Updated place"),
+        takenAt: z.string().optional().describe("Updated capture date (ISO-8601 DateTime)"),
+        tags: z.array(z.string()).optional().describe("Updated tags"),
+        visibility: VisibilityEnum.optional().describe("Updated visibility")
+      }
+    },
+    async ({
+      id,
+      title,
+      description,
+      kind,
+      fileId,
+      personId,
+      place,
+      takenAt,
+      tags,
+      visibility
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (description !== void 0) input.description = description;
+        if (kind !== void 0) input.kind = kind;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (personId !== void 0) input.personId = personId;
+        if (place !== void 0) input.place = place;
+        if (takenAt !== void 0) input.takenAt = takenAt;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable memory field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_MEMORY, { id, input });
+        return jsonResult(data.colUpdateMemory);
+      } catch (error) {
+        ctx.logger.error("collabkin memories_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update memory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "memories_delete")),
+    {
+      title: "Delete Memory",
+      description: "Delete a memory from a family tree.",
+      inputSchema: { id: z.string().describe("Memory ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_MEMORY,
+          { id }
+        );
+        return jsonResult({ success: data.colDeleteMemory, id });
+      } catch (error) {
+        ctx.logger.error("collabkin memories_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerStoryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "stories_list")),
+    {
+      title: "List Stories",
+      description: "List stories, optionally filtered by tree and/or person, with cursor/offset pagination.",
+      inputSchema: {
+        treeId: z.string().optional().describe("Filter by family tree ID"),
+        personId: z.string().optional().describe("Filter by associated person ID"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ treeId, personId, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_STORIES, {
+          treeId,
+          personId,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.colListStories);
+      } catch (error) {
+        ctx.logger.error("collabkin 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_get")),
+    {
+      title: "Get Story",
+      description: "Fetch a single story by ID, including its comments.",
+      inputSchema: { id: z.string().describe("Story ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_STORY, { id });
+        if (!data.colStory) return errorResult(`Story ${id} not found`);
+        return jsonResult(data.colStory);
+      } catch (error) {
+        ctx.logger.error("collabkin 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_create")),
+    {
+      title: "Create Story",
+      description: "Add a story to a family tree. `treeId` and `title` are required; for recorded stories set `format` (AUDIO/VIDEO) and `recordingFileId`.",
+      inputSchema: {
+        treeId: z.string().min(1).describe("Owning family tree ID"),
+        title: z.string().min(1).describe("Story title"),
+        body: z.string().optional().describe("Written story body"),
+        format: StoryFormatEnum.optional().describe("Story format (default WRITTEN)"),
+        narrator: z.string().optional().describe("Narrator name"),
+        personId: z.string().optional().describe("Associated person ID"),
+        recordingFileId: z.string().optional().describe("Recording File ID (wspace-files-svc)"),
+        tags: z.array(z.string()).optional().describe("Discovery tags"),
+        visibility: VisibilityEnum.optional().describe("Visibility (default TREE)")
+      }
+    },
+    async ({
+      treeId,
+      title,
+      body,
+      format,
+      narrator,
+      personId,
+      recordingFileId,
+      tags,
+      visibility
+    }) => {
+      try {
+        const input = { treeId, title };
+        if (body !== void 0) input.body = body;
+        if (format !== void 0) input.format = format;
+        if (narrator !== void 0) input.narrator = narrator;
+        if (personId !== void 0) input.personId = personId;
+        if (recordingFileId !== void 0) input.recordingFileId = recordingFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (visibility !== void 0) input.visibility = visibility;
+        const data = await ctx.gql.workspace.request(CREATE_STORY, { input });
+        return jsonResult(data.colCreateStory);
+      } catch (error) {
+        ctx.logger.error("collabkin 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_delete")),
+    {
+      title: "Delete Story",
+      description: "Delete a story from a family tree.",
+      inputSchema: { id: z.string().describe("Story ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_STORY,
+          { id }
+        );
+        return jsonResult({ success: data.colDeleteStory, id });
+      } catch (error) {
+        ctx.logger.error("collabkin stories_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete story: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCommentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "comments_list")),
+    {
+      title: "List Comments",
+      description: "List comments for a memory or a story. Provide exactly one of `memoryId` or `storyId`.",
+      inputSchema: {
+        memoryId: z.string().optional().describe("List comments on this memory"),
+        storyId: z.string().optional().describe("List comments on this story")
+      }
+    },
+    async ({ memoryId, storyId }) => {
+      try {
+        if (!memoryId && !storyId) {
+          return errorResult("Provide exactly one of memoryId or storyId");
+        }
+        const data = await ctx.gql.workspace.request(LIST_COMMENTS, { memoryId, storyId });
+        return jsonResult(data.colListComments);
+      } catch (error) {
+        ctx.logger.error("collabkin comments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list comments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "comments_add")),
+    {
+      title: "Add Comment",
+      description: "Add a comment to a memory or a story. `body` is required; provide exactly one of `memoryId` or `storyId`.",
+      inputSchema: {
+        body: z.string().min(1).describe("Comment body"),
+        memoryId: z.string().optional().describe("Memory to comment on"),
+        storyId: z.string().optional().describe("Story to comment on")
+      }
+    },
+    async ({ body, memoryId, storyId }) => {
+      try {
+        if (!memoryId && !storyId) {
+          return errorResult("Provide exactly one of memoryId or storyId");
+        }
+        const input = { body };
+        if (memoryId !== void 0) input.memoryId = memoryId;
+        if (storyId !== void 0) input.storyId = storyId;
+        const data = await ctx.gql.workspace.request(ADD_COMMENT, { input });
+        return jsonResult(data.colAddComment);
+      } catch (error) {
+        ctx.logger.error("collabkin comments_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add comment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "comments_delete")),
+    {
+      title: "Delete Comment",
+      description: "Delete a comment.",
+      inputSchema: { id: z.string().describe("Comment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_COMMENT,
+          { id }
+        );
+        return jsonResult({ success: data.colDeleteComment, id });
+      } catch (error) {
+        ctx.logger.error("collabkin comments_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete comment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTimelineTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "timeline_list")),
+    {
+      title: "List Timeline",
+      description: "The family timeline \u2014 dated events for a tree (optionally one person), ordered most-recent first. `treeId` is required; filter by event `type` if desired.",
+      inputSchema: {
+        treeId: z.string().describe("Family tree ID"),
+        personId: z.string().optional().describe("Restrict to events about this person"),
+        type: EventTypeEnum.optional().describe("Filter by event type")
+      }
+    },
+    async ({ treeId, personId, type }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TIMELINE, { treeId, personId, type });
+        return jsonResult(data.colTimeline);
+      } catch (error) {
+        ctx.logger.error("collabkin timeline_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list timeline: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "timeline_create_event")),
+    {
+      title: "Create Event",
+      description: "Add a dated event to the family timeline. `treeId`, `title`, and `date` are required.",
+      inputSchema: {
+        treeId: z.string().min(1).describe("Owning family tree ID"),
+        title: z.string().min(1).describe("Event title"),
+        date: z.string().describe("Event date (ISO-8601 DateTime)"),
+        type: EventTypeEnum.optional().describe("Event type (default MILESTONE)"),
+        description: z.string().optional().describe("Event description"),
+        place: z.string().optional().describe("Where it happened"),
+        personId: z.string().optional().describe("Person the event is about"),
+        isApproximate: z.boolean().optional().describe("Whether the date is approximate (default false)")
+      }
+    },
+    async ({ treeId, title, date, type, description, place, personId, isApproximate }) => {
+      try {
+        const input = { treeId, title, date };
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (place !== void 0) input.place = place;
+        if (personId !== void 0) input.personId = personId;
+        if (isApproximate !== void 0) input.isApproximate = isApproximate;
+        const data = await ctx.gql.workspace.request(CREATE_EVENT, { input });
+        return jsonResult(data.colCreateEvent);
+      } catch (error) {
+        ctx.logger.error("collabkin timeline_create_event failed", { error: String(error) });
+        return errorResult(
+          `Failed to create event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "timeline_delete_event")),
+    {
+      title: "Delete Event",
+      description: "Delete an event from the family timeline.",
+      inputSchema: { id: z.string().describe("Event ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_EVENT,
+          { id }
+        );
+        return jsonResult({ success: data.colDeleteEvent, id });
+      } catch (error) {
+        ctx.logger.error("collabkin timeline_delete_event failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/collabkin/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Collabkin Health Check",
+      description: "Public health probe for the Collabkin subgraph (colHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.colHealth });
+      } catch (error) {
+        ctx.logger.error("collabkin health failed", { error: String(error) });
+        return errorResult(
+          `Collabkin health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/collabkin/resources.ts
+function registerCollabkinResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const treesUri = track(mcpResourceUri(ctx.productName, "trees"));
+  server.registerResource(
+    "collabkin-schema",
+    schemaUri,
+    {
+      title: "Collabkin Domain Schema",
+      description: "Overview of the Collabkin family-heritage domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Collabkin Domain (Overview)
+
+A private, collaborative home for a family and its ancestry.
+
+## Entities
+- ColFamilyTree \u2014 top-level container (people, memberships, memories, stories, timeline)
+- ColPerson \u2014 a relative or ancestor within a tree (has relationships)
+- ColRelationship \u2014 a typed edge between two people (PARENT, SPOUSE, \u2026)
+- ColMembership \u2014 a family member / invited collaborator + consent state
+- ColMemory (+ColComment) \u2014 a photo/video/document/artifact + its comments
+- ColStory (+ColComment) \u2014 a written/recorded family story + its comments
+- ColEvent \u2014 a dated entry on the family timeline
+
+## Enums
+- ColTreeStatus: ACTIVE, ARCHIVED
+- ColGender: FEMALE, MALE, OTHER, UNKNOWN
+- ColLifeStatus: DECEASED, LIVING, UNKNOWN
+- ColMemberRole: CONTRIBUTOR, OWNER, STEWARD, VIEWER
+- ColMembershipStatus: ACTIVE, DECLINED, INVITED, REMOVED
+- ColMemoryKind: ARTIFACT, AUDIO, DOCUMENT, PHOTO, VIDEO
+- ColVisibility: PRIVATE, STEWARDS, TREE
+- ColEventType: BIRTH, DEATH, DIVORCE, EDUCATION, IMMIGRATION, MARRIAGE, MILESTONE, MILITARY, OTHER, RESIDENCE
+- ColRelationshipType: CHILD, GRANDCHILD, GRANDPARENT, GUARDIAN, PARENT, PARTNER, SIBLING, SPOUSE
+- ColStoryFormat: AUDIO, VIDEO, WRITTEN
+- ColCertainty: CONFIRMED, DISPUTED, PROBABLE, UNVERIFIED
+
+## Tool groups
+trees, people, relationships, memberships, memories, stories, comments, timeline.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+Memory/story/portrait/cover blobs live in wspace-files-svc (referenced by File id).
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "collabkin-trees",
+    treesUri,
+    {
+      title: "Collabkin Family Tree Directory",
+      description: "The first 50 active family trees in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${treesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_FAMILY_TREES,
+          { status: "ACTIVE", pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: treesUri,
+              text: JSON.stringify(data.colListFamilyTrees, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: treesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerCollabkinPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const setupName = track(mcpPromptName(p, "tree-setup"));
+  const heritageName = track(mcpPromptName(p, "heritage-curation"));
+  server.registerPrompt(
+    setupName,
+    {
+      title: "Family Tree Setup",
+      description: "Guide for setting up a new Collabkin family tree end to end: create the tree, add people, connect them with relationships, and invite family members.",
+      argsSchema: {
+        name: z.string().optional().describe("Family tree name"),
+        surname: z.string().optional().describe("Primary family surname")
+      }
+    },
+    ({ name, surname }) => {
+      ctx.logger.debug(`Prompt ${setupName} called`, { name, surname });
+      const nameNote = name ? `Use the tree name "${name}".` : "Ask the user for the family tree name.";
+      const surnameNote = surname ? `Use surname "${surname}".` : "";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me set up a new Collabkin family tree.
+
+1. **Create Tree**: Use ${p}_trees_create. ${nameNote} ${surnameNote}
+2. **Add People**: Use ${p}_people_create for each relative/ancestor \u2014 set treeId, givenName (required), plus gender, lifeStatus, birthDate/birthPlace, and deathDate for ancestors.
+3. **Connect Relationships**: Use ${p}_relationships_create to link people (PARENT, SPOUSE, SIBLING, CHILD, \u2026) \u2014 pass treeId, fromPersonId, toPersonId, and type.
+4. **Invite Family**: Use ${p}_memberships_invite to bring in collaborators (treeId, memberUserId, role=CONTRIBUTOR/VIEWER).
+5. **Verify**: Use ${p}_people_list and ${p}_relationships_list (filtered by the new treeId) to confirm the shape.
+
+Show results at each step and confirm before inviting members.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    heritageName,
+    {
+      title: "Heritage Curation",
+      description: "Workflow for enriching a family tree: add memories and stories, discuss them via comments, and build out the family timeline.",
+      argsSchema: {
+        treeId: z.string().optional().describe("Family tree ID to curate")
+      }
+    },
+    ({ treeId }) => {
+      ctx.logger.debug(`Prompt ${heritageName} called`, { treeId });
+      const treeNote = treeId ? `Curate tree "${treeId}".` : `First list trees with ${p}_trees_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me curate family heritage in Collabkin. ${treeNote}
+
+1. **Memories**: Use ${p}_memories_create to add photos/videos/documents/artifacts (treeId, title, kind, optional fileId from wspace-files, personId, visibility).
+2. **Stories**: Use ${p}_stories_create for written or recorded stories (treeId, title, body or format+recordingFileId, narrator, personId).
+3. **Discuss**: Use ${p}_comments_add to discuss a memory or story (exactly one of memoryId/storyId).
+4. **Timeline**: Use ${p}_timeline_create_event to add dated milestones (births, marriages, immigrations, \u2026) and ${p}_timeline_list to review them most-recent first.
+5. **Review**: Use ${p}_memories_list and ${p}_stories_list to confirm what was captured.
+
+Summarize what was added after each step and suggest gaps to fill.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/collabkin/index.ts
+var collabkinModule = {
+  id: "collabkin",
+  version: "0.0.1",
+  displayName: "Collabkin",
+  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;
+    };
+    registerTreeTools(server, ctx, trackTool);
+    registerPersonTools(server, ctx, trackTool);
+    registerRelationshipTools(server, ctx, trackTool);
+    registerMembershipTools(server, ctx, trackTool);
+    registerMemoryTools(server, ctx, trackTool);
+    registerStoryTools(server, ctx, trackTool);
+    registerCommentTools(server, ctx, trackTool);
+    registerTimelineTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerCollabkinResources(server, ctx, trackResource);
+    registerCollabkinPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var collabkin_default = collabkinModule;
+
+export { collabkin_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map