@burdenoff/mcp-libs 2026.627.3 → 2026.627.5

package/dist/modules/manufacturedops/index.cjs

@@ -0,0 +1,1884 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/manufacturedops/tools/production.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/manufacturedops/operations.ts
+var WORK_CENTER_FIELDS = `
+  id code name description type capacityHours idealRunRate isActive tags
+  createdAt updatedAt workspaceId
+`;
+var PRODUCTION_OPERATION_FIELDS = `
+  id productionOrderId name sequence status workCenterId operatorId
+  setupMinutes runMinutes goodCount scrapCount startedAt completedAt
+  createdAt updatedAt workspaceId
+`;
+var MATERIAL_LOT_FIELDS = `
+  id lotNumber materialSku materialName quantity uom status supplier
+  receivedAt expiresAt productionOrderId parentLotId tags
+  createdAt updatedAt workspaceId
+`;
+var PRODUCTION_ORDER_FIELDS = `
+  id orderNumber productSku productName quantity quantityDone uom priority status
+  plannedStart plannedEnd actualStart actualEnd dueDate erpReference notes tags
+  createdAt updatedAt workspaceId
+`;
+var INSPECTION_PLAN_FIELDS = `
+  id code name description stage productSku characteristics isActive
+  createdAt updatedAt workspaceId
+`;
+var QUALITY_INSPECTION_FIELDS = `
+  id stage result sampleSize defectCount measurements notes
+  inspectionPlanId productionOrderId materialLotId workCenterId inspectorId
+  inspectedAt createdAt updatedAt workspaceId
+`;
+var NON_CONFORMANCE_FIELDS = `
+  id ncrNumber title description severity status disposition
+  quantityAffected rootCause correctiveAction ownerId inspectionId
+  dueDate resolvedAt tags createdAt updatedAt workspaceId
+`;
+var ASSET_FIELDS = `
+  id assetTag name manufacturer model serialNumber status
+  pmIntervalHours runningHours workCenterId installedAt lastServicedAt
+  tags createdAt updatedAt workspaceId
+`;
+var MAINTENANCE_WORK_ORDER_FIELDS = `
+  id woNumber title description type status assetId technicianId
+  scheduledFor startedAt completedAt laborMinutes downtimeMinutes
+  createdAt updatedAt workspaceId
+`;
+var DOWNTIME_EVENT_FIELDS = `
+  id reason description durationMinutes assetId workCenterId productionOrderId
+  startedAt endedAt createdAt updatedAt workspaceId
+`;
+var PAGE_INFO = `pageInfo { cursor hasMore }`;
+var GET_WORK_CENTER = `
+  query ManGetWorkCenter($id: ID!) {
+    manWorkCenter(id: $id) {
+      ${WORK_CENTER_FIELDS}
+      operations { id name sequence status productionOrderId }
+    }
+  }
+`;
+var LIST_WORK_CENTERS = `
+  query ManListWorkCenters($isActive: Boolean) {
+    manListWorkCenters(isActive: $isActive) {
+      ${WORK_CENTER_FIELDS}
+    }
+  }
+`;
+var CREATE_WORK_CENTER = `
+  mutation ManCreateWorkCenter($input: ManCreateWorkCenterInput!) {
+    manCreateWorkCenter(input: $input) {
+      ${WORK_CENTER_FIELDS}
+    }
+  }
+`;
+var UPDATE_WORK_CENTER = `
+  mutation ManUpdateWorkCenter($id: ID!, $input: ManUpdateWorkCenterInput!) {
+    manUpdateWorkCenter(id: $id, input: $input) {
+      ${WORK_CENTER_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_WORK_CENTER = `
+  mutation ManArchiveWorkCenter($id: ID!) {
+    manArchiveWorkCenter(id: $id)
+  }
+`;
+var GET_PRODUCTION_ORDER = `
+  query ManGetProductionOrder($id: ID!) {
+    manProductionOrder(id: $id) {
+      ${PRODUCTION_ORDER_FIELDS}
+      operations { ${PRODUCTION_OPERATION_FIELDS} }
+      materialLots { ${MATERIAL_LOT_FIELDS} }
+    }
+  }
+`;
+var LIST_PRODUCTION_ORDERS = `
+  query ManListProductionOrders(
+    $pagination: PaginationInput
+    $productSku: String
+    $status: ManProductionOrderStatus
+  ) {
+    manListProductionOrders(pagination: $pagination, productSku: $productSku, status: $status) {
+      items { ${PRODUCTION_ORDER_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_PRODUCTION_ORDER = `
+  mutation ManCreateProductionOrder($input: ManCreateProductionOrderInput!) {
+    manCreateProductionOrder(input: $input) {
+      ${PRODUCTION_ORDER_FIELDS}
+    }
+  }
+`;
+var UPDATE_PRODUCTION_ORDER = `
+  mutation ManUpdateProductionOrder($id: ID!, $input: ManUpdateProductionOrderInput!) {
+    manUpdateProductionOrder(id: $id, input: $input) {
+      ${PRODUCTION_ORDER_FIELDS}
+    }
+  }
+`;
+var TRANSITION_PRODUCTION_ORDER = `
+  mutation ManTransitionProductionOrder($id: ID!, $status: ManProductionOrderStatus!) {
+    manTransitionProductionOrder(id: $id, status: $status) {
+      ${PRODUCTION_ORDER_FIELDS}
+    }
+  }
+`;
+var ADD_OPERATION = `
+  mutation ManAddOperation($input: ManCreateOperationInput!) {
+    manAddOperation(input: $input) {
+      ${PRODUCTION_OPERATION_FIELDS}
+    }
+  }
+`;
+var RECORD_OPERATION = `
+  mutation ManRecordOperation($id: ID!, $input: ManRecordOperationInput!) {
+    manRecordOperation(id: $id, input: $input) {
+      ${PRODUCTION_OPERATION_FIELDS}
+    }
+  }
+`;
+var LIST_MATERIAL_LOTS = `
+  query ManListMaterialLots(
+    $pagination: PaginationInput
+    $productionOrderId: ID
+    $status: ManMaterialLotStatus
+  ) {
+    manListMaterialLots(
+      pagination: $pagination
+      productionOrderId: $productionOrderId
+      status: $status
+    ) {
+      items { ${MATERIAL_LOT_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_MATERIAL_LOT = `
+  mutation ManCreateMaterialLot($input: ManCreateMaterialLotInput!) {
+    manCreateMaterialLot(input: $input) {
+      ${MATERIAL_LOT_FIELDS}
+    }
+  }
+`;
+var SET_MATERIAL_LOT_STATUS = `
+  mutation ManSetMaterialLotStatus($id: ID!, $status: ManMaterialLotStatus!) {
+    manSetMaterialLotStatus(id: $id, status: $status) {
+      ${MATERIAL_LOT_FIELDS}
+    }
+  }
+`;
+var GET_INSPECTION = `
+  query ManGetInspection($id: ID!) {
+    manInspection(id: $id) {
+      ${QUALITY_INSPECTION_FIELDS}
+      inspectionPlan { ${INSPECTION_PLAN_FIELDS} }
+      nonConformances { ${NON_CONFORMANCE_FIELDS} }
+    }
+  }
+`;
+var LIST_INSPECTIONS = `
+  query ManListInspections(
+    $pagination: PaginationInput
+    $productionOrderId: ID
+    $result: ManInspectionResult
+  ) {
+    manListInspections(
+      pagination: $pagination
+      productionOrderId: $productionOrderId
+      result: $result
+    ) {
+      items { ${QUALITY_INSPECTION_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var RECORD_INSPECTION = `
+  mutation ManRecordInspection($input: ManRecordInspectionInput!) {
+    manRecordInspection(input: $input) {
+      ${QUALITY_INSPECTION_FIELDS}
+    }
+  }
+`;
+var LIST_INSPECTION_PLANS = `
+  query ManListInspectionPlans($isActive: Boolean, $stage: ManInspectionStage) {
+    manListInspectionPlans(isActive: $isActive, stage: $stage) {
+      ${INSPECTION_PLAN_FIELDS}
+    }
+  }
+`;
+var CREATE_INSPECTION_PLAN = `
+  mutation ManCreateInspectionPlan($input: ManCreateInspectionPlanInput!) {
+    manCreateInspectionPlan(input: $input) {
+      ${INSPECTION_PLAN_FIELDS}
+    }
+  }
+`;
+var GET_NON_CONFORMANCE = `
+  query ManGetNonConformance($id: ID!) {
+    manNonConformance(id: $id) {
+      ${NON_CONFORMANCE_FIELDS}
+      inspection { ${QUALITY_INSPECTION_FIELDS} }
+    }
+  }
+`;
+var LIST_NON_CONFORMANCES = `
+  query ManListNonConformances(
+    $pagination: PaginationInput
+    $severity: ManSeverity
+    $status: ManNonConformanceStatus
+  ) {
+    manListNonConformances(pagination: $pagination, severity: $severity, status: $status) {
+      items { ${NON_CONFORMANCE_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var RAISE_NON_CONFORMANCE = `
+  mutation ManRaiseNonConformance($input: ManRaiseNonConformanceInput!) {
+    manRaiseNonConformance(input: $input) {
+      ${NON_CONFORMANCE_FIELDS}
+    }
+  }
+`;
+var UPDATE_NON_CONFORMANCE = `
+  mutation ManUpdateNonConformance($id: ID!, $input: ManUpdateNonConformanceInput!) {
+    manUpdateNonConformance(id: $id, input: $input) {
+      ${NON_CONFORMANCE_FIELDS}
+    }
+  }
+`;
+var TRANSITION_NON_CONFORMANCE = `
+  mutation ManTransitionNonConformance($id: ID!, $status: ManNonConformanceStatus!) {
+    manTransitionNonConformance(id: $id, status: $status) {
+      ${NON_CONFORMANCE_FIELDS}
+    }
+  }
+`;
+var GET_ASSET = `
+  query ManGetAsset($id: ID!) {
+    manAsset(id: $id) {
+      ${ASSET_FIELDS}
+      workOrders { ${MAINTENANCE_WORK_ORDER_FIELDS} }
+    }
+  }
+`;
+var LIST_ASSETS = `
+  query ManListAssets(
+    $pagination: PaginationInput
+    $status: ManAssetStatus
+    $workCenterId: ID
+  ) {
+    manListAssets(pagination: $pagination, status: $status, workCenterId: $workCenterId) {
+      items { ${ASSET_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_ASSET = `
+  mutation ManCreateAsset($input: ManCreateAssetInput!) {
+    manCreateAsset(input: $input) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var UPDATE_ASSET = `
+  mutation ManUpdateAsset($id: ID!, $input: ManUpdateAssetInput!) {
+    manUpdateAsset(id: $id, input: $input) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var LIST_MAINTENANCE_WORK_ORDERS = `
+  query ManListMaintenanceWorkOrders(
+    $assetId: ID
+    $pagination: PaginationInput
+    $status: ManMaintenanceStatus
+  ) {
+    manListMaintenanceWorkOrders(assetId: $assetId, pagination: $pagination, status: $status) {
+      items {
+        ${MAINTENANCE_WORK_ORDER_FIELDS}
+        asset { id assetTag name status }
+      }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_MAINTENANCE_WORK_ORDER = `
+  mutation ManCreateMaintenanceWorkOrder($input: ManCreateMaintenanceWorkOrderInput!) {
+    manCreateMaintenanceWorkOrder(input: $input) {
+      ${MAINTENANCE_WORK_ORDER_FIELDS}
+    }
+  }
+`;
+var TRANSITION_MAINTENANCE_WORK_ORDER = `
+  mutation ManTransitionMaintenanceWorkOrder($id: ID!, $status: ManMaintenanceStatus!) {
+    manTransitionMaintenanceWorkOrder(id: $id, status: $status) {
+      ${MAINTENANCE_WORK_ORDER_FIELDS}
+    }
+  }
+`;
+var LIST_DOWNTIME_EVENTS = `
+  query ManListDowntimeEvents($assetId: ID, $reason: ManDowntimeReason, $workCenterId: ID) {
+    manListDowntimeEvents(assetId: $assetId, reason: $reason, workCenterId: $workCenterId) {
+      ${DOWNTIME_EVENT_FIELDS}
+    }
+  }
+`;
+var RECORD_DOWNTIME = `
+  mutation ManRecordDowntime($input: ManRecordDowntimeInput!) {
+    manRecordDowntime(input: $input) {
+      ${DOWNTIME_EVENT_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query ManHealth {
+    manHealth
+  }
+`;
+var WorkCenterTypeEnum = zod.z.enum(["ASSEMBLY", "CELL", "LINE", "MACHINE", "MANUAL"]).describe("Type of a production work center");
+var ProductionOrderStatusEnum = zod.z.enum(["PLANNED", "RELEASED", "IN_PROGRESS", "PAUSED", "COMPLETED", "CLOSED", "CANCELLED"]).describe("Execution lifecycle status of a production order");
+var ProductionPriorityEnum = zod.z.enum(["LOW", "NORMAL", "HIGH", "URGENT"]).describe("Scheduling priority of a production order");
+var OperationStatusEnum = zod.z.enum(["PENDING", "SETUP", "RUNNING", "DONE", "SKIPPED"]).describe("Status of a routing/production operation");
+var MaterialLotStatusEnum = zod.z.enum(["AVAILABLE", "ALLOCATED", "CONSUMED", "QUARANTINED", "SCRAPPED"]).describe("Inventory/quality status of a material lot");
+var InspectionStageEnum = zod.z.enum(["INCOMING", "IN_PROCESS", "FINAL", "AUDIT"]).describe("Stage at which a quality inspection is performed");
+var InspectionResultEnum = zod.z.enum(["PENDING", "PASS", "FAIL", "CONDITIONAL"]).describe("Outcome of a quality inspection");
+var SeverityEnum = zod.z.enum(["MINOR", "MAJOR", "CRITICAL"]).describe("Severity of a non-conformance");
+var NonConformanceStatusEnum = zod.z.enum(["OPEN", "INVESTIGATING", "CONTAINED", "CORRECTIVE_ACTION", "CLOSED"]).describe("Resolution lifecycle status of an NCR/CAPA");
+var NonConformanceDispositionEnum = zod.z.enum(["OPEN", "USE_AS_IS", "REWORK", "SCRAP", "RETURN_TO_SUPPLIER"]).describe("Disposition decision for a non-conformance");
+var AssetStatusEnum = zod.z.enum(["OPERATIONAL", "DEGRADED", "DOWN", "MAINTENANCE", "RETIRED"]).describe("Operational status of a maintainable asset");
+var MaintenanceTypeEnum = zod.z.enum(["PREVENTIVE", "CORRECTIVE", "PREDICTIVE", "INSPECTION"]).describe("Type of a maintenance work order");
+var MaintenanceStatusEnum = zod.z.enum(["SCHEDULED", "IN_PROGRESS", "ON_HOLD", "COMPLETED", "CANCELLED"]).describe("Lifecycle status of a maintenance work order");
+var DowntimeReasonEnum = zod.z.enum(["PLANNED", "BREAKDOWN", "CHANGEOVER", "MATERIAL_SHORTAGE", "QUALITY", "OTHER"]).describe("Reason classification for a downtime event");
+var IsoDateTime = zod.z.string().describe('ISO-8601 datetime, e.g. "2026-06-26T09:00:00.000Z"');
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+var PaginationFields = {
+  limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+  offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+  cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+};
+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/manufacturedops/tools/production.ts
+function registerProductionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_centers_get")),
+    {
+      title: "Get Work Center",
+      description: "Fetch a single work center by ID, including its scheduled operations.",
+      inputSchema: { id: zod.z.string().describe("Work center ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_WORK_CENTER, { id });
+        if (!data.manWorkCenter) return errorResult(`Work center ${id} not found`);
+        return jsonResult(data.manWorkCenter);
+      } catch (error) {
+        ctx.logger.error("manufacturedops work_centers_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get work center: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_centers_list")),
+    {
+      title: "List Work Centers",
+      description: "List work centers in the bound workspace, optionally filtered by active state.",
+      inputSchema: {
+        isActive: zod.z.boolean().optional().describe("Only active (true) or archived (false) centers")
+      }
+    },
+    async ({ isActive }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORK_CENTERS, { isActive });
+        return jsonResult(data.manListWorkCenters);
+      } catch (error) {
+        ctx.logger.error("manufacturedops work_centers_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list work centers: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_centers_create")),
+    {
+      title: "Create Work Center",
+      description: "Create a work center (machine/line/cell/manual station). `code` must be unique within the workspace.",
+      inputSchema: {
+        code: zod.z.string().min(1).describe("Unique work-center code"),
+        name: zod.z.string().min(1).describe("Display name"),
+        type: WorkCenterTypeEnum.optional().describe("Work-center type (default MACHINE)"),
+        description: zod.z.string().optional().describe("Description"),
+        capacityHours: zod.z.number().optional().describe("Available capacity in hours"),
+        idealRunRate: zod.z.number().optional().describe("Ideal run rate (units/hour) for OEE"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ code, name, type, description, capacityHours, idealRunRate, tags }) => {
+      try {
+        const input = { code, name };
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (capacityHours !== void 0) input.capacityHours = capacityHours;
+        if (idealRunRate !== void 0) input.idealRunRate = idealRunRate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_WORK_CENTER, { input });
+        return jsonResult(data.manCreateWorkCenter);
+      } catch (error) {
+        ctx.logger.error("manufacturedops work_centers_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create work center: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_centers_update")),
+    {
+      title: "Update Work Center",
+      description: "Update a work center. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Work center ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        type: WorkCenterTypeEnum.optional().describe("Updated type"),
+        description: zod.z.string().optional().describe("Updated description"),
+        capacityHours: zod.z.number().optional().describe("Updated capacity (hours)"),
+        idealRunRate: zod.z.number().optional().describe("Updated ideal run rate"),
+        isActive: zod.z.boolean().optional().describe("Updated active state"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, type, description, capacityHours, idealRunRate, isActive, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (capacityHours !== void 0) input.capacityHours = capacityHours;
+        if (idealRunRate !== void 0) input.idealRunRate = idealRunRate;
+        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 mutable field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_WORK_CENTER, { id, input });
+        return jsonResult(data.manUpdateWorkCenter);
+      } catch (error) {
+        ctx.logger.error("manufacturedops work_centers_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update work center: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_centers_archive")),
+    {
+      title: "Archive Work Center",
+      description: "Archive (soft-delete) a work center so it is no longer schedulable.",
+      inputSchema: { id: zod.z.string().describe("Work center ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_WORK_CENTER,
+          { id }
+        );
+        return jsonResult({ ok: data.manArchiveWorkCenter, id });
+      } catch (error) {
+        ctx.logger.error("manufacturedops work_centers_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive work center: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "production_orders_get")),
+    {
+      title: "Get Production Order",
+      description: "Fetch a single production order by ID, including its operations and material lots.",
+      inputSchema: { id: zod.z.string().describe("Production order ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PRODUCTION_ORDER, { id });
+        if (!data.manProductionOrder) return errorResult(`Production order ${id} not found`);
+        return jsonResult(data.manProductionOrder);
+      } catch (error) {
+        ctx.logger.error("manufacturedops production_orders_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get production order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "production_orders_list")),
+    {
+      title: "List Production Orders",
+      description: "List production orders (paginated), optionally filtered by product SKU and/or status.",
+      inputSchema: {
+        productSku: zod.z.string().optional().describe("Filter by product SKU"),
+        status: ProductionOrderStatusEnum.optional().describe("Filter by status"),
+        ...PaginationFields
+      }
+    },
+    async ({ productSku, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PRODUCTION_ORDERS, {
+          productSku,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.manListProductionOrders);
+      } catch (error) {
+        ctx.logger.error("manufacturedops production_orders_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list production orders: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "production_orders_create")),
+    {
+      title: "Create Production Order",
+      description: "Create a production (manufacturing) order. `orderNumber` and `productSku` must be provided.",
+      inputSchema: {
+        orderNumber: zod.z.string().min(1).describe("Unique order number"),
+        productSku: zod.z.string().min(1).describe("Product SKU being manufactured"),
+        productName: zod.z.string().min(1).describe("Product display name"),
+        quantity: zod.z.number().optional().describe("Order quantity"),
+        uom: zod.z.string().optional().describe('Unit of measure (e.g. "ea", "kg")'),
+        priority: ProductionPriorityEnum.optional().describe("Priority (default NORMAL)"),
+        plannedStart: IsoDateTime.optional().describe("Planned start (ISO-8601)"),
+        plannedEnd: IsoDateTime.optional().describe("Planned end (ISO-8601)"),
+        dueDate: IsoDateTime.optional().describe("Due date (ISO-8601)"),
+        erpReference: zod.z.string().optional().describe("External ERP reference"),
+        notes: zod.z.string().optional().describe("Free-form notes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      orderNumber,
+      productSku,
+      productName,
+      quantity,
+      uom,
+      priority,
+      plannedStart,
+      plannedEnd,
+      dueDate,
+      erpReference,
+      notes,
+      tags
+    }) => {
+      try {
+        const input = { orderNumber, productSku, productName };
+        if (quantity !== void 0) input.quantity = quantity;
+        if (uom !== void 0) input.uom = uom;
+        if (priority !== void 0) input.priority = priority;
+        if (plannedStart !== void 0) input.plannedStart = plannedStart;
+        if (plannedEnd !== void 0) input.plannedEnd = plannedEnd;
+        if (dueDate !== void 0) input.dueDate = dueDate;
+        if (erpReference !== void 0) input.erpReference = erpReference;
+        if (notes !== void 0) input.notes = notes;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PRODUCTION_ORDER, { input });
+        return jsonResult(data.manCreateProductionOrder);
+      } catch (error) {
+        ctx.logger.error("manufacturedops production_orders_create failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create production order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "production_orders_update")),
+    {
+      title: "Update Production Order",
+      description: "Update a production order. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Production order ID"),
+        productName: zod.z.string().optional().describe("Updated product name"),
+        quantity: zod.z.number().optional().describe("Updated quantity"),
+        uom: zod.z.string().optional().describe("Updated unit of measure"),
+        priority: ProductionPriorityEnum.optional().describe("Updated priority"),
+        plannedStart: IsoDateTime.optional().describe("Updated planned start"),
+        plannedEnd: IsoDateTime.optional().describe("Updated planned end"),
+        dueDate: IsoDateTime.optional().describe("Updated due date"),
+        erpReference: zod.z.string().optional().describe("Updated ERP reference"),
+        notes: zod.z.string().optional().describe("Updated notes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      productName,
+      quantity,
+      uom,
+      priority,
+      plannedStart,
+      plannedEnd,
+      dueDate,
+      erpReference,
+      notes,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (productName !== void 0) input.productName = productName;
+        if (quantity !== void 0) input.quantity = quantity;
+        if (uom !== void 0) input.uom = uom;
+        if (priority !== void 0) input.priority = priority;
+        if (plannedStart !== void 0) input.plannedStart = plannedStart;
+        if (plannedEnd !== void 0) input.plannedEnd = plannedEnd;
+        if (dueDate !== void 0) input.dueDate = dueDate;
+        if (erpReference !== void 0) input.erpReference = erpReference;
+        if (notes !== void 0) input.notes = notes;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PRODUCTION_ORDER, { id, input });
+        return jsonResult(data.manUpdateProductionOrder);
+      } catch (error) {
+        ctx.logger.error("manufacturedops production_orders_update failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to update production order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "production_orders_transition")),
+    {
+      title: "Transition Production Order",
+      description: "Advance a production order through its execution lifecycle (PLANNED \u2192 RELEASED \u2192 IN_PROGRESS \u2192 COMPLETED \u2192 CLOSED, or PAUSED/CANCELLED). Transitions are validated server-side.",
+      inputSchema: {
+        id: zod.z.string().describe("Production order ID"),
+        status: ProductionOrderStatusEnum.describe("Target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_PRODUCTION_ORDER, { id, status });
+        return jsonResult(data.manTransitionProductionOrder);
+      } catch (error) {
+        ctx.logger.error("manufacturedops production_orders_transition failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to transition production order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "operations_add")),
+    {
+      title: "Add Production Operation",
+      description: "Add a routing operation (step) to a production order, optionally assigned to a work center.",
+      inputSchema: {
+        productionOrderId: zod.z.string().min(1).describe("Owning production order ID"),
+        name: zod.z.string().min(1).describe('Operation name (e.g. "CNC mill", "Assembly")'),
+        sequence: zod.z.number().int().optional().describe("Ordering sequence number"),
+        workCenterId: zod.z.string().optional().describe("Assigned work center ID")
+      }
+    },
+    async ({ productionOrderId, name, sequence, workCenterId }) => {
+      try {
+        const input = { productionOrderId, name };
+        if (sequence !== void 0) input.sequence = sequence;
+        if (workCenterId !== void 0) input.workCenterId = workCenterId;
+        const data = await ctx.gql.workspace.request(ADD_OPERATION, { input });
+        return jsonResult(data.manAddOperation);
+      } catch (error) {
+        ctx.logger.error("manufacturedops operations_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add operation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "operations_record")),
+    {
+      title: "Record Production Operation",
+      description: "Record progress against a routing operation (setup/run minutes, good/scrap counts, status).",
+      inputSchema: {
+        id: zod.z.string().describe("Operation ID"),
+        status: OperationStatusEnum.optional().describe("Updated operation status"),
+        setupMinutes: zod.z.number().int().optional().describe("Setup minutes logged"),
+        runMinutes: zod.z.number().int().optional().describe("Run minutes logged"),
+        goodCount: zod.z.number().optional().describe("Good units produced"),
+        scrapCount: zod.z.number().optional().describe("Scrap units produced")
+      }
+    },
+    async ({ id, status, setupMinutes, runMinutes, goodCount, scrapCount }) => {
+      try {
+        const input = {};
+        if (status !== void 0) input.status = status;
+        if (setupMinutes !== void 0) input.setupMinutes = setupMinutes;
+        if (runMinutes !== void 0) input.runMinutes = runMinutes;
+        if (goodCount !== void 0) input.goodCount = goodCount;
+        if (scrapCount !== void 0) input.scrapCount = scrapCount;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of status/setupMinutes/runMinutes/goodCount/scrapCount"
+          );
+        }
+        const data = await ctx.gql.workspace.request(RECORD_OPERATION, { id, input });
+        return jsonResult(data.manRecordOperation);
+      } catch (error) {
+        ctx.logger.error("manufacturedops operations_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record operation: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "material_lots_list")),
+    {
+      title: "List Material Lots",
+      description: "List material lots (paginated), optionally filtered by production order and/or status.",
+      inputSchema: {
+        productionOrderId: zod.z.string().optional().describe("Filter by production order ID"),
+        status: MaterialLotStatusEnum.optional().describe("Filter by lot status"),
+        ...PaginationFields
+      }
+    },
+    async ({ productionOrderId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MATERIAL_LOTS, {
+          productionOrderId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.manListMaterialLots);
+      } catch (error) {
+        ctx.logger.error("manufacturedops material_lots_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list material lots: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "material_lots_create")),
+    {
+      title: "Create Material Lot",
+      description: "Receive / create a traceable material lot. `lotNumber`, `materialSku`, and `materialName` are required.",
+      inputSchema: {
+        lotNumber: zod.z.string().min(1).describe("Unique lot number"),
+        materialSku: zod.z.string().min(1).describe("Material SKU"),
+        materialName: zod.z.string().min(1).describe("Material display name"),
+        quantity: zod.z.number().optional().describe("Received quantity"),
+        uom: zod.z.string().optional().describe("Unit of measure"),
+        supplier: zod.z.string().optional().describe("Supplier name"),
+        receivedAt: IsoDateTime.optional().describe("Received timestamp (ISO-8601)"),
+        expiresAt: IsoDateTime.optional().describe("Expiry timestamp (ISO-8601)"),
+        productionOrderId: zod.z.string().optional().describe("Allocated production order ID"),
+        parentLotId: zod.z.string().optional().describe("Parent lot ID (for genealogy/splits)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      lotNumber,
+      materialSku,
+      materialName,
+      quantity,
+      uom,
+      supplier,
+      receivedAt,
+      expiresAt,
+      productionOrderId,
+      parentLotId,
+      tags
+    }) => {
+      try {
+        const input = { lotNumber, materialSku, materialName };
+        if (quantity !== void 0) input.quantity = quantity;
+        if (uom !== void 0) input.uom = uom;
+        if (supplier !== void 0) input.supplier = supplier;
+        if (receivedAt !== void 0) input.receivedAt = receivedAt;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        if (productionOrderId !== void 0) input.productionOrderId = productionOrderId;
+        if (parentLotId !== void 0) input.parentLotId = parentLotId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_MATERIAL_LOT, { input });
+        return jsonResult(data.manCreateMaterialLot);
+      } catch (error) {
+        ctx.logger.error("manufacturedops material_lots_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create material lot: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "material_lots_set_status")),
+    {
+      title: "Set Material Lot Status",
+      description: "Change a material lot status (AVAILABLE/ALLOCATED/CONSUMED/QUARANTINED/SCRAPPED).",
+      inputSchema: {
+        id: zod.z.string().describe("Material lot ID"),
+        status: MaterialLotStatusEnum.describe("Target lot status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_MATERIAL_LOT_STATUS, { id, status });
+        return jsonResult(data.manSetMaterialLotStatus);
+      } catch (error) {
+        ctx.logger.error("manufacturedops material_lots_set_status failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to set material lot status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerQualityTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inspections_get")),
+    {
+      title: "Get Quality Inspection",
+      description: "Fetch a single quality inspection by ID, including its plan and any raised non-conformances.",
+      inputSchema: { id: zod.z.string().describe("Inspection ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_INSPECTION, { id });
+        if (!data.manInspection) return errorResult(`Inspection ${id} not found`);
+        return jsonResult(data.manInspection);
+      } catch (error) {
+        ctx.logger.error("manufacturedops inspections_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get inspection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inspections_list")),
+    {
+      title: "List Quality Inspections",
+      description: "List quality inspections (paginated), optionally filtered by production order and/or result.",
+      inputSchema: {
+        productionOrderId: zod.z.string().optional().describe("Filter by production order ID"),
+        result: InspectionResultEnum.optional().describe("Filter by inspection result"),
+        ...PaginationFields
+      }
+    },
+    async ({ productionOrderId, result, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INSPECTIONS, {
+          productionOrderId,
+          result,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.manListInspections);
+      } catch (error) {
+        ctx.logger.error("manufacturedops inspections_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list inspections: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inspections_record")),
+    {
+      title: "Record Quality Inspection",
+      description: "Record a quality inspection result against a production order, material lot, or work center.",
+      inputSchema: {
+        stage: InspectionStageEnum.optional().describe("Inspection stage (default IN_PROCESS)"),
+        result: InspectionResultEnum.optional().describe("Inspection result (default PENDING)"),
+        sampleSize: zod.z.number().int().optional().describe("Number of units sampled"),
+        defectCount: zod.z.number().int().optional().describe("Number of defective units found"),
+        measurements: JsonObject.optional().describe("Measurement readings as JSON"),
+        notes: zod.z.string().optional().describe("Inspector notes"),
+        inspectionPlanId: zod.z.string().optional().describe("Inspection plan ID"),
+        productionOrderId: zod.z.string().optional().describe("Production order ID"),
+        materialLotId: zod.z.string().optional().describe("Material lot ID"),
+        workCenterId: zod.z.string().optional().describe("Work center ID"),
+        inspectedAt: IsoDateTime.optional().describe("Inspection timestamp (ISO-8601)")
+      }
+    },
+    async ({
+      stage,
+      result,
+      sampleSize,
+      defectCount,
+      measurements,
+      notes,
+      inspectionPlanId,
+      productionOrderId,
+      materialLotId,
+      workCenterId,
+      inspectedAt
+    }) => {
+      try {
+        const input = {};
+        if (stage !== void 0) input.stage = stage;
+        if (result !== void 0) input.result = result;
+        if (sampleSize !== void 0) input.sampleSize = sampleSize;
+        if (defectCount !== void 0) input.defectCount = defectCount;
+        if (measurements !== void 0) input.measurements = measurements;
+        if (notes !== void 0) input.notes = notes;
+        if (inspectionPlanId !== void 0) input.inspectionPlanId = inspectionPlanId;
+        if (productionOrderId !== void 0) input.productionOrderId = productionOrderId;
+        if (materialLotId !== void 0) input.materialLotId = materialLotId;
+        if (workCenterId !== void 0) input.workCenterId = workCenterId;
+        if (inspectedAt !== void 0) input.inspectedAt = inspectedAt;
+        const data = await ctx.gql.workspace.request(RECORD_INSPECTION, { input });
+        return jsonResult(data.manRecordInspection);
+      } catch (error) {
+        ctx.logger.error("manufacturedops inspections_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record inspection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inspection_plans_list")),
+    {
+      title: "List Inspection Plans",
+      description: "List inspection plans, optionally filtered by active state and/or stage.",
+      inputSchema: {
+        isActive: zod.z.boolean().optional().describe("Only active (true) or inactive (false) plans"),
+        stage: InspectionStageEnum.optional().describe("Filter by inspection stage")
+      }
+    },
+    async ({ isActive, stage }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INSPECTION_PLANS, { isActive, stage });
+        return jsonResult(data.manListInspectionPlans);
+      } catch (error) {
+        ctx.logger.error("manufacturedops inspection_plans_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list inspection plans: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inspection_plans_create")),
+    {
+      title: "Create Inspection Plan",
+      description: "Create an inspection plan (characteristics checklist). `code` and `name` are required.",
+      inputSchema: {
+        code: zod.z.string().min(1).describe("Unique inspection-plan code"),
+        name: zod.z.string().min(1).describe("Plan name"),
+        stage: InspectionStageEnum.optional().describe("Plan stage (default IN_PROCESS)"),
+        description: zod.z.string().optional().describe("Description"),
+        productSku: zod.z.string().optional().describe("Product SKU this plan applies to"),
+        characteristics: JsonObject.optional().describe("Inspection characteristics as JSON")
+      }
+    },
+    async ({ code, name, stage, description, productSku, characteristics }) => {
+      try {
+        const input = { code, name };
+        if (stage !== void 0) input.stage = stage;
+        if (description !== void 0) input.description = description;
+        if (productSku !== void 0) input.productSku = productSku;
+        if (characteristics !== void 0) input.characteristics = characteristics;
+        const data = await ctx.gql.workspace.request(CREATE_INSPECTION_PLAN, { input });
+        return jsonResult(data.manCreateInspectionPlan);
+      } catch (error) {
+        ctx.logger.error("manufacturedops inspection_plans_create failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create inspection plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "non_conformances_get")),
+    {
+      title: "Get Non-Conformance",
+      description: "Fetch a single non-conformance (NCR) by ID, including its originating inspection.",
+      inputSchema: { id: zod.z.string().describe("Non-conformance ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_NON_CONFORMANCE, { id });
+        if (!data.manNonConformance) return errorResult(`Non-conformance ${id} not found`);
+        return jsonResult(data.manNonConformance);
+      } catch (error) {
+        ctx.logger.error("manufacturedops non_conformances_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get non-conformance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "non_conformances_list")),
+    {
+      title: "List Non-Conformances",
+      description: "List non-conformances (paginated), optionally filtered by severity and/or status.",
+      inputSchema: {
+        severity: SeverityEnum.optional().describe("Filter by severity"),
+        status: NonConformanceStatusEnum.optional().describe("Filter by status"),
+        ...PaginationFields
+      }
+    },
+    async ({ severity, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_NON_CONFORMANCES, {
+          severity,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.manListNonConformances);
+      } catch (error) {
+        ctx.logger.error("manufacturedops non_conformances_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list non-conformances: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "non_conformances_raise")),
+    {
+      title: "Raise Non-Conformance",
+      description: "Raise a non-conformance report (NCR). `ncrNumber` and `title` are required; optionally link an inspection.",
+      inputSchema: {
+        ncrNumber: zod.z.string().min(1).describe("Unique NCR number"),
+        title: zod.z.string().min(1).describe("NCR title/summary"),
+        description: zod.z.string().optional().describe("Detailed description"),
+        severity: SeverityEnum.optional().describe("Severity (default MINOR)"),
+        disposition: NonConformanceDispositionEnum.optional().describe(
+          "Disposition (default OPEN)"
+        ),
+        quantityAffected: zod.z.number().optional().describe("Quantity of units affected"),
+        inspectionId: zod.z.string().optional().describe("Originating inspection ID"),
+        ownerId: zod.z.string().optional().describe("Owner (assignee) user ID"),
+        dueDate: IsoDateTime.optional().describe("Resolution due date (ISO-8601)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      ncrNumber,
+      title,
+      description,
+      severity,
+      disposition,
+      quantityAffected,
+      inspectionId,
+      ownerId,
+      dueDate,
+      tags
+    }) => {
+      try {
+        const input = { ncrNumber, title };
+        if (description !== void 0) input.description = description;
+        if (severity !== void 0) input.severity = severity;
+        if (disposition !== void 0) input.disposition = disposition;
+        if (quantityAffected !== void 0) input.quantityAffected = quantityAffected;
+        if (inspectionId !== void 0) input.inspectionId = inspectionId;
+        if (ownerId !== void 0) input.ownerId = ownerId;
+        if (dueDate !== void 0) input.dueDate = dueDate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(RAISE_NON_CONFORMANCE, { input });
+        return jsonResult(data.manRaiseNonConformance);
+      } catch (error) {
+        ctx.logger.error("manufacturedops non_conformances_raise failed", { error: String(error) });
+        return errorResult(
+          `Failed to raise non-conformance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "non_conformances_update")),
+    {
+      title: "Update Non-Conformance",
+      description: "Update a non-conformance (root cause, corrective action, disposition, owner, \u2026). At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Non-conformance ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        description: zod.z.string().optional().describe("Updated description"),
+        severity: SeverityEnum.optional().describe("Updated severity"),
+        disposition: NonConformanceDispositionEnum.optional().describe("Updated disposition"),
+        quantityAffected: zod.z.number().optional().describe("Updated quantity affected"),
+        rootCause: zod.z.string().optional().describe("Root-cause analysis"),
+        correctiveAction: zod.z.string().optional().describe("Corrective/preventive action (CAPA)"),
+        ownerId: zod.z.string().optional().describe("Updated owner user ID"),
+        dueDate: IsoDateTime.optional().describe("Updated due date (ISO-8601)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      description,
+      severity,
+      disposition,
+      quantityAffected,
+      rootCause,
+      correctiveAction,
+      ownerId,
+      dueDate,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (description !== void 0) input.description = description;
+        if (severity !== void 0) input.severity = severity;
+        if (disposition !== void 0) input.disposition = disposition;
+        if (quantityAffected !== void 0) input.quantityAffected = quantityAffected;
+        if (rootCause !== void 0) input.rootCause = rootCause;
+        if (correctiveAction !== void 0) input.correctiveAction = correctiveAction;
+        if (ownerId !== void 0) input.ownerId = ownerId;
+        if (dueDate !== void 0) input.dueDate = dueDate;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_NON_CONFORMANCE, { id, input });
+        return jsonResult(data.manUpdateNonConformance);
+      } catch (error) {
+        ctx.logger.error("manufacturedops non_conformances_update failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to update non-conformance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "non_conformances_transition")),
+    {
+      title: "Transition Non-Conformance",
+      description: "Advance an NCR/CAPA through its resolution lifecycle (OPEN \u2192 INVESTIGATING \u2192 CONTAINED \u2192 CORRECTIVE_ACTION \u2192 CLOSED). Transitions are validated server-side.",
+      inputSchema: {
+        id: zod.z.string().describe("Non-conformance ID"),
+        status: NonConformanceStatusEnum.describe("Target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_NON_CONFORMANCE, { id, status });
+        return jsonResult(data.manTransitionNonConformance);
+      } catch (error) {
+        ctx.logger.error("manufacturedops non_conformances_transition failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to transition non-conformance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMaintenanceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_get")),
+    {
+      title: "Get Asset",
+      description: "Fetch a single maintainable asset by ID, including its maintenance work orders.",
+      inputSchema: { id: zod.z.string().describe("Asset ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ASSET, { id });
+        if (!data.manAsset) return errorResult(`Asset ${id} not found`);
+        return jsonResult(data.manAsset);
+      } catch (error) {
+        ctx.logger.error("manufacturedops assets_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_list")),
+    {
+      title: "List Assets",
+      description: "List maintainable assets (paginated), optionally filtered by status and/or work center.",
+      inputSchema: {
+        status: AssetStatusEnum.optional().describe("Filter by asset status"),
+        workCenterId: zod.z.string().optional().describe("Filter by work center ID"),
+        ...PaginationFields
+      }
+    },
+    async ({ status, workCenterId, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ASSETS, {
+          status,
+          workCenterId,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.manListAssets);
+      } catch (error) {
+        ctx.logger.error("manufacturedops assets_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list assets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_create")),
+    {
+      title: "Create Asset",
+      description: "Register a maintainable asset (machine/equipment). `assetTag` and `name` are required.",
+      inputSchema: {
+        assetTag: zod.z.string().min(1).describe("Unique asset tag"),
+        name: zod.z.string().min(1).describe("Asset display name"),
+        manufacturer: zod.z.string().optional().describe("Manufacturer"),
+        model: zod.z.string().optional().describe("Model"),
+        serialNumber: zod.z.string().optional().describe("Serial number"),
+        pmIntervalHours: zod.z.number().optional().describe("Preventive-maintenance interval (hours)"),
+        runningHours: zod.z.number().optional().describe("Current running hours"),
+        workCenterId: zod.z.string().optional().describe("Host work center ID"),
+        installedAt: IsoDateTime.optional().describe("Install timestamp (ISO-8601)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      assetTag,
+      name,
+      manufacturer,
+      model,
+      serialNumber,
+      pmIntervalHours,
+      runningHours,
+      workCenterId,
+      installedAt,
+      tags
+    }) => {
+      try {
+        const input = { assetTag, name };
+        if (manufacturer !== void 0) input.manufacturer = manufacturer;
+        if (model !== void 0) input.model = model;
+        if (serialNumber !== void 0) input.serialNumber = serialNumber;
+        if (pmIntervalHours !== void 0) input.pmIntervalHours = pmIntervalHours;
+        if (runningHours !== void 0) input.runningHours = runningHours;
+        if (workCenterId !== void 0) input.workCenterId = workCenterId;
+        if (installedAt !== void 0) input.installedAt = installedAt;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_ASSET, { input });
+        return jsonResult(data.manCreateAsset);
+      } catch (error) {
+        ctx.logger.error("manufacturedops assets_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_update")),
+    {
+      title: "Update Asset",
+      description: "Update a maintainable asset (status, running hours, PM interval, \u2026). At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Asset ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        manufacturer: zod.z.string().optional().describe("Updated manufacturer"),
+        model: zod.z.string().optional().describe("Updated model"),
+        serialNumber: zod.z.string().optional().describe("Updated serial number"),
+        status: AssetStatusEnum.optional().describe("Updated asset status"),
+        pmIntervalHours: zod.z.number().optional().describe("Updated PM interval (hours)"),
+        runningHours: zod.z.number().optional().describe("Updated running hours"),
+        workCenterId: zod.z.string().optional().describe("Updated host work center ID"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      manufacturer,
+      model,
+      serialNumber,
+      status,
+      pmIntervalHours,
+      runningHours,
+      workCenterId,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (manufacturer !== void 0) input.manufacturer = manufacturer;
+        if (model !== void 0) input.model = model;
+        if (serialNumber !== void 0) input.serialNumber = serialNumber;
+        if (status !== void 0) input.status = status;
+        if (pmIntervalHours !== void 0) input.pmIntervalHours = pmIntervalHours;
+        if (runningHours !== void 0) input.runningHours = runningHours;
+        if (workCenterId !== void 0) input.workCenterId = workCenterId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_ASSET, { id, input });
+        return jsonResult(data.manUpdateAsset);
+      } catch (error) {
+        ctx.logger.error("manufacturedops assets_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "maintenance_list")),
+    {
+      title: "List Maintenance Work Orders",
+      description: "List maintenance work orders (paginated), optionally filtered by asset and/or status.",
+      inputSchema: {
+        assetId: zod.z.string().optional().describe("Filter by asset ID"),
+        status: MaintenanceStatusEnum.optional().describe("Filter by work-order status"),
+        ...PaginationFields
+      }
+    },
+    async ({ assetId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MAINTENANCE_WORK_ORDERS, {
+          assetId,
+          status,
+          pagination: buildPagination({ limit, offset, cursor })
+        });
+        return jsonResult(data.manListMaintenanceWorkOrders);
+      } catch (error) {
+        ctx.logger.error("manufacturedops maintenance_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list maintenance work orders: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "maintenance_create")),
+    {
+      title: "Create Maintenance Work Order",
+      description: "Create a maintenance work order against an asset. `woNumber`, `title`, and `assetId` are required.",
+      inputSchema: {
+        woNumber: zod.z.string().min(1).describe("Unique work-order number"),
+        title: zod.z.string().min(1).describe("Work-order title"),
+        assetId: zod.z.string().min(1).describe("Target asset ID"),
+        type: MaintenanceTypeEnum.optional().describe("Maintenance type (default PREVENTIVE)"),
+        description: zod.z.string().optional().describe("Description"),
+        technicianId: zod.z.string().optional().describe("Assigned technician user ID"),
+        scheduledFor: IsoDateTime.optional().describe("Scheduled timestamp (ISO-8601)")
+      }
+    },
+    async ({ woNumber, title, assetId, type, description, technicianId, scheduledFor }) => {
+      try {
+        const input = { woNumber, title, assetId };
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (technicianId !== void 0) input.technicianId = technicianId;
+        if (scheduledFor !== void 0) input.scheduledFor = scheduledFor;
+        const data = await ctx.gql.workspace.request(CREATE_MAINTENANCE_WORK_ORDER, { input });
+        return jsonResult(data.manCreateMaintenanceWorkOrder);
+      } catch (error) {
+        ctx.logger.error("manufacturedops maintenance_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create maintenance work order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "maintenance_transition")),
+    {
+      title: "Transition Maintenance Work Order",
+      description: "Advance a maintenance work order through its lifecycle (SCHEDULED \u2192 IN_PROGRESS \u2192 COMPLETED, or ON_HOLD/CANCELLED). Transitions are validated server-side.",
+      inputSchema: {
+        id: zod.z.string().describe("Maintenance work order ID"),
+        status: MaintenanceStatusEnum.describe("Target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_MAINTENANCE_WORK_ORDER, { id, status });
+        return jsonResult(data.manTransitionMaintenanceWorkOrder);
+      } catch (error) {
+        ctx.logger.error("manufacturedops maintenance_transition failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to transition maintenance work order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "downtime_list")),
+    {
+      title: "List Downtime Events",
+      description: "List downtime events, optionally filtered by asset, work center, and/or reason.",
+      inputSchema: {
+        assetId: zod.z.string().optional().describe("Filter by asset ID"),
+        workCenterId: zod.z.string().optional().describe("Filter by work center ID"),
+        reason: DowntimeReasonEnum.optional().describe("Filter by downtime reason")
+      }
+    },
+    async ({ assetId, workCenterId, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DOWNTIME_EVENTS, { assetId, workCenterId, reason });
+        return jsonResult(data.manListDowntimeEvents);
+      } catch (error) {
+        ctx.logger.error("manufacturedops downtime_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list downtime events: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "downtime_record")),
+    {
+      title: "Record Downtime Event",
+      description: "Record a downtime event against an asset, work center, and/or production order. `startedAt` is required.",
+      inputSchema: {
+        startedAt: IsoDateTime.describe("Downtime start timestamp (ISO-8601)"),
+        reason: DowntimeReasonEnum.optional().describe("Downtime reason (default BREAKDOWN)"),
+        description: zod.z.string().optional().describe("Description"),
+        durationMinutes: zod.z.number().int().optional().describe("Duration in minutes"),
+        endedAt: IsoDateTime.optional().describe("Downtime end timestamp (ISO-8601)"),
+        assetId: zod.z.string().optional().describe("Affected asset ID"),
+        workCenterId: zod.z.string().optional().describe("Affected work center ID"),
+        productionOrderId: zod.z.string().optional().describe("Affected production order ID")
+      }
+    },
+    async ({
+      startedAt,
+      reason,
+      description,
+      durationMinutes,
+      endedAt,
+      assetId,
+      workCenterId,
+      productionOrderId
+    }) => {
+      try {
+        const input = { startedAt };
+        if (reason !== void 0) input.reason = reason;
+        if (description !== void 0) input.description = description;
+        if (durationMinutes !== void 0) input.durationMinutes = durationMinutes;
+        if (endedAt !== void 0) input.endedAt = endedAt;
+        if (assetId !== void 0) input.assetId = assetId;
+        if (workCenterId !== void 0) input.workCenterId = workCenterId;
+        if (productionOrderId !== void 0) input.productionOrderId = productionOrderId;
+        const data = await ctx.gql.workspace.request(RECORD_DOWNTIME, { input });
+        return jsonResult(data.manRecordDowntime);
+      } catch (error) {
+        ctx.logger.error("manufacturedops downtime_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record downtime: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/manufacturedops/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Manufacturedops Health Check",
+      description: "Public liveness/identity probe for the Manufacturedops subgraph (manHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.manHealth });
+      } catch (error) {
+        ctx.logger.error("manufacturedops health failed", { error: String(error) });
+        return errorResult(
+          `Manufacturedops health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/manufacturedops/resources.ts
+function registerManufacturedopsResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const ordersUri = track(mcpResourceUri(ctx.productName, "production-orders"));
+  const workCentersUri = track(mcpResourceUri(ctx.productName, "work-centers"));
+  const ncrUri = track(mcpResourceUri(ctx.productName, "non-conformances"));
+  server.registerResource(
+    "manufacturedops-schema",
+    schemaUri,
+    {
+      title: "Manufacturedops Domain Schema",
+      description: "Overview of the Manufacturedops MES domain \u2014 entities, enums, and the per-domain tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Manufacturedops Domain (Overview)
+
+Manufacturing Operations Platform (MES): production planning & shop-floor
+execution, quality & traceability, and maintenance & OEE.
+
+## Entities
+- ManWorkCenter \u2014 a machine/line/cell/manual station (has operations)
+- ManProductionOrder \u2014 a manufacturing order (has operations + material lots)
+- ManProductionOperation \u2014 a routing step on a production order
+- ManMaterialLot \u2014 a traceable material lot (genealogy via parent/child)
+- ManQualityInspection \u2014 a recorded inspection (links plan + non-conformances)
+- ManInspectionPlan \u2014 a reusable inspection characteristics checklist
+- ManNonConformance \u2014 an NCR/CAPA (links originating inspection)
+- ManAsset \u2014 a maintainable asset (has maintenance work orders)
+- ManMaintenanceWorkOrder \u2014 a maintenance job against an asset
+- ManDowntimeEvent \u2014 a recorded downtime event (asset/work-center/order)
+
+## Enums
+- ManWorkCenterType: ASSEMBLY, CELL, LINE, MACHINE, MANUAL
+- ManProductionOrderStatus: PLANNED, RELEASED, IN_PROGRESS, PAUSED, COMPLETED, CLOSED, CANCELLED
+- ManProductionPriority: LOW, NORMAL, HIGH, URGENT
+- ManOperationStatus: PENDING, SETUP, RUNNING, DONE, SKIPPED
+- ManMaterialLotStatus: AVAILABLE, ALLOCATED, CONSUMED, QUARANTINED, SCRAPPED
+- ManInspectionStage: INCOMING, IN_PROCESS, FINAL, AUDIT
+- ManInspectionResult: PENDING, PASS, FAIL, CONDITIONAL
+- ManSeverity: MINOR, MAJOR, CRITICAL
+- ManNonConformanceStatus: OPEN, INVESTIGATING, CONTAINED, CORRECTIVE_ACTION, CLOSED
+- ManNonConformanceDisposition: OPEN, USE_AS_IS, REWORK, SCRAP, RETURN_TO_SUPPLIER
+- ManAssetStatus: OPERATIONAL, DEGRADED, DOWN, MAINTENANCE, RETIRED
+- ManMaintenanceType: PREVENTIVE, CORRECTIVE, PREDICTIVE, INSPECTION
+- ManMaintenanceStatus: SCHEDULED, IN_PROGRESS, ON_HOLD, COMPLETED, CANCELLED
+- ManDowntimeReason: PLANNED, BREAKDOWN, CHANGEOVER, MATERIAL_SHORTAGE, QUALITY, OTHER
+
+## Tool groups
+production (work_centers, production_orders, operations, material_lots),
+quality (inspections, inspection_plans, non_conformances),
+maintenance (assets, maintenance work orders, downtime), plus the public health probe.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "manufacturedops-production-orders",
+    ordersUri,
+    {
+      title: "Manufacturedops Production Orders",
+      description: "The first 50 production orders in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${ordersUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PRODUCTION_ORDERS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: ordersUri,
+              text: JSON.stringify(data.manListProductionOrders, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: ordersUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "manufacturedops-work-centers",
+    workCentersUri,
+    {
+      title: "Manufacturedops Work Centers",
+      description: "Active work centers in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${workCentersUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_WORK_CENTERS,
+          { isActive: true }
+        );
+        return {
+          contents: [
+            {
+              uri: workCentersUri,
+              text: JSON.stringify(data.manListWorkCenters, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: workCentersUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "manufacturedops-non-conformances",
+    ncrUri,
+    {
+      title: "Manufacturedops Non-Conformances",
+      description: "The first 50 non-conformances (NCR/CAPA) in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${ncrUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_NON_CONFORMANCES,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: ncrUri,
+              text: JSON.stringify(data.manListNonConformances, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: ncrUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerManufacturedopsPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const orderName = track(mcpPromptName(p, "production-order-runbook"));
+  const qualityName = track(mcpPromptName(p, "quality-maintenance-ops"));
+  server.registerPrompt(
+    orderName,
+    {
+      title: "Production Order Runbook",
+      description: "Guide for planning and running a production order end to end: create the order, add routing operations, allocate material lots, release and progress through the shop floor, and inspect output.",
+      argsSchema: {
+        productSku: zod.z.string().optional().describe("Product SKU to manufacture"),
+        orderNumber: zod.z.string().optional().describe("Order number to assign")
+      }
+    },
+    ({ productSku, orderNumber }) => {
+      ctx.logger.debug(`Prompt ${orderName} called`, { productSku, orderNumber });
+      const skuNote = productSku ? `Manufacture product SKU "${productSku}".` : "Ask the user for the product SKU.";
+      const orderNote = orderNumber ? `Use order number "${orderNumber}".` : "Assign a unique order number.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me plan and run a Manufacturedops production order.
+
+1. **Work Centers**: Use ${p}_work_centers_list to confirm the available work centers (create any missing ones with ${p}_work_centers_create).
+2. **Create Order**: Use ${p}_production_orders_create. ${skuNote} ${orderNote} Set quantity, uom, priority, and planned start/end.
+3. **Add Routing**: Use ${p}_operations_add for each step (name + sequence + workCenterId).
+4. **Allocate Materials**: Use ${p}_material_lots_create for incoming lots, then ${p}_material_lots_set_status=ALLOCATED for the order.
+5. **Release & Run**: Use ${p}_production_orders_transition (PLANNED \u2192 RELEASED \u2192 IN_PROGRESS). Log progress with ${p}_operations_record (setup/run minutes, good/scrap counts, status).
+6. **Inspect**: Use ${p}_inspections_record at the relevant stage; if it FAILs, raise an NCR with ${p}_non_conformances_raise.
+7. **Close**: Use ${p}_production_orders_transition (COMPLETED \u2192 CLOSED) when quantityDone meets target.
+
+Show results at each step and confirm before releasing and before closing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    qualityName,
+    {
+      title: "Quality & Maintenance Operations",
+      description: "Daily operations workflow: triage the NCR/CAPA queue, drive corrective actions, review asset health, schedule maintenance, and log downtime for OEE.",
+      argsSchema: {
+        assetId: zod.z.string().optional().describe("Asset ID to focus maintenance on")
+      }
+    },
+    ({ assetId }) => {
+      ctx.logger.debug(`Prompt ${qualityName} called`, { assetId });
+      const assetNote = assetId ? `Focus maintenance on asset "${assetId}".` : `First list assets with ${p}_assets_list and pick the ones needing attention.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily Manufacturedops quality & maintenance operations. ${assetNote}
+
+1. **NCR Queue**: Use ${p}_non_conformances_list filtered by status=OPEN (and severity=CRITICAL/MAJOR) to find open issues.
+2. **Drive CAPA**: For each, use ${p}_non_conformances_update to record rootCause + correctiveAction, then ${p}_non_conformances_transition (INVESTIGATING \u2192 CONTAINED \u2192 CORRECTIVE_ACTION \u2192 CLOSED).
+3. **Asset Health**: Use ${p}_assets_list filtered by status=DEGRADED/DOWN; inspect each with ${p}_assets_get to review running hours vs PM interval.
+4. **Schedule Maintenance**: Use ${p}_maintenance_create for due PM/corrective jobs, then ${p}_maintenance_transition (SCHEDULED \u2192 IN_PROGRESS \u2192 COMPLETED).
+5. **Downtime / OEE**: Use ${p}_downtime_record for any stoppages and ${p}_downtime_list to review losses by reason.
+6. **Inspections**: Use ${p}_inspections_list filtered by result=FAIL to catch recurring quality escapes.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/manufacturedops/index.ts
+var manufacturedopsModule = {
+  id: "manufacturedops",
+  version: "0.0.1",
+  displayName: "Manufacturedops",
+  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;
+    };
+    registerProductionTools(server, ctx, trackTool);
+    registerQualityTools(server, ctx, trackTool);
+    registerMaintenanceTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerManufacturedopsResources(server, ctx, trackResource);
+    registerManufacturedopsPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var manufacturedops_default = manufacturedopsModule;
+
+module.exports = manufacturedops_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map