@burdenoff/mcp-libs 2026.627.2 → 2026.627.4

package/dist/modules/govcitizenhub/index.js

@@ -0,0 +1,1625 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/govcitizenhub/operations.ts
+var AGENCY_FIELDS = `
+  id code name description jurisdiction contactEmail contactPhone
+  isActive tags workspaceId createdAt updatedAt
+`;
+var SERVICE_FIELDS = `
+  id agencyId name slug category status summary eligibility
+  feeType feeAmount currency slaDays requiredDocuments formSchema
+  tags publishedAt workspaceId createdAt updatedAt
+`;
+var APPLICATION_FIELDS = `
+  id reference serviceId citizenId assignedToId status priority
+  formData tags submittedAt dueDate decidedAt decisionReason
+  workspaceId createdAt updatedAt
+`;
+var DOCUMENT_FIELDS = `
+  id applicationId name requirement status rejectionReason
+  file { id } workspaceId createdAt updatedAt
+`;
+var CASE_NOTE_FIELDS = `
+  id applicationId authorId body type workspaceId createdAt updatedAt
+`;
+var PERMIT_FIELDS = `
+  id title serviceId holderId applicationId status verificationCode
+  issuedAt expiresAt revokedAt revokeReason file { id }
+  workspaceId createdAt updatedAt
+`;
+var GRIEVANCE_FIELDS = `
+  id title description category status priority reporterId assignedToId
+  agencyId location latitude longitude photoFileIds resolution resolvedAt
+  tags workspaceId createdAt updatedAt
+`;
+var PAYMENT_FIELDS = `
+  id applicationId payerId amount currency status providerRef
+  receiptNumber lineItems paidAt refundedAt workspaceId createdAt updatedAt
+`;
+var PAGE_INFO_FIELDS = `cursor hasMore`;
+var GET_AGENCY = `
+  query GovGetAgency($id: ID!) {
+    govAgency(id: $id) {
+      ${AGENCY_FIELDS}
+      services { id name slug category status }
+    }
+  }
+`;
+var LIST_AGENCIES = `
+  query GovListAgencies($isActive: Boolean, $pagination: PaginationInput) {
+    govListAgencies(isActive: $isActive, pagination: $pagination) {
+      ${AGENCY_FIELDS}
+    }
+  }
+`;
+var CREATE_AGENCY = `
+  mutation GovCreateAgency($input: GovCreateAgencyInput!) {
+    govCreateAgency(input: $input) {
+      ${AGENCY_FIELDS}
+    }
+  }
+`;
+var UPDATE_AGENCY = `
+  mutation GovUpdateAgency($id: ID!, $input: GovUpdateAgencyInput!) {
+    govUpdateAgency(id: $id, input: $input) {
+      ${AGENCY_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_AGENCY = `
+  mutation GovArchiveAgency($id: ID!) {
+    govArchiveAgency(id: $id)
+  }
+`;
+var GET_SERVICE = `
+  query GovGetService($id: ID!) {
+    govService(id: $id) {
+      ${SERVICE_FIELDS}
+      agency { id name code }
+    }
+  }
+`;
+var LIST_SERVICES = `
+  query GovListServices(
+    $agencyId: ID
+    $category: GovServiceCategory
+    $status: GovServiceStatus
+    $pagination: PaginationInput
+  ) {
+    govListServices(
+      agencyId: $agencyId
+      category: $category
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${SERVICE_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_SERVICE = `
+  mutation GovCreateService($input: GovCreateServiceInput!) {
+    govCreateService(input: $input) {
+      ${SERVICE_FIELDS}
+    }
+  }
+`;
+var UPDATE_SERVICE = `
+  mutation GovUpdateService($id: ID!, $input: GovUpdateServiceInput!) {
+    govUpdateService(id: $id, input: $input) {
+      ${SERVICE_FIELDS}
+    }
+  }
+`;
+var TRANSITION_SERVICE = `
+  mutation GovTransitionService($id: ID!, $status: GovServiceStatus!) {
+    govTransitionService(id: $id, status: $status) {
+      ${SERVICE_FIELDS}
+    }
+  }
+`;
+var GET_APPLICATION = `
+  query GovGetApplication($id: ID!) {
+    govApplication(id: $id) {
+      ${APPLICATION_FIELDS}
+      documents { ${DOCUMENT_FIELDS} }
+      notes { ${CASE_NOTE_FIELDS} }
+      permits { ${PERMIT_FIELDS} }
+    }
+  }
+`;
+var LIST_APPLICATIONS = `
+  query GovListApplications(
+    $assignedToId: ID
+    $citizenId: ID
+    $serviceId: ID
+    $status: GovApplicationStatus
+    $pagination: PaginationInput
+  ) {
+    govListApplications(
+      assignedToId: $assignedToId
+      citizenId: $citizenId
+      serviceId: $serviceId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${APPLICATION_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_APPLICATION = `
+  mutation GovCreateApplication($input: GovCreateApplicationInput!) {
+    govCreateApplication(input: $input) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var UPDATE_APPLICATION = `
+  mutation GovUpdateApplication($id: ID!, $input: GovUpdateApplicationInput!) {
+    govUpdateApplication(id: $id, input: $input) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var SUBMIT_APPLICATION = `
+  mutation GovSubmitApplication($id: ID!) {
+    govSubmitApplication(id: $id) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var TRANSITION_APPLICATION = `
+  mutation GovTransitionApplication(
+    $id: ID!
+    $status: GovApplicationStatus!
+    $reason: String
+  ) {
+    govTransitionApplication(id: $id, status: $status, reason: $reason) {
+      ${APPLICATION_FIELDS}
+    }
+  }
+`;
+var ADD_DOCUMENT = `
+  mutation GovAddDocument($input: GovAddDocumentInput!) {
+    govAddDocument(input: $input) {
+      ${DOCUMENT_FIELDS}
+    }
+  }
+`;
+var REVIEW_DOCUMENT = `
+  mutation GovReviewDocument(
+    $id: ID!
+    $status: GovDocumentStatus!
+    $rejectionReason: String
+  ) {
+    govReviewDocument(id: $id, status: $status, rejectionReason: $rejectionReason) {
+      ${DOCUMENT_FIELDS}
+    }
+  }
+`;
+var ADD_CASE_NOTE = `
+  mutation GovAddCaseNote($input: GovAddCaseNoteInput!) {
+    govAddCaseNote(input: $input) {
+      ${CASE_NOTE_FIELDS}
+    }
+  }
+`;
+var LIST_PERMITS = `
+  query GovListPermits($holderId: ID, $serviceId: ID, $status: GovPermitStatus) {
+    govListPermits(holderId: $holderId, serviceId: $serviceId, status: $status) {
+      ${PERMIT_FIELDS}
+    }
+  }
+`;
+var VERIFY_PERMIT = `
+  query GovVerifyPermit($verificationCode: String!) {
+    govVerifyPermit(verificationCode: $verificationCode) {
+      ${PERMIT_FIELDS}
+    }
+  }
+`;
+var ISSUE_PERMIT = `
+  mutation GovIssuePermit($input: GovIssuePermitInput!) {
+    govIssuePermit(input: $input) {
+      ${PERMIT_FIELDS}
+    }
+  }
+`;
+var REVOKE_PERMIT = `
+  mutation GovRevokePermit($id: ID!, $reason: String) {
+    govRevokePermit(id: $id, reason: $reason) {
+      ${PERMIT_FIELDS}
+    }
+  }
+`;
+var GET_GRIEVANCE = `
+  query GovGetGrievance($id: ID!) {
+    govGrievance(id: $id) {
+      ${GRIEVANCE_FIELDS}
+    }
+  }
+`;
+var LIST_GRIEVANCES = `
+  query GovListGrievances(
+    $agencyId: ID
+    $reporterId: ID
+    $status: GovGrievanceStatus
+    $pagination: PaginationInput
+  ) {
+    govListGrievances(
+      agencyId: $agencyId
+      reporterId: $reporterId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${GRIEVANCE_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var REPORT_GRIEVANCE = `
+  mutation GovReportGrievance($input: GovReportGrievanceInput!) {
+    govReportGrievance(input: $input) {
+      ${GRIEVANCE_FIELDS}
+    }
+  }
+`;
+var UPDATE_GRIEVANCE = `
+  mutation GovUpdateGrievance($id: ID!, $input: GovUpdateGrievanceInput!) {
+    govUpdateGrievance(id: $id, input: $input) {
+      ${GRIEVANCE_FIELDS}
+    }
+  }
+`;
+var TRANSITION_GRIEVANCE = `
+  mutation GovTransitionGrievance(
+    $id: ID!
+    $status: GovGrievanceStatus!
+    $resolution: String
+  ) {
+    govTransitionGrievance(id: $id, status: $status, resolution: $resolution) {
+      ${GRIEVANCE_FIELDS}
+    }
+  }
+`;
+var GET_PAYMENT = `
+  query GovGetPayment($id: ID!) {
+    govPayment(id: $id) {
+      ${PAYMENT_FIELDS}
+    }
+  }
+`;
+var LIST_PAYMENTS = `
+  query GovListPayments(
+    $applicationId: ID
+    $payerId: ID
+    $status: GovPaymentStatus
+    $pagination: PaginationInput
+  ) {
+    govListPayments(
+      applicationId: $applicationId
+      payerId: $payerId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${PAYMENT_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_PAYMENT = `
+  mutation GovCreatePayment($input: GovCreatePaymentInput!) {
+    govCreatePayment(input: $input) {
+      ${PAYMENT_FIELDS}
+    }
+  }
+`;
+var MARK_PAYMENT_PAID = `
+  mutation GovMarkPaymentPaid($id: ID!, $providerRef: String) {
+    govMarkPaymentPaid(id: $id, providerRef: $providerRef) {
+      ${PAYMENT_FIELDS}
+    }
+  }
+`;
+var REFUND_PAYMENT = `
+  mutation GovRefundPayment($id: ID!) {
+    govRefundPayment(id: $id) {
+      ${PAYMENT_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query GovHealth {
+    govHealth
+  }
+`;
+var ServiceCategoryEnum = z.enum([
+  "CERTIFICATES",
+  "EDUCATION",
+  "GRIEVANCES",
+  "HEALTH",
+  "LICENCES_AND_PERMITS",
+  "OTHER",
+  "SOCIAL_WELFARE",
+  "TAXES_AND_PAYMENTS",
+  "UTILITIES"
+]).describe("Top-level category of a public service or grievance");
+var ServiceStatusEnum = z.enum(["DRAFT", "PUBLISHED", "RETIRED", "SUSPENDED"]).describe("Publication lifecycle status of a service");
+var FeeTypeEnum = z.enum(["FIXED", "FREE", "VARIABLE"]).describe("How a service is charged: FREE, a FIXED amount, or VARIABLE");
+var ApplicationStatusEnum = z.enum(["APPROVED", "DRAFT", "INFO_REQUESTED", "IN_REVIEW", "REJECTED", "SUBMITTED", "WITHDRAWN"]).describe("Review-lifecycle status of a citizen application");
+var CasePriorityEnum = z.enum(["HIGH", "LOW", "NORMAL", "URGENT"]).describe("Priority of an application or grievance");
+var CaseNoteTypeEnum = z.enum(["CITIZEN_MESSAGE", "DECISION", "INFO_REQUEST", "INTERNAL"]).describe("Kind of case note on an application");
+var DocumentStatusEnum = z.enum(["ACCEPTED", "PENDING", "REJECTED"]).describe("Review status of a submitted document");
+var GrievanceStatusEnum = z.enum(["ACKNOWLEDGED", "CLOSED", "IN_PROGRESS", "OPEN", "REJECTED", "RESOLVED"]).describe("Resolution-lifecycle status of a grievance");
+var PaymentStatusEnum = z.enum(["FAILED", "PAID", "PENDING", "REFUNDED"]).describe("Status of a fee payment");
+var PermitStatusEnum = z.enum(["ACTIVE", "EXPIRED", "ISSUED", "REVOKED"]).describe("Lifecycle status of an issued permit");
+var JsonObject = z.record(z.string(), z.unknown());
+function buildPagination(args) {
+  const pagination = {};
+  if (args.limit !== void 0) pagination.limit = args.limit;
+  if (args.offset !== void 0) pagination.offset = args.offset;
+  if (args.cursor !== void 0) pagination.cursor = args.cursor;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/govcitizenhub/tools/agencies.ts
+function registerAgencyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agencies_get")),
+    {
+      title: "Get Agency",
+      description: "Fetch a single GovCitizenHub government agency by ID, including the services it operates.",
+      inputSchema: { id: z.string().describe("Agency ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_AGENCY, { id });
+        if (!data.govAgency) return errorResult(`Agency ${id} not found`);
+        return jsonResult(data.govAgency);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub agencies_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get agency: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agencies_list")),
+    {
+      title: "List Agencies",
+      description: "List government agencies in the bound workspace with an optional active filter and pagination.",
+      inputSchema: {
+        isActive: z.boolean().optional().describe("Only active (true) or archived (false) agencies"),
+        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 ({ isActive, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_AGENCIES, {
+          isActive,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.govListAgencies);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub agencies_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list agencies: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agencies_create")),
+    {
+      title: "Create Agency",
+      description: "Register a new government agency in the bound workspace.",
+      inputSchema: {
+        name: z.string().min(1).describe("Agency display name"),
+        code: z.string().optional().describe("Short agency code"),
+        description: z.string().optional().describe("Agency description"),
+        jurisdiction: z.string().optional().describe("Geographic/legal jurisdiction"),
+        contactEmail: z.string().optional().describe("Public contact email"),
+        contactPhone: z.string().optional().describe("Public contact phone"),
+        tags: z.array(z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ name, code, description, jurisdiction, contactEmail, contactPhone, tags }) => {
+      try {
+        const input = { name };
+        if (code !== void 0) input.code = code;
+        if (description !== void 0) input.description = description;
+        if (jurisdiction !== void 0) input.jurisdiction = jurisdiction;
+        if (contactEmail !== void 0) input.contactEmail = contactEmail;
+        if (contactPhone !== void 0) input.contactPhone = contactPhone;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_AGENCY, { input });
+        return jsonResult(data.govCreateAgency);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub agencies_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create agency: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agencies_update")),
+    {
+      title: "Update Agency",
+      description: "Update a government agency. At least one mutable field must be provided. Use `isActive` to (de)activate.",
+      inputSchema: {
+        id: z.string().describe("Agency ID"),
+        name: z.string().optional().describe("Updated display name"),
+        code: z.string().optional().describe("Updated agency code"),
+        description: z.string().optional().describe("Updated description"),
+        jurisdiction: z.string().optional().describe("Updated jurisdiction"),
+        contactEmail: z.string().optional().describe("Updated contact email"),
+        contactPhone: z.string().optional().describe("Updated contact phone"),
+        isActive: z.boolean().optional().describe("Updated active flag"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      code,
+      description,
+      jurisdiction,
+      contactEmail,
+      contactPhone,
+      isActive,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (code !== void 0) input.code = code;
+        if (description !== void 0) input.description = description;
+        if (jurisdiction !== void 0) input.jurisdiction = jurisdiction;
+        if (contactEmail !== void 0) input.contactEmail = contactEmail;
+        if (contactPhone !== void 0) input.contactPhone = contactPhone;
+        if (isActive !== void 0) input.isActive = isActive;
+        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/code/description/jurisdiction/contactEmail/contactPhone/isActive/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_AGENCY, { id, input });
+        return jsonResult(data.govUpdateAgency);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub agencies_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update agency: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agencies_archive")),
+    {
+      title: "Archive Agency",
+      description: "Archive (soft-delete) a government agency. Returns true on success.",
+      inputSchema: { id: z.string().describe("Agency ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_AGENCY,
+          { id }
+        );
+        return jsonResult({ archived: data.govArchiveAgency });
+      } catch (error) {
+        ctx.logger.error("govcitizenhub agencies_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive agency: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerServiceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "services_get")),
+    {
+      title: "Get Service",
+      description: "Fetch a single GovCitizenHub public service by ID, including its owning agency.",
+      inputSchema: { id: z.string().describe("Service ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SERVICE, { id });
+        if (!data.govService) return errorResult(`Service ${id} not found`);
+        return jsonResult(data.govService);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub services_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get service: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "services_list")),
+    {
+      title: "List Services",
+      description: "List public services in the bound workspace with optional agency/category/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        agencyId: z.string().optional().describe("Filter by owning agency ID"),
+        category: ServiceCategoryEnum.optional().describe("Filter by category"),
+        status: ServiceStatusEnum.optional().describe("Filter by publication 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 ({ agencyId, category, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SERVICES, {
+          agencyId,
+          category,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.govListServices);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub services_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list services: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "services_create")),
+    {
+      title: "Create Service",
+      description: "Create a public service under an agency. `slug` must be unique within the workspace; `feeType`+`feeAmount` define the fee model.",
+      inputSchema: {
+        agencyId: z.string().min(1).describe("Owning agency ID"),
+        name: z.string().min(1).describe("Service display name"),
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        category: ServiceCategoryEnum.optional().describe("Service category (default OTHER)"),
+        summary: z.string().optional().describe("Short summary"),
+        eligibility: z.string().optional().describe("Eligibility criteria text"),
+        feeType: FeeTypeEnum.optional().describe("Fee model (default FREE)"),
+        feeAmount: z.number().optional().describe("Fee amount (for FIXED/VARIABLE)"),
+        currency: z.string().optional().describe("ISO currency code for the fee"),
+        slaDays: z.number().int().optional().describe("Target turnaround in days"),
+        requiredDocuments: z.array(z.string()).optional().describe("Names of documents the citizen must submit"),
+        formSchema: JsonObject.optional().describe("JSON schema describing the application form"),
+        tags: z.array(z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      agencyId,
+      name,
+      slug,
+      category,
+      summary,
+      eligibility,
+      feeType,
+      feeAmount,
+      currency,
+      slaDays,
+      requiredDocuments,
+      formSchema,
+      tags
+    }) => {
+      try {
+        const input = { agencyId, name, slug };
+        if (category !== void 0) input.category = category;
+        if (summary !== void 0) input.summary = summary;
+        if (eligibility !== void 0) input.eligibility = eligibility;
+        if (feeType !== void 0) input.feeType = feeType;
+        if (feeAmount !== void 0) input.feeAmount = feeAmount;
+        if (currency !== void 0) input.currency = currency;
+        if (slaDays !== void 0) input.slaDays = slaDays;
+        if (requiredDocuments !== void 0) input.requiredDocuments = requiredDocuments;
+        if (formSchema !== void 0) input.formSchema = formSchema;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_SERVICE, { input });
+        return jsonResult(data.govCreateService);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub services_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create service: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "services_update")),
+    {
+      title: "Update Service",
+      description: "Update a public service. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Service ID"),
+        name: z.string().optional().describe("Updated display name"),
+        category: ServiceCategoryEnum.optional().describe("Updated category"),
+        summary: z.string().optional().describe("Updated summary"),
+        eligibility: z.string().optional().describe("Updated eligibility text"),
+        feeType: FeeTypeEnum.optional().describe("Updated fee model"),
+        feeAmount: z.number().optional().describe("Updated fee amount"),
+        currency: z.string().optional().describe("Updated currency"),
+        slaDays: z.number().int().optional().describe("Updated SLA days"),
+        requiredDocuments: z.array(z.string()).optional().describe("Updated required documents"),
+        formSchema: JsonObject.optional().describe("Updated form schema JSON"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      category,
+      summary,
+      eligibility,
+      feeType,
+      feeAmount,
+      currency,
+      slaDays,
+      requiredDocuments,
+      formSchema,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (category !== void 0) input.category = category;
+        if (summary !== void 0) input.summary = summary;
+        if (eligibility !== void 0) input.eligibility = eligibility;
+        if (feeType !== void 0) input.feeType = feeType;
+        if (feeAmount !== void 0) input.feeAmount = feeAmount;
+        if (currency !== void 0) input.currency = currency;
+        if (slaDays !== void 0) input.slaDays = slaDays;
+        if (requiredDocuments !== void 0) input.requiredDocuments = requiredDocuments;
+        if (formSchema !== void 0) input.formSchema = formSchema;
+        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/category/summary/eligibility/feeType/feeAmount/currency/slaDays/requiredDocuments/formSchema/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_SERVICE, { id, input });
+        return jsonResult(data.govUpdateService);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub services_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update service: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "services_transition")),
+    {
+      title: "Transition Service",
+      description: "Advance a service through its publication lifecycle (DRAFT \u2192 PUBLISHED \u2192 SUSPENDED/RETIRED) with validated transitions.",
+      inputSchema: {
+        id: z.string().describe("Service ID"),
+        status: ServiceStatusEnum.describe("Target publication status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_SERVICE, { id, status });
+        return jsonResult(data.govTransitionService);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub services_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition service: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerApplicationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_get")),
+    {
+      title: "Get Application",
+      description: "Fetch a single GovCitizenHub citizen application by ID, including its documents, case notes, and issued permits.",
+      inputSchema: { id: z.string().describe("Application ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_APPLICATION, { id });
+        if (!data.govApplication) return errorResult(`Application ${id} not found`);
+        return jsonResult(data.govApplication);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub applications_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get application: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_list")),
+    {
+      title: "List Applications",
+      description: "List citizen applications with optional citizen/service/assignee/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        citizenId: z.string().optional().describe("Filter by applicant (citizen) user ID"),
+        serviceId: z.string().optional().describe("Filter by service ID"),
+        assignedToId: z.string().optional().describe("Filter by assigned caseworker user ID"),
+        status: ApplicationStatusEnum.optional().describe("Filter by review 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 ({ citizenId, serviceId, assignedToId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_APPLICATIONS, {
+          citizenId,
+          serviceId,
+          assignedToId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.govListApplications);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub applications_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list applications: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_create")),
+    {
+      title: "Create Application",
+      description: "Start a new citizen application against a service (created in DRAFT). The applicant identity comes from the gateway actor headers.",
+      inputSchema: {
+        serviceId: z.string().min(1).describe("Service being applied for"),
+        reference: z.string().optional().describe("Optional caller-supplied reference number"),
+        priority: CasePriorityEnum.optional().describe("Priority (default NORMAL)"),
+        formData: JsonObject.optional().describe("Submitted form data JSON"),
+        tags: z.array(z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ serviceId, reference, priority, formData, tags }) => {
+      try {
+        const input = { serviceId };
+        if (reference !== void 0) input.reference = reference;
+        if (priority !== void 0) input.priority = priority;
+        if (formData !== void 0) input.formData = formData;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_APPLICATION, { input });
+        return jsonResult(data.govCreateApplication);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub applications_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create application: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_update")),
+    {
+      title: "Update Application",
+      description: "Update a draft/in-progress application. At least one mutable field must be provided. Use `assignedToId` to assign a caseworker.",
+      inputSchema: {
+        id: z.string().describe("Application ID"),
+        assignedToId: z.string().optional().describe("Assigned caseworker user ID"),
+        priority: CasePriorityEnum.optional().describe("Updated priority"),
+        formData: JsonObject.optional().describe("Updated form data JSON"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, assignedToId, priority, formData, tags }) => {
+      try {
+        const input = {};
+        if (assignedToId !== void 0) input.assignedToId = assignedToId;
+        if (priority !== void 0) input.priority = priority;
+        if (formData !== void 0) input.formData = formData;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of assignedToId/priority/formData/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_APPLICATION, { id, input });
+        return jsonResult(data.govUpdateApplication);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub applications_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update application: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_submit")),
+    {
+      title: "Submit Application",
+      description: "Submit a DRAFT application for review (moves it to SUBMITTED).",
+      inputSchema: { id: z.string().describe("Application ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SUBMIT_APPLICATION, { id });
+        return jsonResult(data.govSubmitApplication);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub applications_submit failed", { error: String(error) });
+        return errorResult(
+          `Failed to submit application: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "applications_transition")),
+    {
+      title: "Transition Application",
+      description: "Advance an application through its review lifecycle (SUBMITTED \u2192 IN_REVIEW \u2192 INFO_REQUESTED/APPROVED/REJECTED/WITHDRAWN) with validated transitions. `reason` is recorded with the decision.",
+      inputSchema: {
+        id: z.string().describe("Application ID"),
+        status: ApplicationStatusEnum.describe("Target review status"),
+        reason: z.string().optional().describe("Reason/decision note for the transition")
+      }
+    },
+    async ({ id, status, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_APPLICATION, { id, status, reason });
+        return jsonResult(data.govTransitionApplication);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub applications_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition application: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerDocumentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "documents_add")),
+    {
+      title: "Add Document",
+      description: "Attach a supporting document to an application. `fileId` references an already-uploaded wspace-files-svc File; `requirement` ties it to a service-required document.",
+      inputSchema: {
+        applicationId: z.string().min(1).describe("Application the document belongs to"),
+        name: z.string().min(1).describe("Document display name"),
+        fileId: z.string().optional().describe("wspace-files-svc File ID for the uploaded blob"),
+        requirement: z.string().optional().describe("Name of the required-document slot this satisfies")
+      }
+    },
+    async ({ applicationId, name, fileId, requirement }) => {
+      try {
+        const input = { applicationId, name };
+        if (fileId !== void 0) input.fileId = fileId;
+        if (requirement !== void 0) input.requirement = requirement;
+        const data = await ctx.gql.workspace.request(ADD_DOCUMENT, { input });
+        return jsonResult(data.govAddDocument);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub documents_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add document: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "documents_review")),
+    {
+      title: "Review Document",
+      description: "Accept or reject a submitted document. Supply `rejectionReason` when setting status=REJECTED.",
+      inputSchema: {
+        id: z.string().describe("Document ID"),
+        status: DocumentStatusEnum.describe("Review outcome (ACCEPTED/PENDING/REJECTED)"),
+        rejectionReason: z.string().optional().describe("Reason when rejecting")
+      }
+    },
+    async ({ id, status, rejectionReason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REVIEW_DOCUMENT, { id, status, rejectionReason });
+        return jsonResult(data.govReviewDocument);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub documents_review failed", { error: String(error) });
+        return errorResult(
+          `Failed to review document: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerNoteTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "case_notes_add")),
+    {
+      title: "Add Case Note",
+      description: "Add a case note to an application. `type` controls visibility/intent: INTERNAL (staff-only), CITIZEN_MESSAGE, INFO_REQUEST, or DECISION. The author identity comes from the gateway actor headers.",
+      inputSchema: {
+        applicationId: z.string().min(1).describe("Application the note belongs to"),
+        body: z.string().min(1).describe("Note body text"),
+        type: CaseNoteTypeEnum.optional().describe("Note type (default INTERNAL)")
+      }
+    },
+    async ({ applicationId, body, type }) => {
+      try {
+        const input = { applicationId, body };
+        if (type !== void 0) input.type = type;
+        const data = await ctx.gql.workspace.request(ADD_CASE_NOTE, { input });
+        return jsonResult(data.govAddCaseNote);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub notes_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add case note: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPermitTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "permits_list")),
+    {
+      title: "List Permits",
+      description: "List issued permits in the bound workspace, optionally filtered by holder, service, or status.",
+      inputSchema: {
+        holderId: z.string().optional().describe("Filter by permit holder user ID"),
+        serviceId: z.string().optional().describe("Filter by service ID"),
+        status: PermitStatusEnum.optional().describe("Filter by permit status")
+      }
+    },
+    async ({ holderId, serviceId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PERMITS, { holderId, serviceId, status });
+        return jsonResult(data.govListPermits);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub permits_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list permits: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "permits_verify")),
+    {
+      title: "Verify Permit",
+      description: "Public permit verification by its printed verification code (citizen-facing trust check). Returns the permit or null if no match.",
+      inputSchema: {
+        verificationCode: z.string().min(1).describe("The printed permit verification code")
+      }
+    },
+    async ({ verificationCode }) => {
+      try {
+        const data = await ctx.gql.workspace.request(VERIFY_PERMIT, { verificationCode });
+        if (!data.govVerifyPermit) {
+          return errorResult(`No permit found for verification code ${verificationCode}`);
+        }
+        return jsonResult(data.govVerifyPermit);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub permits_verify failed", { error: String(error) });
+        return errorResult(
+          `Failed to verify permit: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "permits_issue")),
+    {
+      title: "Issue Permit",
+      description: "Issue a permit/licence to a holder for a service. `verificationCode` must be unique; optionally tie it to the originating application and an expiry.",
+      inputSchema: {
+        serviceId: z.string().min(1).describe("Service the permit is issued under"),
+        holderId: z.string().min(1).describe("User ID of the permit holder"),
+        title: z.string().min(1).describe("Permit title"),
+        verificationCode: z.string().min(1).describe("Unique printed verification code"),
+        applicationId: z.string().optional().describe("Originating application ID"),
+        fileId: z.string().optional().describe("wspace-files-svc File ID of the permit PDF"),
+        expiresAt: z.string().optional().describe("Expiry timestamp (ISO 8601)")
+      }
+    },
+    async ({ serviceId, holderId, title, verificationCode, applicationId, fileId, expiresAt }) => {
+      try {
+        const input = { serviceId, holderId, title, verificationCode };
+        if (applicationId !== void 0) input.applicationId = applicationId;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(ISSUE_PERMIT, { input });
+        return jsonResult(data.govIssuePermit);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub permits_issue failed", { error: String(error) });
+        return errorResult(
+          `Failed to issue permit: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "permits_revoke")),
+    {
+      title: "Revoke Permit",
+      description: "Revoke an issued permit. `reason` is recorded with the revocation.",
+      inputSchema: {
+        id: z.string().describe("Permit ID"),
+        reason: z.string().optional().describe("Reason for revocation")
+      }
+    },
+    async ({ id, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REVOKE_PERMIT, { id, reason });
+        return jsonResult(data.govRevokePermit);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub permits_revoke failed", { error: String(error) });
+        return errorResult(
+          `Failed to revoke permit: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerGrievanceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grievances_get")),
+    {
+      title: "Get Grievance",
+      description: "Fetch a single GovCitizenHub civic grievance by ID.",
+      inputSchema: { id: z.string().describe("Grievance ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_GRIEVANCE, { id });
+        if (!data.govGrievance) return errorResult(`Grievance ${id} not found`);
+        return jsonResult(data.govGrievance);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub grievances_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get grievance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grievances_list")),
+    {
+      title: "List Grievances",
+      description: "List civic grievances with optional agency/reporter/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        agencyId: z.string().optional().describe("Filter by responsible agency ID"),
+        reporterId: z.string().optional().describe("Filter by reporter (citizen) user ID"),
+        status: GrievanceStatusEnum.optional().describe("Filter by resolution 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 ({ agencyId, reporterId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_GRIEVANCES, {
+          agencyId,
+          reporterId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.govListGrievances);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub grievances_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list grievances: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grievances_report")),
+    {
+      title: "Report Grievance",
+      description: "File a new civic grievance. The reporter identity comes from the gateway actor headers. Optionally geotag it (location/latitude/longitude) and attach photo File IDs.",
+      inputSchema: {
+        title: z.string().min(1).describe("Grievance title"),
+        description: z.string().min(1).describe("Detailed description"),
+        category: ServiceCategoryEnum.optional().describe("Category (default GRIEVANCES)"),
+        priority: CasePriorityEnum.optional().describe("Priority (default NORMAL)"),
+        agencyId: z.string().optional().describe("Responsible agency ID"),
+        location: z.string().optional().describe("Human-readable location"),
+        latitude: z.number().optional().describe("Latitude"),
+        longitude: z.number().optional().describe("Longitude"),
+        photoFileIds: z.array(z.string()).optional().describe("wspace-files-svc File IDs for attached photos"),
+        tags: z.array(z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      title,
+      description,
+      category,
+      priority,
+      agencyId,
+      location,
+      latitude,
+      longitude,
+      photoFileIds,
+      tags
+    }) => {
+      try {
+        const input = { title, description };
+        if (category !== void 0) input.category = category;
+        if (priority !== void 0) input.priority = priority;
+        if (agencyId !== void 0) input.agencyId = agencyId;
+        if (location !== void 0) input.location = location;
+        if (latitude !== void 0) input.latitude = latitude;
+        if (longitude !== void 0) input.longitude = longitude;
+        if (photoFileIds !== void 0) input.photoFileIds = photoFileIds;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(REPORT_GRIEVANCE, { input });
+        return jsonResult(data.govReportGrievance);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub grievances_report failed", { error: String(error) });
+        return errorResult(
+          `Failed to report grievance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grievances_update")),
+    {
+      title: "Update Grievance",
+      description: "Update a grievance. At least one mutable field must be provided. Use `assignedToId` to assign an owner and `agencyId` to route it.",
+      inputSchema: {
+        id: z.string().describe("Grievance ID"),
+        assignedToId: z.string().optional().describe("Assigned owner user ID"),
+        agencyId: z.string().optional().describe("Responsible agency ID"),
+        priority: CasePriorityEnum.optional().describe("Updated priority"),
+        location: z.string().optional().describe("Updated location"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, assignedToId, agencyId, priority, location, tags }) => {
+      try {
+        const input = {};
+        if (assignedToId !== void 0) input.assignedToId = assignedToId;
+        if (agencyId !== void 0) input.agencyId = agencyId;
+        if (priority !== void 0) input.priority = priority;
+        if (location !== void 0) input.location = location;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of assignedToId/agencyId/priority/location/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_GRIEVANCE, { id, input });
+        return jsonResult(data.govUpdateGrievance);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub grievances_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update grievance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "grievances_transition")),
+    {
+      title: "Transition Grievance",
+      description: "Advance a grievance through its resolution lifecycle (OPEN \u2192 ACKNOWLEDGED \u2192 IN_PROGRESS \u2192 RESOLVED/CLOSED/REJECTED) with validated transitions. `resolution` is recorded on resolve.",
+      inputSchema: {
+        id: z.string().describe("Grievance ID"),
+        status: GrievanceStatusEnum.describe("Target resolution status"),
+        resolution: z.string().optional().describe("Resolution note")
+      }
+    },
+    async ({ id, status, resolution }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_GRIEVANCE, { id, status, resolution });
+        return jsonResult(data.govTransitionGrievance);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub grievances_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition grievance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPaymentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payments_get")),
+    {
+      title: "Get Payment",
+      description: "Fetch a single GovCitizenHub fee payment by ID.",
+      inputSchema: { id: z.string().describe("Payment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PAYMENT, { id });
+        if (!data.govPayment) return errorResult(`Payment ${id} not found`);
+        return jsonResult(data.govPayment);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub payments_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get payment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payments_list")),
+    {
+      title: "List Payments",
+      description: "List fee payments with optional application/payer/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        applicationId: z.string().optional().describe("Filter by application ID"),
+        payerId: z.string().optional().describe("Filter by payer user ID"),
+        status: PaymentStatusEnum.optional().describe("Filter by payment 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 ({ applicationId, payerId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PAYMENTS, {
+          applicationId,
+          payerId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.govListPayments);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub payments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list payments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payments_create")),
+    {
+      title: "Create Payment",
+      description: "Record a fee payment (created PENDING). Optionally tie it to an application and supply itemised lineItems JSON. The payer identity comes from the gateway actor headers.",
+      inputSchema: {
+        amount: z.number().describe("Payment amount"),
+        applicationId: z.string().optional().describe("Application the fee is for"),
+        currency: z.string().optional().describe("ISO currency code"),
+        providerRef: z.string().optional().describe("External payment-provider reference"),
+        lineItems: JsonObject.optional().describe("Itemised line-items JSON")
+      }
+    },
+    async ({ amount, applicationId, currency, providerRef, lineItems }) => {
+      try {
+        const input = { amount };
+        if (applicationId !== void 0) input.applicationId = applicationId;
+        if (currency !== void 0) input.currency = currency;
+        if (providerRef !== void 0) input.providerRef = providerRef;
+        if (lineItems !== void 0) input.lineItems = lineItems;
+        const data = await ctx.gql.workspace.request(CREATE_PAYMENT, { input });
+        return jsonResult(data.govCreatePayment);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub payments_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create payment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payments_mark_paid")),
+    {
+      title: "Mark Payment Paid",
+      description: "Mark a pending payment as PAID, optionally recording the external provider reference.",
+      inputSchema: {
+        id: z.string().describe("Payment ID"),
+        providerRef: z.string().optional().describe("External payment-provider reference")
+      }
+    },
+    async ({ id, providerRef }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MARK_PAYMENT_PAID, { id, providerRef });
+        return jsonResult(data.govMarkPaymentPaid);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub payments_mark_paid failed", { error: String(error) });
+        return errorResult(
+          `Failed to mark payment paid: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payments_refund")),
+    {
+      title: "Refund Payment",
+      description: "Refund a paid payment (moves it to REFUNDED).",
+      inputSchema: { id: z.string().describe("Payment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REFUND_PAYMENT, { id });
+        return jsonResult(data.govRefundPayment);
+      } catch (error) {
+        ctx.logger.error("govcitizenhub payments_refund failed", { error: String(error) });
+        return errorResult(
+          `Failed to refund payment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/govcitizenhub/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "GovCitizenHub Health Check",
+      description: "Public health probe for the GovCitizenHub subgraph (govHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.govHealth });
+      } catch (error) {
+        ctx.logger.error("govcitizenhub health failed", { error: String(error) });
+        return errorResult(
+          `GovCitizenHub health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/govcitizenhub/resources.ts
+function registerGovcitizenhubResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const agenciesUri = track(mcpResourceUri(ctx.productName, "agencies"));
+  const servicesUri = track(mcpResourceUri(ctx.productName, "services"));
+  server.registerResource(
+    "govcitizenhub-schema",
+    schemaUri,
+    {
+      title: "GovCitizenHub Domain Schema",
+      description: "Overview of the GovCitizenHub domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# GovCitizenHub Domain (Overview)
+
+Government & Citizen Services Operating System \u2014 a unified catalog of public
+services, citizen applications, casework and permits, fee payments, and civic
+grievances.
+
+## Entities
+- GovAgency \u2014 a government agency (operates services)
+- GovService \u2014 a public service in the catalog (fee model, SLA, required docs)
+- GovApplication \u2014 a citizen application against a service (+documents, notes, permits)
+- GovDocument \u2014 a supporting document on an application (references a Files-svc File)
+- GovCaseNote \u2014 a casework note on an application
+- GovPermit \u2014 an issued permit/licence (publicly verifiable by code)
+- GovGrievance \u2014 a civic grievance report
+- GovPayment \u2014 a fee payment against an application
+
+## Enums
+- GovServiceCategory: CERTIFICATES, EDUCATION, GRIEVANCES, HEALTH, LICENCES_AND_PERMITS, OTHER, SOCIAL_WELFARE, TAXES_AND_PAYMENTS, UTILITIES
+- GovServiceStatus: DRAFT, PUBLISHED, RETIRED, SUSPENDED
+- GovFeeType: FIXED, FREE, VARIABLE
+- GovApplicationStatus: DRAFT, SUBMITTED, IN_REVIEW, INFO_REQUESTED, APPROVED, REJECTED, WITHDRAWN
+- GovCasePriority: LOW, NORMAL, HIGH, URGENT
+- GovCaseNoteType: INTERNAL, CITIZEN_MESSAGE, INFO_REQUEST, DECISION
+- GovDocumentStatus: PENDING, ACCEPTED, REJECTED
+- GovGrievanceStatus: OPEN, ACKNOWLEDGED, IN_PROGRESS, RESOLVED, CLOSED, REJECTED
+- GovPaymentStatus: PENDING, PAID, FAILED, REFUNDED
+- GovPermitStatus: ISSUED, ACTIVE, EXPIRED, REVOKED
+
+## Tool groups
+agencies, services, applications, documents, notes, permits, grievances, payments, health.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe
+and the public permit-verification check.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "govcitizenhub-agencies",
+    agenciesUri,
+    {
+      title: "GovCitizenHub Agency Directory",
+      description: "The first 50 active government agencies in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${agenciesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_AGENCIES, {
+          isActive: true,
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: agenciesUri,
+              text: JSON.stringify(data.govListAgencies, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: agenciesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "govcitizenhub-services",
+    servicesUri,
+    {
+      title: "GovCitizenHub Service Catalog",
+      description: "The first 50 published public services in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${servicesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SERVICES, {
+          status: "PUBLISHED",
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: servicesUri,
+              text: JSON.stringify(data.govListServices, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: servicesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerGovcitizenhubPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const catalogName = track(mcpPromptName(p, "service-catalog-setup"));
+  const caseworkName = track(mcpPromptName(p, "casework-triage"));
+  server.registerPrompt(
+    catalogName,
+    {
+      title: "Service Catalog Setup",
+      description: "Guide for standing up a GovCitizenHub agency and its public-service catalog end to end: create the agency, add services, then publish them.",
+      argsSchema: {
+        agency: z.string().optional().describe("Agency name"),
+        category: z.string().optional().describe("Primary service category")
+      }
+    },
+    ({ agency, category }) => {
+      ctx.logger.debug(`Prompt ${catalogName} called`, { agency, category });
+      const agencyNote = agency ? `Use the agency name "${agency}".` : "Ask the user for the agency name.";
+      const categoryNote = category ? `Use category ${category}.` : "Help the user pick a GovServiceCategory.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me set up a GovCitizenHub agency and its service catalog.
+
+1. **Create Agency**: Use ${p}_agencies_create. ${agencyNote} Optionally set code, jurisdiction, and contact details.
+2. **Add Services**: Use ${p}_services_create for each public service \u2014 ${categoryNote} Provide a unique slug, the fee model (feeType + feeAmount), slaDays, and any requiredDocuments.
+3. **Verify Catalog**: Use ${p}_services_list filtered by the new agencyId to confirm the draft services.
+4. **Publish**: Use ${p}_services_transition with status=PUBLISHED for each service that is ready to accept applications.
+5. **Activate Agency**: If needed, use ${p}_agencies_update to confirm the agency is active.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    caseworkName,
+    {
+      title: "Casework Triage",
+      description: "Daily casework workflow: triage the submitted-application queue, request info or review documents, advance applications, issue permits, and handle grievances.",
+      argsSchema: {
+        assignedToId: z.string().optional().describe("Caseworker user ID to triage for")
+      }
+    },
+    ({ assignedToId }) => {
+      ctx.logger.debug(`Prompt ${caseworkName} called`, { assignedToId });
+      const assigneeNote = assignedToId ? `Focus on applications assigned to "${assignedToId}".` : `Triage across all caseworkers (omit the assignedToId filter).`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily GovCitizenHub casework triage. ${assigneeNote}
+
+1. **Queue**: Use ${p}_applications_list with status=SUBMITTED (then IN_REVIEW) to find applications awaiting action.
+2. **Open a Case**: Use ${p}_applications_get to load an application with its documents, notes, and permits.
+3. **Documents**: Use ${p}_documents_review to ACCEPT/REJECT each submitted document (supply a rejectionReason when rejecting).
+4. **Communicate**: Use ${p}_case_notes_add with type=INFO_REQUEST to ask the citizen for more, or type=INTERNAL for staff notes.
+5. **Advance**: Use ${p}_applications_transition to move the case (IN_REVIEW \u2192 INFO_REQUESTED/APPROVED/REJECTED), recording a reason.
+6. **Issue Permit**: On approval, use ${p}_permits_issue to grant the permit/licence (unique verificationCode), tying it to the application.
+7. **Payments**: Use ${p}_payments_list to confirm fees are PAID; use ${p}_payments_mark_paid where a provider reference confirms settlement.
+8. **Grievances**: Use ${p}_grievances_list with status=OPEN and ${p}_grievances_transition to acknowledge/progress/resolve them.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/govcitizenhub/index.ts
+var govcitizenhubModule = {
+  id: "govcitizenhub",
+  version: "0.0.1",
+  displayName: "GovCitizenHub",
+  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;
+    };
+    registerAgencyTools(server, ctx, trackTool);
+    registerServiceTools(server, ctx, trackTool);
+    registerApplicationTools(server, ctx, trackTool);
+    registerDocumentTools(server, ctx, trackTool);
+    registerNoteTools(server, ctx, trackTool);
+    registerPermitTools(server, ctx, trackTool);
+    registerGrievanceTools(server, ctx, trackTool);
+    registerPaymentTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerGovcitizenhubResources(server, ctx, trackResource);
+    registerGovcitizenhubPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var govcitizenhub_default = govcitizenhubModule;
+
+export { govcitizenhub_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map